def get_table_object(table_name):
metadata = db.MetaData()
table_object = db.Table(
table_name,
metadata,
autoload=True,
autoload_with=db.get_engine(bind='summarization'))
return table_object
import arrow
from werkzeug.security import generate_password_hash, check_password_hash
from api import db
from api.model import Department
from api import select_table_name
session = os.environ.get('CURRENT_ASSIGNED_COURSES_SESSION')
semester = os.environ.get('CURRENT_ASSIGNED_COURSES_SEMESTER')
table_name = select_table_name(f'ASSIGNED_COURSES_{semester}_{session}')
assigned_courses = db.Table(
table_name,
db.Column('lecturer_id',
db.Integer,
db.ForeignKey('lecturers.id'),
primary_key=True),
db.Column('course_id',
db.Integer,
db.ForeignKey('courses.id'),
primary_key=True))
class Lecturer(db.Model):
__tablename__ = 'lecturers'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
email = db.Column(db.String(128), index=True)
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'))
password_hash = db.Column(db.String(128))
assigned_courses = db.relationship('Course',
from .AudioFile import AudioFile
from .Person import Person
from .Host import Host, HostSchema
from .Participant import Participant, ParticipantSchema
from api import db, ma
from marshmallow import fields, validate, post_load, ValidationError
from marshmallow_sqlalchemy import SQLAlchemyAutoSchema
participantList = db.Table('participantList',
db.Column('participant_id',
db.Integer,
db.ForeignKey('participant.id'),
primary_key=True),
db.Column('podcast_id',
db.Integer,
db.ForeignKey('podcast.id'),
primary_key=True),
extend_existing=True)
class Podcast(AudioFile):
"""
Inherits from AudioFile class.
The relationship between theparent class and subclasses
follow the "Joined Table Inheritance" (https://docs.sqlalchemy.org/en/13/orm/inheritance.html)
fields:
id: Integer,
name: String [max length = 100],
duratioin: Integer [Positive only],
from datetime import datetime
from flask_sqlalchemy import SQLAlchemy, declarative_base
#from api.finances import models as finance_models
#from api.finances.models import Record
from api import db, ma
# Tabela de associação
# https://flask-sqlalchemy.palletsprojects.com/en/2.x/models/
# Uma coluna representando o relacionamento entre usuários e grupos (muitos para muitos)
clients_groups = db.Table(
'clients_groups',
db.Column('client_id',
db.Integer,
db.ForeignKey('client.id'),
primary_key=True),
db.Column('group_id',
db.Integer,
db.ForeignKey('group.id'),
primary_key=True))
class Client(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True)
id_phone = db.Column(db.Integer, db.ForeignKey('phone.id'), nullable=True)
email = db.Column(db.String(50), unique=True)
created = db.Column(db.DateTime)
# cria uma propriedade
# (não faz parte do banco de dados)
records = db.relationship(
from api import db #importando a instância db
from .funcionario_model import Funcionario
#Criando tabela auxiliar para o relacionamento de n para n
funcionario_projeto = db.Table(
'funcionario_projeto',
db.Column('projeto_id',
db.Integer,
db.ForeignKey('projeto.id'),
primary_key=True,
nullable=False),
db.Column('funcionario_id',
db.Integer,
db.ForeignKey('funcionario.id'),
primary_key=True,
nullable=False))
class Projeto(db.Model):
__tablename__ = 'projeto'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
nome = db.Column(db.String(50), nullable=False)
descricao = db.Column(db.String(100), nullable=False)
#relacionamento n para n
funcionarios = db.relationship(Funcionario,
secondary='funcionario_projeto',
back_populates='projetos')
from api import app, db
from werkzeug.security import generate_password_hash, check_password_hash
from itsdangerous import (TimedJSONWebSignatureSerializer as Serializer, BadSignature, SignatureExpired)
from datetime import datetime
ownership = db.Table('ownership',
db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
db.Column('garden_id', db.Integer, db.ForeignKey('garden.id'), primary_key=True)
)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(32), index=True, unique=True)
email = db.Column(db.String(120), index=True, unique=True)
password_hash = db.Column(db.String(128))
gardens = db.relationship('Garden', secondary=ownership, lazy='dynamic',
backref=db.backref('owners', lazy='dynamic'))
sensors = db.relationship('Sensor', backref='owner', lazy='dynamic')
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)
def generate_auth_token(self, expiration=600):
s = Serializer(app.config['SECRET_KEY'], expires_in=expiration)
return s.dumps({'id': self.id})
from api import db
tag_blog = db.Table(
'tag_blog',
db.Column('tag_id', db.Integer, db.ForeignKey('tag_id'), primary_key=True),
db.Column('blog_id',
db.Integer,
db.ForeignKey('blog_id'),
primary_key=True))
from api import db
tag_article = db.Table(
"tag_article",
db.Column("tag_id", db.Integer, db.ForeignKey("tag.id_"),
primary_key=True),
db.Column("article_id",
db.Integer,
db.ForeignKey("article.id_"),
primary_key=True),
)
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
'''
class User(db.Model):
UserToken = db.Column(db.String(60), primary_key=True)
UserName = db.Column(db.String(10), unique=True, nullable=False)
Password = db.Column(db.String(60), nullable=False)
CreatedDate = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
def __repr__(self):
return f"User('{self.userName}', '{self.userToken}')"
taskDetail = db.Table('taskDetail',
db.Column('TaskToken', db.String(60), db.ForeignKey('task.TaskToken')),
db.Column('RestaurantToken', db.String(60), db.ForeignKey('restaurant.RestaurantToken'))
)
class Task(db.Model):
TaskToken = db.Column(db.String(60), primary_key=True)
CreatedDate = db.Column(db.DateTime, nullable=False, default=datetime.utcnow())
Status = db.Column(db.String(10), nullable=False, default='PENDING')
Restaurants = db.relationship('Restaurant', secondary=taskDetail, backref=db.backref('Assignee', lazy='dynamic'))
class Restaurant(db.Model):
RestaurantToken = db.Column(db.String(60), primary_key=True)
Name = db.Column(db.String(30))
YelpScore = db.Column(db.Integer)
OurScore = db.Column(db.Integer)
from api import db
from api.constants import JOBS
from sqlalchemy_utils import ChoiceType
items = db.Table('items',
db.Column('item_id', db.String(20), db.ForeignKey('item.id')),
db.Column('job_id', db.Integer, db.ForeignKey('job.id')))
class Job(db.Model):
"""
A single job for any given :class:`api.models.Character` and all its items / stats
Jobs are a *superset* of classes. For example, all of the following are jobs for simplicity
* Archer
* Bard
* Blacksmith
* Machinist
"""
id = db.Column(db.Integer, primary_key=True)
character_id = db.Column(db.String(100), db.ForeignKey('character.id'))
job = db.Column(ChoiceType(JOBS))
items = db.relationship('Item',
secondary=items,
backref=db.backref('jobs', lazy='select'))
hp = db.Column(db.Integer)
mp = db.Column(db.Integer)
tp = db.Column(db.Integer)
import arrow
from werkzeug.security import generate_password_hash, check_password_hash
from api import db
from api.model import Department
from api import select_table_name
session = os.environ.get('CURRENT_ASSIGNED_COURSES_SESSION')
semester = os.environ.get('CURRENT_ASSIGNED_COURSES_SEMESTER')
DB_NAME = os.environ.get('DB_NAME')
assigned_courses_table_name = select_table_name(f'ASSIGNED_COURSES_{semester}_{session}')
lecturer_lectures_table_name = select_table_name(f'LECTURER_LECTURES_{semester}_{session}')
student_lectures_table_name = select_table_name(f'STUDENT_LECTURES_{semester}_{session}')
assigned_courses = db.Table(assigned_courses_table_name,
db.Column('lecturer_id', db.Integer, db.ForeignKey('lecturers.id'), primary_key=True),
db.Column('course_id', db.Integer, db.ForeignKey('courses.id'), primary_key=True))
lecture_attendance = db.Table(lecturer_lectures_table_name,
db.Column('lecturer_id', db.Integer, db.ForeignKey('lecturers.id'), primary_key=True),
db.Column('course_id', db.Integer, db.ForeignKey('courses.id'), primary_key=True),
db.Column('count', db.Integer, default=1))
class Lecturer(db.Model):
__tablename__ = 'lecturers'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(100))
email = db.Column(db.String(128), index=True)
department_id = db.Column(db.Integer, db.ForeignKey('departments.id'))
from api import db
from sqlalchemy import func
from sqlalchemy.sql import label
from datetime import (
datetime,
timedelta,
)
from api import UPDATE_DATA_ON_MINUTES
search_results = db.Table('results',
db.Column('keyword', db.String(120), db.ForeignKey('keyword.name')),
db.Column('tweet', db.String(20), db.ForeignKey('tweet.t_id')),
)
class TweetModel(db.Model):
__tablename__ = 'tweet'
t_id = db.Column(db.String(20), primary_key=True)
text = db.Column(db.String(280), nullable=False)
# created_at = db.Column(db.DateTime, nullable=False)
retweet_count = db.Column(db.Integer, nullable=False)
# TODO: Fix the spell mistake here
favorite_count = db.Column(db.Integer, nullable=False)
author_id = db.Column(db.String(20), nullable=False)
keywords = db.relationship('SearchKeyword', secondary=search_results,
backref=db.backref('tweets'), lazy='dynamic')
def __init__(self, data):
from api import db
from marshmallow_sqlalchemy import ModelSchema
movies_actors_association = db.Table(
'actors',
db.Column('actor_id',
db.Integer,
db.ForeignKey('actor.id'),
primary_key=True),
db.Column('movie_id',
db.Integer,
db.ForeignKey('movie.id'),
primary_key=True))
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), unique=True, nullable=False)
genre_id = db.Column(db.Integer, db.ForeignKey('genre.id'), nullable=False)
genre = db.relationship('Genre', backref=db.backref('movie', lazy=True))
cast = db.relationship('Actor',
secondary=movies_actors_association,
lazy=True,
backref=db.backref('movies', lazy=True))
def __repr__(self):
return self.title
class Genre(db.Model):
from datetime import datetime
from api import db
# Table for Many-to-Many Relationship
FundInvestments = db.Table(
'fundinvestments',
db.Column('fund_id', db.Integer,
db.ForeignKey('fund.id')),
db.Column('committment_id', db.Integer,
db.ForeignKey('committment.id')),
db.Column('capitalcall_id', db.Integer,
db.ForeignKey('capitalcall.id')),
db.Column('fundinvestment_id', db.Integer,
db.ForeignKey('fundinvestment.id'))
)
class Fund(db.Model):
__tablename__ = 'fund'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False, unique=True)
date = db.Column(db.DateTime, default=datetime.now(), nullable=False)
# Establish One-to-Many relationship
committments = db.relationship(
'Committment',
backref='fund',
lazy='dynamic'
from api import app, db
groups_users = db.Table(
'groups_users',
db.Column('group_id',
db.ForeignKey('groups.id',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True),
db.Column('user_id',
db.ForeignKey('users.id', ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True))
class Group(db.Model):
__tablename__ = "groups"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20), unique=True, nullable=False)
users = db.relationship('User',
secondary=groups_users,
back_populates='groups')
def serialize(self):
return {"name": self.name}
def get_group(name):
return db.session.query(Group).filter(Group.name == name).first()
def get_members(name):
from api import db
from flask import Flask, url_for, redirect, render_template, request, abort
from flask_sqlalchemy import SQLAlchemy
from flask_security import Security, SQLAlchemyUserDatastore, \
UserMixin, RoleMixin, login_required, current_user
from flask_admin.contrib import sqla
# 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):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(80), unique=True)
description = db.Column(db.String(255))
def __str__(self):
return self.name
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
from api import db
from sqlalchemy_utils import TSVectorType
from flask_sqlalchemy import BaseQuery
from sqlalchemy_searchable import SearchQueryMixin
movie_genre_lnk = db.Table(
'movie_genre_lnk', db.Model.metadata,
db.Column('movie_id', db.Integer, db.ForeignKey('movie.id')),
db.Column('genre_id', db.Integer, db.ForeignKey('genre.id')))
movie_country_lnk = db.Table(
'movie_country_lnk', db.Model.metadata,
db.Column('movie_id', db.Integer, db.ForeignKey('movie.id')),
db.Column('country_id', db.Integer, db.ForeignKey('country.id')))
class MovieQuery(BaseQuery, SearchQueryMixin):
pass
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
query_class = MovieQuery
search_vector = db.Column(TSVectorType('title'))
# Movie Metadata
title = db.Column(db.Text())
status = db.Column(db.Text())
budget = db.Column(db.BigInteger())
imdb_id = db.Column(db.Text())
from api import db
from api.models.user import UserModel
from api.models.tag import TagModel
from datetime import datetime
tags = db.Table(
'tags',
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'), primary_key=True),
db.Column('note_model_id',
db.Integer,
db.ForeignKey('note_model.id'),
primary_key=True))
class NoteModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
note = db.Column(db.String(300), unique=False, nullable=False)
date = db.Column(db.DateTime, default=datetime.now)
author_id = db.Column(db.Integer, db.ForeignKey(UserModel.id))
private = db.Column(db.Boolean(),
default=True,
server_default="true",
nullable=False)
archive = db.Column(db.Boolean(),
default=False,
server_default="false",
nullable=False)
tags = db.relationship(TagModel,
secondary=tags,
lazy='subquery',
backref=db.backref('notes', lazy=True))
from api import db, ma
from api.utilities import generate_uuid
from datetime import datetime
from marshmallow_sqlalchemy import SQLAlchemyAutoSchema
from marshmallow_sqlalchemy.fields import Nested
assignees_for_tasks = db.Table('assignees_for_tasks',
db.Column('assignee_id', db.Integer, db.ForeignKey('user.id')),
db.Column('task_id', db.Integer, db.ForeignKey('task.id'))
)
class Project(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
description = db.Column(db.String(255))
completed = db.Column(db.Boolean, nullable=False, default=False)
slug = db.Column(db.String(36), nullable=False, unique=True, default=generate_uuid)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, onupdate=datetime.utcnow)
planned_complete_date = db.Column(db.DateTime)
completed_at = db.Column(db.DateTime)
tasks = db.relationship('Task', backref='project', lazy='dynamic')
def save(self):
db.session.add(self)
def delete(self):
db.session.delete(self)
from api import db
tags_blog = db.Table(
'tags_blog', db.Column('blog_id', db.Integer, db.ForeignKey('blog.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id')))
from api import db
tag_blog = db.Table(
'tag_blog',
db.Column("tag_id", db.Integer, db.ForeighKey('tag_id'), primary_key=True),
db.Column("blog_id", db.Integer, db.ForeighKey("blog_id"), primary_key=True)
)
# Author: Floreint-Eduard Decu
# Date: July 2020
import datetime
from api import db
# api is the app module
# db is the SQLAlchemy (ORM DATABASE) instantiated in __init__.py
# Association tables
# Relationship between a user and its followers
following = db.Table(
'followers', db.Column('follower_id', db.Integer,
db.ForeignKey('user.id')),
db.Column('followed_id', db.Integer, db.ForeignKey('user.id')))
# Relationship between a post and the users who liked a post
post_likes = db.Table(
'postlikes', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('post_id', db.Integer, db.ForeignKey('post.id')))
class User(db.Model):
#Table content
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(db.String(50), unique=True, nullable=False)
first_name = db.Column(db.String(20), nullable=False)
last_name = db.Column(db.String(20), nullable=False)
email = db.Column(db.String(20), nullable=False)
password = db.Column(db.String(50), nullable=False)
created = db.Column(db.DateTime,
class Types(db.Model):
__tablename__ = 'types'
__table_args__ = {'schema': 'multiquestions'}
id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True)
type = db.Column(db.String(80), nullable=False)
typename = db.Column(db.String(80), nullable=False)
question = db.relationship('Questions',
secondary='multiquestions.relationtypes',
backref=db.backref('types', lazy='dynamic'))
relationtypes = db.Table('relationtypes',
db.Model.metadata,
db.Column(
'id_question', db.Integer,
db.ForeignKey('multiquestions.questions.id')),
db.Column('id_types', db.Integer,
db.ForeignKey('multiquestions.types.id')),
schema='multiquestions')
class Tags(db.Model):
__tablename__ = 'tags'
__table_args__ = {'schema': 'multiquestions'}
id = db.Column(db.Integer, primary_key=True, nullable=False, unique=True)
tagname = db.Column(db.String(80), unique=True, nullable=False)
question = db.relationship('Questions',
secondary='multiquestions.relationtags',
backref=db.backref('tags', lazy='dynamic'))
def serialize(self):
from datetime import datetime
from werkzeug.security import check_password_hash, generate_password_hash
from sqlalchemy.dialects import postgresql
from api import db
import enum
product_category = db.Table(
'product_category',
db.Column('product_id', db.Integer, db.ForeignKey('products.id'), primary_key=True),
db.Column('category_id', db.Integer, db.ForeignKey('categories.id'), primary_key=True)
)
product_flower = db.Table(
'product_flower',
db.Column('product_id', db.Integer, db.ForeignKey('products.id'), primary_key=True),
db.Column('flower_id', db.Integer, db.ForeignKey('flower.id'), primary_key=True)
)
class Role(enum.Enum):
ADMIN = 0
USER = 1
OPERATOR = 2
COPYWRITER = 3
class PaymentMethod(enum.Enum):
CASH = 0
LIQPAY = 1
from api import db
from sqlalchemy.dialects import postgresql
from sqlalchemy import ForeignKey, Column, text
from sqlalchemy.orm import relationship
from sqlalchemy.sql.expression import bindparam
import urllib
from config import URL_TO_MOUNT, THUMBNAIL_ROOT_URL
import binascii
import videoinfo
import logging
import os
from flask import jsonify, url_for
tag_media_association_table = db.Table(
'tag_media', db.metadata,
Column('tag_id', db.Integer, db.ForeignKey('tag.tag_id')),
Column('media_id', db.Integer,
db.ForeignKey('media.media_id', ondelete="cascade")))
# These queries search in the mediainfo JSON which looks like this
# {"streams" : [{"codec_name" : ".." , "width": ".." , "height": ".."}]}
# jsonb_array_elemnts is used to convert the array to a set which can
# be queried using a SELECT
#
# Beware: Super duper hack!
#
# TODO/FIXME: There is some way to construct these queries using the
# sqlalchemy query builder
# There just seems no good documentation (besides this -
# https://bitbucket.org/zzzeek/sqlalchemy/issues/3566/figure-out-how-to-support-all-of-pgs#comment-22842678)
from datetime import datetime
from api import db
from .category import Category
from .review import Review
business_category = db.Table(
'business_category',
db.Column('business_id',
db.Integer,
db.ForeignKey('businesses.id'),
primary_key=True),
db.Column('category_id',
db.Integer,
db.ForeignKey('categories.id'),
primary_key=True))
class Business(db.Model):
""""""
__tablename__ = 'businesses'
id = db.Column(db.Integer, primary_key=True, index=True)
name = db.Column(db.String(100), nullable=False, unique=True)
description = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
location_id = db.Column(db.Integer, db.ForeignKey('locations.id'))
categories = db.relationship('Category',
secondary=business_category,
lazy='subquery',
backref=db.backref('businesses', lazy=True))
from api import db
malt_beer_table = db.Table(
'malt_beer', db.Column('beer_id', db.Integer, db.ForeignKey('beer.id')),
db.Column('malt_id', db.Integer, db.ForeignKey('malt.id')))
hops_beer_table = db.Table(
'hops_beer', db.Column('beer_id', db.Integer, db.ForeignKey('beer.id')),
db.Column('hops_id', db.Integer, db.ForeignKey('hops.id')))
mash_method_table = db.Table(
'mash_method',
db.Column('method_id', db.Integer, db.ForeignKey('method.id')),
db.Column('mash_id', db.Integer, db.ForeignKey('mash.id')))
class Mash(db.Model):
__tablename__ = 'mash'
id = db.Column(db.Integer, primary_key=True)
duration = db.Column(db.Integer)
value = db.Column(db.Integer)
unit = db.Column(db.String(20))
def __repr__(self):
return f'Mash {self.id=} {self.duration=} {self.value=} {self.unit=}'
class Fermentation(db.Model):
__tablename__ = 'fermentation'
from werkzeug.security import generate_password_hash, check_password_hash
import arrow
from api import db, select_table_name
from api.model import Level
session = os.environ.get('CURRENT_REGISTERED_COURSES_SESSION')
semester = os.environ.get('CURRENT_REGISTERED_COURSES_SEMESTER')
registered_courses_table_name = select_table_name(f'REGISTERED_COURSES_{semester}_{session}')
exam_table_name = select_table_name(f'STUDENTS_EXAM_{semester}_{session}')
student_lectures_table_name = select_table_name(f'STUDENT_LECTURES_{semester}_{session}')
lecturer_lectures_table_name = select_table_name(f'LECTURER_LECTURES_{semester}_{session}')
registered_courses = db.Table(registered_courses_table_name,
db.Column('student_id', db.Integer, db.ForeignKey('students.id'), primary_key=True),
db.Column('course_id', db.Integer, db.ForeignKey('courses.id'), primary_key=True))
exam_attendance = db.Table(exam_table_name,
db.Column('student_id', db.Integer, db.ForeignKey('students.id'), primary_key=True),
db.Column('course_id', db.Integer, db.ForeignKey('courses.id'), primary_key=True))
lecture_attendance = db.Table(student_lectures_table_name,
db.Column('student_id', db.Integer, db.ForeignKey('students.id'), primary_key=True),
db.Column('course_id', db.Integer, db.ForeignKey('courses.id'), primary_key=True),
db.Column('count', db.Integer, default=0))
class Student(db.Model):
__tablename__ = 'students'
from werkzeug.security import generate_password_hash, check_password_hash
import arrow
from api import db, select_table_name
from api.model import Level
session = os.environ.get('CURRENT_REGISTERED_COURSES_SESSION')
semester = os.environ.get('CURRENT_REGISTERED_COURSES_SEMESTER')
table_name = select_table_name(f'REGISTERED_COURSES_{semester}_{session}')
registered_courses = db.Table(
table_name,
db.Column('student_id',
db.Integer,
db.ForeignKey('students.id'),
primary_key=True),
db.Column('course_id',
db.Integer,
db.ForeignKey('courses.id'),
primary_key=True))
class Student(db.Model):
__tablename__ = 'students'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
firstname = db.Column(db.String(50))
lastname = db.Column(db.String(50))
othername = db.Column(db.String(50))
reg_no = db.Column(db.String(11), unique=True, index=True)
email = db.Column(db.String(128), index=True)
from api import db
import enum
coins_wallets_association = db.Table(
'coins_wallets',
db.Column('coin_id', db.Integer, db.ForeignKey('coin.coin_id')),
db.Column('wallet_id', db.Integer, db.ForeignKey('wallet.wallet_id')))
class CurrencyUnit(enum.Enum):
USD = 1
PEN = 2
EUR = 3
class Coin(db.Model):
coin_id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(150), nullable=False)
name = db.Column(db.String(50), unique=True, nullable=False)
price = db.Column(db.Float, nullable=False)
wallets = db.relationship('Wallet',
secondary=coins_wallets_association,
backref=db.backref('coins', lazy='dynamic'))
def to_dict(self, currency):
return {
"id": self.coin_id,
"description": self.description,
"name": self.name,
"price": self.__convert_coin(currency)
}
