class Beer(db.Model):
"""Beer object, takes care of everything you would want to know
about a specific beer."""
# Attributes specific to this particular beer
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
abv = db.Column(db.Float)
photo = db.Column(db.String(200))
special_ingredient = db.Column(db.String(250))
# Relationships to other models
genre_id = db.Column(db.Integer, db.ForeignKey('genre.id'))
genre = db.relationship('Genre', backref = db.backref('beers', lazy='dynamic'))
brewery_id = db.Column(db.Integer, db.ForeignKey('brewery.id'))
brewery = db.relationship('Brewery', backref = db.backref('beers', lazy='dynamic'))
def __init__(self, name, abv, photo, special_ingredient, genre, brewery):
self.name = name
self.abv = abv
self.photo = photo
self.special_ingredient = special_ingredient
self.genre = genre
self.brewery = brewery
def __repr__(self):
return '<Beer %r>' % self.name
class Rating(db.Model):
"""Rating object for a beer, from a user."""
id = db.Column(db.Integer, primary_key=True)
score = db.Column(db.Integer)
scale = db.Column(db.Integer)
notes = db.Column(db.Text)
session_beer = db.Column(db.Integer)
# Relationships to other models
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
user = db.relationship('User',
backref = db.backref('user', lazy='dynamic'))
beer_id = db.Column(db.Integer, db.ForeignKey('beer.id'))
beer = db.relationship('Beer',
backref = db.backref('beer', lazy='dynamic'))
def __init__(self, score, scale, notes, session_beer, user, beer):
self.score = score
self.scale = scale
self.notes = notes
self.session_beer = session.beer
self.user = user
self.beer = beer
def __repr__(self):
return '<Rating %r>' % (self.score + '/' + self.scale)
class Vote(db.Model, TimestampMixin):
__tablename__ = 'votes'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
video_id = db.Column(db.Integer, db.ForeignKey('videos.id'))
video = db.relationship('Video', backref=db.backref('votes', uselist=True, cascade='delete,all'))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User', backref=db.backref('votes', uselist=True, cascade='delete,all'))
status = db.Column(db.String(50))
def __init__(self, *args, **kwargs):
super(Vote, self).__init__(*args, **kwargs)
class Usercontent(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.Integer,
db.ForeignKey('user.username', ondelete='CASCADE'))
user = db.relationship('User', backref=db.backref('usercontent_set'))
content = db.Column(db.Text(), nullable=False)
create_date = db.Column(db.DateTime(), nullable=False)
modify_date = db.Column(db.DateTime(), nullable=True)
filename = db.Column(db.String(200), nullable=False)
voter = db.relationship('User',
secondary=usercontent_like_voter,
backref=db.backref('usercontent_voter_set'))
class Org(db.Model):
__tablename__ = 'orgs'
id = db.Column('id', db.Integer(), primary_key=True, autoincrement=True)
name = db.Column('name', db.String(), nullable=False)
en_name = db.Column('en_name', db.String())
head = db.Column('head', db.String())
parent_id = db.Column('parent_id', db.Integer, db.ForeignKey('orgs.id'))
children = db.relationship('Org',
backref=db.backref('parent', remote_side=[id]))
strategies = db.relationship('Strategy', backref=db.backref('org'))
def __repr__(self):
return self.name
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
subject = db.Column(db.String(200), nullable=False)
content = db.Column(db.Text(), nullable=False)
create_date = db.Column(db.DateTime(), nullable=False)
modify_date = db.Column(db.DateTime(), nullable=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
# user 속성은 Post모델에서 계정모델(User)을 참조하기 위해서 추가된 속성으로 post.user.username과 같이 사용된다.
user = db.relationship('User', backref=db.backref('post_set'))
voter = db.relationship('User',
secondary=post_voter,
backref=db.backref('post_voter_set'))
class SubjectModel(db.Model):
__tablename__ = 'subjects'
p_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True, nullable=False)
code = db.Column(db.String(120), unique=True, nullable=False)
class_id = db.Column(db.Integer,
db.ForeignKey('classes.p_id'),
nullable=False)
department_id = db.Column(db.Integer,
db.ForeignKey('departments.p_id'),
nullable=False)
classes = db.relationship("ClassModel",
backref=db.backref("std_class", uselist=False))
departmentes = db.relationship("DepartmentModel",
backref=db.backref("std_departments",
uselist=False))
def save_to_db(self):
db.session.add(self)
db.session.commit()
def db_to_delete(self):
db.session.delete(self)
db.session.commit()
def db_to_commit(self):
db.session.commit()
#FOR CONVERT DATA INTO JSON FORMAT
@staticmethod
def to_json(data):
return {
'name': data.name,
'code': data.code,
'class': data.class_id,
'department': data.department_id
}
@classmethod
def find_by_id(cls, p_id):
return cls.query.filter_by(p_id=p_id).first()
@classmethod
def return_all(cls):
return {
'subjects':
list(map(lambda x: self.to_json(x), SubjectModel.query.all()))
}
class Reply(db.Model):
id = db.Column(db.Integer, primary_key=True)
post_id = db.Column(db.Integer, db.ForeignKey('post.id',
ondelete='CASCADE'))
post = db.relationship('Post', backref=db.backref('reply_set'))
content = db.Column(db.Text(), nullable=False)
create_date = db.Column(db.DateTime(), nullable=False)
modify_date = db.Column(db.DateTime(), nullable=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
user = db.relationship('User', backref=db.backref('reply_set'))
voter = db.relationship('User',
secondary=reply_voter,
backref=db.backref('reply_voter_set'))
class Users_twitter(UserMixin ,db.Model):
"""this is the registering a new user"""
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
username = db.Column(db.String(30))
password = db.Column(db.String())
joined_on = db.Column(db.Date)
profile_image= db.Column(db.String())
user=db.relationship("Posts", backref='this_user')
# this is a query and it returns allm people that the curent user is following::: soo basically the cureent user is on the left of the table while\
# his/her follwers are on the right handside of the table
following = db.relationship("Users_twitter", secondary="follower_followee_jk",
primaryjoin=(followers.c.me_user_id_follower==id),
secondaryjoin=(followers.c.followee_id_followee==id),
backref=db.backref("followers", lazy="dynamic"), lazy="dynamic")
# # this query returns all peape that follw the current user
followed_by = db.relationship("Users_twitter", secondary=followers,
primaryjoin=(followers.c.followee_id_followee==id),
secondaryjoin=(followers.c.me_user_id_follower==id), backref=db.backref("poeple_following_me", lazy="dynamic"), lazy="dynamic" )
# function to commit tothe db
def create(self):
db.session.add(self)
db.session.commit()
# checking password and username
@classmethod
def pass_username_check (cls,username, password):
username_check = cls.query.filter_by(username=username).first()
if username_check and check_password_hash(username_check.password, password):
return True
else:
return False
class CourseModel(db.Model):
__tablename__ = 'course'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(255), nullable=False, unique=True)
# Relationships
students = db.relationship('StudentModel',
backref='course',
lazy='select',
cascade='all, delete-orphan')
classrooms = db.relationship('ClassroomModel',
backref='course',
lazy='select',
cascade='all, delete-orphan')
subjects = db.relationship('SubjectModel',
secondary=course_subject,
backref=db.backref('course', lazy='select'))
def __init__(self, name: str):
self.name = name
def __repr__(self):
return f'<CourseModel {self.name}>'
class Content(db.Model):
__tablename__ = "content"
content_id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(), nullable=False)
genre = db.Column(db.String())
year = db.Column(db.Integer)
groups = db.relationship("Group",
secondary=group_content,
backref=db.backref("contents"))
profiles = db.relationship("Profile",
secondary=unrecommend,
backref=db.backref("contents"))
def __repr__(self):
return f"<Content {self.content_id}>"
class Beam(db.Model):
id = db.Column(db.Integer, primary_key=True)
tag = db.Column(db.String, unique=True)
wall_tag = db.Column(db.String(10))
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category',
backref=db.backref('caregory', lazy=True))
width = db.Column(db.Float)
depth = db.Column(db.Float)
length = db.Column(db.Float)
amount = db.Column(db.Integer)
timestamp = db.Column(db.String, default=time.ctime())
def __init__(self, doc_id, tag, wall_tag, width, depth, length, amount,
category, top_bar, mid_bar, bot_bar, stirup, stirup_spacing,
amt_top, amt_mid, amt_bot):
self.tag = tag
self.wall_tag = wall_tag
self.width = width
self.length = length
self.depth = depth
self.amount = amount
def __repr__(self):
return '<Structural Member Beam {}'.format(self.tag)
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
username = db.Column(db.String(255))
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=True)
roles = db.relationship('Role',
secondary=user_role_link,
backref=db.backref('related_user', lazy='dynamic'))
searchphrases = db.relationship('Theme',
secondary=user_theme_link,
backref=db.backref('related_user',
lazy='dynamic'))
def __repr__(self):
return '<{}>'.format(self.username)
class ProjectModel(db.Model):
__tablename__ = 'projects'
projectID = db.Column(db.Integer, primary_key=True, autoincrement=True)
project_name = db.Column(db.String(255), unique=True, nullable=False)
project_manager = db.Column(db.String(255), unique=True, nullable=False)
tasks = db.relationship('TaskModel', backref=db.backref('projects'))
def __init__(self, project_name, project_manager):
self.project_name = project_name
self.project_manager = project_manager
def get_id(self):
return self.projectID
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete_from_db(self):
db.session.delete(self)
db.session.commit()
@classmethod
def find_by_projectID(cls, projectID):
return cls.query.filter_by(projectID=projectID).first()
@classmethod
def find_by_project_name(cls, project_name):
return cls.query.filter_by(project_name=project_name)
class QuizModel(db.Model):
__tablename__ = 'quiz'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
start_date = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
final_date = db.Column(db.DateTime, nullable=False)
num_of_questions = db.Column(db.Integer, nullable=False, default=1)
grade = db.Column(db.Float, nullable=False, default=0)
# Relationships
subject_id = db.Column(db.Integer,
db.ForeignKey('subject.id'),
nullable=False)
professor_id = db.Column(db.String(11),
db.ForeignKey('professor.id'),
nullable=False)
questions = db.relationship('QuestionModel',
secondary=quiz_question,
lazy='select',
backref=db.backref('quiz', lazy='select'))
def __init__(self, start_date: datetime, final_date: datetime,
num_of_questions: int, grade: float, subject_id: int,
professor_id: str):
self.start_date = start_date
self.final_date = final_date
self.num_of_questions = num_of_questions
self.grade = grade
self.subject_id = subject_id
self.professor_id = professor_id
class PurchaseTransfer(db.Model):
""" A record of a purchase being transferred from one user to another. """
__tablename__ = 'purchase_transfer'
id = db.Column(db.Integer, primary_key=True)
purchase_id = db.Column(db.Integer,
db.ForeignKey('purchase.id'),
nullable=False)
to_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
from_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
purchase = db.relationship(Purchase,
backref=db.backref("transfers", cascade="all"))
def __init__(self, purchase, to_user, from_user):
if to_user.id == from_user.id:
raise PurchaseTransferException(
'"From" and "To" users must be different.')
super().__init__(purchase=purchase,
to_user_id=to_user.id,
from_user_id=from_user.id)
def __repr__(self):
return "<Purchase Transfer: %s from %s to %s on %s>" % (
self.ticket_id, self.from_user_id, self.to_user_id, self.timestamp)
class User(AuditableMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
login = db.Column(db.String(255), unique=True,
nullable=False)
password = db.Column(db.String(300))
email = db.Column(db.Unicode(300))
fullname = db.Column(db.Unicode(255),
default=u'')
last_sign_in = db.Column(db.DateTime)
status = db.Column(db.String(1), default=ACTIVE_USER,
nullable=False)
roles = db.relationship(Role, secondary='users_roles', lazy='joined',
backref=db.backref('users', lazy='dynamic'))
def __init__(self, login, password=None, **kwargs):
self.login = to_unicode(login)
self.password = password
kwargs.setdefault('fullname', u'')
db.Model.__init__(self, **kwargs)
@classmethod
def by_login(cls, login):
login = to_unicode(login)
return db.query(cls).filter(cls.login == login).first()
@property
def is_active(self):
"""Returns `True` if the user is active."""
return self.status == ACTIVE_USER
def add_role(self, name):
"""Adds a role (by name) to the user."""
role = Role.by_name(name)
if not role:
role = Role(name)
db.add(role)
if not role in self.roles:
self.roles.append(role)
def remove_role(self, name):
"""Remove a role (by name) from the user."""
role = Role.by_name(name)
if not role:
return
if role in self.roles:
self.roles.remove(role)
def __repr__(self):
return '<%s %s (%s)>' % (self.__class__.__name__,
self.fullname.encode('utf8') or '?', self.login.encode('utf8'))
class Volunteer(db.Model):
id = db.Column(db.Integer, primary_key=True)
fname = db.Column(db.String(80))
lname = db.Column(db.String(100))
phone_numbers = db.relationship('PhoneNumber', lazy='subquery', backref=db.backref('volunteer', lazy=True))
areas = db.relationship('Area', secondary=areas_volunteers, lazy='subquery',
backref=db.backref('volunteers', lazy=True))
species = db.relationship('FosterSpecies', secondary=volunteers_species, lazy='subquery',
backref=db.backref('volunteers', lazy=True))
last_contacted = db.Column(db.DateTime, index=True, default=datetime.utcnow)
active = db.Column(db.Boolean, default=True)
black_listed = db.Column(db.Boolean, default=False)
notes = db.Column(db.String(500), nullable=True)
def __repr__(self):
return '<Volunteer %r>' % self.fname+' '+self.lname
class User(UserMixin, db.Model):
"""
User model for reviewers.
"""
__tablename__ = 'user'
id = Column(Integer, autoincrement=True, primary_key=True)
active = Column(Boolean, default=True)
username = Column(String(200), unique=True)
email = Column(String(200), unique=True)
password = Column(String(200), default='')
admin = Column(Boolean, default=False)
poweruser = Column(Boolean, default=False)
about_me = db.Column(db.String(140))
register_in = db.Column(db.DateTime, default=datetime.now)
last_seen = db.Column(db.DateTime, default=datetime.now)
ratings = db.relationship('Rating', backref='user')
reviews = db.relationship('Review', backref='user')
lists = db.relationship('List', backref='user')
followed = db.relationship('User',
secondary=followers,
primaryjoin=(followers.c.follower_id == id),
secondaryjoin=(followers.c.followed_id == id),
backref=db.backref('followers', lazy='dynamic'),
lazy='dynamic')
def is_active(self):
"""
Returns if user is active.
"""
return self.active
def is_admin(self):
"""
Returns if user is admin.
"""
return self.admin
def avatar(self, size):
digest = md5(self.email.lower().encode('utf-8')).hexdigest()
return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(
digest, size)
def follow(self, user):
if not self.is_following(user):
self.followed.append(user)
def unfollow(self, user):
if self.is_following(user):
self.followed.remove(user)
def is_following(self, user):
return self.followed.filter(
followers.c.followed_id == user.id).count() > 0
def followed_review(self):
followed = Review.query.join(
followers, (followers.c.followed_id == Review.user_id)).filter(
followers.c.follower_id == self.id)
own = Review.query.filter_by(user_id=self.id)
return followed.union(own).order_by(Review.timestamp.desc())
class Area(db.Model):
area = db.Column(db.String(80), primary_key=True)
# OneToMany connection with Clinic. Connection with Volunteer is ManyToMany and defined with helper table
clinics = db.relationship('Clinic', backref=db.backref('areas', lazy='subquery'), lazy=True, )
def __repr__(self):
return self.area
class Guides(db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
name = db.Column(db.String(100))
done = db.Column(db.Boolean, default=False, index=True)
info = db.Column(db.PickleType())
time_lapse = db.Column(db.String(50))
doc_id = db.Column(db.Integer, db.ForeignKey('doctor.id'))
patients = db.relationship('User',
backref=db.backref('guides'),
secondary=patients)
@staticmethod
def insert_guides():
guides = {
"Pain Medication": ['Acetaminophen (Tylenol)', 'hours=4'],
"Zinc Supplement": ['Cold-Eeze lozenges', 'hours=4'],
"Vitamin C": ['Vitamin-C', 'days=1']
}
for g in guides:
guide = Guides.query.filter_by(name=g).first()
if guide is None:
guide = Guides(name=g,
info=guides[g][0],
time_lapse=guides[g][1])
db.session.add(guide)
db.session.commit()
class User(db.Model, UserMixin):
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)
image_file = db.Column(db.String(20),
unique=False,
nullable=False,
default="default.jpg")
password = db.Column(db.String(60), nullable=False)
posts = db.relationship('Post', backref=db.backref('author', lazy=True))
def get_reset_token(self, expire_sec=1800):
s = Serializer(app.config['SECRET_KEY'], expire_sec)
return s.dumps({'user_id': self.id}).decode('utf-8')
@staticmethod
def verify_reset_token(token):
s = Serializer(app.config['SECRET_KEY'])
try:
user_id = s.loads(token)['user_id']
return User.query.get(user_id)
except:
return None
def __repr__(self):
return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class SurveyQuestion(db.Model):
__tablename__ = 'survey_questions'
id = db.Column(db.Integer, primary_key=True)
cid = db.Column(db.Integer, db.ForeignKey('survey_categories.id'))
category = db.relationship('SurveyCategory',
backref=db.backref('questions', lazy='dynamic'))
question = db.Column(db.String(128), nullable=False)
year = db.Column(db.String(4), nullable=False)
class SurveyAnswer(db.Model):
__tablename__ = 'survey_answers'
id = db.Column(db.Integer, primary_key=True)
question_id = db.Column(db.String(128), nullable=False)
year = db.Column(db.String(4), nullable=False)
qid = db.Column(db.Integer, db.ForeignKey('survey_questions.id'))
question = db.relationship('SurveyQuestion',
backref=db.backref('answers', lazy='dynamic'))
class StudentCheckInRecord(db.Model):
__tablename__ = 'student_check_in_records'
id = db.Column('id', db.Integer(), primary_key=True)
stud_id = db.Column('stud_id', db.ForeignKey('students.id'))
student = db.relationship('Student',
backref=db.backref('check_in_records'))
classchk_id = db.Column('classchk_id',
db.Integer(),
db.ForeignKey('class_check_in.id'),
nullable=False)
classchk = db.relationship('ClassCheckIn',
backref=db.backref('student_records'))
check_in_time = db.Column('checkin',
db.DateTime(timezone=True),
nullable=False)
check_in_status = db.Column('status', db.String())
elapsed_mins = db.Column('elapsed_mins', db.Integer())
class District(db.Model):
__tablename__ = 'districts'
id = db.Column('id', db.Integer(), primary_key=True)
name = db.Column('name', db.String(40), nullable=False)
code = db.Column('code', db.String(), nullable=False)
province_id = db.Column(db.Integer(), db.ForeignKey('provinces.id'))
subdistricts = db.relationship('Subdistrict',
backref=db.backref('district'))
class Products(db.Model):
__tablename__ = 'products'
products_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
group = db.Column(db.String(30), nullable=False)
stock_quantity = db.Column(db.Integer, default=0)
price = db.Column(db.Integer, default=0)
ordering = db.relationship('Invoices', secondary=orders, backref=db.backref('invoicing'), lazy='dynamic')
product_qty = db.relationship('Quantities', backref='product', lazy=True)
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='CASCADE'),
nullable=False)
user = db.relationship('User', backref=db.backref('comment_set'))
content = db.Column(db.Text(), nullable=False)
create_date = db.Column(db.DateTime(), nullable=False)
modify_date = db.Column(db.DateTime(), nullable=True)
usercontent_id = db.Column(db.Integer,
db.ForeignKey('usercontent.id',
ondelete='CASCADE'),
nullable=True)
usercontent = db.relationship('Usercontent',
backref=db.backref('comment_set'))
voter = db.relationship('User',
secondary=comment_like_voter,
backref=db.backref('comment_voter_set'))
class Refund(db.Model):
__versioned__ = {}
__tablename__ = "refund"
id = db.Column(db.Integer, primary_key=True)
payment_id = db.Column(db.Integer,
db.ForeignKey("payment.id"),
nullable=False)
provider = db.Column(db.String, nullable=False)
amount_int = db.Column(db.Integer, nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
purchases = db.relationship("Purchase",
backref=db.backref("refund", cascade="all"))
__mapper_args__ = {"polymorphic_on": provider}
def __init__(self, payment, amount):
self.payment_id = payment.id
self.payment = payment
self.amount = amount
@classmethod
def get_export_data(cls):
if cls.__name__ == "Refund":
# Export stats for each refund type separately
return {}
purchase_counts = (cls.query.outerjoin(cls.purchases).group_by(
cls.id).with_entities(func.count("Ticket.id")))
data = {
"public": {
"refunds": {
"counts": {
"timestamp_week":
export_intervals(cls.query, cls.timestamp, "week",
"YYYY-MM-DD"),
"purchases":
bucketise(purchase_counts, [0, 1, 2, 3, 4]),
"amounts":
bucketise(
cls.query.with_entities(cls.amount_int / 100),
[0, 10, 20, 30, 40, 50, 100, 150, 200],
),
}
}
},
"tables": ["refund"],
}
return data
@property
def amount(self):
return Decimal(self.amount_int) / 100
@amount.setter
def amount(self, val):
self.amount_int = int(val * 100)
class Refund(db.Model):
__versioned__ = {}
__tablename__ = 'refund'
id = db.Column(db.Integer, primary_key=True)
payment_id = db.Column(db.Integer,
db.ForeignKey('payment.id'),
nullable=False)
provider = db.Column(db.String, nullable=False)
amount_int = db.Column(db.Integer, nullable=False)
timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
purchases = db.relationship('Purchase',
backref=db.backref('refund', cascade='all'))
__mapper_args__ = {'polymorphic_on': provider}
def __init__(self, payment, amount):
self.payment_id = payment.id
self.payment = payment
self.amount = amount
@classmethod
def get_export_data(cls):
if cls.__name__ == 'Refund':
# Export stats for each refund type separately
return {}
purchase_counts = cls.query.outerjoin(cls.purchases).group_by(
cls.id).with_entities(func.count('Ticket.id'))
data = {
'public': {
'refunds': {
'counts': {
'timestamp_week':
export_intervals(cls.query, cls.timestamp, 'week',
'YYYY-MM-DD'),
'purchases':
bucketise(purchase_counts, [0, 1, 2, 3, 4]),
'amounts':
bucketise(
cls.query.with_entities(cls.amount_int / 100),
[0, 10, 20, 30, 40, 50, 100, 150, 200]),
},
},
},
'tables': ['refund'],
}
return data
@property
def amount(self):
return Decimal(self.amount_int) / 100
@amount.setter
def amount(self, val):
self.amount_int = int(val * 100)
