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
