it/itf/boxes/models.py

242 lines
6.0 KiB
Python
Raw Normal View History

2011-04-04 01:35:25 +00:00
from django.db import models
from django.contrib.contenttypes.models import ContentType
from app.models import ItfModel
from django.contrib.contenttypes import generic
'''
Classes that need to link to a ContentType should link to ModelExtra instead. Maybe there's a better way to do this?
'''
class ModelExtra(models.Model):
model = models.OneToOneField(ContentType)
friendly_name = models.CharField(max_length=255, blank=True, null=True)
friendly_name_plural = models.CharField(max_length=255, blank=True, null=True)
sort_options = models.ManyToManyField("ModelSort", blank=True, null=True)
2011-04-09 19:45:31 +00:00
has_comments = models.BooleanField(default=False)
2011-04-04 01:35:25 +00:00
def __unicode__(self):
return "%d: %s" % (self.id, self.friendly_name)
def get_dict(self):
return {
2011-04-09 00:51:31 +00:00
'id': self.id,
2011-04-04 01:35:25 +00:00
'module': self.model.model_class()._meta.app_label,
2011-04-10 02:00:43 +00:00
'model': self.model.model_class().__name__,
2011-04-09 19:45:31 +00:00
'has_comments': self.has_comments,
2011-04-04 01:35:25 +00:00
# 'info': self.info,
'friendly_name': self.friendly_name,
'friendly_name_plural': self.friendly_name_plural,
'fk_filters': self.model.model_class().fk_filters,
'fts_fields': self.model.model_class().fts_fields,
2011-04-09 19:45:31 +00:00
'sort_options': map(lambda x: {'key': x.key, 'operator': x.operator, 'text': x.text}, self.sort_options.all())
2011-04-04 01:35:25 +00:00
}
class ModelSort(models.Model):
2011-04-09 19:45:31 +00:00
operator = models.CharField(max_length=4)
key = models.CharField(max_length=64)
text = models.CharField(max_length=256)
2011-04-04 01:35:25 +00:00
def __unicode__(self):
2011-04-09 19:45:31 +00:00
return "%s%s: %s" % (self.operator, self.key, self.text,)
2011-04-04 01:35:25 +00:00
"""
Base class for buttons - buttons can be an 'extra_button' for either a Box class or an instance of a model (defined in ModelExtra).
"""
class Button(ItfModel):
typ = ''
icon = models.CharField(max_length=255) #FIXME: read choices from list of icons
mouseover = models.CharField(max_length=255)
class Meta:
abstract = True
def __unicode__(self):
return "%d: %s" % (self.id, self.mouseover)
def get_dict(self):
data = self.get_data()
2011-04-09 00:51:31 +00:00
data['id'] = self.id,
2011-04-04 01:35:25 +00:00
data['type'] = self.typ,
data['icon'] = self.icon,
data['mouseover'] = self.mouseover
return data
'''
Subclasses need to implement get_data and return additional data-items as a dict. Keys cannot be one of 'type', 'icon', and 'mouseover' in the return value.
'''
def get_data(self):
return {}
class BoxButton(Button):
class Meta:
abstract = True
class ModelButton(Button):
class Meta:
abstract = True
class DialogButton(BoxButton):
typ = 'dialog'
dialogTitle = models.CharField(max_length=255)
dialogHTML = models.TextField()
def get_data(self):
return {
'title': self.dialogTitle,
'html': self.dialogHTML
}
class StaticDownloadButton(BoxButton):
typ = 'staticDownload'
fil = models.FileField(upload_to='uploads/button_downloads/')
def get_data(self):
return {
'file': {
'path': self.fil.url
}
}
class ModelDownloadButton(ModelButton):
typ = 'modelDownload'
file_field = models.CharField(max_length=100) #name of field which holds the file/s(?) to be downloaded
def get_data(self):
return {
'file': {
'path': self.fil.url
}
}
"""
Join model to enable m2m relations to generic foreign keys
"""
class ExtraButton(models.Model):
related_name = models.CharField(max_length=255, blank=True, null=True)
button_content_type = models.ForeignKey(ContentType)
button_id = models.PositiveIntegerField()
button = generic.GenericForeignKey('button_content_type', 'button_id')
def __unicode__(self):
return "%d: %s" % (self.id, self.related_name)
def get_dict(self):
return self.button.get_dict()
"""
Join model
"""
class PanelBoxes(models.Model):
related_name = models.CharField(max_length=255, blank=True, null=True)
box_content_type = models.ForeignKey(ContentType)
box_id = models.PositiveIntegerField()
box = generic.GenericForeignKey("box_content_type", "box_id")
def __unicode__(self):
return "%d: %s" % (self.id, self.related_name)
def get_dict(self):
return self.box.get_dict()
class Meta:
verbose_name = "Panel box"
verbose_name_plural = "Panel boxes"
'''
Abstract base-class for boxes.
'''
class Box(ItfModel):
title = models.CharField(max_length=256)
extra_buttons = models.ManyToManyField("ExtraButton", blank=True, null=True)
2011-04-09 19:45:31 +00:00
logo = models.ImageField(upload_to="upload/box_logos/", blank=True, null=True)
2011-04-04 01:35:25 +00:00
class Meta:
abstract = True
def render():
return ''
def __unicode__(self):
return "%d: %s" % (self.id, self.title)
def _get_buttons(self):
ret = []
for b in self.extra_buttons.all():
ret.append(b.button.get_dict())
return ret
def get_dict(self):
return {}
class StaticBox(Box):
html = models.TextField(blank=True, null=True)
def get_dict(self):
return {
2011-04-09 00:51:31 +00:00
'id': self.id,
2011-04-04 01:35:25 +00:00
'type': 'StaticBox',
'title': self.title,
'html': self.html,
'extra_buttons': self._get_buttons()
}
class ModelsBox(Box):
default_model = models.ForeignKey(ModelExtra)
view_models = models.ManyToManyField(ModelExtra, related_name="box_views", blank=True, null=True)
info = models.TextField(blank=True)
@property
def module(self):
return self.default_model.app_label
def get_dict(self):
data = {
2011-04-09 00:51:31 +00:00
'id': self.id,
2011-04-04 01:35:25 +00:00
'type': 'ModelsBox',
'title': self.title,
'info': self.info,
'extra_buttons': self._get_buttons(),
'default_model': self.default_model.get_dict(),
'view_models': map(lambda x: x.get_dict(), self.view_models.all())
}
return data
class Panel(models.Model):
title = models.CharField(max_length=255)
boxes = models.ManyToManyField("PanelBoxes", blank=True, null=True)
enabled = models.BooleanField(default=False)
displayed = models.BooleanField(default=False)
def __unicode__(self):
return self.title
def get_dict(self):
return {
2011-04-09 00:51:31 +00:00
'id': self.id,
2011-04-04 01:35:25 +00:00
'title': self.title,
'boxes': map(lambda x: x.get_dict(), self.boxes.all())
}
2011-04-08 20:15:51 +00:00
'''
class Page(models.Model):
class Meta:
abstract = True
'''