def _execute_time(self):
start_time = OHHODatetime.get_current_timestamp()
result = func(self)
end_time = OHHODatetime.get_current_timestamp()
OHHOLog.print_log(end_time)
OHHOLog.print_log(start_time)
OHHOLog.print_log(end_time - start_time)
return result
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 get_near_map(self, user_id, delta_time=5 * 1000):
timestamp = OHHODatetime.get_current_timestamp()
timestamp = timestamp - delta_time
query = self.map.filter_by_user(user_id)
query = self.map.get_great_than_equal_timestamp(query, timestamp)
query = self.map.order_by_id_desc(query)
return query
def _backstage_authenticate(self):
OHHOLog.print_log("backstage authentication start")
if self.current_user:
OHHOLog.print_log("backstage authentication current user:"******"backstage authentication user")
user_id = user.id
token_from_db = token_instance.get_by_user_id(user_id)
if token_from_db:
current_timestamp = OHHODatetime.get_current_timestamp()
if token_from_db.timestamp and current_timestamp - token_from_db.timestamp > 20 * 60 * 1000:
OHHOLog.print_log("backstage authentication timeout")
OHHOLog.print_log(current_timestamp)
OHHOLog.print_log(token_from_db.timestamp)
token_instance.delete(token_from_db)
self.clear_cookie("username")
return self.redirect("/backstage/login/")
else:
OHHOLog.print_log("backstage authentication success")
token_instance.update(token_from_db, dict())
result = func(self)
else:
self.clear_cookie("username")
return self.redirect("/backstage/login/")
else:
self.clear_cookie("username")
return self.redirect("/backstage/login/")
else:
OHHOLog.print_log("backstage authentication no username")
return self.redirect("/backstage/login/")
return result
def get(self, apply_id):
"""
根据请求ID获取最新的配对请求，
并且这个请求只在30分钟内有效
:param data_dict:
:return:
"""
if apply_id:
agree = self.agree
query = agree.filter_by_apply(apply_id)
query = agree.order_by_id_desc(query)
query = agree.first(query)
if query:
# 因为配对同意只能添加不能更改（没有地方会更改），
# 所以这里的timestamp是添加时的timestamp
if query.timestamp + VALID_INTERVAL_MILLISECOND > OHHODatetime.get_current_timestamp(
):
return query
else:
OHHOLog.print_log(VALID_FRIEND_AGREE_NOT_EXIST)
else:
OHHOLog.print_log(FRIEND_AGREE_NOT_EXIST)
else:
OHHOLog.print_log(PARAMETERS_ARE_INVALID)
return None
def return_map_information(self, friend_user_id):
result = dict()
result["is_timeout"] = 0
user = self.user.get_by_id(friend_user_id)
if user:
map_information = self.user.get_user_map_information_from_redis(user.username)
map_information_dict = RedisDB.data2dict(map_information)
if map_information_dict:
map_information_dict["longitude"] = float(map_information_dict.get("longitude", 0))
map_information_dict["latitude"] = float(map_information_dict["latitude"])
map_information_dict["altitude"] = float(map_information_dict["altitude"])
map_information_dict["accuracy"] = float(map_information_dict["accuracy"])
map_information_dict["angle"] = float(map_information_dict["angle"])
map_information_dict["satellite_number"] = int(map_information_dict["satellite_number"])
now = OHHODatetime.get_current_timestamp()
if map_information_dict["timestamp"] > 0 and now - map_information_dict["timestamp"] > 30000:
result["is_timeout"] = 1
result["timestamp"] = now
result["last_timestamp"] = map_information_dict["timestamp"]
else:
information = dict()
information["user_id"] = friend_user_id
information["latitude"] = float(map_information_dict["latitude"])
information["longitude"] = float(map_information_dict["longitude"])
information["accuracy"] = float(map_information_dict["accuracy"])
information["supplier"] = map_information_dict["supplier"]
if map_information_dict.get("floor", None):
information["floor"] = map_information_dict["floor"]
information["address"] = map_information_dict["address"]
information["timestamp"] = now
result["information"] = map_information_dict
return result
def get(self, one_user_id, another_user_id):
"""
根据发起人和接收人获取最新的配对请求，
并且这个请求只在30分钟内有效
:param data_dict:
:return:
"""
if one_user_id and another_user_id:
apply = self.apply
query = apply.get_query()
query = apply.get_by_one_user(query, one_user_id)
query = apply.get_by_another_user(query, another_user_id)
query = apply.order_by_id_desc(query)
query = apply.first(query)
if query:
# 因为配对请求只能添加不能更改（没有地方会更改），
# 所以这里的timestamp是添加时的timestamp
if query.timestamp + VALID_INTERVAL_MILLISECOND > OHHODatetime.get_current_timestamp():
return query
else:
OHHOLog.print_log(VALID_MATCH_APPLY_NOT_EXIST)
else:
OHHOLog.print_log(MATCH_APPLY_NOT_EXIST)
else:
OHHOLog.print_log(PARAMETERS_ARE_INVALID)
return None
def is_valid_instance(self, instance):
if instance:
timestamp = OHHODatetime.get_current_timestamp()
if instance.timestamp + VALID_INTERVAL_MILLISECOND < timestamp:
return False
return True
else:
return False
def get_apply_friend_list(self, user_id):
timestamp = int(OHHODatetime.get_current_timestamp())
query = self.apply.get_query()
query = self.apply.get_by_another_user(query, user_id)
# query = self.friend_get_apply_list(query)
query = self.apply.get_great_than_equal_timestamp(
query, timestamp - ONE_DAY_MICRO_SECONDS)
# query = self.get_valid_relation(query)
return query
def get_countdown(self, apply_id, total=TOTAL_TIME):
result = dict()
result["current_stamp"] = OHHODatetime.get_current_timestamp()
duplex_agree = self.duplex_agree.get_by_apply(apply_id)
current_timestamp = OHHODatetime.get_current_timestamp()
if duplex_agree and duplex_agree.timestamp:
end_timestamp = total + duplex_agree.timestamp
passed = current_timestamp - duplex_agree.timestamp
result["start_timestamp"] = duplex_agree.timestamp
result["end_timestamp"] = end_timestamp
result["countdown"] = TOTAL_TIME - passed
result["is_both_agree"] = True
else:
result["start_timestamp"] = 0
result["end_timestamp"] = 0
result["countdown"] = 0
result["is_both_agree"] = False
return result
def is_valid_instance(self, instance):
# OHHOLog.print_log("start")
if instance:
# OHHOLog.print_log("start")
# OHHOLog.print_log(instance.id)
timestamp = OHHODatetime.get_current_timestamp()
if instance.timestamp + VALID_INTERVAL_MILLISECOND < timestamp:
return False
return True
else:
return False
def get_by_apply(self, apply_id_list):
result = list()
if apply_id_list:
query = self.refuse.find_by_apply(apply_id_list)
query = self.refuse.order_by_id_desc(query)
query = self.refuse.first(query)
if not self.refuse.is_empty(query):
for q in query:
if q.timestamp + VALID_INTERVAL_MILLISECOND > OHHODatetime.get_current_timestamp(
):
result.append(q)
return result
def get_header():
header = dict()
nonce = OHHORandom.get_nonce()
current_time = str(OHHODatetime.get_current_timestamp())
app_secret = APP_SECRET
app_key = APP_KEY
check_sum = LogicHeader.get_check_sum(app_secret, nonce, current_time)
header[HEADER_NAME_NONCE] = nonce
header[HEADER_NAME_CURRENT_TIME] = current_time
header[HEADER_NAME_APP_KEY] = app_key
header[HEADER_NAME_NONCE] = nonce
header[HEADER_NAME_CHECK_SUM] = check_sum
return header
def clear_outdated_user(self):
timestamp = OHHODatetime.get_current_timestamp()
timestamp = timestamp - 1 * 60 * 1000
query = self.match_online.get_query()
delete_query = self.match_online.get_less_than_timestamp(
query, timestamp)
success = self.match_online.delete_some(delete_query)
if success:
OHHOLog.print_log(
Result.result_success("clear online outdated user"))
else:
OHHOLog.print_log(
Result.result_failed("clear online outdated user"))
def find_device_position(self, identity_id):
result = dict()
data = list()
circle = dict()
circle["longitude"] = -1
circle["latitude"] = -1
circle["radius"] = -1
self.device.set_identity(identity_id)
device = self.device.get_by_identity()
if device:
relation = self.relation.get_by_device(device.id)
if relation:
query = self.map.get_by_user(relation.user_id)
query = self.map.order_by_id_desc(query)
first = self.map.first(query)
if first:
current_timestamp = OHHODatetime.get_current_timestamp()
if current_timestamp < first.timestamp + FIND_DEVICE_TIMESTAMP_DELTA:
circle["longitude"] = first.longitude
circle["latitude"] = first.latitude
sensor_query = self.sensor.get_query()
sensor_query = self.sensor.get_by_device(
sensor_query, device.id)
sensor_query = self.sensor.get_by_user(
sensor_query, relation.user_id)
sensor_query = self.sensor.order_by_id_desc(
sensor_query)
first = self.sensor.first(sensor_query)
if first:
if current_timestamp < first.timestamp + FIND_DEVICE_TIMESTAMP_DELTA:
result = Result.result_success()
circle["radius"] = first.distance
else:
result = Result.result_failed(
"device sensor is outdated!")
else:
result = Result.result_failed("no device sensor!")
else:
result = Result.result_failed(
"map position is outdated!")
else:
result = Result.result_failed("no map position!")
else:
result = Result.result_failed("no user binds the device!")
else:
result = Result.result_failed("no such device!")
data.append(circle)
result["data"] = data
return result
def get(self, user_id, base_url):
data = list()
result = Result.result_success()
user = self.user.get_by_id(user_id)
current_timestamp = OHHODatetime.get_current_timestamp()
timestamp = RedisDB.hash_get(REDIS_APPLY_TIMESTAMP_NAME, user_id)
if not timestamp:
timestamp = current_timestamp - 5 * 60 * 1000
OHHOLog.print_log(timestamp)
RedisDB.hash_set(REDIS_APPLY_TIMESTAMP_NAME, user_id,
current_timestamp)
# OHHOLog.print_log("start")
# OHHOLog.print_log(user_id)
if user:
# OHHOLog.print_log("user")
apply_you = self.apply.polling_get_by_another(
user, int(timestamp), current_timestamp)
OHHOLog.print_log(current_timestamp)
OHHOLog.print_log(current_timestamp)
# OHHOLog.print_log(int(timestamp))
# OHHOLog.print_log(current_timestamp)
# OHHOLog.print_log(self.apply.apply.is_empty(apply_you))
if not self.apply.apply.is_empty(apply_you):
OHHOLog.print_log("has valid apply!")
for apply in apply_you:
OHHOLog.print_log(apply.id)
if self.meet.has_agree_apply(
apply.one_user_id) or self.meet.has_agree_apply(
apply.another_user_id):
# OHHOLog.print_log("has agree apply!")
continue
if self.meet.has_valid_apply(apply.one_user_id,
apply.another_user_id):
# OHHOLog.print_log("has valid apply 2!")
OHHOLog.print_log(apply.id)
user_dict = self.user.get_user_basic_information(
apply.one_user_id, base_url)
if user_dict:
data.append(user_dict)
if data:
# OHHOLog.print_log("has data")
# OHHOLog.print_log(data)
result["data"] = data
else:
pass
OHHOLog.print_log("not data")
return result
def add_without_commit(model, obj_dict):
try:
instance = model()
obj_dict["created_at"] = OHHODatetime.get_utc_now()
obj_dict["changed_at"] = OHHODatetime.get_utc_now()
if not obj_dict.get("timestamp", None):
obj_dict["timestamp"] = OHHODatetime.get_current_timestamp()
for key, value in obj_dict.items():
Operation.set_attribute(instance, key, value)
session.add(instance)
return instance
except Exception as ex:
OHHOLog.print_log(ex)
return None
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_icon(self, user_id, icon_id, icon, is_head_sculpture, base_url):
# result = Result.result_failed("default failed")
# OHHOLog.print_log(icon)
if icon:
now = OHHODatetime.get_now()
path = "static/user/icon/%d/%d/%d/" % (now.year, now.month,
now.day)
os.makedirs(path, exist_ok=True)
img = icon[0]
timestamp = OHHODatetime.get_current_timestamp()
name = str(user_id) + "_" + str(timestamp) + ".png"
thumbnail_name = str(user_id) + "_" + str(
timestamp) + "_thumbnail.png"
path_name = path + name
thumbnail_path_name = path + thumbnail_name
with open(path_name, 'wb') as f:
f.write(img["body"])
self.compress_icon(path_name, thumbnail_path_name)
icon_object = self.user.user_icon.get_by_id(icon_id)
data = dict()
data["icon"] = path_name
data["thumbnail"] = thumbnail_path_name
data["is_head_sculpture"] = is_head_sculpture
if icon_object:
self.user.user_icon.update_without_commit(icon_object, data)
else:
data["user_id"] = user_id
self.user.user_icon.add_without_commit(data)
result = Result.result_success()
result["url"] = base_url + path_name
result["thumbnail_url"] = base_url + thumbnail_path_name
else:
result = Result.result_failed("no image file")
result["url"] = ""
icon_object = self.user.user_icon.get_by_id(icon_id)
if icon_object:
data = dict()
data["icon"] = ""
data["thumbnail"] = ""
data["is_head_sculpture"] = 0
self.user.user_icon.update_without_commit(icon_object, data)
OHHOLog.print_log(result)
def upload_map_position(self, user_id, map_information, apply_id, base_url, timestamp=0):
# 上传地图坐标，只保存最新的坐标
information = dict()
user = self.user.get_by_id(user_id)
longitude = float(map_information.get("longitude", 0))
latitude = float(map_information.get("latitude", 0))
if user:
if map_information:
geohash_code = OHHOGeohash.get(latitude, longitude, 6)
map_information["geohash_code"] = geohash_code
map_information["timestamp"] = OHHODatetime.get_current_timestamp()
map_information["user_id"] = user_id
self.user.set_user_map_information(user.username, map_information)
self.user.add_user_geo_position(longitude, latitude, user.username)
self.map.add(map_information)
self_state, apply_id = self.meet.get_user_state_by_apply_and_user(apply_id, user_id)
friend_user_id = self.meet.get_another_user_id(apply_id, user_id)
friend_state, apply_id = self.meet.get_user_state_by_apply_and_user(apply_id, friend_user_id)
self_state, apply_id = self.meet.get_user_state_by_apply_and_user(apply_id, user_id)
if friend_state == PUSH_STATE_TYPE_END_MEET or self_state == PUSH_STATE_TYPE_END_MEET:
information["information"] = {"apply_id": int(apply_id)}
else:
information = self.return_map_information(friend_user_id)
if information.get("information", ""):
information["information"]["apply_id"] = int(apply_id)
map_instance = Map()
information["information"]["orientation"] = map_instance.main(user_id, friend_user_id)
information["information"]["nearest_poi_name"] = AMAP.get_nearest_poi_name_interface(longitude,
latitude)
else:
information["information"] = {"apply_id": int(apply_id)}
result = Result.result_success()
apply_id = int(apply_id)
temp = self.meet.get_countdown(apply_id)
result = OHHOOperation.dict_add_dict(result, temp)
result["data"] = information
return result
def add_user_icon(user_id, image_file, base_url, image_sequence):
image_sequence = int(image_sequence)
now = OHHODatetime.get_now()
path = "static/user/icon/%d/%d/%d/" % (now.year, now.month, now.day)
os.makedirs(path, exist_ok=True)
if image_file:
img = image_file[0]
timestamp = OHHODatetime.get_current_timestamp()
name = str(user_id) + "_" + str(timestamp) + ".png"
path_name = path + name
with open(path_name, 'wb') as f:
f.write(img["body"])
result = Result.result_success()
instance = DBOHHOUserIcon()
user_icon = instance.get_by_user(user_id)
if user_icon:
if image_sequence == 0:
instance.update(user_icon, {"first": path_name})
elif image_sequence == 1:
instance.update(user_icon, {"second": path_name})
elif image_sequence == 2:
instance.update(user_icon, {"third": path_name})
else:
instance.update(user_icon, {"fourth": path_name})
else:
if image_sequence == 0:
instance.add({"first": path_name, "user_id": user_id})
elif image_sequence == 1:
instance.add({"second": path_name, "user_id": user_id})
elif image_sequence == 2:
instance.add({"third": path_name, "user_id": user_id})
else:
instance.add({"fourth": path_name, "user_id": user_id})
result["url"] = base_url + path_name
if image_sequence == 0:
UpdateUserInfo.update_user_info(user_id, icon=base_url + path_name)
else:
result = Result.result_failed("no image file")
result["url"] = ""
return result
def add_group_and_page(self, permission_dict, group_id):
timestamp = OHHODatetime.get_current_timestamp()
permission_dict["timestamp"] = timestamp
OHHOLog.print_log(permission_dict)
if not self.page_permission.get_by_timestamp(timestamp) and group_id:
success = self.page_permission.add(permission_dict)
if success:
permission = self.page_permission.get_by_timestamp(timestamp)
if permission:
data = dict()
data["group_id"] = group_id
data["page_permission_id"] = permission.id
success = self.group_and_page.add(data)
if success:
return "添加成功"
else:
return "添加页面权限成功，但未绑定（请重新添加）"
else:
return "添加失败"
else:
return "参数不正确或者其他人和你同时添加，请重新添加"
def update_match_online(self, user_id):
timestamp = OHHODatetime.get_current_timestamp()
instance = self.match_online.get_by_user(user_id)
if instance:
success = self.match_online.update(instance,
{"timestamp": timestamp})
if success:
OHHOLog.print_log(
Result.result_success("update online for user %d" %
(int(user_id))))
else:
OHHOLog.print_log(
Result.result_failed("update online for user %d" %
(int(user_id))))
else:
success = self.match_online.add({"user_id": user_id})
if success:
OHHOLog.print_log(
Result.result_success("add online for user %d" %
(int(user_id))))
else:
OHHOLog.print_log(
Result.result_failed("add online for user %d" %
(int(user_id))))
def get_valid_timestamp(self):
timestamp = OHHODatetime.get_current_timestamp()
return timestamp - VALID_INTERVAL_MILLISECOND
def parse_parameters(self, data):
"""
数据结构
{
"list": [
{
"adCode": "110105",
"adName": "朝阳区",
"businessArea": "酒仙桥",
"cityCode": "010",
"distance": 32,
"img1": "http://store.is.autonavi.com/showpic/1c14d394cf5036a4418c92ec8d1bcbe7",
"img2": "http://store.is.autonavi.com/showpic/21122e8fcbca2e979b9089068b3a1c8e",
"img3": "http://store.is.autonavi.com/showpic/ce8c7fe35460bc58c4b37f59ff2b0812",
"poiId": "B0FFHVITFC",
"provinceCode": "110000",
"provinceName": "北京市",
"snippet": "酒仙桥路18号颐堤港LG层LG-12",
"tel": "010-64318399",
"title": "美希亚弁当(颐堤港)",
"typeCode": "050202",
"typeDes": "餐饮服务;外国餐厅;日本料理"
},
{
"adCode": "110105",
"adName": "朝阳区",
"businessArea": "酒仙桥",
"cityCode": "010",
"distance": 34,
"poiId": "B0FFI2DTOL",
"provinceCode": "110000",
"provinceName": "北京市",
"snippet": "颐堤港2层L273",
"tel": "",
"title": "弗萨塔可",
"typeCode": "050100",
"typeDes": "餐饮服务;中餐厅;中餐厅"
}
],
"name": "颐提港",
"longitude": 116.490807
"latitude": 39.97005
}
:param rssi_parameters:
:return:
"""
data_dict = OHHOOperation.json2dict(data)
data = list()
if data_dict:
name = data_dict["name"]
longitude = data_dict["longitude"]
latitude = data_dict["latitude"]
phone = data_dict["phone"]
the_list = data_dict["list"]
for d in the_list:
temp = d
temp["name"] = name
temp["longitude"] = longitude
temp["latitude"] = latitude
temp["phone"] = phone
temp["timestamp"] = OHHODatetime.get_current_timestamp()
data.append(temp)
return data
def agree_meet(self, user_id, friend_user_id, apply_id, base_url):
"""
同意见面
1. 两个人都没有同意的申请
2. 对方有有效的申请
:param user_id: 用户ID
:param friend_user_id: 另一用户ID
:return:
"""
user_id = int(user_id)
friend_user_id = int(friend_user_id)
apply_id = int(apply_id)
function = "agree meet"
apply = self.meet.get_apply_by_id(apply_id)
result = Result.result_success()
result["current_timestamp"] = OHHODatetime.get_current_timestamp()
if apply:
# 是否有有效的申请
is_apply_agreeable = self.meet.is_apply_agreeable(apply, user_id)
if is_apply_agreeable:
# 本人同意见面
self.meet.add_agree(apply_id, user_id)
# 获取另一人的user_id
another_user_id = apply.one_user_id if apply.another_user_id == user_id else apply.another_user_id
# 另一人是否同意
is_another_agreed = self.meet.is_apply_agreed(
apply_id, another_user_id)
if is_another_agreed:
OHHOLog.print_log("another agreed: %d" % (another_user_id))
one_user_map_data = self.user.get_user_map_information(
user_id)
another_user_map_data = self.user.get_user_map_information(
another_user_id)
if one_user_map_data and another_user_map_data:
self.meet.add_duplex_agree(one_user_map_data,
another_user_map_data,
apply_id)
# 另一人是否有空（是否见面结束）
# is_another_not_free = self.meet.get_apply_id_list_by_user_from_meeting(another_user_id)
state, nothing_id = self.meet.get_user_state(
another_user_id)
OHHOLog.print_log("user state: %d" % (int(state)))
if state != PUSH_STATE_TYPE_END_MEET:
OHHOLog.print_log("the user is %d, and he is busy" %
(another_user_id))
OHHOLog.print_log("and his state is %d" % state)
# 没空 就把对方的ID写入到双方都同意的redis缓存中
self.meet.add_duplex_agree2redis(
user_id, another_user_id, apply_id)
# self.meet.add_duplex_agree2redis(another_user_id, str(user_id) + "," + str(apply_id))
else:
OHHOLog.print_log("both agree")
# 有空 向双方发送推送
type = PUSH_STATE_TYPE_AGREE_MEET
OHHOLog.print_log("push %d to %d, apply id is %d" %
(another_user_id, user_id, apply_id))
result = self.push_agree(user_id, another_user_id,
apply_id, base_url, function,
type)
OHHOLog.print_log(result)
OHHOLog.print_log("push %d to %d, apply id is %d" %
(user_id, another_user_id, apply_id))
result = self.push_agree(another_user_id, user_id,
apply_id, base_url, function,
type)
OHHOLog.print_log(result)
# 添加两个人的状态为见面中
self.meet.add_meeting(apply_id, user_id)
self.meet.add_meeting(apply_id, another_user_id)
else:
OHHOLog.print_log("single agree")
type = PUSH_STATE_TYPE_SINGLE_AGREE_MEET
OHHOLog.print_log("push %d to %d, apply id is %d" %
(user_id, another_user_id, apply_id))
result = self.push_agree(another_user_id, user_id,
apply_id, base_url, function,
type)
OHHOLog.print_log(result)
return result
