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