def update_user(curr_user, id):
data = request.get_json()
if not curr_user.is_admin():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
user = User.query.get(id)
if not user:
return ResponseMessage(False, message="Invalid user id!").resp()
for k, v in data.items():
if k == 'branch':
if not Branch.query.filter_by(code=v).first():
raise Exception("Invalid branch code!")
if k == 'whse':
if not Warehouses.query.filter_by(whsecode=v).first():
raise Exception("Invalid warehouse code!")
if k == 'password':
user.hash_password(v)
else:
setattr(user, k, v)
db.session.commit()
user_schema = UserSchema(exclude=("password", "date_created",))
result = user_schema.dump(user)
return ResponseMessage(True, message="User data successfully updated!", data=result).resp()
except (exc.IntegrityError, pyodbc.IntegrityError) as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def get_all_users(curr_user):
# contains to filter
filt = []
data = request.args.to_dict()
for k, v in data.items():
if k == 'search':
filt.append(('username', 'like', f'%{v}%'))
elif k == 'branch':
if v:
filt.append((k, '==', v))
elif k == 'whse':
if v:
filt.append((k, '==', v))
else:
filt.append((k, '==', bool(int(v))))
try:
user_filter = BaseQuery.create_query_filter(User, filters={'and': filt})
user = db.session.query(User).filter(*user_filter). \
order_by(User.fullname.asc()).all()
user_schema = UserSchema(many=True, only=("id", "username", "fullname",))
result = user_schema.dump(user)
return ResponseMessage(True, count=len(result), data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def get_all_whse(curr_user):
try:
data = request.args.to_dict()
filt = []
if 'transtype' in data:
transtype = data['transtype']
if transtype.upper() == 'TRFR':
filt.append(('whsecode', '!=', curr_user.whse))
if 'branch' in data:
filt.append(('branch', '==', data['branch']))
if 'whsecode' in data:
filt.append(('whsecode', '==', data['whsecode']))
branch_filter = BaseQuery.create_query_filter(Warehouses,
filters={'and_': filt})
warehouses = db.session.query(Warehouses).filter(*branch_filter).all()
whse_schema = WarehouseSchema(many=True)
result = whse_schema.dump(warehouses)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def add_new_price_list(curr_user):
if not curr_user.is_admin():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
data = request.get_json()
data['created_by'] = curr_user.id
data['updated_by'] = curr_user.id
if PriceListHeader.query.filter_by(code=data['code']).first():
return ResponseMessage(False, message="Already exists!").resp(), 500
try:
price_list = PriceListHeader(**data)
db.session.add(price_list)
db.session.commit()
price_schema = PriceListHeaderSchema()
result = price_schema.dump(price_list)
return ResponseMessage(True,
message="Successfully added!",
data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def get_all_deposit(curr_user):
cust = request.args.get('customer')
status = request.args.get('status')
filt = []
if cust:
filt.append(('cust_code', 'like', f'%{cust}%'))
if status:
filt.append(('status', '==', status))
try:
# generate obj for query
dep_filter = BaseQuery.create_query_filter(Deposit,
filters={'and': filt})
dep = db.session.query(Deposit).filter(*dep_filter).all()
dep_schema = DepositSchema(many=True,
exclude=("date_created", "date_updated",
"created_by", "updated_by"))
result = dep_schema.dump(dep)
return ResponseMessage(True, count=len(result), data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def ar_confirm(curr_user):
if not curr_user.is_cashier() and not curr_user.is_admin(
) and not curr_user.is_manager():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
ids = request.args.get('ids').rstrip(']').lstrip('[')
ids = list(ids.split(','))
filt_sales_h = [('id', 'in', ids)]
sales_filt = BaseQuery.create_query_filter(
SalesHeader, filters={'and': filt_sales_h})
sales = SalesHeader.query.filter(*sales_filt).all()
success_ref = []
unsuccess_ref = []
for sale in sales:
if sale.confirm:
unsuccess_ref.append(sale.reference)
continue
sale.confirm = True
sale.confirm_by = curr_user.id
sale.date_confirm = datetime.now()
success_ref.append(sale.reference)
db.session.commit()
success_message = f"Confirm success transaction: {str(success_ref).rstrip(']').lstrip('[')}"
unsuccess_message = f"Confirm unsuccess transaction: {str(unsuccess_ref).rstrip(']').lstrip('[')}"
return ResponseMessage(True, message=f"{success_message}" if len(success_ref) > 0 else '' \
f" ,{unsuccess_message}" if len(unsuccess_ref) > 0 else '' + '.').resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def confirm_item_request(curr_user, id):
if not curr_user.is_admin() and not curr_user.is_manager():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
data = request.get_json()
confirm = data['confirm']
remarks = data['remarks'] if 'remarks' in data else ''
item_req = ItemRequest.query.get(id)
if not item_req:
raise Exception("Invalid id")
if item_req.confirm:
raise Exception("Already confirmed!")
item_req.confirm = confirm
item_req.remarks = remarks
item_req.date_updated = datetime.now()
item_req.updated_by = curr_user.id
db.session.commit()
return ResponseMessage(True, message='Successfully confirm').resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def create_cashout(curr_user):
if not curr_user.is_admin() and not curr_user.is_manager():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
data = request.get_json()
data['created_by'] = curr_user.id
data['updated_by'] = curr_user.id
obj = ObjectType.query.filter_by(code='CSHT').first()
series = Series.query.filter_by(whsecode=curr_user.whse,
objtype=obj.objtype).first()
if series.next_num + 1 > series.end_num:
raise Exception("Series number already in max!")
if not series:
raise Exception("Invalid Series")
# add to the header
data['series'] = series.id
data['seriescode'] = series.code
data['transnumber'] = series.next_num
data['reference'] = f"{series.code}-{obj.code}-{series.next_num}"
data['objtype'] = obj.objtype
cash_out = CashOut(**data)
# add plus 1 to series
series.next_num += 1
db.session.add_all([cash_out, series])
db.session.commit()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def count_for_payment_sales(curr_user):
try:
transdate = request.args.get('transdate')
for_payment = db.session.query(SalesHeader).filter(
and_(
func.cast(SalesHeader.transdate, DATE) == transdate,
or_(
and_(SalesHeader.confirm == True,
SalesHeader.transtype != 'CASH'),
and_(SalesHeader.confirm != True,
SalesHeader.transtype == 'CASH')),
SalesHeader.docstatus == 'O')).count()
for_confirmation = db.session.query(SalesHeader).filter(
and_(
func.cast(SalesHeader.transdate, DATE) == transdate,
SalesHeader.confirm != True, SalesHeader.transtype != 'CASH',
SalesHeader.docstatus == 'O')).count()
return ResponseMessage(True,
data={
"for_payment": for_payment,
"for_confirmation": for_confirmation
}).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def void_payment(curr_user, id):
if not curr_user.is_admin() and not curr_user.is_manager():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
payment = PayTransHeader.query.get(id)
# check if payment is not equal to close
if payment.docstatus != 'C':
# if not close then raise exception
raise Exception("Payment is already canceled!")
payment.docstatus = 'N'
payment.updated_by = curr_user.id
payment.date_updated = datetime.now()
db.session.commit()
pay_schema = PaymentHeaderSchema()
result = pay_schema.dump(payment)
return ResponseMessage(True,
message="Successfully canceled!",
data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def update_receive_sap_number(curr_user, id):
if not curr_user.is_admin() and not curr_user.is_can_add_sap():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
sap_number = request.json['sap_number']
receive = ReceiveHeader.query.get(id)
receive.sap_number = sap_number
receive.updated_by = curr_user.id
receive.date_updated = datetime.now()
row = ReceiveRow.query.filter(ReceiveRow.receive_id == id).all()
for i in row:
i.sap_number == sap_number
i.updated_by = curr_user.id
i.date_updated = datetime.now()
receive.docstatus = 'C'
db.session.commit()
return ResponseMessage(True, message='Successfully updated!').resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def new_salestype(curr_user):
if not curr_user.is_admin():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
data = request.get_json()
if SalesType.query.filter_by(code=data['code']).first():
return ResponseMessage(False,
message="Code already exist!").resp(), 401
try:
data['created_by'] = curr_user.id
data['updated_by'] = curr_user.id
salestype = SalesType(**data)
db.session.add(salestype)
db.session.commit()
stype_schema = SalesTypeSchema(exclude=("date_created",
"date_updated"))
result = stype_schema.dump(salestype)
return ResponseMessage(True,
message="Successfully added!",
data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def final_count_report(curr_user):
data = request.args.to_dict()
transdate = ''
filt = []
for k, v in data.items():
if k == 'whsecode':
if v:
filt.append((k, "==", v))
else:
filt.append(k, "==", curr_user.whse)
elif k == 'transdate':
if v:
transdate = v
else:
if v:
filt.append(k, "==", v)
try:
final_count = FinalInvCount.query. \
filter(func.cast(FinalInvCount.transdate, DATE) == transdate,
FinalInvCountRow.whsecode == curr_user.whse,).first()
if not final_count:
raise Exception("No final count transaction!")
fc_schema = FinalCountSchema()
result = fc_schema.dump(final_count)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def cancel_recv(curr_user, id):
if not curr_user.is_admin():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
# query the whse
whse = Warehouses.query.filter_by(whsecode=curr_user.whse).first()
if whse.is_cutoff():
return ResponseMessage(
False, message="Your warehouse cutoff is enable!").resp(), 401
data = request.get_json()
try:
receive = ReceiveHeader.query.get(id)
if receive.docstatus == 'N':
raise Exception("Already canceled!")
receive.docstatus = 'N'
receive.remarks = data['remarks']
receive.updated_by = curr_user.id
receive.date_updated = datetime.now()
db.session.commit()
return ResponseMessage(True, message='Successfully canceled!').resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def update_pullout_sap_num(curr_user):
if not curr_user.is_can_add_sap() and not curr_user.is_manager() and not curr_user.is_admin():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
sap_num = request.json['sap_number']
ids = json.loads(request.args.get('ids'))
pullout = PullOutHeader.query.filter(PullOutHeader.id.in_(ids)).all()
print(pullout)
for i in pullout:
if i.sap_number:
raise Exception(f'{i.reference} already have sap number!')
i.sap_number = sap_num
i.docstatus = 'C'
i.remarks = request.json['remarks'] if request.json['remarks'] else None
i.updated_by = curr_user.id
i.date_updated = datetime.now()
db.session.commit()
return ResponseMessage(True, message="Successfully updated!").resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f'{err}').resp(), 500
except Exception as err:
return ResponseMessage(False, message=f'{err}').resp(), 500
finally:
db.session.close()
def get_po_details(curr_user, id):
try:
pullout = PullOutHeader.query.get(id)
po_schema = PullOutHeaderSchema(only=(
"id",
"series",
"seriescode",
"transnumber",
"objtype",
"transdate",
"reference",
"remarks",
"docstatus",
"sap_number",
"created_by",
"updated_by",
"date_created",
"date_updated",
"confirm",
"row",
))
result = po_schema.dump(pullout)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def get_all_sales_type(curr_user):
try:
data = request.args.to_dict()
filt = []
filt_in = []
for k, v in data.items():
filt.append((k, '==', v))
if curr_user.is_sales():
if curr_user.is_ar_sales():
filt_in.append('AR Sales')
if curr_user.is_cash_sales():
filt_in.append('CASH')
if curr_user.is_agent_sales():
filt_in.append('Agent AR Sales')
if not curr_user.is_admin() and not curr_user.is_manager():
filt.append(('code', 'in', filt_in))
sales_filter = BaseQuery.create_query_filter(SalesType,
filters={'and': filt})
stype = db.session.query(SalesType).filter(*sales_filter).all()
stype_schema = SalesTypeSchema(many=True)
result = stype_schema.dump(stype)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def new_discount_type(curr_user):
if not curr_user.is_admin():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
data = request.get_json()
# add to data
data['created_by'] = curr_user.id
data['updated_by'] = curr_user.id
disc_type = DiscountType(**data)
db.session.add(disc_type)
db.session.commit()
disc_type_schema = DiscountTypeSchema(only=("id", "code",
"description", "discount"))
result = disc_type_schema.dump(disc_type)
return ResponseMessage(True,
message=f"Successfully added!",
data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def create_customer(curr_user):
if not curr_user.is_admin():
return jsonify({
"success": "false",
"message": "You're not authorized!"
}), 400
data = request.get_json()
data['created_by'] = curr_user.id
data['updated_by'] = curr_user.id
if Customer.query.filter_by(code=data['code']).first() or \
Customer.query.filter_by(code=data['code'], whse=data['whse']).first():
return ResponseMessage(
False, message="Customer code already exist!").resp(), 400
try:
cust = Customer(**data)
db.session.add(cust)
db.session.commit()
cust_schema = CustomerSchema()
result = cust_schema.dump(cust)
return ResponseMessage(True,
message="Successfully added!",
data=result).resp()
except Exception as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp(), 500
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def payment_type_new(curr_user):
if not curr_user.is_admin():
raise Exception("Unauthorized user!")
data = request.get_json()
try:
ptype = PaymentType(**data)
ptype.created_by = curr_user.id
ptype.updated_by = curr_user.id
db.session.add(ptype)
db.session.commit()
ptype_schema = PaymentTypeSchema()
result = ptype_schema.dump(ptype)
return ResponseMessage(True,
message="Successfully added!",
data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}"), 500
except Exception as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}"), 500
finally:
db.session.close()
def get_whseinv(curr_user):
try:
whseinv = db.session.query(
WhseInv.item_code, WhseInv.quantity,
PriceListRow.price, Items.uom).join(
Warehouses,
WhseInv.warehouse == Warehouses.whsecode).outerjoin(
Items, Items.item_code == WhseInv.item_code).outerjoin(
PriceListRow,
and_(PriceListRow.pricelist_id == Warehouses.pricelist,
PriceListRow.item_code ==
WhseInv.item_code)).filter(
and_(WhseInv.warehouse == curr_user.whse,
WhseInv.quantity > 0)).order_by(
WhseInv.item_code,
WhseInv.quantity.desc()).all()
whseinv_schema = WhseInvSchema(many=True)
result = whseinv_schema.dump(whseinv)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def item_req_sap_update(curr_user, id):
if not curr_user.is_admin() and not curr_user.is_can_add_sap():
return ResponseMessage(False, message="Unauthorized user!").resp(), 401
try:
data = request.get_json()
sap_number = data['sap_number']
remarks = data['remarks'] if 'remarks' in data else ''
item_req = ItemRequest.query.get(id)
if not item_req.confirm:
raise Exception("Please confirm it first!")
item_req.sap_number = sap_number
item_req.remarks = remarks
item_req.docstatus = 'C'
item_req.date_updated = datetime.now()
item_req.updated_by = curr_user.id
db.session.commit()
return ResponseMessage(True, message='Successfully confirm').resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
finally:
db.session.close()
def create_uom(curr_user):
user = curr_user
if not user.is_admin():
return jsonify({"success": False, "message": "You're not authorized!"})
code = request.args.get('code')
description = request.args.get('description')
if UnitOfMeasure.query.filter_by(code=code).first():
return ResponseMessage(False,
message="UoM code is already exists!").resp()
try:
uom = UnitOfMeasure(code=code,
description=description,
created_by=user.id,
updated_by=user.id)
db.session.add(uom)
db.session.commit()
uom_schema = UomSchema(only=("id", "code", "description"))
result = uom_schema.dump(uom)
return ResponseMessage(True,
message="Successfully added!",
data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp()
except Exception as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp()
finally:
db.session.close()
def update_uom(curr_user, id):
if not curr_user.is_admin():
return ResponseMessage(False, message="You're not authorized!")
code = request.args.get('code')
description = request.args.get('description')
try:
uom = UnitOfMeasure.query.get(id)
if not uom:
return ResponseMessage(False, message="Invalid uom id!")
uom.code = code
uom.description = description
uom.date_updated = datetime.now()
uom.updated_by = curr_user.id
db.commit()
uom_schema = UomSchema()
result = uom_schema.dump(uom)
return ResponseMessage(True,
message="Successfully updated!",
data=result).resp()
except (exc.IntegrityError, pyodbc.IntegrityError) as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp()
except Exception as err:
db.session.rollback()
return ResponseMessage(False, message=f"{err}").resp()
finally:
db.session.close()
def get_sales_details(curr_user, id):
try:
sales = SalesHeader.query.get(id)
sales_schema = SalesHeaderSchema()
result = sales_schema.dump(sales)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def get_payment_type_details(curr_user, id):
try:
ptype = PaymentType.query.get(id)
ptype_schema = PaymentTypeSchema()
result = ptype_schema.dump(ptype)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp()
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp()
def get_all_custtype(curr_user):
try:
cust_type = CustomerType.query.all()
custtype_schema = CustTypeSchema(many=True)
result = custtype_schema.dump(cust_type)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def get_deposit_details(curr_user, id):
try:
dep = Deposit.query.get(id)
dep_schema = DepositSchema()
result = dep_schema.dump(dep)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, exc.IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def get_whse(curr_user, id):
try:
whse = Warehouses.query.get(id)
whse_schema = WarehouseSchema()
result = whse_schema.dump(whse)
return ResponseMessage(True, data=result).resp()
except (pyodbc.IntegrityError, IntegrityError) as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
def get_objtype(curr_user, id):
try:
obj = ObjectType.query.get(id)
if not obj:
return ResponseMessage(
False, message=f"Invalid object type id!").resp(), 401
obj_schema = ObjectTypeSchema()
result = obj_schema.dump(obj)
return ResponseMessage(True, data=result).resp()
except Exception as err:
return ResponseMessage(False, message=f"{err}").resp(), 500
