def test_edit_market_price():
security = create_security()
committee = create_user(is_committee=True)
security_service.edit_market_price(
id=security["id"], subject_id=committee["id"], market_price=10
)
with session_scope() as session:
assert session.query(Security).one().market_price == 10
security_service.edit_market_price(
id=security["id"], subject_id=committee["id"], market_price=None
)
with session_scope() as session:
assert session.query(Security).one().market_price is None
def create_new_message(self, chat_room_id, message, author_id):
with session_scope() as session:
chat_room = session.query(ChatRoom).get(chat_room_id)
if chat_room is None:
raise ResourceNotFoundException("Chat room not found")
if ChatRoomService.is_disbanded(chat_room):
raise ResourceNotFoundException("Chat room is disbanded")
if (session.query(UserChatRoomAssociation).filter_by(
user_id=author_id,
chat_room_id=chat_room_id).count() == 0):
raise ResourceNotOwnedException(
"User is not in this chat room")
first_chat = (session.query(Chat).filter_by(
chat_room_id=chat_room_id).count() == 0)
message = Chat(
chat_room_id=str(chat_room_id),
message=message,
author_id=str(author_id),
)
session.add(message)
session.flush()
chat_room.updated_at = message.created_at
if first_chat:
other_party_id = ChatRoomService._get_other_party_id(
chat_room_id=str(chat_room.id), user_id=author_id)
other_party_email = session.query(User).get(
other_party_id).email
self.email_service.send_email(emails=[other_party_email],
template="new_chat_message")
return {"type": "chat", **message.asdict()}
def edit_offer_status(self, chat_room_id, offer_id, user_id, offer_status):
with session_scope() as session:
OfferService._check_deal_status(session=session,
chat_room_id=chat_room_id,
user_id=user_id)
offer = session.query(Offer).get(offer_id)
if offer.offer_status != "PENDING":
raise InvalidRequestException("Offer is closed")
if offer_status == "CANCELED" and offer.author_id != user_id:
raise InvalidRequestException("You can only cancel your offer")
if offer_status in ["ACCEPTED", "REJECTED"
] and offer.author_id == user_id:
raise InvalidRequestException(
"You can not accept/reject your own offer")
chat_room = session.query(ChatRoom).get(chat_room_id)
chat_room.updated_at = offer.created_at
chat_room.is_deal_closed = offer_status == "ACCEPTED"
offer.offer_status = offer_status
session.add(offer)
session.flush()
offer_response = OfferResponse(offer_id=str(offer.id))
session.add(offer_response)
session.flush()
return OfferService._serialize_chat_offer(
offer=offer.asdict(),
is_deal_closed=chat_room.is_deal_closed,
offer_response=offer_response.asdict(),
author_id=user_id,
)
def create_new_offer(self, chat_room_id, author_id, price,
number_of_shares):
with session_scope() as session:
OfferService._check_deal_status(session=session,
chat_room_id=chat_room_id,
user_id=author_id)
offers = session.query(Offer).filter_by(chat_room_id=chat_room_id,
offer_status="PENDING")
if offers.count() > 0:
raise InvalidRequestException("There are still pending offers")
chat_room = session.query(ChatRoom).get(chat_room_id)
if ChatRoomService.is_disbanded(chat_room):
raise ResourceNotFoundException("Chat room is disbanded")
offer = Offer(
chat_room_id=str(chat_room_id),
price=price,
number_of_shares=number_of_shares,
author_id=str(author_id),
)
session.add(offer)
session.flush()
chat_room.updated_at = offer.created_at
offer_dict = offer.asdict()
return OfferService._serialize_chat_offer(
offer=offer_dict, is_deal_closed=chat_room.is_deal_closed)
def _ban_user(self, my_user_id, other_user_id):
# Currently this bans the user two-way: both as buyer and as seller
with session_scope() as session:
session.add_all([
BannedPair(buyer_id=my_user_id, seller_id=other_user_id),
BannedPair(buyer_id=other_user_id, seller_id=my_user_id),
])
def _add_db_objects(
self,
round_id,
match_results,
sell_order_to_seller_dict,
buy_order_to_buyer_dict,
):
with session_scope() as session:
for buy_order_id, sell_order_id in match_results:
match = Match(buy_order_id=buy_order_id,
sell_order_id=sell_order_id)
session.add(match)
session.flush()
chat_room = ChatRoom(match_id=str(match.id))
session.add(chat_room)
session.flush()
buyer_assoc = UserChatRoomAssociation(
user_id=buy_order_to_buyer_dict[buy_order_id],
chat_room_id=str(chat_room.id),
role="BUYER",
)
seller_assoc = UserChatRoomAssociation(
user_id=sell_order_to_seller_dict[sell_order_id],
chat_room_id=str(chat_room.id),
role="SELLER",
)
session.add_all([buyer_assoc, seller_assoc])
session.query(Round).get(round_id).is_concluded = True
def get_stats(self):
with session_scope() as session:
return {
'sellers':
session.query(User).filter_by(can_sell=True).count(),
'buyers': session.query(User).filter_by(can_buy=True).count()
}
def archive_room(self, user_id, chat_room_id):
with session_scope() as session:
session.query(UserChatRoomAssociation).filter_by(
user_id=user_id,
chat_room_id=chat_room_id).one().is_archived = True
return {"chat_room_id": chat_room_id}
def create_new_offer(
self, chat_room_id, author_id, price, number_of_shares, user_type
):
with session_scope() as session:
OfferService._check_deal_status(
session=session,
chat_room_id=chat_room_id,
user_id=author_id,
user_type=user_type,
)
chat_room = session.query(ChatRoom).get(chat_room_id)
offer = Offer(
chat_room_id=str(chat_room_id),
price=price,
number_of_shares=number_of_shares,
author_id=str(author_id),
)
offer = OfferService._get_current_offer(session=session, offer=offer)
OfferService._update_chatroom_datetime(
session=session, chat_room=chat_room, offer=offer
)
return OfferService._serialize_chat_offer(
chat_room_id=chat_room_id,
offer=offer,
is_deal_closed=chat_room.is_deal_closed,
)
def test_create_order__authorized():
user = create_user()
user_id = user["id"]
security_id = create_security()["id"]
sell_order_params = {
"user_id": user_id,
"number_of_shares": 20,
"price": 30,
"security_id": security_id,
}
with patch("src.services.RoundService.get_active", return_value=None), patch(
"src.services.RoundService.should_round_start", return_value=False
), patch("src.services.EmailService.send_email") as email_mock:
sell_order_id = sell_order_service.create_order(
**sell_order_params, scheduler=None
)["id"]
email_mock.assert_called_with(
emails=[user["email"]], template="create_sell_order"
)
with session_scope() as session:
sell_order = session.query(SellOrder).get(sell_order_id).asdict()
assert_dict_in({**sell_order_params, "round_id": None}, sell_order)
def test_run_matches():
round = create_round()
buy_user = create_user("1")
buy_user2 = create_user("2")
sell_user = create_user("3")
sell_user2 = create_user("4")
buy_order = create_buy_order("1", round_id=round["id"], user_id=buy_user["id"])
buy_order_id = buy_order["id"]
create_buy_order("2", round_id=round["id"], user_id=buy_user2["id"])
sell_order = create_sell_order("3", round_id=round["id"], user_id=sell_user["id"])
sell_order_id = sell_order["id"]
create_sell_order("4", round_id=round["id"], user_id=sell_user2["id"])
with patch(
"src.services.match_buyers_and_sellers",
return_value=[(buy_order_id, sell_order_id)],
) as mock_match, patch(
"src.services.RoundService.get_active", return_value=round
), patch(
"src.services.EmailService.send_email"
) as mock_email:
match_service.run_matches()
mock_email.assert_has_calls(
[
call([buy_user["email"]], template="match_done_has_match_buyer"),
call([sell_user["email"]], template="match_done_has_match_seller"),
call(
[buy_user2["email"], sell_user2["email"]],
template="match_done_no_match",
),
]
)
assert set(u["user_id"] for u in mock_match.call_args[0][0]) == set(
[buy_user["id"], buy_user2["id"]]
)
assert set(u["user_id"] for u in mock_match.call_args[0][1]) == set(
[sell_user["id"], sell_user2["id"]]
)
assert mock_match.call_args[0][2] == []
with session_scope() as session:
match = session.query(Match).one()
assert match.buy_order_id == buy_order_id
assert match.sell_order_id == sell_order_id
assert (
session.query(UserChatRoomAssociation)
.filter_by(user_id=buy_order["user_id"])
.one()
.chat_room_id
== session.query(UserChatRoomAssociation)
.filter_by(user_id=sell_order["user_id"])
.one()
.chat_room_id
)
assert session.query(Round).get(round["id"]).is_concluded
def echo_controller(request):
"""Make echo response based on request data."""
data = request.get('data')
with session_scope() as session:
message = Message(data=data.get('data'))
session.add(message)
return make_response(request, 200, data)
def test_create__user_exists():
user_params = {
"email": "*****@*****.**",
"full_name": "Ben",
"provider_user_id": "testing",
"display_image_url": "http://blah",
"is_buy": True,
"auth_token": None,
}
with patch("src.services.EmailService.send_email"):
user_service.create_if_not_exists(
**{
**user_params,
"email": "*****@*****.**",
"full_name": "Boo",
"display_image_url": "old",
})
with patch("src.services.EmailService.send_email") as mock:
user_service.create_if_not_exists(**user_params)
mock.assert_not_called()
with session_scope() as session:
user = session.query(User).one().asdict()
user_expected = user_params
user_expected.pop("is_buy")
user_expected.update({"can_buy": "UNAPPROVED", "can_sell": "NO"})
assert_dict_in(user_expected, user)
def get_chat_offers(self, user_id, chat_room_id):
with session_scope() as session:
results = session.query(Offer).filter_by(chat_room_id=chat_room_id).all()
data = []
for result in results:
data.append(OfferService._serialize_offer(offer=result.asdict()))
return data
def test_create_order__pending():
user = create_user(can_buy=False)
user_id = user["id"]
security_id = create_security()["id"]
create_user_request(user_id=user_id, is_buy=True)
round = create_round()
buy_order_params = {
"user_id": user_id,
"number_of_shares": 20,
"price": 30,
"security_id": security_id,
}
with patch("src.services.RoundService.get_active", return_value=round), patch(
"src.services.RoundService.should_round_start", return_value=False
), patch("src.services.EmailService.send_email") as email_mock:
buy_order_id = buy_order_service.create_order(**buy_order_params)["id"]
email_mock.assert_called_with(
emails=[user["email"]], template="create_buy_order"
)
with session_scope() as session:
buy_order = session.query(BuyOrder).get(buy_order_id).asdict()
assert_dict_in({**buy_order_params, "round_id": round["id"]}, buy_order)
def get_chat_messages(self, user_id, chat_room_id):
with session_scope() as session:
results = session.query(Chat).filter_by(chat_room_id=chat_room_id).all()
data = []
for result in results:
data.append(ChatService._serialize_message(message=result.asdict()))
return data
def get_requests(self, subject_id):
with session_scope() as session:
if not session.query(User).get(subject_id).is_committee:
raise InvisibleUnauthorizedException("Not committee")
buy_requests = (session.query(UserRequest, User).join(
User, User.id == UserRequest.user_id).filter(
UserRequest.is_buy == True,
UserRequest.closed_by_user_id == None).all())
sell_requests = (session.query(UserRequest, User).join(
User, User.id == UserRequest.user_id).filter(
UserRequest.is_buy == False,
UserRequest.closed_by_user_id == None).all())
return {
"buyers": [{
**r[0].asdict(),
**{
k: v
for k, v in r[1].asdict().items() if k not in [
"id", "created_at", "updated_at"
]
},
} for r in buy_requests],
"sellers": [{
**r[0].asdict(),
**{
k: v
for k, v in r[1].asdict().items() if k not in [
"id", "created_at", "updated_at"
]
},
} for r in sell_requests],
}
def reject_offer(self, chat_room_id, offer_id, user_id, user_type):
with session_scope() as session:
OfferService._check_deal_status(
session=session,
chat_room_id=chat_room_id,
user_id=user_id,
user_type=user_type,
)
chat_room = session.query(ChatRoom).get(chat_room_id)
offer = session.query(Offer).filter_by(id=offer_id).one()
if offer.offer_status != "PENDING":
raise InvalidRequestException("Offer is closed")
OfferService._update_offer_status(
session=session,
chat_room=chat_room,
offer=offer,
offer_status="REJECTED",
)
offer = OfferService._get_current_offer(session=session, offer=offer)
OfferService._update_chatroom_datetime(
session=session, chat_room=chat_room, offer=offer
)
return OfferService._serialize_chat_offer(
chat_room_id=chat_room_id,
offer=offer,
is_deal_closed=chat_room.is_deal_closed,
)
def create_order(self, user_id, number_of_shares, price, security_id):
with session_scope() as session:
user = session.query(User).get(user_id)
if user is None:
raise ResourceNotFoundException()
if user.asdict()["can_buy"] == "NO":
raise UnauthorizedException("User cannot place buy orders.")
buy_order_count = session.query(BuyOrder).filter_by(user_id=user_id).count()
if buy_order_count >= self.config["ACQUITY_BUY_ORDER_PER_ROUND_LIMIT"]:
raise UnauthorizedException("Limit of buy orders reached.")
active_round = RoundService(self.config).get_active()
buy_order = BuyOrder(
user_id=user_id,
number_of_shares=number_of_shares,
price=price,
security_id=security_id,
round_id=(active_round and active_round["id"]),
)
session.add(buy_order)
session.commit()
self.email_service.send_email(
emails=[user.email], template="create_buy_order"
)
return buy_order.asdict()
def test_create__is_sell():
user_params = {
"email": "*****@*****.**",
"full_name": "Ben",
"provider_user_id": "testing",
"display_image_url": "http://blah",
"is_buy": False,
"auth_token": None,
}
committee_email = create_user(is_committee=True)["email"]
with patch("src.services.EmailService.send_email") as mock:
user_service.create_if_not_exists(**user_params)
mock.assert_any_call(emails=[user_params["email"]],
template="register_seller")
mock.assert_any_call(emails=[committee_email],
template="new_user_review")
with session_scope() as session:
user = session.query(User).filter_by(email="*****@*****.**").one().asdict()
req = session.query(UserRequest).one().asdict()
user_expected = user_params
user_expected.pop("is_buy")
user_expected.update({"can_buy": "NO", "can_sell": "UNAPPROVED"})
assert_dict_in(user_expected, user)
assert_dict_in({"user_id": user["id"], "is_buy": False}, req)
def delete_message_controller(request):
"""Delete message based on message_id in request data."""
data = request.get('data')
message_id = data.get('message_id')
with session_scope() as session:
message = session.query(Message).filter_by(id=message_id).first()
session.delete(message)
return make_response(request, 200)
def get_orders_by_user_in_current_round(self, user_id):
current_round = RoundService(self.config).get_active()
with session_scope() as session:
buy_orders = (session.query(BuyOrder).filter_by(
user_id=user_id).filter((BuyOrder.round_id == (
current_round and current_round["id"]))
| (BuyOrder.round_id == None)).all())
return [buy_order.asdict() for buy_order in buy_orders]
def get_other_party_details(self, chat_room_id, user_id):
with session_scope() as session:
chat_room = session.query(ChatRoom).get(chat_room_id).asdict()
if not chat_room["is_revealed"]:
raise ResourceNotOwnedException("Other party has not revealed.")
if chat_room["seller_id"] == user_id:
other_party_user_id = chat_room["buyer_id"]
elif chat_room["buyer_id"] == user_id:
other_party_user_id = chat_room["seller_id"]
else:
raise ResourceNotOwnedException("Wrong user.")
with session_scope() as session:
user = session.query(User).get(other_party_user_id).asdict()
return {k: user[k] for k in ["email", "full_name"]}
def get_active(self):
with session_scope() as session:
active_round = (
session.query(Round)
.filter(Round.end_time >= datetime.now(), Round.is_concluded == False)
.one_or_none()
)
return active_round and active_round.asdict()
def get_order_by_id(self, id, user_id):
with session_scope() as session:
order = session.query(BuyOrder).get(id)
if order is None:
raise ResourceNotFoundException()
if order.user_id != user_id:
raise ResourceNotOwnedException()
return order.asdict()
def get_messages_controller(request):
"""Get all messages like a {'data': <value>, 'created': <value>}."""
with session_scope() as session:
messages = [{
'data': item.data,
'created': item.created.timestamp()
} for item in session.query(Message).all()]
return make_response(request, 200, messages)
def get_user_by_linkedin_id(self, provider_user_id):
with session_scope() as session:
user = (session.query(User).filter_by(
provider_user_id=provider_user_id).one_or_none())
if user is None:
raise ResourceNotFoundException()
user_dict = user.asdict()
return user_dict
def test_delete_order():
user_id = create_user()["id"]
sell_order_id = create_sell_order(user_id=user_id)["id"]
sell_order_service.delete_order(id=sell_order_id, subject_id=user_id)
with session_scope() as session:
assert session.query(SellOrder).filter_by(id=sell_order_id).count() == 0
def get_chat_rooms_by_user_id(self, user_id):
with session_scope() as session:
chat_rooms = (session.query(
UserChatRoomAssociation, ChatRoom).join(
ChatRoom, UserChatRoomAssociation.chat_room_id ==
ChatRoom.id).filter(
UserChatRoomAssociation.user_id == user_id).all())
return [chat_room[1].asdict() for chat_room in chat_rooms]
def update_message_controller(request):
"""Update message based on message_id and text in request data."""
data = request.get('data')
message_data = data.get('text')
message_id = data.get('message_id')
with session_scope() as session:
message = session.query(Message).filter_by(id=message_id).first()
message.data = message_data
return make_response(request, 200)
