class Auditory(db.Model):
__tablename__ = "auditories"
id = db.Column('id_60', db.Integer, primary_key=True)
title = db.Column("obozn", db.String(20))
korp_id = db.Column("korp", db.Integer, db.ForeignKey('vackorp.id_67'))
maxstud = db.Column(db.SmallInteger)
specoborud = db.Column(db.SmallInteger)
def __str__(self, *args, **kwargs):
return "<Auditory: {}>".format(self.title.strip())
def __repr__(self):
return str(self)
@staticmethod
def get_key(title: str):
title = title.strip().lower().replace("_вт", "").replace("-", "").replace(".", "")
title = title.translate(LETTER_MAPPING_TABLE)
return title
@staticmethod
def get_new_aud_title(title):
return f"enter_{Auditory.get_key(title)}"
raspnagr = db.relationship('Raspnagr', backref=db.backref('auditory', lazy='joined'), lazy='dynamic')
raspis = db.relationship('Raspis', backref=db.backref('auditory', lazy='joined'), lazy='dynamic')
class SQLModel(db.Model):
"""
sql
"""
__tablename__ = "sql_model"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False, comment="SQL名")
project_id = db.Column(db.ForeignKey("requirement_model.id"))
project = db.relationship('RequirementModel',
backref=db.backref('sql_model', lazy='dynamic'))
database_id = db.Column(db.ForeignKey("database_model.id"))
database = db.relationship('DatabaseModel',
backref=db.backref('sql_model', lazy='dynamic'))
content = db.Column(db.Text, nullable=False, comment="sql语句")
special_field = db.Column(db.String(64), nullable=False, comment="特殊字段")
parent_id = db.Column(db.Integer, db.ForeignKey("sql_model.id"))
parent = db.relationship("SQLModel", remote_side=[id])
parent_field = db.Column(db.String(64), nullable=False, comment="父字段")
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class Venta(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
fecha = db.Column(db.Text)
cantidad = db.Column(db.Integer)
silla = db.relationship('Silla',
backref=db.backref('ventas', lazy='dynamic'))
conferencia = db.relationship('Conferencia',
backref=db.backref('ventas', lazy='dynamic'))
def __init__(self, fecha, cantidad, silla, conferencia):
self.fecha = fecha
self.cantidad = cantidad
self.silla = silla
self.conferencia = conferencia
class WishAuddPara(db.Model):
__tablename__ = "wishauddpara"
wish = db.Column("wish", db.Integer, db.ForeignKey('wishaudd.id_62'), primary_key=True)
para = db.Column("para", db.SmallInteger)
wish_instance = db.relationship('WishAudd', backref=db.backref('pairs', lazy='joined'))
class RequirementModel(db.Model):
"""
需求
"""
__tablename__ = "requirement_model"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), nullable=False, comment="项目名")
comments = db.Column(db.String(128), nullable=True, comment="备注")
user_mail_list = db.Column(db.Text, nullable=False, comment="用户邮箱")
# sqls = db.relationship('SQLModel', backref='project', lazy='dynamic')
# tasks = db.relationship('TasksModel', backref='project', lazy='dynamic')
task_type_id = db.Column(db.ForeignKey("task_type_model.id"))
task_type = db.relationship('TaskTypeModel',
backref=db.backref('requirement_model',
lazy='dynamic'))
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class Discipline(db.Model):
__tablename__ = "vacpred"
id = db.Column('id_15', db.Integer, primary_key=True)
title = db.Column("pred", db.String(250))
titles = db.Column("preds", db.String(250))
raspnagr = db.relationship('Raspnagr', backref=db.backref('discipline', lazy='joined'), lazy='dynamic')
class Chair(db.Model):
__tablename__ = "vackaf"
id = db.Column('id_17', db.Integer, primary_key=True)
title = db.Column("kaf", db.String(100))
short_title = db.Column("sokr", db.String(10))
raspnagr = db.relationship('Raspnagr', backref=db.backref('chair', lazy='joined'), lazy='dynamic')
class Teacher(db.Model):
__tablename__ = "prepods"
id = db.Column('id_61', db.Integer, primary_key=True)
full_name = db.Column('prep', db.String(100))
name = db.Column('preps', db.String(50))
raspnagr = db.relationship('Raspnagr', backref=db.backref('teacher', lazy='joined'), lazy='dynamic')
class TasksLogModel(db.Model):
"""
任务日志
"""
__tablename__ = "tasks_log_model"
id = db.Column(db.Integer, primary_key=True)
ex_type = db.Column(db.Integer, comment="执行类型")
task_no = db.Column(db.ForeignKey("tasks_model.id"))
task = db.relationship('TasksModel',
backref=db.backref('tasks_log_model',
lazy='dynamic'))
return_info = db.Column(db.Text, nullable=True, comment="返回信息")
dt_handled = db.Column(db.DateTime,
default=time_utils.now_dt,
comment="处理时间")
is_successful = db.Column(db.Boolean, default=True, comment="是否成功")
recipient = db.Column(db.Text, nullable=True, comment="收信人")
file_name = db.Column(db.String(128), nullable=True, comment="文件名")
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __repr__(self):
return str(self.task_no)
def __str__(self):
return str(self.id)
class Kontkurs(db.Model):
id = db.Column('id_1', db.Integer, primary_key=True)
title = db.Column("obozn")
shup = db.Column(db.Integer)
spclntion = db.Column(db.Integer)
kurs = db.Column(db.Integer)
fil = db.Column(db.Integer)
fac_id = db.Column("fac", db.Integer, db.ForeignKey('vacfac.id_5'))
aobozn_id = db.Column("aobozn", db.Integer, db.ForeignKey('vacaobozn.id_6'))
stud = db.Column(db.Integer)
groups = db.Column(db.Integer)
pgroups = db.Column(db.Integer)
smenao = db.Column(db.Integer)
smenav = db.Column(db.Integer)
groupkey = db.Column(db.Integer)
undoworksps = db.Column(db.String(250))
anothernumstudsps = db.Column(db.String(250))
newnumstud = db.Column(db.SmallInteger)
ntcgraph = db.Column(db.SmallInteger)
syear = db.Column(db.Integer)
groupslist = db.relationship('Kontgrp', backref='kontkurs', lazy='joined')
kontlist = db.relationship('Kontlist', backref='kontkurs', lazy='select')
raspnagr = db.relationship("Raspnagr", backref=db.backref('kontkurs', lazy='select'))
def __str__(self, *args, **kwargs):
return "<Kontkurs: {}>".format(self.title.strip())
def __repr__(self):
return str(self)
def get_title(self):
return self.title.replace("(И,О)", "")
class Follow(db.Model):
__tablename__ = "follows"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
follower_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
followee_id = db.Column(db.Integer,
db.ForeignKey('users.id'),
nullable=False)
follower = db.relationship('User',
backref=db.backref('followers', lazy=True),
foreign_keys=[follower_id])
followee = db.relationship('User',
backref=db.backref('followees', lazy=True),
foreign_keys=[followee_id])
class Article(db.Model):
__tablename__ = 'articles'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), nullable=False)
content = db.Column(db.Text, nullable=False)
created_at = db.Column(db.DateTime())
updated_at = db.Column(db.DateTime())
author = db.relationship('User', backref=db.backref('auth_users'))
author_id = db.Column(db.Integer,
db.ForeignKey('auth_users.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('article_categories'))
category_id = db.Column(db.Integer,
db.ForeignKey('article_categories.id'),
nullable=False)
tags = db.Column(db.String(80), nullable=False)
summary = db.Column(db.Text, nullable=False)
view_num = db.Column(db.Integer, default=0)
def __str__(self):
return self.title
class Note(db.Model):
__tablename__ = 'notes'
id = db.Column(db.Integer, primary_key=True)
anki_id = db.Column(db.Integer)
deck_id = db.Column(db.Integer, db.ForeignKey('decks.id'))
deck = db.relationship('Deck', backref="notes")
title = db.Column(db.String)
content = db.Column(db.String)
tags = db.relationship('Tag',
secondary=notes_tags_association,
lazy='subquery',
backref=db.backref('notes', lazy=True))
class Conferencia(db.Model):
id = db.Column(db.Integer, unique=True, primary_key=True)
nombre = db.Column(db.String(200), unique=True)
descripcion = db.Column(db.Text)
fecha = db.Column(db.Text)
precio = db.Column(db.Integer)
sillas = db.relationship('Silla',
backref=db.backref('conferecias', lazy='dynamic'))
def __init__(self, nombre, descripcion, fecha, precio):
self.nombre = nombre
self.descripcion = descripcion
self.fecha = fecha
self.precio = precio
class Kontgrp(db.Model):
id = db.Column('id_7', db.Integer, primary_key=True)
kont_id = db.Column("kont", db.Integer, db.ForeignKey('kontkurs.id_1'))
title = db.Column("obozn", db.String(20))
ngroup = db.Column(db.Integer)
students = db.Column(db.Integer)
parent_id = db.Column("parent", db.Integer, db.ForeignKey('kontgrp.id_7'))
depth = db.Column(db.Integer)
budzh = db.Column(db.Integer)
spclntion = db.Column(db.Integer)
op = db.relationship("Kontgrplist", backref=db.backref("kontgrp", lazy="joined"), lazy='joined')
raspnagr = db.relationship("Raspnagr", backref=db.backref('kontgrp', lazy='joined'))
children = db.relationship("Kontgrp", backref=db.backref('parent', remote_side=[id], lazy="joined"))
def __str__(self, *args, **kwargs):
return "<Kontgrp: {}>".format(self.title.strip())
def __repr__(self):
return str(self)
def get_title(self):
return self.title.replace("(И,О)", "")
class Model(db.Model):
__tablename__ = "model"
id = Column(Integer, primary_key=True)
make_id = Column(Integer, ForeignKey("make.id"))
name = Column(String(50))
#make backref to Make
badges = relationship("Badge",
backref=db.backref("model", uselist=False),
uselist=True)
def Serialize(self, **kwargs):
schema = ModelSchema(**kwargs)
return schema.dump(self)
def Create(make, model):
result = Model(
make_id = make.id, \
name = model["Model"])
db.session.add(result)
db.session.flush()
if "Badges" in model:
result.LoadBadges(model["Badges"])
return result
def LoadBadges(self, badges):
for badge in badges:
result = Badge.Create(self, badge)
if not result:
print("Failed to import a badge {0}!".format(badge["Badge"]))
exit()
def GetById(modelid):
return Model.query \
.filter(Model.id == modelid) \
.scalar()
def __str__(self):
return "<Model " + str(self.id) + ": " + self.name + ">"
class Bookmark(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text, nullable=False)
date = db.Column(db.DateTime, default=datetime.utcnow)
description = db.Column(db.String(300))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
# Set the relationship with the Tag class, need to use a string as it's not defined until later. ToDo: Move it up
# and replace it with the class name for future proofing. The second argument to the relationship call is the
# argument 'secondary' which tells the relationship to use our junction table called "tags" above. We also defined
# a backref called 'bookmarks' which will add an attribute called bookmarks to the other side of the relationship.
# So each tag will get a bookmarks attribute containing a list of the associated bookmarks. Dynamic loading in case
# there are a large number of bookmarks associated with each tag.
# Underscore as I don't want to access this directly from other classes.
_tags = db.relationship('Tag', secondary=tags, lazy='joined', backref=db.backref('bookmarks', lazy='dynamic'))
@staticmethod
def newest(num):
return Bookmark.query.order_by(desc(Bookmark.date)).limit(num)
# In the view and the form, we handle the list of tags as a comma separated string. So it's convenient to create a
# tag property that provides a list of strings as well. The getter takes the contents of the _tags list which holds
# actual Tag model objects. Then it takes the name from each and joins it into a string. So when we ask for the
# value of the tags property on a bookmark, we get a string, with a list of tag names.
@property
def tags(self):
return ",".join([t.name for t in self._tags])
# When we pass a string with a list of tags to be set to this property, we need to find out for each of those tags
# whether it already exists in the database. If it doesn't, we need to insert a new tag into the tag table and then
# add the new model object to the tag list for this bookmark. If it does exist, we can simply retrieve it and put it
# in the list. So if it exists, we create a new method get_or_create that takes the name of a tag and returns a tag
# model instance by either creating or retrieving a tag with that name. We then do a for loop over all the words in
# the string we received and then call the method on each of those words. The resulting list is a list of tag model
# objects and we can assign that to the _tags attribute. Assigning a list of tag objects is all we have to do and
# SQLAlchemy will take it from there and create all the relevant rows in the database.
@tags.setter
def tags(self, string):
# Check if the tags are a string
if string:
self._tags = [Tag.get_or_create(name) for name in string.split(',')]
# If not, set the list ot an empty list, otherwise, it will always fail the test.
else:
self._tags = []
def __repr__(self):
return "Bookmark '{}': '{}'>".format(self.description, self.url)
class TasksModel(db.Model):
"""
任务
"""
__tablename__ = "tasks_model"
id = db.Column(db.Integer, primary_key=True)
task_no = db.Column(db.String(128),
nullable=False,
default=gen_task_no,
comment="备注")
task_type = db.Column(db.Enum('cron', 'interval', 'date'),
server_default='cron',
nullable=False)
name = db.Column(db.String(128), nullable=False, comment="任务名")
project_id = db.Column(db.ForeignKey("requirement_model.id"))
project = db.relationship('RequirementModel',
backref=db.backref('tasks_model',
lazy='dynamic'))
comments = db.Column(db.String(256), nullable=True, comment="备注")
year = db.Column(db.Integer, nullable=True, comment="年")
month = db.Column(db.Integer, nullable=True, comment="月")
day = db.Column(db.Integer, nullable=True, comment="日")
week = db.Column(db.Integer, nullable=True, comment="周")
day_of_week = db.Column(db.Integer, nullable=True, comment="周期")
hour = db.Column(db.Integer, nullable=True, comment="时")
minute = db.Column(db.Integer, nullable=True, comment="分")
second = db.Column(db.Integer, nullable=True, comment="秒")
status = db.Column(db.Boolean, default=False, comment="状态")
is_deleted = db.Column(db.Boolean, default=False)
dt_create = db.Column(db.DateTime, default=time_utils.now_dt)
dt_update = db.Column(db.DateTime,
default=time_utils.now_dt,
onupdate=time_utils.now_dt)
def __repr__(self):
return self.name
def __str__(self):
return self.name
class Obozn(db.Model):
__tablename__ = "vacaobozn"
id = db.Column('id_6', db.Integer, primary_key=True)
title = db.Column("aobozn", db.String(50))
kontkurs = db.relationship("Kontkurs", backref=db.backref("aobozn", lazy="joined"))
class Tweet(db.Model):
__tablename__ = "tweets"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
text = db.Column(db.String(140), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
user = db.relationship('User', backref=db.backref('tweets', lazy=True))
class Faculty(db.Model):
__tablename__ = "vacfac"
id = db.Column('id_5', db.Integer, primary_key=True)
title = db.Column("fac", db.String(65))
kontkurs = db.relationship('Kontkurs', backref=db.backref('faculty', lazy='joined'), lazy='dynamic')
class Comment(FullText, db.Model):
"""
This class is here because comments can only be made on threads,
so it is contained in the threads module.
Note the parent_id and children values. A comment can be commented
on, so a comment has a one to many relationship with itself.
Backrefs:
A comment can refer to its parent thread with 'thread'
A comment can refer to its parent comment (if exists) with 'parent'
"""
__tablename__ = 'threads_comment'
__fulltext_columns__ = ('text', )
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(THREAD.MAX_BODY), default=None)
user_id = db.Column(db.Integer, db.ForeignKey('users_user.id'))
thread_id = db.Column(db.Integer, db.ForeignKey('threads_thread.id'))
parent_id = db.Column(db.Integer, db.ForeignKey('threads_comment.id'))
children = db.relationship('Comment',
backref=db.backref('parent', remote_side=[id]),
lazy='dynamic')
depth = db.Column(db.Integer, default=1) # savet at depth 1
created_on = db.Column(db.DateTime, default=now)
updated_on = db.Column(db.DateTime, default=now)
votes = db.Column(db.Integer, default=1)
@reconstructor
def setup_fields(self):
self.text = format_comment(self.text)
def __repr__(self):
return '<Comment %r>' % (self.text[:25])
def set_depth(self):
"""
call after initializing
"""
if self.parent:
self.depth = self.parent.depth + 1
db.session.commit()
def get_comments(self, order_by='votes'):
"""
default order by votes
"""
if order_by == 'votes':
return self.children.order_by(db.desc(Comment.votes)).\
all()[:THREAD.MAX_COMMENTS]
elif order_by == 'timestamp':
return self.comments.order_by(db.desc(Comment.votes)).\
all()[:THREAD.MAX_COMMENTS]
def pretty_date(self, typeof='created'):
"""
returns a humanized version of the raw age of this thread,
eg: 34 minutes ago versus 2040 seconds ago.
"""
if typeof == 'created':
logger.info(arrow.get(self.created_on, 'UTC'))
logger.info(arrow.get(self.created_on, 'UTC').humanize())
return arrow.get(self.created_on, 'UTC').humanize()
elif typeof == 'updated':
return arrow.get(self.updated_on, 'UTC').humanize()
def has_voted(self, user_id):
select_votes = comment_upvotes.select(
db.and_(comment_upvotes.c.user_id == user_id,
comment_upvotes.c.comment_id == self.id))
rs = db.engine.execute(select_votes)
return False if rs.rowcount == 0 else True
def vote(self, user_id):
"""
Add a vote from user id to a comment.
"""
already_voted = self.has_voted(user_id)
vote_status = None
if not already_voted:
# vote up the thread
db.engine.execute(comment_upvotes.insert(),
user_id=user_id,
comment_id=self.id)
self.votes = self.votes + 1
vote_status = True
else:
# unvote the thread
db.engine.execute(
comment_upvotes.delete(
db.and_(comment_upvotes.c.user_id == user_id,
comment_upvotes.c.comment_id == self.id)))
self.votes = self.votes - 1
vote_status = False
db.session.commit() # for the vote count
return vote_status
def comment_on(self):
"""
when someone comments on this particular comment
"""
pass
class Make(db.Model):
__tablename__ = "make"
id = Column(Integer, primary_key=True)
type_ = Column(String(10))
name = Column(String(50))
models = relationship("Model",
backref=db.backref("make", uselist=False),
uselist=True)
__mapper_args__ = {"polymorphic_identity": "make", "polymorphic_on": type_}
def Serialize(self, **kwargs):
schema = MakeSchema(**kwargs)
return schema.dump(self)
def LoadModels(self, models):
for model in models:
result = Model.Create(self, model)
if not result:
print("Failed to import a model {0}!".format(model["Model"]))
exit()
# Finds all Make records of type 'type' and returns them, where applicable,
# as an instance of their derived type.
def GetByType(type):
return with_polymorphic(Make, "*").query \
.filter(Make.type_ == type) \
.all()
# Finds the Make record associated with makeid, but returns it with a parent-child relationship
# between Make and a derived type (if any.)
# -> Make.GetById( x )
# <- (Car<x>)
def GetById(makeid):
return with_polymorphic(Make, "*").query \
.filter(Make.id == makeid) \
.scalar()
@hybrid_property
def num_models(self):
return len(self.models)
@hybrid_property
def num_badges(self):
total = 0
for x in self.models:
total += len(x.badges)
return total
# Type sensitive hybrid methods.
# Remember to call on the Class level of a child.
# Creates a new table based on the derived type for each item in makes.
# Then generates that makes models, and that models badges (if applicable.)
# If you define a new type and have custom create logic, you'll need to override this.
@hybrid_method
def Create(cls, makes):
for make in makes:
if cls.Exists(make["Make"]):
continue
result = cls(name=make["Make"])
db.session.add(result)
db.session.flush()
result.LoadModels(make["Models"])
if not result:
print("Failed to import type: {0}!".format(cls.__table__.name))
exit()
return True
# Finds a [ Car/Bike, Model, Badge (if applic.) ] set based on make, model and badge.
# Can return multiple results. Particularly if you provide no badge.
# Always returns in the form of a list for consistency. Ensure you do your len() as you may not always get a Badge.
# ( Toyota, Supra ) would return SZ, RZ, SZ-R etc.
@hybrid_method
def Find(cls, make, model, badge=None):
query = db.session.query(cls, Model, Badge) \
.join(Model, Model.make_id == cls.id) \
.outerjoin(Badge, Badge.model_id == Model.id) \
\
.filter(cls.name == make) \
.filter(Model.name == model) \
.filter(or_(Badge.name == badge, or_(badge == None, Badge.name == None))) \
.filter(cls.type_ == cls.__table__.name)
return query.all()
# Checks whether any make record exists where attached to the type of cls.
@hybrid_method
def Exists(cls, name):
return cls.query \
.filter(cls.name == name) \
.filter(cls.type_ == cls.__table__.name) \
.scalar()
class Raspnagr(db.Model):
id = db.Column('id_51', db.Integer, primary_key=True)
kontkurs_id = db.Column("kont", db.Integer, db.ForeignKey('kontkurs.id_1'))
kontgrp_id = db.Column("kontid", db.Integer, db.ForeignKey('kontgrp.id_7'))
op = db.Column("op", db.Integer)
nt = db.Column(db.Integer, db.ForeignKey("normtime.id_40"))
sem = db.Column(db.Integer)
pred_id = db.Column("pred", db.Integer, db.ForeignKey("vacpred.id_15"))
kaf_id = db.Column("kaf", db.Integer, db.ForeignKey("vackaf.id_17"))
fobuch = db.Column(db.SmallInteger)
afobuch = db.Column(db.SmallInteger)
nagrid = db.Column(db.Integer)
h = db.Column(db.Float)
hy = db.Column(db.Integer)
dbeg = db.Column(db.Date)
days = db.Column(db.Integer)
prep_id = db.Column("prep", db.Integer, db.ForeignKey('prepods.id_61'))
aud_id = db.Column("aud", db.Integer, db.ForeignKey('auditories.id_60'))
nagrtype = db.Column(db.SmallInteger)
nagrprop = db.Column(db.Integer)
nagr_h = db.Column(db.Float)
stud = db.Column(db.Integer)
editstud = db.Column(db.Integer)
rnprep = db.Column(db.Integer)
# hy1 = db.Column(db.Integer)
# hy2 = db.Column(db.Integer)
syear = db.Column(db.Integer)
raspis = db.relationship('Raspis', backref=db.backref('raspnagr', lazy='joined'), lazy='dynamic')
raspis_zaoch = db.relationship('RaspisZaoch', backref=db.backref('raspnagr', lazy='joined'), lazy='dynamic')
kontlist = db.relationship('Kontlist', backref='raspnagr', lazy='subquery')
kontgrplist = db.relationship('Kontgrplist', backref='raspnagr', lazy='subquery')
@classmethod
def get_for_kontgrp(self, kontgrp):
raspnagrs = Raspnagr.query.filter(
or_(Raspnagr.kontgrp_id == kontgrp.id, Raspnagr.kontkurs_id == kontgrp.kont_id)
)
return raspnagrs
@classmethod
def get_for_kontkurs_id(self, kontkurs_id, sem=1, subgroup_number=0):
Kontgrp2 = aliased(Kontgrp)
KontgrpCommon = aliased(Kontgrp)
KontgrpParent = aliased(Kontgrp)
if not isinstance(kontkurs_id, list):
kontkurs_id = [kontkurs_id, ]
if int(subgroup_number):
filter_ = and_(or_(
Raspnagr.kontkurs_id.in_(kontkurs_id),
Kontlist.kontkurs_id.in_(kontkurs_id),
KontgrpCommon.kont_id.in_(kontkurs_id),
), or_(
KontgrpCommon.id == None,
and_(KontgrpParent.id == None, KontgrpCommon.ngroup == subgroup_number),
KontgrpParent.ngroup == subgroup_number
), )
else:
filter_ = or_(
Raspnagr.kontkurs_id.in_(kontkurs_id),
KontgrpCommon.kont_id.in_(kontkurs_id),
Kontlist.kontkurs_id.in_(kontkurs_id),
)
raspnagrs = Raspnagr.query.filter(
Raspnagr.id.in_(Raspnagr.query
.outerjoin(Kontgrp, Raspnagr.kontgrp_id == Kontgrp.id)
.outerjoin(Kontgrplist, Kontgrplist.op == Raspnagr.op)
.outerjoin(Kontlist, Kontlist.op == Raspnagr.op)
.outerjoin(Kontgrp2, Kontgrp2.id == Kontgrplist.kontgrp_id)
.outerjoin(KontgrpCommon, func.coalesce(Kontgrp2.id, Kontgrp.id) == KontgrpCommon.id)
.outerjoin(KontgrpParent, KontgrpCommon.parent_id == KontgrpParent.id)
.filter(filter_).filter(Raspnagr.sem == sem).with_entities(Raspnagr.id)))
return raspnagrs
