summaryrefslogtreecommitdiff
path: root/archaeological_finds/models.py
blob: 84a041a41c9b9cd40fc435396c76466de99e3cc6 (plain)
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (C) 2012-2013 Étienne Loks  <etienne.loks_AT_peacefrogsDOTnet>

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.

# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

# See the file COPYING for details.

from django.conf import settings
from django.contrib.gis.db import models
from django.db.models import Max
from django.utils.translation import ugettext_lazy as _, ugettext

from ishtar_common.models import GeneralType, ImageModel, BaseHistorizedItem, \
              LightHistorizedItem, HistoricalRecords, OwnPerms, Source, Person

from archaeological_operations.models import AdministrativeAct
from archaeological_context_records.models import ContextRecord, Dating
WAREHOUSE_AVAILABLE = 'archaeological_warehouse' in settings.INSTALLED_APPS
if WAREHOUSE_AVAILABLE:
    from archaeological_warehouse.models import Warehouse, Container

class MaterialType(GeneralType):
    code = models.CharField(_(u"Code"), max_length=10, blank=True, null=True)
    recommendation = models.TextField(_(u"Recommendation"))
    parent = models.ForeignKey("MaterialType", blank=True, null=True,
                               verbose_name=_(u"Parent material"))

    class Meta:
        verbose_name = _(u"Material type")
        verbose_name_plural = _(u"Material types")

class BaseFind(BaseHistorizedItem, OwnPerms):
    label = models.CharField(_(u"ID"), max_length=60)
    description = models.TextField(_(u"Description"))
    context_record = models.ForeignKey(ContextRecord,
              related_name='base_finds', verbose_name=_(u"Context Record"))
    is_isolated = models.NullBooleanField(_(u"Is isolated?"), blank=True,
                                          null=True)
    index = models.IntegerField(u"Index", default=0)
    material_index = models.IntegerField(u"Material index", default=0)
    history = HistoricalRecords()

    class Meta:
        verbose_name = _(u"Base find")
        verbose_name_plural = _(u"Base finds")
        permissions = (
            ("view_basefind", ugettext(u"Can view all Base find")),
            ("view_own_basefind", ugettext(u"Can view own Base find")),
            ("add_own_basefind", ugettext(u"Can add own Base find")),
            ("change_own_basefind", ugettext(u"Can change own Base find")),
            ("delete_own_basefind", ugettext(u"Can delete own Base find")),
        )

    def __unicode__(self):
        return self.label

    def get_last_find(self):
        #TODO: manage virtuals - property(last_find) ?
        finds = self.find.filter().order_by("-order").all()
        return finds and finds[0]

    def complete_id(self):
        # OPE|MAT.CODE|UE|FIND_index
        if not self.context_record.operation:
            return
        find = self.get_last_find()
        ope = self.context_record.operation
        c_id = [unicode(ope.code_patriarche) or \
                (unicode(ope.year) + "-" + unicode(ope.operation_code))]
        c_id.append(find and find.material_type.code or '')
        c_id.append(self.context_record.label)
        c_id.append(unicode(self.index))
        return settings.JOINT.join(c_id)

    def short_id(self):
        # OPE|FIND_index
        if not self.context_record.operation:
            return
        find = self.get_last_find()
        ope = self.context_record.operation
        c_id = [unicode(ope.code_patriarche) or \
                (unicode(ope.year) + "-" + unicode(ope.operation_code))]
        c_id.append(unicode(self.index))
        return settings.JOINT.join(c_id)

    def full_label(self):
        return self._real_label() or self._temp_label() or u""

    def material_type_label(self):
        find = self.get_last_find()
        finds = [find and find.material_type.code or '']
        ope = self.context_record.operation
        finds += [unicode(ope.code_patriarche) or \
                  (unicode(ope.year) + "-" + unicode(ope.operation_code))]
        finds += [self.context_record.label, unicode(self.material_index)]
        return settings.JOINT.join(finds)

    def _real_label(self):
        if not self.context_record.parcel \
           or not self.context_record.operation \
           or not self.context_record.operation.code_patriarche:
            return
        find = self.get_last_find()
        lbl = find.label or self.label
        return settings.JOINT.join([unicode(it) for it in (
                           self.context_record.operation.code_patriarche,
                           self.context_record.label,
                           lbl) if it])

    def _temp_label(self):
        if not self.context_record.parcel:
            return
        find = self.get_last_find()
        lbl = find.label or self.label
        return settings.JOINT.join([unicode(it) for it in (
                           self.context_record.parcel.year,
                           self.index,
                           self.context_record.label,
                           lbl) if it])

class Find(BaseHistorizedItem, ImageModel, OwnPerms):
    TABLE_COLS = ['label', 'material_type', 'dating.period',
                  'base_finds.context_record.parcel.town',
                  'base_finds.context_record.operation.year',
                  'base_finds.context_record.operation.operation_code',
                  'container.reference', 'container.location',
                  'base_finds.is_isolated']
    if settings.COUNTRY == 'fr':
        TABLE_COLS.insert(6,
                  'base_finds.context_record.operation.code_patriarche')
    base_finds = models.ManyToManyField(BaseFind, verbose_name=_(u"Base find"),
                                        related_name='find')
    order = models.IntegerField(_(u"Order"))
    label = models.CharField(_(u"ID"), max_length=60)
    description = models.TextField(_(u"Description"), blank=True, null=True)
    material_type = models.ForeignKey(MaterialType,
                              verbose_name = _(u"Material type"))
    volume = models.FloatField(_(u"Volume (l)"), blank=True, null=True)
    weight = models.FloatField(_(u"Weight (g)"), blank=True, null=True)
    find_number = models.IntegerField(_("Find number"), blank=True, null=True)
    upstream_treatment = models.ForeignKey("Treatment", blank=True, null=True,
      related_name='downstream_treatment', verbose_name=_("Upstream treatment"))
    downstream_treatment = models.ForeignKey("Treatment", blank=True, null=True,
      related_name='upstream_treatment', verbose_name=_("Downstream treatment"))
    dating = models.ForeignKey(Dating, verbose_name=_(u"Dating"))
    if WAREHOUSE_AVAILABLE:
        container = models.ForeignKey(Container, verbose_name=_(u"Container"),
                                  blank=True, null=True, related_name='finds')
    history = HistoricalRecords()

    def __init__(self, *args, **kwargs):
        super(Find, self).__init__(*args, **kwargs)
        image = self._meta.get_field_by_name("image")[0]
        image.upload_to = "finds/"
        thumbnail = self._meta.get_field_by_name("thumbnail")[0]
        thumbnail.upload_to = "finds/thumbs/"

    class Meta:
        verbose_name = _(u"Find")
        verbose_name_plural = _(u"Finds")
        permissions = (
            ("view_find", ugettext(u"Can view all Find")),
            ("view_own_find", ugettext(u"Can view own Find")),
            ("add_own_find", ugettext(u"Can add own Find")),
            ("change_own_find", ugettext(u"Can change own Find")),
            ("delete_own_find", ugettext(u"Can delete own Find")),
        )

    @property
    def short_class_name(self):
        return _(u"FIND")

    def __unicode__(self):
        return self.label

    def get_first_base_find(self):
        q= self.base_finds
        if not q.count():
            return
        return q.all()[0]

    @property
    def reference(self):
        bf = self.get_first_base_find()
        if not bf:
            return "00"
        return bf.short_id()

    def get_department(self):
        bf = self.get_first_base_find()
        if not bf:
            return "00"
        return bf.context_record.operation.get_department()

    def get_town_label(self):
        bf = self.get_first_base_find()
        if not bf:
            return "00"
        return bf.context_record.operation.get_town_label()

    @classmethod
    def get_years(cls):
        years = set()
        finds = cls.objects.filter(downstream_treatment__isnull=True)
        for find in finds:
            bi = find.base_finds.all()
            if not bi:
                continue
            bi = bi[0]
            if bi.context_record.operation.start_date:
                yr = bi.context_record.operation.start_date.year
                years.add(yr)
        return list(years)

    @classmethod
    def get_by_year(cls, year):
        return cls.objects.filter(downstream_treatment__isnull=True,
                base_finds__context_record__operation__start_date__year=year)

    @classmethod
    def get_operations(cls):
        operations = set()
        finds = cls.objects.filter(downstream_treatment__isnull=True)
        for find in finds:
            bi = find.base_finds.all()
            if not bi:
                continue
            bi = bi[0]
            pk = bi.context_record.operation.pk
            operations.add(pk)
        return list(operations)

    @classmethod
    def get_by_operation(cls, operation_id):
        return cls.objects.filter(downstream_treatment__isnull=True,
                base_finds__context_record__operation__pk=operation_id)

    @classmethod
    def get_total_number(cls):
        return cls.objects.filter(downstream_treatment__isnull=True).count()

    def duplicate(self, user):
        dct = dict([(attr, getattr(self, attr)) for attr in ('order', 'label',
                        'description', 'material_type', 'volume', 'weight',
                        'find_number', 'dating')])
        dct['order'] += 1
        dct['history_modifier'] = user
        new = self.__class__(**dct)
        new.save()
        for base_find in self.base_finds.all():
            new.base_finds.add(base_find)
        return new

    def save(self, *args, **kwargs):
        if not self.pk:
            super(Find, self).save(*args, **kwargs)
        for base_find in self.base_finds.all():
            if not base_find.index:
                idx = BaseFind.objects.filter(context_record=\
                      base_find.context_record).aggregate(Max('index'))
                base_find.index = idx and idx['index__max'] + 1 or 1
            if not base_find.material_index:
                idx = BaseFind.objects.filter(context_record=\
                        base_find.context_record,
                        find__material_type=self.material_type).aggregate(
                                                      Max('material_index'))
                base_find.material_index = idx and \
                                        idx['material_index__max'] + 1 or 1
            base_find.save()
        super(Find, self).save(*args, **kwargs)

class FindSource(Source):
    class Meta:
        verbose_name = _(u"Find documentation")
        verbose_name_plural = _(u"Find documentations")
    find = models.ForeignKey(Find, verbose_name=_(u"Find"),
                             related_name="source")

class TreatmentType(GeneralType):
    virtual = models.BooleanField(_(u"Virtual"))
    class Meta:
        verbose_name = _(u"Treatment type")
        verbose_name_plural = _(u"Treatment types")

class Treatment(BaseHistorizedItem, OwnPerms):
    container = models.ForeignKey(Container, verbose_name=_(u"Container"),
                                  blank=True, null=True)
    description = models.TextField(_(u"Description"), blank=True, null=True)
    treatment_type = models.ForeignKey(TreatmentType,
                                       verbose_name=_(u"Treatment type"))
    if WAREHOUSE_AVAILABLE:
        location = models.ForeignKey(Warehouse, verbose_name=_(u"Location"),
                                     blank=True, null=True)
    person = models.ForeignKey(Person, verbose_name=_(u"Person"),
                               blank=True, null=True)
    start_date = models.DateField(_(u"Start date"), blank=True, null=True)
    end_date = models.DateField(_(u"End date"), blank=True, null=True)
    history = HistoricalRecords()

    class Meta:
        verbose_name = _(u"Treatment")
        verbose_name_plural = _(u"Treatments")
        permissions = (
            ("view_treatment", ugettext(u"Can view all Treatment")),
            ("view_own_treatment", ugettext(u"Can view own Treatment")),
            ("add_own_treatment", ugettext(u"Can add own Treatment")),
            ("change_own_treatment", ugettext(u"Can change own Treatment")),
            ("delete_own_treatment", ugettext(u"Can delete own Treatment")),
        )

    def __unicode__(self):
        lbl = unicode(self.treatment_type)
        if self.person:
            lbl += u" %s %s" % (_(u"by"), unicode(self.person))
        return lbl

class TreatmentSource(Source):
    class Meta:
        verbose_name = _(u"Treatment documentation")
        verbose_name_plural = _(u"Treament documentations")
    treatment = models.ForeignKey(Treatment, verbose_name=_(u"Treatment"),
                             related_name="source")

class Property(LightHistorizedItem):
    find = models.ForeignKey(Find, verbose_name=_(u"Find"))
    administrative_act = models.ForeignKey(AdministrativeAct,
                                         verbose_name=_(u"Administrative act"))
    person = models.ForeignKey(Person, verbose_name=_(u"Person"))
    start_date = models.DateField(_(u"Start date"))
    end_date = models.DateField(_(u"End date"))

    class Meta:
        verbose_name = _(u"Property")
        verbose_name_plural = _(u"Properties")

    def __unicode__(self):
        return self.person + settings.JOINT + self.find