Ejemplo n.º 1
0
def confirmEmail(userId:str):
    user = accountModel.UserAccount.objects(id=userId).first()
    if user:
        if user.active:
            responseData = {"message": "account already activated", "detail": {
                "login": "******",
                "url": f"{WEBSITE_URL}/{API_BASE_URI}/login",
                "body": {"email": "string", "password": "******"}
            }}
            return KhairoFullMixin.Response(userMessage=responseData,
                                            success=False,
                                            status_code=status.HTTP_401_UNAUTHORIZED)
        user.update(active=True)
        SuccessResponseData = {
            "user": user.to_json(indent=4),
            "message": "Account verified successfully",
            "extra":{
                "login":"******",
                "method":"post",
                "body":{"email":"string", "password":"******"}
            }
        }
        return KhairoFullMixin.Response(userMessage=SuccessResponseData,
                                           status_code=status.HTTP_200_OK, success=True)
    ErrorResponseData = {"message": "Account does not exist"}
    return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                       status_code=status.HTTP_401_UNAUTHORIZED,
                                       success=False)
Ejemplo n.º 2
0
async def remove_single_service(serviceId: str, user: dict = Depends(AccountManager.authenticate_user)):

    """[remove or delete service]

    Args:
        serviceId (str): [service id to be removed]

    Returns:
        [type]: [objectId of the service deleted ]
        :param user:
        :param serviceId:
    """
    if user["admin"]:
        old_data = Service.get_single_service(serviceId)
        if old_data:
            try:
                os.unlink(old_data.image_path)
                old_data.delete()
                return KhairoFullMixin.Response(userMessage={"id": serviceId}, status_code=status.HTTP_200_OK)
            except OSError as e:
                return KhairoFullMixin.Response(userMessage={"message": " error deleting service"},
                                                status_code=status.HTTP_404_NOT_FOUND)
            except Exception as e:
                return KhairoFullMixin.Response(userMessage={"message": " error deleting service"},
                                                status_code=status.HTTP_404_NOT_FOUND)
        return KhairoFullMixin.Response(userMessage={"message": " service does not exist"},
                                        status_code=status.HTTP_404_NOT_FOUND)
    else:
        return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                        status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 3
0
def passwordReset(userOldData:UserPasswordReset, userId:str):
    user = accountModel.UserAccount.objects(id=userId, email=userOldData.email)
    if user:
            if userOldData.password.strip() == userOldData.confirmPassword.strip():
                newPassword = AccountManager.hash_password(password=userOldData.password)
                if newPassword:
                    user.update(password=newPassword, passwordCode=None)
                    SuccessResponseData = {
                        "user": user.to_json(indent=4),
                        "message": "password change successfully",
                        "extra": {
                            "login": "******",
                            "method": "post",
                            "body": {"email": "string", "password": "******"}
                        }
                    }
                    return KhairoFullMixin.Response(userMessage=SuccessResponseData,
                                                       status_code=status.HTTP_200_OK, success=True)
                ErrorResponseData = {"message": "could not change password"}
                return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                                   status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                                                   success=False)
            ErrorResponseData = {"message": "password does not match "}
            return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                               status_code=status.HTTP_400_BAD_REQUEST,
                                               success=False)

    ErrorResponseData = {"message": "Account does not exist"}
    return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                       status_code=status.HTTP_401_UNAUTHORIZED,
                                       success=False)
Ejemplo n.º 4
0
async def update_service_option(optionId: str, user: dict = Depends(AccountManager.authenticate_user)):
    if user["admin"]:
        old_option = ServiceOption.get_single_option(optionId)
        if old_option:
            old_option.delete()
            return KhairoFullMixin.Response(userMessage={"id": optionId}, status_code=status.HTTP_200_OK)
        return KhairoFullMixin.Response(userMessage={"message": "error deleting option"},
                                        status_code=status.HTTP_400_BAD_REQUEST)
    return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 5
0
async def create_service_category(categoryId: str, user: dict = Depends(AccountManager.authenticate_user)):
    if user["admin"]:
        new_Category = Categories.get_single_category(categoryId)
        if new_Category:
            new_Category.delete()
            return KhairoFullMixin.Response(userMessage={"id": categoryId}, status_code=status.HTTP_200_OK)
        return KhairoFullMixin.Response(userMessage={"message": "category is found"},
                                        status_code=status.HTTP_404_NOT_FOUND)
    return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 6
0
async def create_service_option(optionData: OptionInput, user: dict = Depends(AccountManager.authenticate_user)):
    if user["admin"]:
        new_option = ServiceOption(**optionData.dict())
        new_option.save(clean=True)
        if new_option:
            return KhairoFullMixin.Response(userMessage={"option": new_option.to_json()},
                                            status_code=status.HTTP_201_CREATED)
        return KhairoFullMixin.Response(userMessage={"message": "error creating option"},
                                        status_code=status.HTTP_400_BAD_REQUEST)
    return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 7
0
async def create_service_category(category: CategoryInput, user: dict = Depends(AccountManager.authenticate_user)):
    if user["admin"]:
        new_Category = Categories(**category.dict())
        new_Category.save(clean=True)
        if new_Category:
            return KhairoFullMixin.Response(userMessage={"category": new_Category.to_json()},
                                            status_code=status.HTTP_201_CREATED)
        return KhairoFullMixin.Response(userMessage={"message": "error adding category"},
                                        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
    return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 8
0
async def update_service_option(optionData: OptionUpdateInput, user: dict = Depends(AccountManager.authenticate_user)):
    if user["admin"]:
        update_option = ServiceOption.get_single_option(optionId=optionData.id)
        if update_option:
            update_option.update(option=optionData.option)
            update_option.save()
            return KhairoFullMixin.Response(userMessage={"option": update_option.to_json()},
                                            status_code=status.HTTP_200_OK)
        return KhairoFullMixin.Response(userMessage={"message": "error creating option"},
                                        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
    return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 9
0
def confirmEmail(userId: str):
    user = accountModel.UserAccount.objects(id=userId).first()
    if user:
        if user.active:
            responseData = {"message": "account already activated"}
            return KhairoFullMixin.Response(userMessage=responseData,
                                            status_code=status.HTTP_400_BAD_REQUEST)
        user.update(active=True)
        SuccessResponseData = {"message": "Account verified successfully"}
        return KhairoFullMixin.Response(userMessage=SuccessResponseData,
                                        status_code=status.HTTP_200_OK)
    ErrorResponseData = {"message": "Account does not exist"}
    return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 10
0
async def get_single_service(serviceId: str):
    """[get single service]

    Args:
        serviceId (str): [the service Id to be returned]

    Returns:
        [type]: [match service id if exist]
    """
    service = Service.get_single_service(serviceId)
    if service:
        return KhairoFullMixin.Response(userMessage={"service": service.to_json()}, status_code=status.HTTP_200_OK)
    return KhairoFullMixin.Response(userMessage={"message": "service does not exist user"},
                                    status_code=status.HTTP_400_BAD_REQUEST)
Ejemplo n.º 11
0
def getPasswordLink(userOldData: GetPasswordResetLink, background: BackgroundTasks):
    user = accountModel.UserAccount.get_singleUserByEmail(email=userOldData.email)
    if user:
        mailData = {
            "title": "Password reset",
            "message": f"password reset pass code\n Password reset link: {userOldData.passwordReset_url}/{user.id}"
        }
        background.add_task(KhairoFullMixin.mailUser, userEmail=user.email,
                            emailTitle=mailData.get("title"),
                            emailMessage=mailData.get("message"))
        ResponseData = {"message": "Check your email for password reset link"}
        return KhairoFullMixin.Response(userMessage=ResponseData,
                                        status_code=status.HTTP_200_OK)
    ErrorResponseData = {"message": "Account does not exist"}
    return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 12
0
async def create_service(serviceData: ServiceInput = Depends(ServiceInput.as_form),
                         user: dict = Depends(AccountManager.authenticate_user)):
    """[creating new service]

    Args:
        serviceData (ServiceInput): [name, description, cover_img, price, options, categories]

    Returns:
        [type]: [new_service]
        :param user:
        :param serviceData:
        :type cover_img: object

    """

    # file_type = cover_img.content_type[-3:]
    if user["admin"]:
        try:
            random_string = uuid4().hex
            file_location = f"{STATIC_DIR}/{random_string}{serviceData.cover_image.filename}"
            new_service = Service(
                name=serviceData.name,
                description=serviceData.description,
                price=serviceData.price,
                category=serviceData.category,
                options=serviceData.options.split(','),
                image_path=file_location,
                cover_img=f"{WEBSITE_URL}/{STATIC_FILE_NAME}/{random_string}{serviceData.cover_image.filename}"
            ).save()
            if new_service:
                await KhairoFullMixin.upload(fileObject=serviceData.cover_image, file_path=file_location)
                return KhairoFullMixin.Response(
                    userMessage={"service": new_service.to_json()},
                    status_code=status.HTTP_201_CREATED)
            else:
                new_service.delete()
                return KhairoFullMixin.Response(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                                                userMessage={"error": "Error saving service"})
        except NotUniqueError:
            return KhairoFullMixin.Response(userMessage={"message": "service with this name already exist"},
                                            status_code=status.HTTP_400_BAD_REQUEST)
    return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 13
0
def loginUserAccount(userIn: UserLoginInput, response: Response):
    user = accountModel.UserAccount.get_singleUserByEmail(email=userIn.email)
    if user:
        if user.active:
            if AccountManager.check_password(userIn.password, user.password):
                encode_jwt_access, encode_jwt_refresh = AccountManager.JwtEncoder(
                    user=user.to_json())
                if encode_jwt_access and encode_jwt_refresh:
                    response.set_cookie(key="refresh_token",
                                        value=encode_jwt_refresh,
                                        httponly=True,
                                        max_age=172800,
                                        expires=172800,
                                        domain=WEBSITE_URL,
                                        secure=True)
                plan = accountModel.UserPlan.get_user_plan(userId=user.id)
                SuccessResponseData = {
                    "user": user.to_json(indent=4),
                    "plan": plan.active_plan.to_json() if plan else None,
                    "message": "logged in successfully",
                    "access_token": encode_jwt_access,
                    "access_token_type": "Bearer",
                    "expires": "2 days"
                }
                return KhairoFullMixin.Response(userMessage=SuccessResponseData,
                                                status_code=status.HTTP_200_OK)

            ErrorResponseData = {"message": "Password does not match"}
            return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                            status_code=status.HTTP_401_UNAUTHORIZED)

        ErrorResponseData = {
            "message": "Email was sent to you, please verify your email"}
        return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                        status_code=status.HTTP_401_UNAUTHORIZED)

    ErrorResponseData = {"message": "Account does not exist"}
    return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 14
0
def passwordReset(userOldData: UserPasswordReset):
    user = accountModel.UserAccount.objects(id=userOldData.userId).first()
    if user:
        if userOldData.password.strip() == userOldData.confirmPassword.strip():
            newPassword = AccountManager.hash_password(
                password=userOldData.password)
            if newPassword:
                # user.update(password=newPassword, passwordCode=None)
                SuccessResponseData ={"message": "password change successfully"},
                   
                return KhairoFullMixin.Response(userMessage=SuccessResponseData,
                                                status_code=status.HTTP_200_OK)
            ErrorResponseData = {"message": "could not change password"}
            return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
        ErrorResponseData = {"message": "password does not match "}
        return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                        status_code=status.HTTP_400_BAD_REQUEST)

    ErrorResponseData = {"message": "Account does not exist"}
    return KhairoFullMixin.Response(userMessage=ErrorResponseData,
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 15
0
async def update_single_service(serviceData: ServiceUpdateInput, user: dict = Depends(AccountManager.authenticate_user)):
    """[updating service]

    Args:
        serviceData (ServiceUpdateInput): [any passed data]

    Returns:
        [type]: [update_service]
        :param serviceData:
        :param user:
    """
    if user["admin"]:
        update_service = Service.get_single_service(serviceId=serviceData.id)
        if update_service:
            update_service.update(**serviceData.dict())
            update_service.save(clean=True)
            if update_service:
                return KhairoFullMixin.Response(userMessage={"service": update_service.to_json()}, status_code=status.HTTP_200_OK)
            return KhairoFullMixin.Response(userMessage={"message": "Error updating  service"},
                                            status_code=status.HTTP_400_BAD_REQUEST)
    else:
        return KhairoFullMixin.Response(userMessage={"message": " error validating admin"},
                                        status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 16
0
def registerUserAccount(user:UserRegisterationInput, background:BackgroundTasks):
    if accountModel.UserAccount.get_singleUserByEmail(email=user.email):
        ErrorResponse = {"message": "Account does not exist"}
        return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False,
                                    status_code=status.HTTP_400_BAD_REQUEST)
    if user.password.strip() == user.confirmPassword.strip():
        try:
            password = AccountManager.hash_password(password=user.password)
            newUserDetails = {
                "firstname": user.firstname,
                "lastname":user.lastname,
                "email": user.email,
                "password": password
            }
            newUser = accountModel.UserAccount(**newUserDetails).save(clean=True)
            if newUser:
                mailData = {
                    "title":"Khairo diet Account verification",
                    "message":f" Welcome to {WEBSITE_NAME}, {newUser.firstname} { newUser.lastname}\n "
                              f"Your account was created successfully please "
                              f"verify your email to continue\n {WEBSITE_URL}{API_BASE_URI}/user/{newUser.id}"
                }
                
                background.add_task(KhairoFullMixin.mailUser, userEmail=newUser.email,
                                             emailTitle=mailData.get("title"),
                                             emailMessage=mailData.get("message"))

                SuccessResponseData = {
                    "user": {"firstname":newUser.firstname, "lastname":newUser.lastname},
                    "message": "Account was created successfully",
                    "confirm email": "A mail was sent to your to confirm your email address"
                    }

                return KhairoFullMixin.Response(userMessage=SuccessResponseData, success=True,
                                                   status_code=status.HTTP_201_CREATED)
            ErrorResponse = {"message": "Error creating account, check your detail and try again"}
            return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False,
                                               status_code=status.HTTP_400_BAD_REQUEST)
        except errors.ValidationError:
            ErrorResponse = {"message": "Error creating account, check your detail and try again"}
            return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False,
                                               status_code=status.HTTP_400_BAD_REQUEST)

        except errors.NotUniqueError:
            ErrorResponse = {"message": "Account with this email already exist, try again"}
            return KhairoFullMixin.Response(userMessage=ErrorResponse, success=False,
                                            status_code=status.HTTP_400_BAD_REQUEST)

    ErrorResponse = {"message": "Password do not match, try again"}
    return KhairoFullMixin.Response(userMessage=ErrorResponse,
                                    success=False,
                                    status_code=status.HTTP_400_BAD_REQUEST)
Ejemplo n.º 17
0
async def get_service_option():
    all_option = ServiceOption.get_all_option()
    if all_option:
        return KhairoFullMixin.Response(userMessage={"option": [option.to_json() for option in all_option]}, status_code=status.HTTP_200_OK)
    return KhairoFullMixin.Response(userMessage={"message": "no option is found"},
                                    status_code=status.HTTP_401_UNAUTHORIZED)
Ejemplo n.º 18
0
async def get_all_service():
    all_service = Service.get_all_service()
    if all_service:
        return KhairoFullMixin.Response(userMessage={"service": [service.to_json() for service in all_service]},  status_code=status.HTTP_200_OK)
    return KhairoFullMixin.Response(userMessage={"message": "error getting all product"},
                                    status_code=status.HTTP_404_NOT_FOUND)
Ejemplo n.º 19
0
def getUserAccount(user: dict = Depends(AccountManager.authenticate_user)):
    plan = accountModel.UserPlan.get_user_plan(userid=user["id"])
    return KhairoFullMixin.Response({"user": user,
                                     "plan": plan.active_plan.to_json() if plan else None},
                                    status_code=status.HTTP_200_OK)
Ejemplo n.º 20
0
async def create_service_category():
    get_all_category = Categories.get_all_category()
    if get_all_category:
        return KhairoFullMixin.Response(userMessage={"category": [category.to_json() for category in get_all_category]}, status_code=status.HTTP_200_OK)
    return KhairoFullMixin.Response(userMessage={"message": "no category is found"},
                                    status_code=status.HTTP_404_NOT_FOUND)
Ejemplo n.º 21
0
async def update_service_option(optionId: str):
    single_option = ServiceOption.get_single_option(optionId)
    if single_option:
        return KhairoFullMixin.Response(userMessage={"option": single_option.to_json()}, status_code=status.HTTP_200_OK)
    return KhairoFullMixin.Response(userMessage={"message": "option does not exist"},
                                    status_code=status.HTTP_404_NOT_FOUND)