class User(db.Entity): email = Required(str) username = Optional(str) password = Optional(str, nullable=True) last_login_at = Optional(datetime) current_login_at = Optional(datetime) last_login_ip = Optional(str) current_login_ip = Optional(str) login_count = Optional(int) active = Required(bool, default=True) confirmed_at = Optional(datetime) roles = Set(lambda: Role) def has_role(self, name): return name in {r.name for r in self.roles.copy()}
class Role(db.Entity): _table_ = 'roles' rid = PrimaryKey(int, auto=True) name = Required(str, unique=True) users = Set('User') is_admin = Required(bool) is_group_admin = Required(bool) can_add_group_admin = Required(bool) can_remove_group_admin = Required(bool) is_subgroup_admin = Required(bool) can_add_subgroup_admin = Required(bool) can_remove_subgroup_admin = Required(bool) can_add_templates = Required(bool) can_edit_templates = Required(bool) can_delete_templates = Required(bool) can_add_users = Required(bool) can_edit_users = Required(bool) can_delete_users = Required(bool) can_add_groups = Required(bool) can_edit_groups = Required(bool) can_delete_groups = Required(bool) can_add_subgroups = Required(bool) can_edit_subgroups = Required(bool) can_delete_subgroups = Required(bool) can_add_queue_items = Required(bool) can_edit_queue_items = Required(bool) can_delete_queue_items = Required(bool) can_add_customers = Required(bool) can_edit_customers = Required(bool) can_delete_customers = Required(bool) @classmethod def get_permissions(cls, rid): role = None roles = Role.select(lambda r: rid == rid).prefetch() for each in roles: role = each return role @classmethod def update_permissions(cls, user_id, **kwargs): pass @classmethod def get_all(cls): return Role.select().prefetch()
class Card(db.Entity): """Object containing the data for a card.""" id = PrimaryKey(int, auto=True) name = Required(str) state = Required(str) base_data = Optional(Json) fields = Optional(Json) media_files = Set("MediaFile") dt_queried = Optional(datetime) dt_generated = Optional(datetime) dt_exported = Optional(datetime) template = Required(Template) def __setattr__(self, key, value): """Change state according to values set.""" super().__setattr__(key, value) if key == "base_data": self.dt_queried = datetime.now() self.state = "ready" if key == "fields": self.dt_generated = datetime.now() self.state = "done" if key == "state": update_word_state_dict(self.name, self.state) @db_session def get_media(self, field_key): """Get :class:`MediaFile` of this card by ``field_key`` which is unique.""" media_files = select(m for m in self.media_files if m.field_key == field_key) return toolz.first(media_files) if media_files else None @db_session def add_media(self, **kwargs): """Add a new :class:`MediaFile` to this card.""" media_file = MediaFile(**kwargs, card=self) return media_file @db_session def write_media_files_to_folder(self, folder="."): """Write media-files in :attr:`media_files` to folder with name `folder`.""" media_files = select(m for m in self.media_files) for m_file in media_files: name = f"{self.name}.{m_file.type}" with CD(folder): with open(name, "wb") as file: file.write(m_file.content)
class Match(database.Entity): match_id = PrimaryKey(str) start_time = Required(int) lobby_type = Required(int) radiant_win = Optional(bool) heroes = Set(lambda: Hero) match_seq_num = None radiant_team_id = None dire_team_id = None players = None @staticmethod def fromJSON(s): ID = str(s["match_id"]) match = Match.get(match_id=ID) if match is not None: return None d = {"match_id": ID, "start_time": s["start_time"], "lobby_type": s["lobby_type"], "heroes": []} match = Match(**d) heroes = [] for item in s["players"]: p = Player.fromJSON(item) h = Hero.fromJSON(item, match.match_id, p.account_id) heroes.append(h) match.heroes = heroes return match def detailsFromJSON(self, s): self.radiant_win = s["radiant_win"] def pretty(self): radiant = filter(lambda x: x.faction_id == 0, self.players) dire = filter(lambda x: x.faction_id == 1, self.players) vs = "{:<30s} {:>30s}" coll = ["{:^61s}".format(self)] if self.radiant_win is not None: if self.radiant_win: s = "Radiant Victory" else: s = "Dire Victory" coll.append("{:^61s}".format(s)) for x, y in zip(radiant, dire): coll.append(vs.format(x.pretty(), y.pretty())) return "\n".join(coll)
class Player(database.Entity): account_id = PrimaryKey(str) heroes = Set(lambda: Hero) ranking = Optional(float) @staticmethod def fromJSON(s): d = {'heroes': []} if "account_id" in s: d["account_id"] = str(s["account_id"]) else: d["account_id"] = "-1" p = Player.get(account_id=str(d["account_id"])) if p is not None: return p return Player(**d)
class CaseConfig(db.Entity): """ Sprint Case Configuration """ _table_ = 'case_config' uuid = PrimaryKey(uuid.UUID, default=uuid.uuid4) """Case Created in Sprint""" sprint = Required(Json, default={'field': '', 'value': []}) # Case Created in Requirement requirement = Required(Json, default={'field': '', 'value': []}) # Case Created in Version version = Required(Json, default={'field': '', 'value': []}) sprints = Set('Sprint')
class SensorTemperatureModule(Sensor): registries = Set('SensorTemperatureModuleRegistry', lazy=True) ambient = Optional(bool) def toDict(self, fromdate=None, todate=None): return { "id": "{}:{}".format(self.classtype, self.name), "readings": self.getRegistries(fromdate, todate) } def insertRegistry(self, temperature_dc, time=None): return SensorTemperatureModuleRegistry( sensor=self, time=time or datetime.datetime.now(datetime.timezone.utc), temperature_dc=temperature_dc)
class Switcharoo(db.Entity): id = PrimaryKey(int, auto=True) time = Required(datetime) submission_id = Optional(str, unique=True, nullable=True) thread_id = Optional(str) comment_id = Optional(str) context = Optional(int) link_post = Required(bool) user = Optional(str, max_len=21) subreddit = Optional(str, max_len=21) issues = Set('Issues') requests = Optional('FixRequests', cascade_delete=True) def _link_reddit(self, reddit): self.reddit = reddit self._submission = None self._comment = None @property def submission(self): if not self.submission_id: return None if not self._submission: self._submission = self.reddit.submission(self.submission_id) return self._submission @property def comment(self): if not self.comment_id: return None if not self._comment: self._comment = self.reddit.comment(self.comment_id) return self._comment def print(self): try: if self.submission_id: print( f"Roo {self.id}: {self.submission.title} by {self.submission.author}" f" {datetime.fromtimestamp(self.submission.created_utc)}") else: print( f"Roo {self.id}: {self.comment.author if self.comment.author else ''}" f" {datetime.fromtimestamp(self.comment.created_utc if self.comment.author else '')}" ) except praw.exceptions.ClientException: print(f"Roo {self.id}")
class Author(db.Entity): name = Required(str) books = Set('Book') slug = Optional(str) def before_insert(self): self.slug = slugify(self.name) @property def url(self): return url_for('author', slug=self.slug) def __repr__(self): return '<Author: {}>'.format(self.name) def __str__(self): return self.name
class Genre(db.Entity): name = Required(str, unique=True) books = Set('Book') slug = Optional(str) def before_insert(self): self.slug = slugify(self.name) @property def url(self): return url_for('genre', slug=self.slug) def __repr__(self): return '<Genre: {}>'.format(self.name) def __str__(self): return self.name
class Persoon(db.Entity): id = PrimaryKey(int, auto=True) naam = Required(str) geboortedatum = Required(date) cadeaus = Set('Cadeau') def __init__(self, naam, geboortedatum): self.naam = naam self.geboortedatum = geboortedatum def geef_cadeau(self, aanleiding: str, omschrijving: str) -> Cadeau: datum = datetime.today() cadeau = Cadeau(ontvanger=self, aanleiding=aanleiding, omschrijving=omschrijving, datum=datum) return cadeau
class Item(db.Entity): id = PrimaryKey(int, auto=True) signal = Optional(Signal) tags = Set(Tag) price_item = Optional('PriceItem') argument = Optional('Argument') data_item = Optional('DataItem') symbol = Optional(Symbol) def add_tags(self, tags): """Add multiple tags to item object Arguments: tags {list} -- list of Tags """ for tag in tags: self.tags.add(tag)
class Tag(db.Entity): YAO = 'yahoo' GOG = 'google' USD = 'USD' EUR = 'EUR' IDX = 'index' ICA = 'incomeanalysis' ICF = 'incomefacts' REC = 'recommendation' ICO = 'income' BLE = 'balance' CSH = 'cash' id = PrimaryKey(int, auto=True) name = Optional(str) items = Set('Item') type = Required('Type')
class Announced(db.Entity): date = Required(datetime) title = Required(str) indexer = Required(str) torrent = Required(str) backend = Required(str) snatched = Set("Snatched") def serialize(self, transform_date): return { "id": self.id, "date": transform_date(self.date), "title": self.title, "indexer": self.indexer, "torrent": self.torrent, "backend": self.backend, }
class Users(db.Entity, UserMixin): _table_ = 'sys_users' name = Required(str, unique=True, max_len=50, index='idx_users_name') display = Required(str, max_len=50) password = Required(str, default='-', max_len=64) active = Required(bool, default=True, sql_default=True) last_login_at = Optional(datetime) current_login_at = Optional(datetime) last_login_ip = Optional(str, max_len=50) current_login_ip = Optional(str, max_len=50) login_count = Optional(int, sql_default=0) roles = Set("Roles", table='sys_users_roles') def verify_password(self, password): from flask_security.utils import verify_password return verify_password(password, self.password)
class Matiere(db.Entity, ColorMixin, PositionMixin): referent_attribute_name = "groupe" id = PrimaryKey(UUID, auto=True, default=uuid4) nom = Required(str) groupe = Required("GroupeMatiere") _position = Required(int) _fgColor = Required(int, size=32, unsigned=True, default=4278190080) _bgColor = Optional(int, size=32, unsigned=True, default=4294967295) activites = Set("Activite") def __init__( self, bgColor=None, fgColor=None, groupe=None, position=None, **kwargs ): kwargs = self.adjust_kwargs_color(bgColor, fgColor, kwargs) with self.init_position(position, groupe) as _position: super().__init__(groupe=groupe, _position=_position, **kwargs) def __repr__(self): return f"Matiere[{self.nom}]" @property def activites_list(self): return self.to_dict()["activites"] def to_dict(self): dico = super().to_dict(exclude=["_fgColor", "_bgColor", "_position"]) dico.update( { "id": str(self.id), "groupe": str(self.groupe.id), "fgColor": self.fgColor, "bgColor": self.bgColor, "position": self.position, "activites": [ str(x.id) for x in self.activites.order_by(lambda x: x.position) ], } ) return dico def before_delete(self): self.before_delete_position() def after_delete(self): self.after_delete_position()
class Task(db.Entity): def __str__(self): return self.title and (str(self.id) + ' ' + self.title + ' ' + self.text + ' ' + str(self.status) + ' ' + self.tags + ' ' + datetime_to_str(self.date)) id = PrimaryKey(int, auto=True) creator = Required(int) title = Required(str) text = Required(str) status = Required(int) tags = Optional(str) date = Optional(datetime) parent_id = Optional(int) comment = Set('Comment', cascade_delete=True) periodic_task_id = Optional(int) users = Required(Json)
class Sprint(db.Entity): """ Sprint Information """ _table_ = 'sprint' uuid = PrimaryKey(uuid.UUID, default=uuid.uuid4) name = Required(str) project = Required(Project) issue_config = Required(IssueConfig) case_config = Required(CaseConfig) # Status: active, disable, delete status = Required(str, default='active') issue_capture_sprint_level = Set('IssueCaptureSprintLevel') issue_capture_req_level = Set('IssueCaptureReqLevel') issue_capture_static_project = Set('IssueCaptureStaticProject') issue_capture_static_sprint = Set('IssueCaptureStaticSprint') case_capture_sprint_level = Set('CaseCaptureSprintLevel') case_capture_req_level = Set('CaseCaptureReqLevel') case_capture_static_project = Set('CaseCaptureStaticProject') case_capture_static_sprint = Set('CaseCaptureStaticSprint') grade_report = Set('GradeReportSprint')
class SpotifyUser(db.Entity): _table_ = "spotify_users" id = PrimaryKey(str) # pylint: disable=redefined-builtin name = Optional(str, sql_default="''") user = Optional("User") playlists = Set("Playlist") @property def uri(self): return f"spotify:user:{self.id}" @property def href(self): return f"https://api.spotify.com/v1/users/{self.id}" @property def external_url(self): return f"http://open.spotify.com/user/{self.id}"
class Otazka(db.Entity): """Obecná otázka: * V obecne_zadani se dá specifikovat rozsah náhodného čísla. * typ_otazky: Otevřená, Uzavřená, Hodnota, Vzorec""" _table_ = "otazka" id = PrimaryKey(int, column="id_otazka", auto=True) ucitel = Required("Ucitel") jmeno = Required(unicode, 80) typ_otazky = Required(str, 1, sql_type="char") obecne_zadani = Required(unicode) spravna_odpoved = Optional(unicode, 512) spatna_odpoved1 = Optional(unicode, 512) spatna_odpoved2 = Optional(unicode, 512) spatna_odpoved3 = Optional(unicode, 512) spatna_odpoved4 = Optional(unicode, 512) spatna_odpoved5 = Optional(unicode, 512) spatna_odpoved6 = Optional(unicode, 512) otazky_testuu = Set("Otazka_testu")
class Group(db.Entity): name = Required(str, 255, unique=True) users = Set(User) def update(self, payload={}): update_payload = {} for attribute, value in payload.items(): if attribute == "users": user_emails = [] for user_email in value: user_emails.append(User.get(email=user_email)) update_payload["users"] = user_emails else: update_payload[attribute] = value self.set(**update_payload) def remove(self): self.delete()
class FriseSection(Section): height = Required(int) zones = Set("ZoneFrise") titre = Optional(str) def to_dict(self, **kwargs): dico = super().to_dict(**kwargs) dico["zones"] = [ x.to_dict() for x in self.zones.order_by(lambda x: x.position) ] return dico @classmethod def restore(cls, **kwargs): zones = kwargs.pop("zones", []) new_f = cls(**kwargs) for z in zones: ZoneFrise.restore(**z) return new_f
class ORMContact(db.Entity): _table_ = 'addressbook' id = PrimaryKey(int, column='id') firstname = Optional(str, column='firstname') lastname = Optional(str, column='lastname') deprecated = Optional(datetime, column='deprecated') groups = Set(lambda: ORMFixture.ORMGroup, table="address_in_groups", column="group_id", reverse="contacts", lazy=True) address = Optional(str, column='address') home = Optional(str, column='home') mobile = Optional(str, column='mobile') work = Optional(str, column='work') phone2 = Optional(str, column='phone2') email = Optional(str, column='email') email2 = Optional(str, column='email2') email3 = Optional(str, column='email3')
class SourceUserData(db.Entity): """User-specific data for feed sources.""" source: Attribute = Required(Source) tags: Attribute = Set('Tag') user: Attribute = Required('User') user_label: Attribute = Optional(str) composite_key(source, user) @property def label(self) -> str: """Returns the display label for the source. If there's a user-defined label, uses that, otherwise uses the label fetched from the feed. :return: A string of the display label. """ return self.user_label or self.source.fetched_label
class String(RegisterMixin, database.Entity): inverter = Required(Inverter) name = Required(str) registries = Set('StringRegistry', lazy=True) deviceColumnName = 'string' # used as displayname, might be CCP box name + plug slot or string name stringbox_name = Optional(str, nullable=True) def insertRegistry( self, intensity_mA, time=None, ): return StringRegistry( string=self, time=time or datetime.datetime.now(datetime.timezone.utc), intensity_mA=intensity_mA, )
class User(db.Entity): username = Required(str, unique=True) email = Required(str, unique=True) password_hash = Required(str) books = Set('Book') def is_password_valid(self, plaintext): return bcrypt.checkpw(plaintext.encode('utf8'), self.password_hash.encode('utf8')) def generate_token(self): payload = { 'exp': datetime.utcnow() + timedelta(hours=6), 'iat': datetime.utcnow(), 'sub': self.id } token = jwt.encode(payload, secret, 'HS256').decode('utf8') return token
class Annotation(DB.Entity, Serializable): type_ = Discriminator(str) _discriminator_ = "History" binary = Required(Binary) path = Optional(str) functions = Set("Function") @property def path_obj(self): return Path(self.path) def name(self): return "Matched against history" def serialize(self, **kwargs) -> dict: dict_ = self.to_dict(exclude=["binary", "functions"]) dict_["name"] = self.name() dict_["functions"] = self.functions.count() dict_["path"] = self.path_obj return dict_
class Tag(db.Entity): """Tag entity.""" id = PrimaryKey(UUID, default=uuid4) """Unique identifier for the tag.""" label = Required(str, max_len=32) """Visible label for the tag.""" trashed = Required(bool, default=False) """Trashed status of the tag.""" user = Required(User) """User relationship.""" bookmarks = Set(Bookmark) """Bookmark relationship.""" composite_key(label, user) """Uniqueness constraint on owning user and label."""
class User(db.Entity): email = Required(str) username = Optional(str) security_number = Optional(int) password = Optional(str, nullable=True) last_login_at = Optional(datetime) current_login_at = Optional(datetime) tf_primary_method = Optional(str, nullable=True) tf_totp_secret = Optional(str, nullable=True) tf_phone_number = Optional(str, nullable=True) us_totp_secrets = Optional(str, nullable=True) us_phone_number = Optional(str, nullable=True) last_login_ip = Optional(str) current_login_ip = Optional(str) login_count = Optional(int) active = Required(bool, default=True) confirmed_at = Optional(datetime) roles = Set(lambda: Role) def has_role(self, name): return name in {r.name for r in self.roles.copy()}
class MoleculeStructure(FingerprintMolecule, metaclass=LazyEntityMeta, database='CGRdb'): id = PrimaryKey(int, auto=True) user = DoubleLink(Required('User', reverse='molecule_structures'), Set('MoleculeStructure')) molecule = Required('Molecule') date = Required(datetime, default=datetime.utcnow) last = Required(bool, default=True) data = Required(bytes, optimistic=False) signature = Required(bytes, unique=True) bit_array = Required(IntArray, optimistic=False, index=False, lazy=True) def __init__(self, molecule, structure, user): super().__init__(molecule=molecule, data=dumps(structure), user=user, signature=bytes(structure), bit_array=self.get_fingerprint(structure)) @property def structure(self): if self.__cached_structure is None: self.__cached_structure = loads(self.data) return self.__cached_structure __cached_structure = None