bugwar/models.py at master · fastsoft/bugwar · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

from django.db.models import *
from django.contrib.auth.models import User
from urlparse import urlparse

LABEL_CHOICES = tuple(
    (label, label) for label in (
        'pass',
        'fail',
        'log',
        'warn',
    )
)

class Result(Model):
    salvo = ForeignKey('Salvo', related_name = 'results')
    datetime = DateTimeField()
    creation_counter = IntegerField(null = True)
    label = CharField(choices = LABEL_CHOICES, max_length = 16)
    name = CharField(max_length = 1024)
    message = CharField(null = True, max_length = 1024)
    def __unicode__(self):
        return u'%s %s %s %s' % (self.datetime, self.name, self.label, self.message)

class Measure(Model):
    salvo = ForeignKey('Salvo', related_name = 'measures')
    datetime = DateTimeField()
    creation_counter = IntegerField(null = True)
    name = CharField(max_length = 1024)
    value = FloatField()
    def __unicode__(self):
        return u'%s %s %s' % (self.datetime, self.name, self.value)

    class Meta:
        verbose_name = 'measurement'

class Log(Model):

    class Meta:
        verbose_name = 'event'
        verbose_name_plural = 'log'

    salvo = ForeignKey('Salvo', related_name = 'logs')
    result = ForeignKey('Result', related_name = 'logs', null = True)
    measure = ForeignKey('Measure', related_name = 'logs', null = True)
    datetime = DateTimeField()
    creation_counter = IntegerField(null = True)
    message = CharField(max_length = 1024)
    label = CharField(choices = LABEL_CHOICES, max_length = 16)
    def __unicode__(self):
        return u'%s %s %s' % (self.datetime, self.message, self.label)

class Attachment(Model):
    salvo = ForeignKey('Salvo', related_name = 'attachments')
    result = ForeignKey('Result', related_name = 'attachments', null = True)
    measure = ForeignKey('Measure', related_name = 'attachments', null = True)
    datetime = DateTimeField()
    creation_counter = IntegerField(null = True)
    name = CharField(max_length = 512)
    file = FileField(upload_to = 'bugwar/uploads')
    content_type = CharField(max_length = 128)

class Salvo(Model):
    battery = ForeignKey('Battery', null = True, related_name = 'salvos')
    owner = ForeignKey(User, null = True)
    start = DateTimeField(null = True, blank = True)
    stop = DateTimeField(null = True, blank = True)
    url = CharField(max_length = 1024, null = True, blank = True)
    revision = IntegerField(default = 0, null = True)
    configuration_json = CharField(max_length = 4096, null = True)

    def __unicode__(self):
        return u'%s' % self.id

    @property
    def configuration(self):
        import djata.formatter.json as json
        if self.configuration_json is None: return {}
        return json.loads(self.configuration_json)

    @property
    def passes(self):
        return self.results.filter(label = 'pass')

    @property
    def fails(self):
        return self.results.filter(label = 'fail')

    @property
    def errors(self):
        return self.results.filter(label = 'error')

    @property
    def warnings(self):
        return self.results.filter(label = 'warn')

    @property
    def url_display(self):
        display = urlparse(self.url and self.url or '')[2]
        if len(display) > 27:
            return '...%s' % display[-27:]
        return display

    @property
    def duration(self):
        return self.stop - self.start

    def delete(self):
        for log in self.logs.all():
            log.delete()
        for measure in self.measures.all():
            measure.delete()
        for result in self.results.all():
            result.delete()
        super(Salvo, self).delete()

class Battery(Model):
    name = CharField(max_length = 255, unique = True)
    #name = CharField(max_length = 255, primary = True)
    #created = DateTimeField(auto_now_add = True)

    def __unicode__(self):
        return self.name

    @property
    def latest_salvo(self):
        return self.salvos.latest('start')

    def delete(self):
        for salvo in self.salvos.all():
            salvo.delete()
        super(Battery, self).delete()

    class Meta:
        verbose_name_plural = 'batteries'