OrganisationDTO,
NewOrganisationDTO,
OrganisationManagerDTO,
)
from backend.models.postgis.user import User
from backend.models.postgis.campaign import Campaign, campaign_organisations
from backend.models.postgis.utils import NotFound
from backend.models.postgis.statuses import OrganisationType
# Secondary table defining many-to-many relationship between organisations and managers
organisation_managers = db.Table(
"organisation_managers",
db.metadata,
db.Column(
"organisation_id", db.Integer, db.ForeignKey("organisations.id"), nullable=False
),
db.Column("user_id", db.BigInteger, db.ForeignKey("users.id"), nullable=False),
db.UniqueConstraint("organisation_id", "user_id", name="organisation_user_key"),
)
class InvalidRoleException(Exception):
pass
class Organisation(db.Model):
""" Describes an Organisation """
__tablename__ = "organisations"
from backend import db
from backend.models.dtos.interests_dto import InterestDTO, InterestsListDTO
from backend.models.postgis.utils import NotFound
# Secondary table defining many-to-many join for interests of a user.
user_interests = db.Table(
"user_interests",
db.metadata,
db.Column("interest_id", db.Integer, db.ForeignKey("interests.id")),
db.Column("user_id", db.BigInteger, db.ForeignKey("users.id")),
)
# Secondary table defining many-to-many join for interests of a project.
project_interests = db.Table(
"project_interests",
db.metadata,
db.Column("interest_id", db.Integer, db.ForeignKey("interests.id")),
db.Column("project_id", db.BigInteger, db.ForeignKey("projects.id")),
)
class Interest(db.Model):
""" Describes an interest for projects and users"""
__tablename__ = "interests"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, unique=True)
@staticmethod
def get_by_id(interest_id: int):
from backend import db
list_memberships = db.Table(
'list_memberships',
db.Column('list_id', db.Integer, db.ForeignKey('list.id'), nullable=False),
db.Column('member_id',
db.Integer,
db.ForeignKey('member.id'),
nullable=False))
class Member(db.Model):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
institution = db.Column(db.String(120), nullable=False)
is_executive_assistant = db.Column(db.Boolean)
is_archived = db.Column(db.Boolean)
executive_assistant_id = db.Column(db.Integer, db.ForeignKey('member.id'))
executive_assistant = db.relationship('Member',
backref='member_executive_assistant',
uselist=False,
remote_side=[id],
lazy=True)
emails = db.relationship('Email', backref='member', lazy=True)
phone_numbers = db.relationship('PhoneNumber', backref='member', lazy=True)
lists = db.relationship('List',
secondary=list_memberships,
backref=db.backref('members', lazy=True),
lazy=True)
cure_center_profile = db.relationship('CureCenterProfile',
from backend import db
from backend.helpers.serialization import to_json_trainer
from backend import bcrypt
user_conversation_association = db.Table(
'user_association_conversation',
db.Column('user_id', db.Integer,
db.ForeignKey('conversation.conversation_id')),
db.Column('conversation_id', db.Integer, db.ForeignKey('user.user_id')))
class User(db.Model):
user_id = db.Column(db.Integer, primary_key=True)
user_uuid = db.Column(db.String(120), unique=True, nullable=False)
email = db.Column(db.String(40), unique=True, nullable=False)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
biography = db.Column(db.Text)
password = db.Column(db.Binary(60), nullable=False)
rating = db.Column(db.Integer, default=0)
conversations = db.relationship("Conversation",
secondary=user_conversation_association,
backref=db.backref('users',
lazy='dynamic'))
def save_to_db(self):
db.session.add(self)
db.session.commit()
@classmethod
def return_all(self):
from backend import db
authors = db.Table(
"authors",
db.Column("book_id",
db.Integer,
db.ForeignKey("book.id"),
primary_key=True),
db.Column("author_id",
db.String,
db.ForeignKey("author.name"),
primary_key=True),
)
class Author(db.Model):
name = db.Column(db.String, primary_key=True)
def __repr__(self):
return f"<Author(name='{self.name}')>"
import geojson
import json
from backend import db
from geoalchemy2 import Geometry
from backend.models.postgis.utils import InvalidGeoJson, ST_SetSRID, ST_GeomFromGeoJSON
# Priority areas aren't shared, however, this arch was taken from TM2 to ease data migration
project_priority_areas = db.Table(
"project_priority_areas",
db.metadata,
db.Column("project_id", db.Integer, db.ForeignKey("projects.id")),
db.Column("priority_area_id", db.Integer,
db.ForeignKey("priority_areas.id")),
)
class PriorityArea(db.Model):
""" Describes an individual priority area """
__tablename__ = "priority_areas"
id = db.Column(db.Integer, primary_key=True)
geometry = db.Column(Geometry("POLYGON", srid=4326))
@classmethod
def from_dict(cls, area_poly: dict):
""" Create a new Priority Area from dictionary """
pa_geojson = geojson.loads(json.dumps(area_poly))
if type(pa_geojson) is not geojson.Polygon:
raise InvalidGeoJson("Priority Areas must be supplied as Polygons")
from backend import db
from backend.models.dtos.campaign_dto import CampaignDTO, CampaignListDTO
campaign_projects = db.Table(
"campaign_projects",
db.metadata,
db.Column("campaign_id", db.Integer, db.ForeignKey("campaigns.id")),
db.Column("project_id", db.Integer, db.ForeignKey("projects.id")),
)
campaign_organisations = db.Table(
"campaign_organisations",
db.metadata,
db.Column("campaign_id", db.Integer, db.ForeignKey("campaigns.id")),
db.Column("organisation_id", db.Integer,
db.ForeignKey("organisations.id")),
db.UniqueConstraint("campaign_id",
"organisation_id",
name="campaign_organisation_key"),
)
class Campaign(db.Model):
""" Describes an Campaign"""
__tablename__ = "campaigns"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
logo = db.Column(db.String)
url = db.Column(db.String)
from werkzeug.security import generate_password_hash, check_password_hash
from backend import db
annotation_table = db.Table(
"annotation",
db.metadata,
db.Column("id", db.Integer(), primary_key=True),
db.Column(
"segmentation_id",
db.Integer(),
db.ForeignKey("segmentation.id"),
nullable=False,
),
db.Column(
"label_value_id", db.Integer(), db.ForeignKey("label_value.id"), nullable=False
),
db.Column("created_at", db.DateTime(), nullable=False, default=db.func.now()),
db.Column(
"last_modified",
db.DateTime(),
nullable=False,
default=db.func.now(),
onupdate=db.func.utc_timestamp(),
),
)
user_project_table = db.Table(
"user_project",
db.metadata,
db.Column("id", db.Integer(), primary_key=True),
from backend.models.dtos.licenses_dto import LicenseDTO, LicenseListDTO
from backend import db
# Secondary table defining the many-to-many join
user_licenses_table = db.Table(
"user_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=user_licenses_table) # Many to Many relationship
@staticmethod
def get_by_id(license_id: int):
""" Get license by id """
return License.query.get(license_id)
from backend import db
genres = db.Table(
"genres",
db.Column("book_id",
db.Integer,
db.ForeignKey("book.id"),
primary_key=True),
db.Column("genre_id",
db.String,
db.ForeignKey("genre.name"),
primary_key=True),
)
class Genre(db.Model):
name = db.Column(db.String, primary_key=True)
def __repr__(self):
return f"<Genre(name='{self.name}')>"
from flask.ext.security import RoleMixin, UserMixin
from backend import db
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))
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
from sqlalchemy import Column, ForeignKey, Integer, UniqueConstraint
from backend import db
recipients = db.Table(
"UserMessages",
Column("m_id", Integer, ForeignKey("Messages.id")),
Column("r_id", Integer, ForeignKey("Users.id"), index=True),
UniqueConstraint("m_id", "r_id", name="uc_mr_ids"),
)
from backend import db
followers = db.Table(
"followers",
db.Column("reader_id", db.Integer, db.ForeignKey("reader.id"), primary_key=True),
db.Column("follower_id", db.Integer, db.ForeignKey("reader.id"), primary_key=True),
)
in d.items()
if k not in exclude and not isinstance(v, list)
}
class DictBase:
def to_dict(self):
return dictonify(self.__dict__)
def __init__(self, **kwargs):
for k, v in kwargs.items():
self.__dict__[k] = v
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 __init__(self, name):
self.name = name
def __str__(self):
return self.name
from backend import db, app
cart = db.Table(
'cart', db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('product_id', db.Integer, db.ForeignKey('product.id')))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(60), nullable=False)
cart_items = db.relationship('Product',
secondary=cart,
lazy='subquery',
backref=db.backref('in_cart_of', lazy=True))
uploaded_products = db.relationship('Product',
backref='uploaded_by',
lazy=True)
def __repr__(self):
return f"User('{self.username}', '{self.email}')"
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
image_file = db.Column(db.Text, nullable=False)
name = db.Column(db.String(20), nullable=False)
company = db.Column(db.String(20), nullable=False)
price = db.Column(db.String(20), nullable=False)
description = db.Column(db.Text, nullable=False)
from backend import db
from sqlalchemy import inspect
import datetime
now = datetime.datetime.now()
pattern_activity = db.Table(
'pattern_activity',
db.Column('pattern_id',
db.Integer,
db.ForeignKey('pattern.id'),
primary_key=True),
db.Column('activity_id',
db.Integer,
db.ForeignKey('activity.id'),
primary_key=True))
location_period = db.Table(
'location_period',
db.Column('location_id',
db.Integer,
db.ForeignKey('location.id'),
primary_key=True),
db.Column('period_id',
db.Integer,
db.ForeignKey('period.id'),
primary_key=True))
class Pattern(db.Model):
id = db.Column(db.Integer, primary_key=True)
'phone': self.phone,
'performers': list(map(lambda x: x.to_obj(), self.performers)),
'services': list(map(lambda x: x.to_obj(), self.services))
}
@staticmethod
def get(user_id):
return db.session.query(Business).filter(Business.user_id == user_id).first()
performer_service = db.Table('performer_service',
db.Column('performer_id', db.Integer, db.ForeignKey(
'performer.id',
onupdate="CASCADE",
ondelete="CASCADE"
), primary_key=True),
db.Column('service_id', db.Integer, db.ForeignKey(
'service.id',
onupdate="CASCADE",
ondelete="CASCADE"
), primary_key=True)
)
class Performer(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
services = db.relationship('Service', secondary=performer_service,
back_populates='performers', lazy='dynamic')
phone = db.Column(db.String(80), nullable=True)
photo_id = db.Column(UUIDType(binary=False), db.ForeignKey(
'image.id',
from backend.models.postgis.campaign import Campaign, campaign_projects
from backend.models.postgis.utils import (
ST_SetSRID,
ST_GeomFromGeoJSON,
timestamp,
ST_Centroid,
NotFound,
)
from backend.services.grid.grid_service import GridService
from backend.models.postgis.interests import Interest, project_interests
# Secondary table defining many-to-many join for projects that were favorited by users.
project_favorites = db.Table(
"project_favorites",
db.metadata,
db.Column("project_id", db.Integer, db.ForeignKey("projects.id")),
db.Column("user_id", db.BigInteger, db.ForeignKey("users.id")),
)
# 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")),
)
class ProjectTeams(db.Model):
__tablename__ = "project_teams"
team_id = db.Column(db.Integer,
from backend.helpers.serialization import to_json_trainer
from backend.models.conversation import Conversation
from backend import bcrypt
from backend import db
trainer_certification_association = db.Table(
'association_certification',
db.Column('trainer_id', db.Integer,
db.ForeignKey('certification.certification_id')),
db.Column('certification_id', db.Integer,
db.ForeignKey('trainer.trainer_id')))
trainer_conversation_association = db.Table(
'trainer_association_conversation',
db.Column('trainer_id', db.Integer,
db.ForeignKey('conversation.conversation_id')),
db.Column('conversation_id', db.Integer,
db.ForeignKey('trainer.trainer_id')))
class Trainer(db.Model):
trainer_id = db.Column(db.Integer, primary_key=True)
trainer_uuid = db.Column(db.String(120), unique=True, nullable=False)
email = db.Column(db.String(40), unique=True, nullable=False)
first_name = db.Column(db.String(30), nullable=False)
last_name = db.Column(db.String(30), nullable=False)
biography = db.Column(db.Text)
password = db.Column(db.Binary(60), nullable=False)
rating = db.Column(db.Integer, default=0)
certifications = db.relationship(
