def add_black(self, user_id, friend_user_id):
relation = self.friend.get_friend_by_user_and_friend(
user_id, friend_user_id)
black_relation = self.friend.get_black_by_user_and_friend(
user_id, friend_user_id)
if relation or black_relation:
relation = relation if relation else black_relation
success = self.friend.add_black(relation)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
else:
data = dict()
data["account_id"] = user_id
data["friend_account_id"] = friend_user_id
data["type"] = 2
success = self.friend.friend.add(data)
if success:
result = Result.result_success("add black successfully!")
else:
result = Result.result_failed("add black failed!")
return result
def set_online_switch(self, user_id, is_online):
configuration = self.configuration.get_by_user(user_id)
if configuration:
if is_online:
success = self.configuration.open_online(configuration)
if success:
result = Result.result_success("open online successfully!")
else:
result = Result.result_failed("open online failed!")
else:
success = self.configuration.close_online(configuration)
if success:
result = Result.result_success(
"close online successfully!")
else:
result = Result.result_failed("close online failed!")
else:
data_dict = dict()
data_dict["user_id"] = user_id
data_dict["is_online"] = is_online
success = self.configuration.add(data_dict)
if is_online:
if success:
result = Result.result_success(
"add open online successfully!")
else:
result = Result.result_failed("add open online failed!")
else:
if success:
result = Result.result_success(
"add close online successfully!")
else:
result = Result.result_failed("add close online failed!")
return result
def bind_cellphone(self, cellphone_id, user_id):
result = dict()
result["success"] = False
relation = self.relation.get_by_cellphone_and_user(
cellphone_id, user_id)
if relation and self.relation.is_valid(relation, has_state=True):
result = Result.result_success(CELLPHONE_EXIST)
# else:
# self.delete_relations(user_id)
# restore = self.relation.restore(relation)
# if restore:
# result = Result.result_success(RESTORE_SUCCESS)
# else:
# result = Result.result_failed(RESTORE_FAILED)
else:
self.delete_relations(user_id)
data_dict = dict()
data_dict["user_id"] = user_id
data_dict["cellphone_id"] = cellphone_id
temp = self.relation.add(data_dict)
if temp:
result = Result.result_success()
else:
result = Result.result_failed()
return result
def authenticate(self, country_code, username, password, cellphone_dict,
base_url, code):
country_code_object = self.user.get_country_code(country_code)
country_code_id = country_code_object.id if country_code_object else 0
OHHOLog.print_log("check user")
user_check_result = self.user.check_user_only_by_user(
username, code, country_code_id)
OHHOLog.print_log(user_check_result)
user = self.user.get_by_cellphone(username)
cellphone_key = cellphone_dict.get("key", None)
self.cellphone.set_key(cellphone_key)
cellphone = self.cellphone.get()
OHHOLog.print_log("check user and cellphone relation")
if user and cellphone:
is_bind = self.cellphone.is_bound_by_user(cellphone.id, user.id)
if is_bind:
cellphone_relation_result = Result.result_success()
else:
OHHOLog.print_log("unsafe cellphone!")
cellphone_relation_result = Result.result_failed()
else:
OHHOLog.print_log("user or cellphone not exist!")
cellphone_relation_result = Result.result_failed()
if not cellphone:
OHHOLog.print_log("add cellphone!")
success = self.cellphone.add_cellphone(cellphone_dict)
if success:
add_cellphone_result = Result.result_success()
else:
add_cellphone_result = Result.result_failed()
OHHOLog.print_log(add_cellphone_result)
OHHOLog.print_log(cellphone_relation_result)
if Result.is_success(user_check_result) and Result.is_success(
cellphone_relation_result):
result = Result.result_success()
elif Result.is_password_incorrect(
user_check_result) or Result.is_update_beyond_three_month(
user_check_result):
result = user_check_result
elif Result.is_success(user_check_result):
result = Result.result_unsafe()
elif Result.is_not_exist(user_check_result):
result = Result.result_not_exist()
else:
result = Result.result_failed()
if user and Result.is_success(result):
result["data"] = self.user.get_user_information(user.id, base_url)
return result
def add(self, user_id, name, match_condition_id):
"""
用户ID，名称唯一确定一条值，match_condition可以更改
:param data: name, user_id, match_condition_id
:return:
"""
if user_id:
relation = self.get_nearest_match_relation_by_user(user_id)
if relation:
result = Result.result_exist(USER_AND_MATCH_CONDITION_EXIST)
result["data"] = relation
else:
data = dict()
data["user_id"] = user_id
data["match_condition_id"] = match_condition_id
if name:
data["name"] = name
success = self.relation.add(data)
if success:
result = Result.result_success()
relation = self.get_nearest_match_relation_by_user(user_id)
result["data"] = relation
else:
result = Result.result_failed()
result["data"] = None
else:
result = Result.result_failed(PARAMETERS_ARE_INVALID)
result["data"] = None
return result
def refuse_meet(self, user_id, friend_user_id, apply_id, base_url):
"""
拒绝见面
只要对方有申请见面,就可以拒绝见面
:param user_id: 用户ID
:param friend_user_id: 另一用户ID
:param meet_state: 见面状态 0未见，1见面，2 请求相见，3同意相见，4不同意相见，5 取消见面，默认为0
:return:
"""
# 向对方发送拒绝的推送
try:
if user_id and friend_user_id and apply_id:
type = PUSH_STATE_TYPE_REFUSE_MEET
if not self.meet.is_meet_end(apply_id, friend_user_id):
result = self.push_information(friend_user_id, user_id,
apply_id, type, base_url)
OHHOLog.print_log(result)
# information = self.user.get_push_user_information(user_id, apply_id, base_url)
# information["function"] = "refuse meet"
# self.user.push_user_information(friend_user_id, PUSH_STATE_TYPE_REFUSE_MEET, information)
self.meet.add_exclude(user_id, friend_user_id)
self.meet.add_refuse(apply_id, user_id)
return Result.result_success()
else:
OHHOLog.print_log(
"user_id:%s, friend_user_id:%s, apply_id:%s" %
(str(user_id), str(friend_user_id), str(apply_id)))
return Result.result_failed("there is some id is 0")
except Exception as ex:
OHHOLog.print_log(ex)
return Result.result_failed(ex)
def send(self, user_id, friend_user_id, content, type):
result = Result.result_success()
data = dict()
data["account_id"] = user_id
data["another_account_id"] = friend_user_id
data["message"] = content
success = self.message.add(data)
if success:
OHHOLog.print_log("add message to database successfully!")
else:
OHHOLog.print_log("add message to database failed!")
result["add2db"] = success
message = dict()
msg = dict()
msg["content"] = content
msg["user_id"] = user_id
msg["type"] = type
msg["current_timestamp"] = OHHODatetime.get_current_timestamp()
message["msg"] = msg
success = self.send_message.send_attach_message(
user_id, friend_user_id, OHHOOperation.dict2json(message))
OHHOLog.print_log(success)
result["send2im"] = success
return result
def met(self, user_id, last_id, limit, base_url):
met_list = self.meet.get_meet(user_id, last_id)
blacks = self.friend.get_black_by_user(user_id)
black_list = [b.friend_account_id
for b in blacks] if blacks else list()
data = list()
count = 0
for met in met_list:
another_user_id = met.user_id if met.another_user_id == int(
user_id) else met.another_user_id
if another_user_id in black_list:
continue
temp = self.user.get_friend_information(user_id, another_user_id,
met.apply_id, base_url)
if temp:
temp["last_id"] = met.id
temp["apply_id"] = met.apply_id
temp["created_at"] = OHHODatetime.clock2string(
OHHODatetime.utc2beijing(met.created_at))
data.append(temp)
count += 1
if limit and int(limit) > 0:
if count >= int(limit):
break
result = Result.result_success()
result["data"] = data
return result
def not_met(self, user_id, friend_user_id, apply_id):
data = dict()
data["user_id"] = user_id
data["is_meet"] = False
data["apply_id"] = apply_id
self.user.push(data, friend_user_id)
return Result.result_success()
def change(self, user_id, cellphone_number, code, country_code):
country_code_obj = self.country_code.get_by_country_code(country_code)
if country_code_obj:
code_cellphone_number = country_code + cellphone_number
else:
return Result.result_failed("the country_code not exist")
is_correct = Code.check_code(code_cellphone_number, code)
if is_correct:
the_user = self.user.get_by_id(user_id)
if the_user:
if self.user.user.exist_valid_cellphone_country_code_id(
country_code_obj.id, cellphone_number):
return Result.result_failed(
"the cellphone number has been registered!")
else:
last_cellphone = the_user.cellphone
cellphone = cellphone_number
data = dict()
data["last_cellphone"] = last_cellphone
data["cellphone"] = cellphone
data["country_code_id"] = country_code_obj.id
success = self.user.update_user(the_user, data)
if success:
return Result.result_success()
else:
return Result.result_failed()
else:
return Result.result_failed("the user %d does not exist" %
(int(user_id)))
else:
return Result.result_failed("cellphone code is incorrect!")
def refuse_friend(self, user_id, friend_user_id):
"""
拒绝添加好友
用户已经申请,并且你们不是朋友/黑名单关系,可以拒绝
:param user_id: 用户ID
:param friend_user_id: 另一用户ID
:return:
"""
if self.friend.has_valid_apply(friend_user_id, user_id):
apply = self.friend.get_apply_by_user_and_friend(
friend_user_id, user_id)
if apply:
success = self.friend.add_refuse(apply.id, user_id)
if success:
log_string = "%d refuse %d to be friend" % (user_id,
friend_user_id)
OHHOLog.print_log(log_string)
self.im_friend.refuse_friend(user_id, friend_user_id, "")
return Result.result_success()
else:
return Result.result_failed()
else:
return Result.result_failed("no valid friend apply!")
else:
return Result.result_failed("no valid friend apply!")
def get(self):
@gen.coroutine
def add_new_user(password, cellphone, country_code="+86"):
username = OHHOUUID.get_uuid1_string()
user = User()
user.set_username(username)
OHHOLog.print_log(user.add_user(password, cellphone, country_code))
the_user = user.get_by_username(username)
if the_user:
result = Result.result_success()
result["user_id"] = the_user.id
else:
result = Result.result_failed()
result["user_id"] = 0
return result
password = '******'
# cellphone = 0
for i in range(10000):
OHHOLog.print_log(i)
gen.Task(add_new_user, password, i)
# yield add_new_user(password, i)
OHHOLog.print_log("end")
self.write(Result.result_success())
self.finish()
def set_device_use(self, user_id, identity_id, data_dict):
user_id = int(user_id)
# OHHOLog.print_log(user_id)
# OHHOLog.print_log(identity_id)
# OHHOLog.print_log(data_dict)
self.device.set_identity(identity_id)
relation = self.device.get_relation_by_device()
# OHHOLog.print_log(relation.user_id)
if relation and relation.user_id == user_id:
type = data_dict.get("type", 0)
type = int(type)
OHHOLog.print_log(type)
if type == 1:
primary = self.device.get_primary_relation_by_user(user_id)
if primary:
for p in primary:
OHHOLog.print_log("reset")
result = self.device.relation_update(p, {"type": 0})
OHHOLog.print_log(result)
success = self.device.relation_update(relation, data_dict)
if success:
return Result.result_success()
else:
return Result.result_failed()
elif relation:
return Result.result_device_used_by_other()
else:
return Result.result_failed("this is not your device!")
def rematch(self, user_id, friend_user_id, apply_id, is_published):
# 加到exclude表中, 取消见面
# type 0:未被惩罚
# type 1: 惩罚，删除这个人以前的惩罚，加到惩罚表中；关闭本人的配对开关
self.meet.add_exclude(user_id, friend_user_id)
user_map = self.map.get_by_user(user_id)
friend_map = self.map.get_by_user(friend_user_id)
user_address = user_map.address if user_map else ""
friend_user_address = friend_map.address if friend_map else ""
self.meet.add_meet_end(apply_id, user_id, user_address)
self.meet.add_meet_end(apply_id, friend_user_id, friend_user_address)
self.meet.delete_meeting(apply_id, user_id)
self.meet.delete_meeting(apply_id, friend_user_id)
if not self.meet.is_meet_end(apply_id, friend_user_id):
data = dict()
data["user_id"] = user_id
data["apply_id"] = apply_id
self.user.push_user_information(friend_user_id,
PUSH_STATE_TYPE_END_MEET, data)
if is_published:
self.meet.delete_published_by_user(user_id)
data = dict()
data["user_id"] = user_id
data["apply_id"] = apply_id
self.meet.add_published(data)
configuration = self.configuration.get_by_user(user_id)
if configuration:
self.configuration.close_match(configuration)
return Result.result_success()
def met(self, user_id, friend_user_id, apply_id, base_url):
user_id = int(user_id)
friend_user_id = int(friend_user_id)
apply_id = int(apply_id)
type = PUSH_STATE_TYPE_MET
result = self.push_information(friend_user_id, user_id, apply_id, type,
base_url)
OHHOLog.print_log(result)
# information = self.user.get_push_user_information(user_id, apply_id, base_url)
# information["function"] = "met by device"
# self.user.push_user_information(friend_user_id, PUSH_STATE_TYPE_MET, information)
user_map = self.map.get_by_user(user_id)
if user_map:
user_address = user_map.address
else:
user_address = ""
friend_user_map = self.map.get_by_user(friend_user_id)
if friend_user_map:
friend_user_address = friend_user_map.address
else:
friend_user_address = ""
data = dict()
data["user_id"] = user_id
data["another_user_id"] = friend_user_id
data["apply_id"] = apply_id
data["user_address"] = user_address
data["friend_user_map"] = friend_user_address
data["type"] = 0
self.meet.add_met(data)
return Result.result_success()
def add_friend(self, user_id, friend_user_id, apply_id):
friend = self.get_friend_by_user_and_friend(user_id, friend_user_id)
if friend:
success1 = True
else:
data = dict()
data["account_id"] = user_id
data["friend_account_id"] = friend_user_id
data["apply_id"] = apply_id
success1 = self.friend.add(data)
friend = self.get_friend_by_user_and_friend(friend_user_id, user_id)
if friend:
success2 = True
else:
data = dict()
data["account_id"] = friend_user_id
data["friend_account_id"] = user_id
data["apply_id"] = apply_id
success2 = self.friend.add(data)
if success1 and success2:
return Result.result_success()
else:
return Result.result_failed()
def add(self,
user_id,
another_user_id,
map_information,
base_url,
timestamp=None):
if timestamp:
map_information["timestamp"] = timestamp
map_information["user_id"] = user_id
map_information["another_user_id"] = another_user_id
success = self.map.add(map_information)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
# return result
map_instance = self.map.get_by_user_id(another_user_id)
result["data"] = dict()
if map_instance:
OHHOLog.print_log("has map")
OHHOLog.print_log(map_instance)
OHHOLog.print_log(self.map.get_information(map_instance, base_url))
result["data"]["information"] = self.map.get_information(
map_instance, base_url)
else:
OHHOLog.print_log("not has map")
result["data"]["information"] = dict()
return result
def meet_end(self, user_id, friend_user_id, apply_id, base_url):
apply_id = int(apply_id)
if apply_id:
the_map = self.map.get_by_user(user_id)
if the_map:
address = the_map.address
else:
address = ""
self.meet.add_meet_end(apply_id, user_id, address)
type = PUSH_STATE_TYPE_END_MEET
is_meet_end = self.meet.is_meet_end(apply_id, friend_user_id)
if not is_meet_end:
self.push_information(friend_user_id, user_id, apply_id, type,
base_url)
# information = dict()
# information["function"] = "meet end"
# self.user.push_user_information(friend_user_id, PUSH_STATE_TYPE_END_MEET, information)
# self.delete_map(user_id)
# self.delete_map(friend_user_id)
# self.delete_sensor(user_id)
# self.delete_sensor(friend_user_id)
self.delete_meeting(apply_id, user_id)
# self.delete_meeting(apply_id, friend_user_id)
return Result.result_success()
else:
return Result.result_failed("apply_is is %d" % (int(apply_id)))
def apply_meet(self, user_id, friend_user_id, match_condition_id, base_url):
"""
申请见面
见过面的不能申请
:param user_id: 用户ID
:param friend_user_id: 另一用户ID
:param match_condition_id: 配对条件ID
:return:
"""
result = dict()
if self.meet.has_valid_apply(user_id, friend_user_id):
return Result.result_has_valid_meet_apply()
if self.meet.is_meet(user_id, friend_user_id):
return Result.result_is_meet()
condition = self.condition.get_by_id(match_condition_id)
if condition:
success = self.meet.add_apply(user_id, friend_user_id, match_condition_id)
if success:
log_string = "%d apply %d to meet" % (user_id, friend_user_id)
OHHOLog.print_log(log_string)
message = self.user.get_user_basic_information(user_id, base_url)
self.user.push(log_string, friend_user_id, DEFAULT_IM_USER_ID)
return Result.result_success()
else:
return Result.result_failed()
else:
return Result.result_failed("no such condition!")
def meet_state(self, user_id, base_url):
result = Result.result_success()
result["state"], apply_id = self.meet.get_user_state(user_id)
result["apply_id"] = apply_id
if apply_id:
countdown = self.meet.get_countdown(apply_id)
# result = OHHOOperation.dict_add_dict(result, temp)
apply = self.apply.get_by_id(apply_id)
if apply:
friend_user_id = apply.another_user_id if apply.one_user_id == int(
user_id) else apply.one_user_id
result["friend_state"], temp = self.meet.get_user_state(
friend_user_id, result["apply_id"])
if result["state"] == PUSH_STATE_TYPE_END_MEET:
pass
else:
friend_user_information = self.user.get_basic_user_information(
friend_user_id, base_url)
friend_user_information["user_id"] = friend_user_id
friend_user_information["apply_id"] = apply_id
friend_user_information = OHHOOperation.dict_add_dict(
friend_user_information, countdown)
result["friend_user_information"] = friend_user_information
OHHOLog.print_log(result)
return result
def get(self, user_id, friend_user_id, is_apply, base_url):
result = Result.result_success()
user = self.user.get_by_id(user_id)
if user:
if int(is_apply):
apply = self.apply.get_nearest(user_id, friend_user_id)
else:
apply = self.apply.get_nearest(friend_user_id, user_id)
if apply:
agree = self.agree.get(apply.id)
refuse = self.refuse.get(apply.id)
if self.meet.is_meet_by_apply(apply.id):
result["state"] = 6 # 见面
else:
if agree:
if not refuse:
result["state"] = 1 # "agree"
else:
result["state"] = 3 # "cancel"
else:
if refuse:
result["state"] = 2 # "refuse"
else:
result["state"] = 4 # "default"
else:
result["state"] = 5 # "no such apply"
if result["state"] in [1, 6]:
result["data"] = self.user.get_user_basic_information(
friend_user_id, base_url)
return result
def add_feedback(self, user_id, friend_user_id, apply_id, reason, content,
category):
data = dict()
data["user_id"] = user_id
data["another_user_id"] = friend_user_id
data["apply_id"] = apply_id
data["reason"] = reason
data["message"] = content
if self.apply.get_by_id(apply_id):
success = self.feedback.add(data)
category_list = OHHOOperation.json2list(category)
impression_instance = DBOHHOUserImpression()
for c in category_list:
if c:
temp = dict()
temp["type"] = 1
temp["content_id"] = int(c)
temp["apply_id"] = apply_id
temp["user_id"] = user_id
temp["another_user_id"] = friend_user_id
impression_instance.add(temp)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_failed("no valid apply!")
return result
def get(self, user_id, base_url=None):
user = self.user.get_by_id(user_id)
if user:
result = Result.result_success()
result["data"] = self.user.get_user_information(user_id, base_url)
else:
result = Result.result_failed("no such user!")
return result
def set_match_switch(self, user_id, is_match):
published = self.published.get_the_last_by_user(user_id)
if published:
current_timestamp = OHHODatetime.get_current_timestamp()
if published.timestamp + PUBLISHED_TIMESTAMP >= current_timestamp:
result = Result.result_published()
result["rest"] = PUBLISHED_TIMESTAMP - (current_timestamp -
published.timestamp)
return result
else:
self.published.delete(published)
configuration = self.configuration.get_by_user(user_id)
if configuration:
if is_match:
success = self.configuration.open_match(configuration)
if success:
result = Result.result_success("open match successfully!")
else:
result = Result.result_failed("open match failed!")
else:
success = self.configuration.close_match(configuration)
if success:
result = Result.result_success("close match successfully!")
else:
result = Result.result_failed("close match failed!")
else:
data_dict = dict()
data_dict["user_id"] = user_id
data_dict["is_switch"] = is_match
success = self.configuration.add(data_dict)
if is_match:
if success:
result = Result.result_success(
"add open match successfully!")
else:
result = Result.result_failed("add open match failed!")
else:
if success:
result = Result.result_success(
"add close match successfully!")
else:
result = Result.result_failed("add close match failed!")
return result
def add(self, name):
data = dict()
data["name"] = name
success = self.work_domain.add(data)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
return result
def add_user_exclude(user_id, exclude_user_ids):
extension = DBOHHOUserAccuracyExtension()
user = extension.get_by_user(user_id)
if user:
success = extension.update(user, {"exclude": exclude_user_ids})
if success:
return Result.result_success("update successfully!")
else:
return Result.result_failed("update failed!")
else:
success = extension.add({
"user_id": user_id,
"exclude": exclude_user_ids
})
if success:
return Result.result_success("add successfully!")
else:
return Result.result_failed("add failed!")
def open_match_switch(self, user_id):
configuration = self.configuration.get_by_user(user_id)
if configuration:
success = self.configuration.open_match(configuration)
if success:
result = Result.result_success("open match successfully!")
else:
result = Result.result_failed("open match failed!")
else:
data_dict = dict()
data_dict["user_id"] = user_id
data_dict["is_switch"] = 1
success = self.configuration.add(data_dict)
if success:
result = Result.result_success("add open match successfully!")
else:
result = Result.result_failed("add open match failed!")
return result
def delete_one_user_exclude(user_id, exclude_user_id):
extension = DBOHHOUserAccuracyExtension()
user = extension.get_by_user(user_id)
if user:
exclude = user.exclude
exclude_user_id_list = exclude.split(",")
exclude_user_id_list = [int(e) for e in exclude_user_id_list]
if int(exclude_user_id) in exclude_user_id_list:
exclude_user_id_list.remove(exclude_user_id)
exclude_string = ",".join(exclude_user_id_list)
success = extension.update(user, {"exclude": exclude_string})
if success:
return Result.result_success("update successfully!")
else:
return Result.result_failed("update failed!")
else:
return Result.result_success("no such user in your exclude!")
else:
return Result.result_failed("no such user extension!")
def add(self, data):
data_list = self.parse_parameters(data)
if data_list:
success = self.bulk_add(data_list)
if success:
return Result.result_success()
else:
return Result.result_failed("failed!")
else:
return Result.result_failed("no data")
def add(self, name):
data = dict()
data["name"] = name
drink = self.drink
success = drink.add(data)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
return result
