class User(MongoModel): id = fields.CharField(primary_key=True) uuid = fields.CharField() email = fields.EmailField() name = fields.CharField() surname = fields.CharField() authmethod = fields.CharField() password = fields.CharField(required=True) mfa_hash = fields.CharField() first_login = fields.DateTimeField(blank=True) last_login = fields.DateTimeField(blank=True) last_password_change = fields.DateTimeField(blank=True) is_active = fields.BooleanField(default=True) privacy_accepted = fields.BooleanField(default=True) expiration = fields.DateTimeField(blank=True) roles = fields.EmbeddedDocumentListField(Role, blank=True) belongs_to = fields.EmbeddedDocumentField("Group", blank=True) class Meta: # write_concern = WriteConcern(j=True) connection_alias = AUTH_DB indexes = [ IndexModel("uuid", unique=True), IndexModel("email", unique=True) ]
class EncodeStream(HardwareStream): def __init__(self, *args, **kwargs): super(EncodeStream, self).__init__(*args, **kwargs) relay_video = fields.BooleanField(default=constants.DEFAULT_RELAY_VIDEO, required=True) relay_audio = fields.BooleanField(default=constants.DEFAULT_RELAY_AUDIO, required=True) deinterlace = fields.BooleanField(default=constants.DEFAULT_DEINTERLACE, required=True) frame_rate = fields.IntegerField(default=constants.INVALID_FRAME_RATE, required=True) volume = fields.FloatField(default=constants.DEFAULT_VOLUME, required=True) video_codec = fields.CharField(default=constants.DEFAULT_VIDEO_CODEC, required=True) audio_codec = fields.CharField(default=constants.DEFAULT_AUDIO_CODEC, required=True) audio_channels_count = fields.IntegerField( default=constants.INVALID_AUDIO_CHANNELS_COUNT, required=True) size = fields.EmbeddedDocumentField(Size, default=Size()) video_bit_rate = fields.IntegerField( default=constants.INVALID_VIDEO_BIT_RATE, required=True) audio_bit_rate = fields.IntegerField( default=constants.INVALID_AUDIO_BIT_RATE, required=True) logo = fields.EmbeddedDocumentField(Logo, default=Logo()) rsvg_logo = fields.EmbeddedDocumentField(RSVGLogo, default=RSVGLogo()) aspect_ratio = fields.EmbeddedDocumentField(Rational, default=Rational()) def get_type(self) -> constants.StreamType: return constants.StreamType.ENCODE def get_relay_video(self): return self.relay_video def get_relay_audio(self): return self.relay_audio def get_deinterlace(self): return self.deinterlace def get_frame_rate(self): return self.frame_rate def get_volume(self): return self.volume def get_video_codec(self): return self.video_codec def get_audio_codec(self): return self.audio_codec def get_audio_channels_count(self): return self.audio_channels_count def get_video_bit_rate(self): return self.video_bit_rate def get_audio_bit_rate(self): return self.audio_bit_rate
class Person(EmbeddedMongoModel): name = fields.CharField(blank=True) dietary_vegetarian = fields.BooleanField(default=False) dietary_gluten_free = fields.BooleanField(default=False) dietary_other = fields.CharField(blank=True)
class UserStream(EmbeddedMongoModel): FAVORITE_FIELD = 'favorite' PRIVATE_FIELD = 'private' RECENT_FIELD = 'recent' sid = fields.ReferenceField(IStream, required=True) favorite = fields.BooleanField(default=False) private = fields.BooleanField(default=False) recent = fields.DateTimeField(default=datetime.utcfromtimestamp(0)) interruption_time = fields.IntegerField( default=0, min_value=0, max_value=constants.MAX_VIDEO_DURATION_MSEC, required=True) def get_id(self) -> str: return str(self.pk) @property def id(self): return self.pk def to_front_dict(self): res = self.sid.to_front_dict() res[UserStream.FAVORITE_FIELD] = self.favorite res[UserStream.PRIVATE_FIELD] = self.private res[UserStream.RECENT_FIELD] = date_to_utc_msec(self.recent) return res
class Repair(MongoModel): deadline = fields.DateTimeField() machineID = fields.IntegerField() rtype = fields.CharField() description = fields.CharField() in_progress = fields.BooleanField() completed = fields.BooleanField()
class S_value(EmbeddedMongoModel): name = fields.CharField(required=True) display_name = fields.CharField(required=True) scope = fields.CharField(required=True) # sample/all type_ = fields.CharField(required=True) # number/text/date/file showuser = fields.BooleanField(required=True) required = fields.BooleanField(required=False, default=True)
class Application(MongoModel): _id = fields.CharField(required=True, primary_key=True) app_id = fields.CharField(required=True, verbose_name='app_id', mongo_name='appId') app_hash = fields.CharField(required=True, verbose_name='app_hash', mongo_name='appHash') app_secure = fields.BinaryField(required=True, verbose_name='app_secure', mongo_name='appCrypt') app_manager = fields.EmbeddedDocumentField(AppManager, required=True, verbose_name='app_manager_info', mongo_name='appManager') created_date = fields.DateTimeField(verbose_name='app_created_date', mongo_name='createdDate', required=True) app_is_valid = fields.BooleanField(required=True, verbose_name='app_is_valid', mongo_name='isValid', default=True) valid_until = fields.DateTimeField(required=True, verbose_name='app_valid_until', mongo_name='validUntil') is_deleted = fields.BooleanField(verbose_name='app_is_deleted', mongo_name='isDeleted', default=False) deleted_date = fields.DateTimeField(verbose_name='user_deleted_date', mongo_name='deletedDate', default=None) class Meta: connection_alias = 'Application' collection_name = 'registeredApps' cascade = True write_concern = wc.WriteConcern(j=True) read_preference = ReadPreference.NEAREST read_concern = rc.ReadConcern(level='majority') indexes = [ IndexModel('appId', name='appIdIndex', unique=True, sparse=True), IndexModel('appHash', name='appHashIndex', unique=True, sparse=True), IndexModel('appCrypt', name='appCryptIndex', unique=True, sparse=True), IndexModel('createdDate', name='createdDateIndex', sparse=True), IndexModel('validUntil', name='validUntilIndex', sparse=True), IndexModel('appManager.email', name='managerEmailIndex', sparse=True, unique=True) ] ignore_unknown_fields = True
class MessageFilter(MongoModel): name = fields.CharField() text = fields.CharField() exclude = fields.BooleanField() full_text = fields.BooleanField() class Meta: connection_alias = 'mongobot' write_concern = WriteConcern(j=True)
class User(MongoModel): email = fields.EmailField(required=False, mongo_name='email') name = fields.CharField(required=False, mongo_name='name') mobile_no = fields.CharField(min_length=10, max_length=10, required=False, mongo_name='mobile_no') role = fields.CharField(choices=('mentor', 'student', 'admin'), required=False, mongo_name='role') photo_url = fields.CharField(mongo_name='photo_url', default=None) uploaded_photo_url = fields.CharField(mongo_name='uploaded_photo_url', default=None) user_token = fields.CharField(mongo_name='user_token') user_group = fields.CharField(mongo_name='user_group', default=None) nickname = fields.CharField(mongo_name='nickname') preferences = fields.ListField(mongo_name='preferences') created_at = fields.DateTimeField(mongo_name='created_at') updated_at = fields.DateTimeField(mongo_name='updated_at') linkedin = fields.CharField(mongo_name='linkedin') certificates = fields.CharField(mongo_name='certificates') courses = fields.CharField(mongo_name='courses') background = fields.CharField(mongo_name='background') mentor_verified = fields.BooleanField(mongo_name='mentor_verified', default=False) hours_per_day = fields.CharField(mongo_name='hours_per_day') login_status = fields.BooleanField(mongo_name='login_status', default=True) sessions = fields.BigIntegerField(mongo_name='sessions', default=0) class Meta: write_concern = WriteConcern(j=True) ignore_unknown_fields = True connection_alias = 'onx-app' final = True def clean(self): if self.email != None: self.check_duplicate_user() self.validate_user_group() def check_duplicate_user(self): try: User.objects.get({'email': self.email}) raise ValidationError('User with this email already exist') except User.DoesNotExist: pass def validate_user_group(self): try: if self.user_group != None: group = CorporateGroup.objects.get({'code': self.user_group}) self.user_group = str(group._id) else: pass except Exception as e: message = "Invalid corporate code." if str(e) == "" else str(e) raise ValidationError(message)
class SoftwareComponent(EmbeddedMongoModel): name = fields.CharField(primary_key=True) package = fields.CharField() version = fields.CharField() version_uid = fields.CharField() update_available = fields.BooleanField() config_mismatch = fields.BooleanField() uncommitted_changes = fields.BooleanField()
class ChannelAdmin(EmbeddedMongoModel): uid = fields.ReferenceField(User, on_delete=fields.ReferenceField.CASCADE, verbose_name='user_id', mongo_name='userId', required=True) admin_since = fields.DateTimeField(verbose_name='admin_since', mongo_name='adminJoinDate', required=True) can_post = fields.BooleanField(verbose_name='admin_can_post', mongo_name='adminCanPost', default=True) can_edit_others = fields.BooleanField(verbose_name='admin_can_edit_others', mongo_name='adminCanEditOthers', default=False) can_delete_others = fields.BooleanField(verbose_name='admin_can_delete_others', mongo_name='adminCanDeleteOthers', default=False) can_update_channel_info = fields.BooleanField(verbose_name='admin_can_update_channel_info', mongo_name='adminCanUpdateChannelInfo', default=False)
class Result(MongoModel): # "doi": "The DOI of the record", doi = fields.CharField(primary_key=True) scores = fields.EmbeddedDocumentListField('Score') persisted = fields.BooleanField(required=True) # "contentType": "Type of the content (e.g. Article)", contentType = fields.CharField(blank=True) # "title": "The title of the record", title = fields.CharField(blank=True) # "authors": ["Full name of one creator"], authors = fields.ListField(blank=True) # "publicationName": "Name of the publication", publicationName = fields.CharField(blank=True) # "openAccess": "Bool: Belongs to openaccess collection", openAccess = fields.BooleanField(blank=True) # "publisher": "Name of the publisher", publisher = fields.CharField(blank=True) # "publicationDate": "Date of publication", publicationDate = fields.CharField(blank=True) # "publicationType": "Type of publication", publicationType = fields.CharField(blank=True) # "issn": "International Standard Serial Number", issn = fields.CharField(blank=True) # "volume": "Volume of the publication", volume = fields.CharField(blank=True) # "number": "Number of the publication", number = fields.CharField(blank=True) # "genre": ["Name of one genre"], genre = fields.ListField(blank=True) # "pages": { # "first": "First page in publication", # "last": "Last page in publication" # }, pages = fields.ListField(blank=True) # "journalId": "ID of the publication journal", journalId = fields.CharField(blank=True) # "copyright": "Copyright notice", copyright = fields.CharField(blank=True) # "abstract": "Abstract (Summary)", abstract = fields.CharField(blank=True) # "uri": "Link to the record" uri = fields.CharField(blank=True) # printIsbn = fields.CharField(blank=True) electronicIsbn = fields.CharField(blank=True) isbn = fields.CharField(blank=True) class Meta: ignore_unknown_fields = True
class MDBHyperpipeInfo(EmbeddedMongoModel): class Meta: final = True connection_alias = "photon_core" data = fields.DictField(blank=True) cross_validation = fields.DictField(blank=True) optimization = fields.DictField(blank=True) flowchart = fields.CharField(blank=True) metrics = fields.ListField(blank=True) best_config_metric = fields.CharField(blank=True) maximize_best_config_metric = fields.BooleanField(blank=True) estimation_type = fields.CharField(blank=True) eval_final_performance = fields.BooleanField(blank=True)
class SectionDiff(EmbeddedMongoModel): heading = fields.CharField() level = fields.IntegerField() body = fields.CharField(blank=True) body_diff = fields.CharField(blank=True) inserted = fields.BooleanField(default=False) deleted = fields.BooleanField(default=False) edited = fields.BooleanField(default=False) idx = fields.IntegerField(default=None) @property def is_empty(self): return not (self.inserted or self.deleted or self.edited)
class Pipeline(CreatedUpdated, DeleteObjectsMixin, MongoModel): from newsgac.users.models import User from newsgac.data_sources.models import DataSource from newsgac.tasks.models import TrackedTask user = fields.ReferenceField(User, required=True) display_title = fields.CharField(required=True) created = fields.DateTimeField() updated = fields.DateTimeField() data_source = fields.ReferenceField(DataSource, required=True, blank=False) stop_words = fields.ReferenceField(StopWords, required=False, blank=True) lowercase = fields.BooleanField(required=True, default=False) lemmatization = fields.BooleanField(required=True, default=False) quote_removal = fields.BooleanField(required=True, default=True) nlp_tool = fields.EmbeddedDocumentField(NlpTool, blank=True, required=True, default=TFIDF.create()) learner = fields.EmbeddedDocumentField(Learner) sk_pipeline = ObjectField() result = fields.EmbeddedDocumentField(Result, blank=True) grid_search_result = ObjectField() task = fields.EmbeddedDocumentField(TrackedTask, default=TrackedTask()) @classmethod def create(cls): return cls( display_title="", data_source=None, stop_words=cls.stop_words.default, lowercase=cls.lowercase.default, lemmatization=cls.lemmatization.default, nlp_tool=cls.nlp_tool.default, learner=LearnerSVC.create() ) def get_feature_extractor(self): raise NotImplementedError('Subclass should implement get_feature_extractor') def get_sk_pipeline(self): return get_sk_pipeline(self) def delete(self): from newsgac.ace import ACE # delete this pipeline from related ace runs for ace in ACE.objects.raw({'pipelines': {'$in': [self.pk]}}): ace.delete_pipeline(self) super(Pipeline, self).delete()
class Post(MongoModel): reddit_post_id = fields.CharField(required=True, primary_key=True) subreddit = fields.CharField() artist = fields.CharField() album = fields.CharField() album_type = fields.CharField() total_tracks = fields.IntegerField() spotify_album_uri = fields.CharField() track = fields.CharField() track_num = fields.IntegerField() spotify_track_uri = fields.CharField() created_utc = fields.DateTimeField() upvotes = fields.IntegerField() exists_in_playlist = fields.BooleanField(default=False) parsed_artist = fields.CharField() parsed_title = fields.CharField() class Meta: connection_alias = "FreshTracks" collection_name = "post" # Ensure that only one track per same album can exist in each subreddit # playlist indexes = [ IndexModel(keys=[("spotify_album_uri", pymongo.ASCENDING), ("subreddit", pymongo.ASCENDING)], unique=True) ]
class TopicVersionDiff(VersionDiff): sections = fields.EmbeddedDocumentListField(SectionDiff, blank=True) summary = fields.CharField(blank=True) summary_diff = fields.CharField(blank=True) summary_changed = fields.BooleanField() name = fields.CharField(blank=True) prev_name = fields.CharField(blank=True) @property def is_empty(self): return not (self.summary_changed or self.name_changed or any(not section.is_empty for section in self.sections)) @property def name_changed(self): return self.name != self.prev_name @staticmethod def compute(version_a, version_b): sections = diff_sections(version_a.sections, version_b.sections) summary_diff = markup_changes(version_a.summary, version_b.summary) name = version_b.name prev_name = version_a.name return TopicVersionDiff( version_a=version_a, version_b=version_b, sections=sections, summary=version_b.summary, summary_diff=summary_diff, summary_changed=version_a.summary != version_b.summary, name=name, prev_name=prev_name, )
class Response(BaseMongoModel): id = fields.ObjectIdField(primary_key=True) form = fields.ReferenceField(Form, on_delete=fields.ReferenceField.CASCADE) user = fields.ReferenceField(User, on_delete=fields.ReferenceField.CASCADE, blank=True) # paymentInfo = fields.EmbeddedDocumentField(PaymentInfo) paymentInfo = fields.DictField() payment_status_detail = fields.EmbeddedDocumentListField( PaymentStatusDetailItem, blank=True, default=list) paid = fields.BooleanField(default=False) amount_paid = fields.CharField(default="0") payment_trail = fields.EmbeddedDocumentListField(PaymentTrailItem, blank=True, default=list) update_trail = fields.EmbeddedDocumentListField(UpdateTrailItem, blank=True, default=list) email_trail = fields.EmbeddedDocumentListField(EmailTrailItem, blank=True, default=list) value = fields.DictField() date_created = fields.DateTimeField(required=True) date_modified = fields.DateTimeField(required=True) pending_update = fields.DictField(blank=True) admin_info = fields.DictField() modify_link = fields.CharField(blank=True) predicate = fields.DictField() counter = fields.IntegerField(blank=True)
class Batch(EmbeddedMongoModel): workflow = fields.ReferenceField(Workflow, required=True) step_cat = fields.CharField(required=True) batch_name = fields.CharField(required=True) batch_created_on = fields.DateTimeField(required=True) position = fields.EmbeddedDocumentField(PositionInPlate, required=True) archived = fields.BooleanField(required=True, default=False)
class Activity(MongoModel): user_id = fields.CharField(mongo_name='user_id') session_id = fields.CharField(mongo_name='session_id') is_dynamic = fields.BooleanField(mongo_name='is_dynamic') content = fields.CharField(mongo_name='content') created_at = fields.DateTimeField(required=False, mongo_name='created_at') updated_at = fields.DateTimeField(mongo_name='updated_at') class Meta: write_concern = WriteConcern(j=True) ignore_unknown_fields = True connection_alias = 'onx-app' def clean(self): # self.validate_user() pass def validate_user(self): try: if self.user_id != None: user = User.objects.get({'_id': ObjectId(self.user_id)}) # else: # raise ValidationError("user_id is mandatory for creating an activity.") except Exception as e: message = 'User does not exists' if str(e) == "" else str(e) raise ValidationError(message)
class BookmarksDiff(MongoModel): version_a = fields.ReferenceField(BookmarksVersion) version_b = fields.ReferenceField(BookmarksVersion) sections = fields.EmbeddedDocumentListField(SectionDiff, blank=True) summary = fields.CharField(blank=True) summary_diff = fields.CharField(blank=True) summary_changed = fields.BooleanField() @property def is_empty(self): return not ( self.summary_changed or any(not section.is_empty for section in self.sections) ) @staticmethod def compute(version_a, version_b): sections = diff_sections(version_a.sections, version_b.sections) summary_diff = markup_changes(version_a.summary, version_b.summary) return BookmarksDiff( version_a=version_a, version_b=version_b, sections=sections, summary=version_b.summary, summary_diff=summary_diff, summary_changed=version_a.summary != version_b.summary, )
class Emergency(MongoModel): etype = fields.CharField() location = fields.ListField(fields.CharField()) num_victims = fields.IntegerField(min_value=0) num_aggressors = fields.IntegerField(min_value=0) pers_involved = fields.ListField(fields.ReferenceField(Person)) is_active = fields.BooleanField(default=True)
class LogInfo(MongoModel): """日志记录""" log = fields.CharField() create = fields.DateTimeField() fetched = fields.BooleanField(default=False) log_type = fields.IntegerField(mongo_name='type') class Meta: connection_alias = DB_LOG collection_name = CN_COMMON_LOG @classmethod def grouped_unfetched_logs(cls, types): try: all_unfetcheds = list(cls.objects.raw({'fetched': False, 'type': {'$in': types}}).order_by([('log', 1)])) if not all_unfetcheds: return [] else: grouped = dict() for log in all_unfetcheds: l_type = log.log_type grouped[l_type] = grouped[l_type] + [log] if grouped.get(l_type) else [log] return list(grouped.values()) except Exception as e: print("Get logs failed, " + str(e)) return []
class PersonSpecialization(MongoModel): person_id = ValidatedReferenceField(Person, on_delete=ReferenceField.CASCADE) department_id = ValidatedReferenceField(Department, on_delete=ReferenceField.CASCADE) specialization_id = ValidatedReferenceField( Specialization, on_delete=ReferenceField.CASCADE) level = fields.FloatField(default=None, blank=True) details = fields.DictField() is_active = fields.BooleanField(required=True, default=True) def save(self, cascade=None, full_clean=True, force_insert=False): super().save(cascade, full_clean, force_insert) update_person_subrating(PersonSpecialization, self.person_id) class Meta: write_concern = WriteConcern(w=1) connection_alias = "reviewer" final = True indexes = [ IndexModel([("person_id", pymongo.DESCENDING), ("department_id", pymongo.DESCENDING), ("specialization_id", pymongo.DESCENDING)], unique=True), IndexModel("department_id"), IndexModel("specialization_id") ]
class HealthContext(EmbeddedMongoModel): status = fields.CharField() isPhysicallyHurt = fields.BooleanField(default=False) diseases = fields.ListField(fields.CharField()) aggressions = fields.ListField(fields.CharField()) injuries = fields.ListField(fields.CharField()) disorders = fields.DictField()
class UsuarioModel(MongoModel): username = fields.CharField() password = fields.CharField() estatus = fields.BooleanField() fecha_alta = fields.DateTimeField() fecha_baja = fields.DateTimeField() dbreferencia = fields.ReferenceField(CajeroModel)
class TaskStatus(MongoModel): task = fields.ReferenceField(Task, primary_key=True, required=True) status = fields.IntegerField(default=TaskStatusConst.UNALLOCATED) delayed = fields.BooleanField(default=False) progress = fields.EmbeddedDocumentField(TaskProgress) objects = TaskStatusManager() class Meta: archive_collection = 'task_status_archive' ignore_unknown_fields = True def archive(self): with switch_collection(TaskStatus, TaskStatus.Meta.archive_collection): super().save() self.delete() def update_progress(self, action_id, action_status, **kwargs): self.refresh_from_db() if not self.progress: self.progress = TaskProgress() self.progress.initialize(action_id, self.task.plan) self.save() self.progress.update(action_id, action_status, **kwargs) self.save(cascade=True)
class BotConfig(MongoModel): REMINDERS_CHANNEL = fields.IntegerField(blank=True) IS_MAINTENANCE = fields.BooleanField() CTFTIME_TEAM_ID = fields.CharField() HTB_TEAM_ID = fields.CharField() ADMIN_ROLE = fields.CharField() EXTENSIONS = fields.EmbeddedDocumentListField(CogDetails, default=[])
class UserDetails(MongoModel): '''Model to maintain user details. Attributes: createdOn: Datetime object updatedOn: Datetime object ''' createdOn = fields.DateTimeField(required=True, default=lambda: datetime.now()) updatedOn = fields.DateTimeField(required=True, default=lambda: datetime.now()) email = fields.EmailField(required=True, primary_key=False) pincode = fields.CharField(required=False, blank=True) district = fields.CharField(required=False, blank=True) active = fields.BooleanField(required=True, default=False) alertCount = fields.IntegerField(required=True, default=0) age = fields.IntegerField(required=True) objects = UserDetailsManager() class Meta: collection_name = 'UserDetails' indexes = [ IndexModel( [ ('pincode', DESCENDING), ('district', DESCENDING) ], background=True ) ] final = True
class MDBHyperpipe(MongoModel): class Meta: final = True connection_alias = 'photon_core' name = fields.CharField() version = fields.CharField() output_folder = fields.CharField(blank=True) permutation_id = fields.CharField(blank=True) permutation_failed = fields.CharField(blank=True) permutation_test = fields.EmbeddedDocumentField(MDBPermutationResults, blank=True) computation_completed = fields.BooleanField(default=False) computation_start_time = fields.DateTimeField(blank=True) computation_end_time = fields.DateTimeField(blank=True) outer_folds = fields.EmbeddedDocumentListField(MDBOuterFold, default=[], blank=True) best_config = fields.EmbeddedDocumentField(MDBConfig, blank=True) best_config_feature_importances = fields.ListField(blank=True) metrics_train = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True) metrics_test = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True) hyperpipe_info = fields.EmbeddedDocumentField(MDBHyperpipeInfo) # dummy estimator dummy_estimator = fields.EmbeddedDocumentField(MDBDummyResults, blank=True) # stuff for wizard connection user_id = fields.CharField(blank=True) wizard_object_id = fields.ObjectIdField(blank=True) wizard_system_name = fields.CharField(blank=True)