def add_farm(self, **kw):
'''
'''
# import ipdb;ipdb.set_trace()
farm = model.Farm()
# check registed user
user_name = kw.get('user_name', '')
find_result = DBSession.query(
model.Farm).filter_by(user_name=user_name).first()
if find_result:
return USER_EXIST
[
setattr(farm, key, kw[key]) for key in FARM_KEYS
if key in kw and kw[key] != ''
]
try:
DBSession.add(farm)
transaction.commit()
return SUCCESS
except Exception, e:
transaction.abort()
print 'error of add_farm: {}'.format(e)
return UNKNOW_ERROR
def farm_list(self, ):
# import ipdb;ipdb.set_trace()
result = {}
result_list = []
find_result = DBSession.query(model.Farm).all()
if not find_result:
return FIND_NOTHING
def _trans(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in FARM_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
for res in find_result:
trans_result = {}
if res:
trans_one = _trans(res)
trans_result.update(trans_one)
result_list.append(trans_result)
result['result_list'] = result_list
return result
def add_user_animals(self, **kw):
'''
'''
# import ipdb;ipdb.set_trace()
animals = model.UserAnimals()
[setattr(animals, key, int(kw[key])) for key in USER_ANIMALS_KEYS if key in kw]
try:
DBSession.add(animals)
transaction.commit()
return SUCCESS
except Exception, e:
transaction.abort()
print 'error of add_farm: {}'.format(e)
return UNKNOW_ERROR
def farm_animals(self, farm_id=''):
# import ipdb;ipdb.set_trace()
result = {}
result_list = []
find_result = DBSession.query(model.FarmAnimals)
if farm_id:
find_result = find_result.filter_by(farm_id=farm_id)
read_all = find_result.all()
if not read_all:
return FIND_NOTHING
def _trans(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in FARM_ANIMALS_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
for res in read_all:
trans_result = {}
if res:
trans_one = _trans(res)
trans_result.update(trans_one)
result_list.append(trans_result)
result['result_list'] = result_list
return result
def farm_list(self, ):
# import ipdb;ipdb.set_trace()
result = {}
result_list = []
find_result = DBSession.query(model.Farm).all()
if not find_result:
return FIND_NOTHING
def _trans(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in FARM_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
for res in find_result:
trans_result = {}
if res:
trans_one = _trans(res)
trans_result.update(trans_one)
result_list.append(trans_result)
result['result_list'] = result_list
return result
def farm_animals(self, farm_id=''):
# import ipdb;ipdb.set_trace()
result = {}
result_list = []
find_result = DBSession.query(model.FarmAnimals)
if farm_id:
find_result = find_result.filter_by(farm_id=farm_id)
read_all = find_result.all()
if not read_all:
return FIND_NOTHING
def _trans(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in FARM_ANIMALS_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
for res in read_all:
trans_result = {}
if res:
trans_one = _trans(res)
trans_result.update(trans_one)
result_list.append(trans_result)
result['result_list'] = result_list
return result
def add_user_animals(self, **kw):
'''
'''
# import ipdb;ipdb.set_trace()
animals = model.UserAnimals()
[
setattr(animals, key, int(kw[key])) for key in USER_ANIMALS_KEYS
if key in kw
]
try:
DBSession.add(animals)
transaction.commit()
return SUCCESS
except Exception, e:
transaction.abort()
print 'error of add_farm: {}'.format(e)
return UNKNOW_ERROR
def user_animals(self, user_id):
# import ipdb;ipdb.set_trace()
result = {}
result_list = []
find_result = DBSession.query(
model.UserAnimals, model.FarmAnimals).join(
model.User,
model.User.user_id == model.UserAnimals.user_id).join(
model.FarmAnimals,
model.FarmAnimals.animal_id == model.UserAnimals.animal_id)
if user_id:
find_result = find_result.filter(
model.UserAnimals.user_id == user_id)
read_all = find_result.all()
if not read_all:
return FIND_NOTHING
def _trans_user_animals(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in USER_ANIMALS_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
def _trans_animals(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in FARM_ANIMALS_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
for res in read_all:
trans_result = {}
if res[0]:
trans_one = _trans_user_animals(res[0])
trans_result.update(trans_one)
if res[1]:
trans_two = _trans_animals(res[1])
trans_result.update(trans_two)
result_list.append(trans_result)
result['result_list'] = result_list
return result
def add_farm(self, **kw):
'''
'''
# import ipdb;ipdb.set_trace()
farm = model.Farm()
# check registed user
user_name = kw.get('user_name', '')
find_result = DBSession.query(model.Farm).filter_by(user_name=user_name).first()
if find_result:
return USER_EXIST
[setattr(farm, key, kw[key]) for key in FARM_KEYS if key in kw and kw[key] != '']
try:
DBSession.add(farm)
transaction.commit()
return SUCCESS
except Exception, e:
transaction.abort()
print 'error of add_farm: {}'.format(e)
return UNKNOW_ERROR
def login(self, user_name, password):
'''
'''
# import ipdb;ipdb.set_trace()
# check registed user
find_result = DBSession.query(model.User).filter_by(
user_name=user_name).filter_by(password=password).first()
if not find_result:
return USER_PASSWORD_ERROR
return LOGIN_SUCCESS
def login(self, user_name, password):
'''
'''
# import ipdb;ipdb.set_trace()
# check registed user
find_result = DBSession.query(model.User).filter_by(
user_name=user_name).filter_by(password=password).first()
if not find_result:
return USER_PASSWORD_ERROR
return LOGIN_SUCCESS
def registe(self, user_name, password, email_address=''):
'''
'''
# import ipdb;ipdb.set_trace()
user = model.User()
user.user_name = user_name
user.password = password
user.email_address = email_address
# check registed user
find_result = DBSession.query(model.User).filter_by(user_name=user_name).first()
if find_result:
return USER_EXIST
try:
DBSession.add(user)
transaction.commit()
return SUCCESS
except Exception, e:
transaction.abort()
print 'error of registe: {}'.format(e)
raise UNKNOW_ERROR
def user_animals(self, user_id):
# import ipdb;ipdb.set_trace()
result = {}
result_list = []
find_result = DBSession.query(model.UserAnimals, model.FarmAnimals).join(
model.User, model.User.user_id==model.UserAnimals.user_id).join(
model.FarmAnimals, model.FarmAnimals.animal_id==
model.UserAnimals.animal_id)
if user_id:
find_result = find_result.filter(model.UserAnimals.user_id==user_id)
read_all = find_result.all()
if not read_all:
return FIND_NOTHING
def _trans_user_animals(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in USER_ANIMALS_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
def _trans_animals(target):
'''
translate target from object to dict
'''
result_list_dict = {}
for key in FARM_ANIMALS_KEYS:
result_list_dict.update({key: getattr(target, key)})
if key in ('createtime', 'updatetime'):
result_list_dict[key] = str(getattr(target, key))
return result_list_dict
for res in read_all:
trans_result = {}
if res[0]:
trans_one = _trans_user_animals(res[0])
trans_result.update(trans_one)
if res[1]:
trans_two = _trans_animals(res[1])
trans_result.update(trans_two)
result_list.append(trans_result)
result['result_list'] = result_list
return result
def registe(self, user_name, password, email_address=''):
'''
'''
# import ipdb;ipdb.set_trace()
user = model.User()
user.user_name = user_name
user.password = password
user.email_address = email_address
# check registed user
find_result = DBSession.query(
model.User).filter_by(user_name=user_name).first()
if find_result:
return USER_EXIST
try:
DBSession.add(user)
transaction.commit()
return SUCCESS
except Exception, e:
transaction.abort()
print 'error of registe: {}'.format(e)
raise UNKNOW_ERROR
def setUp(self):
"""Setup test fixture for each model test method."""
try:
new_attrs = {}
new_attrs.update(self.attrs)
new_attrs.update(self.do_get_dependencies())
self.obj = self.klass(**new_attrs)
DBSession.add(self.obj)
DBSession.flush()
return self.obj
except:
DBSession.rollback()
raise
def test_query_obj(self):
"""Model objects can be queried"""
obj = DBSession.query(self.klass).one()
for key, value in self.attrs.items():
eq_(getattr(obj, key), value)
def tearDown(self):
"""Tear down test fixture for each model test method."""
DBSession.rollback()
