class Document(db.Entity): # url = pony.orm.core.Index(Required(str)) url_sha = PrimaryKey(str) url = Required(str, unique=True) filename = Required(str) mtime = Required(int) content = Optional(LongStr) content_sha = Optional(str) tokens = Set("Token") tokfreq = Required(bytes)
class PollutionForecast(db.Entity): # Модель данных прогноза загрязнения id = PrimaryKey(int, auto=True) station_id = Required('Station') pollution_type = Required('PollutionType') timestamp = Required(str) datetime = Required(datetime) delta_hour = Required(int) predictor = Required(str) value = Required(float)
class City(db.Entity): id = PrimaryKey(int, auto=True) name = Required(str, unique=True) complaints = Set('Complaint') opencalls = Set('OpenCall') users = Set('User') @db_session def to_dict(self): return {'id': self.id, 'name': self.name}
class Project(db.Entity): _table_ = 'Project' id = PrimaryKey(str) name = Required(str, unique=True) sub_name = Optional(str) description = Optional(str) host_group = Optional(str) host_names = Optional(str) tasks = Optional(str)
class FiscalNumber(db.Entity): _table_ = '%s_fiscal' % schema if DEBUG else (schema, 'fiscal') id = PrimaryKey(int, auto=True) sign = Required(str) drive = Required(str) document = Required(str) date = Required(datetime) seller = Required('Seller') composite_key(sign, drive, document) goods = Set('Goods')
class Korisnik(db.Entity): id = PrimaryKey(str) Ime = Required(str) Prezime = Required(str) Adresa = Required(str) Username = Required(str) Password = Required(str) korisnik_trosak = Set("Trosak") korisnik_prihod = Set("Prihod") korisnik_izvjesce = Set("Izvjesce")
class Gif(db.Entity): id = PrimaryKey(int, auto=True) origin_host = Required(GifHosts, reverse='origin_gifs') origin_id = Required(str) reversed_host = Required(GifHosts, reverse='reversed_gifs') reversed_id = Required(str) time = Required(date) nsfw = Optional(bool) total_requests = Optional(int) last_requested_date = Optional(date)
class ActionPrimitive(db.Entity): """The ORM entity representing a ``CardAction`` member """ id = PrimaryKey(int, auto=True) """(int) Numeric identifier for the action""" name = Required(str) """(str) The display-style string for the action""" effects = Set('EffectPrimitive') """The set of ``EffectPrimitive`` entities with this action"""
class FactionPrimitive(db.Entity): """The ORM entity representing a ``CardFaction`` member """ id = PrimaryKey(int, auto=True) """(int) Numeric identifier for the faction""" name = Required(str, unique=True) """(str) The display-style string for the faction""" cards = Set('CardPrimitive') """The set of ``CardPrimitive`` entities belonging to this faction"""
class Variable(db.Entity): _table_ = 'variable' id = PrimaryKey(int, auto=True) metadata = Required(Json, index=True) data = Required(Json, 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) user = Required(str) info = Optional(Json) env = Required(Env) @classmethod @db_session def update_variable(cls, env_id, metadata, data, user): obj = get(n for n in Variable if n.env.id == env_id and n.env.delete_at == None and n.delete_at == None) if obj: obj.user = user obj.update_at = datetime.datetime.utcnow() obj.metadata = metadata obj.data = data else: Variable(user=user, metadata=metadata, data=data, env=env_id) @classmethod @db_session def delete_variable_by_env_id(cls, env_id, user): obj = get(n for n in Variable if n.env.id == env_id and n.env.delete_at == None) if obj: obj.user = user obj.delete_at = datetime.datetime.utcnow() @classmethod @db_session def get_metadata_variable_by_env_id(cls, env_id): obj = get(n for n in Variable if n.env.id == env_id and n.env.delete_at == None and n.delete_at == None) if obj: return obj.metadata else: raise IsNotExist(title='环境里没有设置项目变量', detail=f'环境id为{env_id}的环境下没有找到项目变量') @classmethod @db_session def get_data_variable_by_env_id(cls, env_id): obj = get(n for n in Variable if n.env.id == env_id and n.env.delete_at == None and n.delete_at == None) if obj: return obj.data else: raise IsNotExist(title='环境里没有设置项目变量', detail=f'环境id为{env_id}的环境下没有找到项目变量')
class Song(db.Entity): id: UUID = PrimaryKey(UUID, default=uuid4, auto=True) filename: str = Required(str, 256, unique=True) artist: str = Required(LongStr, lazy=False) title: str = Required(LongStr, lazy=False) length: int = Required(int, unsigned=True) lastplayed: datetime = Optional(datetime) playcount: int = Required(int, default=0, unsigned=True) added: datetime = Required(datetime, default=datetime.utcnow) favored_by = Set(User) queue = Set("Queue", hidden=True, cascade_delete=True)
class Unit(db.Entity): _table_ = "units" id = PrimaryKey(str, default=lambda: str(uuid4())) created_at = Required(dt.datetime, default=lambda: dt.datetime.now()) updated_at = Required(dt.datetime, default=lambda: dt.datetime.now()) name = Required(str) photo = Required(str) description = Required(str) max_persons = Required(int) unit_prices = Set("UnitPrice") unit_reservations = Set("Reservation")
class ProfileSkin(db.Entity): id = PrimaryKey(int, auto=True) profile = Required(Profile) name = Required( str, unique=True, default=lambda: "".join([uuid4().hex, uuid4().hex])) model = Optional(str) # "" or None if Steve, "slim" if Alex. def before_delete(self): SKINS_ROOT.joinpath(self.name).unlink()
class Responses(db.Entity): id = PrimaryKey(int, auto=True) # Default db id column for pk processed_text = Required( str, 1000, index='idx_parsed_text') # Stores the processed response text original_text = Required( str, 1000 ) # Stores the original response text/ Unused currently, but may help in future. response_link = Required(str, unique=True) # Link to the response text hero_id = Required( 'Heroes') # The hero_id for hero whose response text this is
class Region(db.Entity, CustomSqlRegion): # code = PrimaryKey(str) type = Required(str) name = Required(str) # PrimaryKey(str) code = PrimaryKey(str) identifiers = Set('Identifier') parent = Optional('Region', reverse='subregions') subregions = Set('Region', reverse='parent') series = Set('Series') tags = Set('Tag') entity_type = 'region' @property def key(self): region_key = self.name return region_key @db_session def toDict(self, compact=False): parent_region = self.parentRegion if compact: if parent_region: region_parent = parent_region.toDict() else: region_parent = None region_identifiers = [i.string for i in self.identifiers] subregions = list() region_series = list() else: region_series = [i.key for i in self.series] if parent_region: region_parent = parent_region.key else: region_parent = None region_identifiers = [i.key for i in self.identifiers] subregions = [i.key for i in self.subRegions] data = { 'entityType': 'region', 'entityKey': self.key, 'regionType': self.regionType, 'regionName': self.name, # Relations 'regionIdentifiers': region_identifiers, 'regionParent': region_parent, 'regionSubregions': subregions, 'regionSeries': region_series, 'regionTags': list() } return data
class Client(DB.Entity): """A client.""" id = PrimaryKey(int, auto=True) name = Optional(str) address = Optional(str) postal_code = Optional(str) city = Optional(str) country = Optional(str) tel = Optional(str) email = Optional(str) bills = Set('Bill')
class Agenda(db.Entity): """ Agenda Table """ id = PrimaryKey(int, auto=True) date = Optional(str) state = Optional(bool) hour = Optional(str) dni = Optional(int) turno = Optional(int) comments = Optional(str) medico = Optional(Medic) patient = Optional(Patient)
class Package(db.Entity): _table_ = 'Package' id = PrimaryKey(int, auto=True) author = Required(str) name = Required(str) description = Required(str) runtime = Required(str) license = Required(str) last_update = Required(str) repo = Required(str, unique=True) forks = Set('Fork')
class Game(db.Entity): id = PrimaryKey(int, auto=True) name = Required(str) creation_date = Required(datetime.datetime) created_by = Required(int) player_amount = Required(int) started = Required(bool) status = Required(Json) board = Optional('Board') players = Set('Player') chats = Set('Message')
class Annotation(db.Entity, BackupAble): id = PrimaryKey(UUID, auto=True, default=uuid4) x = Required(float) y = Required(float) section = Required(Section) style = Optional(db.Style, default=db.Style, cascade_delete=True) def __new__(cls, *args, **kwargs): if classtype := kwargs.pop("classtype", None): cls = getattr(db, classtype) return super().__new__(cls)
class Crop(engine.Entity): id = PrimaryKey(str, 32) created = Required(datetime, sql_default='CURRENT_TIMESTAMP') modified = Required(datetime, sql_default='CURRENT_TIMESTAMP') active = Required(bool, default=True) name = Required(str, 40) lot_name = Required(str, 64, default='Unnamed') lot_size = Required(float) land = Required('Land') cards = Set('Card')
class ORMGroup(db.Entity): _table_ = 'group_list' id = PrimaryKey(int, column='group_id') name = Optional(str, column='group_name') header = Optional(str, column='group_header') footer = Optional(str, column='group_footer') contacts = Set(lambda: ORMFixture.ORMContact, table="address_in_groups", column="id", reverse="groups", lazy=True)
class ChatMessage(db.Entity): _table_ = "chat_message" id = PrimaryKey(UUID, default=uuid4) user = Required(User, column="user_id") time = Required(int, default=lambda: int(time.time())) message = Required(str, 512) def responsize(self): return dict(username=self.user.name, time=self.time * 1000, message=self.message)
class Destination(db.Entity): _table_ = '%s_destination' % schema if DEBUG else (schema, 'destination') id = PrimaryKey(int, auto=True) host = Required(str) model = Required('Model') name = Required(str) password = Optional(str) port = Required(int, default=6379) def __init__(self, **kwargs): super(Destination, self).__init__(**filter_kwargs(kwargs))
class Locale(db.Entity): """ Une Langue id: au format "en_US" """ id = PrimaryKey(str) traductions = Set(Traduction) @classmethod def all(cls): return [l.id for l in cls.select().order_by(cls.id)]
class Game(database.Entity): id = PrimaryKey(int, auto=True) teams = Set(Team) host = Required(Player, reverse="games_hosted") location = Optional(str) date = Optional(date) accepted_players = Set(Player, reverse="accepted_games") cancelled = Optional(bool) final_score = Optional(str)
class Account(db.Entity): _table_ = ("finance", "accounts") id = PrimaryKey(int, auto=True) budget_id = Required("Budget") # maps to budget name = Required(str) parent_id = Optional(int) # maps to self created_at = Optional(int) # foreign references from_records = Set("Record", reverse="from_account_id") to_records = Set("Record", reverse="to_account_id")
class RecordSource(db.Entity): _table_ = ("finance", "record_source") id = PrimaryKey(int, auto=True) budget_id = Required("Budget") # maps to budget source_key = Required(str) source_type = Required(str) record_count = Required(int) created_at = Optional(int) # foreign references records = Set("Record")
class Budget(db.Entity): _table_ = ("finance", "budgets") id = PrimaryKey(int, auto=True) home_id = Required(int) name = Required(str) created_at = Optional(int) # foreign references record_sources = Set("RecordSource") accounts = Set("Account") records = Set("Record")
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): # "AlbumID3" type in XSD info = { "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) if count(self.tracks.year) > 0: info["year"] = min(self.tracks.year) genre = ", ".join(self.tracks.genre.distinct()) if genre: info["genre"] = genre try: starred = StarredAlbum[user.id, self.id] info["starred"] = starred.date.isoformat() except ObjectNotFound: pass return info def sort_key(self): year = min(t.year if t.year else 9999 for t in self.tracks) return f"{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()