class ObjPurchaseOrderCharge(BaseModel):
__tablename__ = "PURCHASE_ORDER_CHARGE"
po_no = db.Column(db.String(100), primary_key=True)
po_line_no = db.Column(db.String(10), primary_key=True)
mmp_charge_code = db.Column(db.String(100), primary_key=True)
mmp_charge = db.Column(db.Numeric)
mmp_charge_in_ntd = db.Column(db.Numeric)
mmp_charge_amount = db.Column(db.Numeric)
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.Integer)
def __repr__(self):
return '<PURCHASE_REQUESTS_DETAIL %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
sender = db.Column(db.Integer, nullable=False)
content = db.Column(db.Text)
time_post = db.Column(db.Integer)
time_update = db.Column(db.Integer)
def __init__(self, sender, content):
self.sender = sender
self.content = content
self.time_post = int(time.time())
self.time_update = self.time_post
def __repr__(self):
return '<Comment %r>' % self.content
def json(self):
return json.dumps(self,
default=lambda o: o.__dict__,
ensure_ascii=False)
def serialized(self):
comment = {"id": self.id, "sender": dump_sender(self.sender)}
if self.content:
comment["content"] = self.content
return comment
class StoreModel(db.Model): # noqa
__tablename__ = "stores"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
items = db.relationship("ItemModel", lazy="dynamic")
def __init__(self, name: str):
self.name = name
def json(self) -> dict:
return {
"name": self.name,
"items": [item.json() for item in self.items.all()],
}
@classmethod
def find_by_name(cls, name: str):
return cls.query.filter_by(name=name).first()
def save_to_db(self): # both update and post
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def return_all_items(cls):
return cls.query.all()
class ItemModel(db.Model): # noqa
__tablename__ = "items"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
price = db.Column(db.Float(precision=2))
store_id = db.Column(db.Integer, db.ForeignKey("stores.id"))
store = db.relationship("StoreModel")
__DB_LOCATION = "src/data.db"
def __init__(self, name: str, price: float, store_id: int):
self.name = name
self.price = price
self.store_id = store_id
def json(self) -> dict:
return {"name": self.name, "price": self.price, "store": self.store_id}
@classmethod
def find_by_name(cls, name: str):
return cls.query.filter_by(name=name).first()
def save_to_db(self): # both update and post
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def return_all_items(cls):
return cls.query.all()
class User(db.Model):
"""User
Attributes:
email (str): email of the user
password (str): password of the user
gender (str): male or female
age (int): age of the person
weight (float): weight in kilograms
lifestyle (str): sitting, normal or active
allergies (str): csv string of allergies
"""
__tablename__ = 'user'
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(128))
password = db.Column(db.String(128))
confirmed = db.Column(db.Boolean)
gender = db.Column(db.String(128))
age = db.Column(db.Integer)
weight = db.Column(db.Float)
height = db.Column(db.Float)
lifestyle = db.Column(db.String())
allergies = db.Column(db.String())
def __init__(self, email, password):
self.email = email
self.password = password
self.confirmed = False
self.gender = None
self.age = None
self.weight = None
self.height = None
self.lifestyle = None
self.allergies = ''
class Club(db.Model):
id = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(255), unique=True)
abbreviation = db.Column(db.String(255), unique=True)
logo = db.Column(db.String(255))
description = db.Column(db.String(255), default="")
registrations = db.relationship("Registration")
_default_fields = ["name", "id", "description", "logo", "abbreviation"]
class Creditcard(db.Model):
__tablename__ = 'Creditcard'
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
address_id = db.Column(u'address_id', db.Integer(),
db.ForeignKey('UserAddress.id'))
billing_id = db.Column(u'billing_id', db.Integer(),
db.ForeignKey('Billing.id'))
name = db.Column(u'name', db.String(length=64), nullable=False)
cc_number = db.Column(u'cc_number', db.BigInteger(), nullable=False)
sec_number = db.Column(u'sec_number', db.Integer(), nullable=False)
exp_date = db.Column(u'exp_date', db.Date(), nullable=False)
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
def __init__(self, name, address_id, billing_id, cc_number, sec_number,
exp_date):
self.address_id = address_id
self.billing_id = billing_id
self.name = name
self.cc_number = cc_number
self.sec_number = sec_number
self.exp_date = exp_date
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
UserAddress = db.relationship('UserAddress',
primaryjoin='Creditcard.address_id==UserAddress.id')
Billing = db.relationship('Billing',
primaryjoin='Creditcard.billing_id==Billing.id')
class ObjCharge(BaseModel):
__tablename__ = "CHARGE"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
pr_no = db.Column(db.String(100))
charge_deptcode = db.Column(db.String(100))
charge_pcode = db.Column(db.String(100))
charge = db.Column(db.Numeric)
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.Integer)
def __repr__(self):
return '<CHARGE %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class OrderItem(db.Model):
__tablename__ = 'OrderItem'
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
order_id = db.Column(u'order_id', db.Integer(), db.ForeignKey('Order.id'))
book_id = db.Column(u'book_id', db.Integer(), db.ForeignKey('Book.id'))
quantity = db.Column(u'quantity', db.Integer())
cost = db.Column(u'cost', db.DECIMAL(precision=7, scale=2), nullable=False)
price = db.Column(u'price', db.DECIMAL(precision=7, scale=2),
nullable=False)
status = db.Column(u'status', db.String(length=10), nullable=False)
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
def __init__(self, order_id, book_id, quantity, cost, price, status):
self.order_id = order_id
self.book_id = book_id
self.quantity = quantity
self.cost = cost
self.price = price
self.status = status
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
Order = db.relationship('Order',
primaryjoin='OrderItem.order_id==Order.id')
Book = db.relationship('Book', primaryjoin='OrderItem.book_id==Book.id')
class ObjPaymentApplication(BaseModel):
__tablename__ = "PAYMENT_APPLICATION"
po_no = db.Column(db.String(100), primary_key=True)
fin_pm_no = db.Column(db.String(100), primary_key=True)
fin_payment_date = db.Column(db.DateTime, None)
order_type = db.Column(db.String(100))
hsf = db.Column(db.String(100))
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.Integer)
def __repr__(self):
return '<PAYMENT_APPLICATION %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class ObjVendor(BaseModel):
__tablename__ = "VENDORS"
vendor_code = db.Column(db.String(100), primary_key=True)
brief_name = db.Column(db.String(255))
full_name = db.Column(db.String(255))
chinese_full_name = db.Column(db.String(255))
location = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.String(255))
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.String(255))
def __repr__(self):
return '<VENDORS %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class ObjDashboard(BaseModel):
__tablename__ = "DASHBOARD"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.Integer)
def __repr__(self):
return '<DASHBOARD %r>' % self.id
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128), unique=True, nullable=False)
email = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.Text, nullable=False)
nick = db.Column(db.String(128))
avatar = db.Column(db.String(256))
profile_image = db.Column(db.String(256))
friends = db.Column(db.Text)
time_register = db.Column(db.Integer)
time_last_login = db.Column(db.Integer)
def __init__(self, username, email):
self.username = username
self.email = email
self.time_register = int(time.time())
self.time_last_login = self.time_register
def __repr__(self):
return '<User %r>' % self.username
def json(self):
user = {
'username': self.username,
'nick': self.nick,
'avatar': self.avatar,
'profile-image': self.profile_image
}
return json.jsonify(user)
def sender(self):
user = {
'username': self.username,
'nick': self.nick,
'avatar': self.avatar
}
return json.jsonify(user)
def serialized(self):
return {
'username': self.username,
'nick': self.nick,
'avatar': self.avatar
}
def serialized_friends(self):
return dump_friends(self.friends)
def serialized_tweets(self):
from model.tweet import dump_tweets
return dump_tweets(self.id, self.friends)
class ObjPlant(BaseModel):
__tablename__ = "PLANTS"
id = db.Column(db.Integer, autoincrement=True, primary_key=True)
name = db.Column(db.String(100))
bg_id = db.Column(db.Integer)
site_id = db.Column(db.Integer)
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.Integer)
def __repr__(self):
return '<PLANTS %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class Order(db.Model):
__tablename__ = 'Order'
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
user_id = db.Column(u'user_id', db.Integer(), db.ForeignKey('User.id'))
cart_id = db.Column(u'cart_id', db.Integer(), db.ForeignKey('Cart.id'))
shipping = db.Column(u'shipping', db.DECIMAL(precision=7, scale=2),
nullable=False)
tax = db.Column(u'tax', db.DECIMAL(precision=7, scale=2), nullable=False)
status = db.Column(u'status', db.String(length=10), nullable=False)
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
def __init__(self, user_id, cart_id, shipping, tax, status):
self.user_id = user_id
self.cart_id = cart_id
self.shipping = shipping
self.tax = tax
self.subtotal = 0
self.status = status
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
User = db.relationship('User', primaryjoin='Order.user_id==User.id')
Cart = db.relationship('Cart', primaryjoin='Order.cart_id==Cart.id')
class Image(db.Model):
id = db.Column(db.Integer, primary_key=True)
url = db.Column(db.Text)
def __init__(self, url):
self.url = url
def __repr__(self):
return '<Image %r>' % self.url
def json(self):
return json.dumps(self, default=lambda o: o.__dict__, ensure_ascii=False)
def serialized(self):
return {"url": self.url}
class User(BaseModel, UserMixin):
"""
This is the user model (used for both login and registration) will consider separating login to a separate table/db
"""
id = db.Column(db.Integer(), primary_key=True)
student_id = db.Column(db.String(255), unique=True, nullable=True)
email = db.Column(db.String(255), unique=True)
first_name = db.Column(db.String(255))
last_name = db.Column(db.String(255))
password = db.Column(db.String(255), default="")
active = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role',
secondary=roles_users,
backref=db.backref('users', lazy='dynamic'))
registrations = db.relationship("Registration")
_default_fields = ["student_id", "email", "first_name", "last_name"]
def get_auth_token(self, allow_refresh=False):
"""
Create an authentication token for this user
:param allow_refresh: Doesn't do anything at the moment except add to payload
:return: The string token
"""
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=3),
'iat': datetime.datetime.utcnow(),
'sub': self.email,
'refresh': allow_refresh
}
token = jwt.encode(payload, app.config.get('SECRET_KEY'),
'HS256').decode()
return token
@staticmethod
def decode_auth_token(token):
"""
Decode an authentication token provided by JWT
:param token: The string/bytes token object
:return: The user associated and related payload
"""
try:
payload = jwt.decode(token.encode(), app.config.get("SECRET_KEY"))
user = User.query.filter(User.email == payload["sub"]).first()
if not user:
raise InvalidTokenError()
return user, payload
except jwt.ExpiredSignatureError:
raise Unauthorized("This token has expired")
except jwt.InvalidTokenError:
traceback.print_exc()
raise Unauthorized("Unable to authenticate with that information")
class InventoryOrder(db.Model):
__tablename__ = 'InventoryOrder'
__table_args__ = {}
#column definitions
cost = db.Column(u'cost', db.DECIMAL(precision=7, scale=2), nullable=False)
cur_quantity = db.Column(u'cur_quantity', db.Integer(), nullable=False)
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
inventory_id = db.Column(u'inventory_id', db.Integer(),
db.ForeignKey('Inventory.id'))
orig_quantity = db.Column(u'orig_quantity', db.Integer(), nullable=False)
def __init__(self, cost, cur_quantity, inv_id, orig_quant):
self.cost = cost
self.cur_quantity = cur_quantity
self.inventory_id = inv_id
self.orig_quantity = orig_quant
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
Inventory = db.relationship('Inventory',
primaryjoin='InventoryOrder.inventory_id==Inventory.id')
class CartItem(db.Model):
__tablename__ = 'CartItem'
__table_args__ = {}
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
cart_id = db.Column(u'cart_id', db.Integer(), db.ForeignKey('Cart.id'))
book_id = db.Column(u'book_id', db.Integer(), db.ForeignKey('Book.id'))
quantity = db.Column(u'quantity', db.Integer())
status = db.Column(u'status', db.String(length=10), nullable=False)
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
def __init__(self, cart_id, book_id, quantity, status):
self.cart_id = cart_id
self.book_id = book_id
self.quantity = quantity
self.status = status
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
Book = db.relationship('Book', primaryjoin='CartItem.book_id==Book.id')
Cart = db.relationship('Cart', primaryjoin='CartItem.cart_id==Cart.id')
class Book(db.Model):
__tablename__ = 'Book'
__table_args__ = {}
#column definitions
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
isbn = db.Column(u'isbn', db.BigInteger(), nullable=False, unique=True)
price = db.Column(u'price', db.DECIMAL(precision=7, scale=2),
nullable=False)
publisher_id = db.Column(u'publisher_id', db.Integer(),
db.ForeignKey('Publisher.id'))
title = db.Column(u'title', db.Text(), nullable=False)
def __init__(self, isbn, title, price, pub_id):
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
self.isbn = isbn
self.title = title
self.price = price
self.publisher_id = pub_id
def __repr__(self):
return "<Book id: {0}, title: {1}>".format(self.id, self.title)
#db.relationship definitions
Publisher = db.relationship('Publisher',
primaryjoin='Book.publisher_id==Publisher.id')
Authors = db.relationship('Author', secondary=Book_Author,
backref=db.backref('books'))
Categories = db.relationship('Category', secondary=Book_Category,
backref=db.backref('books'))
class User(db.Model):
__tablename__ = 'User'
__table_args__ = {}
#column definitions
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
email = db.Column(u'email', db.String(length=128), nullable=False,
unique=True)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
name = db.Column(u'name', db.String(length=64))
password = db.Column(u'password', db.String(length=64), nullable=False)
phone = db.Column(u'phone', db.BigInteger())
username = db.Column(u'username', db.String(length=32), nullable=False,
unique=True)
authenticated = False
def __init__(self, email, username, password, name=None, phone=None):
self.name = name if name != '' else None
self.username = username
self.email = email
self.password = generate_encrypted_password(password)
self.phone = str_to_digits(phone)
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
self.authenticated = False
def __repr__(self):
return "<User id: {id}, username: {usn}, name: {name},>".format(
id=self.id, name=self.name, usn=self.username,
auth=self.authenticated)
#Methods for Flask-Login
def get_id(self):
return unicode(self.id)
def is_anonymous(self):
return not isinstance(self.id, long)
def is_authenticated(self):
return self.authenticated
def is_active(self):
return self.is_authenticated()
def is_admin(self):
#TODO: Test whehter admin relationship exists
return False
#db.relationship definitions
Carts = db.relationship('Cart', primaryjoin='User.id==Cart.user_id',
backref=db.backref('User'))
class ObjApproverList(BaseModel):
__tablename__ = "APPROVER_LIST"
pr_no = db.Column(db.String(100))
approver_level = db.Column(db.String(5))
approver_date = db.Column(db.DateTime)
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.Integer)
def __repr__(self):
return '<APPROVER_LIST %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class ObjRTDetail(BaseModel):
__tablename__ = "RT_DETAIL"
rt_no = db.Column(db.Integer, primary_key=True)
rt_line_no = db.Column(db.Integer, primary_key=True)
rt_qty = db.Column(db.Numeric)
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.Integer)
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.Integer)
def __repr__(self):
return '<RT_LINES %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class ObjPaymentTerm(BaseModel):
__tablename__ = "PAYMENT_TERM"
payment_term = db.Column(db.String(100), primary_key=True)
payment_code = db.Column(db.String(100))
description = db.Column(db.String(255))
created_at = db.Column(db.DateTime, default=datetime.now())
created_by = db.Column(db.String(255))
updated_at = db.Column(db.DateTime, default=datetime.now())
updated_by = db.Column(db.String(255))
def __repr__(self):
return '<PAYMENT_TERM %r>' % self.id
def create(self, data):
db.session.add(data)
return db.session.commit()
def update(self):
return db.session.commit()
def delete(self, id):
od = self.query.get(id)
if None != od:
db.session.delete(od)
return db.session.commit()
class Cart(db.Model):
__tablename__ = 'Cart'
__table_args__ = {}
#column definitions
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
user_id = db.Column(u'user_id', db.Integer(), db.ForeignKey('User.id'))
status = db.Column(u'status', db.String(length=10), nullable=False)
def __init__(self, user_id, status):
self.user_id = user_id
self.status = status
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
class Category(db.Model):
__tablename__ = 'Category'
__table_args__ = {}
#column definitions
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
name = db.Column(u'name', db.String(length=64), nullable=False,
unique=True)
def __init__(self, name):
self.name = name
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
Books = db.relationship('Book', secondary=Book_Category)
class Author(db.Model):
__tablename__ = 'Author'
__table_args__ = {}
#column definitions
birth_date = db.Column(u'birth_date', db.Date())
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
name = db.Column(u'name', db.Text(), nullable=False)
def __init__(self, name, b_date):
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
self.name = name
self.birth_date = b_date
#db.relationship definitions
Books = db.relationship('Book', secondary=Book_Author)
class Billing(db.Model):
__tablename__ = 'Billing'
__table_args__ = {}
#column definitions
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
type = db.Column(u'type', db.String(length=12))
user_id = db.Column(u'user_id', db.Integer(), db.ForeignKey('User.id'))
def __init__(self, type, user_id):
self.type = type
self.user_id = user_id
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
User = db.relationship('User', primaryjoin='Billing.user_id==User.id')
class OrderPayment(db.Model):
__tablename__ = 'OrderPayment'
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
order_id = db.Column(u'order_id', db.Integer(), db.ForeignKey('Order.id'))
billing_id = db.Column(u'billing_id', db.Integer(),
db.ForeignKey('Billing.id'))
price = db.Column(u'price', db.DECIMAL(precision=7, scale=2),
nullable=False)
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
def __init__(self, order_id, billing_id, price):
self.order_id = order_id
self.billing_id = billing_id
self.price = price
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
Order = db.relationship('Order',
primaryjoin='OrderPayment.order_id==Order.id')
Billing = db.relationship('Billing',
primaryjoin='OrderPayment.billing_id==Billing.id')
class Giftcard(db.Model):
__tablename__ = 'Giftcard'
__table_args__ = {}
#column definitions
billing_id = db.Column(u'billing_id', db.Integer(),
db.ForeignKey('Billing.id'))
date_created = db.Column(u'date_created', db.DateTime(), nullable=False)
date_modified = db.Column(u'date_modified', db.DateTime(), nullable=False)
id = db.Column(u'id', db.Integer(), primary_key=True, nullable=False)
number = db.Column(u'number', db.String(length=24), nullable=False,
unique=True)
pin = db.Column(u'pin', db.Integer(), nullable=False)
def __init__(self, billing_id, number, pin):
self.billing_id = billing_id
self.number = number
self.pin = pin
current_time = now().strftime("%Y-%m-%d %H:%M")
self.date_created = current_time
self.date_modified = current_time
#db.relationship definitions
Billing = db.relationship('Billing',
primaryjoin='Giftcard.billing_id==Billing.id')
