def get_list(package):
"""get theme list
"""
user = package.get('user')
params = package.get('params')
target_schoolid = int(params.get(ParamType.SchoolId))
page = params.get(ParamType.Page)
if page is None:
page = 1
page = int(page)
user_id = user.get('id')
school_id = PermissionHelper.get_user_school(user_id)
public_permission = user.get('permission')
if target_schoolid != 0:
if target_schoolid != school_id and public_permission < 8:
return Response.error_response('Access Denied')
theme_list = SubjectHelper.get_subjects(target_schoolid, 0, page)
for theme in theme_list:
theme.update({
'count':
ProgramHelper.get_subject_programs_count(theme.get('id'))
})
ret = {
'tot_count': SubjectHelper.get_subject_count(target_schoolid, 0),
'now_count': len(theme_list),
'theme_list': theme_list
}
return Response.success_response(ret)
def get_school_list(package):
""" Processing the request of getting school list
"""
params = package.get('params')
page = params.get(ParamType.Page)
search_text = params.get(ParamType.SearchText)
if page is None:
page = 1
page = int(page)
if int(page) < 1:
return Response.error_response('Invalid Page Number')
school_list = SchoolHelper.get_school_list(page, search_text)
for school in school_list:
buf_name = school.get('schoolname')
del school['schoolname']
school.update({'name': buf_name})
tot_count = SchoolHelper.get_school_count(search_text)
return Response.success_response({
'tot_count': tot_count,
'now_count': len(school_list),
'school_list': school_list
})
def refunds(request):
if request.method == 'GET':
return render_to_response(
'sale/refunds.html',
RequestContext(request, {
'sale_active': 1,
'customs': get_customs(),
'stocks': get_stocks()
}))
else:
data = request.POST.get('data')
print data
if not data:
return failed_response('参数错误')
else:
all = json.loads(data)
r = Refunds()
r.custom = Custom.objects.get(id=all['custom'])
r.stock = Stock.objects.get(id=all['stock'])
r.save()
for item in all['detail']:
pro = SalesDetail()
pro.product = Product.objects.get(id=item['pid'])
pro.num = int(item['pnum'])
pro.price = float(item['pprice'])
pro.scale = float(item['pscale'])
pro.save()
r.detail.add(pro)
r.save()
return success_response('添加成功')
def get_list(package):
""" get message list
"""
user = package.get('user')
params = package.get('params')
friendname = params.get(ParamType.Username)
friend = UserHelper.get_user_by_username(friendname)
if friend is None:
return Response.error_response("Error Username")
page = params.get(ParamType.Page)
if page is None:
page = 1
page = int(page)
chat = ChatHelper.get_chat(user['id'], friend['id'])
if chat:
ChatHelper.do_read(chat, user['id'])
count = MessageHelper.get_messages_count(chat)
messages = MessageHelper.get_messages(chat, page)
data = {
'tot_count': count,
'now_count': len(messages),
'msg_list': messages
}
return Response.success_response(data)
return Response.checked_response('NoChat')
def get_recipe_users():
recipe_users = {}
query = datastore_client.query(kind=DS_exp_racks_KIND)
query_results = list(query.fetch())
for rack in query_results:
rack_recipe_uuid = rack.get('recipe_uuid')
if rack_recipe_uuid is None:
continue
exp_name = ''
exp_uuid = rack.get('experiment_uuid')
if exp_uuid is not None:
exp = get_one(DS_experiments_KIND, 'experiment_uuid', exp_uuid)
if exp is not None:
exp_name = exp.get('experiment_name')
recipe_users[rack_recipe_uuid] = {
'rack_uuid': rack.get('rack_uuid', ''),
'rack_name': rack.get('rack_id', ''),
'experiment_uuid': exp_uuid,
'experiment_name': exp_name,
}
return success_response(message='Success', recipe_users=recipe_users)
def new(request):
if request.method == 'GET':
return render_to_response(
'purchase/new.html',
RequestContext(
request, {
'purchase_active': 1,
'providers': get_providers(),
'stocks': get_stocks()
}))
else:
data = request.POST.get('data')
if not data:
return failed_response('参数错误')
else:
all = json.loads(data)
p = Purchase()
p.provider = Provider.objects.get(id=all['supporter'])
p.stock = Stock.objects.get(id=all['stock'])
p.save()
for item in all['detail']:
pro = PurchaseDetail()
pro.product = Product.objects.get(id=item['pid'])
pro.num = int(item['pnum'])
pro.price = float(item['pprice'])
pro.save()
p.detail.add(pro)
p.save()
return success_response('添加成功')
def allocate(request):
if request.method == 'GET':
stocks = Stock.objects.all()
return render_to_response(
'stock/allocate.html',
RequestContext(request, {
'stock_active': 1,
'stocks': stocks
}))
else:
data = request.POST.get('data')
if not data:
return failed_response('参数错误')
else:
all = json.loads(data)
al = Allocate()
al.source_stock = Stock.objects.get(id=all['source_stock'])
al.dest_stock = Stock.objects.get(id=all['dest_stock'])
al.save()
for item in all['detail']:
pro = AllocateNum()
pro.product = Product.objects.get(id=item['pid'])
pro.num = int(item['pnum'])
pro.save()
al.nums.add(pro)
al.save()
return success_response('调拨成功')
def forget_password(package):
"""provess the request of forgetting the password
"""
session = package.get('session')
params = package.get('params')
username = params.get(ParamType.Username)
password = params.get(ParamType.Password)
captcha = params.get(ParamType.CAPTCHA)
user = UserHelper.get_user_by_username(username)
if user is None:
return Response.error_response('No User')
phone = user['phone']
code = VerifyHelper.get_latest_code(session, phone)
if code is None:
return Response.error_response('GUXYNB')
if code['code'] != captcha:
return Response.error_response('CAPTCHA Error')
info = {'password': password}
UserHelper.modify_user(user['id'], info)
return Response.success_response(None)
def get_provider(request):
if not request.user.is_active:
return need_login()
result = []
providers = Provider.objects.all()
for item in providers:
result.append({'id': item.id, 'name': item.name})
return success_response(result)
def get_recipe():
received_form_response = json.loads(request.data.decode('utf-8'))
uuid = received_form_response.get('recipe_uuid')
if uuid is None:
return error_response(message='Failed', recipe={})
recipe_entity = get_by_key(DS_exp_recipes_KIND, uuid)
recipe = recipe_entity.get('recipe')
return success_response(message='Success', recipe=recipe)
def get_products(request):
if not request.user.is_active:
return need_login()
products = []
for p in Product.objects.all().order_by('name'):
products.append({
'id': p.id,
'name': p.name,
'price': p.price_retail,
'cost': p.price_cost
})
return success_response(products)
def delete_recipe():
received_form_response = json.loads(request.data.decode('utf-8'))
uuid = received_form_response.get('recipe_uuid')
if uuid is None:
return error_response(message='Failed')
recipe_entity = get_by_key(DS_exp_recipes_KIND, uuid)
if recipe_entity is None:
return error_response(message='Failed, recipe not found ' + uuid)
datastore_client.delete(key=recipe_entity.key);
return success_response(message='Success')
def download(package):
"""process the request of downloading
"""
user = package.get('user')
user_id = user.get('id')
params = package.get('params')
program_id = (int)(params.get(ParamType.ProgramId))
program = ProgramHelper.get_program(program_id)
if program is None:
return Response.error_response('No Program')
prog_schoolid = program.get('schoolid')
prog_status = program.get('status')
if prog_status not in [0, 1, 2, 3]:
return Response.error_response('Status not Valid')
school_id = PermissionHelper.get_user_school(user_id)
permission = PermissionHelper.get_permission(user_id, school_id)
if permission > 4:
if program.get('status') == 0:
ProgramHelper.judging(program_id)
info = {'content': program['code'], 'readme': program['doc']}
return Response.success_response({'code': info})
if prog_schoolid == 0:
if user.get('permission') < 2:
return Response.error_response('Access Denied')
if school_id != prog_schoolid or permission < 2:
return Response.error_response('Access Denied')
if program.get('status') == 0:
ProgramHelper.judging(program_id)
info = {'content': program['code'], 'readme': program['doc']}
return Response.success_response({'code': info})
def check_session(package):
"""process the request of check session
"""
user = package.get('user')
user = UserHelper.user_filter(user)
if user is None:
return Response.success_response({'user': None})
user_id = user.get('id')
permission_public = user.get('permission')
del user['permission']
school_id = PermissionHelper.get_user_school(user_id)
if school_id == 0:
school_name = 'public area'
if permission_public > 4:
permission_private = permission_public
else:
permission_private = -1
else:
school = SchoolHelper.get_school(school_id)
if school is None:
school_name = '-'
else:
school_name = school.get('schoolname')
permission_private = PermissionHelper.get_permission(
user_id, school_id)
school = {
'id': school_id,
'name': school_name,
}
ret_user = {
'username': user.get('username'),
'school': school,
'permission_private': permission_private,
'permission_public': permission_public
}
return Response.success_response({'user': ret_user})
def get_apply_list(package):
# pylint: disable-msg=too-many-return-statements
""" Processing the request of getting apply list
"""
user = package.get('user')
if user is None:
return Response.error_response('No User')
user_id = user.get('id')
# school_id = PermissionHelper.get_user_school(user_id)
params = package.get('params')
list_type = params.get(ParamType.ApplyListType)
page_num = params.get(ParamType.Page)
target_schoolid = int(params.get(ParamType.SchoolId))
if target_schoolid == 0:
return Response.error_response('Invalid SchoolId')
permission = PermissionHelper.get_permission(user_id, target_schoolid)
if not PermissionManager.check_permission(permission,
ActionType.GetApplyList):
return Response.error_response('Access Denied')
if list_type is None:
list_type = 0
list_type = int(list_type)
if page_num is None:
page_num = 1
page_num = int(page_num)
if list_type not in [0, 1, 2]:
return Response.error_response('Invalid list type')
if page_num < 1:
return Response.error_response('Invalid page number')
apply_list = SchoolApplyHelper.get_applies(target_schoolid, list_type,
page_num)
school = SchoolHelper.get_school(target_schoolid)
if school is None:
return Response.error_response('No School')
ret = {
'tot_count':
SchoolApplyHelper.get_applies_count(target_schoolid, list_type),
'now_count':
len(apply_list),
'apply_list':
apply_list
}
return Response.success_response(ret)
def get_list(package):
""" get chat list
"""
user = package.get('user')
chats = ChatsHelper.get_chats(user['id'])
blocks = ChatBlockHelper.get_block_list(user['id'])
chats = [chat for chat in chats if chat['user']['username'] not in blocks]
msg_count = 0
for chat in chats:
msg_count += chat['unread']
return Response.success_response({
'chat_count': len(chats),
'msg_count': msg_count,
'chat_list': chats
})
def test_0003(self):
"""
Test for `response.py`
"""
response = Response.invalid_request()
self.assertEqual(response.status_code, 200)
response = Response.success_response(None)
self.assertEqual(response.status_code, 200)
response = Response.checked_response('')
self.assertEqual(response.status_code, 200)
response = Response.error_response('')
self.assertEqual(response.status_code, 200)
response = Response.failed_response('')
self.assertEqual(response.status_code, 200)
response = Response.make_response(None, None, None)
self.assertEqual(response.status_code, 200)
def done(package):
"""method for merge chunks
"""
user = package.get('user')
params = package.get('params')
key = params.get(ParamType.FileKey)
filepath = os.path.join('/mnt/media', 'chunks')
filepath = os.path.join(filepath, key)
with open(os.path.join(filepath, 'config'), 'rb') as file:
(school_id, category_id, filename, video_title,
description) = pickle.load(file)
number = len(glob.glob(os.path.join(filepath, 'chunk') + '*'))
chunks = ['chunk' + str(i) for i in range(number)]
_, pwd, filesize = File.store_file(filename, chunks, 'video', filepath)
VideoHelper.add_video(user['id'], video_title, description, filename, pwd,
school_id, category_id, filesize)
return Response.success_response(None)
def start(package):
"""method for start uploading a big file
"""
params = package.get('params')
school_id = params.get(ParamType.SchoolId)
category_id = params.get(ParamType.CategoryId)
filename = params.get(ParamType.Filename)
video_title = params.get(ParamType.VideoTitle)
description = params.get(ParamType.Description)
key = params.get(ParamType.FileKey)
filepath = os.path.join('/mnt/media', 'chunks')
filepath = os.path.join(filepath, key)
os.makedirs(filepath)
with open(os.path.join(filepath, 'config'), 'wb') as file:
pickle.dump(
(school_id, category_id, filename, video_title, description), file)
return Response.success_response({'key': key})
def change_password(package):
"""process the request of changing password
"""
session = package.get('session')
params = package.get('params')
oldpassword = params.get(ParamType.OldPassword)
newpassword = params.get(ParamType.NewPassword)
user = UserHelper.get_user_by_session(session)
if user is None:
return Response.error_response('No User')
if not UserHelper.signin_check_password(user, oldpassword):
return Response.error_response('Old Password Error')
info = {'password': newpassword}
user_id = user.get('id')
UserHelper.modify_user(user_id, info)
return Response.success_response(None)
def get_info(package):
"""process the request of getting user's info
"""
params = package.get('params')
username = params.get(ParamType.UsernameWithDefault)
if username is None:
user = package.get('user')
else:
user = UserHelper.get_user_by_username(username)
if user is None:
return Response.error_response("No User")
user = UserHelper.user_filter(user)
permission_public = user.get('permission')
user_id = user.get('id')
school_id = PermissionHelper.get_user_school(user_id)
if school_id == 0:
if permission_public >= 8:
permission_private = permission_public
else:
permission_private = -1
schoolname = 'public area'
else:
permission_private = PermissionHelper.get_permission(
user_id, school_id)
school = SchoolHelper.get_school(school_id)
if school is None:
schoolname = '-'
else:
schoolname = school.get('schoolname')
download = ProgramHelper.count_user_downloadlog(user_id)
del user['permission']
user.update({
'school_name': schoolname,
'permission_public': permission_public,
'permission_private': permission_private,
'download': download
})
return Response.success_response({'user': user})
def basic_view(request):
"""basic view
"""
ip_address = get_ip(request)
if func is not start_session:
package = {
'request' : request,
'ip' : ip_address,
'method' : method,
'paramlist' : paramlist,
'checklist' : checklist,
'action' : action,
'file' : request.FILES.get('file', None)
}
for check in checks:
package, error = check(package)
if error is not None:
return error
return func(package)
token = SessionHelper.add_session(ip_address)
return Response.success_response(data={'token' : token})
def info(package):
"""method for download video
"""
params = package.get('params')
school_id = params.get(ParamType.SchoolId)
category_id = params.get(ParamType.CategoryId)
page = params.get(ParamType.Page)
if page is None:
page = '1'
page = int(page)
if page <= 0:
page = 1
selector = VideoHelper.get_video_filter(school_id, category_id)
count, videos = get_list(Video,
selector,
VideoHelper.video_to_dict,
page,
hide_list=['filepath'])
return Response.success_response({
'tot_count': count,
'now_count': len(videos),
'video_list': videos
})
def get_all_recipes():
query = datastore_client.query(kind=DS_exp_recipes_KIND)
query_results = list(query.fetch())
recipes = []
for recipe in query_results:
# place holders until the second (slower) API gets this data
exp_uuid = ''
exp_name = ''
rack_uuid = ''
rack_name = ''
recipes.append({
'uuid': recipe.key.id_or_name,
'name': recipe.get('name', ''),
'authors': recipe.get('authors', ''),
'modified': recipe.get('modified', ''),
'experiment_name': exp_name,
'experiment_uuid': exp_uuid,
'rack_name': rack_name,
'rack_uuid': rack_uuid,
})
return success_response(message='Success', recipes=recipes)
def download(package):
"""user download program
"""
user = package.get('user')
params = package.get('params')
prog_id = (int)(params.get(ParamType.ProgramId))
user_id = user.get('id')
program = ProgramHelper.get_program(prog_id)
if program is None:
return Response.error_response('No Program')
if not DownloadLogHelper.check_download(user_id, prog_id):
DownloadLogHelper.add_downloadlog(user_id, prog_id)
log_count = DownloadLogHelper.count_downloadlog(prog_id)
ProgramHelper.set_downloads(prog_id, log_count)
info = {'content': program.get('code'), 'readme': program.get('doc')}
# program = ProgramHelper.get_program(prog_id)
# return Response.checked_response(str(program.get('downloads')))
return Response.success_response({'code': info})
def submit_recipe():
received_form_response = json.loads(request.data.decode('utf-8'))
recipe_str = received_form_response.get('recipe',{})
if recipe_str is None:
return error_response(message='No recipe received.')
recipe = None # JSON recipe
error_message = None
authors = received_form_response.get('authors','')
try:
# make a recipe dict
recipe = json.loads(recipe_str)
if recipe.get('uuid') is None:
recipe['uuid'] = str(uuid.uuid4())
# always update the timestamp
recipe['creation_timestamp_utc'] = \
datetime.utcnow().strftime('%FT%XZ')
# get schema
rf = recipe.get('format')
recipe_format = 'openag-phased-environment-v1'
if rf is not None:
recipe_format = rf
schema_entity = get_by_key(DS_recipe_schema_KIND, recipe_format)
schema = json.loads(schema_entity.get('schema'))
# Validate recipe against schema
jsonschema.validate(recipe, schema)
except json.decoder.JSONDecodeError as e:
error_message = "Invalid recipe json encoding: {}".format(e)
except jsonschema.exceptions.ValidationError as e:
error_message = "Invalid recipe json schema: {}".format(e)
print(e)
except KeyError as e:
error_message = "Invalid recipe json schema: `{}` is requred".format(e)
except Exception as e:
error_message = "Unhandled exception: {}".format(type(e))
if error_message is not None:
return error_response(message=error_message)
# Insert the recipe into the datastore DS_exp_recipes_KIND:
# 1. Make a key. ExperimentRecipes are keyed by the recipe UUID.
key = datastore_client.key(DS_exp_recipes_KIND, recipe.get('uuid'))
# 2. Create a recipe Entity.
# Indexes every column except the recipe (because JSON is large).
recipe_entity = datastore.Entity(key, exclude_from_indexes=['recipe'])
# 3. Update the entity and save it to the datastore.
recipe_str = json.dumps(recipe)
recipe_entity.update({
'name': recipe.get('name', ''),
'authors': authors,
'modified': recipe.get('creation_timestamp_utc'),
'recipe': recipe_str
})
datastore_client.put(recipe_entity)
if recipe_entity.key:
return success_response(message='Success',
modified=recipe.get('creation_timestamp_utc'),
uuid=recipe.get('uuid'))
else:
return error_response(message='Failed to save to datastore.')
def get_program_list(package):
#pylint: disable-msg=too-many-locals
#pylint: disable-msg=too-many-return-statements
#pylint: disable-msg=too-many-branches
#pylint: disable-msg=too-many-statements
"""All list
"""
params = package.get('params')
user = package.get('user')
mine = params.get(ParamType.Mine)
schoolid = params.get(ParamType.SchoolIdWithDefault)
status_up = params.get(ParamType.StatusUp)
status_low = params.get(ParamType.StatusDown)
subjectid = params.get(ParamType.ThemeIdWithDefault)
listtype = params.get(ParamType.Listype)
page = params.get(ParamType.Page)
if schoolid is not None:
schoolid = int(schoolid)
if subjectid is not None:
subjectid = int(subjectid)
if status_up is not None:
status_up = int(status_up)
else:
status_up = 6
if status_low is not None:
status_low = int(status_low)
else:
status_low = -3
if listtype is not None:
listtype = int(listtype)
else:
listtype = 0
if page is None:
page = 1
else:
page = int(page)
if status_up not in range(-4, 7):
return Response.error_response('Illegel Status Upper Limit')
if status_low not in range(-4, 7):
return Response.error_response('Illegal Status Lower Limit')
if mine == 'true':
user_id = user.get('id')
progs_list = ProgramHelper.get_user_programs(user_id, page, listtype)
if len(progs_list) == 0:
data = {
'tot_count' : 0,
'now_count' : 0,
'code_list' : []
}
return Response.success_response(data)
username = user.get('username')
codelist = []
for prog in progs_list:
prog_id = prog.get('id')
liked = ProgramLikeHelper.check_like(user_id, prog_id)
downloaded = DownloadLogHelper.check_download(user_id, prog_id)
schoolid = PermissionHelper.get_user_school(user_id)
schoolname = SchoolHelper.get_school_name(schoolid)
info = ProgramHelper.prog_filter(
prog, username, downloaded, liked, schoolname
)
codelist.append(info)
data = {
'tot_count' : ProgramHelper.get_user_programs_count(user_id),
'now_count' : len(progs_list),
'code_list' : codelist
}
return Response.success_response(data)
if schoolid is None:
return Response.error_response('Invalid School')
user_id = user.get('id')
progs_list = ProgramHelper.get_programs_school(
status_up, status_low, schoolid, subjectid, page, listtype
)
if len(progs_list) == 0:
data = {
'tot_count' : 0,
'now_count' : 0,
'code_list' : []
}
return Response.success_response(data)
username = user.get('username')
codelist = []
for prog in progs_list:
prog_id = prog.get('id')
liked = ProgramLikeHelper.check_like(user_id, prog_id)
downloaded = DownloadLogHelper.check_download(user_id, prog_id)
schoolid = PermissionHelper.get_user_school(user_id)
schoolname = SchoolHelper.get_school_name(schoolid)
info = ProgramHelper.prog_filter(
prog, username, downloaded, liked, schoolname
)
codelist.append(info)
data = {
'tot_count' : ProgramHelper.get_programs_school_count(
status_up, status_low, schoolid, subjectid
),
'now_count' : len(progs_list),
'code_list' : codelist
}
return Response.success_response(data)
def getlist(package):
#pylint: disable-msg=too-many-locals
"""process the request of getting user's info
"""
params = package.get('params')
show_invalid = params.get(ParamType.ShowInvalid) == 'true'
manager_first = params.get(ParamType.ManagerFirst) == 'true'
school_id = int(params.get(ParamType.SchoolId))
page = params.get(ParamType.Page)
if page is None:
page = 1
page = int(page)
if school_id == 0:
user_list = UserHelper.user_list(page, show_invalid, manager_first)
ret_list = []
if len(user_list) == 0:
data = {
'tot_count': UserHelper.user_count(show_invalid),
'now_count': 0,
'user_list': []
}
return Response.success_response(data)
for user in user_list:
download = ProgramHelper.count_user_downloadlog(user.get('id'))
ret_list.append({
'username': user.get('username'),
'motto': user.get('motto'),
'permission': user.get('permission'),
'download': download
})
data = {
'tot_count': UserHelper.user_count(show_invalid),
'now_count': len(ret_list),
'user_list': ret_list
}
return Response.success_response(data)
buf_userlist = UserHelper.get_all(show_invalid, manager_first)
userlist = []
for user in buf_userlist:
user_id = user.get('id')
school = PermissionHelper.get_user_school(user_id)
if school_id != school:
continue
download = ProgramHelper.count_user_downloadlog(user.get('id'))
permission_private = PermissionHelper.get_permission(user_id, school)
print('permission private', permission_private)
userlist.append({
'username': user['username'],
'motto': user['motto'],
'permission': permission_private,
'download': download
})
if len(userlist) < (page - 1) * 20:
data = {'tot_count': len(userlist), 'now_count': 0, 'user_list': []}
return Response.success_response(data)
pagelist = userlist[(page - 1) * 20:page * 20]
data = {
'tot_count': len(userlist),
'now_count': len(pagelist),
'user_list': userlist,
}
return Response.success_response(data)
def login():
received_form_response = json.loads(request.data.decode('utf-8'))
return success_response(
message='Success',
is_admin=True,
)
def get_list(package):
""" get block list
"""
user = package.get('user')
blocks = ChatBlockHelper.get_block_list(user['id'])
return Response.success_response({'list' : blocks})
