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()
