def test_list_admin_users_ok_response(self, mock_get_user_by_email_or_id,
mock_filter_by,
mock_pagination_meta):
'''
Test list_admin_users OK response.
'''
# Arrange
with self.app.app_context():
mock_filter_by.return_value.items = [
self.mock_user_role,
]
mock_get_user_by_email_or_id.return_value = {
"id": "-LXTuXlk2W4Gskt8KTte",
"email": "*****@*****.**",
"first_name": "Joseph",
"last_name": "Serunjogi",
"name": "Joseph Serunjogi"
}
mock_pagination_meta.return_value = {
"total_rows": 1,
"total_pages": 1,
"current_page": 1,
"next_page": None,
"prev_page": None
}
user_controller = UserController(self.request_context)
# Act
result = user_controller.list_admin_users()
# Assert
assert result.status_code == 200
assert result.get_json()['msg'] == 'OK'
assert result.get_json()['payload']['meta']['current_page'] == 1
assert result.get_json()['payload']['meta']['next_page'] == None
def test_list_user_succeeds(
self,
mock_user_repo_find_first,
):
with self.app.app_context():
role = RoleFactory()
UserRoleFactory(user_id=self.mock_user.id, role_id=role.id)
PermissionFactory.create(keyword="view_users", role=role)
mock_user_repo_find_first.return_value = self.mock_user
user_controller = UserController(self.request_context)
response = user_controller.list_user(id=self.mock_user.id)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()["msg"], "OK")
self.assertEqual(
response.get_json()["payload"]["user"]["first_name"],
self.mock_user.first_name,
)
self.assertEqual(
response.get_json()["payload"]["user"]["last_name"],
self.mock_user.last_name,
)
def test_create_user_method_handles_user_creation_with_non_existent_role_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory()
role = RoleFactory(name="test_role")
UserRoleFactory(role_id=role.id, user_id=user.id)
non_existent_role_id = 100
mock_request_params.return_value = [
"Joseph",
"Serunjogi",
"*****@*****.**",
non_existent_role_id,
"male",
str(datetime.now()),
1,
"password",
]
user_controller = UserController(self.request_context)
response = user_controller.create_user()
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.get_json()["msg"],
"Role with userTypeId(roleId) {} does not exist".format(
non_existent_role_id),
)
def test_list_admin_users_ok_response(self, mock_user_repo_find_first,
mock_filter_by,
mock_pagination_meta):
"""
Test list_admin_users OK response.
"""
# Arrange
with self.app.app_context():
mock_filter_by.return_value.items = [
self.mock_user_role,
]
mock_user_repo_find_first.return_value = self.mock_user
mock_pagination_meta.return_value = {
"total_rows": 1,
"total_pages": 1,
"current_page": 1,
"next_page": None,
"prev_page": None,
}
user_controller = UserController(self.request_context)
# Act
result = user_controller.list_admin_users()
# Assert
assert result.status_code == 200
assert result.get_json()["msg"] == "OK"
assert result.get_json()["payload"]["meta"]["current_page"] == 1
assert result.get_json()["payload"]["meta"]["next_page"] is None
def test_list_user_when_user_found_succeeds(self):
with self.app.app_context():
user_controller = UserController(self.request_context)
response = user_controller.list_user(slack_id="-LXTuXlk2W4Gskt8KTtedhmdydsbnyw")
self.assertEqual(response.status_code, 404)
self.assertEqual(response.get_json()['msg'], 'User not found')
def test_list_user_when_user_found_succeeds(
self,
mock_user_repo_find_first,
):
with self.app.app_context():
user_controller = UserController(self.request_context)
mock_user_repo_find_first.return_value = self.mock_user
response = user_controller.list_user(id=1)
self.assertEqual(response.status_code, 200)
def salvar_cadastro():
try:
UserController.create(
username=request.form['username'],
password=request.form['password'],
email=request.form['email'],
fullname=request.form['name'],
gender=request.form['gender'],
contact_number=request.form['number'],
address=request.form['location'],
)
return redirect('/access_allowed')
except:
return redirect('/access_denied')
def test_create_user_succeeds(self, mock_request_params):
with self.app.app_context():
mock_request_params.return_value = [
"*****@*****.**", "Eno", "Bassey", "-LXTuXlk2W4Gskt8KTte",
False
]
user_controller = UserController(self.request_context)
# Act
result = user_controller.create_user()
# Assert
assert result.status_code == 201
assert result.get_json()['msg'] == 'OK'
def test_list_user_succeeds(self):
with self.app.app_context():
role = RoleFactory()
user_role = UserRoleFactory(role_id=role.id)
user = UserFactory(slack_id="-LXTuXlk2W4Gskt8KTte", user_type_id=user_role.id)
user_controller = UserController(self.request_context)
response = user_controller.list_user(slack_id=user.slack_id)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()['msg'], "OK")
self.assertEqual(response.get_json()['payload']['user']['slackId'], user.slack_id)
self.assertEqual(response.get_json()['payload']['user']['firstName'], user.first_name)
self.assertEqual(response.get_json()['payload']['user']['lastName'], user.last_name)
def post(self):
"""
Add a new user
"""
from app.controllers.user_controller import UserController
post_data = request.get_json()
return UserController.create_user(post_data)
def post(self):
"""
Login user through telegram
"""
post_data = request.get_json()
user_data = {
"id": post_data.get("id", None),
"first_name": post_data.get("first_name", None),
"last_name": post_data.get("last_name", None),
"username": post_data.get("username", None),
"photo_url": post_data.get("photo_url", None),
"auth_date": post_data.get("auth_date", None),
"hash": post_data.get("hash", None)
}
data_check_string = self._concat_params_to_string(user_data)
data_check_string_bytes = data_check_string.encode("utf-8")
secret_key = os.environ.get("ACCESS_TOKEN", None)
secret_key_bytes = hashlib.sha256(secret_key.encode("utf-8")).digest()
hmac_string = hmac.new(secret_key_bytes, data_check_string_bytes,
hashlib.sha256).hexdigest()
# if everything is ok with telegram then
from app.controllers.user_controller import UserController
return UserController.create_user(post_data)
def add_coin():
data = request.get_json()
percent = 100
if "symbol" in data and "user_id" in data:
symbol = data["symbol"]
user_id = data["user_id"]
else:
return jsonify(success=0, results={}, message="Некорректные данные")
if "percent" in data:
percent = data["percent"]
coin = CoinController.from_db(symbol=symbol)
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
if not coin:
return jsonify(success=0, results={}, message="Монета не найдена")
wallet = user.add_coin(coin, percent)
if wallet:
return jsonify(success=1,
results=wallet.to_json(),
message="Кошелек получен")
jsonify(success=0, results={}, message="Кошелек не найден")
def test_create_user_method_handles_user_creation_with_duplicate_user_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory(user_id="-LXTuXlk2W4Gskt8KTte")
role = RoleFactory(name='test_role')
UserRoleFactory(role_id=role.id, user_id=user.id)
mock_request_params.return_value = [
"Joseph", "Serunjogi", None, None, user.user_id, role.id
]
user_controller = UserController(self.request_context)
response = user_controller.create_user()
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.get_json()['msg'],
"User with userId '{}' already exists".format(user.user_id))
def test_create_user_method_handles_user_creation_with_duplicate_email_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory(email="*****@*****.**",
password="******")
mock_request_params.return_value = [
user.email, "Joseph", "Serunjogi", "-LXTuXlk2W4Gskt8KTte",
False
]
user_controller = UserController(self.request_context)
response = user_controller.create_user()
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.get_json()['msg'],
"User with email '{}' already exists".format(user.email))
def test_list_user_succeeds(self):
with self.app.app_context():
user = UserFactory.create(email="*****@*****.**",
password="******")
user_controller = UserController(self.request_context)
response = user_controller.list_user(email="*****@*****.**")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.get_json()['msg'], "OK")
self.assertEqual(response.get_json()['payload']['user']['email'],
user.email)
self.assertEqual(
response.get_json()['payload']['user']['firstName'],
user.first_name)
self.assertEqual(
response.get_json()['payload']['user']['lastName'],
user.last_name)
def test_create_user_succeeds(self, mock_request_params,
mock_get_location):
location = LocationFactory()
role = RoleFactory(name='test_role')
with self.app.app_context():
mock_get_location.return_value = location.id
mock_request_params.return_value = [
"Joseph", "Serunjogi", None, None, "-LXTuXlk2W4Gskt8KTte",
role.id
]
user_controller = UserController(self.request_context)
# Act
result = user_controller.create_user()
# Assert
assert result.status_code == 201
assert result.get_json()['msg'] == 'OK'
def test_create_user_fails_for_existing_user(
self,
mock_user_role_repo_new_user_role,
# mock_user_repo_new_user,
mock_user_repo_exists,
mock_role_repo_find_first,
mock_request_params,
mock_get_location,
):
location = LocationFactory()
role = RoleFactory(name="test_role")
with self.app.app_context():
mock_get_location.return_value = location.id
mock_role_repo_find_first.return_value = self.mock_role
mock_user_repo_exists.return_value = self.mock_user2
# mock_user_repo_new_user.return_value = None
mock_user_role_repo_new_user_role.return_value = self.mock_user_role
mock_request_params.return_value = [
"Joseph",
"Serunjogi",
self.mock_user2.email,
role.id,
"male",
str(datetime.now()),
1,
"password",
]
user_controller = UserController(self.request_context)
# Act
result = user_controller.create_user()
print(result)
print(result.get_json())
# Assert
assert result.status_code == 400
assert (
result.get_json()["msg"] ==
f"User with email '{self.mock_user2.email}' already exists")
def overall_balance():
data = request.get_json()
if "user_id" in data:
user_id = data["user_id"]
else:
return jsonify(success=0, results={}, message="Отсутствует user_id")
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
balance = user.get_overall_balance()
return jsonify(success=1, results={"balance": balance}, message="Успешно")
def index():
if request.method == 'GET':
text_query = request.args.get('q', None)
users = None
if text_query != None:
users = UserController.find_by_name(text_query)
else:
users = UserController.get_all_users()
return {"users": users}
if request.method == 'POST':
req_body = request.json
res = UserController.create_user(req_body)
return {
'user': res.get('value'),
'success': res.get('success', False),
'message': res.get('message')
}
if request.method == 'DELETE':
success = UserController.delete_all_users()
return {"success": success}
def user_by_id(user_id=None):
if request.method == 'GET':
message = 'user not found'
user = UserController.find_by_id(user_id)
return {
'user': user,
'success': True if user else False,
'message': None if user else message
}
if request.method == 'PUT':
req_body = request.json
res = UserController.update_user(user_id, req_body)
return {
'user': res.get('value'),
'success': res.get('success', False),
'message': res.get('message')
}
if request.method == 'DELETE':
res = UserController.delete_user(user_id)
return {
'success': res.get('success', False),
'message': res.get('message')
}
def test_create_user_method_handles_user_creation_with_non_existent_role_id(
self, mock_request_params):
with self.app.app_context():
user = UserFactory(user_id="-LXTuXlk2W4Gskt8KTte")
role = RoleFactory(name='test_role')
UserRoleFactory(role_id=role.id, user_id=user.id)
non_existent_role_id = 100
mock_request_params.return_value = [
"Joseph", "Serunjogi", None, None, user.user_id,
non_existent_role_id
]
user_controller = UserController(self.request_context)
response = user_controller.create_user()
self.assertEqual(response.status_code, 400)
self.assertEqual(
response.get_json()['msg'],
"Role with userTypeId(roleId) {} does not exist".format(
non_existent_role_id))
def test_create_user_succeeds(
self,
mock_user_role_repo_new_user_role,
mock_user_repo_new_user,
mock_user_repo_exists,
mock_role_repo_find_first,
mock_request_params,
mock_get_location,
):
location = LocationFactory()
role = RoleFactory(name="test_role")
with self.app.app_context():
mock_get_location.return_value = location.id
mock_role_repo_find_first.return_value = self.mock_role
mock_user_repo_exists.return_value = None
mock_user_repo_new_user.return_value = self.mock_user2
mock_user_role_repo_new_user_role.return_value = self.mock_user_role
mock_request_params.return_value = [
"Joseph",
"Serunjogi",
"*****@*****.**",
role.id,
"male",
str(datetime.now()),
1,
"password",
]
user_controller = UserController(self.request_context)
# Act
result = user_controller.create_user()
# Assert
assert result.status_code == 201
assert result.get_json()["msg"] == "OK"
def get_user():
data = request.get_json()
user_id: int = data["user_id"]
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
user_data = {
"name": user.name,
"email": user.email,
"balance": user.balance
}
return jsonify(success=1,
results=user_data,
message="Пользователь получен успешно")
def top_up():
data = request.get_json()
if "user_id" in data and "amount":
user_id = data["user_id"]
amount = data["amount"]
else:
return jsonify(success=0, results={}, message="Отсутствует user_id")
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
user.user.top_up(amount)
return jsonify(success=1,
results={"balance": user.balance},
message="Успешно")
def get_trades():
data = request.get_json()
if "user_id" in data:
user_id = data["user_id"]
else:
return jsonify(success=0, results={}, message="Отсутствует user_id")
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
results = list()
for trade in user.trades:
results.append(trade.to_json())
return jsonify(success=1, results=results, message="Успешно")
def get_wallets():
data = request.get_json()
if "user_id" in data:
user_id = data["user_id"]
else:
return jsonify(success=0, results={}, message="Некорректные данные")
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
wallets = user.wallets
results = list()
for wallet in wallets:
results.append(wallet.to_json())
return jsonify(success=1, results=results, message="Успешно")
def sell_coin():
data = request.get_json()
if "user_id" in data and "symbol" in data:
user_id = data["user_id"]
symbol = data["symbol"]
else:
return jsonify(success=0,
results={},
message="Отсутствует ключ 'user_id' или 'user_id'")
coin = CoinController.from_db(symbol=symbol)
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
if not coin:
return jsonify(success=0, results={}, message="Монета не найдена")
wallet = user.get_wallet(coin)
wallet.sell()
return jsonify(success=1, results={}, message="Монета продана")
def make_shell_context():
from app.main.models import User, Coin, Wallet
from app.controllers.wallet_controller import WalletController
from app.controllers.coin_controller import CoinController
from app.controllers.user_controller import UserController
from app.controllers.model_controller import ModelController
from app.controllers.binance_controller import BinanceController
return {
'db': db,
'User': User,
'Coin': Coin,
"Wallet": Wallet,
"WC": WalletController,
"CC": CoinController,
"UC": UserController,
"MC": ModelController,
"BC": BinanceController,
"oleg": UserController.from_db(1),
"btc": CoinController.from_db(symbol="BTCUSDT"),
"eth": CoinController.from_db(symbol="ETHUSDT"),
"xrp": CoinController.from_db(symbol="XRPUSDT")
}
def get_profit():
data = request.get_json()
if "user_id" in data:
user_id = data["user_id"]
else:
return jsonify(success=0,
results={},
message="Отсутствует ключ 'user_id' или 'user_id'")
user = UserController.from_db(user_id)
if not user:
return jsonify(success=0, results={}, message="Пользователь не найден")
if "symbol" in data:
symbol = data["symbol"]
coin = CoinController.from_db(symbol=symbol)
wallet = user.get_wallet(coin)
profit = wallet.get_profit()
else:
profit = user.get_profit()
return jsonify(success=1, results={"profit": profit}, message=f"Профит")
from flask import jsonify, request, Blueprint
from flask.views import MethodView
from datetime import datetime
from flask_jwt_extended import get_jwt_identity, jwt_required
from app.validation import Validation
from app.decorator import admin_permission_required
from app.controllers.product_controller import ProductController
from app.controllers.sale_controller import SaleController
from app.controllers.user_controller import UserController
from app.db.db_functions import DBFunctions
validate = Validation()
product_controller = ProductController()
user_controller = UserController()
sale_controller = SaleController()
db_func = DBFunctions()
views_blueprint = Blueprint("views_blueprint", __name__)
"""PRODUCT VIEWS"""
class AddProduct(MethodView):
@admin_permission_required
def post(self):
try:
data = request.get_json()
search_keys = ("product", "quantity", "unit_price")
if all(key in data.keys() for key in search_keys):
product = data.get("product")
quantity = data.get("quantity")
unit_price = data.get("unit_price")
invalid = validate.product_validation(
