class AppRequest(models.Model):
request = models.ForeignKey(Request, db_index=True)
appid = models.CharField(max_length=38, db_index=True)
version = VersionField(help_text='Format: 255.255.65535.65535',
number_bits=(8, 8, 16, 16), default=0, null=True, blank=True)
nextversion = VersionField(help_text='Format: 255.255.65535.65535',
number_bits=(8, 8, 16, 16), default=0, null=True, blank=True)
lang = models.CharField(max_length=40, null=True, blank=True)
tag = models.CharField(max_length=40, null=True, blank=True)
installage = models.SmallIntegerField(null=True, blank=True)
events = models.ManyToManyField(Event)
class SparkleVersion(BaseModel):
is_enabled = models.BooleanField(default=True)
is_critical = models.BooleanField(default=False)
app = models.ForeignKey(Application, on_delete=models.CASCADE)
channel = models.ForeignKey(Channel,
db_index=True,
on_delete=models.CASCADE)
version = VersionField(help_text='Format: 65535.65535',
number_bits=(16, 16),
db_index=True)
short_version = VersionField(help_text='Format: 255.255.65535.65535',
number_bits=(8, 8, 16, 16),
blank=True,
null=True)
minimum_system_version = VersionField(help_text='Format: 255.255.255',
number_bits=(8, 8, 8),
blank=True,
null=True)
release_notes = models.TextField(blank=True, null=True)
file = models.FileField(upload_to=version_upload_to,
null=True,
storage=public_read_storage)
file_size = models.PositiveIntegerField(null=True, blank=True)
dsa_signature = models.CharField(verbose_name='DSA signature',
max_length=140,
null=True,
blank=True)
objects = VersionManager()
class Meta:
index_together = (('app', 'channel'), )
unique_together = (('app', 'channel', 'version'), )
def __str__(self):
return "{app} {version}".format(app=self.app, version=self.version)
@property
def file_absolute_url(self):
return self.file.url
@property
def file_package_name(self):
return os.path.basename(self.file_absolute_url)
@property
def file_url(self):
return '%s/' % os.path.dirname(self.file_absolute_url)
@property
def size(self):
return self.file_size
class TestModel(models.Model):
name = models.CharField(max_length=30)
slug = ResolweSlugField(populate_from='name', unique_with='version')
version = VersionField(default='0.0.0')
class BaseModel(models.Model):
"""Abstract model that includes common fields for other models."""
class Meta:
"""BaseModel Meta options."""
abstract = True
unique_together = ('slug', 'version')
default_permissions = ()
#: URL slug
slug = AutoSlugField(populate_from='name',
unique_with='version',
editable=True,
max_length=100)
#: process version
version = VersionField(number_bits=VERSION_NUMBER_BITS, default='0.0.0')
#: object name
name = models.CharField(max_length=100)
#: creation date and time
created = models.DateTimeField(auto_now_add=True, db_index=True)
#: modified date and time
modified = models.DateTimeField(auto_now=True, db_index=True)
#: user that created the entry
contributor = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.PROTECT)
def __str__(self):
"""Format model name."""
return self.name
class TestModel(models.Model):
name = models.CharField(max_length=30)
slug = ResolweSlugField(populate_from="name", unique_with="version")
version = VersionField(default="0.0.0")
class Version(BaseModel):
is_enabled = models.BooleanField(default=True)
is_critical = models.BooleanField(default=False)
app = models.ForeignKey(Application, on_delete=models.CASCADE)
platform = models.ForeignKey(Platform,
db_index=True,
on_delete=models.CASCADE)
channel = models.ForeignKey(Channel,
db_index=True,
on_delete=models.CASCADE)
version = VersionField(help_text='Format: 255.255.65535.65535',
number_bits=(8, 8, 16, 16),
db_index=True)
release_notes = models.TextField(blank=True, null=True)
file = models.FileField(upload_to=_version_upload_to,
null=True,
storage=public_read_storage)
file_hash = models.CharField(verbose_name='Hash',
max_length=140,
null=True,
blank=True)
file_size = models.PositiveIntegerField(null=True, blank=True)
objects = VersionManager()
class Meta:
db_table = 'versions'
unique_together = (('app', 'platform', 'channel', 'version'), )
index_together = (('app', 'platform', 'channel', 'version'), )
ordering = ['id']
def __str__(self):
return "{app} {version}".format(app=self.app, version=self.version)
@property
def file_absolute_url(self):
url = furl(self.file.url)
if not url.scheme:
url = '%s%s' % (settings.OMAHA_URL_PREFIX, url)
return str(url)
@property
def file_package_name(self):
url = furl(self.file_absolute_url)
return os.path.basename(url.pathstr)
@property
def file_url(self):
url = furl(self.file_absolute_url)
if url.port and url.port != 80:
return '%s://%s:%d%s/' % (url.scheme, url.host, url.port,
os.path.dirname(url.pathstr))
else:
return '%s://%s%s/' % (url.scheme, url.host,
os.path.dirname(url.pathstr))
@property
def size(self):
return self.file_size
class BaseModel(models.Model):
"""Abstract model that includes common fields for other models."""
class Meta:
"""BaseModel Meta options."""
abstract = True
unique_together = ('slug', 'version')
default_permissions = ()
get_latest_by = 'version'
#: URL slug
slug = ResolweSlugField(populate_from='name',
unique_with='version',
max_length=100)
#: process version
version = VersionField(number_bits=VERSION_NUMBER_BITS, default='0.0.0')
#: object name
name = models.CharField(max_length=100)
#: creation date and time
created = models.DateTimeField(auto_now_add=True, db_index=True)
#: modified date and time
modified = models.DateTimeField(auto_now=True, db_index=True)
#: user that created the entry
contributor = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.PROTECT)
def __str__(self):
"""Format model name."""
return self.name
def save(self, *args, **kwargs):
"""Save the model."""
name_max_len = self._meta.get_field('name').max_length
if len(self.name) > name_max_len:
self.name = self.name[:(name_max_len - 3)] + '...'
for _ in range(MAX_SLUG_RETRIES):
try:
# Attempt to save the model. It may fail due to slug conflict.
with transaction.atomic():
super().save(*args, **kwargs)
break
except IntegrityError as error:
# Retry in case of slug conflicts.
if '{}_slug'.format(self._meta.db_table) in error.args[0]:
self.slug = None
continue
raise
else:
raise IntegrityError(
"Maximum number of retries exceeded during slug generation")
class ReleaseModel(models.Model):
version_txt = models.CharField('Version Number', max_length=20)
version = VersionField(verbose_name='Version as Int')
version_link = models.URLField('Link to Version Release Notes')
def save(self, *args, **kwargs):
if not self.version:
self.version = Version(self.version_txt)
super(ReleaseModel, self).save(*args, **kwargs)
class Request(models.Model):
os = models.ForeignKey(Os, null=True, blank=True)
hw = models.ForeignKey(Hw, null=True, blank=True)
version = VersionField(help_text='Format: 255.255.65535.65535', number_bits=(8, 8, 16, 16))
ismachine = models.PositiveSmallIntegerField(null=True, blank=True)
sessionid = models.CharField(max_length=40, null=True, blank=True)
userid = models.CharField(max_length=40, null=True, blank=True)
installsource = models.CharField(max_length=40, null=True, blank=True)
originurl = models.URLField(null=True, blank=True)
testsource = models.CharField(max_length=40, null=True, blank=True)
updaterchannel = models.CharField(max_length=10, null=True, blank=True)
created = models.DateTimeField(db_index=True, default=datetime_now, editable=False, blank=True)
ip = models.GenericIPAddressField(blank=True, null=True)
class Version(BaseModel):
is_enabled = models.BooleanField(default=True)
app = models.ForeignKey(Application)
platform = models.ForeignKey(Platform, db_index=True)
channel = models.ForeignKey(Channel, db_index=True)
version = VersionField(help_text='Format: 255.255.65535.65535',
number_bits=(8, 8, 16, 16),
db_index=True)
release_notes = models.TextField(blank=True, null=True)
file = models.FileField(upload_to=_version_upload_to)
file_hash = models.CharField(verbose_name='Hash',
max_length=140,
null=True,
blank=True)
file_size = models.PositiveIntegerField(null=True, blank=True)
objects = VersionManager()
class Meta:
db_table = 'versions'
unique_together = (('app', 'platform', 'channel', 'version'), )
index_together = (('app', 'platform', 'channel', 'version'), )
def __str__(self):
return "{app} {version}".format(app=self.app, version=self.version)
@property
def file_absolute_url(self):
return self.file.url
@property
def file_package_name(self):
return os.path.basename(self.file_absolute_url)
@property
def file_url(self):
return '%s/' % os.path.dirname(self.file_absolute_url)
class Version(models.Model):
name = models.CharField(max_length=255)
version_number = VersionField()
branch = models.ForeignKey(Branch)
class Asset(models.Model):
class Meta:
verbose_name = _("asset")
verbose_name_plural = _("assets")
author = models.ForeignKey(User, on_delete=models.CASCADE, verbose_name=_("author"))
application = models.ForeignKey('Application', on_delete=models.CASCADE, verbose_name=_("application"))
component = models.ForeignKey('Component', on_delete=models.CASCADE, null=True, verbose_name=_("component"))
license = models.ForeignKey('License', on_delete=models.SET_NULL, null=True, blank=False, verbose_name=_("license"))
original_author = models.CharField(max_length=255, null=True, blank=True, verbose_name=_("original author"))
creation_date = models.DateTimeField(null=True, blank=True, verbose_name=_("Originally created"))
title = models.CharField(max_length=255, verbose_name=_("title"))
notes = models.TextField(null=True, verbose_name=_("description"))
image = models.ImageField(upload_to=get_thumbnail_path, verbose_name=_("thumbnail"), null=True, blank=True)
big_image = models.ImageField(upload_to=get_big_image_path, verbose_name=_("larger image"), null=True, blank=True)
data = models.FileField(upload_to=get_data_path, verbose_name=_("data file"))
url = models.URLField(null=True, blank=True, verbose_name=_("URL"))
pub_date = models.DateTimeField(verbose_name=_("date published"))
version = VersionField(null=True, blank=True, number_bits=[8,8,8,8], verbose_name=_("asset version"))
app_version_min = VersionField(verbose_name=_("Minimum compatible application version"), null=True, blank=True, number_bits=[8,8,8,8])
app_version_max = VersionField(verbose_name=_("Maximum compatible application version"), null=True, blank=True, number_bits=[8,8,8,8])
tags = TaggableManager(blank=True, verbose_name=_("tags"))
num_votes = models.PositiveIntegerField(default=0)
votes = VotableManager(extra_field='num_votes')
def clean(self):
if self.component and self.data and not self.component.is_filename_allowed(self.data.name):
raise ValidationError(_("It is not allowed to upload files of this type for this component"))
if self.component and not self.component.big_image_allowed:
if self.big_image:
raise ValidationError(_("It is not allowed to upload big images for this component"))
if self.component and self.component.thumbnail_mandatory:
if not self.image and not (self.component and self.component.thumbnailer_name):
raise ValidationError(_("You should upload thumbnail file"))
super(Asset, self).clean()
def save(self, *args, **kwargs):
if self.data and not self.image and self.component:
thumbnailer = self.component.thumbnailer()
auto_thumbnail = None
if thumbnailer:
auto_thumbnail = thumbnailer.make_thumbnail(self.data)
elif self.big_image:
auto_thumbnail = thumbnail_from_big_image(self.big_image, size=self.component.max_thumbnail_size)
if auto_thumbnail:
# pass save=False because otherwise it would call save() recursively
self.image.save("auto_thumbnail.png", auto_thumbnail, save=False)
super(Asset,self).save(*args, **kwargs)
def get_tags(self):
return ", ".join([tag.name for tag in self.tags.all()])
def get_app_versions(self):
if not self.app_version_min and not self.app_version_max:
return pgettext_lazy("application version", "any")
if self.app_version_min and not self.app_version_max:
return pgettext_lazy("application version", ">= {}").format(self.app_version_min)
if not self.app_version_min and self.app_version_max:
return pgettext_lazy("application version", "<= {}").format(self.app_version_max)
return pgettext_lazy("application version", ">= {0} and <= {1}").format(self.app_version_min, self.app_version_max)
def get_filename(self):
return basename(self.data.name)
def get_comments_count(self):
ct = ContentType.objects.get_for_model(Asset)
return Comment.objects.filter(content_type=ct, object_pk=self.pk).count()
def __str__(self):
result = ""
if self.application:
result += str(self.application) + " "
if self.component:
result += self.component.title + " "
result += self.title
return result.encode('utf-8')
def __unicode__(self):
result = ""
if self.application:
result += str(self.application) + " "
if self.component:
result += self.component.title + " "
result += self.title
return result
class DummyModelCustomBit(models.Model):
version = VersionField(number_bits=(8, 16, 8))
class DummyModel(models.Model):
version = VersionField()
class PageVersion(MP_Node):
hidden_page = models.OneToOneField(
'cms.Page',
on_delete=models.CASCADE,
verbose_name=_('Hidden Page'),
related_name='page_version',
help_text=_('This Page object holds the versioned '
'contents of this PageVersion.'))
draft = models.ForeignKey('cms.Page',
on_delete=models.CASCADE,
verbose_name=_('Draft'),
related_name='page_versions',
help_text=_('Current active draft.'))
version_id = VersionField(verbose_name=_("Version Id"),
null=True,
blank=True)
title = models.CharField(_('Version Title'), blank=True, max_length=63)
comment = models.TextField(
_('Version Comment'),
blank=True,
help_text=_('Particular information concerning this Version'))
active = models.BooleanField(
_('Active'),
default=False,
help_text=_(
'This the active version of current draft. There can be only one such '
'version per Page version tree.'))
dirty = models.BooleanField(
_('Dirty'),
default=False,
help_text=_(
'Only new PageVersions are not dirty of if a page has been reverted to a '
'PageVersion.'))
language = models.CharField(_('Language'), blank=True, max_length=20)
owner = models.CharField(_("owner"),
max_length=constants.PAGE_USERNAME_MAX_LENGTH,
editable=False,
default='script')
@property
def get_title(self):
return self.hidden_page.get_title(self.language)
@property
def get_full_title(self):
return '{page} - {lang} [{ver} - {title}]'.format(
page=self.get_title,
lang=self.language,
ver=self.version_id,
title=self.title[:30])
@property
def get_revision_view_url(self):
return reverse('djangocms_reversion2:view_revision2',
kwargs={'revision_pk': self.id})
@property
def get_revision_public_url(self):
if self.hidden_page and self.hidden_page.get_public_object():
return self.hidden_page.get_public_url(language=self.language)
@property
def get_draft_url(self):
return self.draft.get_draft_url(language=self.language)
@property
def get_draft_public_url(self):
return self.draft.get_public_url(language=self.language)
@property
def latest_version(self):
latest_version = PageVersion.get_latest_version(language=self.language,
draft=self.draft)
if latest_version and latest_version.version_id:
return latest_version
@property
def is_latest_version(self):
return self == self.latest_version
# Main Class Queries here
# -----------------------
@classmethod
def get_versions(cls,
language,
hidden_page=None,
draft=None,
order_by='-id'):
if hidden_page and not draft:
page_versions = cls.objects.filter(
hidden_page=hidden_page.get_draft_object(), language=language)
if page_versions.exists():
draft = page_versions.first().draft
if draft and hasattr(draft, 'get_draft_object'):
draft = draft.get_draft_object()
if draft:
return cls.objects.filter(draft=draft,
language=language).order_by(order_by)
@classmethod
def get_latest_version(cls, language, hidden_page=None, draft=None):
page_versions = cls.get_versions(language,
hidden_page=hidden_page,
draft=draft)
if page_versions and page_versions.exists():
return page_versions.first()
@classmethod
def get_latest_version_id(cls, language, hidden_page=None, draft=None):
latest_version = cls.get_latest_version(language,
hidden_page=hidden_page,
draft=draft)
if latest_version and latest_version.version_id:
return latest_version.version_id
# Main Method to create a version
# -------------------------------
@classmethod
def create_version(cls,
draft,
language,
version_parent=None,
comment='',
title='',
version_id=None):
if draft.page_versions.filter(
active=True, dirty=False, language=language).count() > 0:
raise AssertionError('not dirty')
# Check that title is included if required -
if not title and not ALLOW_BLANK_TITLE:
raise AssertionError('Version Title cannot be blank')
# owner of the PageVersion is the last editor
from cms.utils.permissions import get_current_user
user = get_current_user()
if user:
try:
owner = force_text(user)
except AttributeError:
# AnonymousUser may not have USERNAME_FIELD
owner = "anonymous"
else:
# limit changed_by and created_by to avoid problems with Custom User Model
if len(owner) > constants.PAGE_USERNAME_MAX_LENGTH:
owner = u'{0}... (id={1})'.format(
owner[:constants.PAGE_USERNAME_MAX_LENGTH - 15],
user.pk)
else:
owner = "script"
if isinstance(user, string_types):
from cms.models import User
user = User.objects.get(username=user)
hidden_page = revise_page(draft, language, user, version_id)
if not version_parent and draft.page_versions.filter(
language=language).exists():
version_parent = draft.page_versions.get(active=True,
language=language)
if version_parent:
page_version = version_parent.add_child(
hidden_page=hidden_page,
draft=draft,
comment=comment,
title=title,
version_id=version_id,
active=version_parent.active,
language=language,
owner=owner)
version_parent.deactivate()
else:
page_version = PageVersion.add_root(hidden_page=hidden_page,
draft=draft,
comment=comment,
title=title,
version_id=version_id,
active=True,
language=language,
owner=owner)
return page_version
def save(self, **kwargs):
self.title = self.title or self.generate_title()
self.comment = self.comment or self.generate_comment()
super(PageVersion, self).save(**kwargs)
def generate_title(self):
return ''
def generate_comment(self):
return ''
@property
def username(self):
return self.hidden_page.changed_by
def deactivate(self, commit=True):
self.active = False
if commit:
self.save()
deactivate.alters_data = True
def __str__(self):
if self.title:
return self.title
return self.hidden_page.get_title()
class Meta:
# example: user.has_perm('djangocms_reversion2.view_page_version')
# permissions = (
# ('view_page_version', _('permission to view the page version')),
# ('delete_page_version', _('permission to delete the page version')),
# ('create_page_version', _('permission to create the page version')),
# ('edit_page_version', _('permission to edit a page version')),
# ('revert_to_page_version', _('permission to revert a page to the page version')),
# )
default_permissions = () #'add', 'change', 'delete')
class Agreement(ChoicesDescriptorMixin, TimeStampedModel):
name = models.CharField(
verbose_name='Name',
max_length=100,
)
description = models.CharField(
verbose_name='Agreement description',
max_length=100,
blank=True,
null=True,
)
file_name = models.CharField(
verbose_name='Agreement file name',
max_length=200,
)
document_name = models.CharField(
default=settings.BRAND_NAME + ' Agreement v',
verbose_name='Agreement document name',
max_length=200,
)
version = VersionField()
recipient = models.CharField(
max_length=1,
default=settings.AGREEMENT_RECIPIENT_DEFAULT,
choices=settings.AGREEMENT_RECIPIENT,
blank=False,
null=False,
)
status = models.CharField(
max_length=1,
default=settings.AGREEMENT_STATUS_DEFAULT,
choices=settings.AGREEMENT_STATUS,
blank=False,
null=False,
)
domain = models.CharField(
max_length=1,
default=settings.AGREEMENT_DOMAIN_DEFAULT,
choices=settings.AGREEMENT_DOMAIN_CHOICES,
)
CHOICES_DESCRIPTOR_FIELDS = ['status', 'domain']
objects = AgreementManager()
def __str__(self):
return '{} for {} - {}'.format(
self.name,
self.get_recipient_display(),
self.get_status_display(),
)
@property
def date_cancelled(self):
return self.modified if self.is_cancelled else None
@property
def date_activation(self):
return self.modified if self.is_active else None
@property
def html(self):
return render_to_string(self.template_name)
@property
def template_name(self):
return '{}/{}'.format(
settings.AGREEMENT_TEMPLATE_FOLDER,
self.file_name,
)
@property
def file_url(self):
version = str(self.version).split('.')[0]
return static(
'{}/{}{}.pdf'.format(
settings.AGREEMENT_TEMPLATE_FOLDER,
self.document_name,
version,
), )
def set_status(self, status):
self.status = status
self.save(update_fields=['status', 'modified'])
def cancel_old_agreements(self):
Agreement.objects.filter_by_status_active().filter(
recipient=self.recipient, ).update(
status=settings.AGREEMENT_STATUS_CANCELLED)
def activate(self):
self.cancel_old_agreements()
self.set_status(settings.AGREEMENT_STATUS_ACTIVE)
