diff options
Diffstat (limited to 'ishtar_common/models.py')
| -rw-r--r-- | ishtar_common/models.py | 2187 |
1 files changed, 2187 insertions, 0 deletions
diff --git a/ishtar_common/models.py b/ishtar_common/models.py new file mode 100644 index 000000000..747643718 --- /dev/null +++ b/ishtar_common/models.py @@ -0,0 +1,2187 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# Copyright (C) 2010-2011 É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. + +""" +Models description +""" +import datetime + +from django.conf import settings +from django.core.exceptions import ObjectDoesNotExist, ValidationError +from django.core.validators import validate_slug +from django.utils.translation import ugettext_lazy as _, ugettext +from django.utils.safestring import SafeUnicode, mark_safe +from django.core.urlresolvers import reverse, NoReverseMatch +from django.db.utils import DatabaseError +from django.db.models import Q, Max, Count, Sum, Avg +from django.db.models.signals import m2m_changed, post_save + +from django.contrib.auth.models import User +from django.contrib.gis.db import models +from django.contrib import admin + +from simple_history.models import HistoricalRecords as BaseHistoricalRecords + +JOINT = u" - " + +def post_save_user(sender, **kwargs): + if not kwargs['created']: + return + user = kwargs['instance'] + if not IshtarUser.objects.filter(username=user.username).count(): + IshtarUser.create_from_user(user) +post_save.connect(post_save_user, sender=User) + +# HistoricalRecords enhancement: don't save identical versions +class HistoricalRecords(BaseHistoricalRecords): + def create_historical_record(self, instance, type): + manager = getattr(instance, self.manager_name) + attrs = {} + for field in instance._meta.fields: + attrs[field.attname] = getattr(instance, field.attname) + history = instance.history.all() + if not history: + manager.create(history_type=type, **attrs) + return + old_instance = history[0] + for field in instance._meta.fields: + if getattr(old_instance, field.attname) != attrs[field.attname]: + manager.create(history_type=type, **attrs) + return + +# valid ID validator for models +def valid_id(cls): + def func(value): + try: + cls.objects.get(pk=value) + except ObjectDoesNotExist: + raise ValidationError(_(u"Not a valid item.")) + return func + +def valid_ids(cls): + def func(value): + if "," in value: + value = value.split(",") + for v in value: + try: + cls.objects.get(pk=v) + except ObjectDoesNotExist: + raise ValidationError( + _(u"An item selected is not a valid item.")) + return func + +# unique validator for models +def is_unique(cls, field): + def func(value): + query = {field:value} + try: + assert cls.objects.filter(**query).count() == 0 + except AssertionError: + raise ValidationError(_(u"This item already exist.")) + return func + +class OwnPerms: + """ + Manage special permissions for object's owner + """ + @classmethod + def get_query_owns(cls, user): + """ + Query object to get own items + """ + return None # implement for each object + + def is_own(self, user): + """ + Check if the current object is owned by the user + """ + query = self.get_query_owns(user) + if not query: + return False + query = query & Q(pk=self.pk) + return cls.objects.filter(query).count() + + @classmethod + def has_item_of(cls, user): + """ + Check if the user own some items + """ + query = cls.get_query_owns(user) + if not query: + return False + return cls.objects.filter(query).count() + + @classmethod + def get_owns(cls, user): + """ + Get Own items + """ + if isinstance(user, User): + user = IshtarUser.objects.get(user_ptr=user) + if user.is_anonymous(): + return [] + query = cls.get_query_owns(user) + if not query: + return [] + return cls.objects.filter(query).order_by(*cls._meta.ordering).all() + +class GeneralType(models.Model): + """ + Abstract class for "types" + """ + label = models.CharField(_(u"Label"), max_length=100) + txt_idx = models.CharField(_(u"Textual ID"), + validators=[validate_slug], max_length=30, unique=True) + comment = models.TextField(_(u"Comment"), blank=True, null=True) + available = models.BooleanField(_(u"Available")) + HELP_TEXT = u"" + + class Meta: + abstract = True + + def __unicode__(self): + return self.label + + @classmethod + def get_help(cls, dct={}, exclude=[]): + help_text = cls.HELP_TEXT + c_rank = -1 + help_items = u"\n" + for item in cls.get_types(dct=dct, instances=True, exclude=exclude): + if hasattr(item, '__iter__'): + # TODO: manage multiple levels + continue + if not item.comment: + continue + if c_rank > item.rank: + help_items += u"</dl>\n" + elif c_rank < item.rank: + help_items += u"<dl>\n" + c_rank = item.rank + help_items += u"<dt>%s</dt><dd>%s</dd>" % (item.label, + u"<br/>".join(item.comment.split('\n'))) + c_rank += 1 + if c_rank: + help_items += c_rank*u"</dl>" + if help_text or help_items != u'\n': + return mark_safe(help_text + help_items) + return u"" + + @classmethod + def get_types(cls, dct={}, instances=False, exclude=[]): + base_dct = dct.copy() + if hasattr(cls, 'parent'): + return cls._get_parent_types(base_dct, instances, exclude=exclude) + return cls._get_types(base_dct, instances, exclude=exclude) + + @classmethod + def _get_types(cls, dct={}, instances=False, exclude=[]): + dct['available'] = True + if not instances: + yield ('', '--') + items = cls.objects.filter(**dct) + if exclude: + items = items.exclude(txt_idx__in=exclude) + for item in items.all(): + if instances: + item.rank = 0 + yield item + else: + yield (item.pk, _(unicode(item))) + + PREFIX = "› " + + @classmethod + def _get_childs(cls, item, dct, prefix=0, instances=False, exclude=[]): + prefix += 1 + dct['parent'] = item + childs = cls.objects.filter(**dct) + if exclude: + childs = childs.exclude(txt_idx__in=exclude) + if hasattr(cls, 'order'): + childs = childs.order_by('order') + for child in childs.all(): + if instances: + child.rank = prefix + yield child + else: + yield (child.pk, SafeUnicode(prefix*cls.PREFIX + \ + unicode(_(unicode(child))) )) + for sub_child in cls._get_childs(child, dct, prefix, instances, + exclude=exclude): + yield sub_child + + @classmethod + def _get_parent_types(cls, dct={}, instances=False, exclude=[]): + dct['available'] = True + if not instances: + yield ('', '--') + dct['parent'] = None + items = cls.objects.filter(**dct) + if exclude: + items = items.exclude(txt_idx__in=exclude) + if hasattr(cls, 'order'): + items = items.order_by('order') + for item in items.all(): + if instances: + item.rank = 0 + yield item + else: + yield (item.pk, unicode(item)) + for child in cls._get_childs(item, dct, instances, exclude=exclude): + yield child + +class HistoryError(Exception): + def __init__(self, value): + self.value = value + def __str__(self): + return repr(self.value) + +class BaseHistorizedItem(models.Model): + history_modifier = models.ForeignKey(User, related_name='+', + verbose_name=_(u"Last editor")) + class Meta: + abstract = True + + def save(self, *args, **kwargs): + assert hasattr(self, 'history_modifier') == True + super(BaseHistorizedItem, self).save(*args, **kwargs) + return True + + def get_previous(self, step=None, date=None, strict=True): + """ + Get a "step" previous state of the item + """ + assert step or date + historized = self.history.all() + item = None + if step: + assert len(historized) > step + item = historized[step] + else: + for step, item in enumerate(historized): + if item.history_date == date: + break + # ended with no match + if item.history_date != date: + return + item._step = step + if len(historized) != (step + 1): + item._previous = historized[step + 1].history_date + else: + item._previous = None + if step > 0: + item._next = historized[step - 1].history_date + else: + item._next = None + item.history_date = historized[step].history_date + model = self.__class__ + for k in model._meta.get_all_field_names(): + field = model._meta.get_field_by_name(k)[0] + if hasattr(field, 'rel') and field.rel: + if not hasattr(item, k+'_id'): + setattr(item, k, getattr(self, k)) + continue + val = getattr(item, k+'_id') + if not val: + setattr(item, k, None) + continue + try: + val = field.rel.to.objects.get(pk=val) + setattr(item, k, val) + except ObjectDoesNotExist: + if strict: + raise HistoryError(u"The class %s has no pk %d" % ( + unicode(field.rel.to), val)) + setattr(item, k, None) + item.pk = self.pk + return item + + def rollback(self, date): + """ + Rollback to a previous state + """ + to_del, new_item = [], None + for item in self.history.all(): + to_del.append(item) + if item.history_date == date: + new_item = item + break + if not new_item: + raise HistoryError(u"The date to rollback to doesn't exist.") + try: + for f in self._meta.fields: + k = f.name + if k != 'id' and hasattr(self, k): + if not hasattr(new_item, k): + k = k + "_id" + setattr(self, k, getattr(new_item, k)) + self.save() + except: + raise HistoryError(u"The rollback has failed.") + # clean the obsolete history + for historized_item in to_del: + historized_item.delete() + + def values(self): + values = {} + for f in self._meta.fields: + k = f.name + if k != 'id': + values[k] = getattr(self, k) + return values + + def get_show_url(self): + try: + return reverse('show-'+self.__class__.__name__.lower(), + args=[self.pk, '']) + except NoReverseMatch: + return + +class LightHistorizedItem(BaseHistorizedItem): + history_date = models.DateTimeField(default=datetime.datetime.now) + class Meta: + abstract = True + + def save(self, *args, **kwargs): + super(LightHistorizedItem, self).save(*args, **kwargs) + return True + +class Wizard(models.Model): + url_name = models.CharField(_(u"URL name"), max_length=128, unique=True) + class Meta: + verbose_name = _(u"Wizard") + ordering = ['url_name'] + + def __unicode__(self): + return unicode(self.url_name) + +class WizardStep(models.Model): + order = models.IntegerField(_(u"Order")) + wizard = models.ForeignKey(Wizard, verbose_name=_(u"Wizard")) + url_name = models.CharField(_(u"URL name"), max_length=128) + name = models.CharField(_(u"Label"), max_length=128) + class Meta: + verbose_name = _(u"Wizard step") + ordering = ['wizard', 'order'] + + def __unicode__(self): + return u"%s » %s" % (unicode(self.wizard), unicode(self.name)) + +class UserDashboard: + def __init__(self): + types = IshtarUser.objects.values('person__person_type', + 'person__person_type__label') + self.types = types.annotate(number=Count('pk'))\ + .order_by('person__person_type') + +class FileDashboard: + def __init__(self): + main_dashboard = Dashboard(File) + + self.total_number = main_dashboard.total_number + + types = File.objects.values('file_type', 'file_type__label') + self.types = types.annotate(number=Count('pk')).order_by('file_type') + + by_year = File.objects.extra( + {'date':"date_trunc('year', creation_date)"}) + self.by_year = by_year.values('date')\ + .annotate(number=Count('pk')).order_by('-date') + + now = datetime.date.today() + limit = datetime.date(now.year, now.month, 1) - datetime.timedelta(365) + by_month = File.objects.filter(creation_date__gt=limit).extra( + {'date':"date_trunc('month', creation_date)"}) + self.by_month = by_month.values('date')\ + .annotate(number=Count('pk')).order_by('-date') + + # research + self.research = {} + prog_type = FileType.objects.get(txt_idx='prog') + researchs = File.objects.filter(file_type=prog_type) + self.research['total_number'] = researchs.count() + by_year = researchs.extra({'date':"date_trunc('year', creation_date)"}) + self.research['by_year'] = by_year.values('date')\ + .annotate(number=Count('pk'))\ + .order_by('-date') + by_month = researchs.filter(creation_date__gt=limit)\ + .extra({'date':"date_trunc('month', creation_date)"}) + self.research['by_month'] = by_month.values('date')\ + .annotate(number=Count('pk'))\ + .order_by('-date') + + self.research['by_dpt'] = FileByDepartment.objects\ + .filter(file__file_type=prog_type, + department__isnull=False)\ + .values('department__label')\ + .annotate(number=Count('file'))\ + .order_by('department__label') + FileTown = File.towns.through + self.research['towns'] = FileTown.objects\ + .filter(file__file_type=prog_type)\ + .values('town__name')\ + .annotate(number=Count('file'))\ + .order_by('-number','town__name')[:10] + + # rescue + rescue_type = FileType.objects.get(txt_idx='preventive') + rescues = File.objects.filter(file_type=rescue_type) + self.rescue = {} + self.rescue['total_number'] = rescues.count() + self.rescue['saisine'] = rescues.values('saisine_type__label')\ + .annotate(number=Count('pk'))\ + .order_by('saisine_type__label') + self.rescue['administrative_act'] = AdministrativeAct.objects\ + .filter(associated_file__isnull=False)\ + .values('act_type__label')\ + .annotate(number=Count('pk'))\ + .order_by('act_type__pk') + + by_year = rescues.extra({'date':"date_trunc('year', creation_date)"}) + self.rescue['by_year'] = by_year.values('date')\ + .annotate(number=Count('pk'))\ + .order_by('-date') + by_month = rescues.filter(creation_date__gt=limit)\ + .extra({'date':"date_trunc('month', creation_date)"}) + self.rescue['by_month'] = by_month.values('date')\ + .annotate(number=Count('pk'))\ + .order_by('-date') + + self.rescue['by_dpt'] = FileByDepartment.objects\ + .filter(file__file_type=rescue_type, + department__isnull=False)\ + .values('department__label')\ + .annotate(number=Count('file'))\ + .order_by('department__label') + self.rescue['towns'] = FileTown.objects\ + .filter(file__file_type=rescue_type)\ + .values('town__name')\ + .annotate(number=Count('file'))\ + .order_by('-number','town__name')[:10] + + self.rescue['with_associated_operation'] = rescues\ + .filter(operations__isnull=False).count() + + self.rescue['with_associated_operation_percent'] = round( + float(self.rescue['with_associated_operation'])\ + /self.rescue['total_number']*100, 2) + + by_year_operationnal = rescues.filter(operations__isnull=False)\ + .extra({'date':"date_trunc('year', creation_date)"}) + by_year_operationnal = by_year_operationnal.values('date')\ + .annotate(number=Count('pk'))\ + .order_by('-date') + percents, idx = [], 0 + for dct in self.rescue['by_year']: + if idx > len(by_year_operationnal): + break + if by_year_operationnal[idx]['date'] != dct['date'] or\ + not dct['number']: + continue + val = round(float(by_year_operationnal[idx]['number'])/\ + dct['number']*100, 2) + percents.append({'date':dct['date'], 'number':val}) + self.rescue['operational_by_year'] = percents + + self.rescue['surface_by_town'] = FileTown.objects\ + .filter(file__file_type=rescue_type)\ + .values('town__name')\ + .annotate(number=Sum('file__total_surface'))\ + .order_by('-number','town__name')[:10] + self.rescue['surface_by_dpt'] = FileByDepartment.objects\ + .filter(file__file_type=rescue_type, + department__isnull=False)\ + .values('department__label')\ + .annotate(number=Sum('file__total_surface'))\ + .order_by('department__label') + +class OperationDashboard: + def __init__(self): + main_dashboard = Dashboard(Operation) + + self.total_number = main_dashboard.total_number + + self.filters_keys = ['recorded', 'effective', 'active', 'field', + 'documented', 'closed', 'documented_closed'] + filters = { + 'recorded':{}, + 'effective':{'in_charge__isnull':False}, + 'active':{'in_charge__isnull':False, 'end_date__isnull':True}, + 'field':{'excavation_end_date__isnull':True}, + 'documented':{'source__isnull':False}, + 'documented_closed':{'source__isnull':False, + 'end_date__isnull':False}, + 'closed':{'end_date__isnull':False} + } + filters_label = { + 'recorded':_(u"Recorded"), + 'effective':_(u"Effective"), + 'active':_(u"Active"), + 'field':_(u"Field completed"), + 'documented':_(u"Associated report"), + 'closed':_(u"Closed"), + 'documented_closed':_(u"Documented and closed"), + } + self.filters_label = [filters_label[k] for k in self.filters_keys] + self.total = [] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + nb = Operation.objects.filter(**fltr).count() + self.total.append((lbl, nb)) + + self.surface_by_type = Operation.objects\ + .values('operation_type__label')\ + .annotate(number=Sum('surface'))\ + .order_by('-number','operation_type__label') + + self.by_type = [] + self.types = OperationType.objects.filter(available=True).all() + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + type_res = Operation.objects.filter(**fltr).\ + values('operation_type', 'operation_type__label').\ + annotate(number=Count('pk')).\ + order_by('operation_type') + types_dct = {} + for typ in type_res.all(): + types_dct[typ['operation_type']] = typ["number"] + types = [] + for typ in self.types: + if typ.pk in types_dct: + types.append(types_dct[typ.pk]) + else: + types.append(0) + self.by_type.append((lbl, types)) + + self.by_year = [] + self.years = [res['year'] for res in Operation.objects.values('year')\ + .order_by('-year').distinct()] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + year_res = Operation.objects.filter(**fltr).\ + values('year').\ + annotate(number=Count('pk')).\ + order_by('year') + years_dct = {} + for yr in year_res.all(): + years_dct[yr['year']] = yr["number"] + years = [] + for yr in self.years: + if yr in years_dct: + years.append(years_dct[yr]) + else: + years.append(0) + self.by_year.append((lbl, years)) + + self.by_realisation_year = [] + self.realisation_years = [res['date'] for res in \ + Operation.objects.extra( + {'date':"date_trunc('year', start_date)"}).values('date')\ + .filter(start_date__isnull=False).order_by('-date').distinct()] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + year_res = Operation.objects.filter(**fltr).extra( + {'date':"date_trunc('year', start_date)"}).values('date').\ + values('date').filter(start_date__isnull=False).\ + annotate(number=Count('pk')).\ + order_by('-date') + years_dct = {} + for yr in year_res.all(): + years_dct[yr['date']] = yr["number"] + years = [] + for yr in self.realisation_years: + if yr in years_dct: + years.append(years_dct[yr]) + else: + years.append(0) + self.by_realisation_year.append((lbl, years)) + + self.effective = [] + for typ in self.types: + year_res = Operation.objects.filter(**{'in_charge__isnull':False, + 'operation_type':typ}).\ + values('year').\ + annotate(number=Count('pk')).\ + order_by('-year').distinct() + years_dct = {} + for yr in year_res.all(): + years_dct[yr['year']] = yr["number"] + years = [] + for yr in self.years: + if yr in years_dct: + years.append(years_dct[yr]) + else: + years.append(0) + self.effective.append((typ, years)) + + # TODO: by date + now = datetime.date.today() + limit = datetime.date(now.year, now.month, 1) - datetime.timedelta(365) + by_realisation_month = Operation.objects.filter(start_date__gt=limit, + start_date__isnull=False).extra( + {'date':"date_trunc('month', start_date)"}) + self.last_months = [] + date = datetime.datetime(now.year, now.month, 1) + for mt_idx in xrange(12): + self.last_months.append(date) + if date.month > 1: + date = datetime.datetime(date.year, date.month - 1, 1) + else: + date = datetime.datetime(date.year - 1, 12, 1) + self.by_realisation_month = [] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + month_res = by_realisation_month.filter(**fltr).\ + annotate(number=Count('pk')).\ + order_by('-date') + month_dct = {} + for mt in month_res.all(): + month_dct[mt.date] = mt.number + date = datetime.date(now.year, now.month, 1) + months = [] + for date in self.last_months: + if date in month_dct: + months.append(month_dct[date]) + else: + months.append(0) + self.by_realisation_month.append((lbl, months)) + + # survey and excavations + self.survey, self.excavation = {}, {} + for dct_res, ope_types in ((self.survey, ('arch_diagnostic',)), + (self.excavation, ('prev_excavation', + 'prog_excavation'))): + dct_res['total'] = [] + operation_type = {'operation_type__txt_idx__in':ope_types} + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + fltr.update(operation_type) + nb = Operation.objects.filter(**fltr).count() + dct_res['total'].append((lbl, nb)) + + dct_res['by_year'] = [] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + fltr.update(operation_type) + year_res = Operation.objects.filter(**fltr).\ + values('year').\ + annotate(number=Count('pk')).\ + order_by('year') + years_dct = {} + for yr in year_res.all(): + years_dct[yr['year']] = yr["number"] + years = [] + for yr in self.years: + if yr in years_dct: + years.append(years_dct[yr]) + else: + years.append(0) + dct_res['by_year'].append((lbl, years)) + + dct_res['by_realisation_year'] = [] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + fltr.update(operation_type) + year_res = Operation.objects.filter(**fltr).extra( + {'date':"date_trunc('year', start_date)"}).values('date').\ + filter(start_date__isnull=False).\ + annotate(number=Count('pk')).\ + order_by('-date') + years_dct = {} + for yr in year_res.all(): + years_dct[yr['date']] = yr["number"] + years = [] + for yr in self.realisation_years: + if yr in years_dct: + years.append(years_dct[yr]) + else: + years.append(0) + dct_res['by_realisation_year'].append((lbl, years)) + + current_year_ope = Operation.objects.filter(**operation_type)\ + .filter(year=datetime.date.today().year) + current_realisation_year_ope = Operation.objects\ + .filter(**operation_type)\ + .filter(start_date__year=datetime.date.today().year) + res_keys = [('area_realised', current_realisation_year_ope)] + if dct_res == self.survey: + res_keys.append(('area', + current_year_ope)) + for res_key, base_ope in res_keys: + dct_res[res_key] = [] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + area_res = base_ope.filter(**fltr)\ + .annotate(number=Sum('surface')).all() + val = 0 + if area_res: + val = area_res[0].number + dct_res[res_key].append(val) + # TODO... + res_keys = [('manday_realised', current_realisation_year_ope)] + if dct_res == self.survey: + res_keys.append(('manday', + current_year_ope)) + for res_key, base_ope in res_keys: + dct_res[res_key] = [] + for fltr_key in self.filters_keys: + dct_res[res_key].append('-') + # TODO... + res_keys = [('mandayhect_realised', current_realisation_year_ope)] + if dct_res == self.survey: + res_keys.append(('mandayhect', + current_year_ope)) + for res_key, base_ope in res_keys: + dct_res[res_key] = [] + for fltr_key in self.filters_keys: + dct_res[res_key].append('-') + # TODO... + dct_res['mandayhect_real_effective'] = '-' + if dct_res == self.survey: + dct_res['mandayhect_effective'] = '-' + + + res_keys = [('org_realised', current_realisation_year_ope)] + if dct_res == self.survey: + res_keys.append(('org', current_year_ope)) + for res_key, base_ope in res_keys: + org_res = base_ope.filter(in_charge__attached_to__isnull=False)\ + .values('in_charge__attached_to', + 'in_charge__attached_to__name')\ + .annotate(area=Sum('surface'))\ + .order_by('in_charge__attached_to__name').all() + # TODO: man-days, man-days/hectare + dct_res[res_key] = org_res + + + year_ope = Operation.objects.filter(**operation_type) + res_keys = ['org_by_year'] + if dct_res == self.survey: + res_keys.append('org_by_year_realised') + q = year_ope.values('in_charge__attached_to', + 'in_charge__attached_to__name').\ + filter(in_charge__attached_to__isnull=False).\ + order_by('in_charge__attached_to__name').distinct() + org_list = [(org['in_charge__attached_to'], + org['in_charge__attached_to__name']) for org in q] + org_list_dct = dict(org_list) + for res_key in res_keys: + dct_res[res_key] = [] + years = self.years + if res_key == 'org_by_year_realised': + years = self.realisation_years + for org_id, org_label in org_list: + org_res = year_ope.filter(in_charge__attached_to__pk=org_id) + key_date = '' + if res_key == 'org_by_year': + org_res = org_res.values('year') + key_date = 'year' + else: + org_res = org_res.extra( + {'date':"date_trunc('year', start_date)"}).values('date').\ + filter(start_date__isnull=False) + key_date = 'date' + org_res = org_res.annotate(area=Sum('surface'), + cost=Sum('cost')) + years_dct = {} + for yr in org_res.all(): + area = yr['area'] if yr['area'] else 0 + cost = yr['cost'] if yr['cost'] else 0 + years_dct[yr[key_date]] = (area, cost) + r_years = [] + for yr in years: + if yr in years_dct: + r_years.append(years_dct[yr]) + else: + r_years.append((0, 0)) + dct_res[res_key].append((org_label, r_years)) + area_means, area_sums = [], [] + cost_means, cost_sums = [], [] + for idx, year in enumerate(years): + vals = [r_years[idx] for lbl, r_years in dct_res[res_key]] + sum_area = sum([a for a, c in vals]) + sum_cost = sum([c for a, c in vals]) + area_means.append(sum_area/len(vals)) + area_sums.append(sum_area) + cost_means.append(sum_cost/len(vals)) + cost_sums.append(sum_cost) + dct_res[res_key+'_area_mean'] = area_means + dct_res[res_key+'_area_sum'] = area_sums + dct_res[res_key+'_cost_mean'] = cost_means + dct_res[res_key+'_cost_mean'] = cost_sums + + if dct_res == self.survey: + self.survey['effective'] = [] + for yr in self.years: + year_res = Operation.objects.filter(in_charge__isnull=False, + year=yr).\ + annotate(number=Sum('surface'), + mean=Avg('surface')) + nb = year_res[0].number if year_res.count() else 0 + nb = nb if nb else 0 + mean = year_res[0].mean if year_res.count() else 0 + mean = mean if mean else 0 + self.survey['effective'].append((nb, mean)) + + # TODO:Man-Days/hectare by Year + + # CHECK: month of realisation or month? + dct_res['by_month'] = [] + for fltr_key in self.filters_keys: + fltr, lbl = filters[fltr_key], filters_label[fltr_key] + fltr.update(operation_type) + month_res = by_realisation_month.filter(**fltr).\ + annotate(number=Count('pk')).\ + order_by('-date') + month_dct = {} + for mt in month_res.all(): + month_dct[mt.date] = mt.number + date = datetime.date(now.year, now.month, 1) + months = [] + for date in self.last_months: + if date in month_dct: + months.append(month_dct[date]) + else: + months.append(0) + dct_res['by_month'].append((lbl, months)) + + operation_type = {'operation_type__txt_idx__in':ope_types} + self.departments = [(fd['department__pk'], fd['department__label']) + for fd in OperationByDepartment.objects\ + .filter(department__isnull=False)\ + .values('department__label', 'department__pk')\ + .order_by('department__label').distinct()] + dct_res['by_dpt'] = [] + for dpt_id, dpt_label in self.departments: + vals = OperationByDepartment.objects\ + .filter(department__pk=dpt_id, + operation__operation_type__txt_idx__in=ope_types)\ + .values('department__pk', 'operation__year')\ + .annotate(number=Count('operation'))\ + .order_by('operation__year') + dct_years = {} + for v in vals: + dct_years[v['operation__year']] = v['number'] + years = [] + for y in self.years: + if y in dct_years: + years.append(dct_years[y]) + else: + years.append(0) + years.append(sum(years)) + dct_res['by_dpt'].append((dpt_label, years)) + dct_res['effective_by_dpt'] = [] + for dpt_id, dpt_label in self.departments: + vals = OperationByDepartment.objects\ + .filter(department__pk=dpt_id, + operation__in_charge__isnull=False, + operation__operation_type__txt_idx__in=ope_types)\ + .values('department__pk', 'operation__year')\ + .annotate(number=Count('operation'), + area=Sum('operation__surface'), + fnap=Sum('operation__fnap_cost'), + cost=Sum('operation__cost'))\ + .order_by('operation__year') + dct_years = {} + for v in vals: + values = [] + for value in (v['number'], v['area'], v['cost'], v['fnap']): + values.append(value if value else 0) + dct_years[v['operation__year']] = values + years = [] + for y in self.years: + if y in dct_years: + years.append(dct_years[y]) + else: + years.append((0, 0, 0, 0)) + nbs, areas, costs, fnaps = zip(*years) + years.append((sum(nbs), sum(areas), sum(costs), sum(fnaps))) + dct_res['effective_by_dpt'].append((dpt_label, years)) + + OperationTown = Operation.towns.through + query = OperationTown.objects\ + .filter(operation__in_charge__isnull=False, + operation__operation_type__txt_idx__in=ope_types)\ + .values('town__name', 'town__departement__number')\ + .annotate(nb=Count('operation'))\ + .order_by('-nb', 'town__name')[:10] + dct_res['towns'] = [] + for r in query: + dct_res['towns'].append((u"%s (%s)" % (r['town__name'], + r['town__departement__number']), + r['nb'])) + + if dct_res == self.survey: + query = OperationTown.objects\ + .filter(operation__in_charge__isnull=False, + operation__operation_type__txt_idx__in=ope_types, + operation__surface__isnull=False)\ + .values('town__name', 'town__departement__number')\ + .annotate(nb=Sum('operation__surface'))\ + .order_by('-nb', 'town__name')[:10] + dct_res['towns_surface'] = [] + for r in query: + dct_res['towns_surface'].append((u"%s (%s)" % ( + r['town__name'], r['town__departement__number']), + r['nb'])) + else: + query = OperationTown.objects\ + .filter(operation__in_charge__isnull=False, + operation__operation_type__txt_idx__in=ope_types, + operation__cost__isnull=False)\ + .values('town__name', 'town__departement__number')\ + .annotate(nb=Sum('operation__cost'))\ + .order_by('-nb', 'town__name')[:10] + dct_res['towns_cost'] = [] + for r in query: + dct_res['towns_cost'].append((u"%s (%s)" % (r['town__name'], + r['town__departement__number']), + r['nb'])) + +class Dashboard: + def __init__(self, model): + self.model = model + self.total_number = model.get_total_number() + history_model = self.model.history.model + # last edited - created + self.recents, self.lasts = [], [] + for last_lst, modif_type in ((self.lasts, '+'), (self.recents, '~')): + last_ids = history_model.objects.values('id')\ + .annotate(hd=Max('history_date')) + last_ids = last_ids.filter(history_type=modif_type) + if self.model == Item: + last_ids = last_ids.filter(downstream_treatment_id__isnull=True) + if modif_type == '+': + last_ids = last_ids.filter(upstream_treatment_id__isnull=True) + last_ids = last_ids.order_by('-hd').distinct().all()[:5] + for idx in last_ids: + try: + obj = self.model.objects.get(pk=idx['id']) + except: + # deleted object are always referenced in history + continue + obj.history_date = idx['hd'] + last_lst.append(obj) + # years + self.years = model.get_years() + self.years.sort() + if not self.total_number or not self.years: + return + self.values = [('year', _(u"Year"), reversed(self.years))] + # numbers + self.numbers = [model.get_by_year(year).count() for year in self.years] + self.values += [('number', _(u"Number"), reversed(self.numbers))] + # calculate + self.average = self.get_average() + self.variance = self.get_variance() + self.standard_deviation = self.get_standard_deviation() + self.median = self.get_median() + self.mode = self.get_mode() + # by operation + if not hasattr(model, 'get_by_operation'): + return + operations = model.get_operations() + operation_numbers = [model.get_by_operation(op).count() + for op in operations] + # calculate + self.operation_average = self.get_average(operation_numbers) + self.operation_variance = self.get_variance(operation_numbers) + self.operation_standard_deviation = self.get_standard_deviation( + operation_numbers) + self.operation_median = self.get_median(operation_numbers) + operation_mode_pk = self.get_mode(dict(zip(operations, + operation_numbers))) + if operation_mode_pk: + self.operation_mode = unicode(Operation.objects.get( + pk=operation_mode_pk)) + + def get_average(self, vals=[]): + if not vals: + vals = self.numbers + return sum(vals)/len(vals) + + def get_variance(self, vals=[]): + if not vals: + vals = self.numbers + avrg = self.get_average(vals) + return self.get_average([(x-avrg)**2 for x in vals]) + + def get_standard_deviation(self, vals=[]): + if not vals: + vals = self.numbers + return round(self.get_variance(vals)**0.5, 3) + + def get_median(self, vals=[]): + if not vals: + vals = self.numbers + len_vals = len(vals) + vals.sort() + if (len_vals % 2) == 1: + return vals[len_vals/2] + else: + return (vals[len_vals/2-1] + vals[len_vals/2])/2.0 + + def get_mode(self, vals={}): + if not vals: + vals = dict(zip(self.years, self.numbers)) + mx = max(vals.values()) + for v in vals: + if vals[v] == mx: + return v + +class Departement(models.Model): + label = models.CharField(_(u"Label"), max_length=30) + number = models.CharField(_(u"Number"), unique=True, max_length=3) + + class Meta: + verbose_name = _(u"Departement") + verbose_name_plural = _(u"Departements") + ordering = ['number'] + + def __unicode__(self): + return unicode(self.number) + JOINT + self.label + +class Address(BaseHistorizedItem): + address = models.TextField(_(u"Address"), null=True, blank=True) + address_complement = models.TextField(_(u"Address complement"), null=True, + blank=True) + postal_code = models.CharField(_(u"Postal code"), max_length=10, null=True, + blank=True) + town = models.CharField(_(u"Town"), max_length=30, null=True, blank=True) + country = models.CharField(_(u"Country"), max_length=30, null=True, + blank=True) + phone = models.CharField(_(u"Phone"), max_length=18, null=True, blank=True) + mobile_phone = models.CharField(_(u"Mobile phone"), max_length=18, + null=True, blank=True) + history = HistoricalRecords() + + class Meta: + abstract = True + +class OrganizationType(GeneralType): + class Meta: + verbose_name = _(u"Organization type") + verbose_name_plural = _(u"Organization types") + +class Organization(Address, OwnPerms): + name = models.CharField(_(u"Name"), max_length=100) + organization_type = models.ForeignKey(OrganizationType, + verbose_name=_(u"Type")) + history = HistoricalRecords() + class Meta: + verbose_name = _(u"Organization") + verbose_name_plural = _(u"Organizations") + permissions = ( + ("view_own_organization", ugettext(u"Can view own Organization")), + ("add_own_organization", ugettext(u"Can add own Organization")), + ("change_own_organization", ugettext(u"Can change own Organization")), + ("delete_own_organization", ugettext(u"Can delete own Organization")), + ) + + def __unicode__(self): + return self.name + +class PersonType(GeneralType): + rights = models.ManyToManyField(WizardStep, verbose_name=_(u"Rights")) + class Meta: + verbose_name = _(u"Person type") + verbose_name_plural = _(u"Person types") + +class Person(Address, OwnPerms) : + TYPE = (('Mr', _(u'Mr')), + ('Ms', _(u'Miss')), + ('Md', _(u'Mrs')), + ('Dr', _(u'Doctor')), + ) + title = models.CharField(_(u"Title"), max_length=2, choices=TYPE) + surname = models.CharField(_(u"Surname"), max_length=20) + name = models.CharField(_(u"Name"), max_length=30) + email = models.CharField(_(u"Email"), max_length=40, blank=True, null=True) + person_type = models.ForeignKey(PersonType, verbose_name=_(u"Type")) + attached_to = models.ForeignKey('Organization', + verbose_name=_(u"Is attached to"), blank=True, null=True) + + class Meta: + verbose_name = _(u"Person") + verbose_name_plural = _(u"Persons") + permissions = ( + ("view_person", ugettext(u"Can view Person")), + ("view_own_person", ugettext(u"Can view own Person")), + ("add_own_person", ugettext(u"Can add own Person")), + ("change_own_person", ugettext(u"Can change own Person")), + ("delete_own_person", ugettext(u"Can delete own Person")), + ) + + def __unicode__(self): + lbl = u"%s %s" % (self.name, self.surname) + lbl += JOINT + if self.attached_to: + lbl += unicode(self.attached_to) + elif self.email: + lbl += self.email + return lbl + + def full_label(self): + return u" ".join([unicode(getattr(self, attr)) + for attr in ('title', 'surname', 'name', 'attached_to') + if getattr(self, attr)]) + +class IshtarUser(User): + person = models.ForeignKey(Person, verbose_name=_(u"Person"), unique=True) + + class Meta: + verbose_name = _(u"Ishtar user") + verbose_name_plural = _(u"Ishtar users") + + @classmethod + def create_from_user(cls, user): + default = user.username + surname = user.first_name or default + name = user.last_name or default + email = user.email + person_type = None + if user.is_superuser: + person_type = PersonType.objects.get(txt_idx='administrator') + else: + person_type = PersonType.objects.get(txt_idx='public_access') + person = Person.objects.create(title='Mr', surname=surname, + name=name, email=email, + person_type=person_type, + history_modifier=user) + return IshtarUser.objects.create(user_ptr=user, person=person) + +class AuthorType(GeneralType): + class Meta: + verbose_name = _(u"Author type") + verbose_name_plural = _(u"Author types") + +class Author(models.Model): + person = models.ForeignKey(Person, verbose_name=_(u"Person")) + author_type = models.ForeignKey(AuthorType, verbose_name=_(u"Author type")) + + class Meta: + verbose_name = _(u"Author") + verbose_name_plural = _(u"Authors") + + def __unicode__(self): + return unicode(self.person) + JOINT + unicode(self.author_type) + +class SourceType(GeneralType): + class Meta: + verbose_name = _(u"Source type") + verbose_name_plural = _(u"Source types") + +class Source(models.Model): + title = models.CharField(_(u"Title"), max_length=200) + source_type = models.ForeignKey(SourceType, verbose_name=_(u"Type")) + authors = models.ManyToManyField(Author, verbose_name=_(u"Authors")) + associated_url = models.URLField(verify_exists=False, blank=True, null=True, + verbose_name=_(u"Numerical ressource (web address)")) + receipt_date = models.DateField(blank=True, null=True, + verbose_name=_(u"Receipt date")) + creation_date = models.DateField(blank=True, null=True, + verbose_name=_(u"Creation date")) + TABLE_COLS = ['title', 'source_type', 'authors',] + + class Meta: + abstract = True + + def __unicode__(self): + return self.title + +class FileType(GeneralType): + class Meta: + verbose_name = _(u"Archaeological file type") + verbose_name_plural = _(u"Archaeological file types") + + @classmethod + def is_preventive(cls, file_type_id, key=''): + key = key or 'preventive' + try: + preventive = FileType.objects.get(txt_idx=key).pk + return file_type_id == preventive + except ObjectDoesNotExist: + return False + +class PermitType(GeneralType): + class Meta: + verbose_name = _(u"Permit type") + verbose_name_plural = _(u"Permit types") + +if settings.COUNTRY == 'fr': + class SaisineType(GeneralType): + delay = models.IntegerField(_(u"Delay (in days)")) + class Meta: + verbose_name = u"Type Saisine" + verbose_name_plural = u"Types Saisine" + +class File(BaseHistorizedItem, OwnPerms): + TABLE_COLS = ['numeric_reference', 'year', 'internal_reference', + 'file_type', 'saisine_type', 'towns', ] + year = models.IntegerField(_(u"Year"), + default=lambda:datetime.datetime.now().year) + numeric_reference = models.IntegerField(_(u"Numeric reference")) + internal_reference = models.CharField(_(u"Internal reference"), + max_length=60, unique=True) + file_type = models.ForeignKey(FileType, verbose_name=_(u"File type")) + in_charge = models.ForeignKey(Person, related_name='+', + verbose_name=_(u"Person in charge")) + general_contractor = models.ForeignKey(Person, related_name='+', + verbose_name=_(u"General contractor"), blank=True, null=True) + town_planning_service = models.ForeignKey(Organization, related_name='+', + verbose_name=_(u"Town planning service"), blank=True, null=True) + permit_type = models.ForeignKey(PermitType, verbose_name=_(u"Permit type"), + blank=True, null=True) + permit_reference = models.CharField(_(u"Permit reference"), + max_length=60, blank=True, null=True) + end_date = models.DateField(_(u"Closing date"), null=True, blank=True) + towns = models.ManyToManyField("Town", verbose_name=_(u"Towns"), + related_name='file') + creation_date = models.DateField(_(u"Creation date"), + default=datetime.date.today) + reception_date = models.DateField(_(u'Reception date'), blank=True, + null=True) + related_file = models.ForeignKey("File", verbose_name=_(u"Related file"), + blank=True, null=True) + if settings.COUNTRY == 'fr': + saisine_type = models.ForeignKey(SaisineType, blank=True, null=True, + verbose_name= u"Type de saisine") + reference_number = models.IntegerField(_(u"Reference number"), + blank=True, null=True) + total_surface = models.IntegerField(_(u"Total surface (m²)"), + blank=True, null=True) + total_developed_surface = models.IntegerField( + _(u"Total developed surface (m²)"), blank=True, null=True) + address = models.TextField(_(u"Main address"), null=True, blank=True) + address_complement = models.TextField(_(u"Main address - complement"), + null=True, blank=True) + postal_code = models.CharField(_(u"Main address - postal code"), + max_length=10, null=True, blank=True) + comment = models.TextField(_(u"Comment"), null=True, blank=True) + history = HistoricalRecords() + + class Meta: + verbose_name = _(u"Archaeological file") + verbose_name_plural = _(u"Archaeological files") + permissions = ( + ("view_own_file", ugettext(u"Can view own Archaelogical file")), + ("add_own_file", ugettext(u"Can add own Archaelogical file")), + ("change_own_file", ugettext(u"Can change own Archaelogical file")), + ("delete_own_file", ugettext(u"Can delete own Archaelogical file")), + ) + ordering = ['-year', '-numeric_reference'] + + @classmethod + def get_years(cls): + return [res['year'] for res in list(cls.objects.values('year').annotate( + Count("id")).order_by())] + + @classmethod + def get_by_year(cls, year): + return cls.objects.filter(year=year) + + @classmethod + def get_total_number(cls): + return cls.objects.count() + + def __unicode__(self): + items = [unicode(_('Intercommunal'))] + if self.towns.count() == 1: + items[0] = unicode(self.towns.all()[0]) + items.append("-".join((unicode(self.year), + unicode(self.numeric_reference)))) + items += [unicode(getattr(self, k))[:36] + for k in ['internal_reference',] if getattr(self, k)] + return JOINT.join(items) + + @classmethod + def get_query_owns(cls, user): + return Q(history_modifier=user) & Q(end_date__isnull=True) + + def is_active(self): + return not bool(self.end_date) + + def closing(self): + if self.is_active(): + return + for item in self.history.all(): + if not item.end_date: + break + return {'date':item.history_date, + 'user':IshtarUser.objects.get(pk=item.history_modifier_id)} + + def total_surface_ha(self): + if self.total_surface: + return self.total_surface/10000.0 + + def total_developed_surface_ha(self): + if self.total_developed_surface: + return self.total_developed_surface/10000.0 + + def operation_acts(self): + acts = [] + for ope in self.operations.all(): + for act in ope.administrative_act.all(): + acts.append(act) + return acts + + def is_preventive(self): + return FileType.is_preventive(self.file_type.pk) + +class FileByDepartment(models.Model): + ''' + Database view: don't forget to create it + + create view file_department (id, department_id, file_id) as + select town."id", town."departement_id", file_towns."file_id" + from ishtar_base_town town + inner join ishtar_base_file_towns file_towns on + file_towns."town_id"=town."id" order by town."departement_id"; + CREATE RULE file_department_delete + AS ON DELETE TO file_department DO INSTEAD(); + ''' + file = models.ForeignKey(File, verbose_name=_(u"File")) + department = models.ForeignKey(Departement, verbose_name=_(u"Department"), + blank=True, null=True) + class Meta: + managed = False + db_table = 'file_department' + +class OperationType(GeneralType): + class Meta: + verbose_name = _(u"Operation type") + verbose_name_plural = _(u"Operation types") + + @classmethod + def is_preventive(cls, ope_type_id, key=''): + key = key or 'prev_excavation' + try: + preventive = OperationType.objects.get(txt_idx=key).pk + return ope_type_id == preventive + except ObjectDoesNotExist: + return False + +class RemainType(GeneralType): + class Meta: + verbose_name = _(u"Remain type") + verbose_name_plural = _(u"Remain types") + +class Operation(BaseHistorizedItem, OwnPerms): + TABLE_COLS = ['year_index', 'operation_type', 'remains', 'towns', + 'associated_file', 'start_date', 'excavation_end_date'] + start_date = models.DateField(_(u"Start date"), null=True, blank=True) + excavation_end_date = models.DateField(_(u"Excavation end date"), null=True, + blank=True) + end_date = models.DateField(_(u"Closing date"), null=True, blank=True) + in_charge = models.ForeignKey('Person', related_name='+', null=True, + blank=True, verbose_name=_(u"In charge")) + year = models.IntegerField(_(u"Year")) + operation_code = models.IntegerField(_(u"Operation code")) + associated_file = models.ForeignKey(File, related_name='operations', + verbose_name=_(u"File"), blank=True, null=True) + operation_type = models.ForeignKey(OperationType, related_name='+', + verbose_name=_(u"Operation type")) + surface = models.IntegerField(_(u"Surface (m²)"), blank=True, null=True) + remains = models.ManyToManyField("RemainType", verbose_name=_(u'Remains')) + towns = models.ManyToManyField("Town", verbose_name=_(u"Towns")) + cost = models.IntegerField(_(u"Cost (€)"), blank=True, null=True) + periods = models.ManyToManyField('Period', verbose_name=_(u"Periods")) + scheduled_man_days = models.IntegerField(_(u"Scheduled man-days"), + blank=True, null=True) + optional_man_days = models.IntegerField(_(u"Optional man-days"), + blank=True, null=True) + effective_man_days = models.IntegerField(_(u"Effective man-days"), + blank=True, null=True) + if settings.COUNTRY == 'fr': + code_patriarche = models.IntegerField(u"Code PATRIARCHE", null=True, + blank=True) + TABLE_COLS = ['code_patriarche'] + TABLE_COLS + code_dracar = models.CharField(u"Code DRACAR", max_length=10, null=True, + blank=True) + fnap_financing = models.FloatField(u"Financement FNAP (%)", + blank=True, null=True) + fnap_cost = models.IntegerField(u"Financement FNAP (€)", + blank=True, null=True) + zoning_prescription = models.NullBooleanField( + _(u"Prescription on zoning"), blank=True, null=True) + large_area_prescription = models.NullBooleanField( + _(u"Prescription on large area"), blank=True, null=True) + geoarchaeological_context_prescription = models.NullBooleanField( + _(u"Prescription on geoarchaeological context"), blank=True, null=True) + operator_reference = models.CharField(_(u"Operator reference"), + max_length=20, null=True, blank=True) + common_name = models.CharField(_(u"Generic name"), max_length=120, null=True, + blank=True) + comment = models.TextField(_(u"Comment"), null=True, blank=True) + history = HistoricalRecords() + + class Meta: + verbose_name = _(u"Operation") + verbose_name_plural = _(u"Operations") + permissions = ( + ("view_own_operation", ugettext(u"Can view own Operation")), + ("add_own_operation", ugettext(u"Can add own Operation")), + ("change_own_operation", ugettext(u"Can change own Operation")), + ("delete_own_operation", ugettext(u"Can delete own Operation")), + ) + + def __unicode__(self): + items = [unicode(_('Intercommunal'))] + if self.towns.count() == 1: + items[0] = unicode(self.towns.all()[0]) + items.append("-".join((unicode(self.year), + unicode(self.operation_code)))) + return JOINT.join(items) + + @classmethod + def get_available_operation_code(cls, year=None): + if not year: + year = datetime.date.today().year + max_val = cls.objects.filter(year=year).aggregate( + Max('operation_code'))["operation_code__max"] + return (max_val + 1) if max_val else 1 + + @classmethod + def get_years(cls): + return [res['year'] for res in list(cls.objects.values('year').annotate( + Count("id")).order_by())] + + @classmethod + def get_by_year(cls, year): + return cls.objects.filter(year=year) + + @classmethod + def get_total_number(cls): + return cls.objects.count() + + year_index_lbl = _(u"Operation code") + @property + def year_index(self): + lbl = unicode(self.operation_code) + lbl = u"%d-%s%s" % (self.year, (3-len(lbl))*"0", lbl) + return lbl + + def clean(self): + objs = self.__class__.objects.filter(year=self.year, + operation_code=self.operation_code) + if self.pk: + objs = objs.exclude(pk=self.pk) + if objs.count(): + raise ValidationError(_(u"This operation code already exists for " + u"this year")) + + def is_own(self, person): + return False + + @property + def surface_ha(self): + if self.surface: + return self.surface/10000.0 + + @property + def cost_by_m2(self): + if not self.surface or not self.cost: + return + return round(float(self.cost)/self.surface, 2) + + @property + def cost_by_m2(self): + if not self.surface or not self.cost: + return + return round(float(self.cost)/self.surface, 2) + + @classmethod + def get_query_owns(cls, user): + return Q(in_charge=user.person)|Q(history_modifier=user)\ + & Q(end_date__isnull=True) + + def is_active(self): + return not bool(self.end_date) + + def closing(self): + if self.is_active(): + return + for item in self.history.all(): + if not item.end_date: + break + return {'date':item.history_date, + 'user':IshtarUser.objects.get(pk=item.history_modifier_id)} + +def operation_post_save(sender, **kwargs): + if not kwargs['instance']: + return + operation = kwargs['instance'] + if operation.fnap_financing and operation.cost: + fnap_cost = int(float(operation.cost)/100*operation.fnap_financing) + if not operation.fnap_cost or operation.fnap_cost != fnap_cost: + operation.fnap_cost = fnap_cost + operation.save() + elif operation.fnap_cost and operation.cost: + fnap_percent = float(operation.fnap_cost)*100/operation.cost + operation.fnap_financing = fnap_percent + operation.save() +post_save.connect(operation_post_save, sender=Operation) + +class OperationByDepartment(models.Model): + ''' + Database view: don't forget to create it + + create view operation_department (id, department_id, operation_id) as + select town."id", town."departement_id", operation_towns."operation_id" + from ishtar_base_town town + inner join ishtar_base_operation_towns operation_towns on + operation_towns."town_id"=town."id" order by town."departement_id"; + CREATE RULE operation_department_delete + AS ON DELETE TO operation_department DO INSTEAD(); + ''' + operation = models.ForeignKey(Operation, verbose_name=_(u"Operation")) + department = models.ForeignKey(Departement, verbose_name=_(u"Department"), + blank=True, null=True) + class Meta: + managed = False + db_table = 'operation_department' + +class OperationSource(Source): + class Meta: + verbose_name = _(u"Operation documentation") + verbose_name_plural = _(u"Operation documentations") + operation = models.ForeignKey(Operation, verbose_name=_(u"Operation"), + related_name="source") + index = models.IntegerField(verbose_name=_(u"Index")) + TABLE_COLS = ['operation.year', 'operation.operation_code'] + \ + Source.TABLE_COLS + +class Parcel(LightHistorizedItem): + associated_file = models.ForeignKey(File, related_name='parcels', + blank=True, null=True, verbose_name=_(u"File")) + operation = models.ForeignKey(Operation, related_name='parcels', blank=True, + null=True, verbose_name=_(u"Operation")) + year = models.IntegerField(_(u"Year"), blank=True, null=True) + town = models.ForeignKey("Town", related_name='parcels', + verbose_name=_(u"Town")) + section = models.CharField(_(u"Section"), max_length=4) + parcel_number = models.CharField(_(u"Parcel number"), max_length=6) + + class Meta: + verbose_name = _(u"Parcel") + verbose_name_plural = _(u"Parcels") + + def short_label(self): + return JOINT.join([unicode(item) for item in [self.section, + self.parcel_number] if item]) + + def __unicode__(self): + return self.short_label() + + def long_label(self): + items = [unicode(self.operation or self.associated_file)] + items += [unicode(item) for item in [self.section, self.parcel_number] + if item] + return JOINT.join(items) + +class Period(GeneralType) : + order = models.IntegerField(_(u"Order")) + start_date = models.IntegerField(_(u"Start date")) + end_date = models.IntegerField(_(u"End date")) + parent = models.ForeignKey("Period", verbose_name=_(u"Parent period"), + blank=True, null=True) + + class Meta: + verbose_name = _(u"Type Period") + verbose_name_plural = _(u"Types Period") + + def __unicode__(self): + return self.label + +class DatingType(GeneralType): + class Meta: + verbose_name = _(u"Dating type") + verbose_name_plural = _(u"Dating types") + +class DatingQuality(GeneralType): + class Meta: + verbose_name = _(u"Dating quality") + verbose_name_plural = _(u"Dating qualities") + +class Dating(models.Model): + period = models.ForeignKey(Period, verbose_name=_(u"Period")) + start_date = models.IntegerField(_(u"Start date"), blank=True, null=True) + end_date = models.IntegerField(_(u"End date"), blank=True, null=True) + dating_type = models.ForeignKey(DatingType, verbose_name=_(u"Dating type"), + blank=True, null=True) + quality = models.ForeignKey(DatingQuality, verbose_name=_(u"Quality"), + blank=True, null=True) + + class Meta: + verbose_name = _(u"Dating") + verbose_name_plural = _(u"Datings") + + def __unicode__(self): + start_date = self.start_date and unicode(self.start_date) or u"" + end_date = self.end_date and unicode(self.end_date) or u"" + if not start_date and not end_date: + return unicode(self.period) + return u"%s (%s-%s)" % (self.period, start_date, end_date) + +class Unit(GeneralType): + order = models.IntegerField(_(u"Order")) + parent = models.ForeignKey("Unit", verbose_name=_(u"Parent unit"), + blank=True, null=True) + + class Meta: + verbose_name = _(u"Type Unit") + verbose_name_plural = _(u"Types Unit") + + def __unicode__(self): + return self.label + +class ActivityType(GeneralType): + order = models.IntegerField(_(u"Order")) + + class Meta: + verbose_name = _(u"Type Activity") + verbose_name_plural = _(u"Types Activity") + + def __unicode__(self): + return self.label + +class IdentificationType(GeneralType): + order = models.IntegerField(_(u"Order")) + class Meta: + verbose_name = _(u"Type Identification") + verbose_name_plural = _(u"Types Identification") + + def __unicode__(self): + return self.label + +class ContextRecord(BaseHistorizedItem, OwnPerms): + TABLE_COLS = ['parcel.town', 'operation.year', + 'operation.operation_code', + 'label', 'unit'] + if settings.COUNTRY == 'fr': + TABLE_COLS.insert(1, 'parcel.operation.code_patriarche') + parcel = models.ForeignKey(Parcel, verbose_name=_(u"Parcel"), + related_name='context_record') + operation = models.ForeignKey(Operation, verbose_name=_(u"Operation"), + related_name='context_record') + label = models.CharField(_(u"ID"), max_length=200) + description = models.TextField(_(u"Description"), blank=True, null=True) + length = models.IntegerField(_(u"Length (cm)"), blank=True, null=True) + width = models.IntegerField(_(u"Width (cm)"), blank=True, null=True) + thickness = models.IntegerField(_(u"Thickness (cm)"), blank=True, null=True) + depth = models.IntegerField(_(u"Depth (cm)"), blank=True, null=True) + location = models.CharField(_(u"Location"), blank=True, null=True, + max_length=200, + help_text=_(u"A short description of the location of the context record")) + datings = models.ManyToManyField(Dating) + unit = models.ForeignKey(Unit, verbose_name=_(u"Unit"), related_name='+', + blank=True, null=True) + has_furniture = models.NullBooleanField(u"Has furniture?", blank=True, + null=True) + filling = models.TextField(_(u"Filling"), blank=True, null=True) + interpretation = models.TextField(_(u"Interpretation"), blank=True, + null=True) + taq = models.IntegerField(_(u"TAQ"), blank=True, null=True, + help_text=_(u"\"Terminus Ante Quem\" the context record can't have been " + "created after this date")) + taq_estimated = models.IntegerField(_(u"Estimated TAQ"), blank=True, + null=True, help_text=_(u"Estimation of a \"Terminus Ante Quem\"")) + tpq = models.IntegerField(_(u"TPQ"), blank=True, null=True, + help_text=_(u"\"Terminus Post Quem\" the context record can't have been " + " created before this date")) + tpq_estimated = models.IntegerField(_(u"Estimated TPQ"), blank=True, + null=True, help_text=_(u"Estimation of a \"Terminus Post Quem\"")) + identification = models.ForeignKey(IdentificationType, blank=True, + null=True, verbose_name=_(u"Identification"),) + activity = models.ForeignKey(ActivityType,blank=True, null=True, + verbose_name=_(u"Activity"),) + history = HistoricalRecords() + + class Meta: + verbose_name = _(u"Context Record") + verbose_name_plural = _(u"Context Record") + permissions = ( + ("view_own_contextrecord", ugettext(u"Can view own Context Record")), + ("add_own_contextrecord", ugettext(u"Can add own Context Record")), + ("change_own_contextrecord", ugettext(u"Can change own Context Record")), + ("delete_own_contextrecord", ugettext(u"Can delete own Context Record")), + ) + + def __unicode__(self): + return self.short_label() + + def short_label(self): + return JOINT.join([unicode(item) for item in [self.parcel, + self.label] if item]) + + def full_label(self): + if not self.parcel.operation: + return unicode(self) + return self._real_label() or self._temp_label() + + def _real_label(self): + if not self.parcel.operation.code_patriarche: + return + return JOINT.join((self.parcel.operation.code_patriarche, + self.label)) + + def _temp_label(self): + if self.parcel.operation.code_patriarche: + return + return JOINT.join([unicode(lbl) for lbl in [self.parcel.operation.year, + self.parcel.operation.operation_code, + self.label] if lbl]) + + @classmethod + def get_years(cls): + years = set() + for res in list(cls.objects.values('operation__start_date')): + yr = res['operation__start_date'].year + years.add(yr) + return list(years) + + @classmethod + def get_by_year(cls, year): + return cls.objects.filter(operation__start_date__year=year) + + @classmethod + def get_operations(cls): + return [dct['operation__pk'] + for dct in cls.objects.values('operation__pk').distinct()] + + @classmethod + def get_by_operation(cls, operation_id): + return cls.objects.filter(operation__pk=operation_id) + + @classmethod + def get_total_number(cls): + return cls.objects.filter(operation__start_date__isnull=False).count() + +class ContextRecordSource(Source): + class Meta: + verbose_name = _(u"Context record documentation") + verbose_name_plural = _(u"Context record documentations") + context_record = models.ForeignKey(ContextRecord, + verbose_name=_(u"Context record"), related_name="source") + +class MaterialType(GeneralType): + 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 BaseItem(BaseHistorizedItem, OwnPerms): + label = models.CharField(_(u"ID"), max_length=60) + description = models.TextField(_(u"Description")) + context_record = models.ForeignKey(ContextRecord, + related_name='base_items', 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 item") + verbose_name_plural = _(u"Base items") + permissions = ( + ("view_own_baseitem", ugettext(u"Can view own Base item")), + ("add_own_baseitem", ugettext(u"Can add own Base item")), + ("change_own_baseitem", ugettext(u"Can change own Base item")), + ("delete_own_baseitem", ugettext(u"Can delete own Base item")), + ) + + def __unicode__(self): + return self.label + + def get_last_item(self): + #TODO: manage virtuals - property(last_item) ? + items = self.item.filter().order_by("-order").all() + return items and items[0] + + def full_label(self): + return self._real_label() or self._temp_label() + + def material_type_label(self): + item = self.get_last_item() + items = [item and unicode(item.material_type) or ''] + ope = self.context_record.operation + items += [ope.code_patriarche or \ + (unicode(ope.year) + "-" + unicode(ope.operation_code))] + items += [self.context_record.label, unicode(self.material_index)] + return JOINT.join(items) + + def _real_label(self): + if not self.context_record.parcel.operation.code_patriarche: + return + item = self.get_last_item() + lbl = item.label or self.label + return JOINT.join([unicode(it) for it in ( + self.context_record.parcel.operation.code_patriarche, + self.context_record.label, + lbl) if it]) + + def _temp_label(self): + if self.context_record.parcel.operation.code_patriarche: + return + item = self.get_last_item() + lbl = item.label or self.label + return JOINT.join([unicode(it) for it in ( + self.context_record.parcel.year, + self.index, + self.context_record.label, + lbl) if it]) + +class Item(BaseHistorizedItem, OwnPerms): + TABLE_COLS = ['label', 'material_type', 'dating.period', + 'base_items.context_record.parcel.town', + 'base_items.context_record.parcel.operation.year', + 'base_items.context_record.parcel.operation.operation_code', + 'base_items.is_isolated'] + if settings.COUNTRY == 'fr': + TABLE_COLS.insert(6, + 'base_items.context_record.parcel.operation.code_patriarche') + base_items = models.ManyToManyField(BaseItem, verbose_name=_(u"Base item"), + related_name='item') + 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) + item_number = models.IntegerField(_("Item 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")) + container = models.ForeignKey('Container', verbose_name=_(u"Container"), + blank=True, null=True, related_name='items') + history = HistoricalRecords() + + @classmethod + def get_years(cls): + years = set() + items = cls.objects.filter(downstream_treatment__isnull=True) + for item in items: + bi = item.base_items.all() + if not bi: + continue + bi = bi[0] + 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_items__context_record__operation__start_date__year=year) + + @classmethod + def get_operations(cls): + operations = set() + items = cls.objects.filter(downstream_treatment__isnull=True) + for item in items: + bi = item.base_items.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_items__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', + 'item_number', 'dating')]) + dct['order'] += 1 + dct['history_modifier'] = user + new = self.__class__(**dct) + new.save() + for base_item in self.base_items.all(): + new.base_items.add(base_item) + return new + + class Meta: + verbose_name = _(u"Item") + verbose_name_plural = _(u"Items") + permissions = ( + ("view_own_item", ugettext(u"Can view own Item")), + ("add_own_item", ugettext(u"Can add own Item")), + ("change_own_item", ugettext(u"Can change own Item")), + ("delete_own_item", ugettext(u"Can delete own Item")), + ) + + def __unicode__(self): + return self.label + + def save(self, *args, **kwargs): + if not self.pk: + super(Item, self).save(*args, **kwargs) + for base_item in self.base_items.all(): + if not base_item.index: + idx = BaseItem.objects.filter(context_record=\ + base_item.context_record).aggregate(Max('index')) + base_item.index = idx and idx['index__max'] + 1 or 1 + if not base_item.material_index: + idx = BaseItem.objects.filter(context_record=\ + base_item.context_record, + item__material_type=self.material_type).aggregate( + Max('material_index')) + base_item.material_index = idx and \ + idx['material_index__max'] + 1 or 1 + base_item.save() + super(Item, self).save(*args, **kwargs) + +class ItemSource(Source): + class Meta: + verbose_name = _(u"Item documentation") + verbose_name_plural = _(u"Item documentations") + item = models.ForeignKey(Item, verbose_name=_(u"Item"), + related_name="source") + +class ParcelOwner(LightHistorizedItem): + owner = models.ForeignKey(Person, verbose_name=_(u"Owner")) + parcel = models.ForeignKey(Parcel, verbose_name=_(u"Parcel")) + start_date = models.DateField(_(u"Start date")) + end_date = models.DateField(_(u"End date")) + + class Meta: + verbose_name = _(u"Parcel owner") + verbose_name_plural = _(u"Parcel owners") + + def __unicode__(self): + return self.owner + JOINT + self.parcel + +class WarehouseType(GeneralType): + class Meta: + verbose_name = _(u"Warehouse type") + verbose_name_plural = _(u"Warehouse types") + +class Warehouse(Address, OwnPerms): + name = models.CharField(_(u"Name"), max_length=40) + warehouse_type = models.ForeignKey(WarehouseType, + verbose_name=_(u"Warehouse type")) + person_in_charge = models.ForeignKey(Person, + verbose_name=_(u"Person in charge"), null=True, blank=True) + comment = models.TextField(_(u"Comment"), null=True, blank=True) + + class Meta: + verbose_name = _(u"Warehouse") + verbose_name_plural = _(u"Warehouses") + permissions = ( + ("view_own_warehouse", ugettext(u"Can view own Warehouse")), + ("add_own_warehouse", ugettext(u"Can add own Warehouse")), + ("change_own_warehouse", ugettext(u"Can change own Warehouse")), + ("delete_own_warehouse", ugettext(u"Can delete own Warehouse")), + ) + + def __unicode__(self): + return u"%s (%s)" % (self.name, unicode(self.warehouse_type)) + +class ActType(GeneralType): + TYPE = (('F', _(u'Archaelogical file')), + ('O', _(u'Operation')), + ) + intented_to = models.CharField(_(u"Intended to"), max_length=1, + choices=TYPE) + class Meta: + verbose_name = _(u"Act type") + verbose_name_plural = _(u"Act types") + +class AdministrativeAct(BaseHistorizedItem, OwnPerms): + TABLE_COLS = ['act_type', 'associated_file', 'operation', + 'associated_file.towns', 'operation.towns'] + TABLE_COLS_FILE = ['act_type', 'associated_file', 'associated_file.towns',] + TABLE_COLS_OPE = ['act_type', 'operation', 'operation.towns'] + act_type = models.ForeignKey(ActType, verbose_name=_(u"Act type")) + in_charge = models.ForeignKey(Person, blank=True, null=True, + related_name='+', verbose_name=_(u"Person in charge of the operation")) + operator = models.ForeignKey(Organization, blank=True, null=True, + verbose_name=_(u"Archaeological preventive operator")) + scientific = models.ForeignKey(Person, blank=True, null=True, +related_name='+', verbose_name=_(u"Person in charge of the scientific part")) + signatory = models.ForeignKey(Person, blank=True, null=True, + related_name='+', verbose_name=_(u"Signatory")) + operation = models.ForeignKey(Operation, blank=True, null=True, + related_name='administrative_act', verbose_name=_(u"Operation")) + associated_file = models.ForeignKey(File, blank=True, null=True, + related_name='administrative_act', verbose_name=_(u"Archaelogical file")) + signature_date = models.DateField(_(u"Signature date"), blank=True, + null=True) + act_object = models.CharField(_(u"Object"), max_length=200) + if settings.COUNTRY == 'fr': + ref_sra = models.CharField(u"Référence SRA", max_length=15) + history = HistoricalRecords() + + class Meta: + verbose_name = _(u"Administrative act") + verbose_name_plural = _(u"Administrative acts") + permissions = ( +("view_own_administrativeact", ugettext(u"Can view own Administrative act")), +("add_own_administrativeact", ugettext(u"Can add own Administrative act")), +("change_own_administrativeact", ugettext(u"Can change own Administrative act")), +("delete_own_administrativeact", ugettext(u"Can delete own Administrative act")), + ) + + def __unicode__(self): + return JOINT.join([unicode(item) + for item in [self.operation, self.associated_file, self.act_object] + if item]) + +class ContainerType(GeneralType): + length = models.IntegerField(_(u"Length (mm)"), blank=True, null=True) + width = models.IntegerField(_(u"Width (mm)"), blank=True, null=True) + height = models.IntegerField(_(u"Height (mm)"), blank=True, null=True) + volume = models.IntegerField(_(u"Volume (l)"), blank=True, null=True) + reference = models.CharField(_(u"Reference"), max_length=30) + + class Meta: + verbose_name = _(u"Container type") + verbose_name_plural = _(u"Container types") + +class Container(LightHistorizedItem): + TABLE_COLS = ['reference', 'container_type', 'location',] + location = models.ForeignKey(Warehouse, verbose_name=_(u"Warehouse")) + container_type = models.ForeignKey(ContainerType, + verbose_name=_("Container type")) + reference = models.CharField(_(u"Reference"), max_length=40) + comment = models.TextField(_(u"Comment")) + + class Meta: + verbose_name = _(u"Container") + verbose_name_plural = _(u"Containers") + + def __unicode__(self): + lbl = u" - ".join((self.reference, unicode(self.container_type), + unicode(self.location))) + return lbl + +if settings.COUNTRY == 'fr': + class Arrondissement(models.Model): + name = models.CharField(u"Nom", max_length=30) + department = models.ForeignKey(Departement, verbose_name=u"Département") + + def __unicode__(self): + return JOINT.join((self.name, unicode(self.department))) + + class Canton(models.Model): + name = models.CharField(u"Nom", max_length=30) + arrondissement = models.ForeignKey(Arrondissement, + verbose_name=u"Arrondissement") + def __unicode__(self): + return JOINT.join((self.name, unicode(self.arrondissement))) + +class Town(models.Model): + name = models.CharField(_(u"Name"), max_length=100) + surface = models.IntegerField(_(u"Surface (m²)"), blank=True, null=True) + center = models.PointField(_(u"Localisation"), srid=settings.SRID, + blank=True, null=True) + if settings.COUNTRY == 'fr': + numero_insee = models.CharField(u"Numéro INSEE", max_length=6, + unique=True) + departement = models.ForeignKey(Departement, verbose_name=u"Département", + null=True, blank=True) + canton = models.ForeignKey(Canton, verbose_name=u"Canton", null=True, + blank=True) + objects = models.GeoManager() + + class Meta: + verbose_name = _(u"Town") + verbose_name_plural = _(u"Towns") + if settings.COUNTRY == 'fr': + ordering = ['numero_insee'] + + def __unicode__(self): + if settings.COUNTRY == "fr": + return u"%s (%s)" % (self.name, self.numero_insee) + return self.name + +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")) + 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_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): + item = models.ForeignKey(Item, verbose_name=_(u"Item")) + 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 + JOINT + self.item + |