class Migration(migrations.Migration):
dependencies = [
('contenttypes', '0002_remove_content_type_name'),
('dashboard', '0049_auto_20180421_1429'),
]
operations = [
migrations.AlterModelOptions(
name='notification',
options={
'get_latest_by': ['-updated_at'],
'ordering': ['-updated_at']
},
),
migrations.RenameField(
model_name='notification',
old_name='title',
new_name='subject',
),
migrations.RemoveField(
model_name='customuser',
name='is_claim_admin',
),
migrations.RemoveField(
model_name='customuser',
name='is_insurance_admin',
),
migrations.RemoveField(
model_name='customuser',
name='is_payment_admin',
),
migrations.RemoveField(
model_name='customuser',
name='is_project_admin',
),
migrations.RemoveField(
model_name='customuser',
name='is_variation_admin',
),
migrations.RemoveField(
model_name='notification',
name='body',
),
migrations.RemoveField(
model_name='notification',
name='notification_type',
),
migrations.RemoveField(
model_name='notification',
name='project',
),
migrations.AddField(
model_name='notification',
name='content_type',
field=models.ForeignKey(
default=1,
on_delete=django.db.models.deletion.CASCADE,
to='contenttypes.ContentType'),
preserve_default=False,
),
migrations.AddField(
model_name='notification',
name='message',
field=models.TextField(default='Default message',
verbose_name='Notification message'),
preserve_default=False,
),
migrations.AddField(
model_name='notification',
name='object_id',
field=models.PositiveIntegerField(default=1),
preserve_default=False,
),
]
class TextPost(Post): content = models.TextField()
class Migration(migrations.Migration):
initial = True
dependencies = [
('task_category', '0001_initial'),
('task_profile', '0001_initial'),
('location', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Task',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('details', models.TextField()),
('frequency', models.CharField(max_length=7)),
('size', models.CharField(max_length=6)),
('is_confirmed', models.BooleanField()),
('status', models.CharField(max_length=10)),
('timestamp_created', models.DateTimeField(auto_now_add=True)),
('timestamp_confirmed',
models.DateTimeField(blank=True, null=True)),
('category',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='task_category',
to='task_category.Category')),
('customer',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='task_customer',
to='task_profile.CustomerProfile')),
('location',
models.OneToOneField(
on_delete=django.db.models.deletion.CASCADE,
related_name='task_location',
to='location.TaskLocation')),
('subcategory',
models.ForeignKey(blank=True,
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name='task_subcategory',
to='task_category.Subcategory')),
('tasker',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='task_tasker',
to='task_profile.TaskerProfile')),
],
),
migrations.CreateModel(
name='TaskTransaction',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('status', models.CharField(max_length=10)),
('timestamp_completed',
models.DateTimeField(blank=True, null=True)),
('date', models.DateField(blank=True, null=True)),
('timestamp_started',
models.DateTimeField(blank=True, null=True)),
('task',
models.ForeignKey(blank=True,
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name='tasktransaction_task',
to='task.Task')),
],
),
migrations.CreateModel(
name='Rating',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('rating', models.FloatField()),
('timestamp_created', models.DateTimeField(auto_now_add=True)),
('review', models.TextField(blank=True, null=True)),
('customer',
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
related_name='rating_customer',
to='task_profile.CustomerProfile')),
('tasker',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='rating_tasker',
to='task_profile.TaskerProfile')),
],
),
migrations.CreateModel(
name='Message',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('message', models.TextField()),
('timestamp_created', models.DateTimeField(auto_now_add=True)),
('customer',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='message_customer',
to='task_profile.CustomerProfile')),
('task',
models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
related_name='message_task',
to='task.Task')),
('tasker',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='message_tasker',
to='task_profile.TaskerProfile')),
],
),
]
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name='Author',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('first_name', models.CharField(blank='True', max_length=100)),
('last_name', models.CharField(blank='True', max_length=100)),
],
options={
'verbose_name_plural': 'Авторы',
'verbose_name': 'Автор',
},
),
migrations.CreateModel(
name='New',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('title', models.CharField(blank='True', max_length=200)),
('post',
models.TextField(blank='True',
verbose_name='Описание новости')),
('date', models.DateTimeField(blank='True')),
('image', models.ImageField(upload_to='media/')),
('author',
models.ForeignKey(
on_delete=django.db.models.deletion.DO_NOTHING,
to='news.Author')),
],
options={
'verbose_name_plural': 'Новости',
'verbose_name': 'Новость',
},
),
migrations.CreateModel(
name='Tag',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('title',
models.CharField(blank='True',
max_length=30,
verbose_name='название')),
('short_name',
models.CharField(blank=True,
max_length=10,
null=True,
verbose_name='краткое название')),
],
options={
'verbose_name_plural': 'Тэги',
'verbose_name': 'Тэг',
},
),
migrations.CreateModel(
name='Trends',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('trend_name',
models.ForeignKey(
on_delete=django.db.models.deletion.DO_NOTHING,
to='news.New')),
],
options={
'verbose_name_plural': 'Популярные',
'verbose_name': 'Популярное',
},
),
migrations.AddField(
model_name='new',
name='tags',
field=models.ManyToManyField(blank=True,
related_name='posts',
to='news.Tag',
verbose_name='тэги'),
),
]
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Champion',
fields=[
('id',
models.AutoField(verbose_name='ID',
primary_key=True,
auto_created=True,
serialize=False)),
('name',
models.CharField(verbose_name='nom',
max_length=100,
unique=True)),
('status',
models.CharField(verbose_name='statut',
max_length=100,
choices=[
('new', 'En attente de compilation'),
('pending', 'En cours de compilation'),
('ready', 'Compilé et prêt'),
('error', 'Erreur de compilation')
],
default='new')),
('deleted',
models.BooleanField(verbose_name='supprimé', default=False)),
('comment',
models.TextField(verbose_name='commentaire', blank=True)),
('ts',
models.DateTimeField(verbose_name='date', auto_now_add=True)),
('author',
models.ForeignKey(verbose_name='auteur',
related_name='champions',
to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'champion',
'ordering': ['-ts'],
'verbose_name_plural': 'champions',
},
),
migrations.CreateModel(
name='Map',
fields=[
('id',
models.AutoField(verbose_name='ID',
primary_key=True,
auto_created=True,
serialize=False)),
('name', models.CharField(verbose_name='nom', max_length=100)),
('official',
models.BooleanField(verbose_name='officielle',
default=False)),
('ts',
models.DateTimeField(verbose_name='date', auto_now_add=True)),
('author',
models.ForeignKey(verbose_name='auteur',
related_name='maps',
to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'carte',
'ordering': ['-official', '-ts'],
'verbose_name_plural': 'cartes',
},
),
migrations.CreateModel(
name='Match',
fields=[
('id',
models.AutoField(verbose_name='ID',
primary_key=True,
auto_created=True,
serialize=False)),
('status',
models.CharField(verbose_name='statut',
max_length=100,
choices=[('creating',
'En cours de création'),
('new', 'En attente de lancement'),
('pending', 'En cours de calcul'),
('done', 'Terminé')],
default='creating')),
('ts',
models.DateTimeField(default=django.utils.timezone.now,
verbose_name='date')),
('options',
models.CharField(verbose_name='options',
max_length=500,
default='{}')),
('file_options',
models.CharField(verbose_name='file_options',
max_length=500,
default='{}')),
('author',
models.ForeignKey(verbose_name='lancé par',
related_name='matches',
to=settings.AUTH_USER_MODEL)),
],
options={
'verbose_name': 'match',
'ordering': ['-ts'],
'verbose_name_plural': 'matches',
},
),
migrations.CreateModel(
name='MatchPlayer',
fields=[
('id',
models.AutoField(verbose_name='ID',
primary_key=True,
auto_created=True,
serialize=False)),
('score', models.IntegerField(verbose_name='score',
default=0)),
('champion',
models.ForeignKey(verbose_name='champion',
to='stechec.Champion')),
('match',
models.ForeignKey(verbose_name='match', to='stechec.Match')),
],
options={
'verbose_name': 'participant à un match',
'ordering': ['-match'],
'verbose_name_plural': 'participants à un match',
},
),
migrations.CreateModel(
name='Tournament',
fields=[
('id',
models.AutoField(verbose_name='ID',
primary_key=True,
auto_created=True,
serialize=False)),
('name', models.CharField(verbose_name='nom', max_length=100)),
('ts',
models.DateTimeField(verbose_name='date', auto_now_add=True)),
],
options={
'verbose_name': 'tournoi',
'ordering': ['-ts'],
'verbose_name_plural': 'tournois',
},
),
migrations.CreateModel(
name='TournamentMap',
fields=[
('id',
models.AutoField(verbose_name='ID',
primary_key=True,
auto_created=True,
serialize=False)),
('map',
models.ForeignKey(verbose_name='carte', to='stechec.Map')),
('tournament',
models.ForeignKey(verbose_name='tournoi',
to='stechec.Tournament')),
],
options={
'verbose_name': 'carte utilisée dans un tournoi',
'ordering': ['-tournament'],
'verbose_name_plural': 'cartes utilisées dans un tournoi',
},
),
migrations.CreateModel(
name='TournamentPlayer',
fields=[
('id',
models.AutoField(verbose_name='ID',
primary_key=True,
auto_created=True,
serialize=False)),
('score', models.IntegerField(verbose_name='score',
default=0)),
('champion',
models.ForeignKey(verbose_name='champion',
to='stechec.Champion')),
('tournament',
models.ForeignKey(verbose_name='tournoi',
to='stechec.Tournament')),
],
options={
'verbose_name': 'participant à un tournoi',
'ordering': ['-tournament', '-score'],
'verbose_name_plural': 'participants à un tournoi',
},
),
migrations.AddField(
model_name='tournament',
name='maps',
field=models.ManyToManyField(verbose_name='maps',
through='stechec.TournamentMap',
to='stechec.Map',
related_name='tournaments'),
),
migrations.AddField(
model_name='tournament',
name='players',
field=models.ManyToManyField(verbose_name='participants',
through='stechec.TournamentPlayer',
to='stechec.Champion',
related_name='tournaments'),
),
migrations.AddField(
model_name='match',
name='players',
field=models.ManyToManyField(verbose_name='participants',
through='stechec.MatchPlayer',
to='stechec.Champion',
related_name='matches'),
),
migrations.AddField(
model_name='match',
name='tournament',
field=models.ForeignKey(verbose_name='tournoi',
related_name='matches',
null=True,
blank=True,
to='stechec.Tournament'),
),
]
class Version(amo.models.OnChangeMixin, amo.models.ModelBase):
addon = models.ForeignKey('addons.Addon', related_name='versions')
license = models.ForeignKey('License', null=True)
releasenotes = PurifiedField()
approvalnotes = models.TextField(default='', null=True)
version = models.CharField(max_length=255, default='0.1')
version_int = models.BigIntegerField(null=True, editable=False)
nomination = models.DateTimeField(null=True)
reviewed = models.DateTimeField(null=True)
has_info_request = models.BooleanField(default=False)
has_editor_comment = models.BooleanField(default=False)
deleted = models.BooleanField(default=False)
supported_locales = models.CharField(max_length=255)
_developer_name = models.CharField(max_length=255,
default='',
editable=False)
source = models.FileField(upload_to=source_upload_path,
null=True,
blank=True)
# The order of those managers is very important: please read the lengthy
# comment above the Addon managers declaration/instanciation.
unfiltered = VersionManager(include_deleted=True)
objects = VersionManager()
class Meta(amo.models.ModelBase.Meta):
db_table = 'versions'
ordering = ['-created', '-modified']
def __init__(self, *args, **kwargs):
super(Version, self).__init__(*args, **kwargs)
self.__dict__.update(version_dict(self.version or ''))
def __unicode__(self):
return jinja2.escape(self.version)
def save(self, *args, **kw):
if not self.version_int and self.version:
v_int = version_int(self.version)
# Magic number warning, this is the maximum size
# of a big int in MySQL to prevent version_int overflow, for
# people who have rather crazy version numbers.
# http://dev.mysql.com/doc/refman/5.5/en/numeric-types.html
if v_int < 9223372036854775807:
self.version_int = v_int
else:
log.error('No version_int written for version %s, %s' %
(self.pk, self.version))
super(Version, self).save(*args, **kw)
return self
@classmethod
def from_upload(cls,
upload,
addon,
platforms,
send_signal=True,
source=None,
is_beta=False):
data = utils.parse_addon(upload, addon)
try:
license = addon.versions.latest().license_id
except Version.DoesNotExist:
license = None
max_len = cls._meta.get_field_by_name('_developer_name')[0].max_length
developer = data.get('developer_name', '')[:max_len]
v = cls.objects.create(addon=addon,
version=data['version'],
license_id=license,
_developer_name=developer,
source=source)
log.info('New version: %r (%s) from %r' % (v, v.id, upload))
AV = ApplicationsVersions
for app in data.get('apps', []):
AV(version=v, min=app.min, max=app.max, application=app.id).save()
if addon.type == amo.ADDON_SEARCH:
# Search extensions are always for all platforms.
platforms = [amo.PLATFORM_ALL.id]
else:
platforms = cls._make_safe_platform_files(platforms)
for platform in platforms:
File.from_upload(upload,
v,
platform,
parse_data=data,
is_beta=is_beta)
v.disable_old_files()
# After the upload has been copied to all platforms, remove the upload.
storage.delete(upload.path)
if send_signal:
version_uploaded.send(sender=v)
return v
@classmethod
def _make_safe_platform_files(cls, platforms):
"""Make file platform translations until all download pages
support desktop ALL + mobile ALL. See bug 646268.
Returns platforms ids.
"""
pl_set = set(platforms)
if pl_set == set((amo.PLATFORM_ALL.id, )):
# Make it really ALL:
return [amo.PLATFORM_ALL.id]
has_mobile = amo.PLATFORM_ANDROID in pl_set
has_desktop = any(p in amo.DESKTOP_PLATFORMS for p in pl_set)
has_all = amo.PLATFORM_ALL in pl_set
is_mixed = has_mobile and has_desktop
if (is_mixed and has_all) or has_mobile:
# Mixing desktop and mobile w/ ALL is not safe;
# we have to split the files into exact platforms.
new_plats = []
for platform in platforms:
if platform == amo.PLATFORM_ALL.id:
plats = amo.DESKTOP_PLATFORMS.keys()
plats.remove(amo.PLATFORM_ALL.id)
new_plats.extend(plats)
else:
new_plats.append(platform)
return new_plats
# Platforms are safe as is
return platforms
@property
def path_prefix(self):
return os.path.join(user_media_path('addons'), str(self.addon_id))
@property
def mirror_path_prefix(self):
return os.path.join(user_media_path('addons'), str(self.addon_id))
def license_url(self, impala=False):
return reverse('addons.license', args=[self.addon.slug, self.version])
def flush_urls(self):
return self.addon.flush_urls()
def get_url_path(self):
if not self.addon.is_listed: # Not listed? Doesn't have a public page.
return ''
return reverse('addons.versions', args=[self.addon.slug, self.version])
def delete(self):
log.info(u'Version deleted: %r (%s)' % (self, self.id))
amo.log(amo.LOG.DELETE_VERSION, self.addon, str(self.version))
super(Version, self).delete()
@property
def current_queue(self):
"""Return the current queue, or None if not in a queue."""
from editors.models import (ViewFullReviewQueue, ViewPendingQueue,
ViewPreliminaryQueue,
ViewUnlistedFullReviewQueue,
ViewUnlistedPendingQueue,
ViewUnlistedPreliminaryQueue)
if self.addon.status in [
amo.STATUS_NOMINATED, amo.STATUS_LITE_AND_NOMINATED
]:
return (ViewFullReviewQueue
if self.addon.is_listed else ViewUnlistedFullReviewQueue)
elif self.addon.status == amo.STATUS_PUBLIC:
return (ViewPendingQueue
if self.addon.is_listed else ViewUnlistedPendingQueue)
elif self.addon.status in [amo.STATUS_LITE, amo.STATUS_UNREVIEWED]:
return (ViewPreliminaryQueue
if self.addon.is_listed else ViewUnlistedPreliminaryQueue)
return None
@amo.cached_property(writable=True)
def all_activity(self):
from devhub.models import VersionLog # yucky
al = (VersionLog.objects.filter(
version=self.id).order_by('created').select_related(
'activity_log', 'version').no_cache())
return al
@amo.cached_property(writable=True)
def compatible_apps(self):
"""Get a mapping of {APP: ApplicationVersion}."""
avs = self.apps.select_related('versions', 'license')
return self._compat_map(avs)
@amo.cached_property
def compatible_apps_ordered(self):
apps = self.compatible_apps.items()
return sorted(apps, key=lambda v: v[0].short)
def compatible_platforms(self):
"""Returns a dict of compatible file platforms for this version.
The result is based on which app(s) the version targets.
"""
app_ids = [a.application for a in self.apps.all()]
targets_mobile = amo.ANDROID.id in app_ids
targets_other = any((id_ != amo.ANDROID.id) for id_ in app_ids)
all_plats = {}
if targets_other:
all_plats.update(amo.DESKTOP_PLATFORMS)
if targets_mobile:
all_plats.update(amo.MOBILE_PLATFORMS)
return all_plats
@amo.cached_property
def is_compatible(self):
"""Returns tuple of compatibility and reasons why if not.
Server side conditions for determining compatibility are:
* The add-on is an extension (not a theme, app, etc.)
* Has not opted in to strict compatibility.
* Does not use binary_components in chrome.manifest.
Note: The lowest maxVersion compat check needs to be checked
separately.
Note: This does not take into account the client conditions.
"""
compat = True
reasons = []
if self.addon.type != amo.ADDON_EXTENSION:
compat = False
# TODO: We may want this. For now we think it may be confusing.
# reasons.append(_('Add-on is not an extension.'))
if self.files.filter(binary_components=True).exists():
compat = False
reasons.append(_('Add-on uses binary components.'))
if self.files.filter(strict_compatibility=True).exists():
compat = False
reasons.append(
_('Add-on has opted into strict compatibility '
'checking.'))
return (compat, reasons)
def is_compatible_app(self, app):
"""Returns True if the provided app passes compatibility conditions."""
appversion = self.compatible_apps.get(app)
if appversion and app.id in amo.D2C_MAX_VERSIONS:
return (version_int(appversion.max.version) >= version_int(
amo.D2C_MAX_VERSIONS.get(app.id, '*')))
return False
def compat_override_app_versions(self):
"""Returns the incompatible app versions range(s).
If not ranges, returns empty list. Otherwise, this will return all
the app version ranges that this particular version is incompatible
with.
"""
from addons.models import CompatOverride
cos = CompatOverride.objects.filter(addon=self.addon)
if not cos:
return []
app_versions = []
for co in cos:
for range in co.collapsed_ranges():
if (version_int(range.min) <= version_int(self.version) <=
version_int(range.max)):
app_versions.extend([(a.min, a.max) for a in range.apps])
return app_versions
@amo.cached_property(writable=True)
def all_files(self):
"""Shortcut for list(self.files.all()). Heavily cached."""
return list(self.files.all())
@amo.cached_property
def supported_platforms(self):
"""Get a list of supported platform names."""
return list(set(amo.PLATFORMS[f.platform] for f in self.all_files))
@property
def status(self):
return [f.STATUS_CHOICES[f.status] for f in self.all_files]
@property
def statuses(self):
"""Unadulterated statuses, good for an API."""
return [(f.id, f.status) for f in self.all_files]
def is_allowed_upload(self):
"""
Check that a file can be uploaded based on the files
per platform for that type of addon.
"""
num_files = len(self.all_files)
if self.addon.type == amo.ADDON_SEARCH:
return num_files == 0
elif num_files == 0:
return True
elif amo.PLATFORM_ALL in self.supported_platforms:
return False
else:
compatible = (v for k, v in self.compatible_platforms().items()
if k != amo.PLATFORM_ALL.id)
return bool(set(compatible) - set(self.supported_platforms))
def is_public(self):
# To be public, a version must not be deleted, must belong to a public
# addon, and all its attached files must have public status.
try:
return (not self.deleted and self.addon.is_public()
and all(f.status == amo.STATUS_PUBLIC
for f in self.all_files))
except ObjectDoesNotExist:
return False
@property
def has_files(self):
return bool(self.all_files)
@property
def is_unreviewed(self):
return filter(lambda f: f.status in amo.UNREVIEWED_STATUSES,
self.all_files)
@property
def is_all_unreviewed(self):
return not bool([
f
for f in self.all_files if f.status not in amo.UNREVIEWED_STATUSES
])
@property
def is_beta(self):
return filter(lambda f: f.status == amo.STATUS_BETA, self.all_files)
@property
def is_lite(self):
return filter(lambda f: f.status in amo.LITE_STATUSES, self.all_files)
@property
def is_jetpack(self):
return all(f.jetpack_version for f in self.all_files)
@classmethod
def _compat_map(cls, avs):
apps = {}
for av in avs:
app_id = av.application
if app_id in amo.APP_IDS:
apps[amo.APP_IDS[app_id]] = av
return apps
@classmethod
def transformer(cls, versions):
"""Attach all the compatible apps and files to the versions."""
ids = set(v.id for v in versions)
if not versions:
return
# FIXME: find out why we have no_cache() here and try to remove it.
avs = (ApplicationsVersions.objects.filter(
version__in=ids).select_related('application', 'apps', 'min_set',
'max_set').no_cache())
files = File.objects.filter(version__in=ids).no_cache()
def rollup(xs):
groups = amo.utils.sorted_groupby(xs, 'version_id')
return dict((k, list(vs)) for k, vs in groups)
av_dict, file_dict = rollup(avs), rollup(files)
for version in versions:
v_id = version.id
version.compatible_apps = cls._compat_map(av_dict.get(v_id, []))
version.all_files = file_dict.get(v_id, [])
for f in version.all_files:
f.version = version
@classmethod
def transformer_activity(cls, versions):
"""Attach all the activity to the versions."""
from devhub.models import VersionLog # yucky
ids = set(v.id for v in versions)
if not versions:
return
al = (VersionLog.objects.filter(
version__in=ids).order_by('created').select_related(
'activity_log', 'version').no_cache())
def rollup(xs):
groups = amo.utils.sorted_groupby(xs, 'version_id')
return dict((k, list(vs)) for k, vs in groups)
al_dict = rollup(al)
for version in versions:
v_id = version.id
version.all_activity = al_dict.get(v_id, [])
def disable_old_files(self):
if not self.files.filter(status=amo.STATUS_BETA).exists():
qs = File.objects.filter(
version__addon=self.addon_id,
version__lt=self.id,
version__deleted=False,
status__in=[amo.STATUS_UNREVIEWED, amo.STATUS_PENDING])
# Use File.update so signals are triggered.
for f in qs:
f.update(status=amo.STATUS_DISABLED)
@property
def developer_name(self):
return self._developer_name
def reset_nomination_time(self, nomination=None):
if not self.nomination or nomination:
nomination = nomination or datetime.datetime.now()
# We need signal=False not to call update_status (which calls us).
self.update(nomination=nomination, _signal=False)
# But we need the cache to be flushed.
Version.objects.invalidate(self)
@property
def is_listed(self):
return self.addon.is_listed
@property
def unreviewed_files(self):
"""A File is unreviewed if:
- its status is in amo.UNDER_REVIEW_STATUSES or
- its addon status is in amo.UNDER_REVIEW_STATUSES
and its status is either in amo.UNDER_REVIEW_STATUSES or
amo.STATUS_LITE
"""
under_review_or_lite = amo.UNDER_REVIEW_STATUSES + (amo.STATUS_LITE, )
return self.files.filter(
models.Q(status__in=amo.UNDER_REVIEW_STATUSES)
| models.Q(version__addon__status__in=amo.UNDER_REVIEW_STATUSES,
status__in=under_review_or_lite))
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name='Bus',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('number',
models.IntegerField(
verbose_name='Номер государственной регистрации автобуса,'
)),
],
options={
'verbose_name': 'Автобус',
'verbose_name_plural': 'Автобусы',
},
),
migrations.CreateModel(
name='BusType',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('bus_type',
models.CharField(max_length=100,
verbose_name='Тип автобуса по габариам')),
('capacity', models.IntegerField(verbose_name='Вместимость')),
],
options={
'verbose_name': 'Тип автобуса',
'verbose_name_plural': 'Типы автобусов',
},
),
migrations.CreateModel(
name='Driver',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('fio', models.CharField(max_length=300, verbose_name='ФИО')),
('passport_number',
models.CharField(max_length=20,
verbose_name='Номер паспорта')),
('driver_class',
models.CharField(blank=True,
choices=[('1_класс', '1 Класс'),
('2_класс', '2 Класс'),
('3_класс', '3 Класс')],
max_length=20,
verbose_name='Водительский класс')),
('work_exp', models.IntegerField(verbose_name='Стаж работы')),
('salary', models.IntegerField(verbose_name='Оклад')),
],
options={
'verbose_name': 'Водитель',
'verbose_name_plural': 'Водители',
},
),
migrations.CreateModel(
name='Route',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('starting_point',
models.CharField(max_length=300,
verbose_name='Начальный пункт движения')),
('final_destination',
models.CharField(max_length=300,
verbose_name='Конечный пункт движения')),
('time_start',
models.TimeField(verbose_name='Время начала движения')),
('time_end',
models.TimeField(verbose_name='Время окончания движения')),
('interval_of_movement',
models.IntegerField(
verbose_name='Интервал движения в минутах')),
('length_in_min',
models.IntegerField(verbose_name='Протяженность в минутах')),
('length_in_km',
models.IntegerField(
verbose_name='Протяженность в километрах')),
],
options={
'verbose_name': 'Маршрут',
'verbose_name_plural': 'Маршруты',
},
),
migrations.CreateModel(
name='Schedule',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('day',
models.CharField(blank=True,
choices=[('Понедельник', 'Понедельник'),
('Вторник', 'Вторник'),
('Среда', 'Среда'),
('Четверг', 'Четверг'),
('Пятница', 'Пятница'),
('Суббота', 'Суббота'),
('Воскресенье', 'Воскресенье')],
max_length=20,
verbose_name='День недели')),
('bus',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to='bus_depot.Bus')),
('driver',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to='bus_depot.Driver')),
('route',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to='bus_depot.Route')),
],
options={
'verbose_name': 'График работы',
'verbose_name_plural': 'Графики работы',
},
),
migrations.CreateModel(
name='Journal',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('status',
models.CharField(blank=True,
choices=[('Вышел_на_линию',
'Вышел На Линию'),
('Не_вышел_на_линию',
'Не Вышел На Линию')],
max_length=20,
verbose_name='Статус')),
('comment',
models.TextField(blank=True, verbose_name='Комментарий')),
('schedule',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to='bus_depot.Schedule')),
],
options={
'verbose_name': 'Журнал',
'verbose_name_plural': 'Журнал',
},
),
migrations.AddField(
model_name='bus',
name='bus_type',
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
to='bus_depot.BusType'),
),
]
class Migration(migrations.Migration):
initial = True
dependencies = [
('home', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Category',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=140)),
('level', models.IntegerField(default=0)),
('parent', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='catalog.Category')),
],
),
migrations.CreateModel(
name='Product',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('sku', models.CharField(max_length=30, verbose_name='SKU')),
('title', models.CharField(max_length=140, verbose_name='title')),
('description', models.TextField(verbose_name='description')),
('price', models.BigIntegerField(verbose_name='price')),
('category', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='products', to='catalog.Category')),
],
),
migrations.CreateModel(
name='ProductProperty',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=40, verbose_name='name')),
('property_type', models.IntegerField(choices=[(0, b'Single Value')], default=0, verbose_name='property type')),
('product', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='properties', to='catalog.Product')),
],
options={
'verbose_name_plural': 'Product Properties',
},
),
migrations.CreateModel(
name='Subscription',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=140, verbose_name='name')),
('price', models.BigIntegerField(verbose_name='price')),
('deliveries', models.IntegerField()),
('valid_for_days', models.IntegerField(default=7)),
('products', models.ManyToManyField(related_name='subscriptions', to='catalog.Product')),
],
),
migrations.CreateModel(
name='Variant',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('price', models.BigIntegerField(blank=True, null=True, verbose_name='price')),
('quantity', models.BigIntegerField(default=0)),
('enabled', models.BooleanField(default=True)),
('product', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='variants', to='catalog.Product')),
('stores', models.ManyToManyField(to='home.Store')),
],
),
migrations.CreateModel(
name='VariantImage',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('image', models.ImageField(upload_to=b'media/images/products/')),
('variant', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='catalog.Variant')),
],
),
migrations.CreateModel(
name='VariantProperties',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('value', models.CharField(max_length=100, verbose_name='value')),
('product_property', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='catalog.ProductProperty')),
],
),
]
class Profile(models.Model):
NEW, TRUSTED, SUSPENDED, BANNED, SPAMMER = range(5)
STATE_CHOICES = [(NEW, "New"), (TRUSTED, "Active"), (SPAMMER, "Spammer"),
(SUSPENDED, "Suspended"), (BANNED, "Banned")]
state = models.IntegerField(default=NEW, choices=STATE_CHOICES, db_index=True)
READER, MODERATOR, MANAGER, BLOGGER = range(4)
ROLE_CHOICES = [
(READER, "Reader"), (MODERATOR, "Moderator"), (MANAGER, "Admin"),
(BLOGGER, "Blog User")
]
NO_DIGEST, DAILY_DIGEST, WEEKLY_DIGEST, MONTHLY_DIGEST, ALL_MESSAGES = range(5)
DIGEST_CHOICES = [(NO_DIGEST, 'Never'), (DAILY_DIGEST, 'Daily'),
(WEEKLY_DIGEST, 'Weekly'), (MONTHLY_DIGEST, 'Monthly'),
(ALL_MESSAGES, "Email for every new thread (mailing list mode)")
]
# Subscription to daily and weekly digests.
digest_prefs = models.IntegerField(choices=DIGEST_CHOICES, default=WEEKLY_DIGEST)
LOCAL_MESSAGE, EMAIL_MESSAGE, NO_MESSAGES, DEFAULT_MESSAGES = range(4)
MESSAGING_TYPE_CHOICES = [
(DEFAULT_MESSAGES, "Default"),
(EMAIL_MESSAGE, "Email"),
(LOCAL_MESSAGE, "Local Messages"),
(NO_MESSAGES, "No messages"),
]
# Default subscriptions inherit from this
message_prefs = models.IntegerField(choices=MESSAGING_TYPE_CHOICES, default=DEFAULT_MESSAGES)
# Connection to the user.
user = models.OneToOneField(User, on_delete=models.CASCADE)
# User unique id (handle)
uid = models.CharField(max_length=MAX_UID_LEN, unique=True)
# User diplay name.
name = models.CharField(max_length=MAX_NAME_LEN, default='', db_index=True)
# Maximum amount of uploaded files a user is allowed to aggregate, in mega-bytes.
max_upload_size = models.IntegerField(default=0)
# The role of the user.
role = models.IntegerField(default=READER, choices=ROLE_CHOICES)
# The date the user last logged in.
last_login = models.DateTimeField(null=True, max_length=255, db_index=True)
# The number of new messages for the user.
new_messages = models.IntegerField(default=0, db_index=True)
# The last visit by the user.
date_joined = models.DateTimeField(auto_now_add=True, max_length=255)
# User provided location.
location = models.CharField(default="", max_length=255, blank=True, db_index=True)
# User provided website.
website = models.URLField(default="", max_length=255, blank=True)
# Google scholar ID
scholar = models.CharField(default="", max_length=255, blank=True)
# User reputation score.
score = models.IntegerField(default=0, db_index=True)
# Twitter ID
twitter = models.CharField(default="", max_length=255, blank=True)
# This field is used to select content for the user.
my_tags = models.CharField(default="", max_length=MAX_TEXT_LEN, blank=True)
# The tag value is the canonical form of the post's tags
watched_tags = models.CharField(max_length=MAX_TEXT_LEN, default="", blank=True)
# Description provided by the user html.
text = models.TextField(default="No profile information", null=True, max_length=MAX_TEXT_LEN, blank=True)
# The html version of the user information.
html = models.TextField(null=True, max_length=MAX_TEXT_LEN, blank=True)
# The state of the user email verfication.
email_verified = models.BooleanField(default=False)
# Automatic notification
notify = models.BooleanField(default=False)
# Opt-in to all messages from the site
opt_in = models.BooleanField(default=False)
def __str__(self):
return self.name
def save(self, *args, **kwargs):
self.uid = self.uid or util.get_uuid(8)
self.html = self.html or mistune.markdown(self.text)
self.max_upload_size = self.max_upload_size or self.get_upload_size()
self.name = self.name or self.user.first_name or self.user.email.split("@")[0]
self.date_joined = self.date_joined or now()
self.last_login = self.last_login or now() #- timedelta(days=1)
super(Profile, self).save(*args, **kwargs)
@property
def state_dict(self):
return dict(self.STATE_CHOICES)
def get_upload_size(self):
# Admin users upload limit
if self.user.is_superuser or self.user.is_staff:
return settings.ADMIN_UPLOAD_SIZE
# Trusted users upload limit
if self.user.profile.trusted:
return settings.TRUSTED_UPLOAD_SIZE
# Get the default upload limit
return settings.MAX_UPLOAD_SIZE
def require_recaptcha(self):
"""Check to see if this user requires reCAPTCHA"""
is_required = not (self.trusted or self.score > settings.RECAPTCHA_THRESHOLD_USER_SCORE)
return is_required
def get_score(self):
"""
"""
score = self.score * 10
return score
@property
def is_moderator(self):
# Managers can moderate as well.
return self.role == self.MODERATOR or self.role == self.MANAGER or self.user.is_staff or self.user.is_superuser
@property
def trusted(self):
return (self.user.is_staff or self.state == self.TRUSTED or
self.role == self.MODERATOR or self.role == self.MANAGER or self.user.is_superuser)
@property
def is_manager(self):
return self.role == self.MANAGER
def get_absolute_url(self):
return reverse('user_profile', kwargs=dict(uid=self.uid))
@property
def is_suspended(self):
return self.state == self.SUSPENDED
@property
def is_banned(self):
return self.state == self.BANNED
@property
def is_spammer(self):
return self.state == self.SPAMMER
@property
def is_valid(self):
"""
User is not banned, suspended, or banned
"""
return not self.is_spammer and not self.is_suspended and not self.is_banned
@property
def recently_joined(self):
"""
User that joined X amount of days are considered new.
"""
recent = (util.now() - self.date_joined).days > settings.RECENTLY_JOINED_DAYS
return recent
@property
def low_rep(self):
"""
User has a low score
"""
return self.score <= settings.LOW_REP_THRESHOLD and not self.is_moderator
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('reviews', '0002_auto_20200331_0956'),
]
operations = [
migrations.CreateModel(
name='Comment',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('content', models.TextField(verbose_name='comment content')),
('date_created',
models.DateTimeField(auto_now_add=True,
verbose_name='created time')),
('date_modified',
models.DateTimeField(auto_now=True, verbose_name='modified')),
('idComment',
models.ForeignKey(blank=True,
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name='fk_Comment_to_Comment',
to='reviews.Comment')),
('idReview',
models.ForeignKey(blank=True,
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name='fk_Comment_to_Review',
to='reviews.Review')),
('idUser',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='fk_Comment_to_User',
to=settings.AUTH_USER_MODEL)),
],
options={
'ordering': ['-id'],
},
),
migrations.CreateModel(
name='Like',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('idComment',
models.ForeignKey(blank=True,
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name='fk_Like_to_Comment',
to='reviews.Comment')),
('idReview',
models.ForeignKey(blank=True,
null=True,
on_delete=django.db.models.deletion.CASCADE,
related_name='fk_Like_to_Review',
to='reviews.Review')),
('idUser',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
related_name='fk_Like_to_User',
to=settings.AUTH_USER_MODEL)),
],
options={
'ordering': ['-id'],
},
),
]
class NodeSettings(BaseOAuthNodeSettings, BaseStorageAddon):
oauth_provider = S3Provider
serializer = S3Serializer
folder_id = models.TextField(blank=True, null=True)
folder_name = models.TextField(blank=True, null=True)
encrypt_uploads = models.BooleanField(default=ENCRYPT_UPLOADS_DEFAULT)
user_settings = models.ForeignKey(UserSettings, null=True, blank=True, on_delete=models.CASCADE)
@property
def folder_path(self):
return self.folder_name
@property
def display_name(self):
return u'{0}: {1}'.format(self.config.full_name, self.folder_id)
def set_folder(self, folder_id, auth):
if not bucket_exists(self.external_account.oauth_key, self.external_account.oauth_secret, folder_id):
error_message = ('We are having trouble connecting to that bucket. '
'Try a different one.')
raise exceptions.InvalidFolderError(error_message)
self.folder_id = str(folder_id)
bucket_location = get_bucket_location_or_error(
self.external_account.oauth_key,
self.external_account.oauth_secret,
folder_id
)
try:
bucket_location = BUCKET_LOCATIONS[bucket_location]
except KeyError:
# Unlisted location, S3 may have added it recently.
# Default to the key. When hit, add mapping to settings
pass
self.folder_name = '{} ({})'.format(folder_id, bucket_location)
self.save()
self.nodelogger.log(action='bucket_linked', extra={'bucket': str(folder_id)}, save=True)
def get_folders(self, **kwargs):
# This really gets only buckets, not subfolders,
# as that's all we want to be linkable on a node.
try:
buckets = get_bucket_names(self)
except:
raise exceptions.InvalidAuthError()
return [
{
'addon': 's3',
'kind': 'folder',
'id': bucket,
'name': bucket,
'path': bucket,
'urls': {
'folders': ''
}
}
for bucket in buckets
]
@property
def complete(self):
return self.has_auth and self.folder_id is not None
def authorize(self, user_settings, save=False):
self.user_settings = user_settings
self.nodelogger.log(action='node_authorized', save=save)
def clear_settings(self):
self.folder_id = None
self.folder_name = None
def deauthorize(self, auth=None, log=True):
"""Remove user authorization from this node and log the event."""
self.clear_settings()
self.clear_auth() # Also performs a save
if log:
self.nodelogger.log(action='node_deauthorized', save=True)
def delete(self, save=True):
self.deauthorize(log=False)
super(NodeSettings, self).delete(save=save)
def serialize_waterbutler_credentials(self):
if not self.has_auth:
raise exceptions.AddonError('Cannot serialize credentials for S3 addon')
return {
'access_key': self.external_account.oauth_key,
'secret_key': self.external_account.oauth_secret,
}
def serialize_waterbutler_settings(self):
if not self.folder_id:
raise exceptions.AddonError('Cannot serialize settings for S3 addon')
return {
'bucket': self.folder_id,
'encrypt_uploads': self.encrypt_uploads
}
def create_waterbutler_log(self, auth, action, metadata):
url = self.owner.web_url_for('addon_view_or_download_file', path=metadata['path'], provider='s3')
self.owner.add_log(
's3_{0}'.format(action),
auth=auth,
params={
'project': self.owner.parent_id,
'node': self.owner._id,
'path': metadata['materialized'],
'bucket': self.folder_id,
'urls': {
'view': url,
'download': url + '?action=download'
}
},
)
def after_delete(self, user):
self.deauthorize(Auth(user=user), log=True)
class register(models.Model):
reg_citizen = models.OneToOneField(citizen)
reg_block = models.ForeignKey(block)
reg_key = models.ForeignKey(key)
timestamp = models.DateTimeField(auto_now=True, auto_now_add=True)
register_json = models.TextField(blank=True, null=True)
signature_json = models.FileField(upload_to='signatures_json',
blank=True, null=True)
signature_imag = models.FileField(upload_to='signatures_img',
blank=True, null=True)
def registerCitizen(self, **kwargs):
if 'reg_citizen' in kwargs:
self.reg_citizen = kwargs['reg_citizen']
if 'reg_block'in kwargs:
self.reg_block = kwargs['reg_block']
if 'reg_key'in kwargs:
self.reg_key = kwargs['reg_key']
self.register_json = self.getJSON()
self.signature_json = self.getSign(self.register_json, src='json')
self.signature_imag = self.getSign(self.reg_citizen.photo,
'file', src='img')
def __unicode__(self):
return '{:} at {:}'.format(self.pk, self.reg_block)
#AUXILIAR FUNCTIONS
def getJSON(self):
"""returns a json with register data in it, to be signed and to
build id view"""
#number of blocks of id valitude
eventSpan = 50
print'la fecha es {:}'.format(self.timestamp.isoformat())
#build citizen info hash
citizen_info = {'name': self.reg_citizen.name,
'lastname': self.reg_citizen.lastname,
'social': self.reg_citizen.social}
citizen_json = json.dumps(citizen_info)
h = SHA.new(citizen_json)
citizen_hash = h.hexdigest()
#build rest of the data info
print self.reg_block.index
print self.reg_block.index + eventSpan
data = {'register_time': self.timestamp.isoformat(),
'blockindex': self.reg_block.index,
'blockexpiration': self.reg_block.index + eventSpan,
'blockmerkele': self.reg_block.merkele,
'key_fingerprint': self.reg_key.fingerprint,
'key_details': self.reg_key.atributes,
'photo': self.reg_citizen.photo.__unicode__(),
'citizen_hash': citizen_hash}
for item in citizen_info:
data[item] = citizen_info[item]
jsondata = json.dumps(data)
return jsondata
def getSign(self, data, *args, **kwargs):
"""get cryptographic sign as file"""
#check if you get a file as input, otherwise is a string value
if 'file' in args:
data.open()
message = data.read()
data.close()
else:
message = data
#gets the type of signature, img or json
if 'src' in kwargs:
dataType = kwargs['src']
else:
dataType = 'json'
# retrive private key
self.reg_key.key_file.open()
privkey = RSA.importKey(self.reg_key.key_file.read())
self.reg_key.key_file.close()
#sign message
h = SHA.new(message)
signer = PKCS1_v1_5.new(privkey)
signature = signer.sign(h)
#check if folder exists
signFolder = checkFolder(os.path.join(MEDIA_ROOT,
'signatures_{:}'.format(dataType)))
#save to folder
timemark = datetime.datetime.utcnow().isoformat()
signatureDir = os.path.join(signFolder,
'{:}_{:}'.format(dataType, timemark))
signatureFile = open(signatureDir, 'w')
signatureFile.write(signature)
signatureFile.close()
return signatureDir
class User(AbstractBaseUser, PermissionsMixin):
email = models.EmailField(
verbose_name=_('Email address'),
max_length=255,
unique=True,
)
nickname = models.CharField(verbose_name=_('Nickname'),
max_length=30,
unique=True)
about = models.TextField(
verbose_name=_('About'),
max_length=255,
blank=True,
null=True,
)
facebook_url = models.CharField(
verbose_name=_('Facebook link'),
max_length=255,
blank=True,
null=True,
)
twitter_url = models.CharField(
verbose_name=_('Twitter link'),
max_length=255,
blank=True,
null=True,
)
pinterest_url = models.CharField(
verbose_name=_('Pinterest link'),
max_length=255,
blank=True,
null=True,
)
instagram_url = models.CharField(
verbose_name=_('Instagram link'),
max_length=255,
blank=True,
null=True,
)
gogle_plus_url = models.CharField(
verbose_name=_('Gogle plus link'),
max_length=255,
blank=True,
null=True,
)
image = models.ImageField(upload_to='profile_image/%Y/%m/%d',
blank=True,
null=True)
is_active = models.BooleanField(verbose_name=_('Is active'), default=True)
date_joined = models.DateTimeField(verbose_name=_('Date joined'),
default=timezone.now)
# 이 필드는 레거시 시스템 호환을 위해 추가할 수도 있다.
salt = models.CharField(verbose_name=_('Salt'), max_length=10, blank=True)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = [
'nickname',
]
class Meta:
verbose_name = _('user')
verbose_name_plural = _('users')
ordering = ('-date_joined', )
def __str__(self):
return self.email
def get_full_name(self):
return self.nickname
def get_image(self):
return self.image
def get_about(self):
return self.about
def get_facebook(self):
return self.facebook_url
def get_twitter(self):
return self.twitter_url
def get_pinterest(self):
return self.pinterest_url
def get_instagram(self):
return self.instagram_url
def get_google_plus(self):
return self.gogle_plus_url
def get_short_name(self):
return self.nickname
#비밀번호 설정 오버라이딩
def set_password(self, raw_password):
# Opencart의 salt 값은 9자리의 alphanumeric 문자열
salt = md5(os.urandom(128)).hexdigest()[:9]
# Opencart PHP 프로그램의 비밀번호 암호화 알고리즘
hashed = sha1((salt + sha1(
(salt + sha1(raw_password.encode('utf8')).hexdigest()
).encode('utf8')).hexdigest()).encode('utf8')).hexdigest()
self.salt = salt
self.password = hashed
#비밀번호 변경시 체크 오버라이딩
def check_password(self, raw_password):
try:
user = User.objects.get(email=self.email)
hashed = sha1((user.salt + sha1(
(user.salt + sha1(raw_password.encode('utf8')).hexdigest()
).encode('utf8')).hexdigest()).encode('utf8')).hexdigest()
if user.password == hashed:
return True
else:
return False
except User.DoesNotExist:
return False
@property
def is_staff(self):
"Is the user a member of staff?"
# Simplest possible answer: All superusers are staff
return self.is_superuser
get_full_name.short_description = _('Full name')
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="Event",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"source_event_id",
models.CharField(
help_text="Event ID used at source", max_length=255
),
),
(
"source_url",
models.CharField(
blank=True,
help_text="Event details URL at source",
max_length=4095,
null=True,
),
),
(
"source_license",
models.CharField(
blank=True,
help_text="License under which source published event data",
max_length=255,
null=True,
),
),
(
"name",
models.CharField(help_text="Event title", max_length=255),
),
(
"description",
models.TextField(
blank=True,
help_text="Plain text event description and details",
null=True,
),
),
(
"formatted_description",
models.TextField(
blank=True,
help_text=(
"HTML event description and details (if available from source, otherwise matches plain text description). Will only contain these HTML tags: b, br, em, i, li, p, span, strong, ul.",
),
null=True,
),
),
(
"url",
models.CharField(
blank=True,
help_text="Event website",
max_length=4095,
null=True,
),
),
(
"start_date",
models.DateField(help_text="Start date as YYYY-MM-DD"),
),
(
"start_time",
models.TimeField(
blank=True,
help_text="Start time as HH:MM:SS (optional)",
null=True,
),
),
(
"end_date",
models.DateField(
blank=True,
help_text="Ende date as YYYY-MM-DD (optional)",
null=True,
),
),
(
"end_time",
models.TimeField(
blank=True,
help_text="End time as HH:MM:SS (optional)",
null=True,
),
),
(
"performer",
models.CharField(
blank=True,
help_text="Main event performer (e.g. speaker, band, etc.)",
max_length=255,
null=True,
),
),
(
"mode",
models.CharField(
blank=True,
help_text="Event mode (e.g. presentation, meetup, etc.)",
max_length=255,
null=True,
),
),
],
options={
"ordering": ["start_date", "start_time"],
},
),
migrations.CreateModel(
name="EventSource",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"name",
models.CharField(
help_text="Name of event source",
max_length=255,
unique=True,
),
),
],
),
migrations.CreateModel(
name="Location",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"description",
models.CharField(
help_text="Description of event location (address or similar)",
max_length=1023,
unique=True,
),
),
],
),
migrations.CreateModel(
name="Organizer",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
(
"name",
models.CharField(
help_text="Name of event organizer",
max_length=255,
unique=True,
),
),
],
),
migrations.CreateModel(
name="EventImage",
fields=[
(
"id",
models.AutoField(
auto_created=True,
primary_key=True,
serialize=False,
verbose_name="ID",
),
),
("url", models.CharField(max_length=4095)),
(
"description",
models.CharField(blank=True, max_length=4095, null=True),
),
(
"source",
models.CharField(blank=True, max_length=4095, null=True),
),
(
"event",
models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
related_name="images",
to="events.event",
),
),
],
),
migrations.AddField(
model_name="event",
name="location",
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE,
related_name="events",
to="events.location",
),
),
migrations.AddField(
model_name="event",
name="organizer",
field=models.ForeignKey(
blank=True,
null=True,
on_delete=django.db.models.deletion.SET_NULL,
related_name="events",
to="events.organizer",
),
),
migrations.AddField(
model_name="event",
name="source",
field=models.ForeignKey(
help_text="Source from which this event was gathered",
on_delete=django.db.models.deletion.CASCADE,
related_name="events",
to="events.eventsource",
),
),
migrations.AddConstraint(
model_name="event",
constraint=models.UniqueConstraint(
fields=("source", "source_event_id"), name="unique_event"
),
),
]
class Task(models.Model):
name = models.TextField()
class UserWithProfile(models.Model):
user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, primary_key=True)
description = models.TextField()
picture = models.ImageField(upload_to='image_uploads', default='defaults/default_profile.jpg')
class Message(models.Model):
user = models.ForeignKey(User)
subject = models.CharField(max_length=100, blank=True)
content = models.TextField(blank=True, max_length=MESSAGE_MAX_LENGTH)
author = models.ForeignKey(User, blank=True, null=True, related_name='sent_messages')
read = models.BooleanField(default=False)
created = models.DateTimeField(auto_now_add=True)
deleted_for_user = models.BooleanField(default=False)
deleted_for_author = models.BooleanField(default=False)
content_type = models.ForeignKey(ContentType, blank=True, null=True,
related_name="content_type_set_for_%(class)s")
object_pk = models.TextField('object ID', blank=True, null=True)
object = generic.GenericForeignKey(ct_field="content_type", fk_field="object_pk")
objects = MessageManager()
class Meta:
ordering = ['-created']
def __unicode__(self):
if self.subject and not u' ' in self.subject:
return self.subject[:40]+u'...'
return self.subject or ugettext('[no subject]')
def get_reply_url(self):
return '%s?reply=%s' % (reverse('messages:index'), self.pk)
def delete_for_user(self, user):
if self.user == user:
self.deleted_for_user = True
self.save()
elif self.author == user:
self.deleted_for_author = True
self.save()
def json_data(self):
data = {
'id': self.pk,
'author-avatar': self.author and self.author.small_avatar() or '',
'author-username': self.author and unicode(self.author) or '',
'author-id': self.author and self.author.pk or '',
'user-avatar': self.user and self.user.small_avatar() or '',
'user-username': self.user and unicode(self.user) or '',
'user-id': self.user and self.user.pk or '',
'message-content': self.get_content(),
'message-subject': self.subject,
'message-subject-display': unicode(self),
'is-read': self.read,
'can-reaply': bool(self.author_id)
}
if self.object and hasattr(self.object, 'message_json_data'):
data = self.object.message_json_data(data, self)
return json.dumps(data)
def get_content(self):
content = []
if self.content:
content.append(urlize(escape(self.content)).replace('\n', '<br />'))
content.append('\n')
if self.object and hasattr(self.object, 'render_message'):
added_content = self.object.render_message(self)
content.append(added_content)
return ''.join(content)
def clean(self):
from django.core.exceptions import ValidationError
if not self.subject and not self.content and not self.object:
raise ValidationError(_(u'You should enter subject or message.'))
@classmethod
def on_delete(cls, sender, instance, **kwargs):
ct = ContentType.objects.get_for_model(sender)
cls.objects.filter(content_type__pk=ct.pk, object_pk=instance.pk).delete()
@classmethod
def on_message_saved(self, sender, instance, created, *args, **kwargs):
from messages.tasks import send_new_message_notification
if created and instance.user.changes_notification:
send_new_message_notification.delay(instance.pk)
class Post(models.Model):
author = models.ForeignKey('auth.User')
title = models.CharField(max_length=200)
text = models.TextField()
created_date = models.DateTimeField(default=timezone.now)
published_date = models.DateTimeField(blank=True, null=True)
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Ballpark',
fields=[
('id', models.CharField(max_length=10, primary_key=True, serialize=False)),
('name', models.CharField(max_length=75)),
('location', models.CharField(max_length=50)),
('year', models.IntegerField()),
('singles_left', models.IntegerField()),
('singles_right', models.IntegerField()),
('homeruns_left', models.IntegerField()),
('homeruns_right', models.IntegerField()),
],
),
migrations.CreateModel(
name='Contract',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('type', models.CharField(max_length=8)),
('year', models.IntegerField(default=1)),
('contract_season', models.IntegerField(default=1)),
('length', models.IntegerField()),
('salary', models.IntegerField()),
],
),
migrations.CreateModel(
name='Franchise',
fields=[
('id', models.CharField(max_length=20, primary_key=True, serialize=False)),
('location', models.CharField(max_length=50)),
('nickname', models.CharField(max_length=50)),
('owner', models.ForeignKey(db_column='current_owner', null=True, on_delete=django.db.models.deletion.SET_NULL, to=settings.AUTH_USER_MODEL)),
],
),
migrations.CreateModel(
name='Payroll',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('year', models.IntegerField()),
('money', models.IntegerField()),
('note', models.TextField()),
('paying', models.ForeignKey(db_column='paying', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='paying', to='league.Franchise')),
('receiving', models.ForeignKey(db_column='receiving', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='receiving', to='league.Franchise')),
],
),
migrations.CreateModel(
name='Player',
fields=[
('id', models.CharField(max_length=20, primary_key=True, serialize=False)),
('first_name', models.CharField(max_length=40)),
('last_name', models.CharField(max_length=40)),
('player_type', models.CharField(max_length=2)),
('active', models.BooleanField(default=True)),
('bats', models.CharField(max_length=1)),
('throws', models.CharField(max_length=1)),
('birth_year', models.IntegerField()),
('bbref_id', models.CharField(max_length=20)),
('mlb_id', models.CharField(max_length=10)),
('bp_id', models.CharField(max_length=10)),
('cbs_id', models.CharField(max_length=10)),
('espn_id', models.CharField(max_length=10)),
('fg_id', models.CharField(max_length=10)),
],
),
migrations.CreateModel(
name='Roster',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('player', models.ForeignKey(db_column='player', on_delete=django.db.models.deletion.PROTECT, to='league.Player')),
('team', models.ForeignKey(db_column='team', on_delete=django.db.models.deletion.PROTECT, to='league.Franchise')),
],
),
migrations.CreateModel(
name='Team',
fields=[
('id', models.CharField(max_length=20, primary_key=True, serialize=False)),
('year', models.IntegerField()),
('abbreviation', models.CharField(max_length=5)),
('location', models.CharField(max_length=50)),
('nickname', models.CharField(max_length=50)),
('division', models.CharField(choices=[('ALW', 'AL West'), ('ALE', 'AL East'), ('NLW', 'NL West'), ('NLE', 'NL East')], max_length=12)),
('ballpark', models.ForeignKey(db_column='ballpark', on_delete=django.db.models.deletion.PROTECT, to='league.Ballpark')),
('franchise', models.ForeignKey(db_column='franchise', on_delete=django.db.models.deletion.CASCADE, to='league.Franchise')),
('owner', models.ForeignKey(db_column='owner', null=True, on_delete=django.db.models.deletion.SET_NULL, to=settings.AUTH_USER_MODEL)),
],
),
migrations.AddField(
model_name='contract',
name='player',
field=models.ForeignKey(db_column='player_id', on_delete=django.db.models.deletion.CASCADE, to='league.Player'),
),
]
class RoomType(models.Model)
code = models.CharField(max_length=100)
description = models.TextField()
price = models.FloatField()
maintenance_fee = models.FloatField()
class Blog(models.Model):
name = models.CharField(max_length=100)
tagline = models.TextField()
def __str__(self): # __unicode__ on Python 2
return self.name
class Record(models.Model):
"""The Record contains:
* citation information for an MIT author publication
* plus all of the other data from Elements we will need to construct an
email
"""
class Meta:
ordering = ['author__dlc', 'author__last_name']
# PaperID is not unique, because papers with multiple MIT authors may
# show up in data imports multiple times. However, we should only see
# them once per author.
unique_together = (('author', 'paper_id'))
author = models.ForeignKey(Author, on_delete=models.CASCADE)
email = models.ForeignKey(EmailMessage,
blank=True,
null=True,
on_delete=models.CASCADE)
publisher_name = models.CharField(max_length=255)
acq_method = models.CharField(max_length=255, blank=True)
citation = models.TextField()
doi = models.CharField(max_length=255, blank=True)
# This is the unique ID within Elements, which is NOT the same as the
# proprietary data source ID - those are unique IDs within Scopus, Web of
# Science, etc. We may have multiple records with the same paper ID
# because there will be one record per author (hence the unique_together
# constraint). The unique ID on pubdata-dev does not match that on the
# production server.
paper_id = models.CharField(max_length=255)
message = models.TextField(blank=True)
def __str__(self):
return ("{self.author.last_name}, {self.author.first_name} "
"({self.paper_id})".format(self=self))
def save(self, *args, **kwargs):
# blank=False by default in TextFields, but this applies only to *form*
# validation, not to *instance* validation - django will happily save
# blank strings to the database, and we don't want it to.
if not self.citation:
raise ValidationError('Citation cannot be blank')
return super(Record, self).save(*args, **kwargs)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~ STATIC METHODS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@staticmethod
def create_citation(paper_data):
"""Create text suitable for the citation field.
Some Elements papers include the citation field in their metadata,
but some leave it blank; in those cases we need to build our own
citation text. Stakeholders have indicated that it doesn't matter what
citation format we use or whether the citation is complete (as long as
it includes author, title, and journal title).
This method assumes that the supplied paper metadata has already been
validated; it does not perform any validation.
APA format is:
Author, F.M. (Publication year). Article Title. Journal Title,
Volume(Issue), pp.-pp. doi:XX.XXXXX.
We don't appear to get page number information, so we'll skip that.
"""
citation = '{last}, {first_init}. '.format(
last=paper_data[Fields.LAST_NAME],
first_init=paper_data[Fields.FIRST_NAME][0])
if paper_data[Fields.PUBDATE]:
citation += f'({paper_data[Fields.PUBDATE][0:4]}). '
citation += '{title}. {journal}'.format(
title=paper_data[Fields.TITLE], journal=paper_data[Fields.JOURNAL])
if paper_data[Fields.VOLUME] and paper_data[Fields.ISSUE]:
citation += ', {volume}({issue})'.format(
volume=paper_data[Fields.VOLUME],
issue=paper_data[Fields.ISSUE])
citation += '.'
if paper_data[Fields.DOI]:
citation += (' <a href="https://doi.org/{doi}">doi:{doi}'
'</a>'.format(doi=paper_data[Fields.DOI]))
return citation
@staticmethod
def _get_citation(paper_data):
if paper_data[Fields.CITATION]:
citation = paper_data[Fields.CITATION]
else:
citation = Record.create_citation(paper_data)
return citation
@staticmethod
def get_or_create_from_data(author, paper_data):
"""This expects an author instance and metadata about a single paper
(retrieved via the Elements API), and returns (record, created),
in the manner of objects.get_or_create. It does not validate data;
you should do that before invoking this. If it finds discrepancies
between the data it knows about and the imported data, it updates
the record.
"""
try:
record = Record.objects.get(paper_id=paper_data[Fields.PAPER_ID],
author=author)
logger.info('Got an existing record')
return record, False
except Record.DoesNotExist:
citation = Record._get_citation(paper_data)
record = Record.objects.create(
author=author,
publisher_name=paper_data[Fields.PUBLISHER_NAME],
acq_method=paper_data[Fields.ACQ_METHOD],
citation=citation,
doi=paper_data[Fields.DOI],
paper_id=paper_data[Fields.PAPER_ID],
message=paper_data[Fields.MESSAGE])
logger.info('record created')
return record, True
@staticmethod
def get_duplicates(author, paper_data):
"""See if this paper's metadata would duplicate a record already in the
database.
A _duplicate_ is a record with a different PaperID but the same author
and citation. We want to reject these so they can be fixed in Elements.
(Same citation doesn't suffice, as we may legitimately receive a paper
with the same citation multiple times, once per author.)"""
dupes = Record.objects.filter(
author=author, citation=paper_data[Fields.CITATION]).exclude(
paper_id=paper_data[Fields.PAPER_ID])
if dupes:
return dupes
else:
return None
@staticmethod
def is_record_creatable(paper_data):
"""Determines whether a valid Record can be created from supplied data.
Args:
paper_data (dict): A dict of metadata fields about a single paper.
Returns:
bool: True if record can be created, False otherwise.
"""
try:
if paper_data[Fields.ACQ_METHOD] == 'RECRUIT_FROM_AUTHOR_FPV':
assert bool(paper_data[Fields.DOI])
assert bool(paper_data[Fields.PUBLISHER_NAME])
if not paper_data[Fields.CITATION]:
assert all([bool(paper_data[x]) for x in Fields.CITATION_DATA])
return True
except (AssertionError, KeyError):
return False
@staticmethod
def paper_requested(paper_data):
"""Checks whether we have already sent an email request for this paper.
Args:
paper_data (dict:[str, str]): A dict of metadata fields about a
single paper.
Returns:
bool: True if we've already requested this paper (from any author),
False otherwise.
"""
# Find all records of the same paper, if any.
records = Record.objects.filter(paper_id=paper_data[Fields.PAPER_ID])
# Return True if we've already sent an email for any of those records;
# False otherwise.
return any(
[record.email.date_sent for record in records if record.email])
@staticmethod
def is_data_valid(paper_data):
"""Returns True if this metadata has the required data fields for
making a Record; False otherwise.
For citation data, we'll accept *either* a preconstructed citation,
*or* enough data to construct a minimal citation ourselves."""
citable = bool(paper_data[Fields.CITATION]) or \
all([bool(paper_data[x]) for x in Fields.CITATION_DATA])
return (all([bool(paper_data[x]) for x in Fields.REQUIRED_DATA])
and citable)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~ INSTANCE METHODS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def update_if_needed(self, author, paper_data):
"""Checks a paper's supplied metadata to see if there are any
discrepancies with the existing record. If so, updates it and returns
True. If not, returns False."""
changed = False
if not all([
self.author == author, self.publisher_name
== paper_data[Fields.PUBLISHER_NAME], self.acq_method
== paper_data[Fields.ACQ_METHOD], self.doi
== paper_data[Fields.DOI]
]):
self.author = author
self.publisher_name = paper_data[Fields.PUBLISHER_NAME]
self.acq_method = paper_data[Fields.ACQ_METHOD]
self.doi = paper_data[Fields.DOI]
changed = True
# Don't update records with blank citation information - that will
# cause ValidationErrors. Instead, update them with nonblank info, or
# check if updates to other info merit an update to the citation if the
# citation is blank.
if paper_data[Fields.CITATION]:
if self.citation != paper_data[Fields.CITATION]:
self.citation = paper_data[Fields.CITATION]
changed = True
else:
new_cite = Record.create_citation(paper_data)
if self.citation != new_cite:
self.citation = new_cite
changed = True
if changed:
self.save()
return True
return False
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ PROPERTIES ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@property
def fpv_message(self):
msg = Template('<b>[Note: $publisher_name allows authors to download '
'and deposit the final published article, but does not '
'allow the Libraries to perform the downloading. If '
'you follow this link, download the article, and '
'attach it to an email reply, we can deposit it on '
'your behalf: <a href="http://libproxy.mit.edu/'
'login?url=https://dx.doi.org/$doi">http://'
'libproxy.mit.edu/login?url=https://dx.doi.org/'
'$doi</a>]</b>')
if self.acq_method == 'RECRUIT_FROM_AUTHOR_FPV':
return msg.substitute(publisher_name=self.publisher_name,
doi=self.doi)
else:
return None
@property
def is_sent(self):
if self.email:
return bool(self.email.date_sent)
else:
return False
@property
def is_valid(self):
# If acq_method is FPV, we must have the DOI.
return (self.acq_method != 'RECRUIT_FROM_AUTHOR_FPV' or bool(self.doi))
class Migration(migrations.Migration):
dependencies = [
('exactuals', '0004_auto_20200225_0432'),
]
operations = [
migrations.RemoveField(
model_name='transaction',
name='bath_id',
),
migrations.AddField(
model_name='payee',
name='id',
field=models.AutoField(auto_created=True, default=1, primary_key=True, serialize=False, verbose_name='ID'),
preserve_default=False,
),
migrations.AddField(
model_name='payor',
name='id',
field=models.AutoField(auto_created=True, default=2, primary_key=True, serialize=False, verbose_name='ID'),
preserve_default=False,
),
migrations.AddField(
model_name='payor_payee',
name='id',
field=models.AutoField(auto_created=True, default=3, primary_key=True, serialize=False, verbose_name='ID'),
preserve_default=False,
),
migrations.AddField(
model_name='transaction',
name='batch_id',
field=models.CharField(blank=True, max_length=20, unique=True),
),
migrations.AddField(
model_name='transaction',
name='description',
field=models.TextField(blank=True),
),
migrations.AddField(
model_name='transaction',
name='memo',
field=models.TextField(blank=True),
),
migrations.AddField(
model_name='user',
name='passworld',
field=models.CharField(default=4, max_length=30),
preserve_default=False,
),
migrations.AlterField(
model_name='payee',
name='user_id',
field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to='exactuals.User'),
),
migrations.AlterField(
model_name='payor',
name='user_id',
field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to='exactuals.User'),
),
migrations.AlterField(
model_name='payor_payee',
name='payor_payee_id',
field=models.CharField(max_length=20, unique=True),
),
]
class BuildingPhoto(models.Model):
building = models.ForeignKey(Building, on_delete=models.CASCADE)
url = models.TextField(default="", blank=True)
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name='AuthGroup',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('name', models.CharField(max_length=80, unique=True)),
],
options={
'db_table': 'auth_group',
'managed': False,
},
),
migrations.CreateModel(
name='AuthGroupPermissions',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
],
options={
'db_table': 'auth_group_permissions',
'managed': False,
},
),
migrations.CreateModel(
name='AuthPermission',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('name', models.CharField(max_length=255)),
('codename', models.CharField(max_length=100)),
],
options={
'db_table': 'auth_permission',
'managed': False,
},
),
migrations.CreateModel(
name='AuthUser',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('password', models.CharField(max_length=128)),
('last_login', models.DateTimeField(blank=True, null=True)),
('is_superuser', models.IntegerField()),
('username', models.CharField(max_length=150, unique=True)),
('first_name', models.CharField(max_length=30)),
('last_name', models.CharField(max_length=150)),
('email', models.CharField(max_length=254)),
('is_staff', models.IntegerField()),
('is_active', models.IntegerField()),
('date_joined', models.DateTimeField()),
],
options={
'db_table': 'auth_user',
'managed': False,
},
),
migrations.CreateModel(
name='AuthUserGroups',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
],
options={
'db_table': 'auth_user_groups',
'managed': False,
},
),
migrations.CreateModel(
name='AuthUserUserPermissions',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
],
options={
'db_table': 'auth_user_user_permissions',
'managed': False,
},
),
migrations.CreateModel(
name='City',
fields=[
('cid', models.IntegerField()),
('city',
models.CharField(max_length=50,
primary_key=True,
serialize=False)),
],
options={
'db_table': 'city',
'managed': False,
},
),
migrations.CreateModel(
name='DcyDelivery',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('delivery_name', models.CharField(max_length=255)),
('delivery_code', models.CharField(max_length=255)),
('delivery_sort', models.CharField(max_length=2)),
],
options={
'db_table': 'dcy_delivery',
'managed': False,
},
),
migrations.CreateModel(
name='DjangoAdminLog',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('action_time', models.DateTimeField()),
('object_id', models.TextField(blank=True, null=True)),
('object_repr', models.CharField(max_length=200)),
('action_flag', models.PositiveSmallIntegerField()),
('change_message', models.TextField()),
],
options={
'db_table': 'django_admin_log',
'managed': False,
},
),
migrations.CreateModel(
name='DjangoContentType',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('app_label', models.CharField(max_length=100)),
('model', models.CharField(max_length=100)),
],
options={
'db_table': 'django_content_type',
'managed': False,
},
),
migrations.CreateModel(
name='DjangoMigrations',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('app', models.CharField(max_length=255)),
('name', models.CharField(max_length=255)),
('applied', models.DateTimeField()),
],
options={
'db_table': 'django_migrations',
'managed': False,
},
),
migrations.CreateModel(
name='DjangoSession',
fields=[
('session_key',
models.CharField(max_length=40,
primary_key=True,
serialize=False)),
('session_data', models.TextField()),
('expire_date', models.DateTimeField()),
],
options={
'db_table': 'django_session',
'managed': False,
},
),
migrations.CreateModel(
name='ImageCollectionImg',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('img_url', models.CharField(max_length=100)),
('company_name',
models.CharField(blank=True, max_length=45, null=True)),
('province_name',
models.CharField(blank=True, max_length=45, null=True)),
('city_name',
models.CharField(blank=True, max_length=45, null=True)),
],
options={
'db_table': 'image_collection_img',
'managed': False,
},
),
migrations.CreateModel(
name='Provincial',
fields=[
('pid', models.IntegerField(primary_key=True,
serialize=False)),
('provincial',
models.CharField(blank=True,
db_column='Provincial',
max_length=50,
null=True)),
],
options={
'db_table': 'provincial',
'managed': False,
},
),
migrations.CreateModel(
name='UserInfo',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('username', models.CharField(max_length=45)),
('password', models.CharField(max_length=45)),
('timestamp', models.DateTimeField(blank=True, null=True)),
],
options={
'db_table': 'user_info',
'managed': False,
},
),
]
class Document(models.Model):
TYPE_PDF = "pdf"
TYPE_PNG = "png"
TYPE_JPG = "jpg"
TYPE_GIF = "gif"
TYPE_TIF = "tiff"
TYPES = (TYPE_PDF, TYPE_PNG, TYPE_JPG, TYPE_GIF, TYPE_TIF,)
STORAGE_TYPE_UNENCRYPTED = "unencrypted"
STORAGE_TYPE_GPG = "gpg"
STORAGE_TYPES = (
(STORAGE_TYPE_UNENCRYPTED, "Unencrypted"),
(STORAGE_TYPE_GPG, "Encrypted with GNU Privacy Guard")
)
correspondent = models.ForeignKey(
Correspondent,
blank=True,
null=True,
related_name="documents",
on_delete=models.SET_NULL
)
title = models.CharField(max_length=128, blank=True, db_index=True)
content = models.TextField(
db_index=True,
blank=True,
help_text="The raw, text-only data of the document. This field is "
"primarily used for searching."
)
file_type = models.CharField(
max_length=4,
editable=False,
choices=tuple([(t, t.upper()) for t in TYPES])
)
tags = models.ManyToManyField(
Tag, related_name="documents", blank=True)
checksum = models.CharField(
max_length=32,
editable=False,
unique=True,
help_text="The checksum of the original document (before it was "
"encrypted). We use this to prevent duplicate document "
"imports."
)
created = models.DateTimeField(
default=timezone.now, db_index=True)
modified = models.DateTimeField(
auto_now=True, editable=False, db_index=True)
storage_type = models.CharField(
max_length=11,
choices=STORAGE_TYPES,
default=STORAGE_TYPE_UNENCRYPTED,
editable=False
)
added = models.DateTimeField(
default=timezone.now, editable=False, db_index=True)
class Meta:
ordering = ("correspondent", "title")
def __str__(self):
created = self.created.strftime("%Y%m%d%H%M%S")
if self.correspondent and self.title:
return "{}: {} - {}".format(
created, self.correspondent, self.title)
if self.correspondent or self.title:
return "{}: {}".format(created, self.correspondent or self.title)
return str(created)
@property
def source_path(self):
file_name = "{:07}.{}".format(self.pk, self.file_type)
if self.storage_type == self.STORAGE_TYPE_GPG:
file_name += ".gpg"
return os.path.join(
settings.MEDIA_ROOT,
"documents",
"originals",
file_name
)
@property
def source_file(self):
return open(self.source_path, "rb")
@property
def file_name(self):
return slugify(str(self)) + "." + self.file_type
@property
def download_url(self):
return reverse("fetch", kwargs={"kind": "doc", "pk": self.pk})
@property
def thumbnail_path(self):
file_name = "{:07}.png".format(self.pk)
if self.storage_type == self.STORAGE_TYPE_GPG:
file_name += ".gpg"
return os.path.join(
settings.MEDIA_ROOT,
"documents",
"thumbnails",
file_name
)
@property
def thumbnail_file(self):
return open(self.thumbnail_path, "rb")
@property
def thumbnail_url(self):
return reverse("fetch", kwargs={"kind": "thumb", "pk": self.pk})
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Image',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('file', models.ImageField(upload_to='')),
('location', models.CharField(max_length=140)),
('creator',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL)),
],
options={
'abstract': False,
},
),
migrations.CreateModel(
name='Like',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('creator',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL)),
('image',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to='images.Image')),
],
options={
'abstract': False,
},
),
migrations.CreateModel(
name='Comment',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('message', models.TextField()),
('creator',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to=settings.AUTH_USER_MODEL)),
('image',
models.ForeignKey(on_delete=django.db.models.deletion.CASCADE,
to='images.Image')),
],
options={
'abstract': False,
},
),
]
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name='Instance',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('created_date', models.DateTimeField(auto_now_add=True)),
('updated_date', models.DateTimeField(auto_now=True)),
('languages',
django.contrib.postgres.fields.ArrayField(
base_field=models.CharField(max_length=2),
blank=True,
size=None)),
('role',
models.PositiveSmallIntegerField(default=0,
verbose_name=[(0, 'Thing'),
(1, 'Agent'),
(2, 'Place'),
(3, 'Event')
])),
('identifiers', models.TextField()),
('description', models.TextField()),
('source', models.TextField(blank=True, null=True)),
('data',
django.contrib.postgres.fields.jsonb.JSONField(blank=True,
null=True)),
],
options={
'verbose_name': 'Instance',
'verbose_name_plural': 'Instances',
},
),
migrations.CreateModel(
name='Type',
fields=[
('id',
models.AutoField(auto_created=True,
primary_key=True,
serialize=False,
verbose_name='ID')),
('created_date', models.DateTimeField(auto_now_add=True)),
('updated_date', models.DateTimeField(auto_now=True)),
('languages',
django.contrib.postgres.fields.ArrayField(
base_field=models.CharField(max_length=2),
blank=True,
size=None)),
('name', models.TextField()),
('definition', models.TextField(blank=True, null=True)),
('is_category', models.BooleanField(default=False)),
('source', models.TextField(blank=True, null=True)),
('data',
django.contrib.postgres.fields.jsonb.JSONField(blank=True,
null=True)),
('parents',
models.ManyToManyField(blank=True,
related_name='parent_types',
to='meta.Type')),
],
options={
'verbose_name': 'Type',
'verbose_name_plural': 'Types',
},
),
migrations.AddField(
model_name='instance',
name='concept',
field=models.ForeignKey(
on_delete=django.db.models.deletion.CASCADE, to='meta.Type'),
),
]
class Books(models.Model):
title = models.CharField(max_length=255)
desc = models.TextField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
objects = BookManager()
class Migration(migrations.Migration):
initial = True
dependencies = [
('events', '0027_session_autoseat_mode'),
]
operations = [
migrations.CreateModel(
name='Invitation',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('order', models.CharField(max_length=200, unique=True, verbose_name='order')),
('created', models.DateTimeField(auto_now_add=True, verbose_name='created at')),
('extra_data', models.TextField(blank=True, null=True, verbose_name='extra data')),
('is_pass', models.BooleanField(default=False, verbose_name='is pass')),
('used', models.BooleanField(default=False, verbose_name='used')),
('used_date', models.DateTimeField(blank=True, null=True, verbose_name='invitation used date')),
],
options={
'verbose_name': 'invitation',
'verbose_name_plural': 'invitations',
},
bases=(models.Model, tickets.models.BaseExtraData),
),
migrations.CreateModel(
name='InvitationGenerator',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('amount', models.IntegerField(default=1, verbose_name='amount')),
('price', models.IntegerField(blank=True, null=True, verbose_name='price')),
('concept', models.CharField(max_length=200, verbose_name='concept')),
('created', models.DateTimeField(auto_now_add=True, verbose_name='created at')),
],
options={
'verbose_name': 'invitation generator',
'verbose_name_plural': 'invitation generators',
},
),
migrations.CreateModel(
name='InvitationType',
fields=[
('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=200, verbose_name='name')),
('is_pass', models.BooleanField(default=False, verbose_name='is pass')),
('start', models.DateTimeField(null=True, verbose_name='start date')),
('end', models.DateTimeField(null=True, verbose_name='end date')),
('event', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='invitation_types', to='events.Event', verbose_name='event')),
('gates', models.ManyToManyField(blank=True, null=True, to='events.Gate', verbose_name='gates')),
('sessions', models.ManyToManyField(blank=True, null=True, related_name='invitation_types', to='events.Session', verbose_name='sessions')),
],
options={
'verbose_name': 'invitation type',
'verbose_name_plural': 'invitation types',
},
),
migrations.AddField(
model_name='invitationgenerator',
name='type',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='invs.InvitationType', verbose_name='type'),
),
migrations.AddField(
model_name='invitation',
name='generator',
field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='invitations', to='invs.InvitationGenerator', verbose_name='generator'),
),
migrations.AddField(
model_name='invitation',
name='type',
field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='invitations', to='invs.InvitationType', verbose_name='invitation type'),
),
]
