class Calendar(db.Model):
__tablename__ = 'Calendar'
id = db.Column(db.Integer, primary_key=True)
property_id = db.Column(db.Integer, db.ForeignKey('Property.id'), nullable=False)
system_id = db.Column(db.Integer, db.ForeignKey('Dir_system.id'), nullable=False)
availability = db.Column(db.String(30))
price = db.Column(db.Integer)
currency = db.Column(db.String(30))
start_date = db.Column(db.String(30))
end_date = db.Column(db.String(30))
def __repr__(self):
return '<Calendar {}, {}>'.format(self.id,
self.property_id)
formater={
'id': fields.Integer,
'property_id': fields.Integer,
'system_id': fields.Integer,
'availability': fields.String,
'price': fields.Integer,
'currency': fields.String,
'start_date': fields.String,
'end_date': fields.String,
}
@staticmethod
@marshal_with(formater)
def calendar_by_json(calendar):
return calendar
class Category(Model):
id = Column(db.Integer, primary_key=True)
name = Column(db.String(255))
url_name = Column(
db.String(255),
unique=True,
default=lambda context: urlify(context.current_parameters['name']))
parent_id = Column(db.Integer, db.ForeignKey('category.id'), default=None)
parent = relationship('Category',
remote_side=[id],
backref=db.backref('children', lazy='dynamic'))
additional_fields = Column(TextPickleType(), default='', nullable=False)
@property
def selfApiUrl(self):
return url_for('api.{}'.format(self.__table__.name),
url_name=self.url_name,
_external=True)
# Returns self id and all descendants' ids in a list
def getTreeIds(self):
return list(
itertools.chain([self.id],
*[child.getTreeIds() for child in self.children]))
@property
def tasks_query(self):
return self.get_tasks(just_query=True)
def get_tasks(self, just_query=False):
from project.modules.task import Task
cat_ids = self.getTreeIds()
query = Task.query.filter(Task.category_id.in_(cat_ids))
if just_query:
return query
return query.all()
@property
def doers_query(self):
return self.get_doers(just_query=True)
def get_doers(self, just_query=False):
from project.modules.user import User
cat_ids = self.getTreeIds()
query = User.query.filter(
User.task_categories.any(Category.id.in_(cat_ids)))
if just_query:
return query
return query.all()
@property
def isSubCategory(self):
return self.parent and self.parent.url_name != 'all'
@property
def isSuperCategory(self):
return self.url_name == 'all' or self.parent == None
class UserContact(Model):
id = Column(db.Integer, primary_key=True)
type = Column(db.String(64), nullable=False)
value = Column(db.String(255), nullable=False)
owner_id = Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
owner = relationship('User',
backref=db.backref('contacts', lazy='dynamic'),
uselist=False)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), nullable=False)
email = db.Column(db.String(64), nullable=False)
password = db.Column(db.String(128), nullable=False)
created_at = db.Column(db.DateTime, nullable=False, default=datetime.now)
class DataSystem(db.Model):
__tablename__ = 'Data_system'
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('User.id'))
system_id = db.Column(db.Integer,
db.ForeignKey('Dir_system.id'),
nullable=False)
token = db.Column(db.String(120))
name_slug = db.Column(db.String(120))
class UloginData(Model):
id = Column(db.Integer, primary_key=True)
user_id = Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = relationship('User',
foreign_keys=[user_id],
backref=db.backref('social_identities',
lazy='dynamic'),
uselist=False)
network = Column(db.String(64), nullable=False)
identity = Column(db.String(160), nullable=False)
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True, nullable=False)
firstname = db.Column(db.String(30), nullable=False)
lastname = db.Column(db.String(30), nullable=False)
username = db.Column(db.String(30), nullable=False, unique=True)
email = db.Column(db.String(40), nullable=False, unique=True)
password = db.Column(db.String(128), nullable=False)
time_created = db.Column(db.DateTime(timezone=True),
server_default=func.now())
time_updated = db.Column(db.DateTime(timezone=True), onupdate=func.now())
def __init__(self, firstname, lastname, username, email, password):
self.firstname = firstname
self.lastname = lastname
self.username = username
self.email = email
self.password = password
@staticmethod
def get(user_id=None, username=None):
if user_id:
return User.query.filter_by(id=user_id).first()
elif username:
return User.query.filter_by(username=username).first()
return None
def set_password(self, new_pass):
new_hash = pwd_context.hash(new_pass)
self.password = new_hash
def verify_password(self, password):
return pwd_context.verify(password, self.password)
def generate_auth_token(self, expiration=600):
s = TimedJSONWebSignatureSerializer(os.environ.get("SECRET_KEY"),
expires_in=expiration)
return s.dumps({'id': self.id})
@staticmethod
def verify_auth_token(token):
s = TimedJSONWebSignatureSerializer(os.environ.get("SECRET_KEY"), )
try:
data = s.loads(token)
except SignatureExpired:
return None # valid token, but expired
except BadSignature:
return None # invalid token
user = User.get(user_id=data['id'])
return user
def __repr__(self):
return '{0} {1}: {2}'.format(self.firstname, self.lastname, self.email)
class User(db.Model):
__tablename__ = "users"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128), unique=True, nullable=False)
password_hash = db.Column(db.String(256), nullable=False)
def __init__(self, username, password):
self.username = username
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
class User(db.Model):
__tablename__ = 'TBL_TEST'
SEQ = db.Column(db.Integer, primary_key=True)
USERNAME = db.Column(db.String(80), nullable=False)
NUMBER = db.Column(db.Integer, nullable=False)
def __repr__(self):
return '<User %r>' % self.USERNAME
class MobileConfirmation(Model):
id = Column(db.Integer, primary_key=True)
code = Column(db.String(32), nullable=False)
user_id = Column(db.Integer, db.ForeignKey('user.id'))
user = relationship('User', foreign_keys=[user_id], uselist=False)
created_at = Column(db.DateTime, default=datetime.datetime.utcnow)
class Property(db.Model):
__tablename__ = 'Property'
id = db.Column(db.Integer, primary_key=True)
system_id = db.Column(db.Integer,
db.ForeignKey('Dir_system.id'),
nullable=False)
inner_id = db.Column(db.Integer, nullable=False)
name = db.Column(db.String(120), nullable=False)
country = db.Column(db.String(120))
city = db.Column(db.String(120))
district = db.Column(db.String(120))
zip_code = db.Column(db.String(30))
currency = db.Column(db.String(30))
photo_url = db.Column(db.String(255))
price = db.Column(db.Integer)
min_stay = db.Column(db.Integer)
number_of_guests = db.Column(db.Integer)
size = db.Column(db.Integer)
flat_id = db.Column(db.Integer, db.ForeignKey('Flat.id'))
local_user_id = db.Column(db.Integer, db.ForeignKey('User.id'))
def __repr__(self):
return '<Property {}>'.format(self.name)
class Flat(db.Model):
__tablename__ = 'Flat'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(120), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('User.id'))
def __repr__(self):
return '<Flat {}>'.format(self.name)
class Todo(db.Model):
__tablename__ = 'todos'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
name = db.Column(db.String(128), nullable=False)
done = db.Column(db.Boolean(), default=False, nullable=False)
def __init__(self, name, done):
self.name = name
self.done = done
class Todo(db.Model):
__tablename__ = 'todo'
now = datetime.today()
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
contents = db.Column(db.String(256))
deadline = db.Column(db.Date, nullable=False, default=now.date())
priority = db.Column(db.Integer, default=3)
state = db.Column(db.Integer, default=0)
created = db.Column(db.DateTime, nullable=False, default=datetime.now)
updated = db.Column(db.DateTime, nullable=False, default=datetime.now, onupdate=datetime.now)
def __repr__(self):
return 'Todo(id={id},name={name},contents={contents},deadline={deadline},priority={priority},state={state}'\
.format(id=self.id, name=self.name, contents=self.contents, deadline=self.deadline, priority=self.priority, state=self.state)
class InfoPage(Model):
id = Column(db.Integer, primary_key=True)
url_name = Column(
db.String(255),
unique=True,
default=lambda context: urlify(context.current_parameters['title']))
text = Column(db.Text, nullable=False)
title = Column(db.Text(4096), nullable=False)
listed = Column(db.Boolean, default=True)
sort_order = Column(db.Integer, default=1, nullable=False)
class User(db.Model):
__tablename__ = 'User'
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(120))
last_name = db.Column(db.String(120))
email = db.Column(db.String(255))
password = db.Column(db.String(120))
code_recovery = db.Column(db.String(30), nullable=True)
date_code_recovery = db.Column(db.Date, nullable=True)
def __repr__(self):
return '<User {}>'.format(self.first_name)
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
class Photo(db.Model):
__tablename__ = 'Photo'
id = db.Column(db.Integer, primary_key=True)
file_name = db.Column(db.String(80))
user_id = db.Column(db.Integer, db.ForeignKey('User.id'), nullable=False)
property_id = db.Column(db.Integer, db.ForeignKey('Property.id'))
def __repr__(self):
return '<Photo {}>'.format(self.file_name)
class Task(Model):
class Status:
created = 'created'
assigned = 'assigned'
completed = 'completed'
id = Column(db.Integer, primary_key=True)
title = Column(db.String(255), nullable=False)
description = Column(db.Text, nullable=False)
created_at = Column(db.DateTime, default=datetime.datetime.utcnow)
due = Column(db.DateTime, nullable=False)
customer_id = Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
customer = relationship('User',
foreign_keys=[customer_id],
backref=db.backref('created_tasks',
lazy='dynamic'),
uselist=False)
category_id = Column(db.Integer,
db.ForeignKey('category.id'),
nullable=False)
category = relationship('Category',
backref=db.backref('tasks', lazy='dynamic'),
uselist=False)
contacts = Column(TextPickleType(), nullable=False)
status = Column(db.String(64), nullable=False, default='created')
addresses = Column(TextPickleType(), nullable=False)
# None means "let the doer decide"
reward = Column(db.Numeric(precision=15, scale=2), default=None)
doer_id = Column(db.Integer, db.ForeignKey('user.id'))
doer = relationship('User',
foreign_keys=[doer_id],
backref=db.backref('assigned_tasks', lazy='dynamic'),
uselist=False)
additional_data = Column(TextPickleType(), default='', nullable=False)
class TrustedPerson(Model):
id = Column(db.Integer, primary_key=True)
full_name = Column(db.Text(512), nullable=False)
description = Column(db.Text, nullable=False)
phone = Column(db.String(64), nullable=False)
user_id = Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
user = relationship('User',
foreign_keys=[user_id],
backref=db.backref('trusted_persons', lazy='dynamic'),
uselist=False)
class Rental(db.Model):
__tablename__ = 'Rental'
id = db.Column(db.Integer, primary_key=True)
flat_id = db.Column(db.Integer, db.ForeignKey('Flat.id'), nullable=False)
user_name = db.Column(db.String(30))
phone_number = db.Column(db.String(30))
guests = db.Column(db.Integer)
from_date = db.Column(db.String(30))
to_date = db.Column(db.String(30))
from_time = db.Column(db.String(30))
to_time = db.Column(db.String(30))
def __repr__(self):
return '<Rental {}, user_name={} nights={}>'.format(self.id,
self.user_name,
self.nights)
formater = {
'id': fields.Integer,
'flat_id': fields.Integer,
'user_name': fields.String,
'phone_number': fields.String,
'guests': fields.Integer,
'from_date': fields.String,
'to_date': fields.String,
'from_time': fields.String,
'to_time': fields.String,
}
@staticmethod
@marshal_with(formater)
def rental_by_json(rental):
return rental
class Customers(db.Model):
__tablename__ = "customers"
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(128), unique=True, nullable=False)
dob = db.Column(db.Date, nullable=False)
updated_at = db.Column(db.DateTime, nullable=False)
def __init__(self, name, dob, updated_at):
self.name = name
self.dob = dob
self.updated_at = updated_at
class GuestInfo(db.Model):
__tablename__ = 'GuestInfo'
id = db.Column(db.Integer, primary_key=True)
calendar_id = db.Column(db.Integer, db.ForeignKey('Calendar.id'), nullable=False)
system_id = db.Column(db.Integer, nullable=False)
user_name = db.Column(db.String(30))
phone_number = db.Column(db.String(30))
guests = db.Column(db.Integer)
nights = db.Column(db.Integer)
total_cost = db.Column(db.Integer)
currency = db.Column(db.String(30))
from_time = db.Column(db.String(30))
to_time = db.Column(db.String(30))
def __repr__(self):
return '<GuestInfo {}, {} user_name={} nights={}>'.format(self.id,
self.calendar_id,
self.user_name,
self.nights)
formater = {
'id': fields.Integer,
'calendar_id': fields.Integer,
'user_name': fields.String,
'phone_number': fields.String,
'guests': fields.Integer,
'nights': fields.Integer,
'total_cost': fields.String,
'currency': fields.String,
}
@staticmethod
@marshal_with(formater)
def guest_by_json(renter):
return renter
class Upload(Model):
id = Column(db.Integer, primary_key=True)
created_at = Column(db.DateTime, default=datetime.datetime.utcnow)
author_id = Column(db.Integer, db.ForeignKey('user.id'))
author = relationship('User',
foreign_keys=[author_id],
backref=db.backref('uploads', lazy='dynamic'),
uselist=False)
type = Column(db.String(64), nullable=False)
role = Column(db.String(64), nullable=False)
hash = Column(db.String(64), nullable=False)
description = Column(db.String(512), nullable=False)
mime = Column(db.String(255), nullable=False)
file_path = Column(db.String(1024), nullable=False)
url = Column(db.String(1024), nullable=False)
class Role(Model):
id = Column(db.Integer, primary_key=True)
name = Column(db.String(255), nullable=False, unique=True)
class User(Model, UserMixin):
id = Column(db.Integer, primary_key=True)
full_name = Column(db.String(255), nullable=False)
registered_at = Column(db.DateTime, default=datetime.datetime.utcnow)
last_visited_at = Column(db.DateTime, default=None)
phone = Column(db.String(100))
email = Column(db.String(100), unique=False)
#created_tasks = relationship('Task', backref='customer', lazy='dynamic')
#assigned_tasks = relationship('Task', backref='doer', lazy='dynamic')
password = Column(db.String(64), nullable=False)
password_salt = Column(db.String(8), nullable=False)
city = Column(db.String(255), nullable=False)
active = Column(db.Boolean, default=True,
nullable=False) # Is account activated
email_confirmed = Column(db.Boolean, default=False,
nullable=False) # Is account activated
phone_confirmed = Column(db.Boolean, default=False,
nullable=False) # Is phone confirmed
doer = Column(db.Boolean, default=True,
nullable=False) # Does a user have doer rights
task_categories = relationship('Category',
secondary=category_to_doer,
backref=db.backref('doers', lazy='dynamic'))
balance = Column(db.Numeric(precision=15, scale=2), default=0)
avatar_id = Column(db.Integer, db.ForeignKey('upload.id'), nullable=True)
avatar = relationship('Upload', foreign_keys=[avatar_id], uselist=False)
rights = Column(db.String(100), nullable=False, default='user')
# deprecated
roles = db.relationship('Role',
secondary=role_to_user,
backref=db.backref('users', lazy='dynamic'))
age = Column(db.Integer)
about = Column(db.Text(2048), default='')
deleted = Column(db.Boolean, default=False, nullable=False)
_rating = Column('rating', db.Float, nullable=False, default=0.0)
def delete(self):
self.deleted = True
self.phone = '000000000'
self.email = '*****@*****.**'
self.rights = 'deleted'
try:
db.session.commit()
except:
db.session.rollback()
raise
@hybrid_property
def rating(self):
return self._rating
@rating.setter
def rating(self, value):
raise Exception(
'Please, use User.add_rating(rater, value) and User.remove_rating(rating_id) methods'
)
def make_doer(self):
self.doer = True
if self.balance == None:
self.balance = 0
try:
db.session.commit()
except:
db.session.rollback()
raise
def unmake_doer(self):
self.doer = False
try:
db.session.commit()
except:
db.session.rollback()
raise
def add_rating(self, rater, value):
rating = UserRating(owner=self, rater=rater, value=value)
try:
db.session.add(rating)
db.session.commit()
except:
db.session.rollback()
raise
self._rating = db.session.query(
func.avg(UserRating.value).label('average')).filter(
UserRating.owner_id == self.id).one()[0] or 0
def remove_rating(self, id):
rating = UserRating.query.get(id)
if rating == None:
raise Exception('No user rating with id ' + str(id))
try:
db.session.delete(rating)
db.session.commit()
except:
db.session.rollback()
raise
self._rating = db.session.query(
func.avg(UserRating.value).label('average')).filter(
UserRating.owner_id == self.id).one()[0] or 0
def is_active(self):
return self.active
def is_anonymous(self):
return False
def is_authenticated(self):
return True
def get_id(self):
return str(self.id)