class Assignment(Document):
owner = ReferenceField(User,required=True)
scored_problems = EmbeddedDocumentListField(ScoredProblem,required=True)
students = ListField(ReferenceField(User))
#作业布置与时间
assign_time = DateTimeField(required = True)
days_given = IntField(required=True,min_value=1)
class HistorialCatalogacion(Document):
"""Esquema de historial de catalogación"""
_id = StringField(max_length=32, primary_key=True, required=True)
documento = ReferenceField(Documento, required=True)
catalogacion = EmbeddedDocumentListField(Historico, required=True)
meta = {'collection': 'historial_catalogacion', 'indexes': ['documento']}
class Event(Document):
meta = {
'collection': 'events',
'indexes': [
{
'fields': ['start'],
'unique': True,
},
],
}
name = StringField(required=True)
location = StringField()
description = StringField(max_length=1000)
start = DateTimeField(required=True)
end = DateTimeField(required=True)
request_promotion = BooleanField()
date_created = DateTimeField(default=datetime.now)
owner = EmbeddedDocumentField(EmbeddedUser)
organizers = EmbeddedDocumentListField(EmbeddedUser)
verified = BooleanField(default=False)
def is_owner(self, user_id):
return user_id == self.owner.id
def verified_events(doc_cls, queryset):
return queryset.filter(verified=True)
class Queue(DbModelMixin, Document):
_field_collation_overrides = {
"metadata.": AttributedDocument._numeric_locale,
}
get_all_query_options = GetMixin.QueryParameterOptions(
pattern_fields=("name", ),
list_fields=("tags", "system_tags", "id", "metadata.*"),
)
meta = {
"db_alias": Database.backend,
"strict": strict,
}
id = StringField(primary_key=True)
name = StrippedStringField(required=True,
unique_with="company",
min_length=3,
user_set_allowed=True)
company = StringField(required=True, reference_field=Company)
created = DateTimeField(required=True)
tags = SafeSortedListField(StringField(required=True),
default=list,
user_set_allowed=True)
system_tags = SafeSortedListField(StringField(required=True),
user_set_allowed=True)
entries = EmbeddedDocumentListField(Entry, default=list)
last_update = DateTimeField()
metadata = SafeMapField(field=EmbeddedDocumentField(MetadataItem),
user_set_allowed=True)
class Question(Document):
title = StringField(max_length=1024, required=True)
description = StringField()
author = ReferenceField('User', reverse_delete_rule=NULLIFY)
tags = ListField()
# answer = EmbeddedDocumentListField('Answer')
answer = EmbeddedDocumentListField('Answer')
class Evaluation(db.Document):
user = ReferenceField(User)
display_name = StringField()
text = StringField(default='')
course = ReferenceField(Course)
term = StringField()
like = ListField(ReferenceField(User, deref=True), default=lambda: [])
liked_count = IntField()
rating = IntField()
comments = EmbeddedDocumentListField(Comment, default=lambda: [])
deleted = BooleanField(default=False)
created = DateTimeField(default=datetime.datetime.now)
meta = {
'ordering': ['-created'],
'strict': False,
'indexes': ['course', 'created']
}
def to_dict(self):
return {
'display_name': self.display_name,
'text': self.text,
'course': {
'id': str(self.course.id),
'no': self.course.no,
'name': self.course.name,
'teacherName': self.course.teacher_name
},
'term': self.term,
'like': self.like,
'rating': self.rating,
'created': str(self.created),
'comments': self.comments
}
class StreamDefinitionModel(Document):
stream_id = EmbeddedDocumentField(document_type=StreamIdField,
required=True) # , unique=True)
stream_type = StringField(required=False, min_length=1, max_length=512)
channel_id = StringField(required=True, min_length=1, max_length=512)
last_updated = DateTimeField(required=False)
last_accessed = DateTimeField(required=False)
calculated_intervals = EmbeddedDocumentListField(
document_type=TimeIntervalModel, required=False)
sandbox = StringField()
meta = {
'collection': 'stream_definitions',
'indexes': [{
'fields': ['stream_id'],
'unique': True
}],
}
def get_calculated_intervals(self):
return TimeIntervals(
map(lambda x: TimeInterval(x.start, x.end),
self.calculated_intervals))
def set_calculated_intervals(self, intervals):
if intervals is None:
intervals = []
self.calculated_intervals = tuple(
map(lambda x: TimeIntervalModel(start=x.start, end=x.end),
intervals))
class AssignmentQnA(Document):
assignment = ReferenceField(Assignment, required=True)
qna = ReferenceField(QnA, required=True)
qna_version = IntField()
qna_readable_id = StringField()
base_facts = EmbeddedDocumentListField(FactContent)
max_score = IntField()
class Submission(Document):
group_name = StringField(required=True)
student_id = IntField(required=True)
module_name = StringField(required=True)
submission_date = DateTimeField(required=True)
submission_files = EmbeddedDocumentListField(SubmissionFile)
submission_score = FloatField(required=True)
def load(self, filepath, results):
""" Initiate a new Submission entry from a filepath and a results dict
:filepath: A fileparth ending in
"group_name/student_id/module_name/submission_date'
e.g. data/cohort1/14/pre2-programming/20180724_152918/
:results: A dictionary populated by the contents of results.json in filepath
"""
# Populated from filepath
group, student, module, time = filepath.split("/")[-4:]
self.group_name = group
self.student_id = int(student)
self.module_name = module
self.submission_date = datetime.datetime.strptime(
time, config.INPUT_DATE_FORMAT)
# Populated from json (results.json)
self.submission_score = results["overall_score"]
for filestats in results["data"]:
self.submission_files.append(SubmissionFile().load(filestats))
return self
class Queue(DbModelMixin, Document):
get_all_query_options = GetMixin.QueryParameterOptions(
pattern_fields=("name", ),
list_fields=("tags", "system_tags", "id"),
)
meta = {
'db_alias': Database.backend,
'strict': strict,
}
id = StringField(primary_key=True)
name = StrippedStringField(required=True,
unique_with="company",
min_length=3,
user_set_allowed=True)
company = StringField(required=True, reference_field=Company)
created = DateTimeField(required=True)
tags = ListField(StringField(required=True),
default=list,
user_set_allowed=True)
system_tags = ListField(StringField(required=True), user_set_allowed=True)
entries = EmbeddedDocumentListField(Entry, default=list)
last_update = DateTimeField()
class Student(User):
gender = StringField(regex='(M|F)',
max_length=1,
min_length=1,
required=True)
aka = StringField(max_length=20)
req_for_courses = EmbeddedDocumentListField(RequestForCourse)
class UASZone(Document):
identifier = StringField(required=True, primary_key=True, max_length=7)
country = StringField(min_length=3, max_length=3, required=True)
name = StringField(max_length=200)
type = StringField(choices=CodeZoneType.choices(), required=True)
restriction = StringField(choices=CodeRestrictionType.choices(),
max_length=200,
required=True)
restriction_conditions = ListField(StringField(),
db_field='restrictionConditions')
region = IntField(min_value=0, max_value=0xffff)
reason = ListField(StringField(choices=CodeZoneReasonType.choices()),
max_length=9)
other_reason_info = StringField(max_length=30)
regulation_exemption = StringField(choices=CodeYesNoType.choices())
u_space_class = StringField(db_field='uSpaceClass',
choices=CodeUSpaceClassType.choices(),
max_length=100)
message = StringField(max_length=200)
zone_authority = EmbeddedDocumentField(Authority,
db_field='zoneAuthority',
required=True)
applicability = EmbeddedDocumentField(TimePeriod)
geometry = EmbeddedDocumentListField(AirspaceVolume, required=True)
extended_properties = DictField(db_field='extendedProperties')
user = ReferenceField(User, required=True)
def clean(self):
if self.user is not None:
self.user = _get_or_create_user(self.user)
class PartePessoa(EmbeddedDocument):
PESSOA_TIPO = (
('fisica', 'Física'),
('juridica', 'Jurídica'),
('autoridade', 'Autoridade'),
('orgaorepresentacao', 'Orgão de Representação'))
PESSOA_SEXO = (
('M', 'Masculino'),
('F', 'Feminino'),
('D', 'Diverso'))
tipo = StringField(choices=PESSOA_TIPO)
documento_principal = StringField()
nome = StringField()
nome_genitor = StringField()
nome_genitora = StringField()
data_nascimento = DateTimeField()
data_obito = DateTimeField()
sexo = StringField(max_length=1, choices=PESSOA_SEXO)
cidade_natural = StringField()
estado_natural = StringField(max_length=2)
nacionalidade = StringField(max_length=2)
enderecos = EmbeddedDocumentListField('PartePessoaEndereco')
def __str__(self):
return '{}-{}'.format(self.nome, self.documento_principal)
class Klass(Document):
grade = StringField(required=True)
section = StringField(required=True, unique_with='grade')
student_groups = EmbeddedDocumentListField(StudentGroup)
curriculum = StringField()
datetime_modified = DateTimeField(default=datetime.now())
members = ListField(ReferenceField(Student))
class MockContainer(Document):
mocks = EmbeddedDocumentListField(
MockResource,
element_name='mock',
soft_deletion_key='is_removed')
mock = EmbeddedDocumentField(MockResource, element_name='fmt_mock')
common_mocks = EmbeddedDocumentListField(MockCommonResource, match_key='name')
common_mock = EmbeddedDocumentField(MockCommonResource)
modify_at = DateTimeField(default=None, trigger_modify=True)
meta = {
'db_alias': 'test',
'collection': 'mocks'
}
class TestSuite(Document):
name = StringField(max_length=128, required=True)
scenarios = EmbeddedDocumentListField(Scenario)
def run(self):
data = []
result = True
for scenario in self.scenarios:
scenario.run()
result = scenario.result.result
if result is False:
data.append(scenario.result.data)
if data:
result = False
response_result = Result(result=result, data=data)
return response_result
def from_folder(self, directory):
file_names = os.listdir(directory)
for file_name in file_names:
file_path = os.path.join(directory, file_name)
with open(file_path, "r") as file:
scenario = Scenario.from_json(file.read())
self.scenarios.append(scenario)
class TestSuite(Document):
name = StringField(max_length=128, required=True)
scenarios = EmbeddedDocumentListField(Scenario)
scenarios_folder = StringField(required=False)
def run(self):
if self.scenarios_folder:
self.scenarios = self.from_folder(directory=self.scenarios_folder)
for scenario in self.scenarios:
result = scenario.run()
if result.result:
print("Scenario {} completed successfully!".format(scenario.name))
else:
print("Scenario {} failed, reason:\n{}".format(scenario.name, json.dumps(result.data, indent=2)))
@staticmethod
def from_folder(directory):
file_names = os.listdir(directory)
scenarios = []
for file_name in file_names:
file_path = os.path.join(directory, file_name)
with open(file_path, "r") as file:
scenario = Scenario.from_json(file.read())
scenarios.append(scenario)
return scenarios
class User(DbModelMixin, AuthDocument):
meta = {"db_alias": Database.auth, "strict": strict}
id = StringField(primary_key=True)
name = StringField()
created = DateTimeField()
""" User auth entry creation time """
validated = DateTimeField()
""" Last validation (login) time """
role = StringField(required=True,
choices=get_options(Role),
default=Role.user)
""" User role """
company = StringField(required=True)
""" Company this user belongs to """
credentials = EmbeddedDocumentListField(Credentials, default=list)
""" Credentials generated for this user """
email = EmailField(unique=True, required=True)
""" Email uniquely identifying the user """
class User(UserMixin, db.Document):
meta = {'collection': 'users'}
email = StringField(max_length=35)
data = DateTimeField()
email_confirmation_sent_on = StringField(date=None, nullable=True)
email_confirmed = BooleanField(default=False)
email_confirmed_on = StringField(date=None, nullable=True)
name = StringField(max_length=35)
surname = StringField(max_length=35)
password = StringField()
username = StringField()
image_file = StringField(nullable=False, default='default.jpg')
owned_skills = ListField(StringField())
kskills = EmbeddedDocumentListField(Cskills)
def get_reset_token(self, expires_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expires_sec)
return s.dumps({'email': self.email}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
email = s.loads(token)['email']
except:
return None
return User.objects.get(email=email)
def __repr__(self):
return f"User('{self.username}','{self.email}', '{self.image_file}')"
class Tx(EmbeddedDocument):
segwit = BooleanField(required=True)
tx_hash = BinaryField(unique=True, required=True)
version = IntField(required=True)
tx_ins = ListField(DynamicField(required=True), required=True)
tx_outs = EmbeddedDocumentListField(TxOut, required=True)
locktime = IntField(required=True)
size = IntField(required=True)
class Prescription(db.Document):
prescribed_by = ReferenceField('Doctor')
by_name = StringField()
appointmentId = ReferenceField('Appointment')
notes = StringField()
drugs = EmbeddedDocumentListField(Drug)
date = DateTimeField(default=datetime.utcnow)
prescribed_for = ReferenceField('Patient')
class ScoutSuiteFindingDetails(Document):
# SCHEMA
scoutsuite_rules = EmbeddedDocumentListField(document_type=ScoutSuiteRule, required=False)
def add_rule(self, rule: ScoutSuiteRule) -> None:
if rule not in self.scoutsuite_rules:
self.scoutsuite_rules.append(rule)
self.save()
class Store(EmbeddedDocument):
'''
Holds the data related to a specific store for an item.
'''
name = StringField(min_length=1, max_length=64, required=True)
location = DictField(required=True)
location.validate = validation.validate_location
prices = EmbeddedDocumentListField(Price, required=True)
class Comments(DynamicEmbeddedDocument):
id = StringField()
created_time = IntField()
comment_from = EmbeddedDocumentField(db_field='from', document_type=User)
message = StringField()
likes = DictField(data=EmbeddedDocumentListField(document_type=User))
like_count = IntField()
comment_count = IntField()
class AzureTextAna(EmbeddedDocument):
"""azure 接口对于文本数据分析的结果"""
detected_language = StringField()
""" 取 languageDetection.documents.detectedLanguages.iso6391Name ， eg: 'en' """
detected_language_score = FloatField()
""" 取 languageDetection.documents.detectedLanguages.score , eg: 1.0 """
key_phrases = ListField(StringField(), default=None)
""" 取 keyPhrases.documents.keyPhrases """
doc_sentiment = EmbeddedDocumentField(Sentiment)
""" 取 sentiment.documents 下的内容"""
sentences_sentiment = EmbeddedDocumentListField(Sentiment, default=None)
""" 取 sentiment.documents.sentences 下的内容"""
entities = EmbeddedDocumentListField(EntityInDoc, default=None)
"""取 entities.documents.entities """
entity_linking = EmbeddedDocumentListField(GlobalEntityLinking,
default=None)
"""取 entityLinking.documents.entities """
entity_pii = EmbeddedDocumentListField(EntityInDoc, default=None)
class ValueModel(EmbeddedDocument):
name = StringField(required=True)
description = StringField()
rules = EmbeddedDocumentListField(RuleModel)
type = StringField(
required=True
) # TODO make this have a regex with all the valid types.
value = StringField()
class Help_Request(Document):
channel_id = IntField()
request_user = StringField()
request_status = IntField(default=Help_Request_Status.Pending)
include_groups = ListField(StringField())
include_users = ListField(StringField())
request_create = DateTimeField(default=datetime.datetime.utcnow)
request_closed = DateTimeField(default=None)
chat_log = EmbeddedDocumentListField(EmbeddedChatlog)
class MonkeyFindingDetails(Document):
# SCHEMA
events = EmbeddedDocumentListField(document_type=Event, required=False)
# LOGIC
def add_events(self, events: List[Event]) -> MonkeyFindingDetails:
self.events.extend(events)
self.save()
return self
class DatasetDocument(Document):
"""Backing document that tracks and persists datasets."""
name = StringField(unique=True)
persistent = BooleanField(default=False)
sample_fields = EmbeddedDocumentListField(
document_type=SampleFieldDocument
)
info = DictField(default=dict)
class Athlete(Document):
meta = {'queryset_class': CustomQuerySet}
name = StringField(required=True)
last_name = StringField(required=True)
birth_date = DateField(required=True)
birth_place = StringField(required=True)
fiscal_code = StringField(required=True)
address = StringField(required=True)
zip_code = StringField(required=True, max_length=5)
city = StringField(required=True)
province = StringField(required=True)
gender = StringField(required=True, max_length=1)
phone = StringField(required=True)
email = StringField(required=True)
memberships = EmbeddedDocumentListField(Membership)
tutors = ListField(StringField())
def jsonify(self):
document = super().to_mongo()
if "_id" in document:
document['_id'] = str(document['_id'])
return document
def get_latest_membership(self) -> Optional[DateField]:
if len(self.memberships) == 0:
return None
if len(self.memberships) == 1:
return self.memberships[0].end_date
latest_membership = self.memberships[0].end_date
for membership in self.memberships:
if membership.end_date > latest_membership:
latest_membership = membership.end_date
return latest_membership
def is_enabled(self) -> bool:
for membership in self.memberships:
if membership.end_date > datetime.date.today():
return True
return False
def is_empty(self):
return not self.name \
and not self.last_name \
and not self.birth_date \
and not self.birth_place \
and not self.fiscal_code \
and not self.address \
and not self.city \
and not self.email \
and not self.province \
and not self.gender \
and not self.email
