def get(self):
the_get = Get()
group_id = the_get.get_id(self)
if group_id:
instance_user = DBOHHOUser()
instance_group_user_relation = OHHOPermission().group_and_user
users = instance_user.get_query()
users = instance_user.get_valid(users)
users = instance_user.get_all(users)
user_list = list()
group_user_list = list()
group_users = instance_group_user_relation.get_by_group_id(
group_id)
group_users = instance_group_user_relation.get_all(group_users)
if users:
for user in users:
if group_users:
for group_user in group_users:
if user.username == group_user.username:
group_user_list.append(user)
user_list.append(user)
user_list = list(set(user_list) - set(group_user_list))
return self.render(
PERMISSION_GROUP_USER_RELATION_HTML,
add_url=PERMISSION_GROUP_USER_RELATION_ADD_URL,
delete_url=PERMISSION_GROUP_USER_RELATION_DELETE_URL,
list_url=PERMISSION_GROUP_BACKSTAGE_LIST_URL,
group_id=group_id,
user_list=user_list,
group_user_list=group_user_list,
)
else:
return self.redirect(PERMISSION_GROUP_BACKSTAGE_LIST_URL)
def post(self):
the_post = Post()
username = the_post.get_username(self)
cellphone_key = the_post.get_cellphone_key(self)
user_instance = DBOHHOUser()
cellphone_instance = DBCellphone()
relation_instance = DBOHHOUserAndCellphoneRelation()
user = user_instance.get_by_username(username)
cellphone_instance.set_key(cellphone_key)
cellphone = cellphone_instance.get_by_key()
if user and cellphone:
relation = relation_instance.get_by_cellphone_and_user(
cellphone.id, user.id)
if not relation:
data = dict()
data["user_id"] = user.id
data["cellphone_id"] = cellphone.id
success = relation_instance.add(data)
if success:
return self.redirect(USER_AND_CELLPHONE_LIST_URL)
else:
if not relation.state:
relation_instance.restore(relation)
return self.redirect(USER_AND_CELLPHONE_LIST_URL)
return self.redirect(USER_AND_CELLPHONE_ADD_URL)
def get(self):
user_instance = DBOHHOUser()
cellphone_instance = DBCellphone()
relation_instance = DBOHHOUserAndCellphoneRelation()
the_get = Get()
relation_id = the_get.get_id(self)
username = ""
cellphone_key = ""
state = False
if relation_id:
relation = relation_instance.get_by_id(relation_id)
if relation:
state = relation.state
user = user_instance.get_by_id(relation.user_id)
username = user.username if user else ""
cellphone = cellphone_instance.get_by_id(relation.cellphone_id)
cellphone_key = cellphone.key if cellphone else ""
return self.render(USER_AND_CELLPHONE_DETAIL_HTML,
username=username,
cellphone_key=cellphone_key,
state=state,
relation_id=relation_id,
detail_url=USER_AND_CELLPHONE_DETAIL_URL,
list_url=USER_AND_CELLPHONE_LIST_URL)
def __init__(self):
self.user = DBOHHOUser()
self.user_and_device_relation = DBOHHOUserAndDeviceRelation()
self.password = Password()
self.token = Token()
self.user_extension = DBOHHOUserAccuracyExtension()
self.interest = DBOHHOInterest()
self.map = DBOHHOMapInformation()
self.device = DBOHHODevice()
self.record_user_and_match_condition = DBOHHORecordUserAndMatchCondition(
)
self.match_condition = DBOHHORecordMatchCondition()
self.im_user = DBOHHOIMUser()
self.im_user_relation = DBOHHOIMUserRelation()
self.user_configuration = DBOHHOUserConfiguration()
self.imei = IMEI()
self.user_and_device_imei = DBOHHOUserAndDeviceIMEI()
self.friend = Friend()
self.apply = DBOHHORecordMatchApply()
self.country_code = DBOHHOCountryCode()
self.user_and_cellphone_relation = DBOHHOUserAndCellphoneRelation()
self.user_favourite_book = DBOHHOUserFavouriteBook()
self.user_favourite_movie = DBOHHOUserFavouriteMovie()
self.user_favourite_sport = DBOHHOUserFavouriteSport()
self.user_favourite_music = DBOHHOUserFavouriteMusic()
self.user_icon = DBOHHOUserIcon()
self.user_description = DBOHHOUserDescription()
self.user_impression = DBOHHOUserImpression()
def get(self):
the_get = Get()
relation_id = the_get.get_id(self)
username = ""
identity_id = ""
state = False
user_instance = DBOHHOUser()
device_instance = DBOHHODevice()
relation_instance = DBOHHOUserAndDeviceRelation()
if relation_id:
relation = relation_instance.get_by_id(relation_id)
if relation:
state = relation.state
user = user_instance.get_by_id(relation.user_id)
username = user.username if user else ""
device = device_instance.get_by_id(relation.device_id)
identity_id = device.identity_id if device else ""
return self.render(
USER_AND_DEVICE_DELETE_HTML,
username=username,
identity_id=identity_id,
state=state,
detail_url=USER_AND_DEVICE_DETAIL_URL,
list_url=USER_AND_DEVICE_LIST_URL,
delete_url=USER_AND_DEVICE_DELETE_URL,
)
def get(self):
user_instance = DBOHHOUser()
users_query = user_instance.get_query()
users_query = user_instance.get_valid(users_query)
return self.render(IM_USER_ADD_HTML,
add_url=IM_USER_ADD_URL,
list_url=IM_USER_LIST_URL,
users_query=users_query,
)
def get(self):
user_instance = DBOHHOUser()
device_instance = DBOHHODevice()
user_query = user_instance.get_query()
user_query = user_instance.get_valid(user_query)
device_query = device_instance.get_query()
device_query = device_instance.get_all(device_query)
return self.render(USER_AND_DEVICE_ADD_HTML,
add_url=USER_AND_DEVICE_ADD_URL,
list_url=USER_AND_DEVICE_LIST_URL,
user_query=user_query,
device_query=device_query)
def get(self):
user_instance = DBOHHOUser()
cellphone_instance = DBCellphone()
users_query = user_instance.get_query()
users_query = user_instance.get_valid(users_query)
cellphones_query = cellphone_instance.get_query()
return self.render(
USER_AND_CELLPHONE_ADD_HTML,
add_url=USER_AND_CELLPHONE_ADD_URL,
list_url=USER_AND_CELLPHONE_LIST_URL,
users_query=users_query,
cellphones_query=cellphones_query,
)
def post(self):
the_post = Post()
username = the_post.get_username(self)
im_user_instance = User()
user_instance = DBOHHOUser()
user = user_instance.get_by_username(username)
if user:
success = im_user_instance.add_im(user.id)
if success:
return self.redirect(IM_USER_LIST_URL)
return self.redirect(IM_USER_ADD_URL)
class LogicTestGetUserByDevice(object):
def __init__(self):
self.device = Device()
self.user = DBOHHOUser()
def get(self, identity_list):
data = list()
relation_list = list()
for identity in identity_list:
self.device.set_identity(identity)
relation = self.device.get_relation_by_device()
if relation:
temp = dict()
temp["identity"] = identity
temp["relation"] = relation
relation_list.append(temp)
for item in relation_list:
temp = item
relation = item["relation"]
user = self.user.get_by_id(relation.user_id)
if user:
temp["username"] = user.username
del temp["relation"]
data.append(temp)
if data:
result = Result.get_result(True, 1, 1, "OK!")
else:
result = Result.get_result(False, -1, -1, "no data!")
result["data"] = data
return result
def post(self):
the_post = Post()
user_instance = DBOHHOUser()
condition_instance = DBOHHORecordMatchCondition()
relation_instance = UserAndMatchCondition()
username = the_post.get_username(self)
name = the_post.get_name(self)
match_condition_id = the_post.get_id(self)
user = user_instance.get_by_cellphone(username)
match_condition = condition_instance.get_by_id(match_condition_id)
if user and match_condition:
result = relation_instance.add(user.id, name, match_condition_id)
if result["code"] == 1:
return self.redirect(USER_AND_MATCH_CONDITION_LIST_URL)
return self.redirect(USER_AND_MATCH_CONDITION_ADD_URL)
def post(self):
the_post = Post()
username = the_post.get_username(self)
identity_id = the_post.get_device_identity_id(self)
user_instance = DBOHHOUser()
device_instance = DBOHHODevice()
relation_instance = DBOHHOUserAndDeviceRelation()
user = user_instance.get_by_username(username)
device_instance.set_identity(identity_id)
device = device_instance.get_by_identity()
if user and device:
data = dict()
data["user_id"] = user.id
data["device_id"] = device.id
success = relation_instance.add(data)
if success:
return self.redirect(USER_AND_DEVICE_LIST_URL)
return self.redirect(USER_AND_DEVICE_ADD_URL)
def __init__(self):
self.user = DBOHHOUser()
self.user_and_device_relation = DBOHHOUserAndDeviceRelation()
self.password = Password()
self.token = Token()
self.user_extension = DBOHHOUserAccuracyExtension()
self.interest = DBOHHOInterest()
self.map = DBOHHOMapInformation()
self.device = DBOHHODevice()
self.record_user_and_match_condition = DBOHHORecordUserAndMatchCondition()
self.match_condition = DBOHHORecordMatchCondition()
self.im_user = DBOHHOIMUser()
self.im_user_relation = DBOHHOIMUserRelation()
self.user_configuration = DBOHHOUserConfiguration()
self.imei = IMEI()
self.user_and_device_imei = DBOHHOUserAndDeviceIMEI()
self.friend = Friend()
self.apply = DBOHHORecordMatchApply()
self.country_code = DBOHHOCountryCode()
def __init__(self, index=0):
self.user = DBOHHOUser(index)
self.user_accuracy_extension = DBOHHOUserAccuracyExtension(index)
self.user_description = DBOHHOUserDescription(index)
self.user_favourite_book = DBOHHOUserFavouriteBook(index)
self.user_favourite_movie = DBOHHOUserFavouriteMovie(index)
self.user_favourite_music = DBOHHOUserFavouriteMusic(index)
self.user_favourite_sport = DBOHHOUserFavouriteSport(index)
self.user_icon = DBOHHOUserIcon(index)
self.user_impression = DBOHHOUserImpression(index)
def add_music(data):
user_id = data.get("user_id", "")
music_id = data.get("music_id", "")
user_instance = DBOHHOUser()
music_instance = DBOHHOUserFavouriteMusic()
if user_id and music_id:
user = user_instance.get_by_id(user_id)
if user:
success = music_instance.add(data)
if success:
result = Result.result_success()
else:
result = Result.result_failed("add failure")
else:
result = Result.result_failed("user not exist")
else:
result = Result.result_parameters_are_invalid()
return result
def add_book(data):
user_id = data.get("user_id", "")
isbn = data.get("isbn", "") # 国际图书编码
user_instance = DBOHHOUser()
book_instance = DBOHHOUserFavouriteBook()
if user_id and isbn:
user = user_instance.get_by_id(user_id)
if user:
success = book_instance.add(data)
if success:
result = Result.result_success()
else:
result = Result.result_failed("add failure")
else:
result = Result.result_failed("user not exist")
else:
result = Result.result_parameters_are_invalid()
return result
def post(self):
user_instance = DBOHHOUser()
cellphone_instance = DBCellphone()
relation_instance = DBOHHOUserAndCellphoneRelation()
the_post = Post()
username = the_post.get_username(self)
relation_id = the_post.get_id(self)
detail_url = USER_AND_CELLPHONE_DETAIL_URL + "?id=" + relation_id
cellphone_key = the_post.get_cellphone_key(self)
user = user_instance.get_by_username(username)
cellphone_instance.set_key(cellphone_key)
cellphone = cellphone_instance.get_by_key()
relation = relation_instance.get_by_id(relation_id)
submit = self.get_body_argument("submit", None)
delete_or_restore = self.get_body_argument("delete_or_restore", None)
if submit:
if cellphone and user:
if relation:
data = dict()
data["user_id"] = user.id
data["cellphone_id"] = cellphone.id
success = relation_instance.update(relation, data)
if success:
return self.redirect(USER_AND_CELLPHONE_LIST_URL)
return self.redirect(detail_url)
# if delete_or_restore:
# if cellphone and user:
# if relation:
# if relation.state:
# # print("execute delete")
# success = relation_instance.delete(relation)
# if success:
# return self.redirect(USER_AND_CELLPHONE_LIST_URL)
# else:
# # print("execute restore")
# success = relation_instance.restore(relation)
# if success:
# return self.redirect(USER_AND_CELLPHONE_LIST_URL)
return self.redirect(detail_url)
def is_device_valid(self):
device = self.device.get_by_identity()
# OHHOLog.print_log(self.device.get_identity())
# OHHOLog.print_log(device)
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):
result = Result.result_device_used_by_other()
user = DBOHHOUser()
user_instance = user.get_by_id(relation.user_id)
if user_instance:
result["cellphone_number"] = user_instance.cellphone
code = DBOHHOCountryCode.get_by_id(
user_instance.country_code_id)
if code:
result["country_code"] = code.country_code
else:
result["country_code"] = "+86"
return result
else:
return Result.result_success()
else:
return Result.result_failed(INVALID_DEVICE)
def post(self):
the_post = Post()
username = the_post.get_username(self)
identity_id = the_post.get_device_identity_id(self)
user_instance = DBOHHOUser()
device_instance = DBOHHODevice()
relation_instance = DBOHHOUserAndDeviceRelation()
user = user_instance.get_by_username(username)
device_instance.set_identity(identity_id)
device = device_instance.get_by_identity()
submit = the_post.get_submit(self)
# delete_or_restore = the_post.get_delete_or_restore(self)
if submit:
if device:
relation = relation_instance.get_by_device(device.id)
if relation:
if user:
data = dict()
data["user_id"] = user.id
if relation:
relation_instance.update(relation, data)
# if delete_or_restore:
# if device:
# relation = relation_instance.get_by_device(device.id)
# if relation:
# if relation.state:
# # print("execute delete")
# relation_instance.delete(relation)
# else:
# # print("execute restore")
# relation_instance.restore(relation)
return self.redirect(USER_AND_DEVICE_LIST_URL)
def post(self):
the_post = Post()
username = the_post.get_username(self)
identity_id = the_post.get_device_identity_id(self)
user_instance = DBOHHOUser()
device_instance = DBOHHODevice()
relation_instance = DBOHHOUserAndDeviceRelation()
user = user_instance.get_by_username(username)
device_instance.set_identity(identity_id)
device = device_instance.get_by_identity()
delete_or_restore = the_post.get_delete_or_restore(self)
if delete_or_restore:
if device:
relation = relation_instance.get_by_device(device.id)
if relation:
if relation.state:
# print("execute delete")
relation_instance.delete(relation)
else:
# print("execute restore")
relation_instance.restore(relation)
return self.redirect(USER_AND_DEVICE_LIST_URL)
class LogicBackstageRegister(object):
def __init__(self):
self.user = DBOHHOUser()
self.password = Password()
def register(self, username, password):
if username and password:
self.password.set_password(password)
encryption_password = self.password.encryption()
data = dict()
data["username"] = username
data["password"] = encryption_password
success = self.user.add(data)
if success:
return True
return False
class LogicExistCellphone(object):
def __init__(self):
self.country_code = DBOHHOCountryCode()
self.user = DBOHHOUser()
def exist(self, country_code, cellphone):
OHHOLog.print_log(country_code)
OHHOLog.print_log(cellphone)
country_code_object = self.country_code.get_by_country_code(country_code)
if country_code_object:
success = self.user.get_by_country_code_and_cellphone(country_code_object.id, cellphone)
if success:
return Result.result_success()
else:
return Result.result_failed("no such cellphone")
else:
return Result.result_failed("country code is invalid")
def get(self):
user = DBOHHOUser()
query = user.get_query()
total_count = user.get_count(query)
today_start = OHHODatetime.get_today_start()
utc_today_start = OHHODatetime.beijing2utc(today_start)
today_query = user.get_great_than_equal_created_at(
query, utc_today_start)
today_count = user.get_count(today_query)
return self.render(
STATISTICS_USER_HTML,
total_count=total_count,
today_count=today_count,
)
class LogicAddUser(object):
def __init__(self):
self.user = DBOHHOUser()
self.user_and_device_relation = DBOHHOUserAndDeviceRelation()
self.password = Password()
self.token = Token()
self.user_extension = DBOHHOUserAccuracyExtension()
self.interest = DBOHHOInterest()
self.map = DBOHHOMapInformation()
self.device = DBOHHODevice()
self.record_user_and_match_condition = DBOHHORecordUserAndMatchCondition()
self.match_condition = DBOHHORecordMatchCondition()
self.im_user = DBOHHOIMUser()
self.im_user_relation = DBOHHOIMUserRelation()
self.user_configuration = DBOHHOUserConfiguration()
self.imei = IMEI()
self.user_and_device_imei = DBOHHOUserAndDeviceIMEI()
self.friend = Friend()
self.apply = DBOHHORecordMatchApply()
self.country_code = DBOHHOCountryCode()
self.user_and_cellphone_relation = DBOHHOUserAndCellphoneRelation()
# def gevent_add_user_test(self, cellphone):
def add_user(self, number=10):
gevent_list = [gevent.spawn(self.gevent_add_user_test, number) for i in range(2)]
gevent.joinall(gevent_list)
cellphone = 10000000000
def gevent_add_user_test(self, number):
global cellphone
# identity_card = 100000000000000000
user_query = self.user.get_query()
user_query = self.user.order_by_id_desc(user_query)
user_obj = Operation.first(user_query)
if user_obj:
if user_obj.cellphone:
cellphone = int(user_obj.cellphone)
i = 0
while i <= number:
# OHHOLog.print_log(i)
i += 1
cellphone += 1
while self.user.get_by_cellphone(str(cellphone)):
cellphone = cellphone + 1
user_id = self.add_user_table(str(cellphone))
self.add_user_token_table(user_id)
self.add_user_extension(user_id)
print("for end")
print("end")
# def add_user(self, number=10):
def gevent_add_user_test(self, number):
global cellphone
# identity_card = 100000000000000000
user_query = self.user.get_query()
user_query = self.user.order_by_id_desc(user_query)
user_obj = Operation.first(user_query)
if user_obj:
if user_obj.cellphone:
cellphone = int(user_obj.cellphone)
i = 0
while i <= number:
# OHHOLog.print_log(i)
i += 1
cellphone += 1
while self.user.get_by_cellphone(str(cellphone)):
cellphone = cellphone + 1
user_id = self.add_user_table(str(cellphone))
self.add_user_token_table(user_id)
self.add_user_extension(user_id)
print("for end")
print("end")
def add_user_commit_all(self, number=10):
cellphone = 10000000000
# identity_card = 100000000000000000
user_query = self.user.get_query()
user_query = self.user.order_by_id_desc(user_query)
user_obj = Operation.first(user_query)
if user_obj:
if user_obj.cellphone:
cellphone = int(user_obj.cellphone)
i = 1
dic_list_token = list()
dic_list_extension = list()
while i <= number:
# OHHOLog.print_log(i)
print(i)
i += 1
cellphone += 1
data = dict()
while self.user.get_by_cellphone(str(cellphone)):
cellphone = cellphone + 1
user_id = self.add_user_table(str(cellphone))
token_dic = self.add_user_token_table_dic(user_id)
extension_dic = self.add_user_extension_dic(user_id)
dic_list_token.append(token_dic)
dic_list_extension.append(extension_dic)
self.token.token.bulk_add(dic_list_token)
self.user_extension.bulk_add(dic_list_extension)
print("for end")
print("end")
def add_user1(self, number=10):
cellphone = 10000000000
# identity_card = 100000000000000000
user_query = self.user.get_query()
user_query = self.user.order_by_id_desc(user_query)
user_obj = Operation.first(user_query)
if user_obj:
if user_obj.cellphone:
cellphone = int(user_obj.cellphone)
i = 0
while i <= number:
# OHHOLog.print_log(i)
i += 1
cellphone += 1
while self.user.get_by_cellphone(str(cellphone)):
cellphone = cellphone + 1
user_id = self.add_user_table(str(cellphone))
self.add_user_token_table(user_id)
self.add_user_extension(user_id)
print("for end")
print("end")
def add_user_impression(self, user_id):
data = dict()
obj = OhhoRandom.get_user_impression()
data["user_id"] = user_id
data["another_user_id"] = obj.get("another_user_id", "")
data["content_id"] = obj.get("content_id", "")
data["apply_id"] = obj.get("apply_id", "")
data["type"] = obj.get("type", "")
self.user_impression.add(data)
def add_user_icon(self, user_id):
data = dict()
obj = OhhoRandom.get_user_icon()
data["user_id"] = user_id
data["icon"] = obj.get("icon", "")
data["is_head_sculpture"] = obj.get("is_head_sculpture", "")
data["thumbnail"] = obj.get("thumbnail", "")
self.user_icon.add(data)
def add_user_favourite_sport(self, user_id):
data = dict()
obj = OhhoRandom.get_favourite_sport()
data["user_id"] = user_id
data["sport_id"] = obj.get("sport_id", "")
data["name"] = obj.get("name", "")
data["description"] = obj.get("description", "")
data["index"] = obj.get("index", "")
self.user_favourite_sport.add(data)
def add_user_favourite_music(self, user_id):
data = dict()
obj = OhhoRandom.get_favourite_music()
data["user_id"] = user_id
data["music_id"] = obj.get("music_id", "")
data["name"] = obj.get("name", "")
data["description"] = obj.get("description", "")
data["album"] = obj.get("album", "")
data["publisher"] = obj.get("publisher", "")
data["singer"] = obj.get("singer", "")
data["icon"] = obj.get("icon", "")
data["url"] = obj.get("url", "")
self.user_favourite_music.add(data)
def add_user_favourite_movie(self, user_id):
data = dict()
obj = OhhoRandom.get_favourite_movie()
data["user_id"] = user_id
data["movie_id"] = obj.get("movie_id", "")
data["name"] = obj.get("name", "")
data["description"] = obj.get("description", "")
data["index"] = obj.get("index", "")
data["casts"] = obj.get("casts", "")
data["genres"] = obj.get("genres", "")
data["icon"] = obj.get("icon", "")
data["url"] = obj.get("url", "")
self.user_favourite_movie.add(data)
def add_user_favourite_book(self, user_id):
data = dict()
obj = OhhoRandom.get_favourite_book()
data["user_id"] = user_id
data["isbn"] = obj.get("isbn", "")
data["name"] = obj.get("name", "")
data["description"] = obj.get("description", "")
data["index"] = obj.get("index", "")
data["icon"] = obj.get("icon", "")
data["author"] = obj.get("author", "")
data["url"] = obj.get("url", "")
self.user_favourite_book.add(data)
def add_user_description(self, user_id):
data = dict()
data["user_id"] = user_id
data["type"] = OhhoRandom.get_type()
data["first"] = OhhoRandom.get_first()
data["second"] = OhhoRandom.get_second()
data["third"] = OhhoRandom.get_third()
self.user_description.add(data)
def add_user_and_device_relation(self, user_id):
data = dict()
data["user_id"] = user_id
data["device_id"] = OhhoRandom.get_device_id
self.user_and_device_relation.add(data)
def add_user_and_device_imei(self, user_id):
data = dict()
data["user_id"] = user_id
data["device_id"] = OhhoRandom.get_device_id
data["imei"] = OhhoRandom.get_imei()
self.user_and_device_imei.add(data)
def add_user_and_cellphone_relation(self, user_id):
data = dict()
data["user_id"] = user_id
data["cellphone_id"] = OhhoRandom.get_cellphone_id()
self.user_and_cellphone_relation.add(data)
def add_user_configuration(self, user_id):
data = dict()
data["user_id"] = user_id
data["is_match"] = 1
data["is_online"] = 1
self.user_configuration.add(data)
def add_user_match_condition(self, user_id):
data = dict()
data["user_id"] = user_id
data["match_condition_id"] = OhhoRandom.get_match_condition_id()
self.match_condition.add(data)
def add_user_extension(self, user_id):
data = dict()
data["user_id"] = user_id
data["sex"] = OhhoRandom.get_sex()
# data["identity_card"] = identity_card
# data["real_name"] = ""
data["nickname"] = "宝宝"
data["birthday"] = OhhoRandom.get_birthday()
# data["height"] = OhhoRandom.get_height()
# data["hometown"] = OhhoRandom.get_hometown()
# data["school"] = OhhoRandom.get_school()
# data["company"] = OhhoRandom.get_company()
# data["degree_id"] = OhhoRandom.get_degree_id()
# data["favourite_live_city"] = OhhoRandom.get_favourite_live_city()
# data["occupation_id"] = OhhoRandom.get_occupation_id()
# data["position_id"] = OhhoRandom.get_position_id()
self.user_extension.add(data)
def add_user_extension_dic(self, user_id):
data = dict()
data["user_id"] = user_id
data["sex"] = OhhoRandom.get_sex()
data["nickname"] = "宝宝"
data["birthday"] = OhhoRandom.get_birthday()
return data
def add_user_token_table_dic(self, user_id):
token = OHHORandom.get_nonce()
token_dict = dict()
token_dict["user_id"] = user_id
token_dict["token"] = token
# self.token.token.add(token_dict)
return token_dict
def add_user_token_table(self, user_id):
token = OHHORandom.get_nonce()
token_dict = dict()
token_dict["user_id"] = user_id
token_dict["token"] = token
self.token.token.add(token_dict)
def add_user_table(self, cellphone="00000000000"):
"""添加用户 参数 """
data = dict()
password = "******"
country_code_id = 159
username = OHHOUUID.get_uuid1_string()
self.password.set_password(password)
encryption_password = self.password.encryption()
data["username"] = username
data["password"] = encryption_password
data["cellphone"] = cellphone
data["country_code_id"] = country_code_id
# time1 = time.time()
self.user.add(data)
# print("user_id")
# print(self.user.model.id[0])
user = self.user.get_by_username(username)
# time2 = time.time()
# time3 = time2 - time1
# print("user insert")
# print(time3)
return user.id
def insert_table(self):
data = dict()
password = "******"
country_code_id = 159
username = OHHOUUID.get_uuid1_string()
self.password.set_password(password)
encryption_password = self.password.encryption()
data["username"] = username
data["password"] = encryption_password
data["cellphone"] = "13828838383"
data["country_code_id"] = country_code_id
time1 = time.time()
self.user.add(data)
time2 = time.time()
time3 = time2 - time1
print("user insert")
print(time3)
class LogicAddUser(object):
def __init__(self):
self.user = DBOHHOUser()
self.user_and_device_relation = DBOHHOUserAndDeviceRelation()
self.password = Password()
self.token = Token()
self.user_extension = DBOHHOUserAccuracyExtension()
self.interest = DBOHHOInterest()
self.map = DBOHHOMapInformation()
self.device = DBOHHODevice()
self.record_user_and_match_condition = DBOHHORecordUserAndMatchCondition()
self.match_condition = DBOHHORecordMatchCondition()
self.im_user = DBOHHOIMUser()
self.im_user_relation = DBOHHOIMUserRelation()
self.user_configuration = DBOHHOUserConfiguration()
self.imei = IMEI()
self.user_and_device_imei = DBOHHOUserAndDeviceIMEI()
self.friend = Friend()
self.apply = DBOHHORecordMatchApply()
self.country_code = DBOHHOCountryCode()
def add_user(self, number=10):
cellphone = 10000000000
# identity_card = 100000000000000000
user_query = self.user.get_query()
user_query = self.user.order_by_id_desc(user_query)
user_obj = Operation.first(user_query)
if user_obj:
if user_obj.cellphone:
cellphone = int(user_obj.cellphone)
i = 0
while i <= number:
i += 1
cellphone += 1
while self.user.get_by_cellphone(str(cellphone)):
cellphone = cellphone + 1
user_id = self.add_user_table(str(cellphone))
self.add_user_token_table(user_id)
self.add_user_extension(user_id)
print("for end")
print("end")
def add_func(self, number, cellphone):
def add_user_extension(self, user_id):
data = dict()
data["user_id"] = user_id
data["sex"] = OhhoRandom.get_sex()
# data["identity_card"] = identity_card
# data["real_name"] = ""
data["nickname"] = "宝宝"
data["birthday"] = OhhoRandom.get_birthday()
self.user_extension.add(data)
def add_user_token_table(self, user_id):
token = OHHORandom.get_nonce()
token_dict = dict()
token_dict["user_id"] = user_id
token_dict["token"] = token
self.token.token.add(token_dict)
def add_user_table(self, cellphone="00000000000"):
"""添加用户 参数 """
data = dict()
password = "******"
country_code_id = 159
username = OHHOUUID.get_uuid1_string()
self.password.set_password(password)
encryption_password = self.password.encryption()
data["username"] = username
data["password"] = encryption_password
data["cellphone"] = cellphone
data["country_code_id"] = country_code_id
self.user.add(data)
user = self.user.get_by_username(username)
return user.id
class Device(object):
def __init__(self, identity_id=None, mac_address=None):
self.device = DBOHHODevice(identity_id, mac_address)
self.relation = DBOHHOUserAndDeviceRelation()
self.imei = DBOHHOUserAndDeviceIMEI()
self.user = DBOHHOUser()
self.countryCode = DBOHHOCountryCode()
def set_identity(self, identity_id):
self.device.set_identity(identity_id)
def get_identity(self):
return self.device.identity_id
def set_mac_address(self, mac_address):
self.device.set_mac_address(mac_address)
def get_mac_address(self):
return self.device.mac_address
def get_by_identity(self):
return self.device.get_by_identity()
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 unbind_device(self, user_id):
device = self.device.get_by_identity()
if device and self.device.check_by_mac():
OHHOLog.print_log(device.id)
relation = self.relation.get_by_device(device.id)
if not relation:
return Result.result_success(RELATION_NOT_EXIST)
elif relation.user_id == int(user_id):
if not self.relation.is_valid(relation, True):
return Result.result_success(RELATION_EXIST)
else:
success = self.relation.delete(relation)
if success:
return Result.result_success()
else:
return Result.result_failed()
else:
return Result.result_failed(USED_BY_OTHER)
else:
return Result.result_failed(INVALID_DEVICE)
def is_device_valid(self):
device = self.device.get_by_identity()
# OHHOLog.print_log(self.device.get_identity())
# OHHOLog.print_log(device)
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):
result = Result.result_device_used_by_other()
user = DBOHHOUser()
user_instance = user.get_by_id(relation.user_id)
if user_instance:
result["cellphone_number"] = user_instance.cellphone
code = DBOHHOCountryCode.get_by_id(
user_instance.country_code_id)
if code:
result["country_code"] = code.country_code
else:
result["country_code"] = "+86"
return result
else:
return Result.result_success()
else:
return Result.result_failed(INVALID_DEVICE)
def get_relation_by_device(self):
device = self.device.get_by_identity()
if device:
relation = self.relation.get_by_device(device.id)
if self.relation.is_valid(relation, True):
return relation
else:
return None
return None
def get_primary_relation_by_user(self, user_id):
query = self.relation.get_query()
query = self.relation.get_valid(query)
relations = self.relation.get_by_user(query, user_id)
relations = self.relation.get_primary(relations)
return relations
def relation_update(self, instance, data_dict):
return self.relation.update(instance, data_dict)
def get_all_device(self):
return self.device.get_query()
def find_by_identity(self, query):
return self.device.find_by_identity(query)
def find_by_mac_address(self, query):
return self.device.find_by_mac_address(query)
def get_some_devices(self, query, offset, limit):
return self.device.get_some(query, offset, limit)
def get_by_id(self, device_id):
return self.device.get_by_id(device_id)
def update(self, instance, data):
return self.device.update(instance, data)
def add(self, data):
return self.device.add(data)
def delete(self, instance):
return self.device.delete(instance)
def is_empty(self, query):
count = query.count()
if count > 0:
return False
return True
def set_lost(self, user_id, identity_id):
self.device.set_identity(identity_id)
device = self.device.get_by_identity()
if device:
query = self.relation.get_valid_by_device(device.id)
if query:
query = self.relation.get_by_user(query, user_id)
query = self.relation.get_not_lost(query)
OHHOLog.print_log(query.count())
if query:
success = self.relation.set_lost(query)
if success:
return Result.result_success()
else:
return Result.result_failed()
else:
return Result.result_failed("this device is not yours!")
else:
return Result.result_failed("this device is invalid")
def cancel_lost(self, user_id, identity_id):
self.device.set_identity(identity_id)
device = self.device.get_by_identity()
if device:
query = self.relation.get_valid_by_device(device.id)
if query:
query = self.relation.get_by_user(query, user_id)
OHHOLog.print_log(query.count())
# query = self.relation.get_valid(query)
# OHHOLog.print_log(query.count())
query = self.relation.get_lost(query)
OHHOLog.print_log(query.count())
if query:
success = self.relation.cancel_lost(query)
if success:
return Result.result_success()
else:
return Result.result_failed()
else:
return Result.result_failed("this device is not yours!")
else:
return Result.result_failed("this device is invalid")
def get_valid_relation_by_user(self, user_id):
query = self.relation.get_query()
query = self.relation.get_valid(query)
query = self.relation.get_by_user(query, user_id)
return query
def get_device_information(self, device_id):
device = self.device.get_by_id(device_id)
result = self.device.get_information(device)
imei = self.get_imei_by_deivce(device_id)
if imei:
result["imei"] = imei.imei
else:
result["imei"] = ""
return result
def get_imei_by_deivce(self, device_id):
query = self.imei.get_query()
instance = self.imei.get_by_device_id(query, device_id)
# query = self.imei.order_by_id_desc(query)
# instance = self.imei.first(query)
return instance
def __init__(self):
self.user = DBOHHOUser()
self.password = Password()
def __init__(self):
self.country_code = DBOHHOCountryCode()
self.user = DBOHHOUser()
def __init__(self, identity_id=None, mac_address=None):
self.device = DBOHHODevice(identity_id, mac_address)
self.relation = DBOHHOUserAndDeviceRelation()
self.imei = DBOHHOUserAndDeviceIMEI()
self.user = DBOHHOUser()
self.countryCode = DBOHHOCountryCode()
def __init__(self):
self.relation = DBOHHORecordUserAndMatchCondition()
self.condition = DBOHHORecordMatchCondition()
self.user = DBOHHOUser()
