class SubCategory(db.Model):
__tablename__ = 'subcategory'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40))
is_budget = db.Column(db.Boolean, default=False)
posting_date = db.Column(db.DateTime)
close_date = db.Column(db.DateTime)
budget_amount = db.Column(db.Numeric(16, 2))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
transactions = db.relationship('Transactions',
backref='subcategory',
lazy='dynamic')
userbudget = db.relationship('UserBudget',
backref='subcategory',
lazy='dynamic')
def __repr__(self):
return "<SubCategory(id='%r', name='%r', is_budget='%r', budget_amount='%r', posting_date='%r', close_date='%r')>" % (
self.id, self.name, self.is_budget, self.budget_amount,
self.posting_date, self.close_date)
class UserBudget(db.Model):
__tablename__ = 'userbudget'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40))
is_budget = db.Column(db.Boolean, default=False)
posting_date = db.Column(db.DateTime)
close_date = db.Column(db.DateTime)
budget_amount = db.Column(db.Numeric(16, 2))
created_date = db.Column(db.DateTime)
is_bucket = db.Column(db.Boolean, default=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
subcategory_id = db.Column(db.Integer, db.ForeignKey('subcategory.id'))
usersubcategory_id = db.Column(db.Integer,
db.ForeignKey('usersubcategory.id'))
buckets = db.relationship('Buckets', backref='userbudget', lazy='dynamic')
def __repr__(self):
return "<UserSubCategory(id='%r', name='%r', is_budget='%r', budget_amount='%r', user_id='%r', posting_date='%r', close_date='%r', created_date='%r', category_id='%r', subcategory_id='%r', usersubcategory_id='%r')>" % \
(self.id, self.name, self.is_budget, self.budget_amount, self.user_id, self.posting_date, self.close_date, self.created_date, self.category_id, self.subcategory_id, self.usersubcategory_id)
class Balance(db.Model):
id = db.Column(db.Integer, primary_key=True)
user = db.Column(db.String(128))
amount = db.Column(db.Numeric())
lastUpdated = db.Column(db.DateTime())
def __init__(self, user):
self.user = user
self.amount = 0
self.lastUpdated = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d %H:%M:%S')
def deposit(self, fund):
self.amount += fund
def withdraw(self, fund):
if self.amount >= fund:
self.amount -= fund
return True
else:
return False
class Product:
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
price = db.Column(db.Numeric(5, 2), nullable=True)
buy_code = db.Column(db.String(50))
image_filename = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
def serialize(self):
return {
'id':
str(self.id),
'price':
str(self.price),
'buy_code':
str(self.buy_code),
'image_filename':
self.image_filename,
'created_at':
get_local_time(self.created_at).strftime('%Y-%m-%d')
if self.created_at else None,
}
class Ticket(db.Model):
__tablename__ = "tickets"
id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
event_id = db.Column(UUID(as_uuid=True), db.ForeignKey('events.id'))
old_id = db.Column(db.Integer)
order_id = db.Column(UUID(as_uuid=True), db.ForeignKey('orders.id'))
old_order_id = db.Column(db.Integer)
ticket_type = db.Column(db.String, db.ForeignKey('ticket_types._type'))
eventdate_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('event_dates.id'))
name = db.Column(db.String)
price = db.Column(db.Numeric(precision=2))
last_updated = db.Column(db.DateTime, default=datetime.datetime.utcnow)
created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)
status = db.Column(db.String,
db.ForeignKey('ticket_statuses.status'),
default=TICKET_STATUS_UNUSED)
ticket_number = db.Column(db.Integer)
event = db.relationship("Event",
backref=db.backref("tickets", uselist=False))
class Product(db.Model):
__tablename__ = "products"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False)
type = db.Column(db.String(100), nullable=False)
mrp = db.Column(db.Numeric(6, 2), nullable=False)
description = db.Column(db.String(200), nullable=False)
dateadded = db.Column(db.String(30), nullable=False)
dateupdated = db.Column(db.String(30), nullable=False)
stock = db.relationship("Inventory", backref="product", lazy=True)
language = db.Column(db.String(100), nullable=True, default="English")
file_url = db.Column(db.String(255), nullable=True)
version = db.Column(db.String(30), nullable=True)
vendor = db.Column(db.Integer, db.ForeignKey("vendors.id"), nullable=True)
master_vendor = db.relationship("Vendor", foreign_keys=vendor)
threshold = db.Column(db.Integer, default=50, nullable=True)
def __repr__(self):
return '<name {}>'.format(self.name)
class Inventory(PaginatedAPIMixin, db.Model):
__tablename__='inventory'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30), nullable=False)
description = db.Column(db.String(100))
supplier = db.Column(db.String(30))
model_no = db.Column(db.String(30))
serial_no = db.Column(db.String(30))
price = db.Column(db.Numeric(10,2))
notes = db.Column(db.String(500))
update_by = db.Column(db.String(30), nullable=False)
update_date = db.Column(
db.DateTime, default=datetime.utcnow, nullable=False)
create_date = db.Column(
db.DateTime, default=datetime.utcnow, nullable=False)
def to_dict(self):
data = {
'id': self.id,
'name': self.name,
'description': self.description,
'supplier': self.supplier,
'model_no': self.model_no,
'serial_no': self.serial_no,
'price': str(self.price),
'notes': self.notes
}
return data
def from_dict(self, data, update_by='sys user'):
for key in data:
if data[key]:
if hasattr(self, key):
setattr(self, key, data[key])
self.update_by = update_by
self.update_date = datetime.utcnow()
def __repr__(self):
return '<Inventory {}>'.format(self.name)
class Purchase(db.Model):
__tablename__= 'purchases'
@staticmethod
def reverse_date(date):
return '-'.join(date.split('-')[::-1])
id = db.Column(db.Integer, primary_key=True)
since = db.Column(db.Date)
value = db.Column(db.Numeric(20,2)) # e.g. 12.12
commissioning = db.Column(db.String(256)) # path to commissioning document on disk
supplier_id = db.Column(db.Integer, db.ForeignKey('suppliers.id', ondelete='CASCADE'))
invoice_id = db.Column(db.Integer, db.ForeignKey('invoices.id', ondelete='CASCADE'))
device_id = db.Column(db.Integer, db.ForeignKey('devices.id', ondelete='CASCADE'))
assets = db.relationship('Asset', cascade='all, delete', backref='purchase', lazy='dynamic')
nbr_assets = column_property(func.nbr_assets(id))
asset_value = column_property(func.asset_value(id))
def __repr__(self):
return f'{self.invoice.number}/{self.device.brand}/{self.device.type}'
def log(self):
return f'<Purchase: {self.id}, {self.value}, {self.device.brand}, {self.device.type}'
def ret_dict(self):
return {'id':self.id, 'value':str(float(self.value)).replace('.', ','),
'commissioning':self.commissioning, 'device':self.device.ret_dict(), 'invoice': self.invoice.ret_dict(),
'asset_value': str(float(self.asset_value if self.asset_value else 0)).replace('.', ','),
'nbr_assets': self.nbr_assets if self.nbr_assets else 0}
@staticmethod
def invoice_init():
purchase = Purchase.query.first()
if not purchase.invoice_id:
invoice = Invoice.query.filter(Invoice.number == 'ONBEKEND').first()
purchases = Purchase.query.all()
for purchase in purchases:
purchase.invoice = invoice
db.session.commit()
class AllPosts(db.Model):
__tablename__ = 'AllPosts'
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Numeric(30, 0), index=True, unique=True)
timestamp = db.Column(db.DateTime, index=True)
media_type = db.Column(db.String(20))
category = db.Column(db.String(20))
permalink = db.Column(db.String(100))
count_comments = db.Column(db.Integer)
count_like = db.Column(db.Integer)
count_engagement = db.Column(db.Integer)
count_impressions = db.Column(db.Integer)
count_reach = db.Column(db.Integer)
count_saved = db.Column(db.Integer)
count_video_views = db.Column(db.Integer)
media_url = db.Column(db.Text())
thumbnail_url = db.Column(db.Text())
caption = db.Column(db.Text())
def __init__(self, postid, timestamp, mediatype, category, permalink,
numcomment, numlike, numengagement, numimpression, numreach,
numsaved, numvideoviews, mediaurl, thumbnailurl, caption):
self.post_id = postid
self.timestamp = timestamp
self.media_type = mediatype
self.category = category
self.permalink = permalink
self.count_comments = numcomment
self.count_like = numlike
self.count_engagement = numengagement
self.count_impressions = numimpression
self.count_reach = numreach
self.count_saved = numsaved
self.count_video_views = numvideoviews
self.media_url = mediaurl
self.thumbnail_url = thumbnailurl
self.caption = caption
def __repr__(self):
return '<AllPosts {}>'.format(str(self.post_id))
class Weather(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_stored = db.Column(db.DateTime, index=True, default=datetime.now)
sunset = db.Column(db.DateTime)
sunrise = db.Column(db.DateTime)
high = db.Column(db.Numeric(10, 2))
low = db.Column(db.Numeric(10, 2))
m_phase = db.Column(db.String)
clouds = db.Column(db.Numeric(10, 2))
wind = db.Column(db.Numeric(10, 2))
wind_dir = db.Column(db.Numeric(10, 2))
vis = db.Column(db.Numeric(10, 2))
current = db.Column(db.String)
def __repr__(self):
return '<id {}, Date {}>'.format(self.id, self.date_stored)
class Product(db.Model):
__tablename__ = 'product'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(50), nullable=False, unique=True)
description = db.Column(db.UnicodeText())
price = db.Column(db.Numeric(10, 5, asdecimal=True))
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('products', lazy='dynamic'),
lazy='select')
status = db.Column(db.Enum(ProductStatusEnum, validate_strings=True),
nullable=False)
rel_tags = db.relationship('Tag',
secondary='product_tag',
backref='products')
tags = association_proxy(
'rel_tags',
'name',
creator=lambda name: Tag.query.get_or_create(name=name))
category_name = association_proxy(
'category',
'name',
creator=lambda name: Category.query.get_or_create(name=name))
def __repr__(self):
return '<Product %r>' % self.name
@hybrid_property
def sells(self):
return (db.session.query(label('count', func.sum(
OrderDetail.quantity))).filter(
OrderDetail.product == self).scalar())
@sells.expression
def sells(cls):
return (select([func.coalesce(
func.sum(OrderDetail.quantity),
0)]).where(OrderDetail.product_id == cls.id).label('sells'))
class Cars(db.Model):
__tablename__ = "cars"
# columns
id = db.Column(db.Integer, primary_key=True)
description = db.Column(db.String(255))
make = db.Column(db.String(255))
model = db.Column(db.String(255))
colour = db.Column(db.String(255))
year = db.Column(db.String(255))
transmission = db.Column(db.String(255))
car_type = db.Column(db.String(255))
price = db.Column(db.Numeric(10, 2, asdecimal=False))
photo = db.Column(db.String(255))
user_id = db.Column(db.Integer, db.ForeignKey("users.id"))
def __init__(self, description, make, model, colour, year, transmission,
car_type, price, photo, user_id):
self.description = description
self.make = make
self.model = model
self.colour = colour
self.year = year
self.transmission = transmission
self.car_type = car_type
self.price = price
self.photo = photo
self.user_id = user_id
class Equipment(db.Model):
__tablename__ = "equipment"
id = db.Column(db.Integer, primary_key=True)
equip_ref = db.Column(db.String(128), index=True, unique=True)
brand = db.Column(db.String(64))
model = db.Column(db.String(128))
serial = db.Column(db.String(128), unique=False)
equip_type = db.Column(db.String(64))
product_num = db.Column(db.String(128))
tickets = db.relationship("Ticket")
"""valeur calculée"""
designation = db.Column(db.String(120))
warranty = db.Column(db.Boolean)
real_cost = db.Column(db.Numeric(precision=8, asdecimal=False, \
decimal_return_scale=None))
def __repr__(self):
return '<Equipment {}>'.format(self.equip_ref)
def set_designation(self, brand, model):
designation = self.brand + self.model
class CovidAnamnese(db.Model):
__tablename__ = 'covid_anamnese'
id__covid_anamnese = db.Column(db.BigInteger, primary_key=True)
id__paciente = db.Column(db.BigInteger)
id__usuario = db.Column(db.BigInteger)
diag_covid = db.Column(db.String(1), nullable=False)
febre = db.Column(db.String(1), nullable=False)
prob_resp = db.Column(db.String(1), nullable=False)
viagem = db.Column(db.String(1), nullable=False)
contato_infect = db.Column(db.String(1), nullable=False)
contato_sintomas = db.Column(db.String(1), nullable=False)
part_reuniao = db.Column(db.String(1), nullable=False)
prob_card_resp = db.Column(db.String(1), nullable=False)
prob_outro = db.Column(db.String(1), nullable=False)
usa_medic = db.Column(db.String(1), nullable=False)
medic_desc = db.Column(db.String(1), nullable=False)
temperatura = db.Column(db.Numeric(2, 2), nullable=False)
obs = db.Column(db.String)
data_cadastro = db.Column(db.DateTime,
nullable=False,
server_default=db.FetchedValue())
class HeaterConfig(DeviceConfigBase):
__tablename__ = "heater_config"
temp_treshold = db.Column(db.Numeric(8, 2), nullable=True)
actuator1_state = db.Column(db.Boolean, nullable=False)
actuator2_state = db.Column(db.Boolean, nullable=False)
actuator3_state = db.Column(db.Boolean, nullable=False)
def __init__(self, device_id, temp_treshold, actuator1_state,
actuator2_state, actuator3_state, name, is_active, weekdays,
start_time, duration):
self.temp_treshold = temp_treshold
self.actuator1_state = actuator1_state
self.actuator2_state = actuator2_state
self.actuator3_state = actuator3_state
self.name = name
self.device_id = device_id
self.start_time = start_time
self.duration = duration
self.weekdays = weekdays
self.is_active = is_active
self.uuid = str(uuid.uuid4())
class AddProduct(db.Model):
__seachbale__ = ['name', 'desc']
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
price = db.Column(db.Numeric(10, 2), nullable=False)
discount = db.Column(db.Integer, default=0)
stock = db.Column(db.Integer, nullable=False)
colors = db.Column(db.Text, nullable=False)
desc = db.Column(db.Text, nullable=False)
pub_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
slug = db.Column(db.String(64), unique=True)
category_id = db.Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = db.relationship('Category',
backref=db.backref('categories', lazy=True))
brand_id = db.Column(db.Integer, db.ForeignKey('brand.id'), nullable=False)
brand = db.relationship('Brand', backref=db.backref('brands', lazy=True))
image_1 = db.Column(db.String(150), nullable=False, default='image1.jpg')
filename_1 = db.Column(db.String(80), default='image1.jpg')
image_2 = db.Column(db.String(150), nullable=False, default='image2.jpg')
filename_2 = db.Column(db.String(80), default='image2.jpg')
image_3 = db.Column(db.String(150), nullable=False, default='image3.jpg')
filename_3 = db.Column(db.String(80), default='image3.jpg')
def generate_slug(self):
self.slug = ''
if self.name:
self.slug = slugify(self.name)
def __repr__(self):
return '<Post %r>' % self.name
def __init__(self, *args, **kwargs):
super(AddProduct, self).__init__(*args, **kwargs)
self.slug = slugify(self.name)
class BookSalesInfo(db.Model):
__tablename__ = 'BookSalesInfos'
id = db.Column(db.Integer, primary_key=True)
book_id = db.Column(db.Integer, db.ForeignKey(Book.id), nullable=False)
url = db.Column(db.Text)
sale_price = db.Column(db.Numeric(10, 2))
quality = db.Column(db.String(16))
location = db.Column(db.String(128))
created_on = db.Column(db.DateTime, server_default=db.func.now())
def __init__(self,
book_id,
url,
sale_price=None,
quality=None,
location=None):
self.book_id = book_id
self.url = url
self.sale_price = sale_price
self.quality = quality
self.location = location
class plantsSold(db.Model):
__tablename__ = 'plantsSold'
transactionID = db.Column(db.Integer,
db.ForeignKey(transactionInfo.transactionID),
primary_key=True)
pID = db.Column(db.Integer, db.ForeignKey(plantInfo.pID))
nID = db.Column(db.Integer, db.ForeignKey(nurseryInfo.nID))
dateOfSelling = db.Column(db.DateTime, default=db.func.current_timestamp())
sellingPrice = db.Column(db.Numeric(10, 2), nullable=False)
def __init__(self, transactionID, pID, nID, sellingPrice):
self.transactionID = transactionID
self.pID = pID
self.nID = nID
self.sellingPrice = sellingPrice
def __repr__(self):
return '<transaction-{tid} pid-{pid} selling price-{cost}>'.format(
tid=self.transactionID, pid=self.pID, cost=self.sellingPrice)
class Transaction(db.Model):
"""Data model for transaction table.
Columns include:
transaction_id: auto increment primary key; int
user_id: user id that the transaction is associated with; int
account_id: account id that the transaction is associated with; int
trans_amount: transaction amount; decimal(10, 2)
category_id: category id in plaid; int
is_preferred_saving: whether the transaction is a preferred saving
category; string
trans_date: date of the transaction; date
post_date: date when the transaction is posted on user's account; date
merchant_category: multiple categories possible; string
merchant_address: merchant address; string
merchant_city: merchant city; string
merchant_state: merchant state; string
merchant_country: merchant country; string
merchant_postal_code: merchant postal code; string
merchant_longitude: merchant longitude; string
merchant_latitude: merchant latitude; string
"""
__tablename__ = "transaction"
id = db.Column("transaction_id", db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.user_id"))
account_id = db.Column(db.Integer, db.ForeignKey("accounts.account_id"))
trans_amount = db.Column(db.Numeric(10, 2), nullable=False)
category_id = db.Column(db.Integer)
is_preferred_saving = db.Column(db.String)
trans_date = db.Column(db.Date, nullable=False)
post_date = db.Column(db.Date)
merchant_category = db.Column(db.String)
merchant_address = db.Column(db.String)
merchant_city = db.Column(db.String)
merchant_state = db.Column(db.String)
merchant_country = db.Column(db.String)
merchant_postal_code = db.Column(db.String)
merchant_longitude = db.Column(db.String)
merchant_latitude = db.Column(db.String)
class Order(db.Model):
id = db.Column(db.Integer, primary_key=True)
timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow)
supplier_id = db.Column(db.Integer, db.ForeignKey('supplier.id'))
freight_company = db.Column(db.String(256))
freight_value = db.Column(db.Numeric(10, 2), nullable=False)
obs = db.Column(db.String(512))
order_items = db.relationship('OrderItem', backref='order', lazy='dynamic')
def __repr__(self):
return '<Order {}>'.format(self.supplier_id)
def total_value(self):
total = self.freight_value
for order_item in self.order_items:
total += order_item.quantity * order_item.unit_price
return total
def has_item(self, item):
for order_item in self.order_items:
if order_item.item == item.name:
return True
return False
class BasePackage(db.Model):
__abstract__ = True
id = db.Column(db.Integer(), autoincrement=True, primary_key=True)
#name = db.Column(db.String(255), nullable=False, unique=True)
name = db.Column(db.String(255), nullable=False)
page_views = db.Column(db.Integer(), nullable=False)
heatmaps = db.Column(db.Integer(), nullable=False)
session_recordings = db.Column(db.Integer(), nullable=False)
ab_testing = db.Column(db.Integer(), nullable=False)
ecommerce = db.Column(db.Boolean(), nullable=False)
reports_standard = db.Column(db.Integer(), nullable=False)
reports_power_bi = db.Column(db.Integer(), nullable=False)
api_data_download = db.Column(db.Integer(), nullable=False)
api_recommandations = db.Column(db.Integer(), nullable=False)
api_data_transformation = db.Column(db.Integer(), nullable=False)
api_index_search = db.Column(db.Integer(), nullable=False)
api_product_360 = db.Column(db.Integer(), nullable=False)
api_custom_searches = db.Column(db.Integer(), nullable=False)
price = db.Column(db.Numeric(precision=65, scale=2), nullable=False)
currency = db.Column(db.String(3), nullable=False)
class Property(db.Model):
__tablename__ = "properties"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(255))
bedroom_count = db.Column(db.Integer)
bathroom_count = db.Column(db.Integer)
location = db.Column(db.String(255))
price = db.Column(db.Numeric(10, 2, asdecimal=False))
type = db.Column(db.Enum(PropertyType))
description = db.Column(db.String(1500))
photo_path = db.Column(db.String(255))
def __init__(self, title, bedroom_count, bathroom_count, location, price, type, description, photo_path) -> None:
super().__init__()
self.title = title
self.bedroom_count = bedroom_count
self.bathroom_count = bathroom_count
self.location = location
self.price = price
self.type = type
self.description = description
self.photo_path = photo_path
class PartnerGiving(db.Model):
"""
Create a Role table
"""
__tablename__ = 'partner_givings'
id = db.Column(db.Integer, primary_key=True)
member_id = db.Column(db.Integer,
db.ForeignKey('members.id'),
nullable=False)
arm_id = db.Column(db.Integer,
db.ForeignKey('partnership_arms.id'),
nullable=False)
staff_id = db.Column(db.Integer,
db.ForeignKey('staffs.id'),
nullable=False)
amount = db.Column(db.Numeric(10, 2), nullable=False)
is_pledge = db.Column(db.Boolean, default=False)
entry_date = db.Column(db.Date)
def __repr__(self):
return '<Partner Giving: {}>'.format(self.amount)
class Event(BaseModel):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(150), nullable=False)
category = db.Column(db.String(100), nullable=False)
start_date = db.Column(db.DateTime, nullable=False)
end_date = db.Column(db.DateTime, nullable=False)
cost = db.Column(db.Numeric(10, 2, asdecimal=False),
nullable=False,
default=0)
venue = db.Column(db.String(100))
flyer = db.Column(db.String(100))
visibility = db.Column(db.Boolean, default=0, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# fields that are always returned by to_dict method
_default_fields = ['id', 'name', 'category']
# fields that are never returned by to_dict method
_hidden_fields = []
# fields that are never updated by from_dict method
_readonly_fields = ['id', 'user_id']
class MintTransactions(db.Model):
__tablename__ = 'minttransactions'
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime)
description = db.Column(db.String(500))
original_description = db.Column(db.String(500))
amount = db.Column(db.Numeric(16, 2))
transaction_type = db.Column(db.String(20))
category = db.Column(db.String(100))
account_name = db.Column(db.String(100))
labels = db.Column(db.String(40))
notes = db.Column(db.String(500))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
subcategory_id = db.Column(db.Integer, db.ForeignKey('subcategory.id'))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
usersubcategory_id = db.Column(db.Integer,
db.ForeignKey('usersubcategory.id'))
def __repr__(self):
return "<MintTransactions(id='%r', Date='%r', Description='%r', Original Description='%r', Amount='%f', Transaction Type='%r', Category='%r', Account Name='%r', labels='%r', notes='%r')>" % (
self.id, self.date, self.description, self.original_description,
self.amount, self.transaction_type, self.category,
self.account_name, self.labels, self.notes)
class Employer(db.Model):
__tablename__ = 'employer'
id = db.Column(db.Integer, primary_key=True)
employer_name = db.Column(db.String(100))
employer_code = db.Column(db.String(120))
member_count = db.Column(db.String(3))
thumbnail = db.Column(db.String(255))
register_date = db.Column(db.Numeric(10))
def __init__(self,
employer_name=None,
employer_code=None,
member_count=None,
thumbnail=None,
register_date=None):
self.employer_name = employer_name
self.employer_code = employer_code
self.member_count = member_count
self.thumbnail = thumbnail
self.register_date = register_date
def __repr__(self):
return '<User %r>' % self.name
@property
def serialize(self):
return {
'id': self.id,
'employer_name': self.employer_name,
# This is an example how to deal with Many2Many relations
'employer_code': self.employer_code,
'member_count': self.member_count,
'thumbnail': self.thumbnail,
'register_date': self.register_date,
}
class OB_ENDPOINT(db.Model):
__tablename__ = "OB_ENDPOINT"
ep_id = db.Column(db.NVARCHAR(32),
nullable=False,
default=uuid_gen(),
primary_key=True)
# dev_id = db.Column(db.NVARCHAR(32),nullable=False,primary_key=True)
ep_type = db.Column(db.NVARCHAR(50), nullable=False, primary_key=True)
ep_order = db.Column(db.Integer, default=1)
ep_name = db.Column(db.NVARCHAR(50), nullable=False)
ep_scale = db.Column(db.Numeric(precision=15, scale=3, asdecimal=False),
default=1.0)
ep_unit = db.Column(db.NVARCHAR(20), nullable=True)
ep_pr_host = db.Column(
db.NVARCHAR(20), nullable=False,
default='127.0.0.1') # parent domain(connection info)
ep_interval = db.Column(db.Integer, nullable=False, default=10)
ep_limit = db.Column(db.NVARCHAR(10), nullable=False) # time / count
ep_location = db.Column(db.NVARCHAR(20), nullable=True)
ep_hour = db.Column(db.Integer)
ep_day = db.Column(db.Integer)
ep_month = db.Column(db.Integer)
ep_count = db.Column(db.Integer)
last_update = db.Column(db.DATETIME, nullable=True)
class CoMagicCampaign(db.Model):
__tablename__ = 'comagic_campaigns'
__humanname__ = 'Параметры кампаний'
__order__ = 3
id = db.Column(db.Integer, primary_key=True, info={'verbose_name': 'Идентификатор кампании'})
account_id = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Идентификатор подключенного аккаунта'})
campaign_id = db.Column(db.Integer, nullable=False, info={'verbose_name': 'Внутренний идентификатор кампании'})
name = db.Column(db.Unicode(128), info={'verbose_name': 'Название кампании'})
description = db.Column(db.Unicode(256), info={'verbose_name': 'Описание кампании'})
campaign_type = db.Column(db.Unicode(16), info={'verbose_name': 'Тип кампании'})
engine = db.Column(db.Unicode(16), info={'verbose_name': 'Платформа интегрированной кампании'})
status = db.Column(db.Unicode(8), info={'verbose_name': 'Статус'})
costs = db.Column(db.Numeric(18,2), info={'verbose_name': 'Расходы'})
cost_ratio = db.Column(db.Integer, info={'verbose_name': 'Коэффициент расходов'})
cost_ratio_operator = db.Column(db.Unicode(16), info={'verbose_name': 'Оператор расчета расходов'})
__table_args__ = (
db.Index('comagic_campaigns_idx_1', account_id),
db.Index('comagic_campaigns_idx_2', campaign_id),
)
def __repr__(self):
return '<CoMagicCampaign %r>' % self.id
class Rates(db.Model):
id = db.Column(db.Integer, primary_key=True)
currency = db.Column(db.String(3))
rate = db.Column(db.Numeric(10, 5))
trade_time = db.Column(db.DateTime)
def get_rate(self):
currencys = ['EUR', 'USD', 'GBP', 'JPY', 'CAD', 'MXN', 'AUD']
trade_time = datetime.now()
for currency in currencys:
url = 'http://hl.anseo.cn/cal_{currency}_To_CNY_1.aspx'.format(
currency=currency)
response = urllib.request.urlopen(url)
html = response.read().decode('utf-8')
rates_re = re.compile(r'<p><strong>当前汇率：</strong>(.*?)</p>')
result = rates_re.findall(html)
if result[0]:
rate = Rates(currency=currency,
rate=float(result[0]),
trade_time=trade_time)
db.session.add(rate)
db.session.commit()
def last_rate(self):
results = Rates.query.order_by(Rates.trade_time.desc()).limit(12).all()
tormb = {}
for result in results:
tormb[result.currency] = result.rate
if len(tormb) == 7:
break
return tormb
class Customer(db.Model, UserMixin, ToDictMixin):
"""顾客"""
__tablename = 'customer'
auto_load_attrs = ('id')
id = db.Column(UNSIGNED_INT, primary_key=True, autoincrement=True)
# 昵称
nick_name = db.Column(db.String(64), nullable=False)
gender = db.Column(db.Integer, nullable=True)
city = db.Column(db.String(40), nullable=True)
province = db.Column(db.String(40), nullable=True)
country = db.Column(db.String(40), nullable=True)
avatarUrl = db.Column(db.String(200), nullable=True)
cashbox = db.Column(db.Numeric(8, 2), default=0.0)
is_deleted = db.Column(db.Boolean, default=False)
orders = db.relationship('Order', back_populates='customer')
def to_dict(self):
return {'id': self.id, 'nick_name': self.nick_name}
# endregion
