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)