class Observatoryday(Base): __base_tablename__ = 'observatoryday' day = db.Column(db.DateTime, nullable=False) comment = db.Column(db.String(1000), nullable=True) observers = db.Column(db.String(200), nullable=False) selectedactions = db.Column(db.String(500), nullable=False) observatory_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observatory.id'), nullable=False) Observationperiod = db.relationship("Observationperiod", backref="observatoryday", lazy=True) Catch = db.relationship("Catch", backref="observatoryday", lazy=True) def __init__(self, day, comment, observers, selectedactions, observatory_id): self.day = day self.comment = comment self.observers = observers self.selectedactions = selectedactions self.observatory_id = observatory_id
class Account(Base): __base_tablename__ = 'account' userId = db.Column(db.String(144), nullable=False, unique=True) fullName = db.Column(db.String(144), nullable=False) email = db.Column(db.String(144), nullable=False) observatory = db.Column(db.String(144), nullable=True) Observation = db.relationship("Observation", backref="account", lazy=True) def __init__(self, userId, fullName, email): self.userId = userId self.fullName = fullName self.email = email self.observatory = None def get_id(self): return self.id def get_userId(self): return self.userId def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def getRole(self): return self.role
class Observatory(Base): __base_tablename__ = 'observatory' name = db.Column(db.String(144), nullable=False) actions = db.Column(db.String(500), nullable=False) Observatoryday = db.relationship("Observatoryday", backref="observatory", lazy=True) Location = db.relationship("Location", backref="observatory", lazy=True) Type = db.relationship("Type", backref="observatory", lazy=True) def __init__(self, name, actions): self.name = name self.actions = actions
class Location(Base): __base_tablename__ = 'location' name = db.Column(db.String(144), nullable = False) observatory_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observatory.id'), nullable=False) Observationperiod = db.relationship("Observationperiod", backref="location", lazy=True) def __init__ (self, name, observatory_id): self.name = name self.observatory_id = observatory_id
class User(Base): __tablename__ = "account" username = db.Column(db.String(144), nullable=False) password = db.Column(db.String(144), nullable=False) orders = db.relationship('StoreOrder', backref='account', lazy=True) active = db.Column(db.Boolean()) roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) def get_id(self): return self.id def is_active(self): return True def is_anonymous(self): return False def is_authenticated(self): return True def has_role(self, role): return role in self.roles @staticmethod def find_the_sum_of_spent_money_by_user(user_id): stmt = text("SELECT Store_Order.user_id, SUM(Product.price) FROM Store_Order" " JOIN store_order_has_product ON Store_Order.id = store_order_has_product.store_order_id " " JOIN product ON store_order_has_product.product_id = product.id " " GROUP BY Store_Order.user_id " " HAVING store_order.user_id = :user_id").params(user_id = user_id) res = db.engine.execute(stmt) response = 0 for row in res: response = row[1] return response
class Shorthand(Base): __base_tablename__ = 'shorthand' shorthandblock = db.Column(db.String(4000), nullable=False) observationperiod_id=db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observationperiod.id'), nullable=False) Observation = db.relationship("Observation", backref="shorthand", lazy=True) def __init__ (self, shorthandblock, observationperiod_id): self.shorthandblock=shorthandblock self.observationperiod_id=observationperiod_id
class Observationperiod(Base): __base_tablename__ = 'observationperiod' start_time = db.Column(db.DateTime, nullable=False) end_time = db.Column(db.DateTime, nullable=False) type_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'type.id'), nullable=False) location_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'location.id'), nullable=False) observatoryday_id = db.Column(db.Integer, db.ForeignKey(Base.the_prefix + 'observatoryday.id'), nullable=False) Shorthand = db.relationship("Shorthand", backref="observationperiod", lazy=True) def __init__ (self, start_time, end_time, type_id, location_id, observatoryday_id): self.start_time = start_time self.end_time = end_time self.type_id = type_id self.location_id = location_id self.observatoryday_id = observatoryday_id
class Vote(db.Model, Mixin): class Type: ( LIKE, VOTE ) = range(2) TITLES = dict([(LIKE, 'like'), (VOTE, 'vote')]) class Value: POSITIVE = 1 NEGATIVE = -1 NEUTRAL = 0 TITLES = dict([(POSITIVE, 'positive'), (NEGATIVE, 'negative'), (NEUTRAL, 'neutral')]) __tablename__ = 'vote' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) datetime = db.Column(db.DateTime, default=_datetime.now) value = db.Column(db.Integer, default=Value.NEUTRAL) entity = db.Column(db.String(255)) entity_id = db.Column(db.Integer) type = db.Column(db.Integer, default=Type.VOTE) votes_count = db.Column(db.Integer, default=0) user = db.relationship("User", backref="votes",) @staticmethod def get_for(entity, entity_id, user=None): query = Vote.query.filter(Vote.entity == entity, Vote.entity_id == entity_id) if user: query = query.filter(Vote.user == user) return query.first() if user else query.all() def get_entity(self): return Vote.get_entities().get(self.entity, {}).get(self.entity_id) @staticmethod def get_entities(): return HasVotes.__entities__
class Role(db.Model): __tablename__ = 'roles' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(64), unique=True) permissions = db.relationship("Permission", secondary=role_permission_associate, backref="roles") def __repr__(self): return "<Role {name}>".format(name=self.name) @classmethod def get_by_id(cls, uid): return cls.query.filter_by(id=uid).first() @classmethod def get_all(cls): return cls.query.order_by(cls.name.desc()).all()
class NewsCategory(db.Model, Mixin): __tablename__ = 'news_category' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) parent_id = db. Column(db.Integer, db.ForeignKey('news_category.id'), nullable=True) parent = db.relationship('NewsCategory', remote_side=[id], backref="subcategories", lazy='joined') @classmethod def get_root(cls): return cls.query.filter(cls.parent_id == None).all() @classmethod def add(cls, name): cat = NewsCategory(name=name) db.session.add(cat) db.session.commit() @classmethod def get_by_id(cls, uid): return cls.query.filter_by(id=uid).first() @classmethod def rename(cls, uid, new_name): cat = cls.query.filter_by(id=uid).first() cat.name = new_name db.session.add(cat) db.session.commit() @classmethod def delete(cls, uid): cls.query.filter_by(id=uid).delete() db.session.commit() @classmethod def get_all(cls): return cls.query.order_by(NewsCategory.name).all()
class PasswordRestore(db.Model): __tablename__ = 'password_restore' id = db.Column(db.Integer, primary_key=True) author_id = db.Column(db.Integer, db.ForeignKey('users.id')) token = db.Column(db.String(64)) is_active = db.Column(db.Boolean, default=True) datetime = db.Column(db.DateTime, default=datetime.now) author = db.relationship("User", backref="password_restore") def __repr__(self): return "<PasswordRestore {token}>".format(token=self.token) @classmethod def add_token(cls, user): token = ''.join(str(uuid1()).split('-')) pass_restore = PasswordRestore(author_id=user.id, token=token) db.session.add(pass_restore) db.session.commit() return token @classmethod def is_valid_token(cls, token): expiration = datetime.now() - timedelta(days=1) restore_pass = cls.query.filter( PasswordRestore.token == token, PasswordRestore.is_active == True, PasswordRestore.datetime >= expiration).first() return restore_pass @classmethod def deactivation_token(cls, token_obj): tokens = cls.query.filter( PasswordRestore.author_id == token_obj.author_id).all() for token in tokens: token.is_active = False db.session.commit()
class Department(db.Model, Mixin): __tablename__ = 'department' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255)) parent_id = db. Column(db.Integer, db.ForeignKey('department.id'), nullable=True) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) parent = db.relationship('Department', remote_side=[id], backref="subdepartment") user = db.relationship("User", backref="managed_department", foreign_keys=[user_id], lazy='joined') @property def workers(self): return [user for user in self.users if user != self.user] def __repr__(self): return "<Department {name}>".format(name=self.name) @classmethod def get_by_id(cls, uid): return cls.query.filter_by(id=uid).first() @classmethod def get_by_name(cls, name): return cls.query.filter_by(name=name).first() @classmethod def get_parent_all(cls, uid): return cls.query.filter(Department.id!=uid).order_by(Department.name).all() @classmethod def get_all(cls): return cls.query.order_by(Department.name).all() @classmethod def set_parent(cls, uid, pid): dep = cls.query.filter_by(id=uid).first() if pid == '0': dep.parent_id = None else: dep.parent_id = pid db.session.add(dep) db.session.commit() @classmethod def rename(cls, uid, new_name): dep = cls.query.filter_by(id=uid).first() dep.name = new_name db.session.add(dep) db.session.commit() @classmethod def add(cls, uid, new_name): dep = Department(parent_id=uid, name=new_name) db.session.add(dep) db.session.commit() @classmethod def add_head4dep(cls, option, dep_id, user_id): deps = cls.query.filter_by(user_id=user_id).all() for dep in deps: dep.user_id = None db.session.add(dep) dep = cls.query.filter_by(id=dep_id).first() if option == 1: dep.user_id = user_id elif option == 2: dep.user_id = None db.session.add(dep) db.session.commit() @classmethod def is_user_head(cls, dep_id, user_id): dep = cls.query.filter_by(id=dep_id).first() if dep.user_id == user_id: return True return False @classmethod def get_dep_if_user_head(cls, user_id): return cls.query.filter_by(user_id=user_id).first() @classmethod def count_users_in_dep_tree(cls, dep_id): dep = cls.query.filter_by(id=dep_id).first() c_u = User.count_users_in_department(dep_id) def count_users_recursively(dep): dep_childs = cls.query.filter_by(parent_id=dep.id).all() count_users = 0 for dep_child in dep_childs: count_users += User.count_users_in_department(dep_child.id) count_users += count_users_recursively(dep_child) return count_users c_u += count_users_recursively(dep) return c_u - 1 @classmethod def get_head_user_in_dep_tree(cls, dep_id, user_id): dep = cls.query.filter_by(id=dep_id).first() def head_user_recursively(dep): if dep.user_id: return User.get_by_id(dep.user_id) if dep.parent_id: dep_parent = cls.query.filter_by(id=dep.parent_id).first() return head_user_recursively(dep_parent) return None if dep.user_id == user_id: if dep.parent_id: dep_parent = cls.query.filter_by(id=dep.parent_id).first() return head_user_recursively(dep_parent) return None return head_user_recursively(dep) @classmethod def delete(cls, uid): parent_dep = cls.query.filter_by(parent_id=uid) if (parent_dep.count() == 0) and (User.count_users_in_department(uid) == 0): cls.query.filter_by(id=uid).delete() db.session.commit()
class User(db.Model, AuthUser, Mixin): ''' при добавлении полей не забыть их добавить в application/models/serializers/users.py для корректной валидации данных ''' __tablename__ = 'users' ( STATUS_ACTIVE, STATUS_DELETED, ) = range(2) STATUSES = [(STATUS_ACTIVE, 'Active'), (STATUS_DELETED, 'Deleted')] id = db.Column(db.Integer, primary_key=True) email = db.Column( db.String ) # TODO Add constraint on length; can't be nullable in future full_name = db.Column(db.String(64)) login = db.Column(db.String(64), unique=True) status = db.Column(db.Integer, default=STATUS_ACTIVE) mobile_phone = db.Column( db.String, nullable=True) # TODO Add constraint on length and format inner_phone = db.Column( db.String, nullable=True) # TODO Add constraint on length and format birth_date = db.Column(db.DateTime, nullable=True) # TODO Add default value skype = db.Column(db.String(64), nullable=True) department_id = db.Column(db.Integer, db.ForeignKey('department.id')) position = db.Column(db.String(255)) photo_id = db.Column(db.Integer, db.ForeignKey('file.id')) is_admin = db.Column(db.Boolean, default=False) news_notification = db.Column(db.Boolean, default=False) reg_date = db.Column(db.DateTime, default=datetime.now) permissions = db.relationship("Permission", secondary=user_permission_associate, backref="users", lazy='dynamic') roles = db.relationship("Role", secondary=user_role_associate, backref="users", lazy='dynamic') department = db.relationship("Department", backref="users", foreign_keys=[department_id]) photo = db.relationship("File", lazy="joined") def __repr__(self): return "<User {login}>".format(login=self.login) @classmethod def get_by_id(cls, uid): return cls.query.filter_by(id=uid).first() @classmethod def get_by_email(cls, email): return cls.query.filter_by(email=email).first() @classmethod def get_by_login(cls, login): return cls.query.filter_by(login=login).first() @classmethod def count_users_in_department(cls, department): return cls.query.filter_by(department_id=department).count() @classmethod def find_user(cls, dep_id, name): return cls.query.filter( or_(User.department_id == None, User.department_id != dep_id)).filter( User.full_name.ilike('%' + name + '%')).limit(5).all() @classmethod def get_new(cls): today = date.today() delta = today - timedelta(days=30) return cls.query.filter( User.reg_date > delta, or_(User.status != User.STATUS_DELETED, User.status == None)).order_by(User.reg_date.desc(), User.full_name).all() @classmethod def get_birthday(cls): today = date.today() tomorrow = today + timedelta(days=1) return cls.query.filter( or_( and_( extract('month', User.birth_date) == today.month, extract('day', User.birth_date) == today.day), and_( extract('month', User.birth_date) == tomorrow.month, extract('day', User.birth_date) == tomorrow.day)), or_(User.status != User.STATUS_DELETED, User.status == None)).order_by(User.birth_date.desc(), User.full_name).all() @classmethod def set_user_is_admin(cls, user_id): u = cls.query.filter_by(id=user_id).first() u.is_admin = True u.roles = [] db.session.add(u) db.session.commit() @classmethod def set_user_role(cls, user_id, role_id): u = cls.query.filter_by(id=user_id).first() r = Role.get_by_id(role_id) u.roles = [] u.roles.append(r) u.is_admin = False db.session.add(u) db.session.commit() @classmethod def get_user_role_id(cls, user_id): u = cls.query.filter_by(id=user_id).first() if u.is_admin: return 0 elif u.roles and len(u.roles.all()): return u.roles[0].id return '' @classmethod def set_user_per(cls, user_id, per_string): if per_string == "None": per_list = [] else: per_list = per_string.split(',') u = cls.query.filter_by(id=user_id).first() u.permissions = [] for per_id in per_list: p = Permission.get_by_id(per_id) u.permissions.append(p) db.session.add(u) db.session.commit() @classmethod def get_user_permissions_id(cls, user_id): u = cls.query.filter_by(id=user_id).first() permissions_list = [] for per in u.permissions: permissions_list.append(per.id) return permissions_list @classmethod def add_user2dep(cls, dep_id, user_id): u = cls.query.filter_by(id=user_id).first() if dep_id == 0: dep_id = None u.department_id = dep_id db.session.add(u) @classmethod def edit_user(cls, uid, full_name=full_name, position=position, mobile_phone=mobile_phone, inner_phone=inner_phone, email=email, birth_date=birth_date, skype=skype, photo=photo): u = cls.query.filter_by(id=uid).first() if u: u.full_name = full_name u.position = position u.mobile_phone = mobile_phone u.inner_phone = inner_phone u.email = email if birth_date: u.birth_date = birth_date else: u.birth_date = None u.skype = skype db.session.add(u) if photo: p = u.photo = u.photo or File.create( name='photo.png', module='users', entity=u) p.makedir() p.update_hash() image.thumbnail(photo, width=100, height=100, fill=image.COVER).save( p.get_path(sufix="thumbnail")) image.resize(photo).save(p.get_path()) return u def get_permissions(self): return set([permission.name for permission in self.permissions]).union( set([ permission.name for role in self.roles for permission in role.permissions ])) def has_role(self, role): return role in self.roles @property def age(self): today, born = date.today(), self.birth_date return today.year - born.year - ((today.month, today.day) < (born.month, born.day)) def to_json(self): return user_schema.dump(self)
class Comment(db.Model, Mixin, HasVotes): class Status: (ACTIVE, DELETED, MODIFIED) = range(3) TITLES = dict([(ACTIVE, 'active'), (DELETED, 'deleted'), (MODIFIED, 'modified')]) __tablename__ = 'comment' id = db.Column(db.Integer, primary_key=True) author_id = db.Column(db.Integer, db.ForeignKey('users.id')) text = db.Column(db.Text()) datetime = db.Column(db.DateTime, default=_datetime.now) modify_datetime = db.Column(db.DateTime, default=_datetime.now) entity = db.Column(db.String(255)) entity_id = db.Column(db.Integer) quote_for_id = db.Column(db.Integer, db.ForeignKey('comment.id'), nullable=True) status = db.Column(db.Integer, default=Status.ACTIVE) votes_count = db.Column(db.Integer, default=0) quote_for = db.relationship('Comment', remote_side=[id], order_by="Comment.datetime", backref=backref("quotes", cascade="all")) author = db.relationship("User", backref="comments", lazy='joined') def __init__(self, *args, **kwargs): self.__my_vote = None self.__files = [] @orm.reconstructor def init_on_load(self): self.__my_vote = None self.__files = [] @hybrid_property def my_vote(self): return self.__my_vote @my_vote.setter def my_vote_setter(self, val): self.__my_vote = val def add_file(self, file): self.__files.append(file) @hybrid_property def files(self): if self.__files: return self.__files return File.get(module='comments', entity=self) @files.setter def files_setter(self, files): self.__files = files def to_json(self): return comment_schema.dump(self) @staticmethod def get_for(entity, entity_id, lazy=True): user = auth.service.get_user() if lazy: return Comment.query.filter(Comment.entity == entity, Comment.entity_id == entity_id, Comment.quote_for_id == None) \ .order_by(Comment.datetime.desc()).all() else: query = Comment.query.filter(Comment.entity == entity, Comment.entity_id == entity_id) \ .outerjoin(Vote, and_(Vote.entity == Comment.__tablename__, Vote.entity_id == Comment.id, Vote.user_id == user.id)) \ .outerjoin(File, File.entity == func.concat(Comment.__tablename__, '.', Comment.id)) \ .add_entity(Vote) \ .add_entity(File) \ .order_by(Comment.datetime.desc(), File.id) comments_votes_files = query.all() comments = [] added = {} for comment, vote, file in comments_votes_files: if file: comment.add_file(file) comment.my_vote = vote if not added.get(comment.id): comments.append(comment) added[comment.id] = True return comments def get_entity(self): return Comment.get_entities().get(self.entity, {}).get(self.entity_id) @staticmethod def get_entities(): return HasComments.__entities__ def after_delete_vote(self, vote=None): self.votes_count = (self.votes_count or 0) - 1 def after_add_vote(self, vote=None): self.votes_count = (self.votes_count or 0) + 1 def after_update_vote(self, value): self.votes_count = (self.votes_count or 0) + value
class Post(db.Model, Mixin, HasComments, HasVotes): __tablename__ = 'post' class STATUS: ( ACTIVE, DELETED, BLOCKED, ) = range(3) TITLE = [(ACTIVE, 'active'), (DELETED, 'deleted'), (BLOCKED, 'blocked')] id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255)) text = db.Column(db.Text()) status = db.Column(db.Integer, default=STATUS.ACTIVE) author_id = db.Column(db.Integer, db.ForeignKey('users.id')) community_id = db.Column(db.Integer, db.ForeignKey('community.id')) datetime = db.Column(db.DateTime, default=datetime.now) comments_count = db.Column(db.Integer, default=0) votes_count = db.Column(db.Integer, default=0) views_count = db.Column(db.Integer, default=0) author = db.relationship("User", backref="posts", lazy="joined") @classmethod def all(cls): return cls.query.filter().order_by(cls.datetime.desc()).all() @property def announcement(self): parts = self.text.split('<!-- page break -->') return parts[0] def increment_views(self): self.views_count = (self.views_count or 0) + 1 db.session.commit() def after_delete_comment(self, comment=None): self.__recount_comments() def after_add_comment(self, comment=None): self.__recount_comments() def __recount_comments(self): self.comments_count = len([ c for c in self.comments_all if c.status != Comment.Status.DELETED ]) def after_delete_vote(self, vote=None): self.votes_count = (self.votes_count or 0) - 1 def after_add_vote(self, vote=None): self.votes_count = (self.votes_count or 0) + 1 def after_update_vote(self, value): self.votes_count = (self.votes_count or 0) + value def to_json(self): return news_schema.dump(self)
class News(db.Model, Mixin, HasComments, HasVotes): __tablename__ = 'news' ( STATUS_ACTIVE, STATUS_DELETED, STATUS_BLOCKED, ) = range(3) STATUSES = [(STATUS_ACTIVE, 'Active'), (STATUS_DELETED, 'Deleted'), (STATUS_BLOCKED, 'Blocked')] id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255)) text = db.Column(db.Text()) status = db.Column(db.Integer, default=STATUS_ACTIVE) author_id = db.Column(db.Integer, db.ForeignKey('users.id')) category_id = db.Column(db.Integer, db.ForeignKey('news_category.id')) datetime = db.Column(db.DateTime, default=datetime.now) comments_count = db.Column(db.Integer, default=0) votes_count = db.Column(db.Integer, default=0) views_count = db.Column(db.Integer, default=0) author = db.relationship("User", backref="news", lazy="joined") category = db.relationship("NewsCategory", backref=db.backref( 'news', order_by=desc('News.datetime')), lazy="joined") tags = db.relationship("NewsTag", secondary="news_tag_association", backref=db.backref('news', order_by=desc('News.datetime')), lazy="joined") @classmethod def all(cls): news = cls.query.filter().order_by(cls.datetime.desc()).all() return news @classmethod def all_by_category(cls, id): news = cls.query.filter(News.category_id == id).order_by( cls.datetime.desc()).all() return news @classmethod def all_by_tag(cls, tag): return cls.query.join((NewsTag, cls.tags))\ .filter(NewsTag.name.ilike(tag.name))\ .order_by(cls.datetime.desc()).all() @property def announcement(self): parts = self.text.split('<!-- page break -->') return parts[0] def increment_views(self): self.views_count = (self.views_count or 0) + 1 db.session.commit() def after_delete_comment(self, comment=None): self.__recount_comments() def after_add_comment(self, comment=None): self.__recount_comments() def __recount_comments(self): self.comments_count = len([ c for c in self.comments_all if c.status != Comment.Status.DELETED ]) def after_delete_vote(self, vote=None): self.votes_count = (self.votes_count or 0) - 1 def after_add_vote(self, vote=None): self.votes_count = (self.votes_count or 0) + 1 def after_update_vote(self, value): self.votes_count = (self.votes_count or 0) + value def to_json(self): return news_schema.dump(self)
class CourseModel(db.Model): __tablename__ = 'courses' hash_key = db.Column(db.BigInteger, primary_key=True) timestamp = db.Column(db.DateTime(timezone=True), default=func.now()) date = db.Column(db.String(80), default=func.to_char(func.today, '%Y-%m-%d')) start_name = db.Column(db.String(80), db.ForeignKey('locations.name'), nullable=False) start = db.relationship('LocationModel', foreign_keys=start_name) end_name = db.Column(db.String(80), db.ForeignKey('locations.name'), nullable=False) end = db.relationship('LocationModel', foreign_keys=end_name) map_course = db.Column(db.Float(precision=1)) compass_course = db.Column(db.Float(precision=1)) nautical_mile = db.Column(db.Float(precision=1)) def __init__(self, date, start_name, end_name): self.hash_key = self.create_hash_key(date, start_name, end_name) self.date = date self.start_name = start_name self.end_name = end_name self.map_course = self.get_map_couse() self.compass_course = self.get_compass_course() self.nautical_mile = self.get_nautical_mile() def get_nautical_mile(self): start_location = LocationModel.find_by_name(self.start_name) end_location = LocationModel.find_by_name(self.end_name) return dis.calculate_nautical_mile( self.convert_locationmodel_to_geolocation(start_location), self.convert_locationmodel_to_geolocation(end_location)) def get_map_couse(self): start_location = LocationModel.find_by_name(self.start_name) end_location = LocationModel.find_by_name(self.end_name) return dis.calculate_map_course_from_start_end( self.convert_locationmodel_to_geolocation(start_location), self.convert_locationmodel_to_geolocation(end_location)) def get_compass_course(self): map_course = self.get_map_couse() start_location = LocationModel.find_by_name(self.start_name) start_geo_location = self.convert_locationmodel_to_geolocation( start_location) course = dis.SailingCourse(start_geo_location.name, start_geo_location.latitude, start_geo_location.longitude, map_course=map_course, date=self.date) mag_dev = MagDev() return dis.cal_compass_course(course, mag_dev) @staticmethod def create_hash_key(date, start_name, end_name): return hash((date, start_name, end_name)) @staticmethod def convert_locationmodel_to_geolocation(loc: LocationModel): return dis.GeoLocation(name=loc.name, latitude=loc.latitude, longitude=loc.longtitude) def json(self): return { 'date': self.date, 'start_name': self.start_name, 'end_name': self.end_name, 'map_course': self.map_course, 'compass_course': self.compass_course, 'nautical_mile': self.nautical_mile } @classmethod def find_course(cls, date, start_time, end_time): hasd_key = cls.create_hash_key(date, start_time, end_time) return cls.query.filter_by(hash_key=hasd_key).first() @classmethod def find_by_start_name(cls, start_name): return { start_name: [ course.json() for course in cls.query.filter_by(name=start_name).all() ] } @classmethod def find_by_end_name(cls, end_name): return { end_name: [ course.json() for course in cls.query.filter_by(name=end_name).all() ] } @classmethod def find_by_date(cls, date): return { date: [course.json() for course in cls.query.filter_by(date=date).all()] } def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit()