def unbind_device(self, cellphone, code, identity, mac_address,
country_code):
# OHHOLog.print_log(cellphone)
# OHHOLog.print_log(identity)
# OHHOLog.print_log(mac_address)
if country_code and cellphone:
the_cellphone = country_code + cellphone
else:
return Result.result_parameters_are_invalid(
"country_code or cellphone is empty!")
success = Code.check_code(the_cellphone, code)
if success:
country_code_object = self.user.get_country_code(country_code)
country_code_id = country_code_object.id if country_code_object else 0
user = self.user.get_by_country_code_and_cellphone(
country_code_id, cellphone)
if user:
self.device.set_mac_address(mac_address)
self.device.set_identity(identity)
device = self.device.get_by_identity()
if device:
# OHHOLog.print_log("before delete imei")
self.imei.delete_by_user_and_device(user.id, device.id)
# OHHOLog.print_log("after delete imei")
# query = self.imei.get_by_user_and_device(user.id, device.id)
# self.imei.delete_some(query)
return self.device.unbind_device(user.id)
else:
return Result.result_not_exist(USER_NOT_EXIST)
else:
return Result.result_failed(PASSWORD_IS_INCORRECT)
def basic_meet(self, relation, meet_state):
if relation:
success = self.relation.update_meet_state(relation, meet_state)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_not_exist("no relation!")
return result
def basic_friend(self, relation, friend_state):
if relation:
print(relation)
success = self.relation.update_friend_state(relation, friend_state)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_not_exist()
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 update_setting(self, identity_id, password, name, power):
self.device.set_identity(identity_id)
device = self.device.get_by_identity()
if device:
instance = self.setting.get_by_device(device.id)
if instance:
data_dict = dict()
data_dict["password"] = Password.aes_encryption(password)
data_dict["name"] = name
data_dict["power"] = power
success = self.setting.update(instance, data_dict)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_not_exist(DEVICE_SETTING_NOT_EXIST)
else:
result = Result.result_not_exist(DEVICE_NOT_EXIST)
return result
def check_verification_code(cellphone_number, code):
code_in_redis = Code.get_code(cellphone_number)
if code_in_redis:
code_in_redis_unicode = OHHOOperation.to_str(code_in_redis)
OHHOLog.print_log(code_in_redis_unicode)
OHHOLog.print_log(code)
if code_in_redis_unicode == code:
Code.delete_code(cellphone_number)
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_not_exist()
return result
def get_setting_information(self, identity_id):
self.device.set_identity(identity_id)
device = self.device.get_by_identity()
data = dict()
if device:
instance = self.setting.get_by_device(device.id)
if instance:
data = self.setting.get_information(instance)
data["source_password"] = Password.aes_decryption(data["password"])
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_not_exist(DEVICE_NOT_EXIST)
result["data"] = data
return result
def bind_device(self, user_id, type=1):
try:
OHHOLog.print_log("bind device start")
device = self.get_by_identity()
if device and self.device.check_by_mac():
relation = self.relation.get_by_device(device.id)
if relation and self.relation.is_valid(relation, True):
if relation.user_id == int(user_id):
result = Result.result_exist(RELATION_EXIST)
else:
user = self.user.get_by_id(relation.user_id)
cellphone = user.cellphone
country_code_id = user.country_code_id
country_code_obj = self.countryCode.get_by_id(
country_code_id)
if country_code_obj:
country_code = country_code_obj.country_code
else:
country_code = "+86"
result = Result.result_device_used_by_other()
result["country_code"] = country_code
result["cellphone_number"] = cellphone
else:
success = self.relation.add_without_commit({
"device_id":
device.id,
"user_id":
user_id,
"type":
type
})
if success:
self.relation.commit()
result = Result.result_success()
else:
self.relation.rollback()
result = Result.result_failed()
else:
result = Result.result_not_exist()
OHHOLog.print_log("bind device end")
return result
except Exception as ex:
OHHOLog.print_log(ex)
return Result.result_failed(ex)
def remove_black(self, user_id, friend_user_id):
# query = self.friend.get_relation_by_user_and_friend(user_id, friend_user_id)
# query = self.friend.get_valid_relation(query)
# relation = self.friend.first_relation(query)
relation = self.friend.get_black_by_user_and_friend(user_id, friend_user_id)
if relation:
if relation.apply_id:
success = self.friend.black2friend(relation)
else:
success = self.friend.friend.delete(relation)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_not_exist()
return result
def get(self, user_id, name=None):
relation = self.relation.get(user_id, name)
if relation:
result = Result.result_success()
else:
user_id = 1
name = "test"
relation = self.relation.get(user_id, name)
if relation:
result = Result.result_not_exist(DEFAULT)
else:
result = Result.result_failed()
if relation:
condition = self.condition.get_by_id(relation.match_condition_id)
if condition:
result["data"] = self.condition.get_information(condition)
else:
condition = None
return result, condition
def add_setting(self, identity_id, password, name, power, periods):
self.device.set_identity(identity_id)
device = self.device.get_by_identity()
password_instance = Password(password)
if device:
instance = self.setting.get_by_device(device.id)
if instance:
result = Result.result_exist(DEVICE_SETTING_EXIST)
else:
data_dict = dict()
data_dict["device_id"] = device.id
data_dict["password"] = password_instance.aes_encryption()
data_dict["name"] = name
data_dict["power"] = power
data_dict["periods"] = periods
success = self.setting.add(data_dict)
if success:
result = Result.result_success()
else:
result = Result.result_failed()
else:
result = Result.result_not_exist(DEVICE_NOT_EXIST)
return result
