def create_cycling_data_table(data_table_name):
table = db.Table(
data_table_name,
db.Column('date_time', db.DateTime, nullable=False),
db.Column('test_time', db.Float, nullable=False),
db.Column('step_time', db.Float, nullable=False),
db.Column('step_index', db.Integer, nullable=False),
db.Column('cycle_index', db.Integer, nullable=False),
db.Column('current_A', db.Float, nullable=False),
db.Column('voltage_V', db.Float, nullable=False)
)
return table
from server.models.dtos.licenses_dto import LicenseDTO, LicenseListDTO
from server.models.postgis.utils import NotFound
from server import db
# Secondary table defining the many-to-many join
users_licenses_table = db.Table(
'users_licenses', db.metadata,
db.Column('user', db.BigInteger, db.ForeignKey('users.id')),
db.Column('license', db.Integer, db.ForeignKey('licenses.id')))
class License(db.Model):
""" Describes an individual license"""
__tablename__ = "licenses"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True)
description = db.Column(db.String)
plain_text = db.Column(db.String)
projects = db.relationship("Project", backref='license')
users = db.relationship(
"License", secondary=users_licenses_table) # Many to Many relationship
@staticmethod
def get_by_id(license_id: int):
""" Get license by id """
return License.query.get(license_id)
@classmethod
def create_from_dto(cls, dto: LicenseDTO) -> int:
from werkzeug.security import generate_password_hash, check_password_hash
from server import db
from server.rbac.model import UserMixin
users_roles = db.Table(
'users_roles',
db.Column('user_id',
db.Integer,
db.ForeignKey('user.id'),
primary_key=True),
db.Column('role_id',
db.Integer,
db.ForeignKey('role.id'),
primary_key=True))
class User(db.Model, UserMixin):
__table_args__ = {'extend_existing': True}
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
modified_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
email = db.Column(db.String(255), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
display_name = db.Column(db.String(120))
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True)
new_user = db.Column(db.Boolean(), default=True)
full_name = db.Column(db.String(20), unique=True)
password = db.Column(db.String(20), unique=True)
additional_info = db.Column(db.String(20), unique=True)
# Schedule is a Component of Guttersnipe. 1-to-1 relationship
class Schedule (db.Model):
__tablename__ = 'user_schedule'
id = db.Column(db.Integer, primary_key=True)
schedule = db.Column(db.Integer, db.ForeignKey('schedule.id'))
notes = db.Column(db.String(20))
# User has Mailbox of Messages.
class Message(db.Model):
__tablename__ = 'message'
id = db.Column(db.Integer, primary_key=True)
schedule = db.Column(db.Integer, db.ForeignKey('schedule.id'))
text = db.Column(db.String(2054))
sender = db.Column(db.Integer, db.ForeignKey('guttersnipe.id'))
recipient = db.Column(db.Integer, db.ForeignKey('guttersnipe.id'))
sent = db.Column(db.DateTime)
# User can block another user
#class BlockUser(db.Model):
blockUserTable = db.Table(
'followers',
db.Column('blocker_id', db.Integer, db.ForeignKey('guttersnipe.id')),
db.Column('blocked_id', db.Integer, db.ForeignKey('guttersnipe.id')))
"""API access for an automated system."""
id = db.Column(db.String(255), primary_key=True)
secret = db.Column(db.String(255), nullable=False)
active = db.Column(db.Boolean, default=True)
purpose = db.Column(db.String(255))
created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
modified = db.Column(db.DateTime, default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
revoked = db.Column(db.DateTime)
superuser = db.Column(db.Boolean, default=False)
build_id = db.Column(db.Integer, db.ForeignKey('build.id'))
ownership_table = db.Table(
'build_ownership',
db.Column('build_id', db.Integer, db.ForeignKey('build.id')),
db.Column('user_id', db.String(255), db.ForeignKey('user.id')))
class Build(db.Model):
"""A single repository of artifacts and diffs owned by someone."""
id = db.Column(db.Integer, primary_key=True)
created = db.Column(db.DateTime, default=datetime.datetime.utcnow)
modified = db.Column(db.DateTime, default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow)
name = db.Column(db.String(255))
public = db.Column(db.Boolean, default=False)
owners = db.relationship('User', secondary=ownership_table,
backref=db.backref('builds', lazy='dynamic'),
lazy='dynamic')
cascade="all, delete-orphan")
def __repr__(self):
return '<Font {}>'.format(self.family + " " + self.style)
class UnicodeBlock(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64))
start = db.Column(db.Integer)
end = db.Column(db.Integer)
glyphs = db.relationship('Glyph', back_populates='block')
composite_table = db.Table(
'composite', db.Column('glyph_id', db.Integer, db.ForeignKey('glyph.id')),
db.Column('contour_id', db.Integer, db.ForeignKey('contour.id')))
class Glyph(db.Model):
id = db.Column(db.Integer, primary_key=True)
unicode = db.Column(db.Integer)
name = db.Column(db.String(64))
advance_width = db.Column(db.Integer)
left_side_bearing = db.Column(db.Integer)
#right_side_bearing = advance_width - (left_side_bearing + xMax - xMin)
xMin = db.Column(db.Integer)
xMax = db.Column(db.Integer)
yMin = db.Column(db.Integer)
yMax = db.Column(db.Integer)
from flask_login import UserMixin
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
from sqlalchemy.orm import relationship
from server import db
musculo_ejercicio = db.Table('musculo_ejercicio',
db.Column('id_musculo', db.Integer, db.ForeignKey('parte_cuerpo.id_musculo')),
db.Column('id_ejercicio', db.Integer, db.ForeignKey('ejercicio.id_ejercicio'))
)
class Exercise(db.Model, UserMixin):
__tablename__ = 'ejercicio'
id_ejercicio = db.Column(db.Integer, primary_key=True)
id_tipo_ejercicio = db.Column(db.Integer, db.ForeignKey('tipo_ejercicio.id_tipo_ejercicio'))
nombre_ejercicio = db.Column(db.String(50), nullable=True)
dsc_ejercicio = db.Column(db.String(200), nullable=True)
type_exercise = db.relationship("Type_Exercise", back_populates="exercise", cascade="all,delete")
bodyparts = relationship("BodyPart", secondary=musculo_ejercicio, back_populates="ejercicio", lazy='dynamic')
def __repr__(self):
return f'<Exercise {self.id_ejercicio}, {self.id_tipo_ejercicio}, {self.nombre_ejercicio}, {self.dsc_ejercicio}>'
class BodyPart(db.Model, UserMixin):
__tablename__ = 'parte_cuerpo'
from server import db
from werkzeug.security import generate_password_hash, check_password_hash
from flask_login import UserMixin
from server import login
from datetime import datetime
# M-N relation
FeederUsers = db.Table('feederusers',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
db.Column('feeder_id', db.Integer, db.ForeignKey('feeder.id'), primary_key=True)
)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(64), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
admin = db.Column(db.Boolean,default=False)
feeders = db.relationship('Feeder', secondary=FeederUsers, backref=db.backref('users', lazy='dynamic'), lazy='dynamic')
def __repr__(self):
return f'<User {self.username}>'
def set_password(self,password):
self.password_hash = generate_password_hash(password)
def check_password(self,password):
return check_password_hash(self.password_hash,password)
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
readset = db.Column(db.String)
library = db.Column(db.String)
run_type = db.Column(db.String)
bed = db.Column(db.String)
fastq1 = db.Column(db.String)
fastq2 = db.Column(db.String)
bam = db.Column(db.String)
status = db.Column(db.String)
user_id = db.Column(db.String, db.ForeignKey('users.user_id'))
sample_id = db.Column(db.Integer, db.ForeignKey('samples.id'))
sample_file_link = db.Table(
'sample_file_link',
db.Column('sample_id', db.Integer, db.ForeignKey('samples.id')),
db.Column('file_id', db.Integer, db.ForeignKey('files.id')))
class Sample(db.Model):
__tablename__ = 'samples'
__table_args__ = (db.UniqueConstraint('sample_name',
'user_id',
name='sample_id'), )
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
sample_name = db.Column(db.String)
user_id = db.Column(db.String, db.ForeignKey('users.user_id'))
files = db.relationship(File,
secondary=sample_file_link,
backref="samples")
from server import db
artist_genres = db.Table(
'ArtistGenres',
db.Column('genre_id',
db.Integer,
db.ForeignKey('Genre.id'),
primary_key=True),
db.Column('artist_id',
db.Integer,
db.ForeignKey('Artist.id'),
primary_key=True))
venue_genres = db.Table(
'VenueGenres',
db.Column('genre_id',
db.Integer,
db.ForeignKey('Genre.id'),
primary_key=True),
db.Column('venue_id',
db.Integer,
db.ForeignKey('Venue.id'),
primary_key=True))
class Genre(db.Model):
__tablename__ = 'Genre'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(), nullable=False)
from server import db, UserMixin
from server.backend_database.model_role import modelRole
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('user.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('role.id_tipo_usuario')))
class modelUsuario(db.Model, UserMixin):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
nome_usuario = db.Column(db.String(80))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
data_nascimento = db.Column(db.DateTime())
sexo = db.Column(db.String(1))
telefone = db.Column(db.String(25))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('modelRole',
secondary=roles_users,
backref=db.backref('user', lazy='dynamic'))
import json
from server import db
from sqlalchemy.ext import mutable
class JsonEncodedDict(db.TypeDecorator):
impl = db.Text
def process_bind_param(self, value, dialect):
if value is None:
return '{}'
else:
return json.dumps(value)
def process_result_value(self, value, dialect):
if value is None:
return {}
else:
return json.loads(value)
mutable.MutableDict.associate_with(JsonEncodedDict)
user_location_table = db.Table('user_location_table',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), nullable=False),
db.Column('location_id',db.Integer, db.ForeignKey('location.id'), nullable=False),
)
def __repr__(self):
return f'<User {self.first_name} {self.last_name}>'
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
recipe_ing = db.Table(
'recipe_ing',
db.Column('recipe_id',
UUID(as_uuid=True),
db.ForeignKey('recipe.id'),
primary_key=True),
db.Column('ingredient_id',
UUID(as_uuid=True),
db.ForeignKey('ingredient.id'),
primary_key=True))
class Recipe(db.Model):
__tablename__ = 'recipe'
id = db.Column(UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = db.Column(db.String(40), nullable=False)
from sqlalchemy import func, desc, distinct
from sqlalchemy.ext.hybrid import Comparator, hybrid_property
from flask_login import UserMixin, AnonymousUserMixin, current_user
from server import db, login_manager
@login_manager.user_loader
def load_user(user_id):
"""Check if user is logged-in on every page load."""
if user_id is not None:
return User.query.get(int(user_id))
return None
note_tag = db.Table(
'tags', db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')),
db.Column('note_id', db.Integer, db.ForeignKey('notes.id')))
class User(UserMixin, db.Model):
__table_args__ = {'extend_existing': True}
id = db.Column('id', db.Integer, primary_key=True)
username = db.Column('username', db.String(), unique=False, index=True)
email = db.Column('email', db.String(), unique=True, index=True)
password = db.Column('password', db.String())
registered_on = db.Column('registered_on',
db.DateTime(timezone=True),
server_default=func.now())
notes = db.relationship('Notes',
backref='author',
"""Film models definition."""
from server import db
table_film_to_character_map = db.Table(
"film_to_character_map", db.Model.metadata,
db.Column("film_id", db.Integer,
db.ForeignKey("film.id"),
primary_key=True, nullable=False),
db.Column("character_id", db.Integer,
db.ForeignKey("character.id"),
primary_key=True, nullable=False),
)
class Film(db.Model):
"""Defining a film model."""
__tablename__ = "film"
id = db.Column(db.Integer, primary_key=True)
film_id = db.Column(db.String(64))
title = db.Column(db.String(64))
description = db.Column(db.Text())
director = db.Column(db.String(64))
producer = db.Column(db.String(64))
release_date = db.Column(db.Integer())
rt_score = db.Column(db.Integer())
species = db.Column(db.String(128))
locations = db.Column(db.String(128))
from server import db
from datetime import datetime
timed_comment_likes = db.Table('timed_comment_likes',
db.Column('user_id',db.Integer(),db.ForeignKey('User.id')),
db.Column('comment_id',db.Integer(),db.ForeignKey('TimedComment.id')),
db.UniqueConstraint('user_id', 'comment_id', name='like_constraint')
)
class TimedComment(db.Model):
__tablename__ = 'TimedComment'
id = db.Column(db.Integer, primary_key = True)
show_series_id = db.Column(db.Integer, db.ForeignKey('ShowSeries.id'))
user_id = db.Column(db.Integer, db.ForeignKey('User.id'))
comment_time = db.Column(db.Integer)
is_reported = db.Column(db.Boolean())
content = db.Column(db.String(200))
post_date = db.Column(db.DateTime(), default = datetime.utcnow)
parent_id = db.Column(db.Integer, db.ForeignKey('TimedComment.id'))
liked_by = db.relationship('User', secondary=timed_comment_likes, backref=db.backref('liked_timed_comments',lazy='dynamic'), lazy='dynamic')
children = db.relationship("TimedComment", backref = db.backref('parent',remote_side = id))
def __init__(self, show_series_id, user_id, comment_time, content, parent_id):
self.show_series_id = show_series_id
self.user_id = user_id
self.comment_time = comment_time
self.content = content
self.parent_id = parent_id
from server import db, bcrypt
from datetime import datetime
userDevice = db.Table(
'userDevice', db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
db.Column('device_id', db.Integer, db.ForeignKey('devices.id')))
deviceArea = db.Table(
'deviceArea',
db.Column('device_id', db.Integer, db.ForeignKey('devices.id')),
db.Column('area_id', db.Integer, db.ForeignKey('areas.id')))
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
surname = db.Column(db.String)
email = db.Column(db.String, unique=True)
phone = db.Column(db.String)
passwordHash = db.Column(db.Binary(60))
isAdmin = db.Column(db.Boolean, default=False)
isEmailVerified = db.Column(db.Boolean, default=False)
def __init__(self, name, surname, email, phone, plaintext_password,
isAdmin, isEmailVerified):
self.name = name
self.surname = surname
self.email = email
from sqlalchemy.orm import relationship
from sqlalchemy import ForeignKey
from datetime import datetime
from server import db, login_manager
from flask_login import UserMixin
from datetime import datetime
@login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
user_tickets = db.Table(
'user_tickets',
db.Column('ticket_id', db.Integer, db.ForeignKey('ticket.id')),
db.Column('user_id', db.Integer, db.ForeignKey('user.id')))
class User(db.Model, UserMixin):
__tablename__ = "user"
id = db.Column(db.Integer, primary_key=True)
gid = db.Column(db.Integer, nullable=False, default=6)
tickets = db.relationship('Ticket',
secondary=user_tickets,
lazy='subquery',
backref=db.backref('tickets', lazy=True))
title = db.Column(db.String(30), nullable=True, default='Użytkownik')
username = db.Column(db.String(25), unique=True, nullable=False)
email = db.Column(db.String(50), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
types = db.relationship("Types",
secondary=lambda: helper_pokemon_type,
back_populates="pokemon")
abilities = db.relationship("Abilities",
secondary=lambda: helper_pokemon_ability,
back_populates="pokemon")
generation = db.relationship("Generation",
secondary=lambda: helper_pokemon_generation,
back_populates="pokemon")
habitat = db.relationship("Habitat",
secondary=lambda: helper_pokemon_habitat,
back_populates="pokemon")
helper_pokemon_type = db.Table(
"helper_pokemon_type",
db.Column("pokemon", db.Integer, db.ForeignKey(Pokemon.id)),
db.Column("type", db.Integer, db.ForeignKey(Types.id)))
helper_pokemon_ability = db.Table(
"helper_pokemon_ability",
db.Column("pokemon", db.Integer, db.ForeignKey(Pokemon.id)),
db.Column("ability", db.Integer, db.ForeignKey(Abilities.id)))
helper_pokemon_generation = db.Table(
"helper_pokemon_generation",
db.Column("pokemon", db.Integer, db.ForeignKey(Pokemon.id)),
db.Column("generation", db.Integer, db.ForeignKey(Generation.id)))
helper_pokemon_habitat = db.Table(
"helper_pokemon_habitat",
db.Column("pokemon", db.Integer, db.ForeignKey(Pokemon.id)),
from server import db,ma
notes_label = db.Table('NotesLabel',
db.Column('notes_id',db.Integer,db.ForeignKey('notes.id')),
db.Column('label_id',db.Integer,db.ForeignKey('label.id')))
class User(db.Model):
id = db.Column(db.Integer,primary_key=True)
user_name = db.Column(db.String(50))
email = db.Column(db.String(100),unique=True)
password = db.Column(db.String(80))
is_admin = db.Column(db.Boolean,default=False)
notes = db.relationship('Notes',backref=db.backref('note',lazy=True))
class Notes(db.Model):
id = db.Column(db.Integer,primary_key=True)
title= db.Column(db.String(100), unique=False)
body = db.Column(db.Text, unique=False)
labels= db.relationship('Label',secondary=notes_label,backref='labels')
label = db.Column(db.ARRAY(db.Integer),nullable=True)
user_id = db.Column(db.Integer,db.ForeignKey('user.id'),nullable=False)
def __init__(self,title,body,label,user_id):
self.title=title
self.body=body
self.label=label
self.user_id=user_id
# it doesn't impact the JOIN added by joined eager loading. As a guard
# against this and other potential scenarios, we can check every object as
# its loaded and refuse to continue if there's a problem
# @event.listens_for(OrgBase, "load", propagate=True)
# def load(obj, context):
# todo: need to actually make this work...
# if not obj.organisations and not context.query._execution_options.get("show_all", False):
# raise TypeError(
# "organisation object %s was incorrectly loaded, did you use "
# "joined eager loading?" % obj)
user_transfer_account_association_table = db.Table(
'user_transfer_account_association_table', db.Model.metadata,
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), index=True),
db.Column('transfer_account_id',
db.Integer,
db.ForeignKey('transfer_account.id'),
index=True))
organisation_association_table = db.Table(
'organisation_association_table',
db.Model.metadata,
db.Column('organisation_id',
db.Integer,
db.ForeignKey('organisation.id'),
index=True),
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), index=True),
db.Column('transfer_account_id',
db.Integer,
db.ForeignKey('transfer_account.id'),
from datetime import datetime
from server import db
games_genres = db.Table(
'games_genres', db.Model.metadata,
db.Column('game_id', db.Integer, db.ForeignKey('games.id')),
db.Column('genre_id', db.Integer, db.ForeignKey('genres.id')))
class Series(db.Model):
id = db.Column(db.Integer, primary_key=True)
igdb_id = db.Column(db.BigInteger, nullable=False)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
class Company(db.Model):
__tablename__ = 'companies'
id = db.Column(db.Integer, primary_key=True)
igdb_id = db.Column(db.BigInteger, nullable=False)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
class Genre(db.Model):
__tablename__ = 'genres'
id = db.Column(db.Integer, primary_key=True)
igdb_id = db.Column(db.BigInteger, nullable=False)
name = db.Column(db.String(255), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.now())
from server import db
from server.rbac.model import RoleMixin
roles_parents = db.Table(
'roles_parents',
db.Column('role_id',
db.Integer,
db.ForeignKey('role.id'),
primary_key=True),
db.Column('parent_id',
db.Integer,
db.ForeignKey('role.id'),
primary_key=True))
class Role(db.Model, RoleMixin):
__table_args__ = {'extend_existing': True}
__tablename__ = 'role'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
modified_at = db.Column(db.DateTime,
default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
name = db.Column(db.String(80), nullable=False, unique=True)
description = db.Column(db.String(255))
parents = db.relationship('Role',
secondary=roles_parents,
primaryjoin=(id == roles_parents.c.role_id),
secondaryjoin=(id == roles_parents.c.parent_id),
from server import db
import datetime
UserCourse = db.Table(
'user_course', db.Model.metadata,
db.Column('user', db.Integer, db.ForeignKey('user.id')),
db.Column('course', db.Integer, db.ForeignKey('course.id')))
TeacherCourse = db.Table(
'teacher_course', db.Model.metadata,
db.Column('user', db.Integer, db.ForeignKey('teacher.id')),
db.Column('course', db.Integer, db.ForeignKey('course.id')))
class User(db.Model):
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(50), nullable=False)
teacher = db.relationship("Teacher", uselist=False, back_populates="user")
courses = db.relationship("Course", secondary=UserCourse, backref='users')
course_questions = db.relationship("CourseQuestion",
back_populates="sender")
#sent_messages = db.relationship("Message", back_populates="sender", foreign_keys=[message_history.sender_id])
#received_messages = db.relationship("Message", back_populates="receiver", foreign_keys=[message_history.receiver_id])
def __repr__(self):
return f"User('{self.email}')"
import random
from typing import Dict, List
from sqlalchemy import event
from sqlalchemy.ext.hybrid import hybrid_property
from server import db, bcrypt
association_table = db.Table('image_tag_association',
db.Column('image_id', db.Integer, db.ForeignKey('images.id'), primary_key=True),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id'), primary_key=True))
flatten = lambda list_to_flatten: [item for sublist in list_to_flatten for item in sublist]
class Image(db.Model):
__tablename__ = 'images'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
exif_data = db.Column(db.JSON)
tags = db.relationship('Tag', secondary=association_table, lazy='subquery',
backref=db.backref('images', lazy=True))
def add_tags(self, category_tags: Dict) -> None:
for category, tags in category_tags.items():
from subprocess import Popen, PIPE
from datetime import datetime
from time import mktime
from flask import jsonify
from server import db
from flask_sqlalchemy import SQLAlchemy
tags = db.Table(
'tags',
db.Column('recording_id', db.Integer, db.ForeignKey('recordings.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tags.id')))
class Recording(db.Model):
__tablename__ = "recordings"
id = db.column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
filepath = db.Column(db.String, nullable=False)
date_created = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
date_modified = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
tags = db.relationship('tags',
secondary=tags,
backref=db.backref('recordings'))
def __init__(self, n="", r=False, p=None, t="Start"):
self.id = 0
from sqlalchemy.orm.session import make_transient
from server import db
from server.models.dtos.project_dto import ProjectDTO, DraftProjectDTO, ProjectSummary, PMDashboardDTO
from server.models.postgis.priority_area import PriorityArea, project_priority_areas
from server.models.postgis.project_info import ProjectInfo
from server.models.postgis.statuses import ProjectStatus, ProjectPriority, MappingLevel, TaskStatus, MappingTypes
from server.models.postgis.tags import Tags
from server.models.postgis.task import Task
from server.models.postgis.user import User
from server.models.postgis.utils import ST_SetSRID, ST_GeomFromGeoJSON, timestamp, ST_Centroid, NotFound
from server.services.grid.grid_service import GridService
# Secondary table defining many-to-many join for private projects that only defined users can map on
project_allowed_users = db.Table(
'project_allowed_users', db.metadata,
db.Column('project_id', db.Integer, db.ForeignKey('projects.id')),
db.Column('user_id', db.BigInteger, db.ForeignKey('users.id')))
# cache mapper counts for 30 seconds
active_mappers_cache = TTLCache(maxsize=1024, ttl=30)
class Project(db.Model):
""" Describes a HOT Mapping Project """
__tablename__ = 'projects'
# Columns
id = db.Column(db.Integer, primary_key=True)
status = db.Column(db.Integer,
default=ProjectStatus.DRAFT.value,
nullable=False)
"""
This is the SQL schema of the application.
"""
from flask_sqlalchemy import SQLAlchemy
from server import db, app
from flask_login import UserMixin
from passlib.apps import custom_app_context as pwd_context
from . import logger
import datetime
# Many to many relationship betweem User and Chat
userchat_table = db.Table(
'user_chat_table',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), nullable=False),
db.Column('chat_id', db.Integer, db.ForeignKey('chat.id'), nullable=False),
db.PrimaryKeyConstraint('user_id', 'chat_id'))
#user class for storing user information
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True)
password_hash = db.Column(db.String(128))
jwt_token = db.Column(db.String)
chats = db.relationship('Chat', secondary=userchat_table, backref='users')
def __init__(self, username, password):
self.username = username
self.email = ""
# Several empty classes to implement the search functionality for our models
class CompanyQuery(BaseQuery, SearchQueryMixin):
pass
class GameQuery(BaseQuery, SearchQueryMixin):
pass
class YearQuery(BaseQuery, SearchQueryMixin):
pass
association_table_game_company = db.Table(
'association_game_company',
db.Column('game_id', db.Integer, db.ForeignKey('games.game_id')),
db.Column('company_id', db.Integer, db.ForeignKey('companies.company_id')))
association_table_game_genre = db.Table(
'association_game_genre',
db.Column('game_id', db.Integer, db.ForeignKey('games.game_id')),
db.Column('genre_id', db.Integer, db.ForeignKey('genres.genre_id')))
association_table_game_platform = db.Table(
'association_game_platform',
db.Column('game_id', db.Integer, db.ForeignKey('games.game_id')),
db.Column('platform_id', db.Integer,
db.ForeignKey('platforms.platform_id')))
def get_game_genre_table():
from server import db
from datetime import datetime
from flask_security import UserMixin, RoleMixin
# Define models
roles_users = db.Table(
'roles_users', db.Column('user_id', db.Integer(),
db.ForeignKey('User.id')),
db.Column('role_id', db.Integer(), db.ForeignKey('Role.id')))
class Role(db.Model, RoleMixin):
__tablename__ = 'Role'
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __repr__(self):
return self.name
class User(db.Model, UserMixin):
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30))
email = db.Column(db.String(255))
password = db.Column(db.String(255))
creation_date = db.Column(db.DateTime(), default=datetime.utcnow)
last_login = db.Column(db.DateTime(), default=datetime.utcnow)
is_deleted = db.Column(db.Boolean(), default=False)
