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)