class Article(db.Model): __tablename__ = 'article' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(255)) content = db.Column(db.Text) status = db.Column(db.Integer, default=0) pushtime = db.Column(db.DateTime) users = db.relationship('User', secondary=article_user, backref=db.backref('article')) types = db.relationship('Type', secondary=article_type, backref=db.backref('article'))
class Hostviews(db.Model): __tablename__ = 'hostviews' id = db.Column(db.INTEGER, primary_key=True) Hostname = db.Column(db.String(50)) Netip = db.Column(db.String(50), unique=True) Wnetip = db.Column(db.String(50), unique=True) Cpus = db.Column(db.INTEGER) Memtotal = db.Column(db.INTEGER) Service = db.Column(db.String) env_id = db.Column(db.INTEGER, db.ForeignKey('envviews.id')) envviews = db.relationship('EnvViews', backref=db.backref('hostviews', lazy='dynamic')) def __init__(self, Hostname, Netip, Wnetip, Cpus, Memtotal, Service, env_id): self.Hostname = Hostname self.Netip = Netip self.Wnetip = Wnetip self.Cpus = Cpus self.Memtotal = Memtotal self.Service = Service self.env_id = env_id def __repr__(self): return '<主机信息:{} {}>'.format(self.Hostname, self.Netip)
class Employee(db.Model): __tablename__ = 'employee' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) gender = db.Column(db.String) mobile = db.Column(db.String) address = db.Column(db.String) text = db.Column(db.Text) c_time = db.Column(db.DateTime) departmentid = db.Column(db.Integer, db.ForeignKey('department.id')) department = db.relationship('Department', backref=db.backref('employees', lazy='dynamic')) def __init__(self, name=None, gender=None, mobile=None, address=None, text=None, c_time=None): self.name = name self.gender = gender self.mobile = mobile self.address = address self.text = text self.c_time = datetime.now()
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) first_name = db.Column(db.String(80), nullable=False) middle_name = db.Column(db.String(80)) surname = db.Column(db.String(80), nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) photoname = db.Column(db.String(120), nullable=True) role_id = db.Column(db.Integer, db.ForeignKey('role.id'), nullable=False) role = db.relationship('Role', backref=db.backref('users', lazy=True)) general_info = db.relationship('GeneralInfo', backref=db.backref('users', lazy=True)) highschool_info = db.relationship('HighschoolInfo', backref=db.backref('users', lazy=True)) population_info = db.relationship('PopulationInfo', backref=db.backref('users', lazy=True)) university_info = db.relationship('UniversityInfo', backref=db.backref('users', lazy=True)) family = db.relationship('Family', backref=db.backref('users', lazy=True)) interests = db.relationship('Interests', backref=db.backref('users', lazy=True)) def __repr__(self): return "<User {0!r}>".format(self.username) def set_password(self, password): self.password = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password, password)
class DepartmentModel(db.Model): __tablename__ = 'departments' p_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), unique=True, nullable=False) code = db.Column(db.String(120), unique=True, nullable=False) class_id = db.Column(db.Integer, db.ForeignKey('classes.p_id'), nullable=False) classes = db.relationship("ClassModel", backref=db.backref("dep_class", uselist=False)) def save_to_db(self): db.session.add(self) db.session.commit() def db_to_delete(self): db.session.delete(self) db.session.commit() def db_to_commit(self): db.session.commit() def update_data(self, old_data, new_data): old_data.name = new_data['name'] old_data.code = new_data['code'] old_data.class_id = new_data['class_id'] return old_data #FOR CONVERT DATA INTO JSON FORMAT @staticmethod def to_json(data): return { 'name': data.name, 'code': data.code, 'class': data.classes.name, } @classmethod def find_by_code(cls, code): return cls.query.filter_by(code=code).first() @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() @classmethod def find_by_id(cls, p_id): return cls.query.filter_by(p_id=p_id).first() @classmethod def return_all(cls): return { 'departments': list(map(lambda x: cls.to_json(x), DepartmentModel.query.all())) }
class Family(db.Model): # Aile id = db.Column(db.Integer, primary_key=True) monthly_income_level = db.Column(db.Integer, nullable=False) # Aile Aylık Gelir Düzeyi persons = db.relationship('OtherPersons', backref=db.backref('familys', lazy=True)) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) def __repr__(self): return "<Family {0!r}>".format(self.id)
class State(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) country_id = db.Column(db.Integer, db.ForeignKey('country.id')) country = db.relationship('Country', backref=db.backref('states')) def __init__(self, name, country): self.name = name self.country = country
class City(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) state_id = db.Column(db.Integer, db.ForeignKey('state.id')) state = db.relationship('State', backref=db.backref('cities')) def __init__(self, name, state): self.name = name self.state = state
class UserModel(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(120), unique=True, nullable=False) password = db.Column(db.String(120), nullable=False) firstName = db.Column(db.String()) lastName = db.Column(db.String()) roles = db.relationship('RoleModel', secondary=user_roles, backref=db.backref('users', lazy='dynamic')) def save_to_db(self): db.session.add(self) db.session.commit() def delete_me(self): db.session.delete(self) db.session.commit() @classmethod def find_by_username(cls, username): return cls.query.filter_by(username=username).first() @classmethod def return_all(cls): def to_json(x): return { 'username': x.username, 'password': x.password, 'firstName': x.firstName, 'lastName': x.lastName, 'roles': [role.role_name for role in x.roles] } return list(map(lambda x: to_json(x), UserModel.query.all())) # @classmethod # def delete_all(cls): # try: # num_rows_deleted = db.session.query(cls).delete() # db.session.commit() # return {'message': '{} row(s) deleted'.format(num_rows_deleted)} # except: # return {'message': 'Something went wrong'} @staticmethod def generate_hash(password): return sha256.hash(password) @staticmethod def verify_hash(password, hashed_password): return sha256.verify(password, hashed_password)
class PoolAssignments(db.Model): """ User Model for storing network related details """ __tablename__ = "pool_assignments" id = db.Column(db.Integer, primary_key=True) ipaddress = db.Column(db.String(20)) machinename = db.Column(db.String(50)) status = db.Column(db.Integer, default=0) rangeid = db.Column(db.Integer, db.ForeignKey('network_pools.id')) assignment_tag = db.relationship('Tags', secondary=tags_junction_table, backref=db.backref('assignment_tag'), lazy='dynamic')
class Log(db.Model): id = db.Column(db.Integer, primary_key=True) model = db.Column(db.String(25), nullable=False) field = db.Column(db.String(25), nullable=False) value = db.Column(db.String(25), nullable=False) time = db.Column(db.String(25), nullable=False) ip = db.Column(db.String(20), nullable=False) object_id = db.Column(db.Integer, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) user = db.relationship('User', backref=db.backref('logs', lazy=True)) def __repr__(self): return "<Log {0!r}>".format(self.id)
class Role(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50), nullable=False) funcs = db.relationship('RoleFuncs', backref=db.backref('users', lazy=True)) def access(self, query): for func in self.funcs: if func.name == query: return True return False def __repr__(self): return '<Role {0!r}>'.format(self.name)
class OtherPersons(db.Model): id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(80), nullable=False) # Ismi gender = db.Column(db.String(16), nullable=False) # Cinsiyeti job = db.Column(db.String(80), nullable=False) # Isi marial_status = db.Column(db.String(25), nullable=False) # Evlilik durumu education = db.Column(db.String(25), nullable=False) # Ogretim durumu email = db.Column(db.String(16), nullable=False) # Email birthdate = db.Column(db.String(11), nullable=False) # Dogum tarihi -- death_date = db.Column(db.String(11), nullable=False) # Olum tarihi -- phone_id = db.Column(db.Integer, db.ForeignKey('phone.id'), nullable=True) # Telefon numarasi phone = db.relationship('Phone', backref=db.backref('persons', lazy=True)) family_id = db.Column(db.Integer, db.ForeignKey('family.id'), nullable=False) type_id = db.Column(db.Integer, db.ForeignKey('person_type.id'), nullable=False) # Ogrencinin neyi type_ = db.relationship('PersonType', backref=db.backref('persons', lazy=True)) def __repr__(self): return '<OtherPersons {0!r}>'.format(self.id)
class Networks(db.Model): """ User Model for storing network related details """ __tablename__ = "networks" id = db.Column(db.Integer, primary_key=True) key = db.Column(db.String(75)) networkname = db.Column(db.String(50)) vlanid = db.Column(db.String(25)) datacenter = db.Column(db.String(50)) cluster = db.Column(db.String(50)) subnets = db.relationship('NetworkPools', backref='owner', lazy='joined') network_tag = db.relationship('Tags', secondary=tags_junction_table, backref=db.backref('network_tag'), lazy='dynamic')
class UniversityInfo(db.Model): # Universite Bilgileri id = db.Column(db.Integer, primary_key=True) university_student_no = db.Column(db.Integer, nullable=False) # Üniversite Öğrenci No faculty = db.Column(db.String(25), nullable=False) # Fakülte / MYO department = db.Column(db.String(120), nullable=False) # Bölüm / Program teaching_style = db.Column(db.String(120), nullable=False) # Öğretim Şekli -- student_score = db.Column(db.Integer, nullable=False) # Öss Puanı -- completed_yok = db.Column(db.String(120), nullable=False) # Tamamlanan Yök -- preferences = db.relationship('UniversityPreferences', backref=db.backref('university_info', lazy=True)) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) def __repr__(self): return "<StudentUniversityInfo {0!r}>".format(self.id)
class Book(db.Model): __table__ = 'book' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) subject = db.Column(db.String) author = db.Column(db.String) publish = db.Column(db.String) ISBN = db.Column(db.String) Images = db.Column(db.String) preface = db.Column(db.String) salas = db.Column(db.Boolean) selected = db.Column(db.Boolean) publish_date = db.Column(db.Date) create_date = db.Column(db.Date) categoryid = db.Column(db.Integer, db.ForeignKey('category.id')) category = db.relationship('Category', backref=db.backref('category', lazy='dynamic'))
class NetworkPools(db.Model): """ Model for storing network related details """ __tablename__ = "network_pools" id = db.Column(db.Integer, primary_key=True) poolname = db.Column(db.String(50)) poolrange = db.Column(db.String(20)) subnetmask = db.Column(db.String(20)) gateway = db.Column(db.String(20)) dns1 = db.Column(db.String(20)) dns2 = db.Column(db.String(20)) domainname = db.Column(db.String(50)) owner_id = db.Column(db.Integer, db.ForeignKey('networks.id')) hostips = db.relationship('PoolAssignments', backref='ipowner') pool_tag = db.relationship('Tags', secondary=tags_junction_table, backref=db.backref('pool_tag'), lazy='dynamic')
class Passenger(db.Model): id = db.Column(db.Integer, primary_key=True) email = db.Column(db.String) alias = db.Column(db.String) editURL = db.Column(db.String) validated = db.Column(db.Boolean) oLat = db.Column(db.Numeric) oLon = db.Column(db.Numeric) dLat = db.Column(db.Numeric) dLon = db.Column(db.Numeric) date = db.Column(db.String) picks = db.relationship('Driver', secondary='passengerPicks', backref=db.backref('pickedBy', lazy='dynamic')) def __init__(self, email, alias, oLat, oLon, dLat, dLon, date, url): self.email = email self.alias = alias self.validated = False self.oLat = oLat self.oLon = oLon self.dLat = dLat self.dLon = dLon self.date = date self.editURL = url def __repr__(self): return '<User %r>' % self.email def pick(self, driver): self.picks.append(driver) return self def unpick(self, driver): self.picks.remove(driver) return self def validate(self): self.validated = True return self
class Program(db.Model): id = db.Column(db.Integer, primary_key=True) channel = db.Column(db.Integer, nullable=False) title = db.Column(db.String(128), nullable=False) utitle = db.Column(db.String(128), nullable=False) start = db.Column(db.DateTime, nullable=False) stop = db.Column(db.DateTime, nullable=False) desc = db.Column(db.Text, nullable=True) category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=False) category = db.relationship('Category', backref=db.backref('programs', lazy=True)) def __repr__(self): return '<Program %r>' % self.title def __init__(self, **kwargs): super(Program, self).__init__(**kwargs) # have to do custom stuff due lack of unicode upper in SQLite3 self.utitle = self.title.upper()
class Employee(db.Model): __tablename__ = 'employee' id = db.Column(db.Integer,primary_key=True) name = db.Column(db.String) gender = db.Column(db.String) job = db.Column(db.String) salary = db.Column(db.Float) birthdate = db.Column(db.Date) idcard = db.Column(db.String) address = db.Column(db.String) departmentid = db.Column(db.Integer,db.ForeignKey('department.id')) department = db.relationship('Department',backref=db.backref('employees',lazy='dynamic')) def __init__(self,name=None,gender=None,job=None,salary=0.0,birthdate=None,idcard=None,address=None): self.name = name self.gender = gender self.job = job self.salary = salary self.birthdate = birthdate self.idcard = idcard self.address = address
class IdeaModel(db.Model): __tablename__ = 'ideas' id = db.Column(db.Integer, primary_key=True) content = db.Column(db.String(255), nullable=False) impact = db.Column(db.Integer, nullable=False) ease = db.Column(db.Integer, nullable=False) confidence = db.Column(db.Integer, nullable=False) created_at = db.Column(db.Integer, nullable=False, default=calendar.timegm(time.gmtime())) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) user = db.relationship('UserModel', backref=db.backref('ideas', lazy=True)) def save_to_db(self): db.session.add(self) db.session.commit() @classmethod def find_by_id(cls, id): return cls.query.filter_by(id=id).first() @classmethod def return_paginated(cls): def to_json(x): return { 'id': x.id, 'content': x.content, 'impact': x.impact, 'ease': x.ease, 'confidence': x.confidence, 'average': calculate_avergage(x), 'created_at': x.created_at, } return list(map(lambda x: to_json(x), IdeaModel.query.limit(10).all()))
class Run(db.Model): id = db.Column(db.Integer, primary_key=True) start_time = db.Column(db.DateTime) total_timer_time = db.Column(db.Numeric(scale=2)) total_elapsed_time = db.Column(db.Numeric(scale=2)) # Dynamic Properties # total_ascent = db.Column(db.Numeric(scale=1)) # total_descent = db.Column(db.Numeric(scale=1)) @property def centroid(self): latitude = db.session.query(func.avg( Point.latitude)).filter(Point.run_id == self.id).scalar() longitude = db.session.query(func.avg( Point.longitude)).filter(Point.run_id == self.id).scalar() print(latitude) print(longitude) return {'latitude': latitude, 'longitude': longitude} @property def avg_pace(self): avg_speed = db.session.query(func.avg( Point.speed)).filter(Point.run_id == self.id).scalar() pace = 60 / Q_(avg_speed, ureg.kilometer_per_hour).to( ureg.mile_per_hour).magnitude return f"{round(pace):02}:{round((pace % 1) * 60):02}" @property def max_pace(self): avg_speed = db.session.query(func.max( Point.speed)).filter(Point.run_id == self.id).scalar() pace = 60 / Q_(avg_speed, ureg.kilometer_per_hour).to( ureg.mile_per_hour).magnitude return f"{round(pace):02}:{round((pace % 1) * 60):02}" @property def avg_speed(self): return db.session.query(func.avg( Point.speed)).filter(Point.run_id == self.id).scalar() @property def max_speed(self): return db.session.query(func.max( Point.speed)).filter(Point.run_id == self.id).scalar() @property def start_position(self): return { 'longitude': self.points[0].longitude, 'latitude': self.points[0].latitude } @property def end_position(self): return { 'longitude': self.points[-1].longitude, 'latitude': self.points[-1].latitude } @property def start_datetime(self): return self.points[0].timestamp @property def end_datetime(self): return self.points[-1].timestamp @property def distance(self): return self.points[-1].distance @property def distance_in_miles(self): distance = Q_(self.distance, ureg.meter) return distance.to(ureg.mile).magnitude user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship('User', backref=db.backref('runs')) city_id = db.Column(db.Integer, db.ForeignKey('city.id')) city = db.relationship('City', backref=db.backref('runs')) def __init__(self, city, user): self.city = city self.user = user
class AttendanceModel(db.Model): __tablename__ = 'std_attendance' p_id = db.Column(db.Integer, primary_key=True) date = db.Column(db.DateTime(), nullable=False) class_id = db.Column(db.Integer, db.ForeignKey('classes.p_id'), nullable=False) department_id = db.Column(db.Integer, db.ForeignKey('departments.p_id'), nullable=False) subject_id = db.Column(db.Integer, db.ForeignKey('subjects.p_id'), nullable=False) student_id = db.Column(db.Integer, db.ForeignKey('students.p_id'), nullable=False) status = db.Column(db.String(50), nullable=False) classes = db.relationship("ClassModel", backref=db.backref("atten_class", uselist=False)) departmentes = db.relationship("DepartmentModel", backref=db.backref("atten_class", uselist=False)) subjects = db.relationship("SubjectModel", backref=db.backref("atten_subject")) students = db.relationship("StudentModel", backref=db.backref("atten_student")) def save_to_db(self): db.session.add(self) db.session.commit() def db_to_delete(self): db.session.delete(self) db.session.commit() def db_to_commit(self): db.session.commit() #FOR CONVERT DATA INTO JSON FORMAT @staticmethod def to_json(data): date = data.date return { 'date': date.strftime("%Y-%m-%d"), 'class': data.class_id, 'department': data.department_id, 'subject': data.subject_id, 'student': data.student_id, 'status': data.status } @classmethod def find_by_date(cls, class_id, department_id, subject_id, date): return AttendanceModel.query.filter_by(class_id=class_id, department_id=department_id, subject_id=subject_id, date=date).first() @classmethod def find_student_by_reg(cls, student_id): return StudentModel.query.filter_by(student_id=student_id).first() @classmethod def return_all(cls, class_id, department_id, subject_id, date): print(date) return { 'attendance': list( map( lambda x: cls.to_json(x), AttendanceModel.query.filter_by( date=date, class_id=class_id, department_id=department_id, subject_id=subject_id).all())) }
class Point(db.Model): id = db.Column(db.Integer, primary_key=True) timestamp = db.Column(db.DateTime, nullable=False) elevation = db.Column(db.Numeric) latitude = db.Column(db.Float) longitude = db.Column(db.Float) distance = db.Column(db.Numeric) speed = db.Column(db.Numeric) # precipitation = db.Column(db.Numeric) # precipitation_type = db.Column(db.String) # temperature = db.Column(db.Numeric) # wind_bearing = db.Column(db.Numeric) # wind_speed = db.Column(db.Numeric) leg_id = db.Column(db.Integer, db.ForeignKey('leg.id')) leg = db.relationship('Leg', backref=db.backref('points')) run_id = db.Column(db.Integer, db.ForeignKey('run.id')) run = db.relationship('Run', backref=db.backref('points')) @property def pace(self): speed = Q_(self.speed, ureg.kilometer_per_hour) pace = 60 / speed.to(ureg.mile_per_hour).magnitude return f"{round(pace):02}:{round((pace % 1) * 60):02}" @property def speed_in_mph(self): speed = Q_(self.speed, ureg.kilometer_per_hour) return speed.to(ureg.mile_per_hour).magnitude @property def distance_in_miles(self): distance = Q_(self.distance, ureg.meter) return distance.to(ureg.mile).magnitude @property def elevation_in_feet(self): elevation = Q_(self.elevation, ureg.meter) return elevation.to(ureg.foot).magnitude def timestamp_to_datetime(self, timestamp): '''Convert a string to a datetime instance''' utc_time = pendulum.instance(timestamp) return utc_time #TODO: Move lat long into one var: coords def __init__(self, timestamp, elevation, latitude, longitude, distance, speed, leg, run): # Convert to datetime self.timestamp = self.timestamp_to_datetime(timestamp) self.elevation = elevation self.latitude = latitude self.longitude = longitude self.distance = distance self.speed = speed # self.precipitation = precipitation # self.precipitation_type = precipitation_type # self.temperature = temperature # self.wind_bearing = wind_bearing # self.wind_speed = wind_speed self.leg = leg self.run = run
class StudentModel(db.Model): __tablename__ = 'students' p_id = db.Column(db.Integer, primary_key=True) reg_no = db.Column(db.String(100), unique=True, nullable=False) name = db.Column(db.String(120), nullable=False) gender = db.Column(db.String(120), nullable=False) class_id = db.Column(db.Integer, db.ForeignKey('classes.p_id'), nullable=False) department_id = db.Column(db.Integer, db.ForeignKey('departments.p_id'), nullable=False) session = db.Column(db.String(50), nullable=False) classes = db.relationship("ClassModel", backref=db.backref("std_class", uselist=False)) departmentes = db.relationship("DepartmentModel", backref=db.backref("std_departments", uselist=False)) def save_to_db(self): db.session.add(self) db.session.commit() def db_to_delete(self): db.session.delete(self) db.session.commit() def db_to_commit(self): db.session.commit() @staticmethod def to_json(x): return { 'reg_no': x.reg_no, 'name': x.name, 'gender': x.gender, 'class_id': x.class_id, 'department_id': x.department_id, 'session': x.session } def update_data(self, old_data, new_data): old_data.reg_no = new_data['reg_no'] old_data.name = new_data['name'] old_data.gender = new_data['gender'] old_data.class_id = new_data['class_id'] old_data.department_id = new_data['department_id'] old_data.session = new_data['session'] return old_data @classmethod def find_by_id(cls, p_id): return cls.query.filter_by(p_id=p_id).first() @classmethod def find_by_reg(cls, reg_no): return cls.query.filter_by(reg_no=reg_no).first() @classmethod def return_all(cls): return { 'students': list(map(lambda data: cls.to_json(data), StudentModel.query.all())) }