class TermsAgreement(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL)
terms = models.ForeignKey(Terms)
created = CreationDateTimeField(_('Date'))
@classmethod
def get_current(cls, user):
terms = Terms.get_current()
if terms:
queryset = cls.objects.filter(user=user, terms=terms)
if queryset.count():
return queryset.all()[0]
return None
class Meta(object):
ordering = ('-created', )
verbose_name_plural = _('Terms agreement')
verbose_name = _('Term agreements')
permissions = (('api_read_termsagreement',
'Can view terms agreements through API'), )
class GisTimeStampedModel(models.Model):
""" TimeStampedModel
An abstract base class model that provides self-managed "created" and
"modified" fields for geographic models.
"""
created = CreationDateTimeField(_('created'))
modified = ModificationDateTimeField(_('modified'))
def save(self, **kwargs):
self.update_modified = kwargs.pop(
'update_modified', getattr(self, 'update_modified', True))
super(GisTimeStampedModel, self).save(**kwargs)
class Meta:
get_latest_by = 'modified'
ordering = (
'-modified',
'-created',
)
abstract = True
class PaymentLogEntry(models.Model):
message = models.CharField(max_length=400)
level = models.CharField(max_length=15, choices=PaymentLogLevels.choices)
timestamp = CreationDateTimeField()
payment = models.ForeignKey('payments.Payment', related_name='payments')
class Meta:
ordering = ('-timestamp', )
verbose_name = _("Payment Log")
verbose_name_plural = verbose_name
def __unicode__(self):
return '{0} {1}'.format(self.get_level_display(),
Truncator(self.message).words(6))
def log_entry(self):
return '[{0}] {1: <5} {2 <5} {3}'.format(
self.timestamp.strftime("%d/%b/%Y %H:%M:%S"),
self.get_type_display(), self.get_level_display(), self.message)
class TaskMemberStatusLog(models.Model):
task_member = models.ForeignKey('tasks.TaskMember')
status = models.CharField(_('status'), max_length=20)
start = CreationDateTimeField(
_('created'),
help_text=_('When this task member entered in this status.'))
class Meta:
verbose_name = _(u'task member status log')
verbose_name_plural = _(u'task member status logs')
class Analytics:
type = 'task_member'
tags = {
'id': 'task_member.id',
'status': 'status',
'location': 'task_member.project.location.name',
'location_group': 'task_member.project.location.group.name',
'country': 'task_member.project.country_name',
'theme': {
'task_member.project.theme.name': {
'translate': True
}
},
'theme_slug': 'task_member.project.theme.slug',
}
fields = {
'id': 'task_member.id',
'task_id': 'task_member.task.id',
'project_id': 'task_member.project.id',
'user_id': 'task_member.member.id',
}
@staticmethod
def extra_fields(obj, created):
# Force the time_spent to an int.
return {'hours': int(obj.task_member.time_spent)}
@staticmethod
def timestamp(obj, created):
return obj.start
class ContentModel(PublisherModel):
title = models.CharField(_('title'), max_length=255)
slug = AutoSlugField(verbose_name=_('slug'),
populate_from='title',
overwrite=True,
editable=False,
max_length=255,
db_index=True)
description = models.TextField(_('description'), blank=True, null=True)
created = CreationDateTimeField(verbose_name=_('created'), db_index=True)
modified = ModificationDateTimeField(_('modified'), db_index=True)
ADMIN_FIELDSET_TITLE = ADMIN_FIELDSET_TITLE
ADMIN_FIELDSET_PUBLISHING = ADMIN_FIELDSET_PUBLISHING
class Admin(admin.ModelAdmin):
date_hierarchy = 'publish_date'
fieldsets = (
ADMIN_FIELDSET_TITLE,
ADMIN_FIELDSET_PUBLISHING,
)
list_display = (
"title",
"publish_date",
"published",
)
list_filter = ("published", )
search_fields = (
"title",
"description",
)
class Meta(PublisherModel.Meta):
abstract = True
def __unicode__(self):
return self.title
class Reply(models.Model):
article = models.ForeignKey(Article, verbose_name='板块')
created = CreationDateTimeField("创建的时间")
body = models.TextField("文章内容")
user = models.ForeignKey(settings.AUTH_USER_MODEL, verbose_name='创建的用户')
attachment = models.ManyToManyField(Attachment)
def get_markdown(self):
return markdown.markdown(self.body)
def get_absolute_url(self):
return reverse("article:reply", kwargs={"pk": self.id})
@classmethod
def post_save(cls, sender, instance, created, **kwargs):
if created:
instance.article.update_date = now()
instance.article.save()
#TODO 添加通知
sender = get_model(settings.AUTH_USER_MODEL).objects.get(id=settings.NOTIFICATION_USER)
notify.send(sender,
recipient=instance.article.user,
verb=u'你发起的文章[{article}]有新的回复'.format(article=instance.article.title),
action_object=instance,
description=instance.get_markdown()
)
from apps.account.models import Focus
for focus in Focus.get_focus_by_content_object(instance.article).exclude(user__in=[instance.user, instance.article.user]):
print focus.user
notify.send(sender,
recipient=focus.user,
verb=u'你关注的文章[{article}]有新的回复'.format(article=instance.article.title),
action_object=instance,
description=instance.get_markdown()
)
class Meta(object):
verbose_name = verbose_name_plural = '回复'
def __str__(self):
return self.body
class QueryRun(models.Model):
query = models.ForeignKey(SparqlQuery,
on_delete=models.CASCADE,
related_name='query',
verbose_name=_('query'))
result = models.TextField(blank=True,
null=True,
verbose_name=_('query result'))
executed = CreationDateTimeField(_('execution time'))
executor = models.ForeignKey(User,
on_delete=models.CASCADE,
verbose_name=_('executor'),
related_name='executor')
class Meta:
verbose_name = _('SPARQL query execution')
verbose_name_plural = _('SPARQL query executions')
def __str__(self):
return 'run of query {} at {}'.format(self.query.title, self.executed)
class TideData(models.Model):
file = models.FileField(upload_to='tides/%Y/')
inputted = models.BooleanField(_('Inputed data'), default=False)
year = models.CharField(_('Year'), max_length=4, blank=True, null=True)
converted = ArrayField(ArrayField(models.FloatField(null=True,
blank=True)),
default=[],
null=True,
blank=True)
created = CreationDateTimeField()
modified = ModificationDateTimeField()
def __unicode__(self):
return 'Tide Data uploaded on {}'.format(self.created)
def __str__(self):
return 'Tide Data uploaded on {}'.format(self.created)
class Meta:
verbose_name = 'Tide Upload'
ordering = ['created']
class Evento(models.Model):
incidencia = models.ForeignKey(Incidencia, verbose_name=_(u'Incidencia'))
mensaje = models.TextField(verbose_name=_(u'Mensaje'), )
metadatos = models.TextField(
verbose_name=_(u'Metadatos'),
help_text=_(u'Datos no estructurados en formato JSON'),
blank=True,
null=True)
creado_en = CreationDateTimeField()
def __unicode__(self):
return u'Evento #%d: %s' % (self.id, self.mensaje)
class Meta:
verbose_name = _(u'Evento')
verbose_name_plural = _(u'Eventos')
ordering = ('creado_en', )
class Appointment(models.Model):
patient = models.ForeignKey(Patient, related_name="appointments")
doctor = models.ForeignKey(Doctor, related_name="appointments")
schedule = models.DateTimeField('When')
created = CreationDateTimeField('Created At')
note = models.TextField(null=True, blank=True)
org = models.ForeignKey(Organization,
related_name='appointments',
null=True)
def status(self):
try:
return self.negotiations.order_by("-created")[0].status
except Negotiation.DoesNotExist:
return list(Negotiation.NEGOTIATION_STATUS)[2]
except IndexError:
return list(Negotiation.NEGOTIATION_STATUS)[2]
def status_key(self):
return self.status()[0]
def get_status_display(self):
try:
return self.negotiations.order_by(
"-created")[0].get_status_display()
except Negotiation.DoesNotExist:
return 'Waiting for Approval'
except IndexError:
return 'Waiting for Approval'
def when(self):
try:
return self.negotiations.order_by("-created")[0].when
except Negotiation.DoesNotExist:
return None
except IndexError:
return None
def __unicode__(self):
return "Appointment for %s with %s" % (self.doctor, self.patient)
class MonitoredService(models.Model):
"""Model of a service that can be monitored. The actual monitoring is done
somewhere else..."""
UP = 'UP'
DOWN = 'DOWN'
UNKNOWN = 'UNKNOWN'
MAINTENANCE = 'MAINTENANCE'
STATE_CHOICES = (
(UP, UP),
(DOWN, DOWN),
(UNKNOWN, UNKNOWN),
(MAINTENANCE, MAINTENANCE),
)
# uuid = UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
uuid = UUIDField(version=4, auto=True, primary_key=True)
name = CharField(max_length=128, null=False, blank=False, editable=False)
host = CharField(max_length=128, null=False, blank=False, editable=False)
state = CharField(max_length=64,
choices=STATE_CHOICES,
default=UNKNOWN,
null=False,
blank=False)
created = CreationDateTimeField(editable=False, blank=False, null=False)
updated = ModificationDateTimeField(editable=True, blank=False, null=False)
class Meta:
ordering = ['-updated']
def __repr__(self):
return "<MonitoredService: %s>" % self.uuid
def __unicode__(self):
return "<MonitoredService: %s>" % self.uuid
class Software(models.Model):
nombre = models.CharField(
verbose_name=_(u'Nombre'),
max_length=64,
unique=True
)
familia = models.ForeignKey(FamiliaSoftware,
verbose_name=_(u'Familia')
)
fabricante = models.ForeignKey(Proveedor,
verbose_name=_(u'Fabricante')
)
descripcion = models.TextField(
verbose_name=_(u'Descripción'),
null=True,
blank=True
)
sistema_operativo = models.BooleanField(
verbose_name=_(u'¿Es sistema operativo?'),
default=True
)
creado_en = CreationDateTimeField(
verbose_name=_(u'Creado en')
)
objects = SoftwareManager()
def __unicode__(self):
return (self.nombre)
class Meta:
verbose_name = _(u'Software')
verbose_name_plural = _(u'Software')
ordering = ('nombre', )
class Equipo(models.Model):
ESTADO_ACTIVO = 1
ESTADO_INACTIVO = 2
ESTADO_CHOICES = (
(ESTADO_ACTIVO, u'Activo'),
(ESTADO_INACTIVO, u'Inactivo'),
)
nombre = models.CharField(verbose_name=_(u'Nombre'), max_length=64)
tipo = models.ForeignKey(TipoEquipo, verbose_name=(u'Tipo de equipo'))
descripcion = models.TextField(verbose_name=_(u'Descripción'),
null=True,
blank=True)
empleado = models.ForeignKey(Empleado,
verbose_name=_(u'Empleado asignado'))
serie = models.CharField(verbose_name=_(u'Número de serie'),
max_length=64,
blank=True,
null=True)
fabricante = models.ForeignKey(Proveedor, verbose_name=_(u'Fabricante'))
estado = models.PositiveSmallIntegerField(verbose_name=_(u'Estado'),
choices=ESTADO_CHOICES)
creado_en = CreationDateTimeField(verbose_name=_(u'Creado en'))
def __unicode__(self):
return (self.descripcion)
class Meta:
verbose_name = _(u'Equipo')
verbose_name_plural = _(u'Equipos')
ordering = ('nombre', )
class TimeStampedModel(models.Model):
"""Modified version of django_extensions.db.models.TimeStampedModel
Unfortunately, because null=True needed to be added to create and
modified fields, inheritance causes issues with field clash.
"""
created = CreationDateTimeField(_('created'), null=True)
modified = ModificationDateTimeField(_('modified'), null=True)
def save(self, **kwargs):
self.update_modified = kwargs.pop('update_modified', getattr(self, 'update_modified', True))
super(TimeStampedModel, self).save(**kwargs)
class Meta:
get_latest_by = 'modified'
ordering = (
'-modified',
'-created',
)
abstract = True
class SellerDetails(AbstractBaseUser, PermissionsMixin):
id = models.CharField(max_length=24, primary_key=True, default=get_24_char_uuid)
name = models.CharField(max_length=50)
client_id = models.CharField(max_length=50)
client_secret = models.CharField(max_length=100)
email = models.EmailField(max_length=100, unique=True)
phone_number = models.CharField(max_length=10)
access_token = models.CharField(max_length=1000, blank=True, null=True)
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['phone_number', 'client_id', 'client_secret']
objects = BaseUserManager()
created = CreationDateTimeField()
modified = ModificationDateTimeField()
def __unicode__(self):
return '{} {}'.format(self.id, self.name)
class Meta:
verbose_name = 'Seller detail'
class TimeStampedModel(models.Model):
"""
This is a copy of the django_extensions.db.models.TimeStampedModel
which uses different names for the created and modified fields in the DB.
This is done so that we do not have to re-do the existing model migrations
which originally had the update_ts and create_ts fields.
TimeStampedModel
An abstract base class model that provides self-managed "created" and
"modified" fields.
"""
create_ts = CreationDateTimeField(_('Created'))
update_ts = ModificationDateTimeField(_('Modified'))
class Meta:
get_latest_by = 'update_ts'
ordering = (
'-update_ts',
'-create_ts',
)
abstract = True
class Resource(models.Model):
"""List of resources"""
EXTERNAL = 1
LEARNING = 2
RESOURCE_CHOICES = (
(EXTERNAL, _('External Link')),
(LEARNING, _('Learning Lab')),
)
PUBLISHED = 1
HIDDEN = 2
STATUS_CHOICES = (
(PUBLISHED, _('Published')),
(HIDDEN, _('Hidden')),
)
title = models.CharField(max_length=255)
slug = models.SlugField(verbose_name=_(u'Slug'),
max_length=80,
unique=True)
resource_type = models.IntegerField(choices=RESOURCE_CHOICES)
body = models.TextField()
url = models.URLField(verify_exists=False, max_length=500, blank=True)
email = models.EmailField(max_length=150, blank=True)
is_featured = models.BooleanField(default=False)
thumbnail = models.ImageField(verbose_name=_(u'Learning Lab thumbnail'),
null=True,
blank=True,
upload_to=settings.CHALLENGE_IMAGE_PATH)
status = models.IntegerField(choices=STATUS_CHOICES, default=PUBLISHED)
template = models.CharField(max_length=255, null=True, blank=True)
created = CreationDateTimeField()
updated = ModificationDateTimeField()
def get_image_src(self):
media_url = getattr(settings, 'MEDIA_URL', '')
path = lambda f: f and '%s%s' % (media_url, f)
return path(self.thumbnail)
def __unicode__(self):
return self.title
class UserResumeReferences(models.Model):
class Meta:
verbose_name_plural = 'User resume references'
user_resume = models.ForeignKey(UserResume, related_name='references')
name = models.CharField(max_length=80, verbose_name=_l('Name'))
title = models.CharField(max_length=100, verbose_name=_l('Title'))
phone = models.CharField(max_length=15, verbose_name=_l('Phone'))
address = models.CharField(max_length=255,
null=True,
blank=True,
verbose_name=_l('Address'))
type = models.SmallIntegerField(choices=((0, _l('Familiar')),
(1, _l('Personal'))),
verbose_name=_l('Type'))
created_at = CreationDateTimeField(verbose_name=_l('Created at'))
modified_at = ModificationDateTimeField(verbose_name=_l('Modified at'))
def __unicode__(self):
return '%s: %s, %s: %s' % (_('Name'), self.name, _('Phone'),
self.phone)
class Contact(models.Model):
prefix = models.CharField(max_length=1,
choices=POSTAL_ADDRESS_PREFIX_CHOICES,
verbose_name=_("Title"),
blank=True,
null=True)
name = models.CharField(max_length=300, verbose_name=_("Name"))
dateofcreation = CreationDateTimeField(verbose_name=_("Created at"))
lastmodification = ModificationDateTimeField(
verbose_name=_("Last modified"))
lastmodifiedby = models.ForeignKey(settings.AUTH_USER_MODEL,
limit_choices_to={'is_staff': True},
blank=True,
verbose_name=_("Last modified by"),
null=True)
default_currency = models.CharField(verbose_name=_('Currency'),
max_length=3,
choices=currencies,
blank=True,
null=True)
class Meta:
abstract = True
@property
def get_prefix(self):
if self.prefix:
return PostalAddressPrefix.choices[self.prefix]
return ""
@transaction.atomic()
@reversion.create_revision()
def save(self, *args, **kwargs):
super(Contact, self).save(*args, **kwargs)
def __unicode__(self):
if self.prefix:
return "%s %s" % (self.get_prefix, self.name)
return self.name
class Calendar(models.Model):
date = models.DateField(_('Date'))
sun_rise = models.TimeField(_('Sun rise'), blank=True, null=True)
sun_set = models.TimeField(_('Sun set'), blank=True, null=True)
temperature = models.FloatField(_('Temperature'), blank=True, null=True)
weather = models.ForeignKey(WeatherTypes, blank=True, null=True)
created = CreationDateTimeField()
modified = ModificationDateTimeField()
objects = models.Manager()
data = CalendarManager()
def __unicode__(self):
return str(self.date)
def __str__(self):
return str(self.date)
@property
def free(self):
eventtype = self.event_set.values_list('event_type', flat=True)
if 'closed' in eventtype or 'cancel' in eventtype:
return False
return True
@property
def tide(self):
return [{
'x': x.minutes,
'y': x.level
} for x in self.tide_set.order_by('time')]
class Meta:
verbose_name = 'Calendar'
verbose_name_plural = 'Calendar'
ordering = [
'date',
]
class BankDetail(models.Model):
SBI = "STATE BANK OF INDIA"
HDFC = "HDFC BANK"
ICICI = "ICICI BANK"
AXIS = "AXIS BANK"
BOB = "BANK OF BARODA"
VB = "VIJAYA BANK"
PNB = "PUNJAB NATIONAL BANK"
bank_name_choices = (
(SBI, "STATE BANK OF INDIA"),
(HDFC, "HDFC BANK"),
(ICICI, "ICICI BANK"),
(AXIS, "AXIS BANK"),
(BOB, "BANK OF BARODA"),
(VB, "VIJAYA BANK"),
(PNB, "PUNJAB NATIONAL BANK"),
)
user = models.ForeignKey('UserAccount', on_delete=models.CASCADE)
bank_name = models.CharField(max_length=50, default=SBI, choices=bank_name_choices)
account_number = models.CharField(max_length=20, blank=True, null=False)
branch_name = models.CharField(max_length=50, blank=True, null=False)
ifsc_code = models.CharField(max_length=20, blank=True)
micr_code = models.CharField(max_length=20, blank=True)
city = models.CharField(max_length=20, blank=True)
state = models.CharField(max_length=20, blank=True)
created = CreationDateTimeField(null=True)
modified = ModificationDateTimeField(null=True)
def __unicode__(self):
fields = [self.bank_name, self.ifsc_code]
return " ".join(fields)
class Meta:
verbose_name = 'Bank Detail'
verbose_name_plural = 'Bank Details'
class Indicator(models.Model):
"""Key performance indicators
Key performance indicators are data sources plotted on the topic
diagram, showing how government impacts certain indicators.
"""
slug = models.SlugField(unique=True, editable=False)
created = CreationDateTimeField(editable=False)
modified = ModificationDateTimeField(editable=False)
deleted = models.DateTimeField(null=True, blank=True, editable=False)
last_update = models.DateTimeField(null=True, blank=True, editable=False)
update_freq = models.PositiveIntegerField(
default=60 * 60 * 24,
help_text=_('Indicator update frequency in seconds (86400 == 1 day).'))
error_count = models.PositiveIntegerField(default=0, editable=False)
traceback = models.TextField(blank=True, editable=False)
title = models.CharField(max_length=255)
ylabel = models.CharField(max_length=255)
source = models.URLField(_("Šaltinis"))
def __str__(self):
return self.title
class Faq(models.Model):
question = models.CharField(_('Question'), max_length=255)
answer = models.TextField(_('Answer'), blank=True, null=True)
is_public = models.BooleanField(_('Is Public'), default=False)
slug = AutoSlugField(populate_from=('question', ),
unique=True,
overwrite=True)
sort_value = models.IntegerField(_('Sort Value'), default=faqCount())
objects = models.Manager()
public = PublicManager()
created = CreationDateTimeField()
modified = ModificationDateTimeField()
class Meta:
verbose_name = 'FAQ'
verbose_name_plural = 'FAQ'
ordering = [
'-sort_value',
]
permissions = (('can_publish', 'Can publish this item'), )
def url(self):
return None
class Target(models.Model):
name = models.CharField(max_length=255)
user = models.ForeignKey(to=get_user_model())
host = models.CharField(_('host'),
max_length=255,
help_text=_('domain or ip address'))
created = CreationDateTimeField(_('Created'))
modified = ModificationDateTimeField(_('Modified'))
info = JSONField(null=True, blank=True)
info_raw = models.TextField(null=True, blank=True)
class Meta:
get_latest_by = 'modified'
ordering = (
'-modified',
'-created',
)
def __unicode__(self):
return u'%s[%s]' % (
self.name,
self.host,
)
class BaseProjectDocument(models.Model):
""" Document for an Project """
file = PrivateFileField(max_length=110, upload_to='projects/documents')
author = models.ForeignKey('members.Member',
verbose_name=_('author'),
blank=True,
null=True)
project = models.ForeignKey('projects.Project', related_name="documents")
created = CreationDateTimeField(_('created'))
updated = ModificationDateTimeField(_('updated'))
deleted = models.DateTimeField(_('deleted'), null=True, blank=True)
ip_address = models.GenericIPAddressField(_('IP address'),
blank=True,
null=True,
default=None)
class Meta:
verbose_name = _('project document')
verbose_name_plural = _('project documents')
abstract = True
class OrganizationContact(ValidatedModelMixin, models.Model):
"""
Basic details for an organization contact
"""
name = models.TextField(_('name'), null=True, blank=True, max_length=100)
email = models.EmailField(_('email'), null=True, blank=True, max_length=254)
phone = models.TextField(_('phone'), null=True, blank=True, max_length=40)
owner = models.ForeignKey(settings.AUTH_USER_MODEL, verbose_name=_('owner'), null=True)
created = CreationDateTimeField(
_('created'),
help_text=_('When this contact was created.')
)
updated = ModificationDateTimeField(_('updated'))
required_fields = ['name', 'email']
class Meta(object):
verbose_name = _('Partner Organization Contact')
verbose_name_plural = _('Partner Organization Contacts')
def __str__(self):
return str(self.name)
class ProjectCategoryMembership(models.Model):
"""Intermediary Model to determine when a user is member of a given
``ProjectCategory``"""
APPROVED = 1
PENDING = 2
DENIED = 3
STATUS_CHOICES = (
(APPROVED, _('Approved')),
(PENDING, _('Pending')),
(DENIED, _('Denied')),
)
user = models.ForeignKey('users.Profile')
project_category = models.ForeignKey('popcorn.ProjectCategory')
status = models.IntegerField(choices=STATUS_CHOICES, default=PENDING)
created = CreationDateTimeField()
modified = ModificationDateTimeField()
class Meta:
unique_together = ('user', 'project_category')
def __unicode__(self):
return u'%s membership for %s: %s' % (self.project_category, self.user,
self.get_status_display())
class Organization(ValidatedModelMixin, AnonymizationMixin, models.Model):
"""
Organizations can run Projects. An organization has one or more members.
"""
name = models.CharField(_('name'), max_length=255)
slug = models.SlugField(_('slug'), max_length=100)
description = models.TextField(_('description'), default='', blank=True)
created = CreationDateTimeField(_('created'))
updated = ModificationDateTimeField(_('updated'))
owner = models.ForeignKey(settings.AUTH_USER_MODEL,
verbose_name=_('owner'),
null=True)
website = models.URLField(_('website'), blank=True)
logo = ImageField(_('logo'),
blank=True,
help_text=_('Partner Organization Logo'),
max_length=255,
null=True,
upload_to='partner_organization_logos/')
required_fields = ['name', 'website']
def __str__(self):
return self.name
def save(self, *args, **kwargs):
self.slug = slugify(self.name)
super(Organization, self).save(*args, **kwargs)
class Meta(object):
ordering = ['name']
verbose_name = _("partner organization")
verbose_name_plural = _("partner organizations")
class Voting(models.Model): # Klausimas dėl kurio balsuojama
SEIMAS = 1
SAVIVALDYBE = 2
VOTING_TYPE_CHOICES = (
(SEIMAS, _('Seimo')),
(SAVIVALDYBE, _('Savivaldybės')),
)
created = CreationDateTimeField()
modified = ModificationDateTimeField()
author = models.ForeignKey(User, null=True, blank=True)
title = models.CharField(_("Pavadinimas"), max_length=255)
link = models.URLField(_("Nuoroda"))
description = models.TextField(_("Aprašymas"), blank=True)
datetime = models.DateTimeField(null=True, blank=True)
vid = models.CharField(_("Balsavimo ID"), max_length=20, blank=True)
question = models.CharField(_("Klausimas"), max_length=255, blank=True)
question_a = models.CharField(_("Klausimas A"), max_length=255, blank=True)
question_b = models.CharField(_("Klausimas B"), max_length=255, blank=True)
result = models.CharField(_("Rezultatas"), max_length=40, blank=True)
sitting_no = models.CharField(_("Posėdžio Nr."), max_length=40, blank=True)
position = GenericRelation(Position, related_query_name='voting')
voting_type = models.PositiveSmallIntegerField(choices=VOTING_TYPE_CHOICES,
default=SAVIVALDYBE)
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('topic-details', args=[self.slug])
def get_result_string(self):
if self.question == '':
if self.result == 'pritarta formuluotei A':
return self.question_a
elif self.result == 'pritarta formuluotei B':
return self.question_b
return self.result
class DeletedTicket(models.Model):
delete_on = CreationDateTimeField(editable=False)
delete_reason = models.CharField(_("Przyczyna skasowania"),
max_length=1024,
null=False,
blank=False)
code = models.CharField(_("Kod Biletu"), max_length=16, primary_key=True)
description = models.CharField(_("Opis"),
max_length=128,
db_index=True,
blank=True,
null=True)
hospital = models.ForeignKey(Hospital,
verbose_name=_("Szpital"),
on_delete=models.CASCADE)
bed = models.ForeignKey(Bed,
verbose_name=_("Łóżko"),
on_delete=models.CASCADE,
null=True)
respirator = models.BooleanField(_("Potrzebny Respirator"))
oxygen = models.BooleanField(_("Potrzebny Tlen"))
child = models.BooleanField(_("Potrzebne Łóżko Dziecięce"))
use_respirator = models.BooleanField(_("Użyty Mobilny Respirator"))
use_oxygen = models.BooleanField(_("Użyty Mobilny Tlen"))
expiration_date = models.DateTimeField(_("Data Ważności"),
null=True,
blank=True)
canceled = models.BooleanField(_("Anulowane"))
canceled_reason = models.TextField(_("Przyczyna Anulowania"),
null=True,
blank=True)
created_on = models.DateTimeField()
last_modified_on = models.DateTimeField()
prev = models.ForeignKey("DeletedTicket",
null=True,
editable=False,
on_delete=models.CASCADE)
