def get_category(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
show_all = form_req['show_all']
id_category = form_req['id_category']
if show_all:
Category = CategoryModels.query.all()
data_category = categorys_schema.dump(Category)
for category_value in data_category:
id_category = int(category_value['id'])
total_product = ProductModels.query.filter_by(
id_category=id_category).count()
data = {
"id_category": category_value['id'],
"name": category_value['name'],
'total_product': total_product
}
resultData.append(data)
else:
Category = CategoryModels.query.filter_by(
id=id_category).first()
data_category = category_schema.dump(Category)
id_category = int(data_category['id'])
total_product = ProductModels.query.filter_by(
id_category=id_category).count()
data = {
"id_category": data_category['id'],
"name": data_category['name'],
'total_product': total_product
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Get Category", "Get Category Succes",
start_time, resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Get Category", error, start_time)
else:
result = ResponseApi().error_response(
400, "Get Category", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Get Category",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Get Category",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def get_dashboard(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
try:
total_category = CategoryModels.query.count()
total_product = ProductModels.query.count()
product_data = {'total_product': total_product}
category_data = {'total_category': total_category}
# print(xample)
# pdb.run('mymodule.test()')
data = {'Product': product_data, 'Category': category_data}
result = ResponseApi().error_response(
200, "Get Dashboard", "Get Dashboard Succes",
start_time, data)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Get Dashboard", error, start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Get Dashboard",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Get Dashboard",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def get_user(self,param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
validation = ValidationInput().validation_get_users(form_req)
if validation['code'] == 200:
input_data = validation['result']
email = input_data['email']
user = UsersModel.query.filter_by(email=email).first()
if user:
user_response = user_schema.dump(user)
data = {
"id":user_response['id'],
"name":user_response['name'],
"email":user_response['email'],
"role_id":user_response['user_role_id'],
"token":user_response['token'],
}
result = ResponseApi().error_response(200, "Get User", "Get User Succes", start_time, data)
else:
result = ResponseApi().error_response(400, "Get User", "Your account email not found", start_time)
else:
result = ResponseApi().error_response(validation['code'], "Get User", validation['message'], start_time)
else:
result = ResponseApi().error_response(cek_session['code'], "Get User", cek_session['message'], start_time)
else:
result = ResponseApi().error_response(400, "Get Users", "Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def delete_category(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
delete_All = form_value['delete_all']
if delete_All:
category = CategoryModels.query.order_by(
CategoryModels.id.asc())
data_category = categorys_schema.dump(category)
for category_value in data_category:
data = {
'id_category': category_value['id'],
"name": category_value['name'],
}
resultData.append(data)
CategoryModels.query.delete()
db.session.commit()
else:
id_category = form_value['id_category']
category = CategoryModels.query.filter_by(
id=id_category).first()
category_value = category_schema.dump(category)
db.session.delete(category)
db.session.commit()
data = {
'id_category': category_value['id'],
"name": category_value['name'],
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Delete Category", "Delete Category Succes",
start_time, resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Delete Category", error, start_time)
else:
result = ResponseApi().error_response(
400, "Delete Category", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Delete Category",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Delete Category",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def update_cart(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
id_cart = form_value['id_cart']
id_transaction = form_value['id_transaction']
id_product = form_value['id_product']
qty = form_value['qty']
price = form_value['price']
data = {
"id_transaction": id_transaction,
"id_product": id_product,
"qty": qty,
"price": price,
}
Cart = CartModels.query.filter_by(id=id_cart)
Cart.update(data)
db.session.commit()
resultData.append(data)
result = {
"code": 200,
"SpeedTime":
ResponseApi().speed_response(start_time),
"endpoint": "Update Cart",
"message": "Update Cart Succes",
"result": resultData
}
result = ResponseApi().error_response(
200, "Update Cart", "Cart Update Succes",
start_time, resultData)
# print(result)
# pdb.run('mymodule.test()')
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Update Cart", error, start_time)
else:
result = ResponseApi().error_response(
400, "Update Cart", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Update Cart",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Update Cart",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def insert_company(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
name_company = form_value['name_company']
address_company = form_value['address_company']
no_tlp_company = form_value['no_tlp_company']
facebook_company = form_value['facebook_company']
instagram_company = form_value['instagram_company']
email_company = form_value['email_company']
website_company = form_value['website_company']
new_company = CompanyModels(
name_company, address_company, no_tlp_company,
facebook_company, instagram_company,
email_company, website_company)
db.session.add(new_company)
db.session.commit()
data = {
"name": name_company,
"address": address_company,
"no_telp": no_tlp_company,
"facebook": facebook_company,
"instagram": instagram_company,
"email": email_company,
"website": website_company
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Insert Company", "Insert Company Succes",
start_time, resultData)
# print(result)
# pdb.run('mymodule.test()')
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Insert Company", error, start_time)
else:
result = ResponseApi().error_response(
400, "Insert Company", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Insert Company",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Insert Company",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def insert_transaction(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
id_company = form_value['id_company']
id_user_company = form_value['id_user_company']
id_user_buyer = form_value['id_user_buyer']
buyer_name = form_value['buyer_name']
date_time = form_value['date_time']
amount_of_charge = form_value['amount_of_charge']
new_transaction = TransactionModels(
id_company, id_user_company, id_user_buyer,
buyer_name, date_time, amount_of_charge)
db.session.add(new_transaction)
db.session.commit()
data = {
"id_company": id_company,
"id_user_company": id_user_company,
"id_user_buyer": id_user_buyer,
"buyer_name": buyer_name,
"date_time": date_time,
"amount_of_charge": amount_of_charge,
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Insert Transaction",
"Insert Transaction Succes", start_time,
resultData)
# print(result)
# pdb.run('mymodule.test()')
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Insert Transaction", error, start_time)
else:
result = ResponseApi().error_response(
400, "Insert Transaction", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Insert Transaction",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Insert Transaction",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def register_user(self,param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
form_req = param['form']
if form_req:
validation = ValidationInput().validation_register(form_req)
if validation['code'] == 200:
input_data = validation['result']
code_activated = secrets.token_urlsafe(16)
encode_validation = Helpers().create_session(input_data,'not_confirm',code_activated)
Email = SendEmail().send_email_confirm_register(params=input_data,encode_validation=encode_validation,cek_connection=True)
if Email['code'] == 200:
try:
Companys = CompanyModels.query.filter_by(name=input_data["company_name"]).first()
data_companys = company_schema.dump(Companys)
if not data_companys:
new_company = CompanyModels(input_data['company_name'], input_data['address'], input_data['no_telp'],
'', '', input_data['email'], '')
db.session.add(new_company)
db.session.commit()
Company = CompanyModels.query.filter_by(name=input_data["company_name"]).first()
data_company = company_schema.dump(Company)
if data_company:
new_user = UsersModel(input_data['name'], input_data['email'] , input_data['no_telp'], input_data['password'], input_data['role_id'], 'null', data_company["id"], input_data['address'],'not_confirm',code_activated)
db.session.add(new_user)
db.session.commit()
encode_validation = Helpers().create_session(input_data,'not_confirm',code_activated)
Email = SendEmail().send_email_confirm_register(params=input_data,encode_validation=encode_validation,cek_connection=False)
print(Email)
# pdb.run('mymodule.test()')
data = {
"name" : input_data['name'],
"email" : input_data['email']
}
result = ResponseApi().error_response(200, "Register", "Register Succes Cek Your Email", start_time, data)
else:
result = ResponseApi().error_response(400, "Register", "Company cannot be saved", start_time)
else:
result = ResponseApi().error_response(400, "Register", "Company Already Exist Please Change Your Name Company", start_time)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(400, "Register", error, start_time)
else:
result = ResponseApi().error_response(Email['code'], "Register", Email['Message'], start_time)
else:
result = ResponseApi().error_response(validation['code'], "Logout", validation['message'], start_time)
else:
result = ResponseApi().error_response(400, "Register", "Form Request Is Empty", start_time)
else:
result = ResponseApi().error_response(400, "Register", "Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return jsonify(response)
def get_authority(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
show_all = form_req['show_all']
id_authority = form_req['id_authority']
if show_all:
Authority = AuthorityModels.query.all()
data_auth = authoritys_schema.dump(Authority)
for auth_value in data_auth:
if (auth_value):
data = {
"id_authority":
auth_value['id'],
"name_authority":
auth_value['name_authority'],
}
resultData.append(data)
else:
Authority = AuthorityModels.query.filter_by(
id=id_authority).first()
data_auth = authority_schema.dump(Authority)
data = {
"id_authority": data_auth['id'],
"name_authority": data_auth['name_authority'],
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Delete Authority", "Get Authority Succes",
start_time, resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Get Authority", error, start_time)
else:
result = ResponseApi().error_response(
400, "Get Authority", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Get Authority",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Get Authority",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def update_user(self,param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
data = {}
if form_req:
try:
for form_value in form_req:
id_user = form_value['id_user']
name = form_value['name']
old_password = form_value['old_password']
new_password = form_value['new_password']
no_telp = form_value['no_telp']
role_id = form_value['role_id']
address = form_value['address']
email = form_value['email']
data['name'] = name
data['user_role_id'] = role_id
data['no_telp'] = no_telp
data['address'] = address
data['email'] = email
user = UsersModel.query.filter_by(id=id_user).first()
user_response = user_schema.dump(user)
if old_password:
if hashlib.md5(old_password.encode('utf-8')).hexdigest() == user_response['password']:
data['password'] = hashlib.md5(new_password.encode('utf-8')).hexdigest()
else:
result = ResponseApi().error_response(400, "Update User", "Old Password is Wrong", start_time)
response = ResponseApi().response_api(result)
return response
Users = UsersModel.query.filter_by(id=id_user)
Users.update(data)
db.session.commit()
resultData.append(data)
result = ResponseApi().error_response(200, "Update Company", "Update Company Succes", start_time, resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(400, "Update User", error, start_time)
else:
result = ResponseApi().error_response(400, "Update User", "Form Request Is Empty", start_time)
else:
result = ResponseApi().error_response(cek_session['code'], "Update User", cek_session['message'], start_time)
else:
result = ResponseApi().error_response(400, "Update User", "Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def login_user(self,param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
form_req = param['form']
if form_req:
try:
validation = ValidationInput().validation_login(form_req)
if validation['code'] == 200:
input_data = validation['result']
email = input_data['email']
password = input_data['password']
user = UsersModel.query.filter_by(email=email).first()
if user:
user_response = user_schema.dump(user)
if user_response['status'] == 'not_confirm':
result = ResponseApi().error_response(400, "Login", "Your account email is not verify", start_time)
else:
if user_response['password'] == password:
encode_token = Helpers().create_session(user_response,'Active', user_response['code_activated'])
update_session = self.update_session_user(user_response['id'],encode_token,"Active")
if update_session:
Company = CompanyModels.query.filter_by(id=user_response["id_company"]).first()
data_company = company_schema.dump(Company)
# print(data_company['name'])
# pdb.run('mymodule.test()')
data = {
"name":update_session['name'],
"email":update_session['email'],
"role_id":update_session['user_role_id'],
"token":update_session['token'],
"company":data_company
}
result = ResponseApi().error_response(200, "Login", "Login Succes", start_time, data)
else:
result = ResponseApi().error_response(400, "Login", "Failed Session", start_time)
else:
result = ResponseApi().error_response(400, "Login", "Your account email is incorrect", start_time)
else:
result = ResponseApi().error_response(400, "Login", "Your account email is incorrect", start_time)
else:
result = ResponseApi().error_response(validation['code'], "Logout", validation['message'], start_time)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(400, "Login", error, start_time)
else:
result = ResponseApi().error_response(400, "Login", "Form Request Is Empty", start_time)
else:
result = ResponseApi().error_response(400, "Login", "Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def insert_cart(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
id_transaction = form_value['id_transaction']
id_product = form_value['id_product']
qty = form_value['qty']
price = form_value['price']
new_cart = CartModels(id_transaction, id_product,
qty, price)
db.session.add(new_cart)
db.session.commit()
data = {
"id_transaction": id_transaction,
"id_product": id_product,
"qty": qty,
"price": price,
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Insert Cart", "Insert Cart Succes",
start_time, resultData)
# print(result)
# pdb.run('mymodule.test()')
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Insert Cart", error, start_time)
else:
result = ResponseApi().error_response(
400, "Insert Cart", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Insert Cart",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Insert Cart",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def insert_category(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
name_category = form_value['name']
id_company = cek_session['data']['id_company']
new_category = CategoryModels(
name_category, id_company)
db.session.add(new_category)
db.session.commit()
Category = CategoryModels.query.filter_by(
name=name_category).first()
data_category = category_schema.dump(Category)
data = {
"id_company": data_category['id_company'],
"id_category": data_category['id'],
"name": name_category,
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Insert Category", "Insert Category Succes",
start_time, resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Insert Category", error, start_time)
else:
result = ResponseApi().error_response(
400, "Insert Category", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Insert Category",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Insert Category",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def logout_user(self,param):
start_time = ResponseApi().microtime(True)
result ={}
if Helpers().cek_auth(param):
form_req = param['form']
if form_req:
try:
validation = ValidationInput().validation_logout(form_req)
if validation['code'] == 200:
input_data = validation['result']
email = input_data['email']
user = UsersModel.query.filter_by(email=email).first()
if user:
user_response = user_schema.dump(user)
expired_session = (datetime.now() + timedelta(minutes = int(os.getenv('SESSION_EXPIRED'))))
data_user = {
"name":user_response['name'],
"email":user_response['email'],
"role_id":user_response['user_role_id'],
"expired_session":expired_session.strftime('%Y/%m/%d %H:%M:%S'),
"status":"Logout"
}
encode_token = Helpers().encode_token(data_user)
update_session = self.update_session_user(user_response['id'],encode_token,"Logout")
if update_session:
data = {
"name":update_session['name'],
"email":update_session['email'],
"role_id":update_session['user_role_id'],
"token":update_session['token'],
}
result = ResponseApi().error_response(200, "Logout", "Logout Succes", start_time, data)
else:
result = ResponseApi().error_response(400, "Logout", "Your account email is incorrect", start_time)
else:
result = ResponseApi().error_response(validation['code'], "Logout", validation['message'], start_time)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(400, "Logout", error, start_time)
else:
result = ResponseApi().error_response(400, "Logout", "Form Request Is Empty", start_time)
else:
result = ResponseApi().error_response(400, "Logout", "Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def update_authority(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
id_authority = form_value['id_authority']
name_authority = form_value['name_authority']
data = {
"name_authority": name_authority,
}
Authority = AuthorityModels.query.filter_by(
id=id_authority)
Authority.update(data)
db.session.commit()
resultData.append(data)
result = ResponseApi().error_response(
200, "Update Authority", "Update Authority Succes",
start_time, resultData)
# print(result)
# pdb.run('mymodule.test()')
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Update Authority", error, start_time)
else:
result = ResponseApi().error_response(
400, "Update Authority", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Update Authority",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Update Authority",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def get_user(self, param):
if Helpers().cek_auth(param):
# cek_session = Helpers().cek_session(param)
# if cek_session['code'] == 200:
form_req = param['form']
validation = ValidationInput().validation_get_users(form_req)
if validation['code'] == 200:
input_data = validation['result']
email = input_data['email']
user = UsersModel.query.filter_by(email=email).first()
if user:
user_response = user_schema.dump(user)
result = {
"code": 200,
"endpoint": "Get Users",
"message": "Succes Get Users",
"result": {
"id": user_response['id'],
"name": user_response['name'],
"email": user_response['email'],
"role_id": user_response['role_id'],
"status": user_response['status'],
"position": user_response['position'],
"token": user_response['token'],
}
}
else:
result = {
"code": 400,
"endpoint": "Get Users",
"message": "Your account email not found",
"result": {}
}
else:
result = {
"code": validation['code'],
"endpoint": "Get Users",
"message": validation['message'],
"result": {}
}
# else:
# result = {
# "code" : cek_session['code'],
# "endpoint": "Get Users",
# "message": cek_session['message'],
# "result": {}
# }
else:
result = {
"code": 400,
"endpoint": "Get Users",
"message": "Authentication signature calculation is wrong",
"result": {}
}
response = ResponseApi().response_api(result)
return response
def delete_product(self, param):
if Helpers().cek_auth(param):
# cek_session = Helpers().cek_session(param)
# if cek_session['code'] == 200:
form_req = param['form']
if form_req:
try:
resultData = []
for form_value in form_req:
id_product = form_value['id']
product = ProductModels.query.filter_by(
id=id_product).first()
product_value = product_schema.dump(product)
db.session.delete(product)
db.session.commit()
data = {
'id': product_value['id'],
"name": product_value['name'],
}
resultData.append(data)
result = {
"code": 200,
"endpoint": "Delete Product",
"message": "Delete Product Succes",
"result": resultData
}
except Exception as e:
error = str(e)
result = {
"code": 400,
"endpoint": "Delete Product",
"message": error,
"result": {}
}
else:
result = {
"code": 400,
"endpoint": "Delete Product",
"message": "Form Request Is Empty",
"result": {}
}
# else:
# result = {
# "code" : cek_session['code'],
# "endpoint": "Update Product",
# "message": cek_session['message'],
# "result": {}
# }
else:
result = {
"code": 400,
"endpoint": "Delete Product",
"message": "Authentication signature calculation is wrong",
"result": {}
}
response = ResponseApi().response_api(result)
return response
def update_category(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
# try:
for form_value in form_req:
id_category = form_value['id_category']
id_company = cek_session['data']['id_company']
name_category = form_value['name']
data = {
"id": id_category,
"id_company": id_company,
"name": name_category,
}
Category = CategoryModels.query.filter_by(
id=id_category)
Category.update(data)
db.session.commit()
resultData.append(data)
result = ResponseApi().error_response(
200, "Update Category", "Update Category Succes",
start_time, resultData)
# except Exception as e:
# error = str(e)
# result = ResponseApi().error_response(400, "Update Category", error, start_time)
else:
result = ResponseApi().error_response(
400, "Update Category", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Update Category",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Update Category",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def register_user(self, param):
if Helpers().cek_auth(param):
form_req = param['form']
if form_req:
try:
validation = ValidationInput().validation_register(
form_req)
if validation['code'] == 200:
input_data = validation['result']
new_user = UsersModel(input_data['name'],
input_data['email'],
input_data['password'], True,
input_data['position'],
input_data['role_id'], 'null')
db.session.add(new_user)
db.session.commit()
result = {
"code": 200,
"endpoint": "Register",
"message": "Register Succes",
"result": {
"name": input_data['name'],
"email": input_data['email']
}
}
else:
result = {
"code": validation['code'],
"endpoint": "Register",
"message": validation['message'],
"result": {}
}
except Exception as e:
error = str(e)
result = {
"code": 400,
"endpoint": "Register",
"message": error,
"result": {}
}
else:
result = {
"code": 400,
"endpoint": "Register",
"message": "Form Request Is Empty",
"result": {}
}
else:
result = {
"code": 400,
"endpoint": "Register",
"message": "Authentication signature calculation is wrong",
"result": {}
}
response = ResponseApi().response_api(result)
return jsonify(response)
def get_transaction(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
if form_req:
try:
show_all = form_req['show_all']
id_transaction = form_req['id_transaction']
if show_all:
Transaction = TransactionModels.query.all()
data = transactions_schema.dump(Transaction)
else:
Transaction = TransactionModels.query.filter_by(
id=id_transaction).first()
data = transactions_schema.dump(Transaction)
result = ResponseApi().error_response(
200, "Get Transaction", "Get Transaction Succes",
start_time, data)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Get Transaction", error, start_time)
else:
result = ResponseApi().error_response(
400, "Get Transaction", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Get Transaction",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Get Transaction",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def get_email_view():
code_activated = secrets.token_urlsafe(16)
input_data = {
"name":"ss",
"email":"*****@*****.**",
}
encode_validation = Helpers().create_session(input_data,'not_confirm',code_activated)
url_roots = request.url_root
content = {
'url_roots' : url_roots,
'encode_validation' : encode_validation
}
return render_template('mail_welcome_confirm.html',content = content)
class AdminSignUpView(MethodView):
def __init__(self):
super().__init__()
self.helpers = Helpers()
self.success = Success()
self.error = Error()
@admin_only
def post(self, user_id):
"""This method handles the registration route for an admin"""
json_data = request.get_json(force=True)
email = json_data.get('email')
password = json_data.get('password')
# check if user exists
user = User.query.filter_by(email=json_data.get('email')).first()
if not user:
try:
# check if password exists
if not json_data.get('password'):
return self.error.bad_request('No password provided')
if len(password) < 8:
return self.error.bad_request('Password too short')
# check if email exists
if not json_data.get('email'):
return self.error.bad_request('No email provided')
if not self.helpers.email_valid(email):
return self.error.bad_request('Invalid email')
user = User(email=email, password=password, admin=True)
user.save()
return self.success.create_resource(
'User created successfully')
except Exception as e:
return self.error.internal_server_error(
'Error occurred {}'.format(e))
else:
return self.error.causes_conflict('User already exists')
class LoginView(MethodView):
"""This is a view for handling user login and assigning of tokens"""
def __init__(self):
super().__init__()
self.helpers = Helpers()
self.success = Success()
self.error = Error()
def post(self):
"""A method for handling the log in request endpoint"""
json_data = request.get_json(force=True)
email = json_data.get('email')
password = json_data.get('password')
try:
# check if password exists
if not email:
return self.error.bad_request('No password provided')
if len(password) < 8:
return self.error.bad_request('Password too short')
# check if email exists
if not email:
return self.error.bad_request('No email provided')
if not self.helpers.email_valid(email):
return self.error.bad_request('Invalid email')
# Get the user object
user = User.query.filter_by(email=email).first()
# Authenticate the user
if user and user.is_password_valid(password):
# Generate the access token to be used in header
access_token = user.generate_token(user.id)
if access_token:
token = access_token.decode()
return make_response(jsonify({"token": token})), 200
else:
return self.error.unauthorized('Invalid email or password')
except Exception as e:
return str(e)
def verify_account(self,param):
start_time = ResponseApi().microtime(True)
# if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
try:
email = cek_session['data']['email']
user = UsersModel.query.filter_by(email=email).first()
data = {}
resultData = []
if user:
user_response = user_schema.dump(user)
if user_response['code_activated'] == cek_session['code_activated']:
data['status'] = 'confirm'
data['email'] = user_response['email']
Users = UsersModel.query.filter_by(id=user_response['id'])
Users.update(data)
db.session.commit()
resultData.append(data)
result = ResponseApi().error_response(200, "Verify Users", "Your account email is verify", start_time, resultData)
else:
result = ResponseApi().error_response(400, "Verify Users", "Your account email code is wrong", start_time)
else:
result = ResponseApi().error_response(400, "Verify Users", "Your account email is wrong", start_time)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(400, "Verify Users", error, start_time)
else:
result = ResponseApi().error_response(cek_session['code'], "Verify Users", cek_session['message'], start_time)
# print(decode_token)
# pdb.run('mymodule.test()')
# else:
# result = ResponseApi().error_response(400, "Verify Users", "Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def get_token(self, param):
return Helpers().decode_token(param)
def generate_token(self, param):
return Helpers().encode_auth(param)
def login_user(self, param):
if Helpers().cek_auth(param):
form_req = param['form']
if form_req:
try:
validation = ValidationInput().validation_login(form_req)
if validation['code'] == 200:
input_data = validation['result']
email = input_data['email']
password = input_data['password']
user = UsersModel.query.filter_by(email=email).first()
if user:
user_response = user_schema.dump(user)
if user_response['password'] == password:
expired_session = (datetime.now() + timedelta(
minutes=int(os.getenv('SESSION_EXPIRED'))))
data_user = {
"name":
user_response['name'],
"email":
user_response['email'],
"role_id":
user_response['role_id'],
"status":
user_response['status'],
"position":
user_response['position'],
"expired_session":
expired_session.strftime(
'%Y/%m/%d %H:%M:%S')
}
encode_token = Helpers().encode_token(
data_user)
update_session = self.update_session_user(
user_response['id'], encode_token)
if update_session:
result = {
"code": 200,
"message": "Succes Login",
"endpoint": "Login",
"result": {
"name": update_session['name'],
"email": update_session['email'],
"role_id":
update_session['role_id'],
"status": update_session['status'],
"position":
update_session['position'],
"token": update_session['token'],
}
}
else:
result = {
"code": 400,
"endpoint": "Login",
"message": "Failed Session",
"result": {}
}
else:
result = {
"code": 400,
"endpoint": "Login",
"message":
"Your account email or password is incorrect",
"result": {}
}
else:
result = {
"code": 400,
"endpoint": "Login",
"message":
"Your account email or password is incorrect",
"result": {}
}
else:
result = {
"code": validation['code'],
"endpoint": "Login",
"message": validation['message'],
"result": {}
}
except Exception as e:
error = str(e)
result = {
"code": 400,
"endpoint": "Login",
"message": error,
"result": {}
}
else:
result = {
"code": 400,
"endpoint": "Login",
"message": "Form Request Is Empty",
"result": {}
}
else:
result = {
"code": 400,
"endpoint": "Login",
"message": "Authentication signature calculation is wrong",
"result": {}
}
response = ResponseApi().response_api(result)
return response
def delete_transaction(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
delete_All = form_value['delete_all']
if delete_All:
Transaction = TransactionModels.query.order_by(
TransactionModels.id.asc())
data_transaction = transactions_schema.dump(
Transaction)
for transaction_value in data_transaction:
data = {
'id':
transaction_value['id'],
"id_company":
transaction_value['id_company'],
"id_user_company":
transaction_value['id_user_company'],
"id_user_buyer":
transaction_value['id_user_buyer'],
"buyer_name":
transaction_value['buyer_name'],
"date_time":
transaction_value['date_time'],
"amount_of_charge":
transaction_value['amount_of_charge'],
}
resultData.append(data)
TransactionModels.query.delete()
db.session.commit()
else:
id_transaction = form_value['id_transaction']
Transaction = TransactionModels.query.filter_by(
id=id_transaction).first()
transaction_value = transaction_schema.dump(
Transaction)
db.session.delete(Transaction)
db.session.commit()
data = {
'id':
transaction_value['id'],
"id_company":
transaction_value['id_company'],
"id_user_company":
transaction_value['id_user_company'],
"id_user_buyer":
transaction_value['id_user_buyer'],
"buyer_name":
transaction_value['buyer_name'],
"date_time":
transaction_value['date_time'],
"amount_of_charge":
transaction_value['amount_of_charge'],
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Delete Transaction",
"Delete Transaction Succes", start_time,
resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Delete Transaction", error, start_time)
else:
result = ResponseApi().error_response(
400, "Delete Transaction", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Delete Transaction",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Delete Transaction",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def delete_product(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
delete_All = form_value['delete_all']
if delete_All:
product = ProductModels.query.order_by(
ProductModels.id.asc())
data_product = products_schema.dump(product)
for product_value in data_product:
data = {
'id_product': product_value['id'],
"name": product_value['name'],
}
# Delete cloudinary
cloudinary.api.delete_resources(
[product_value['id_cloudinary']])
# Delete imagekit
imagekit.delete_file(
product_value['id_imagekit'])
resultData.append(data)
ProductModels.query.delete()
db.session.commit()
else:
id_product = form_value['id_product']
product = ProductModels.query.filter_by(
id=id_product).first()
product_value = product_schema.dump(product)
# Delete cloudinary
cloudinary.api.delete_resources(
[product_value['id_cloudinary']])
# Delete imagekit
imagekit.delete_file(
product_value['id_imagekit'])
db.session.delete(product)
db.session.commit()
data = {
'id_product': product_value['id'],
"name": product_value['name'],
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Delete Product", "Delete Product Succes",
start_time, resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Delete Product", error, start_time)
else:
result = ResponseApi().error_response(
400, "Delete Product", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Delete Product",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Delete Product",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
def delete_cart(self, param):
start_time = ResponseApi().microtime(True)
if Helpers().cek_auth(param):
cek_session = Helpers().cek_session(param)
if cek_session['code'] == 200:
form_req = param['form']
resultData = []
if form_req:
try:
for form_value in form_req:
delete_All = form_value['delete_all']
if delete_All:
Cart = CartModels.query.order_by(
CartModels.id.asc())
data_cart = carts_schema.dump(Cart)
for cart_value in data_cart:
data = {
'id_cart':
cart_value['id_cart'],
"id_transaction":
cart_value['id_transaction'],
"id_product":
cart_value['id_product'],
"qty":
cart_value['qty'],
"price":
cart_value['price'],
}
resultData.append(data)
CartModels.query.delete()
db.session.commit()
else:
id_cart = form_value['id_cart']
Cart = CartModels.query.filter_by(
id=id_cart).first()
Cart_value = cart_schema.dump(Cart)
db.session.delete(Cart)
db.session.commit()
data = {
'id_cart': Cart_value['id_cart'],
"id_transaction":
Cart_value['id_transaction'],
"id_product": Cart_value['id_product'],
"qty": Cart_value['qty'],
"price": Cart_value['price'],
}
resultData.append(data)
result = ResponseApi().error_response(
200, "Delete Cart", "Cart Delete Succes",
start_time, resultData)
except Exception as e:
error = str(e)
result = ResponseApi().error_response(
400, "Delete Cart", error, start_time)
else:
result = ResponseApi().error_response(
400, "Delete Cart", "Form Request Is Empty",
start_time)
else:
result = ResponseApi().error_response(cek_session['code'],
"Delete Cart",
cek_session['message'],
start_time)
else:
result = ResponseApi().error_response(
400, "Delete Cart",
"Authentication signature calculation is wrong", start_time)
response = ResponseApi().response_api(result)
return response
