def get(self, *args, **kwargs):
try:
entity_id = int(request.headers.get('entity_id'))
debug_sproc = int(request.headers.get('debug_sproc'))
audit_screen_visit = int(request.headers.get('audit_screen_visit'))
input_params = [
entity_id, kwargs['session_id'], kwargs['user_id'],
kwargs['screen_id'], debug_sproc, audit_screen_visit
]
output_params = [0, 0, 0]
sproc_result_args, cursor = fn_call_stored_procedure(
kwargs['client_db_connection'],
'sproc_sls_rpt_pdf_sales_invoice', *input_params,
*output_params)
return fn_return_sproc_multiple_result_sets(
sproc_result_args=sproc_result_args,
cursor=cursor,
functionality="Sales invoice data fetched successfully")
except Exception as e:
return {'Error': str(e)}, 400
def get(self, *args, **kwargs):
try:
data = request.get_json()
start_date = data.get('start_date')
end_date = data.get('end_date')
client_entity_id = int(data.get('client_entity_id'))
debug_sproc = int(request.headers.get('debug_sproc'))
audit_screen_visit = int(request.headers.get('audit_screen_visit'))
input_params = [
start_date, end_date, client_entity_id, kwargs['session_id'],
kwargs['user_id'], kwargs['screen_id'], debug_sproc,
audit_screen_visit
]
output_params = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
sproc_result_args, cursor = fn_call_stored_procedure(
kwargs['client_db_connection'],
'sproc_org_rpt_dashboard_client', *input_params,
*output_params)
return fn_return_sproc_multiple_result_sets(
sproc_result_args=sproc_result_args,
cursor=cursor,
functionality="Client dashboard data fetched successfully")
except Exception as e:
return {'Error': str(e)}, 400
def post(self, *args, **kwargs):
try:
data = request.get_json()
debug_sproc = int(request.headers.get('debug_sproc'))
audit_screen_visit = int(request.headers.get('audit_screen_visit'))
output_params = [0, 0, 0]
input_params = [
data.get('client_entity_id'),
data.get('invoice_number'),
data.get('invoice_date'),
data.get('invoice_due_date'),
data.get('productEntityId_units_unitRate_taxTypeId_list'),
data.get('payment_terms_id'),
data.get('discount_type_id'),
data.get('discount_value'), kwargs['session_id'],
kwargs['user_id'], kwargs['screen_id'], debug_sproc,
audit_screen_visit
]
sproc_result_args, cursor = fn_call_stored_procedure(
kwargs['client_db_connection'], 'sproc_sls_invoice_dml_ins',
*input_params, *output_params)
return fn_return_sproc_ddl(
sproc_result_args=sproc_result_args,
cursor=cursor,
functionality="Sales invoice saved successfully ")
except Exception as e:
return {'Error': str(e)}, 400
def post(self, *args, **kwargs):
try:
data = request.get_json()
debug_sproc = int(request.headers.get('debug_sproc'))
audit_screen_visit = int(request.headers.get('audit_screen_visit'))
output_params = [0, 0, 0]
input_params = [data.get('isactive'), data.get('product_type_id'), data.get('product_name'),
data.get('brand_id'),data.get('uom_type_id'), data.get('unit_content'),
data.get('product_dimensions'),data.get('isreturnable_item'), data.get('selling_price'),
data.get('ledger_account_entity_id'),data.get('maintain_inventory_flag'),
data.get('opening_stock'), data.get('re_order_level'), data.get('start_reminder_months'),
data.get('stop_reminder_months'), data.get('max_reminder_count'),data.get('reminder_sms_text'),
data.get('reminder_email_text'),kwargs['session_id'],kwargs['user_id'],kwargs['screen_id'],
debug_sproc,audit_screen_visit]
sproc_result_args, cursor = fn_call_stored_procedure(kwargs['client_db_connection'],
'sproc_inv_product_dml_ins',
*input_params,
*output_params)
return fn_return_sproc_ddl(sproc_result_args=sproc_result_args, cursor=cursor,
functionality="Products saved successfully ")
except Exception as e:
return {'Error': str(e)}, 400
def get(self, *args, **kwargs):
try:
sproc_result_args, cursor = fn_call_stored_procedure(
kwargs['client_db_connection'], 'sproc_act_lkp_tax_type')
sproc_result_sets = fn_sproc_response(cursor)
return {
'status': 'Success',
'data': sproc_result_sets,
'message': "Tax type data fetched successfully"
}, 200
except Exception as e:
return {'Error': str(e)}, 400
def get(self, *args, **kwargs):
try:
debug_sproc = int(request.headers.get('debug_sproc'))
audit_screen_visit = int(request.headers.get('audit_screen_visit'))
input_params = [kwargs['session_id'], kwargs['user_id'],
kwargs['screen_id'], debug_sproc, audit_screen_visit]
output_params = [0, 0, 0]
sproc_result_args, cursor = fn_call_stored_procedure(kwargs['client_db_connection'],
'sproc_inv_product_grid',
*input_params,
*output_params)
return fn_return_sproc_single_result_sets(sproc_result_args=sproc_result_args, cursor=cursor,
functionality="Products data Fetched successfully")
except Exception as e:
return {'Error': str(e)}, 400
def wrapper(request, *args, **kwargs):
print(
"------------ start decorator check permission -------------",
datetime.datetime.now())
print("start time for check permission decorator",
datetime.datetime.now())
screen_id = int(flask.request.headers.get('screen_id'))
user_id = int(flask.request.headers.get('user_id'))
session_id = int(flask.request.headers.get('session_id'))
student_entity_id = int(
flask.request.headers.get('student_entity_id'))
token = flask.request.headers.get('token')
check_permission_output_params = [1, 1, 0, 0, 0]
print("start time for check permission stored procedure",
datetime.datetime.now())
sproc_result_sets, cursor = fn_call_stored_procedure(
kwargs['client_db_connection'],
'sproc_sec_check_screen_permission_v2', screen_id, user_id,
session_id, student_entity_id, token,
*check_permission_output_params)
print("end time for check permission stored procedure",
datetime.datetime.now())
# screen_permission_result_sets[5] == valid access & screen_permission_result_sets[7] == err_flag
if (sproc_result_sets[5] == 0):
return {
'Status': 'Failure',
'Message': sproc_result_sets[9]
}, 400
else:
kwargs['screen_id'] = screen_id
kwargs['user_id'] = user_id
kwargs['session_id'] = session_id
kwargs['token'] = token
print("end time for check permission decorator",
datetime.datetime.now())
print(
"------------ end decorator check permission -------------",
datetime.datetime.now())
return function(request, *args, **kwargs)
def fn_sama_get_client_DB_details(user_domain_name):
try:
connection = fn_connect_client_db(host=os.environ.get('MH'),
database=os.environ.get('MDN'),
user=os.environ.get('MDU'),
password=os.environ.get('MDP'))
connection_type = isinstance(connection, str)
if connection_type == True:
return connection, 400
else:
sproc_result_args, cursor = fn_call_stored_procedure(
connection, 'sproc_sama_get_client_db_connnection_info_v2',
user_domain_name, 1, 1, 0, 0, 0)
sproc_result_sets = fn_sproc_response(cursor)
fn_close_db_connection(connection, cursor)
return sproc_result_sets, sproc_result_args
except mysql.connector.Error as e:
return str(e), 400
def get(self, *args, **kwargs):
try:
entity_id = int(request.headers.get('entity_id'))
debug_sproc = int(request.headers.get('debug_sproc'))
audit_screen_visit = int(request.headers.get('audit_screen_visit'))
input_params = [entity_id, kwargs['session_id'], kwargs['user_id'],
kwargs['screen_id'], debug_sproc, audit_screen_visit]
output_params = [0, 0, 0]
sproc_result_args, cursor = fn_call_stored_procedure(kwargs['client_db_connection'],
'sproc_inv_product_detail',
*input_params,
*output_params)
status, cursor_object, status_code = fn_get_sproc_errors(sproc_result_args=sproc_result_args, cursor=cursor)
if status == "Failure" and status_code == 400:
return {'status': status, 'data': cursor_object}, status_code
else:
sproc_result_sets = fn_sproc_multiple_result_sets_response(cursor)[0]
product_details = [{'product': each_product[0],
'product_type_entity_id': each_product[1],
'unit_rate': str(each_product[2]),
'start_reminder_months': each_product[3],
'stop_reminder_months': each_product[4],
'max_reminder_count': each_product[5],
'product_type_entity_id': each_product[6],
'product_entity_id': each_product[7],
'active': each_product[8],
'reminder_sms_text': each_product[9],
'reminder_email_text': each_product[10],
'uom_type_id': str(each_product[11]),
'unit_content': str(each_product[12]),
're_order_level': each_product[13],
'maintain_inventory_flag': each_product[14],
'brand_id': each_product[15]}
for each_product in sproc_result_sets]
return {'status': 'Success', 'product_details': product_details}, 200
except Exception as e:
return {'Error': str(e)}, 400
def get(self, *args, **kwargs):
try:
print("+++++++++++++++ Account lookup +++++++++++++++")
print("start time for account lookup", datetime.datetime.now())
debug_sproc = int(request.headers.get('debug_sproc'))
audit_screen_visit = int(request.headers.get('audit_screen_visit'))
input_params = [
kwargs['session_id'], kwargs['user_id'], kwargs['screen_id'],
debug_sproc, audit_screen_visit
]
output_params = [0, 0, 0]
sproc_result_args, cursor = fn_call_stored_procedure(
kwargs['client_db_connection'], 'sproc_org_lkp_account',
*input_params, *output_params)
print("end time for account lookup", datetime.datetime.now())
return fn_return_sproc_single_result_sets(
sproc_result_args=sproc_result_args,
cursor=cursor,
functionality="Account data fetched successfully")
except Exception as e:
return {'Error': str(e)}, 400
def post(self):
try:
print("------- Calling Post method ------")
print("Start time for post method", datetime.datetime.now())
print("-------------")
data = request.get_json()
user_id = data.get('domain_name')
password = data.get('password')
hash_password = fn_hash(data.get('password'))
login_id, domain_name = user_id.split('@', 1)
sproc_sama_result_sets, sproc_sama_result_args = fn_sama_get_client_DB_details(
user_domain_name=domain_name)
if sproc_sama_result_args == 400:
return {
'status': 'Failure',
'data': sproc_sama_result_sets
}, 400
elif sproc_sama_result_args[-3] == 1:
return {
'status': 'Failure',
'data': sproc_sama_result_args[-1]
}, 400
else:
client_db_details = sproc_sama_result_sets[0]
if client_db_details[0] is None:
return {'status': 'Failure', 'data': 'Invalid login'}, 400
if not client_db_details:
return {
'status': 'Failure',
'data': 'Client database not found'
}, 400
token = client_db_details[0]
db_name = fn_decrypt(client_db_details[1])
db_user = fn_decrypt(client_db_details[2])
db_pwd = fn_decrypt(client_db_details[3])
db_host = fn_decrypt(client_db_details[4])
client_db_connection = fn_connect_client_db(user=db_user,
password=db_pwd,
database=db_name,
host=db_host)
output_params = [0, 0, 0, 0, 0, 0, 0, 0, 0]
sproc_result_args, cursor = fn_call_stored_procedure(
client_db_connection, 'sproc_sec_login_v2', login_id,
password, request.remote_addr, "desktop", token,
*output_params)
sproc_result_sets = fn_sproc_response(cursor)
if sproc_result_args[-4] == "Success":
get_module_names = [
result_set[0] for result_set in sproc_result_sets
]
fn_close_db_connection(client_db_connection, cursor)
result_json = {
'token': token,
'audit_screen_visit': sproc_result_args[5],
'debug_sproc': sproc_result_args[6],
'session_id': sproc_result_args[7],
'user_id': sproc_result_args[8],
'login_success': sproc_result_args[9],
'module_names': get_module_names,
'user': client_db_details[2],
'password': client_db_details[3],
'database': client_db_details[1],
'host': client_db_details[4]
}
print("-------------")
print("Return data for login", datetime.datetime.now())
print("-------------")
return {
'Status': sproc_result_args[-4],
'data': result_json
}, 200
else:
return {
'Status': 'Failure',
'data': sproc_result_args[-4],
'error': sproc_result_args[-1]
}, 400
except Exception as error:
return {"error_response": error}, 400