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