class Invoice(models.Model):
recipient = models.ForeignKey(Recipient, on_delete=models.CASCADE)
description = models.TextField(max_length=1000, default='')
amount = models.FloatField(default=0)
currency = models.CharField(max_length=5, default='CZK')
# models.FloatField(default=1)
exchange_rate = PickledObjectField(default=get_pickle_default)
date = models.DateField(default=datetime.now, blank=True)
datedue = models.DateField(default=datetime.now, blank=True)
iid = models.IntegerField(default=0, null=True, blank=True)
payment = models.CharField(max_length=25, default='bankovním převodem')
owner = models.ForeignKey(User,
on_delete=models.CASCADE,
null=True,
blank=True)
has_items = models.BooleanField(default=False, null=True)
advance = models.ForeignKey(Advance,
on_delete=models.CASCADE,
null=True,
blank=True)
paid = models.DateField(blank=True, null=True)
paid_exchange_rate = PickledObjectField(null=True, blank=True)
def __str__(self):
return ', '.join(
[str(self.iid), self.recipient.name,
str(self.amount), 'CZK'])
class Report(models.Model):
# If not group defined, it was ran
# on the entire annotations as single massive list
group = models.ForeignKey(Group, null=True, blank=True)
PAIRWISE = 0
AVERAGE = 1
REPORT_CHOICE = (
(PAIRWISE, 'pairwise'),
(AVERAGE, 'average'),
)
report_type = models.CharField(max_length=1,
choices=REPORT_CHOICE,
blank=False)
dataframe = PickledObjectField()
args = PickledObjectField()
created = models.DateTimeField(auto_now_add=True)
class Meta:
app_label = 'analysis'
def __unicode__(self):
return u'Report'
class DebugLogRecord(models.Model):
"""Captures statistics for individual requests."""
timestamp = models.DateTimeField(auto_now_add=True)
test_run = models.ForeignKey(TestRun, related_name='records')
request_path = models.CharField(max_length=255)
settings = PickledObjectField(compress=True, blank=True, null=True)
# Timer stats
timer_utime = models.FloatField(blank=True, null=True)
timer_stime = models.FloatField(blank=True, null=True)
timer_cputime = models.FloatField(blank=True, null=True)
timer_total = models.FloatField(blank=True, null=True)
timer_vcsw = models.IntegerField(blank=True, null=True)
timer_ivcsw = models.IntegerField(blank=True, null=True)
# Sql stats
sql_num_queries = models.IntegerField(blank=True, null=True)
sql_time = models.FloatField(blank=True, null=True)
sql_queries = PickledObjectField(compress=True, blank=True, null=True)
# Cache stats
cache_num_calls = models.IntegerField(blank=True, null=True)
cache_time = models.FloatField(blank=True, null=True)
cache_hits = models.IntegerField(blank=True, null=True)
cache_misses = models.IntegerField(blank=True, null=True)
cache_sets = models.IntegerField(blank=True, null=True)
cache_gets = models.IntegerField(blank=True, null=True)
cache_get_many = models.IntegerField(blank=True, null=True)
cache_deletes = models.IntegerField(blank=True, null=True)
cache_calls = PickledObjectField(compress=True, blank=True, null=True)
def __unicode__(self):
return u'DebugLogRecord from %s' % self.timestamp
class SearchSubscription(models.Model):
user = models.ForeignKey(User,
related_name="search_subscriptions",
on_delete=models.CASCADE)
keyword_args = PickledObjectField(default=dict)
search_params = PickledObjectField(default=dict)
filter_class_module = models.CharField(max_length=254)
filter_class_name = models.CharField(max_length=254)
oftenity = models.DurationField(
help_text=_(u"Cada cuanto te notificamos?"))
created = models.DateTimeField(auto_now_add=True, blank=True, null=True)
updated = models.DateTimeField(auto_now=True, blank=True, null=True)
last_run = models.DateTimeField(blank=True, null=True)
token = models.UUIDField(default=uuid.uuid4)
def unsubscribe_url(self):
return reverse('proposal_subscriptions:unsubscribe',
kwargs={'token': self.token})
def base_queryset(self):
mod = __import__(self.filter_class_module,
fromlist=[self.filter_class_name])
filter_klass = getattr(mod, self.filter_class_name)
filter_ = filter_klass(data=self.search_params, **self.keyword_args)
return filter_.qs
def queryset(self):
qs = self.base_queryset()
since_when = timezone.now() - self.oftenity
return qs.filter(created__gt=since_when)
class DyField(models.Model):
"""
Dynamic field
"""
name = models.CharField(max_length=200)
label = models.CharField(max_length=200)
type = models.CharField(max_length=200)
model = models.ForeignKey(DyModel, related_name='dyfields')
args = PickledObjectField()
kwargs = PickledObjectField()
def get_field_name(self):
return slugify(self.name).replace("-", "_")
def get_field(self):
field_type = getattr(models, self.type)
field = field_type(*self.args, **self.kwargs)
return field
@property
def is_geo_field(self):
return self.type in utils.GEOM_FIELDS
@property
def is_datetime_field(self):
return self.type in utils.DATETIME_FIELDS
def save(self, *args, **kwargs):
if not self.label:
self.label = self.name
return super(DyField, self).save(*args, **kwargs)
class Session(models.Model):
session_date = models.DateField()
encounter = models.ForeignKey('Encounter', blank=True, null=True)
pcs = models.ManyToManyField('PC', blank=True)
tracker = PickledObjectField(null=True)
delay = PickledObjectField(null=True)
def __str__(self):
return str(self.session_date)
def extract_npcs(self, monsters):
list = []
for monster in monsters:
for i in range(0, monster.number):
list.append(monster.npc)
return list
def first_pickle_list(self):
monster_list = [monster for monster in self.encounter.monsters.all()]
npc_list = self.extract_npcs(monster_list)
players_list = [p for p in self.pcs.all()]
tracker = Tracker()
result_list = sorted(
chain(npc_list, players_list),
key=attrgetter('initiative'),
reverse=True)
for x in result_list:
tracker.add_player(x)
self.tracker = pickle.dumps(tracker)
class ProjectionIn2D(models.Model):
url = models.CharField(max_length=30, default="URL")
plot = PickledObjectField()
data = PickledObjectField(default="SOME STRING")
kmeans = PickledObjectField(default="SOME STRING", null=True, blank=True)
base_data = models.ForeignKey(BaseData,
on_delete=models.CASCADE,
related_name="ProjectionIn2D")
class Descripcionecg(models.Model):
senal = models.ForeignKey(Signal, on_delete=models.CASCADE, null=True)
filtrada = PickledObjectField(default=0)
hrv = PickledObjectField(default=0)
bpm = models.IntegerField(default=0)
def __str__(self):
return self.senal.nombre
class Division(models.Model):
"""a Division is a set of rules (Queryset) that defines the
eligibility of Persons, Teams and specific Rosters to compete at a related tournament.
A tournament can have more than one Divsion.
Example: TournamentDivision Mixed EUCF. Eligible are all players who have
not played at any EUCR in another Division and all Teams that have qualified through
eucr and whose roster for this tournament does not contain more than 3 new players compared
to the EUCR roster
"""
name = models.CharField(max_length=300, unique=True)
description = models.TextField(blank=True)
def default_eligible_person_query():
return dbsafe_encode(Person.objects.all().query)
eligible_person_query = PickledObjectField(default=default_eligible_person_query)
def default_eligible_team_query():
return dbsafe_encode(Team.objects.all().query)
eligible_team_query = PickledObjectField(default=default_eligible_team_query)
tournaments = models.ManyToManyField("Tournament", through="TournamentDivision")
def eligible_persons(self) -> models.QuerySet:
queryset = Person.objects.all()
queryset.query = self.eligible_person_query
return queryset
# would be nice to have the AND clauses that caused the object to not be selected.
def is_eligible(self, person: Person) -> bool:
queryset = Person.objects.all()
queryset.query = self.eligible_person_query
def eligible_teams(self) -> models.QuerySet:
queryset = Team.objects.all()
queryset.query = self.eligible_team_query
return queryset
# TODO: if not elegible return lookups that caused it
# self.query.where.children reutrns an iterable over all lookups
def is_eligible(self, team: Team) -> bool:
return self.eligible_Teams.filter(pk=team.pk).exists()
def eligible_Rosters(self) -> models.QuerySet:
queryset = Roster.objects.all()
queryset.query = self.eligible_team_query
return queryset
def is_eligible(self, roster: Roster) -> bool:
return self.eligible_Rosters.filter(pk=roster.pk).exists()
def __str__(self):
return f"{self.name} (id= {self.id})"
class ItemMapping(models.Model):
objects = BridgeManager()
# a part of the compound key to identify the bridge
integration = models.ForeignKey('core.Integration')
bridge_name = models.CharField(max_length=512)
# item requisites
left_id = models.CharField(u'"Left system" item id',
max_length=512,
null=True,
db_index=True)
left_hash = models.CharField(u'Last seen hash of the item',
max_length=64,
default='!')
left_extra = PickledObjectField(u'Extra data of the "left side"',
default={})
right_id = models.CharField(u'"Right system" item id',
max_length=512,
null=True,
db_index=True)
right_hash = models.CharField(u'Last seen hash of the item',
max_length=64,
default='!')
right_extra = PickledObjectField(u'Extra data of the "right side"',
default={})
def side(self, side_name):
return SideProxy(self, side_name)
class Meta:
index_together = [
['integration', 'bridge_name', 'left_id'],
['integration', 'bridge_name', 'right_id'],
]
def __log__(self):
"""
Logging utils use this information to convert object to a log record
"""
return {
'id': self.id,
'integration_id': self.integration_id,
'bridge_name': self.bridge_name,
'left_id': self.left_id,
'left_hash': hash_and_extra(self.left_hash, self.left_extra),
'right_id': self.right_id,
'right_hash': hash_and_extra(self.right_hash, self.right_extra),
}
def __str__(self):
return '%s: %s (%s) -> %s (%s)' % (
self.bridge_name, self.left_id,
hash_and_extra(self.left_hash, self.left_extra), self.right_id,
hash_and_extra(self.right_hash, self.right_extra))
class Feature(models.Model):
created = models.DateTimeField(auto_now_add=True, blank=True, null=True)
modified = models.DateTimeField(auto_now=True, blank=True, null=True)
item = models.ForeignKey(Item)
name = models.CharField(max_length=255, blank=True, null=True)
description = PickledObjectField()
feature = PickledObjectField()
def __unicode__(self):
return str(self.pk)
class UserProfile(models.Model): user_name = models.OneToOneField(User, on_delete = models.CASCADE) Score = models.IntegerField(blank=True, default = 0) result=PickledObjectField(null=True) num = models.IntegerField(blank = True, default = 1) prefs = PickledObjectField(null=True) form_submit = models.BooleanField(blank = True,default = False) def __str__(self): return self.user_name.name
class SiteStats(models.Model):
last_modified = models.DateTimeField(auto_now=True)
replays = models.IntegerField()
tags = models.CharField(max_length=1000)
maps = models.CharField(max_length=1000)
active_players = models.CharField(max_length=1000)
all_players = PickledObjectField()
comments = models.CharField(max_length=1000)
games = models.CharField(max_length=1000)
bawards = PickledObjectField()
class ChecklistScore(models.Model):
date_created = models.DateTimeField(default=timezone.now, null=True)
score = models.PositiveIntegerField(null = True)
checked = PickledObjectField(default = dict)
unchecked = PickledObjectField(default = dict)
tenant = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, on_delete = models.CASCADE, related_name='tenant_checklist')
def __str__(self):
return str(self.date_created)[:10] + "; Score: " + str(self.score) + " (" + str(self.tenant.username) + ")"
class TestingModel(models.Model):
pickle_field = PickledObjectField()
compressed_pickle_field = PickledObjectField(compress=True)
default_pickle_field = PickledObjectField(default=({
1: 1,
2: 4,
3: 6,
4: 8,
5: 10
}, 'Hello World', (1, 2, 3, 4, 5), [1, 2, 3, 4, 5]))
class PlayerPieces(models.Model):
noOfSunkShips = models.IntegerField()
# 3 of 1*1, 2 of 2*1, 1 of 4*1, 1 of 3 square L, 1 of 5 square T
squares = PickledObjectField()
# 0 not filled, 1 filled, 2 clicked
iOfSquaresOfType = PickledObjectField(
) # Numbering for 1 and 2 is done from L to R
jOfSquaresOfType = PickledObjectField()
squaresLeft = PickledObjectField(
) # Each type indexes into squaresLeft. 1 1 1 2 2 3 4 5
class Survey(models.Model):
id = models.CharField(max_length=64, primary_key=True)
completed = models.BooleanField(default=False)
history = PickledObjectField(default=[])
response = PickledObjectField(default={})
skipped = models.BooleanField(default=False)
api_data = PickledObjectField(default={})
def field_match(self, fieldname, value):
return field_compare(self.__dict__, fieldname, value)
class Bucket(models.Model):
name = models.CharField(max_length=100)
custom = models.BooleanField(default=False)
# TODO: make into ChoiceField
type = models.CharField(max_length=10)
user = models.ForeignKey('auth.User', related_name='buckets')
requirement_obj = PickledObjectField()
cells = PickledObjectField()
class Meta:
unique_together = (('name', 'user'), )
def test_protocol(self):
field = PickledObjectField()
self.assertNotIn('protocol', field.deconstruct()[3])
with self.settings(PICKLEFIELD_DEFAULT_PROTOCOL=3):
field = PickledObjectField(protocol=4)
self.assertEqual(field.deconstruct()[3].get('protocol'), 4)
field = PickledObjectField(protocol=3)
self.assertNotIn('protocol', field.deconstruct()[3])
class Guest(models.Model):
ip = PickledObjectField(default="")
game = PickledObjectField(default=dill.dumps(Game()))
badges = PickledObjectField(default=dill.dumps([]))
statistics = PickledObjectField(default=dill.dumps({
"games": 0,
"best_days": 0,
"avg_days": 0.0,
"best_kills": 0,
"avg_kills": 0.0,
"party": 0
}))
class MarketImageInfo(models.Model):
id = models.CharField(max_length=36,
primary_key=True,
default=make_uuid,
editable=True)
final_image_id = models.CharField(max_length=36)
base_type = models.CharField(max_length=52)
creator_id = models.CharField(max_length=36)
creator = models.CharField(max_length=36)
downloads = models.BigIntegerField(default=0)
tags = PickledObjectField()
extra_info = PickledObjectField()
published = models.BooleanField(default=False)
class Reporter(models.Model):
name = models.CharField(max_length=100,
db_index=True,
blank=False,
null=False)
stories_coverage = PickledObjectField()
stories_trendencies = PickledObjectField()
def __unicode__(self):
return self.name
def __str__(self):
return self.__unicode__()
class InstagramUser(models.Model):
""" The instagram user accounts """
username = models.CharField(max_length=30)
password = models.CharField(max_length=50)
fbtoken = models.CharField(max_length=300, blank=True)
fbid = models.CharField(max_length=50, blank=True)
access_token = models.CharField(max_length=100, blank=True)
owner = models.ForeignKey(User, default=None, on_delete=models.CASCADE)
fbpageid = models.CharField(max_length=50, blank=True)
instagramId = models.CharField(max_length=50, blank=True)
# Fields below are intended for persistent logins
login_session = PickledObjectField(default=None, null=True, blank=True)
username_id = PickledObjectField(default=None, null=True, blank=True)
class ActionTree(models.Model):
NEW = "NEW"
RUNNING = "RUNNING"
FAILED = "FAILED"
SUCCESS = "SUCCESS"
task = models.ForeignKey(Task, on_delete=models.CASCADE, default=None)
root = PickledObjectField()
trees = PickledObjectField()
state = models.CharField(
max_length=64,
default="NEW") # default = 'NEW', RUNNING, FAILED, SUCCESS
class SVMModels(models.Model):
model_pickle = PickledObjectField()
training_data_X = PickledObjectField()
training_data_y = PickledObjectField()
test_data_X = PickledObjectField()
test_data_y = PickledObjectField()
score = models.FloatField()
random_state_int = models.IntegerField()
test_size = models.FloatField()
model_function_source = models.TextField()
scikit_version = models.CharField(max_length=200)
numpy_version = models.CharField(max_length=200)
scipy_version = models.CharField(max_length=200)
run_date = models.DateTimeField()
def forwards(self, orm):
if VALUE_PICKLEFIELD:
from picklefield.fields import PickledObjectField
tmp_data = PickledObjectField(null=True, blank=True)
else:
tmp_data = models.TextField(null=True, blank=True)
tmp_data.contribute_to_class(orm['form_designer.FormLog'], 'tmp_data')
for log in orm['form_designer.FormLog'].objects.all():
log.set_data(log.tmp_data)
log.save()
# Deleting field 'FormLog.data'
db.delete_column('form_designer_formlog', 'tmp_data')
class ProfileIPData(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
relation = models.ForeignKey('ProfileIP', on_delete=models.CASCADE, related_name='data_versions')
data = models.JSONField(default=dict)
version = models.IntegerField(default=0)
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
created = models.DateTimeField(auto_now_add=True)
parsed_files = PickledObjectField(default=list)
extra_paths_to_parse = PickledObjectField(default=list)
class Meta:
ordering = ['version']
permissions = (
('profile_management', 'Can manage profiles'),
)
class Categorie(models.Model):
name = models.CharField('Nom', max_length=100)
tickets = PickledObjectField()
supports = PickledObjectField()
date = models.DateTimeField(default=timezone.now)
description = models.CharField('Description', max_length=300)
class Meta:
ordering = [
"-date",
]
unique_together = ("name", )
def __str__(self):
return "{}".format(self.name)
class Export(models.Model):
STATUS_CHOICES = (
("completed", _(u"Completed")),
("pending", _(u"Pending")),
("failed", _(u"Failed")),
)
app_label = models.CharField(max_length=50)
model_name = models.CharField(max_length=50)
status = models.CharField(_(u"status"),
max_length=50,
default="pending",
choices=STATUS_CHOICES)
result = PickledObjectField(null=True, default=None)
date_created = models.DateTimeField(auto_now_add=True)
date_done = models.DateTimeField(auto_now=True)
#memb_app = models.ForeignKey(App, blank=True, null=True, on_delete=models.CASCADE)
class Meta:
app_label = 'exports'
def get_absolute_url(self):
return reverse('export.status', args=[self.app_label, self.model_name])
def __str__(self):
return "Export for %s %s" % (self.app_label, self.model_name)
class TaskMeta(models.Model):
"""Task result/status."""
task_id = models.CharField(_(u"task id"), max_length=255, unique=True)
status = models.CharField(_(u"task status"),
max_length=50,
default=states.PENDING,
choices=TASK_STATE_CHOICES)
result = PickledObjectField(null=True, default=None)
date_done = models.DateTimeField(_(u"done at"), auto_now=True)
traceback = models.TextField(_(u"traceback"), blank=True, null=True)
objects = managers.TaskManager()
class Meta:
"""Model meta-data."""
verbose_name = _(u"task meta")
verbose_name_plural = _(u"task meta")
db_table = "celery_taskmeta"
def to_dict(self):
return {
"task_id": self.task_id,
"status": self.status,
"result": self.result,
"date_done": self.date_done,
"traceback": self.traceback
}
def __unicode__(self):
return u"<Task: %s state->%s>" % (self.task_id, self.status)
