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 agree_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:
if not self.friend.is_friend_or_black(user_id, friend_user_id):
result = self.friend.add_friend(user_id, friend_user_id,
apply.id)
success = self.friend.add_agree(apply.id)
if success:
log_string = "%d agree %d to be friend" % (user_id,
friend_user_id)
OHHOLog.print_log(log_string)
self.im_friend.agree_friend(user_id, friend_user_id, "")
return result
else:
return Result.result_failed()
else:
return Result.result_failed("no valid friend apply!")
def delete_without_commit(instances):
try:
session.delete(instances)
return True
except Exception as ex:
OHHOLog.print_log(ex)
return False
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 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 add_user_accuracy_extension(self, user_id, user_extension_dict):
OHHOLog.print_log(user_extension_dict)
result = self.user.add_user_extension(user_id, user_extension_dict)
nickname = user_extension_dict.get(USER_EXTENSION_NICK_NAME, None)
primary_interest = user_extension_dict.get(
USER_EXTENSION_PRIMARY_INTEREST, "")
primary_interest = OHHOOperation.dict2json(primary_interest)
OHHOLog.print_log(user_extension_dict)
OHHOLog.print_log(USER_EXTENSION_PRIMARY_INTEREST)
OHHOLog.print_log(primary_interest)
if nickname is not None:
UpdateUserInfo.update_user_info(user_id, name=nickname)
# create or update match condition
relation = self.user.record_user_and_match_condition.get_nearest_by_user(
user_id)
if relation and relation.match_condition_id:
condition = self.user.match_condition.get_by_id(
relation.match_condition_id)
else:
condition = None
condition_id = self.user.add_new_condition(user_id)
if condition_id:
condition = self.user.match_condition.get_by_id(condition_id)
if condition:
OHHOLog.print_log(condition.id)
self.user.match_condition.update(condition,
{"interest": primary_interest})
return result
def get_personal_page_extension_by_user_id(user_id, base_url):
"""通过user_id 获取到额外的信息(个人主页的信息)"""
user = User()
user_accuracy_extension_instance = DBOHHOUserAccuracyExtension()
user_extension = user_accuracy_extension_instance.get_by_user_id_only_one(
user_id)
data = dict()
if user_extension:
data = user_accuracy_extension_instance.get_information(
user_extension, base_url)
if user_extension.occupation_id:
data["occupation_name"] = user_extension.occupation.name
else:
data["occupation_name"] = ""
if user_extension.position_id:
data["position_name"] = user_extension.position.name
else:
data["position_name"] = ""
if user_extension.degree_id:
data["degree_name"] = user_extension.degree.name
else:
data["degree_name"] = ""
if user_extension.birthday:
data["age"] = user.get_age(user_extension.birthday)
data["zodiac"] = user.get_zodiac(user_extension.birthday)
OHHOLog.print_log("user_accuracy_extension_data")
OHHOLog.print_log(data)
return data
def get(self):
the_post = Get()
self.set_format(the_post.get_format(self))
instance = LogicGetBasicData()
result = instance.get()
OHHOLog.print_log(result)
return self.response(result)
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 get_accuracy_extension_by_user_id(user_id, base_url):
"""通过user_id 获取到额外的信息"""
user_accuracy_extension_instance = DBOHHOUserAccuracyExtension()
user_extension = user_accuracy_extension_instance.get_by_user_id_only_one(
user_id)
data = dict()
if user_extension:
# for user_extension in user_accuracy_extension_list:
data = user_accuracy_extension_instance.get_information(
user_extension, base_url)
if user_extension.occupation_id:
data["occupation_name"] = user_extension.occupation.name
else:
data["occupation_name"] = ""
if user_extension.position_id:
data["position_name"] = user_extension.position.name
else:
data["position_name"] = ""
if user_extension.degree_id:
data["degree_name"] = user_extension.degree.name
else:
data["degree_name"] = ""
OHHOLog.print_log("user_accuracy_extension_data")
OHHOLog.print_log(data)
return data
def get_friend_by_user_and_friend(self, user_id, friend_user_id):
query = self.get_friend_by_user(user_id)
query = self.friend.get_by_friend(query, friend_user_id)
query = self.friend.get_by_apply_id_is_not_none(query)
query = self.friend.order_by_id_asc(query)
OHHOLog.print_log(self.friend.get_count(query))
return self.friend.first(query)
def post(self):
the_post = Post()
OHHOLog.print_log(self.request.body)
permission = OHHOPermission()
submit = the_post.get_submit(self)
group_id = the_post.get_group_id(self)
page_name = the_post.get_page_name(self)
page_permission_id = int(the_post.get_page_permission_id(self))
insert = int(the_post.get_insert(self))
delete = int(the_post.get_delete(self))
update = int(the_post.get_update(self))
select = int(the_post.get_select(self))
if submit:
if page_permission_id:
page_permission = permission.page_permission.get_by_id(page_permission_id)
if page_permission:
success = permission.page_permission.delete(page_permission)
if success:
message = "删除成功"
else:
message = "删除失败"
else:
message = "暂时还没有页面权限，请添加"
else:
message = "页面权限ID不合法"
else:
message = "未提交"
return self.redirect(
PERMISSION_GROUP_PAGE_RELATION_BACKSTAGE_DELETE_URL
+ "?data=%s&page_name=%s&group_id=%d" % (
message, page_name,
int(group_id)))
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 has_duplex_agree(self, user_id, user_id_list, base_url):
result = False
redis_name = REDIS_DUPLEX_AGREE_PREFIX + str(user_id)
duplex_agree_user_ids = RedisDB.list_get_all(redis_name)
duplex_agree_user_ids = [
RedisDB.to_bytes(data) for data in duplex_agree_user_ids
]
for the_user_id in duplex_agree_user_ids:
the_user_id = str(the_user_id)
OHHOLog.print_log(the_user_id)
some_user_id, apply_id = the_user_id.split(",")
some_user_id = int(some_user_id)
apply_id = int(apply_id)
if some_user_id in user_id_list:
state = self.meet.get_user_state_by_user(some_user_id)
if not result and state == PUSH_STATE_TYPE_END_MEET:
information = self.user.get_push_user_information(
some_user_id, apply_id, base_url)
self.user.push_user_information(
user_id, PUSH_STATE_TYPE_AGREE_MEET, information)
information = self.user.get_push_user_information(
user_id, apply_id, base_url)
self.user.push_user_information(
some_user_id, PUSH_STATE_TYPE_AGREE_MEET, information)
# 添加两个人的状态为见面中
self.meet.add_meeting(apply_id, user_id)
self.meet.add_meeting(apply_id, the_user_id)
result = True
else:
RedisDB.list_left_push(redis_name, the_user_id)
return result
def post(self):
the_post = Post()
OHHOLog.print_log(self.request.body)
permission = OHHOPermission()
submit = the_post.get_submit(self)
group_id = int(the_post.get_group_id(self))
page_id = int(the_post.get_page_id(self))
insert = int(the_post.get_insert(self))
delete = int(the_post.get_delete(self))
update = int(the_post.get_update(self))
select = int(the_post.get_select(self))
if submit:
if page_id:
data = dict()
data["page_id"] = page_id
data["insert"] = insert if insert else 0
data["delete"] = delete if delete else 0
data["update"] = update if update else 0
data["select"] = select if select else 0
message = permission.add_group_and_page(data, group_id)
else:
message = "请选择有效页面"
else:
message = "未提交"
return self.redirect(PERMISSION_GROUP_PAGE_RELATION_BACKSTAGE_ADD_URL +
"?id=" + str(group_id) + "&data=" + message)
def get(self, data_dict):
query = self.condition.get_query()
OHHOLog.print_log(query.count())
query = self.condition.filter_all(query, data_dict)
OHHOLog.print_log(query.count())
query = self.condition.order_by_id_asc(query)
return self.condition.first(query)
def rebind_cellphone(self, cellphone_key, cellphone_number, code, base_url, cellphone_dict, country_code):
the_cellphone = country_code + cellphone_number
check = Code.check_code(the_cellphone, code)
if check:
country_code_object = self.user.country_code.get_by_country_code(country_code)
country_code_id = country_code_object.id if country_code_object else 0
# self.user.get_by_country_code_and_cellphone(country_code, cellphone_number)
# user = self.user.get(cellphone_number)
user = self.user.get_by_country_code_and_cellphone(country_code_id, cellphone_number)
self.cellphone.set_key(cellphone_key)
cellphone = self.cellphone.get()
if not cellphone:
success = self.cellphone.add_cellphone(cellphone_dict)
if success:
cellphone = self.cellphone.get()
else:
cellphone = None
if cellphone:
if not user:
OHHOLog.print_log(country_code)
OHHOLog.print_log(cellphone_number)
result = Result.result_failed("user doest not exist")
else:
result = self.cellphone.bind_cellphone(cellphone.id, user.id)
data = self.user.get_user_information(user.id, base_url)
result["data"] = data
else:
result = Result.result_failed("cellphone does not exist!")
else:
result = Result.result_failed("code is incorrect!")
return result
def add_basic(self, user_id, extension, description_I_am,
description_I_like, description_I_unlike,
description_I_hope):
try:
user_extension = self.user_accuracy_extension.get_by_user(user_id)
if user_extension:
self.user_accuracy_extension.update_without_commit(
user_extension, extension)
else:
self.add_extension(extension)
query = self.user_description.get_query()
user_description = self.user_description.get_by_user(
query, user_id)
if description_I_am:
I_am = self.user_description.get_I_am(user_description)
I_am = self.user_description.order_by_id_desc(I_am)
I_am = self.user_description.first(I_am)
if I_am:
self.user_description.update_without_commit(
I_am, description_I_am)
else:
self.user_description.add_I_am(description_I_am)
if description_I_like:
I_like = self.user_description.get_I_like(query)
I_like = self.user_description.order_by_id_desc(I_like)
I_like = self.user_description.first(I_like)
if I_like:
self.user_description.update_without_commit(
I_like, description_I_like)
else:
self.user_description.add_I_like(description_I_like)
if description_I_unlike:
I_unlike = self.user_description.get_I_unlike(query)
I_unlike = self.user_description.order_by_id_desc(I_unlike)
I_unlike = self.user_description.first(I_unlike)
if I_unlike:
self.user_description.update_without_commit(
I_unlike, description_I_unlike)
else:
self.user_description.add_I_unlike(description_I_unlike)
if description_I_hope:
I_hope = self.user_description.get_I_hope(query)
I_hope = self.user_description.order_by_id_desc(I_hope)
I_hope = self.user_description.first(I_hope)
if I_hope:
self.user_description.update_without_commit(
I_hope, description_I_hope)
else:
self.user_description.add_I_hope_she_is(description_I_hope)
return Operation.commit()
except Exception as ex:
OHHOLog.print_log(ex)
return False
def get_by_imei(self, imei):
try:
query = self.get_query()
query = Operation.filter(query, self.model.imei, imei)
return Operation.first(query), None
except Exception as ex:
OHHOLog.print_log(ex)
return True, ex
def delete_some_without_commit(query):
try:
for instance in query:
Operation.delete_without_commit(instance)
return True
except Exception as ex:
OHHOLog.print_log(ex)
return False
def bulk_add(model, dict_list):
try:
session.execute(model.__table__.insert(), dict_list)
session.commit()
return True
except Exception as ex:
OHHOLog.print_log(ex)
return False
def get(self):
print(self.__class__.__name__)
self.set_header("Content-Type", "application/json; charset=utf-8")
name1 = self.get_argument("name1")
name2 = self.get_argument("name2")
result = LogicPhoneDistance.add_by_names(name1, name2)
OHHOLog.print_log(result)
self.write(OHHOOperation.dict2json(result))
def duplex_match(self, user_id, user_id_list):
result = list()
OHHOLog.print_log(user_id_list)
user_id_list = self.match_by_condition_version2(user_id, user_id_list)
for uid in user_id_list:
temp = self.match_by_condition_version2(uid, [user_id])
if temp:
result.append(uid)
return result
def delete_outdated(self):
query = self.get_query()
query = self.get_by_user(query, None)
query = self.get_by_device_from_query(query, None)
twenty_four_hours_before = OHHODatetime.several_hours_before_from_now()
query = self.imei.get_less_than_created_at(query,
twenty_four_hours_before)
OHHOLog.print_log(self.imei.get_count(query))
return self.delete_some(query)
def polling_get_by_another(self, user, small_timestamp, big_timestamp):
apply = self.apply
query = apply.get_query()
query = apply.get_by_another_user(query, user.id)
query = apply.get_by_timestamp_great_than_equal(query, small_timestamp)
query = apply.get_by_timestamp_less_than(query, big_timestamp)
query = apply.order_by_id_desc(query)
OHHOLog.print_log(query.count())
return query
def push_agree(self, to_user_id, user_id, apply_id, base_url, function,
type):
information = self.user.get_basic_user_information(user_id, base_url)
temp = self.meet.get_countdown(apply_id)
OHHOLog.print_log(temp)
information = OHHOOperation.dict_add_dict(information, temp)
information["apply_id"] = apply_id
information["function"] = function
return self.user.push_user_information(to_user_id, type, information)
def add(kwargs):
result = dict()
result["success"] = False
if kwargs:
obj = DBPhonePosition.add(kwargs)
OHHOLog.print_log(obj)
else:
obj = DBPhonePosition.get_none()
if obj:
result["success"] = True
return result
def update_without_commit(instance, obj_dict):
try:
obj_dict["changed_at"] = datetime.datetime.utcnow()
obj_dict["timestamp"] = int(time.time() * 1000)
for key, value in obj_dict.items():
setattr(instance, key, value)
session.merge(instance)
return True
except Exception as ex:
OHHOLog.print_log(ex)
return False
def post(self):
the_post = Post()
self.set_format(the_post.get_format(self))
user_id = the_post.get_user_id(self)
OHHOLog.print_log(user_id)
cellphone_number = the_post.get_cellphone_number(self)
code = the_post.get_code(self)
country_code = the_post.get_country_code(self)
instance = LogicUpdateCellphoneNumber()
result = instance.change(user_id, cellphone_number, code, country_code)
return self.response(result)
def get(self):
self.imei.delete_outdated()
while True:
imei, instance, ex, random = self.imei.get_by_new_imei()
if not instance:
self.imei.add_new_imei(random)
OHHOLog.print_log("add empty imei!")
result = Result.result_success()
result["data"] = random
# result["imei"] = random
return result
