def single_chat_create(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
from_user = _get_user_by_session(int(params["user_session"]))
to_user = _get_user_by_user_id(int(params["user_id"]))
_user_blocked(from_user, to_user)
current_chat_id = _get_chat_id_by_user_ids(from_user.user_id,
to_user.user_id)
if current_chat_id:
return jsonrpc.create_json_response(json,
{"chat_id": current_chat_id[0]})
chat_id = _database.chat_create(from_user.user_id, params["chat_name"],
to_user.user_id)[0]["chat_id"]
return jsonrpc.create_json_response(json, {"chat_id": chat_id})
def friends_send_request_to_add(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
source_user = _get_user_by_session(int(params["user_session"]))
target_user = _get_user_by_user_id(int(params["user_id"]))
if source_user.user_id in _get_friend_waiter_to_add_ids(target_user):
return jsonrpc.create_json_response(json, None)
_user_blocked(source_user, target_user)
_blocked_by_user(source_user, target_user)
if target_user.user_id in _get_friend_waiter_to_add_ids(source_user):
_database.friends_add_to_friend(source_user.user_id,
target_user.user_id)
else:
_database.friends_add_to_waiter(source_user.user_id,
target_user.user_id)
return jsonrpc.create_json_response(json, None)
def user_create(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
params["password"] = get_hash(str(params["password"]))
null_user = _database.user_get_id_by_email(params["email"])
if null_user:
raise jsonrpc.JSONRPCError({
"code":
-1002,
"message":
"Email '%s' already used" % params["email"],
})
null_user = _database.user_get_id_by_email(params["phone"])
if null_user:
raise jsonrpc.JSONRPCError({
"code":
-1003,
"message":
"Phone number '%s' already used" % params["phone"],
})
user = models.User.create_in_database( # type: ignore
_database, # type: ignore
**params, # type: ignore
role=constants.Roles.User, # type: ignore
status=constants.Status.Active, # type: ignore
points=0, # type: ignore
) # type: ignore
return jsonrpc.create_json_response(json, {"user_id": user.user_id})
def friends_block_user(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
source_user = _get_user_by_session(int(params["user_session"]))
target_user = _get_user_by_user_id(int(params["user_id"]))
friends_list = _get_friend_ids(source_user)
if target_user.user_id in friends_list:
_database.friends_delete(source_user.user_id, target_user.user_id)
waiters_list = _get_friend_waiter_to_add_ids(source_user)
if target_user.user_id in waiters_list:
_database.friends_delete_from_waiter(target_user.user_id,
source_user.user_id)
blocked = _get_blocked_user_ids(source_user)
if target_user.user_id in blocked:
return jsonrpc.create_json_response(json, None)
_database.friends_block_user(source_user.user_id, target_user.user_id)
return jsonrpc.create_json_response(json, None)
def friends_accept_request_to_add(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
source_user = _get_user_by_session(int(params["user_session"]))
target_user = _get_user_by_user_id(int(params["user_id"]))
_user_in_friend_waiters(target_user, source_user)
_database.friends_add_to_friend(source_user.user_id, target_user.user_id)
return jsonrpc.create_json_response(json, None)
def action_get(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
_get_user_by_session(int(params["user_session"]))
_action_exists(int(params["action_id"]))
return jsonrpc.create_json_response(
json,
_get_action_by_id(int(params["action_id"])).convert_to_json())
def friends_find(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
simple_keys = {}
for k, v in params.items():
if k not in constants.ALLOWED_SEARCH_KEYS:
continue
simple_keys[k] = v
difficult_keys = []
for k, v in params.items():
if k not in constants.ALLOWED_DIFFICULT_SEARCH_KEYS:
continue
for method in v:
condition = constants.COMPARISON_SIGNS[method["method"]]
data = method["value"]
difficult_keys.append({
"key": k,
"condition": condition,
"data": data
})
return jsonrpc.create_json_response(
json,
[
models.User.create_from_database(
_database, user_id=u_i["user_id"]).convert_to_json()
for u_i in _database.friends_find(simple_keys, difficult_keys)
],
)
def friends_delete(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
source_user = _get_user_by_session(int(params["user_session"]))
target_user = _get_user_by_user_id(int(params["user_id"]))
_user_in_friends(target_user, source_user)
_database.friends_delete(source_user.user_id, target_user.user_id)
return jsonrpc.create_json_response(json, None)
def user_login_by_email(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
user = _get_user_by_email(params["email"])
return jsonrpc.create_json_response(
json, {
"user_session": _user_login(user, params["password"]),
"user_id": user.user_id
})
def single_chats_get_by_user_id(json: Dict[str, Any]) -> Dict[str, Any]:
session = int(json["params"]["user_session"])
user = _get_user_by_session(session)
chats = []
for c_i in _database.single_chat_ids_get_by_user_id(user.user_id):
c = _get_chat(c_i["chat_id"], message_limit=1)
chats.append(c.convert_to_json())
return jsonrpc.create_json_response(json, chats)
def single_chat_send_message(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
from_user = _get_user_by_session(params["user_session"])
chat = _get_chat(int(params["chat_id"]))
_check_user_in_chat(from_user, chat)
_database.singe_chat_send_message(chat.chat_id, from_user.user_id,
params["message"])
return jsonrpc.create_json_response(json, None)
def single_chat_delete(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
chat_id = int(params["chat_id"])
chat = _get_chat(chat_id)
user = _get_user_by_session(int(params["user_session"]))
_check_user_in_chat(user, chat)
_database.single_chat_delete_by_user_id_and_chat_id(chat_id, user.user_id)
return jsonrpc.create_json_response(json, None)
def user_get_actions(json: Dict[str, Any]) -> Dict[str, Any]:
user = _get_user_by_session(int(json["params"]["user_session"]))
action_ids = _database.user_get_actions(user.user_id)
return jsonrpc.create_json_response(
json,
[
models.Action.create_from_database(_database, int(
a_i["action_id"])).convert_to_json() for a_i in action_ids
],
)
def multi_chat_create(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
from_user = _get_user_by_session(int(params["user_session"]))
for u_i in params["user_ids"]:
_get_user_by_user_id(u_i)
block_list = _get_blocked_user_ids_at(from_user)
_check_blocks(from_user, block_list)
chat_id = _database.chat_create(from_user.user_id, params["chat_name"],
*params["user_ids"])[0]["chat_id"]
return jsonrpc.create_json_response(json, {"chat_id": chat_id})
def single_chat_get_by_chat_id(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
user = _get_user_by_session(int(params["user_session"]))
chat = _get_chat(
int(params["chat_id"]),
params.get("message_limit"),
params.get("time_from"),
params.get("time_to"),
)
_check_user_in_chat(user, chat)
return jsonrpc.create_json_response(json, chat.convert_to_json())
def friends_get_friend_requests(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
user = _get_user_by_session(int(params["user_session"]))
return jsonrpc.create_json_response(
json,
{
"frined_requests": [
models.User.create_from_database(_database,
u_i).convert_to_json()
for u_i in _get_friend_waiter_to_add_ids(user)
]
},
)
def action_find(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
_get_user_by_session(int(params["user_session"]))
result = [
models.Action.create_from_database(_database, int(
a_i["action_id"])).convert_to_json()
for a_i in _database.action_find(
latitude=float(params["latitude"]),
longitude=float(params["longitude"]),
r=float(params["r"]),
delta_time=params.get("delta_time"),
)
]
return jsonrpc.create_json_response(json, result)
def friends_get_friends_list(json: Dict[str, Any]) -> Dict[str, Any]:
session = int(json["params"]["user_session"])
user = _get_user_by_session(session)
target_user_id = json["params"].get("user_id")
if target_user_id is not None:
target_user = _get_user_by_user_id(target_user_id)
_blocked_by_user(target_user, user)
user = target_user
return jsonrpc.create_json_response(
json,
[
models.User.create_from_database(
_database, user_id=d["target_user_id"]).convert_to_json()
for d in _database.friends_get_all_ids_by_user_id(user.user_id)
],
)
def action_create(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
owner = _get_user_by_session(params["user_session"])
data = {
"name": params["name"],
"latitude": float(params["latitude"]),
"longitude": float(params["longitude"]),
"owner": owner,
"description": params["description"],
"action_time": int(params["action_time"]),
}
if owner.role >= constants.Roles.Admin:
data["users"] = [
_get_user_by_user_id(int(u_i)) for u_i in params["user_ids"]
]
else:
data["users"] = []
action = models.Action.create_in_database(_database, **data)
return jsonrpc.create_json_response(json, action.convert_to_json())
def delete_user(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
user = _get_user_by_session(int(params["user_session"]))
_authentication(user, constants.Roles.Admin)
_database.user_delete(int(params["user_id"]))
return jsonrpc.create_json_response(json, None)
def user_leave_chat(json: Dict[str, Any]) -> Dict[str, Any]:
user = _get_user_by_session(int(json["params"]["user_session"]))
chat = _get_chat(chat_id=int(json["params"]["chat_id"]), message_limit=0)
chat.delete_user(_database, user)
return jsonrpc.create_json_response(json, None)
def user_leave_action(json: Dict[str, Any]) -> Dict[str, Any]:
user = _get_user_by_session(int(json["params"]["user_session"]))
action = _get_action_by_id(int(json["params"]["action_id"]))
action.delete_user(_database, user)
return jsonrpc.create_json_response(json, None)
def user_get_short_data_by_id(json: Dict[str, Any]) -> Dict[str, Any]:
params = json["params"]
user = _get_user_by_session(int(params["user_session"]))
return jsonrpc.create_json_response(json, user.convert_to_json())
