def test_change_currencies():
price = Decimal('1')
with create_session() as session:
currency = Currency(name='test',
purchasing_price=price,
selling_price=price)
session.add(currency)
change_currencies()
with create_session() as session:
currency = session.query(Currency).filter(Currency.id == 1).first()
assert currency.purchasing_price != price
assert currency.selling_price != price
def add_currency(name: str, selling_price: Decimal,
purchasing_price: Decimal) -> AbstractSerialize:
with create_session() as session:
if selling_price <= 0 or purchasing_price <= 0:
raise CurrenciesDALException(
'Selling or purchasing price less or equal to zero')
if (session.query(Currency).filter(Currency.name == name).first()
is not None):
raise CurrenciesDALException(
'Currency with this name already exists')
currency = Currency(
name=name,
selling_price=selling_price,
purchasing_price=purchasing_price,
modified_at=datetime.now(),
)
session.add(currency)
session.flush()
currency_history = CurrencyHistory(
currency_id=currency.id,
time=currency.modified_at,
purchasing_price=purchasing_price,
selling_price=selling_price,
)
session.add(currency_history)
return serialize(currency)
def get_currency_by_id(currency_id: int) -> AbstractSerialize:
with create_session() as session:
res: Currency = session.query(Currency).filter(
Currency.id == currency_id).first()
if res is None:
raise CurrenciesDALException('Currency not exists')
return serialize(res)
def get_user_operations_history(
user_id: int,
operation_type: Optional[OperationType] = None,
size: Optional[int] = None,
page: Optional[int] = None,
) -> List[AbstractSerialize]:
with create_session() as session:
check_user_existence_and_get_if_exists(user_id, session)
operations_query: Query = session.query(Operation).filter(
Operation.user_id == user_id)
if operation_type is not None:
operations = operations_query.filter(
Operation.operation_type == operation_type).all()
else:
operations = operations_query.all()
if operations is None:
raise UsersDALException(
'Cannot find operations with this parameters')
if size is None and page is not None or size is not None and page is None:
raise PaginationError('size or page not stated')
if size is not None and page is not None:
operations = MyPagination.get_pagination(
operations, page, size)
res = []
for operation in operations:
res.append(serialize(operation))
return res
def get_currency(user_id: int, currency_id: int) -> AbstractSerialize:
with create_session() as session:
res = session.query(UserCurrency).filter(
UserCurrency.user_id == user_id,
UserCurrency.currency_id == currency_id).first()
if not res:
raise UsersDALException()
return serialize(res)
def add_user(login: str) -> AbstractSerialize:
with create_session() as session:
if session.query(User).filter(User.login == login).first() is None:
u = User(login=login, money=settings.start_money)
session.add(u)
session.flush()
return serialize(u)
raise UsersDALException(Message.USER_ALREADY_CREATED.value)
def test_add_currency(currency_params):
currency: CurrencyOutputFields = CurrenciesDAL.add_currency(
*currency_params)
assert currency.id == 1
with create_session() as session:
currency = session.query(Currency).filter(Currency.id == 1).first()
assert currency.selling_price == currency_params[1]
assert currency.purchasing_price == currency_params[2]
def get_user_by_name(user_name: str) -> AbstractSerialize:
with create_session() as session:
try:
user = session.query(User).filter(
User.login == user_name).one()
return serialize(user)
except NoResultFound:
raise UsersDALException()
def get_user_currencies(user_id: int) -> List[AbstractSerialize]:
res: List[AbstractSerialize] = []
with create_session() as session:
check_user_existence_and_get_if_exists(user_id, session)
user_currencies = (session.query(UserCurrency).filter(
UserCurrency.user_id == user_id).all())
for user_currency in user_currencies:
res.append(serialize(user_currency))
return res
def test_add_user(client: FlaskClient, user_login):
response: Response = client.post(
'/users/',
data=json.dumps(dict(login=user_login)),
content_type='application/json',
)
assert response.status_code == HTTPStatus.CREATED
with create_session() as session:
res: User = session.query(User).filter(User.id == 1).first()
assert res.money == settings.start_money
assert res.login == user_login
def get_currency_history(currency_id: int) -> List[AbstractSerialize]:
with create_session() as session:
currency = (session.query(Currency).filter(
Currency.id == currency_id).first())
if currency is None:
raise CurrenciesDALException('Currency not exists')
res: List[AbstractSerialize] = []
for currency_history in (session.query(CurrencyHistory).filter(
CurrencyHistory.currency_id == currency_id).all()):
res.append(serialize(currency_history))
return res
def test_buy_currency():
user_id = 1
currency_id = 1
amount = Decimal('1')
user_currency: UserCurrencyFields = UsersDAL.make_operation_with_currency(
user_id, currency_id, OperationType.BUY, amount, datetime.now())
assert user_currency.id == currency_id
assert user_currency.user_id == user_id
assert user_currency.amount == amount
with create_session() as session:
user = session.query(User).filter(User.id == 1).first()
assert user.money == Decimal('999')
def test_sell_currency():
user_id = 1
currency_id = 1
amount = Decimal('1')
UsersDAL.make_operation_with_currency(user_id, currency_id,
OperationType.BUY, amount,
datetime.now())
user_currency: UserCurrencyFields = UsersDAL.make_operation_with_currency(
user_id, currency_id, OperationType.SELL, amount, datetime.now())
assert user_currency.amount == Decimal('0')
with create_session() as session:
user = session.query(User).filter(User.id == user_id).first()
assert user.money == Decimal('1000')
assert session.query(UserCurrency).filter(
UserCurrency.id == 1).first() is None
def change_currencies() -> None:
with create_session() as session:
for currency in session.query(Currency).all():
price = _get_new_random_price(
(currency.selling_price + currency.purchasing_price) / 2)
currency.selling_price = price * Decimal('0.975')
currency.purchasing_price = price * Decimal('1.025')
now = datetime.now()
currency.modified_at = now
session.add(currency)
session.flush()
currency_history: CurrencyHistory = CurrencyHistory(
currency_id=currency.id,
time=now,
purchasing_price=currency.purchasing_price,
selling_price=currency.selling_price,
)
session.add(currency_history)
def add_default_currencies() -> None:
Base.metadata.create_all(engine)
with create_session() as session:
if len(session.query(Currency).all()) == 0:
for c in settings.default_currencies:
now = datetime.now()
currency = Currency(
name=c.name,
selling_price=c.selling_price,
purchasing_price=c.purchasing_price,
modified_at=now,
)
session.add(currency)
session.flush()
currency_history: CurrencyHistory = CurrencyHistory(
currency_id=currency.id,
time=now,
purchasing_price=currency.purchasing_price,
selling_price=currency.selling_price,
)
session.add(currency_history)
def make_operation_with_currency(
user_id: int,
currency_id: int,
operation: OperationType,
amount: Decimal,
time: datetime,
) -> AbstractSerialize:
with create_session() as session:
currency: Currency = session.query(Currency).filter(
Currency.id == currency_id).first()
if currency is None:
raise UsersDALException('currency does not exist')
user = check_user_existence_and_get_if_exists(user_id, session)
check_course_changes(currency.modified_at, time)
user_currency: UserCurrency = session.query(UserCurrency).filter(
UserCurrency.user_id == user_id,
UserCurrency.currency_id == currency_id).first()
if amount <= 0:
raise UsersDALException('Invalid amount')
os = OperationStrategy()
if operation == OperationType.BUY:
os.set_strategy(Buy())
else:
os.set_strategy(Sell())
user_currency = os.invoke(currency, amount, user, user_currency)
session.add(user_currency)
session.flush()
copy = deepcopy(user_currency)
if user_currency.amount == 0:
session.delete(user_currency)
operation = Operation(
user_id=user_id,
currency_id=currency_id,
operation_type=operation,
amount=amount,
time=datetime.now(),
)
session.add(operation)
return serialize(copy)
def get_user_by_id(user_id: int) -> AbstractSerialize:
with create_session() as session:
user = check_user_existence_and_get_if_exists(user_id, session)
return serialize(user)
def test_add_user_to_db(user_login):
with create_session() as session:
user_from_db: User = session.query(User).filter(User.id == 1).first()
assert user_from_db.login == user_login
assert user_from_db.money == START_MONEY
def test_add_default_currencies() -> None:
add_default_currencies()
with create_session() as session:
currencies = session.query(Currency).all()
assert len(currencies) == len(settings.default_currencies)
def test_clear_db() -> None:
add_default_currencies()
clear_db()
with create_session() as session:
with pytest.raises(BaseException):
session.query(Currency).all()
def get_currencies() -> List[AbstractSerialize]:
currencies: List[AbstractSerialize] = []
with create_session() as session:
for currency in session.query(Currency):
currencies.append(serialize(currency))
return currencies
