from main import Resource, api, fields, create_access_token
from models.usermodel import UserModel, user_schema, users_schema
from werkzeug.security import generate_password_hash
ns_registration = api.namespace('registration', description='User sign up')
ns_login = api.namespace('login', description='Login details')
login_model = api.model('Login_credentials', {
'email': fields.String(),
'password': fields.String()
})
registration_model = api.model(
'Signup_credentials', {
'full_name': fields.String(),
'email': fields.String(),
'password': fields.String()
})
@ns_login.route('')
class Login(Resource):
@api.expect(login_model)
def post(self):
''' use this to authenticate users'''
data = api.payload
email = data['email']
if UserModel.check_if_mail_exists(email):
if UserModel.check_passoword(data['password'], email):
user_id = UserModel.get_user_id(email)
access_token = create_access_token(identity=user_id)
from main import api, fields, Resource, jwt_required, get_jwt_identity
from models.tasksmodel import TaskModel, task_schema, tasks_schema
from models.usersmodel import UserModel
ns_tasks = api.namespace('tasks', description="All Task Operations")
# models Documenting the nature of your Payload
task_model = api.model(
'Task', {
'title': fields.String(),
'description': fields.String(),
'completed': fields.String()
})
@ns_tasks.route('')
class Tasks(Resource):
@jwt_required
def get(self):
"""Use this Endpoint to get all Tasks"""
uid = get_jwt_identity()
user = UserModel.get_userby_id(uid)
user_tasks = user.tasks
return tasks_schema.dump(user_tasks), 200
@api.expect(task_model)
@jwt_required
def post(self):
"""Use this Endpoint to add all Tasks"""
data = api.payload
from main import Resource, api, fields
from models.user import UserModel, users_schema, user_schema
users_namespace = api.namespace(
"users",
description="THis endpoint deals with all operations regarding users")
user_model = api.model(
"User",
{
"full_name": fields.String(),
"email": fields.String(),
"password": fields.String(),
},
)
@users_namespace.route("")
class ItemList(Resource):
def get(self):
"""Get a list of all users"""
users = UserModel.fetch_all()
if users:
return users_schema.dump(users)
else:
return {"message": "please try again later"}, 500
@users_namespace.route("/<int:id>")
class User(Resource):
def get(self, id: int):
""" Geta a user by id"""
from main import api, fields, Resource
from models.usermodel import Users_model, user_schema, users_schema
from werkzeug.security import generate_password_hash, check_password_hash
from flask_jwt_extended import JWTManager,jwt_required,create_access_token,get_jwt_identity
# creating namespace
ns_registration = api.namespace("Register", description="Registration details")
ns_login = api.namespace("Login", description="Login details")
# this helps the user know hoe to input the data
register_model = api.model(
"User",
{
"fullname": fields.String(),
"email": fields.String(min_length=5),
"password": fields.String(),
},
)
login_model = api.model(
"LoginLCredentials", {"email": fields.String(), "password": fields.String()}
)
@ns_login.route("")
class Login(Resource):
@api.expect(login_model)
def post(self):
from models.usermodel import Users_model, user_schema, users_schema
from flask_jwt_extended import (
JWTManager,
jwt_required,
create_access_token,
get_jwt_identity,
)
ns_users = api.namespace("users", description="all tasks regarding users")
# this helps the user know how to input the data
user_model = api.model(
"User",
{
"fullname":
fields.String(
description="Fullname is required", required=True, min_length=2),
"email":
fields.String(description="Your email", required=True, min_length=2),
"password":
fields.String(description="Your password", required=True,
min_length=2),
},
)
@ns_users.route("")
class User_list(Resource):
@api.doc(security="apikey")
@jwt_required
def get(self):
"""Use this endpoint to get all users"""
from main import db, api, fields, Resource, jwt_required, get_jwt_identity
from models.store import StoreModel, stores_scehma, store_schema
from models.user import UserModel
store_namespace = api.namespace(
"stores", description="This Endpoint deals with all operations pertaining Stores"
)
store_model = api.model("Store", {"name": fields.String()})
STORE_NOT_FOUND = "that store does not exists"
OPERATION_SUCCESSFUL = " '{}' operation carried out successfully"
@store_namespace.route("")
class StoreList(Resource):
@jwt_required
@api.doc(security="apikey")
def get(self):
"""Get a list of stores"""
user_id = get_jwt_identity()
user = UserModel.fetch_by_id(user_id)
stores = user.stores
if stores:
return stores_scehma.dump(stores), 200
else:
return {"message": STORE_NOT_FOUND}, 404
@api.expect(store_model)
@jwt_required
@api.doc(security="apikey")
def post(self):
from main import appi, fields
nms_cliente = appi.namespace('mvp')
model_cliente = appi.model('Cliente Model', {'nm_cliente': fields.String(required=True,
description="Nome do Cliente"),
'cpf_cliente': fields.String(required=True,
description="CPF do Cliente"),
'rg_cliente': fields.String(required=True,
description="RG do Cliente"),
'endereco': fields.String(required=True,
description="Endereço do Cliente"),
'cep': fields.String(required=True,
description="CEP do endereço do Cliente"),
'uf': fields.String(required=True,
description="UF do endereço do Cliente"),
'data_nascimento': fields.Date(required=True,
description="Data de nascimento do Cliente"),
'estado_civil': fields.String(required=True,
description="Estado Civil atual do Cliente"),
'profissao': fields.String(required=True,
description="Profissão do Cliente")})
model_get_cliente = appi.model('Cliente Model', {'Id': fields.Integer(description="Id do cliente")})
model_put_cliente = appi.model('Cliente Model', {'nm_cliente': fields.String(description="Nome do Cliente"),
'cpf_cliente': fields.String(description="CPF do Cliente"),
'rg_cliente': fields.String(description="RG do Cliente"),
'endereco': fields.String(description="Endereço do Cliente"),
'cep': fields.String(description="CEP do endereço do Cliente"),
'uf': fields.String(description="UF do endereço do Cliente"),
'data_nascimento': fields.Date(
description="Data de nascimento do Cliente"),
'estado_civil': fields.String(
from main import Resource, api, fields, jwt_required, get_jwt_identity
from models.taskmodel import TaskModel, task_schema, tasks_schema
from models.usermodel import UserModel
# namespace
ns_tasks = api.namespace('tasks', description='All tasks regarding tasks')
# models
task_model = api.model('Task', {
'title': fields.String(),
'description': fields.String()
})
@ns_tasks.route('')
class TasksList(Resource):
@api.doc(security='apiKey')
@jwt_required
def get(self):
""" use this ednpoint to get a list of tasks """
user_id = get_jwt_identity()
user = UserModel.fetch_by_id(user_id)
user_tasks = user.tasks
return tasks_schema.dump(user_tasks)
@api.doc(security='apiKey')
@api.expect(task_model)
@jwt_required
def post(self):
""" use this ednpoint to add a new task """
data = api.payload
import accessToken #file containing the generated access token
import password #file containing the generated password
import timeformat #file containing the function to generate timestamp in the following format YYYYMMDDHHmmss
generated_password = password.the_decoded_password
generated_timestamp = timeformat.the_formatted_time
# create a namespace for the stk resource
ns_stkpush = api.namespace('stkpush', description="MPESA STK PUSH")
stk_transaction = api.model(
'Stk', {
"amount":
fields.Integer(min=1, required=True),
"phoneNumber":
fields.String(
description='Your Phone Number in the format 254XXXXXXXXX',
required=True)
})
@ns_stkpush.route('')
class Stkpush(Resource):
@api.expect(stk_transaction)
def post(self):
"""Use this API endpoint to initiate online payment on behalf of a customer."""
data = api.payload
access_token = accessToken.gerated_access_token
api_url = "https://sandbox.safaricom.co.ke/mpesa/stkpush/v1/processrequest"
headers = {"Authorization": "Bearer %s" % access_token}
request = {
"BusinessShortCode": constants.BusinessShortCode,