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)