def update_by_id(id, db_connection, data):
result = None
try:
db.session.query(BusinessOwner). \
filter(CarWashBusinessOwner.id == BusinessOwner.id). \
filter(CarWashBusinessOwner.id == User.id). \
filter(CarWashBusinessOwner.id == id). \
update(data, synchronize_session='fetch')
# AutoServiceBusinessOwner.query.filter_by(id=id).update(data)
# AutoServiceBusinessOwner.query.filter_by(id=id).update(data)
db_connection.session.commit()
logger.info('update user. ID: %s' % id)
params = {"user_id": id}
success = SuccessUpdate(status=200,
message=MessagesKeys.SUCCESS_UPDATE,
params=params)
# raise Exception()
result = True, success
except InvalidRequestError as error:
result = db_error_message(logger)
db_connection.session.rollback()
except:
result = db_error_message(logger)
db_connection.session.rollback()
return result
def _update_location(self):
try:
BusinessOwner.update_lng_lat(self.business_owner.id, self.business_owner.lng, self.business_owner.lat, db)
success = SuccessUpdate(status=200, message=MessagesKeys.SUCCESS_UPDATE)
result = True, success
except InvalidRequestError as error:
result = db_error_message(logger)
db.session.rollback()
except:
result = db_error_message(logger)
db.session.rollback()
return result
def find(limit=1, **kwargs):
res = None
try:
res = True, Company.query.filter_by(**kwargs).limit(limit).all()
except:
res = db_error_message(logger, message='InvalidRequestError')
return res
def find(limit=1, **kwargs):
res = None
try:
res = True, Administrator.query.filter_by(**kwargs).limit(limit).all()
except:
res = db_error_message(logger)
return res
def find_payment_type_by_id(type_id):
try:
result = True, PaymentType.query.filter(
PaymentType.id == type_id).first()
except:
result = db_error_message(logger)
return result
def add(self, db_connection):
result = None
try:
print(self)
db_connection.session.add(self)
db_connection.session.commit()
params = {
Keys.SUB_CATEGORY_ID: self.sub_category_id,
Keys.CODE: self.code,
Keys.BRAND_ID: self.brand_id,
Keys.COMPANY_ID: self.company_id,
Keys.SUPPLIER_ID: self.supplier_id
}
success = SuccessAddNewProduct(
status=200,
message=MessagesKeys.SUCCESS_ADD_NEW_PRODUCT,
params=params)
result = True, success
except IntegrityError as e:
ValidationError('Integrity error: {}'.format(e.args[0]))
except:
db_connection.session.rollback()
result = db_error_message(logger)
return result
def find_all_payable_job(car_owner_id):
try:
# results = db.session.query(Job). \
# join(CarProblem, CarProblem.job_id == Job.id). \
# join(ServicesDefinition, CarProblem.services_definition_id == ServicesDefinition.id). \
# filter(Job.payment_id.is_(None)). \
# filter(Job.car_owner_id == car_owner_id). \
# with_entities(Job.id, Job.car_id, Job.price, ServicesDefinition.pay, ServicesDefinition.service_grade,
# ServicesDefinition.service_category).all()
# job1 = db.session.query(Job) \
# .filter(Job.type.in_(['AutoService'])) \
# .filter(Job.car_owner_id == car_owner_id) \
# .filter(Job.payment_id.is_(None)).all()
# # print jobs
list_items = db.session.query(Job, Car, User) \
.filter(Job.car_owner_id == Car.car_owner_id) \
.filter(User.id == Job.business_owner_id) \
.filter(Job.type == 'AutoService') \
.filter(Job.car_owner_id == car_owner_id) \
.filter(Job.payment_id.is_(None)).all()
# items = set()
# for result in jobs:
# items.add(result)
# print jobs
result = SuccessListOfPayableJob(status=200,
message=MessagesKeys.SUCCESS_LIST,
params=list_items)
return True, result
except:
return db_error_message(logger)
def check_business_owner_order_list(business_owner_id):
try:
return OrderItem.query.filter(OrderItem.business_owner_id == business_owner_id). \
filter(OrderItem.accepted_number > 0). \
all()
except:
return db_error_message(logger)
def accept_deny_job(job,
data,
db_connection,
where_clause=None,
message=MessagesKeys.SUCCESS_ACCEPT_JOB):
result = True,
try:
query = Job.query.filter_by(id=job.id)
# if where_clause is not None:
# query = query.filter_by(where_clause)
query.update(data)
db_connection.session.commit()
if message == MessagesKeys.SUCCESS_ACCEPT_JOB:
result = True, SuccessAcceptJob(
status=200,
message=MessagesKeys.SUCCESS_ACCEPT_JOB,
params=None)
else:
result = True, SuccessDenyJob(
status=200,
message=MessagesKeys.SUCCESS_DENY_JOB,
params=None)
except:
result = db_error_message(global_logger)
return result
def update_by_id(id, db_connection, data):
result = None
try:
OrderItem.query.filter(OrderItem.id == id).update(data)
db_connection.session.commit()
logger.info('update question_sets. ID: %s' % id)
params = {Keys.ID: id}
success = SuccessUpdate(status=200, message=MessagesKeys.SUCCESS_UPDATE, params=params)
result = True, success
except InvalidRequestError as error:
result = db_error_message(logger)
db_connection.session.rollback()
except:
result = db_error_message(logger)
db_connection.session.rollback()
return result
def load_by_id(id):
res = None
try:
res = True, SubCategory.query.filter_by(id=id).all()
except:
res = db_error_message(logger, message='InvalidRequestError')
return res
def find_job_problems(job):
result = None
try:
result = True, CarProblem.query.filter(
CarProblem.job_id == job.id).all()
except:
False, db_error_message(logger)
return result
def is_added_before(code, supplier_id):
result = None
try:
result = Product.query.filter(Product.code == code).filter(
Product.supplier_id == supplier_id).first()
except:
result = db_error_message(logger, message='InvalidRequestError')
return result
def find_status(status_name):
result = True,
try:
status = Status.query.filter(Status.name == status_name).first()
result = True, status
except:
result = False, db_error_message(global_logger)
return result
def is_brand_and_company_match(company_id, brand_id):
result = None
try:
result = True, CompanyToBrand.query.filter(CompanyToBrand.company_id == company_id). \
filter(CompanyToBrand.brand_id == brand_id).first()
except:
result = db_error_message(logger, message='InvalidRequestError')
return result
def find_login(phone_number):
res = None
try:
res = True, User.query.filter(
User.phone_number == phone_number).first()
except:
res = db_error_message(logger)
return res
def find(limit=1, **kwargs):
res = None
try:
res = True, Supplier.query.filter_by(**kwargs).limit(limit).all()
except:
res = db_error_message(logger)
db.session.rollback()
return res
def update_record_from_dictionary(obj, data):
result = True,
try:
for property, value in data.iteritems():
setattr(obj, property, value)
result = True, obj
except AttributeError:
result = False, db_error_message(global_logger)
return result
def are_auto_type_and_auto_model_matched(auto_type_id, auto_model_id):
try:
res = AutoModel.query.filter(AutoModel.id == auto_model_id). \
filter(AutoModel.auto_types_id == auto_type_id).first()
# res = AutoModel.query.filter(AutoModel.id == auto_type_id). \
# filter(AutoModel.auto_types_id == auto_model_id).first()
except:
res = db_error_message(logger)
return res
def find_all():
try:
collection = AutoType.query.add_columns(AutoType.id, AutoType.name).all()
success = SuccessListAutoTypes(status=200, message=MessagesKeys.SUCCESS_LIST, params=collection)
res = True, success
except:
res = db_error_message(logger)
return res
def find_all_models_of_a_type():
try:
result = AutoType.query. \
all()
res = True, result
except:
res = False, db_error_message(logger)
return res
def find_status(status_name):
result = True,
try:
status = Payment.query.filter(Payment.name == status_name).first()
result = True, status
except:
db.session.rollback()
result = db_error_message(logger)
return result
def update(self, db_connection, data):
result = None
try:
Calendar.query.filter_by(id=self.id).update(data)
db_connection.session.commit()
logger.info('update business_owner. ID: %s' % self.id)
params = {Keys.ID: self.id}
success = SuccessUpdate(status=200,
message=MessagesKeys.SUCCESS_UPDATE,
params=params)
result = True, success
except InvalidRequestError as error:
result = db_error_message(logger, message='InvalidRequestError')
db_connection.session.rollback()
except:
result = db_error_message(logger)
db_connection.session.rollback()
return result
def update(self, db_connection, data):
result = None
try:
Administrator.query.filter_by(phone_number=self.phone_number).update(data)
user = Administrator.query.filter_by(phone_number=self.phone_number).first()
self.id = user.id
db_connection.session.commit()
logger.info('update admin. ID: %s' % self.id)
params = {"user_id": self.id}
success = SuccessUpdate(status=200, message=MessagesKeys.SUCCESS_UPDATE, params=params)
result = True, success
except InvalidRequestError as error:
result = db_error_message(logger)
db_connection.session.rollback()
except:
result = db_error_message(logger)
db_connection.session.rollback()
return result
def register_service_type(service_grade, service_type, db_):
try:
service_grade.service_types.append(service_type)
db_.session.commit()
return True, SuccessServiceTypeRegistration(
status=200,
message=MessagesKeys.SUCCESS_ADD_SERVICE_TYPE,
params=None)
except:
db_.session.rollback()
return db_error_message(logger)
def get_daily_purchase_list_of_supplier(supplier_id):
try:
import datetime
product_id = Product.query.filter(Product.supplier_id == supplier_id). \
with_entities(Product.id)
pending_id = SupplierStatus.query.filter(SupplierStatus.name == Keys.PENDING). \
with_entities(SupplierStatus.id).first()
today = datetime.datetime.now()
beginning = datetime.datetime(today.year, today.month, today.day, 0, 0, 0, 0)
list = OrderItem.query.filter(OrderItem.supplier_status_id.in_(pending_id)). \
filter(OrderItem.date_created < datetime.datetime.now()). \
filter(beginning < OrderItem.date_created). \
filter(OrderItem.product_id.in_(product_id)).all()
return True, list
except:
db_error_message(logger)
def update(self, db_connection, data):
result = None
try:
Car.query.filter_by(id=self.id).update(data)
db_connection.session.commit()
logger.info('update car. ID: %s' % self.id)
params = {"id": self.id}
success = SuccessUpdate(status=200, message=MessagesKeys.SUCCESS_UPDATE, params=params)
result = True, success
except InvalidRequestError as error:
result = db_error_message(logger, message='InvalidRequestError')
db_connection.session.rollback()
except IntegrityError as error:
result = db_error_message(logger, message= Result.language.DUPLICATED_CAR)
db_connection.session.rollback()
except:
result = db_error_message(logger)
db_connection.session.rollback()
return result
def check_supplier(phone_number):
result = None
try:
supplier_id = Supplier.query.filter(
Supplier.phone_number == phone_number).with_entities(
Supplier.id).first()
result = True, supplier_id[0]
except:
result = db_error_message(logger)
db.session.rollback()
return result
def find_all_not_finished_job():
try:
time_delta = timedelta(hours=12)
limited_time_to_follow_up_work = Jobs.start_schedule + time_delta
expected_time = expected_time_for_each_job(Jobs.start_schedule,
Jobs.finish_schedule)
calculate_real_time = calculate_real_time_to_finish_job(
Jobs.start_time, expected_time)
status_ids = Status.query. \
filter((Status.name == Keys.STATUS_ACCEPTED_BY_BUSINESS_OWNER) |
(Status.name == Keys.STATUS_START)). \
with_entities(Status.id). \
all()
not_start_status = Status.query. \
filter(Status.name == Keys.STATUS_ACCEPTED_BY_BUSINESS_OWNER). \
with_entities(Status.id). \
all()
list_unfinished1 = Jobs.query. \
filter(Jobs.status_id.in_(status_ids)). \
filter(Jobs.start_time is not None). \
filter(db.func.current_timestamp() > calculate_real_time). \
with_entities(Jobs.business_owner_id). \
all()
list_unfinished2 = Jobs.query. \
filter(Jobs.status_id.in_(not_start_status)). \
filter(limited_time_to_follow_up_work < db.func.current_timestamp()). \
with_entities(Jobs.business_owner_id). \
all()
list_unfinished_condition = Jobs.query. \
filter((Jobs.business_owner_id.in_(list_unfinished2)) | (Jobs.business_owner_id.in_(list_unfinished1))). \
with_entities(Jobs.business_owner_id). \
all()
query = db.session.query(Jobs). \
join(BusinessOwners, BusinessOwners.id == Jobs.business_owner_id). \
join(Car, Jobs.car_id == Car.id). \
filter(Jobs.business_owner_id.in_(list_unfinished_condition)). \
with_entities(BusinessOwners.name, BusinessOwners.phone_number, Car.plate_number, BusinessOwners.id). \
all()
ids = set()
for result in query:
ids.add(result)
return True, SuccessListOfUnfinishedJob(
status=200, message=MessagesKeys.SUCCESS_LIST, params=ids)
except:
return db_error_message(logger)
def cancel_job(job, data, db_connection):
result = True,
try:
Jobs.query.filter_by(id=job.id).update(data)
db_connection.session.commit()
result = True, SuccessCancelJob(
status=200,
message=MessagesKeys.SUCCESS_CANCEL_JOB,
params=None)
except:
result = db_error_message(logger)
return result
