class OpenCallFeedback(db.Entity): id = PrimaryKey(int, auto=True) text = Required(str) user = Required('User') opencall = Required('OpenCall') created_at = Required(datetime.datetime, default=datetime.datetime.utcnow) @db_session def to_dict(self): return { 'id': self.id, 'user': self.user.id, 'opencall': self.opencall.id, 'text': self.text, 'created_at': self.created_at.isoformat() }
class Conditions(db.Entity, UserMixin): _table_ = '%s_conditions' % schema if DEBUG else (schema, 'conditions') id = PrimaryKey(int, auto=True) date = Required(datetime) user_id = Required(int) data = Required(Json) reaction = Required('Reaction') def __init__(self, data, reaction, user, date=None): if date is None: date = datetime.utcnow() db.Entity.__init__(self, user_id=user.id, date=date, reaction=reaction, data=data)
class Task(db.Entity): _table_ = '%s_task' % schema if DEBUG else (schema, 'task') id = PrimaryKey(int, auto=True) task = Required(str, unique=True, sql_type='CHARACTER(36)') date = Required(datetime, default=datetime.utcnow) _type = Required(int, column='type') user = Required('User') data = Required(Json, lazy=True) def __init__(self, data, **kwargs): _type = kwargs.pop('type', TaskType.MODELING).value super().__init__(_type=_type, data=data, **kwargs) @property def type(self): return TaskType(self._type)
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 User(db.Entity): _table_ = 'user' id = PrimaryKey(int, auto=True) uid = Required(uuid.UUID, default=uuid.uuid1, unique=True, index=True) create_at = Required(datetime.datetime, default=datetime.datetime.utcnow(), index=True) update_at = Required(datetime.datetime, default=datetime.datetime.utcnow(), index=True) delete_at = Optional(datetime.datetime, nullable=True) username = Required(str) password = Required(str) info = Optional(str) @classmethod @db_session def register(cls, username, password): obj = get(n for n in User if n.username == username) if obj: raise IsExist(title='此用户已经存在', detail=f'用户名{username}已经存在', type='LoginError') else: User(username=username, password=password) @classmethod @db_session def login(cls, username, password): obj = get(n for n in User if n.username == username and n.password == password) if not obj: raise DefalutError(title=f'用户名密码不正确', detail=f'用户名密码不正确') return obj.uid @classmethod @db_session def user_is_valid(cls, username, uid): obj = get(n for n in User if n.username == username and n.uid == uid) if obj: return True else: raise DefalutError(title=f'token已失效', detail=f'token已失效', status=401, type='AuthError')
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 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 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 Attribute(db.Entity): """Database attribute, linked to any object.""" subset = Required(str) object_class = Required(str) object_id = Required(int) name = Required(str) PrimaryKey(subset, object_class, object_id, name) pickled = Required(bytes) @property def value(self): """Return the unpickled value.""" return pickle.loads(self.pickled) def __repr__(self): return f"<Attribute {self.name!r}>"
class Session(PicklableEntity, db.Entity): """ Session entity. A session is an object identifying a live connection. Each time a user connects, a session is created with a different identifier (UUID). Each time this connection is broken, the session is destroyed. Connections can store data (through the option handler and the attributes handler). Note: if a user connects to the portal, a session is created in the game database. Should the connection remain live but the game be restarted, the connection is maintained and the session information is retrieved from the database. Web sessions, created by the webserver to keep persistent data, are stored in the WebSession entity (see web.session.WebSession). """ uuid = PrimaryKey(UUID, default=uuid4) context_path = Required(str) account = Optional("Account") character = Optional("Character") binary_options = Required(bytes, default=pickle.dumps({})) @lazy_property def context(self): """Find the context.""" Context = CONTEXTS[self.context_path] return Context(self) @context.setter def context(self, context): """Change the session's context.""" self.context_path = context.pyname @property def focused_context(self): """Return the focused context.""" # If there's a character, return the character's active context. if (character := self.character): return character.context_stack.active_context # Otherwise, return the session context return self.context
class Album(db.Entity): _table_ = "album" id = PrimaryKey(UUID, default=uuid4) name = Required(str) artist = Required(Artist, column="artist_id") tracks = Set(lambda: Track) stars = Set(lambda: StarredAlbum) def as_subsonic_album(self, user): info = dict( id=str(self.id), name=self.name, artist=self.artist.name, artistId=str(self.artist.id), songCount=self.tracks.count(), duration=sum(self.tracks.duration), created=min(self.tracks.created).isoformat(), ) track_with_cover = self.tracks.select( lambda t: t.folder.cover_art is not None).first() if track_with_cover is not None: info["coverArt"] = str(track_with_cover.folder.id) else: track_with_cover = self.tracks.select(lambda t: t.has_art).first() if track_with_cover is not None: info["coverArt"] = str(track_with_cover.id) try: starred = StarredAlbum[user.id, self.id] info["starred"] = starred.date.isoformat() except ObjectNotFound: pass return info def sort_key(self): year = min(map(lambda t: t.year if t.year else 9999, self.tracks)) return "%i%s" % (year, self.name.lower()) @classmethod def prune(cls): return cls.select(lambda self: not exists( t for t in Track if t.album == self)).delete()
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 WorkUnit(database.Entity): part_id = PrimaryKey(int, auto=True) batch_id = Required(int) timestamp = Required(datetime) tool_id = Required(str) cup_pressure = Required(float) lower_cup_pressure = Required(float) upper_cup_pressure = Required(float) air_pressure = Required(float) lower_air_pressure = Required(float) upper_air_pressure = Required(float) error = Optional("PressureError") @property def error_code(self) -> int: return 0 if self.lower_cup_pressure < self.cup_pressure < self.upper_cup_pressure else 1 + 0 \ if self.lower_air_pressure < self.air_pressure < self.upper_air_pressure else 2
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 RadioStation(db.Entity): _table_ = "radio_station" id = PrimaryKey(UUID, default=uuid4) stream_url = Required(str) name = Required(str) homepage_url = Optional(str, nullable=True) created = Required(datetime, precision=0, default=now) def as_subsonic_station(self): info = dict( id=str(self.id), streamUrl=self.stream_url, name=self.name, homePageUrl=self.homepage_url, ) return info
class IssueCaptureStaticSprint(db.Entity): """ Capture Static Data for Sprint """ _table_ = 'issue_capture_static_sprint' uuid = PrimaryKey(uuid.UUID, default=uuid.uuid4) capture_time = Required(datetime, default=datetime.now()) sprint = Required(Sprint) in_rc = Required(Json, default={}) found_since = Required(Json, default={ "newfeature": 0, "improve": 0, "qamissed": 0, "others": 0 }) in_req = Required(Json, default={})
class User(db.Entity): id = PrimaryKey(int, auto=True) user_id = Required(int, size=64, unique=True) name = Required(str) roadblocks_count = Required(int, sql_default='0') admin = Required(bool, sql_default='FALSE') banned = Required(bool, sql_default='FALSE') subscribed = Required(bool, sql_default='FALSE') def is_subscribed(self) -> bool: return self.subscribed def is_admin(self) -> bool: return self.admin def is_banned(self) -> bool: return self.banned
class Result(db.Entity): _table_ = '%s_result' % schema if DEBUG else (schema, 'result') id = PrimaryKey(int, auto=True) key = Required(str) model = Required('Model') result_type = Required(int) structure = Required('Structure') value = Required(str) def __init__(self, **kwargs): _type = kwargs.pop('type', ResultType.TEXT).value _model = db.Model[kwargs.pop('model')] super(Result, self).__init__(result_type=_type, model=_model, **kwargs) @property def type(self): return ResultType(self.result_type)
class Helper(db.Entity): phone = PrimaryKey(str) first_name = Required(str) last_name = Required(str) email = Required(str) lon = Required(float) lat = Required(float) zip_code = Required(str) location_name = Required(str) is_active = Required(bool) verified = Required(bool, default=False) last_called = Required(datetime.datetime, hidden=True) verify_code = Optional(str, nullable=True, hidden=True) def to_dict(self): return super(Helper, self).to_dict(exclude=["last_called", "verify_code"])
class BandwidthTransaction(db.Entity): """ This class describes a bandwidth transaction that resides in the database. """ sequence_number = Required(int) public_key_a = Required(bytes, index=True) public_key_b = Required(bytes, index=True) signature_a = Required(bytes) signature_b = Required(bytes) amount = Required(int, size=64) timestamp = Required(int, size=64) PrimaryKey(sequence_number, public_key_a, public_key_b) @classmethod @db_session(optimistic=False) def insert(cls, transaction: BandwidthTransaction) -> None: """ Insert a BandwidthTransaction object in the database. Remove the last transaction with that specific counterparty while doing so. :param transaction: The transaction to insert in the database. """ if not bandwidth_database.store_all_transactions: # Make sure to only store the latest pairwise transaction. for tx in cls.select( lambda c: c.public_key_a == transaction.public_key_a and c.public_key_b == transaction.public_key_b): tx.delete() db.commit() cls(**transaction.get_db_kwargs()) elif not bandwidth_database.has_transaction(transaction): # We store all transactions and it does not exist yet - insert it. cls(**transaction.get_db_kwargs()) if transaction.public_key_a == bandwidth_database.my_pub_key or \ transaction.public_key_b == bandwidth_database.my_pub_key: # Update the balance history timestamp = int(round(time.time() * 1000)) db.BandwidthHistory( timestamp=timestamp, balance=bandwidth_database.get_my_balance()) num_entries = db.BandwidthHistory.select().count() if num_entries > bandwidth_database.MAX_HISTORY_ITEMS: # Delete the entry with the lowest timestamp entry = list(db.BandwidthHistory.select().order_by( db.BandwidthHistory.timestamp))[0] entry.delete()
class User(db.Entity): _table_ = "user" id = PrimaryKey(UUID, default=uuid4) name = Required(str, 64) # unique mail = Optional(str) password = Required(str, 40) salt = Required(str, 6) admin = Required(bool, default=False) lastfm_session = Optional(str, 32, nullable=True) lastfm_status = Required( bool, default=True) # True: ok/unlinked, False: invalid session last_play = Optional(Track, column="last_play_id") last_play_date = Optional(datetime, precision=0) clients = Set(lambda: ClientPrefs) playlists = Set(lambda: Playlist) __messages = Set(lambda: ChatMessage, lazy=True) # Never used, hide it starred_folders = Set(lambda: StarredFolder, lazy=True) starred_artists = Set(lambda: StarredArtist, lazy=True) starred_albums = Set(lambda: StarredAlbum, lazy=True) starred_tracks = Set(lambda: StarredTrack, lazy=True) folder_ratings = Set(lambda: RatingFolder, lazy=True) track_ratings = Set(lambda: RatingTrack, lazy=True) def as_subsonic_user(self): return dict( username=self.name, email=self.mail, scrobblingEnabled=self.lastfm_session is not None and self.lastfm_status, adminRole=self.admin, settingsRole=True, downloadRole=True, uploadRole=False, playlistRole=True, coverArtRole=False, commentRole=False, podcastRole=False, streamRole=True, jukeboxRole=False, shareRole=False, )
class Conversation(db.Entity): """ https://api.slack.com/types/conversation """ id = PrimaryKey(str, auto=False) name = Optional(str) normalized_name = Optional(str) purpose = Optional(str) is_channel = Optional(bool) is_im = Optional(bool) is_archived = Optional(bool) is_general = Optional(bool) is_shared = Optional(bool) is_member = Optional(bool) is_private = Optional(bool) is_mpim = Optional(bool) created = Required(int) scanned_ranges = Optional(Json, default=[]) messages_processed = Required(int) reached_end = Required(bool, default=False) latest_ts = Optional(str) reached_now = Optional(bool, default=False) @staticmethod def from_dict(convo): Conversation( id=convo.get('id'), name=convo.get('name', 'N/A'), normalized_name=convo.get('normalized_name', 'N/A'), purpose=convo.get('purpose', {}).get('value', ''), is_channel=convo.get('is_channel', False), is_im=convo.get('is_im', False), is_archived=convo.get('is_archived', False), is_general=convo.get('is_general', False), is_shared=convo.get('is_shared', False), is_member=convo.get('is_member', False), is_private=convo.get('is_private', False), is_mpim=convo.get('pyis_mpim', False), created=int(convo.get('created')), scanned_ranges=convo.get('scanned_ranges', []), messages_processed=int(convo.get('messages_processed', 0)), reached_end=convo.get('reached_end', False), reached_now=convo.get('reached_now', False), latest_ts=convo.get('latest_ts', '') )
class Course(db.Entity): """ A class to represent a course """ id = PrimaryKey(int, auto=False) title = Required(str, unique=True) url = Optional(str, unique=True) thumbnail = Optional(str) processed = Optional(bool, default=False) @staticmethod @db_session def new(id, title, url='', thumbnail='', processed=False): """Return a Course either new or from database""" course = select(c for c in Course if c.title == title)[:] if course: return course[0] return Course(id=id, title=title, url=url, thumbnail=thumbnail, processed=processed) @staticmethod @db_session def is_course_new(course): """ Check if the course is new or already in db """ return not course.processed @staticmethod @db_session def add_course(course): """Add a course to the database""" course.processed = True commit() @staticmethod @db_session def count(): """Get total courses in the database""" return len(select(c for c in Course)[:]) @staticmethod @db_session def delete_all(): """Delete all information from the table""" delete(c for c in Course)
class Flows(flows.get_database().Entity): _table_ = "flows" id = PrimaryKey(int, auto=True) in_port = Optional(str, nullable=True) eth_dst = Optional(str, nullable=True) eth_src = Optional(str, nullable=True) eth_type = Optional(str, nullable=True) ipv6_src = Optional(str, nullable=True) ipv6_dst = Optional(str, nullable=True) layer4_protocol = Optional(str, nullable=True) tcp_src = Optional(str, nullable=True) tcp_dst = Optional(str, nullable=True) udp_src = Optional(str, nullable=True) udp_dst = Optional(str, nullable=True) icmpv6_type = Optional(str, nullable=True) icmpv6_code = Optional(str, nullable=True) action = Optional(str, nullable=True) expiration_time = Optional(datetime, 6)
class Document(_db.Entity): id = PrimaryKey(int, auto=True) html = Optional(str) brand = Optional(str) gtin13 = Optional(str) ean = Optional(str) asin = Optional(str) sku = Optional(str) price = Optional(float) currency = Optional(str) vendor = Optional(str) language = Optional(str) tokens = Optional(bytes) brand_bio_labels = Optional(bytes) ean_bio_labels = Optional(bytes) windows_5 = Optional(bytes) windows_11 = Optional(bytes) windows_21 = Optional(bytes)
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 MediaFile(db.Entity): """Class containing a media-file.""" id = PrimaryKey(int, auto=True) """Unique id.""" type = Required(str) """File type, e.g. "mp3", "jpg", "png", etc. ...""" field_key = Required(str) """Name of the field of the card which the content belongs to.""" content = Required(buffer) """Bytes object with media-file.""" card = Required(Card) """Relation to :class:`Card` object.""" @db_session def update(self, **kwargs): """Update attributes by ``*kwargs``.""" for key, val in kwargs.items(): setattr(self, key, val)
class PrivatedSubs(db.Entity): subreddit = PrimaryKey(str, max_len=21) allowed = Optional(bool) expiration = Optional(datetime) update_requested = Required(bool) def is_expired(self): if self.expiration: return datetime.now() > self.expiration else: # If this has no expiration set, it never expires return False def reset(self): with db_session: p = PrivatedSubs[self.subreddit] p.delete() return None
class Model(db.Entity): _table_ = '%s_model' % schema if DEBUG else (schema, 'model') id = PrimaryKey(int, auto=True) description = Optional(str) destinations = Set('Destination') example = Optional(str) model_type = Required(int) name = Required(str, unique=True) results = Set('Result') def __init__(self, **kwargs): _type = kwargs.pop('type', ModelType.MOLECULE_MODELING).value super(Model, self).__init__(model_type=_type, **filter_kwargs(kwargs)) @property def type(self): return ModelType(self.model_type)
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")