class RoleDeprecated(BaseModel):
user_role_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), default='')
access = db.Column(db.Text)
def __repr__(self):
return '<RoleDeprecated {} ({})>'.format(self.title, self.user_role_id)
class State(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64), nullable=False)
abbreviation = db.Column(db.String(2), nullable=False)
def __repr__(self):
return '<State {} ({})>'.format(self.title, self.id)
class ScheduleWellTests(BaseModel):
id = db.Column(db.Integer, primary_key=True)
schedule_id = db.Column(db.Integer, db.ForeignKey('schedule.id'))
well_id = db.Column(db.Integer, db.ForeignKey('well.id'))
test_id = db.Column(db.Integer, db.ForeignKey('test.id'))
def __repr__(self):
return '<ScheduleWellTests {}>'.format(self.id)
class SubstanceGroup(BaseModel):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean, nullable=False, default=True, index=True)
hard_ref = db.Column(db.Integer, nullable=False, default=0)
title = db.Column(db.String(255), nullable=False, default='', index=True)
sort = db.Column(db.Integer, nullable=False, default=0)
def __repr__(self):
return '<SubstanceGroup {} ({})>'.format(self.title, self.id)
class TestMaterial(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), default='')
active = db.Column(db.Boolean, default=True)
sort = db.Column(db.Integer, default=0)
bottle = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<TestMaterial {} ({})>'.format(self.title, self.id)
class Criteria(BaseModel):
id = db.Column(db.Integer, primary_key=True)
state_id = db.Column(db.Integer, db.ForeignKey('state.id'))
active = db.Column(db.Boolean, default=True)
title = db.Column(db.String(10), nullable=False)
values = db.relationship('CriteriaValues',
backref=db.backref('criteria', cascade='all'))
def __repr__(self):
return '<Criteria {} ({})>'.format(self.title, self.id)
class CriteriaValues(BaseModel):
__tablename__ = "criteria_values"
id = db.Column(db.Integer, primary_key=True)
criteria_id = db.Column(db.Integer,
db.ForeignKey('criteria.id'),
nullable=False)
substance_id = db.Column(db.Integer,
db.ForeignKey('substance.id'),
nullable=False)
value = db.Column(db.Float(12), nullable=False)
class Client(BaseModel):
id = db.Column(db.Integer, primary_key=True)
company_id = db.Column(db.Integer, db.ForeignKey('company.id'))
name = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=db.func.now())
company = db.relationship('Company', backref=db.backref('clients', lazy='dynamic', cascade='all'))
@hybrid_property
def role_query(self):
if g.current_role == 'Admin':
return self.query
elif g.current_role == 'LabAdmin' or g.current_role == 'LabAssociate':
return self.query \
.join(self.company) \
.filter(Company.lab == g.current_lab)
elif g.current_role == 'CompanyAdmin' or g.current_role == 'CompanyAssociate':
return self.query \
.join(self.company) \
.join(Company.users) \
.filter(Company.lab == g.current_lab) \
.filter(User.id == current_user.id)
elif g.current_role == 'ClientManager':
return self.query \
.join(self.company) \
.join(self.users) \
.filter(Company.lab == g.current_lab) \
.filter(User.id == current_user.id)
elif g.current_role == 'Technician':
return self.query \
.join(self.company) \
.join(self.sites) \
.join(Site.users) \
.filter(Company.lab == g.current_lab) \
.filter(User.id == current_user.id)
return self.query.filter(False)
def json(self):
res = dict()
for field in self._fields():
res[field] = getattr(self, field)
res['user_ids'] = []
for user in self.users:
res['user_ids'].append(user.id)
return res
def __repr__(self):
return '<Client {} ({})>'.format(self.name, self.id)
class Role(BaseModel):
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 '<Role {} ({})>'.format(self.name, self.id)
@hybrid_property
def role_query(self):
if g.current_role == 'Admin':
return self.query
elif g.current_role == 'Anonymous':
return self.query.filter(False)
else:
return self.query.filter(self.id >= current_user.role.id)
class SiteMap(BaseModel):
id = db.Column(db.Integer, primary_key=True)
site_id = db.Column(db.Integer, db.ForeignKey('site.id'))
title = db.Column(db.String(255))
width = db.Column(db.Integer)
height = db.Column(db.Integer)
url = db.Column(db.String(255))
scale = db.Column(db.Float(12), default=1.0)
site = db.relationship('Site',
backref=db.backref('sitemaps',
lazy='dynamic',
cascade='all'))
def __repr__(self):
return '<SiteMap {} ({})>'.format(self.title, self.id)
def json(self):
res = dict()
for field in self._fields():
res[field] = getattr(self, field)
res['wells'] = []
for well in self.wells:
res['wells'].append(well.json())
return res
class Frequency(BaseModel):
id = db.Column(db.Integer, primary_key=True)
sort = db.Column(db.Integer)
title = db.Column(db.String(255))
timediff = db.Column(db.String(64))
peryear = db.Column(db.Integer)
unit = db.Column(db.String(64))
default = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<Frequency {} ({})>'.format(self.title, self.frequency_id)
class Sample(BaseModel):
id = db.Column(db.Integer, primary_key=True)
schedule_id = db.Column(db.Integer,
db.ForeignKey('schedule.id'),
unique=True,
default=None)
site_id = db.Column(db.Integer, db.ForeignKey('site.id'), default=0)
upload_id = db.Column(db.Integer, db.ForeignKey('upload.id'), default=None)
active = db.Column(db.Boolean, default=True)
date_collected = db.Column(db.Date)
date_extracted = db.Column(db.Date)
date_analyzed = db.Column(db.Date)
site = db.relationship('Site',
backref=db.backref('samples',
lazy='dynamic',
cascade='all'))
schedule = db.relationship('Schedule',
backref=db.backref('samples',
lazy='dynamic',
cascade='all'))
def __repr__(self):
return '<Sample {}>'.format(self.id)
def json(self):
res = dict()
for field in self._fields():
res[field] = getattr(self, field)
res['qty_values'] = self.values.count()
res['substance_ids'] = []
# Convert the dates to the format we want
if self.date_collected:
res['date_collected'] = self.date_collected.strftime("%Y-%m-%d")
if self.date_extracted:
res['date_extracted'] = self.date_extracted.strftime("%Y-%m-%d")
if self.date_analyzed:
res['date_analyzed'] = self.date_analyzed.strftime("%Y-%m-%d")
for value in self.values:
if value.substance.id not in res['substance_ids']:
res['substance_ids'].append(value.substance.id)
return res
class SiteMapWell(BaseModel):
id = db.Column(db.Integer, primary_key=True)
site_map_id = db.Column(db.Integer, db.ForeignKey('site_map.id'))
site_id = db.Column(db.Integer, db.ForeignKey('site.id'))
well_id = db.Column(db.Integer, db.ForeignKey('well.id'))
xpos = db.Column(db.Integer)
ypos = db.Column(db.Integer)
xpos_fields = db.Column(db.Integer)
ypos_fields = db.Column(db.Integer)
sitemap = db.relationship('SiteMap',
backref=db.backref('wells',
lazy='dynamic',
cascade='all'))
well = db.relationship('Well', lazy='joined')
def __repr__(self):
return '<SiteMapWell {} well:{} x:{} y:{}>'.format(
self.id, self.well.title, self.xpos, self.ypos)
class Lab(BaseModel):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean, default=True)
title = db.Column(db.String(255), default='')
address = db.Column(db.String(255), default='')
city = db.Column(db.String(128), default='')
state = db.Column(db.String(64), default='')
zip = db.Column(db.String(32), default='')
phone = db.Column(db.String(255), default='')
contact = db.Column(db.String(255), default='')
cell = db.Column(db.String(32))
fax = db.Column(db.String(32))
email = db.Column(db.String(255))
notes = db.Column(db.Text)
shipping_company = db.Column(db.String(255), default='')
shipping_account = db.Column(db.String(255), default='')
shipping_notes = db.Column(db.Text)
url = db.Column(db.Text, unique=True)
photo_url = db.Column(db.String(255))
def __repr__(self):
return '<Lab {} ({})>'.format(self.title, self.id)
@hybrid_property
def role_query(self):
if g.current_role == 'Admin':
return self.query
return self.query.filter_by(id=g.current_lab.id)
class Office(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
contact = db.Column(db.String(255), default=None)
address = db.Column(db.String(80))
city = db.Column(db.String(255))
state = db.Column(db.String(2))
zip = db.Column(db.String(32))
phone = db.Column(db.String(32), default=None)
cell = db.Column(db.String(32), default=None)
email = db.Column(db.String(255), default=None)
lat = db.Column(db.Float(10))
lng = db.Column(db.Float(10))
def __repr__(self):
return '<Office {} ({})>'.format(self.title, self.id)
class Sampler(BaseModel):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean, default=True)
title = db.Column(db.String(255))
address = db.Column(db.String(255))
city = db.Column(db.String(128))
state = db.Column(db.String(64))
zip = db.Column(db.String(32))
contact = db.Column(db.String(255), default='')
phone = db.Column(db.String(32))
cell = db.Column(db.String(32))
fax = db.Column(db.String(32))
email = db.Column(db.String(255))
notes = db.Column(db.Text)
def __repr__(self):
return '<Sampler {} ({})>'.format(self.title, self.id)
class Company(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), default='')
active = db.Column(db.Boolean, default=True)
address = db.Column(db.String(255))
city = db.Column(db.String(128))
state = db.Column(db.String(64))
zip = db.Column(db.String(32))
contact = db.Column(db.String(255), default='')
phone = db.Column(db.String(32))
cell = db.Column(db.String(32))
fax = db.Column(db.String(32))
email = db.Column(db.String(255))
notes = db.Column(db.Text)
lab_id = db.Column(db.Integer, db.ForeignKey('lab.id'))
lab = db.relationship('Lab', backref=db.backref('companies', lazy='dynamic', cascade='all'))
sites = db.relationship('Site', lazy='dynamic', backref='companies', cascade='all')
def __repr__(self):
return '<Company {} ({})>'.format(self.title, self.id)
@hybrid_property
def role_query(self):
if g.current_role == 'Admin':
return self.query.filter_by(lab_id=g.current_lab.id)
elif g.current_role == 'LabAdmin' or g.current_role == 'LabAssociate':
return self.query.filter_by(lab_id=g.current_lab.id)
elif g.current_role == 'CompanyAdmin' or g.current_role == 'CompanyAssociate':
return current_user.companies.filter_by(lab_id=g.current_lab.id)
elif g.current_role == 'ClientManager' or g.current_role == 'Technician':
return current_user.companies
return self.query.filter_by(lab_id=g.current_lab.id)
def json(self):
res = dict()
for field in self._fields():
res[field] = getattr(self, field)
res['user_ids'] = []
for user in self.users:
res['user_ids'].append(user.id)
# Set is_deletable to True if the company has no active users
res['is_deletable'] = not bool(self.users.filter_by(active=True).count())
return res
class Schedule(BaseModel):
id = db.Column(db.Integer, primary_key=True)
active = db.Column(db.Boolean, default=True)
finished = db.Column(db.Boolean, default=False)
site_id = db.Column(db.Integer, db.ForeignKey('site.id'), default=0)
date = db.Column(db.DateTime)
timeofday = db.Column(db.String(255))
starttime = db.Column(db.String(16))
endtime = db.Column(db.String(16))
typeofactivity = db.Column(db.String(255))
release_number = db.Column(db.String(255))
frequency_association = db.Column(db.String(255))
test_ids = db.Column(JSON)
tests = db.relationship('Test', secondary=schedule_tests,
backref=db.backref('schedules', lazy='dynamic', cascade='all'))
site = db.relationship('Site', backref=db.backref('schedules', lazy='dynamic', cascade='all'))
schedule_well_tests = db.relationship('ScheduleWellTests', lazy='dynamic', cascade='all')
gauged_wells = db.relationship('Well', secondary=gauged_wells, lazy='dynamic', cascade='all')
skipped_wells = db.relationship('Well', secondary=skipped_wells, lazy='dynamic', cascade='all')
def __repr__(self):
return '<Schedule {}>'.format(self.id)
@hybrid_property
def role_query(self):
return self.query
def json(self):
res = dict()
for field in self._fields():
res[field] = getattr(self, field)
res['test_ids'] = []
for test in self.tests:
res['test_ids'].append(test.id)
res['gauged_well_ids'] = []
for gauged_well in self.gauged_wells:
res['gauged_well_ids'].append(gauged_well.id)
res['skipped_well_ids'] = []
for skipped_well in self.skipped_wells:
res['skipped_well_ids'].append(skipped_well.id)
return res
class UserDeprecated(BaseModel):
user_id = db.Column(db.Integer, primary_key=True)
user_role_id = db.Column(db.Integer, db.ForeignKey('role_deprecated.user_role_id'), default=0)
username = db.Column(db.String(128), unique=True)
email = db.Column(db.String(128), default='')
require_password_change = db.Column(db.Boolean, default=True)
suspended = db.Column(db.Boolean, default=False)
login_timestamp = db.Column(db.Integer, default=0)
failed_login_timestamp = db.Column(db.Integer, default=0)
login_failures = db.Column(db.Integer, default=0)
hash_timestamp = db.Column(db.Integer, default=0)
access = db.Column(db.Text)
info = db.Column(db.Text)
name = db.Column(db.String(255), default=None)
company = db.Column(db.String(255), default=None)
address = db.Column(db.String(255), default=None)
phone = db.Column(db.String(255), default=None)
fax = db.Column(db.String(255), default=None)
created = db.Column(db.DateTime, default=db.func.now())
id = db.Column(db.Integer)
def __repr__(self):
return '<UserDeprecated {} ({})>'.format(self.username, self.user_id)
criteria_id = db.Column(db.Integer,
db.ForeignKey('criteria.id'),
nullable=False)
substance_id = db.Column(db.Integer,
db.ForeignKey('substance.id'),
nullable=False)
value = db.Column(db.Float(12), nullable=False)
class State(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(64), nullable=False)
abbreviation = db.Column(db.String(2), nullable=False)
def __repr__(self):
return '<State {} ({})>'.format(self.title, self.id)
substance_state_names = db.Table(
'substance_state_names',
db.Column('substance_id',
db.Integer,
db.ForeignKey('substance.id'),
nullable=False),
db.Column('state_id',
db.Integer,
db.ForeignKey('state.id'),
nullable=False),
db.Column('title', db.String(255), nullable=False),
)
import datetime
from flask import g
from flask_login import current_user, UserMixin
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.dialects.postgresql import JSON
from sampleserve.core import db, BaseModel
from sampleserve.helpers import firstname
users_companies = db.Table(
'users_companies',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('company_id', db.Integer, db.ForeignKey('company.id')),
)
users_clients = db.Table(
'users_clients',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('client_id', db.Integer, db.ForeignKey('client.id')),
)
users_sites = db.Table(
'users_sites',
db.Column('user_id', db.Integer, db.ForeignKey('user.id')),
db.Column('site_id', db.Integer, db.ForeignKey('site.id')),
)
class User(UserMixin, BaseModel):
preservative = db.Column(db.String(255))
filter = db.Column(db.String(255))
field = db.Column(db.Boolean, default=False)
substance_ids = db.Column(db.Text)
test_material_ids = db.Column(db.Text)
test_material_qty = db.Column(db.Text)
def __repr__(self):
return '<Test {} ({})>'.format(self.title, self.id)
class TestMaterial(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255), default='')
active = db.Column(db.Boolean, default=True)
sort = db.Column(db.Integer, default=0)
bottle = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<TestMaterial {} ({})>'.format(self.title, self.id)
tests_substances = db.Table(
'tests_substances',
db.Column('test_id', db.Integer, db.ForeignKey('test.id'), default=0),
db.Column('substance_id',
db.Integer,
db.ForeignKey('substance.id'),
default=0),
)
class Upload(BaseModel):
id = db.Column(db.Integer, primary_key=True)
company_id = db.Column(db.Integer, db.ForeignKey('company.id'))
lab_id = db.Column(db.Integer, db.ForeignKey('lab.id'))
site_id = db.Column(db.Integer, db.ForeignKey('site.id'))
created_at = db.Column(db.DateTime, default=db.func.now())
upload_type = db.Column(db.String(255))
sample_date = db.Column(db.DateTime)
filename = db.Column(db.String(255))
url = db.Column(db.String(255))
sent = db.Column(db.Boolean, default=False)
lab_upload = db.Column(db.Boolean, default=False) # True if the lab uploaded this file rather than user
lab = db.relationship('Lab', backref=db.backref('uploads', lazy='dynamic', cascade='all'))
company = db.relationship('Company', backref=db.backref('uploads', lazy='dynamic', cascade='all'))
@hybrid_property
def role_query(self):
if g.current_role == 'Admin':
return self.query
elif g.current_role == 'LabAdmin' or g.current_role == 'LabAssociate':
return self.query \
.join(self.company) \
.filter(Company.lab == g.current_lab) \
.order_by(Upload.created_at.desc())
elif g.current_role == 'CompanyAdmin' or g.current_role == 'CompanyAssociate':
return self.query \
.join(self.company) \
.join(Company.users) \
.filter(Company.lab == g.current_lab) \
.filter(User.id == current_user.id) \
.order_by(Upload.created_at.desc())
elif g.current_role == 'ClientManager':
return self.query \
.join(self.company) \
.join(self.users) \
.filter(Company.lab == g.current_lab) \
.filter(User.id == current_user.id) \
.order_by(Upload.created_at.desc())
elif g.current_role == 'Technician':
return self.query \
.join(self.company) \
.join(self.sites) \
.join(Site.users) \
.filter(Company.lab == g.current_lab) \
.filter(User.id == current_user.id) \
.order_by(Upload.created_at.desc())
def __repr__(self):
return '<Upload {} ({})>'.format(self.filename, self.id)
def json(self):
res = dict()
for field in self._fields():
res[field] = getattr(self, field)
res['created_at'] = self.created_at.isoformat() + 'Z'
return res
class WellImage(BaseModel):
id = db.Column(db.Integer, primary_key=True)
well_id = db.Column(db.Integer, db.ForeignKey('well.id'))
sort = db.Column(db.Integer)
last_modified = db.Column(db.Integer)
height_md = db.Column(db.Integer)
width_md = db.Column(db.Integer)
width_sm = db.Column(db.Integer)
height_sm = db.Column(db.Integer)
url_md = db.Column(db.String(255))
url_lg = db.Column(db.String(255))
filestack_handle = db.Column(db.String(255))
well = db.relationship('Well',
backref=db.backref('well_image',
lazy='dynamic',
cascade='all'))
def __repr__(self):
return '<WellImage {}>'.format(self.id)
class Test(BaseModel):
id = db.Column(db.Integer, primary_key=True)
state_id = db.Column(db.Integer, db.ForeignKey('state.id'))
active = db.Column(db.Boolean, default=True)
sort = db.Column(db.Integer, default=0)
title = db.Column(db.String(255), default='')
abbrev = db.Column(db.String(128))
preservative = db.Column(db.String(255))
filter = db.Column(db.String(255))
field = db.Column(db.Boolean, default=False)
substance_ids = db.Column(db.Text)
test_material_ids = db.Column(db.Text)
test_material_qty = db.Column(db.Text)
def __repr__(self):
return '<Test {} ({})>'.format(self.title, self.id)
class Frequency(BaseModel):
id = db.Column(db.Integer, primary_key=True)
sort = db.Column(db.Integer)
title = db.Column(db.String(255))
timediff = db.Column(db.String(64))
peryear = db.Column(db.Integer)
unit = db.Column(db.String(64))
default = db.Column(db.Boolean, default=False)
def __repr__(self):
return '<Frequency {} ({})>'.format(self.title, self.frequency_id)
well_date = db.Table(
'well_date',
db.Column('well_id', db.Integer, db.ForeignKey('well.id'), default=0),
db.Column('active', db.Boolean, default=True),
db.Column('position', db.Integer),
db.Column('gaugeonly', db.Boolean, default=False),
db.Column('test_ids', db.String(255)),
)
well_date_set = db.Table(
'well_date_set',
db.Column('site_id', db.Integer, db.ForeignKey('site.id')),
db.Column('position', db.Integer),
db.Column('date', db.Date),
db.Column('schedule_id', db.Integer, default=None),
)
well_options = db.Table(
class User(UserMixin, BaseModel):
id = db.Column(db.Integer, primary_key=True)
role_id = db.Column(db.Integer, db.ForeignKey('role.id'))
lab_id = db.Column(db.Integer, db.ForeignKey('lab.id'))
invitee_id = db.Column(db.Integer, db.ForeignKey('user.id'))
created_at = db.Column(db.DateTime, default=db.func.now())
name = db.Column(db.String(255))
email = db.Column(db.String(255))
photo_url = db.Column(db.String(255))
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=False)
pending = db.Column(db.Boolean(), default=True)
phone = db.Column(db.String(15))
invite_code = db.Column(db.String(255))
reset_code = db.Column(db.String(255))
role = db.relationship('Role', backref=db.backref('users', lazy='dynamic'))
lab = db.relationship('Lab', backref=db.backref('users', lazy='dynamic'))
invitee = db.relationship('User', uselist=False, remote_side=[id], backref=db.backref('invites', uselist=False))
companies = db.relationship('Company', secondary=users_companies, lazy='dynamic', backref=db.backref('users', lazy='dynamic', cascade='all'))
clients = db.relationship('Client', secondary=users_clients, lazy='dynamic', backref=db.backref('users', lazy='dynamic', cascade='all'))
sites = db.relationship('Site', secondary=users_sites, lazy='dynamic', backref=db.backref('users', lazy='dynamic', cascade='all'))
def __repr__(self):
return '<User {} ({})>'.format(self.email, self.id)
@property
def public_fields(self):
return ['id', 'email', 'name', 'photo_url', 'phone', 'active', 'role_id', 'lab_id', 'company_ids', 'client_ids', 'site_ids']
@property
def is_active(self):
return self.active
@property
def company_ids(self):
return [company.id for company in self.companies.all()]
@property
def client_ids(self):
return [client.id for client in self.clients.all()]
@property
def site_ids(self):
return [site.id for site in self.sites.all()]
def json(self):
res = dict()
for field in self._fields():
res[field] = getattr(self, field)
res['company_ids'] = self.company_ids
res['client_ids'] = self.client_ids
res['site_ids'] = self.client_ids
# Set first name
res['firstname'] = firstname(self.name)
return res
@hybrid_property
def role_query(self):
if g.current_role == 'Admin':
return self.query
elif g.current_role == 'Anonymous':
return self.query.filter_by(lab=g.current_lab, pending=True)
return self.query.filter_by(lab=g.current_lab)
class Transaction(BaseModel):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
lab_id = db.Column(db.Integer, db.ForeignKey('lab.id'))
site_id = db.Column('site_id', db.Integer, db.ForeignKey('site.id'))
company_id = db.Column('company_id', db.Integer, db.ForeignKey('company.id'))
created_at = db.Column(db.DateTime, default=db.func.now())
total_amount = db.Column(db.Float(12))
lab_earnings_amount = db.Column(db.Float(12))
samples = db.Column(JSON)
stripe_transaction_id = db.Column(db.String(255))
stripe_card_id = db.Column(db.String(255))
cc_last4 = db.Column(db.Integer)
user = db.relationship('User', backref=db.backref('transactions', lazy='dynamic'))
def __repr__(self):
return '<Transaction {} ({})>'.format(self.total_amount, self.id)
class Well(BaseModel):
id = db.Column(db.Integer, primary_key=True)
site_id = db.Column(db.Integer, db.ForeignKey('site.id'))
frequency_id = db.Column(db.Integer)
active = db.Column(db.Boolean, default=True)
title = db.Column(db.String(255), default='', index=True)
top_of_casing = db.Column(db.Float(10), default=0.0)
xpos = db.Column(db.Integer, default=0)
ypos = db.Column(db.Integer, default=0)
xpos_fields = db.Column(db.Integer, default=0)
ypos_fields = db.Column(db.Integer, default=0)
sort = db.Column(db.Integer, default=0)
sampletechnique = db.Column(db.String(255), default='')
material = db.Column(db.String(255))
diameter = db.Column(db.Float(9))
screenlength = db.Column(db.Float(9))
est_depth_to_water = db.Column(db.Float(10))
depth_to_bottom = db.Column(db.Float(9))
purge_water_disposal = db.Column(db.String(255))
latitude = db.Column(db.Float(9))
longitude = db.Column(db.Float(9))
notes = db.Column(db.Text)
def __repr__(self):
return '<Well {} ({})>'.format(self.title, self.id)
class Substance(BaseModel):
id = db.Column(db.Integer, primary_key=True)
substance_group_id = db.Column(db.Integer,
db.ForeignKey('substance_group.id'),
nullable=False,
default=0)
active = db.Column(db.Boolean, default=False, index=True)
hard_ref = db.Column(db.Integer, default=0)
title = db.Column(db.String(255), index=True)
abbreviation = db.Column(db.String(255))
cas = db.Column(db.String(255))
cas_sanitized = db.Column(db.String(255), index=True)
sort = db.Column(db.Integer, default=0)
unit = db.Column(db.String(16))
precision = db.Column(db.Integer, default=2)
criteria = db.Column(db.Float(12), default=0.0)
field_data = db.Column(db.Boolean, default=False)
@validates('cas')
def update_slug(self, key, cas):
if cas and len(cas):
self.cas_sanitized = cas.replace('-', '').replace(' ', '').upper()
return cas
def __repr__(self):
return '<Substance {} ({})>'.format(self.title, self.id)
