def recognise(request):
global nn
try:
if 'nn' in request.session:
# nn = NetworkReader.readFrom('data/' + request.session['nn'] + '.nn')
img = request.POST['img_data']
img, img_data = _transform_img(img)
print img_data
print img_data.ravel().tolist()
# activation = nn.activate(_img_data_to_vec(img_data))
activation = nn.call(_img_data_to_vec(img_data))
print activation
return JsonResponse({
'status': 'ok',
'activation': activation.tolist()
})
else:
resp = JsonResponse({
'status': 'error',
'msg': 'Run train first'
})
resp.status_code = 400
return resp
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e
})
resp.status_code = 500
return resp
def retrain(request):
dataset_name = request.POST['dataset_name']
try:
X = []
y = []
with open('data/' + dataset_name + '.csv', 'r') as f:
csv_f = csv.reader(f, delimiter=',')
for l in csv_f:
X.append([float(ll) for ll in l[:-1]])
y.append(_number_to_output_vector(int(float(l[-1]))))
X = np.asarray(X)
y = np.asarray(y)
_train2(X, y, dataset_name, 1500)
request.session['nn'] = dataset_name
for im, l in zip(X, y):
print l, nn.call(im)
return JsonResponse({
'status': 'ok'
})
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e.message
})
resp.status_code = 500
return resp
def train_mnist(request):
try:
data = scipy.io.loadmat("mnist/ex4data1.mat")
X = data["X"][:15000]
y = data["y"][:15000]
y[y == 10] = 0
y = [_number_to_output_vector(yy) for yy in y]
print len(X), len(y)
f = uuid.uuid4().hex
_train(X, y, f, 50)
request.session['nn'] = f
return JsonResponse({
'status': 'ok'
})
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e.message
})
resp.status_code = 500
return resp
def get(self, request):
response_data = {
attr[:-4]: os.environ.get(getattr(self, attr))
for attr in dir(self)
if attr.endswith('_key') and getattr(self, attr)
}
response = JsonResponse(response_data)
if not response_data['build_date'] or not response_data['commit_id']:
response.status_code = 501
return response
def get(self, request):
from moj_irat.healthchecks import registry
response_data = {}
for response in registry.run_healthchecks():
response = response.get_dict()
check_name = response.pop('name')
response_data[check_name] = response
all_passed = all(response['status'] for response in response_data.values())
response_data['*'] = dict(status=all_passed)
response = JsonResponse(response_data)
if not all_passed:
response.status_code = 500
return response
def train(request):
images = json.loads(request.POST['dataset'])
random.shuffle(images)
filename = str(int(time.time())) + "_" + str(uuid.uuid4().hex)
try:
images_data = []
with open('data/' + filename + '.csv', 'w') as f:
a = csv.writer(f, delimiter=',')
for img, label in images:
img_data = _img_data_to_vec(_transform_img(img)[1])
img_data = np.append(img_data, [label])
images_data.append(img_data)
a.writerows(images_data)
X = []
y = []
for d in images_data:
X.append(d[:-1])
y.append(_number_to_output_vector(int(d[-1])))
_train2(X, y, filename, 10000)
request.session['nn'] = filename
for im in images_data:
print im[-1], nn.call(im[:-1])
return JsonResponse({
'status': 'ok'
})
except Exception as e:
print e
resp = JsonResponse({
'status': 'error',
'msg': e.message
})
resp.status_code = 500
return resp
def post(self, request):
result = {'ok': False}
pub_key = request.POST.get('key')
password = request.POST.get('password')
if pub_key and password:
sec_data = cache.get(pub_key)
if isinstance(sec_data, dict):
logger = logging.getLogger('system')
try_count = sec_data.get('try_count', 0) + 1
sec_data.update(try_count=try_count)
cache.set(pub_key, sec_data, 300)
if try_count < settings.AUTH_COUNT_LIMIT:
sec_data = '{}{}{}'.format(
pub_key, settings.IN_PASSWORD, sec_data.get('key'))
sha = hashlib.sha256(sec_data.encode())
result.update(ok=password == sha.hexdigest())
else:
cache.delete(pub_key)
logger.warn(
'Auth count limit! From: {}'.format(
get_client_ip(request)))
if result.get('ok'):
rand = SysRand()
key_part1, key_part2, value = rand.create_keys(count=3)
result.update(msg=msg.AUTH_OK)
result = JsonResponse(result)
key = '{}{}'.format(key_part1, key_part2)
time_limit = 3600 * settings.AUTH_TIME
cache.set(
key,
{'value': value, 'open': datetime_now().isoformat()},
time_limit)
result.set_cookie(
settings.AUTH_COOKIE_NAME,
value='{}:{}'.format(key, value),
max_age=time_limit)
logger.info(
'Manager login from {} new key: {}'.format(
get_client_ip(request), key))
else:
result.update(msg=msg.INCORECT_PASSWORD)
result = JsonResponse(result)
return result
def json_lista_evento(request, id_usuario):
usuario = User.objects.get(id=id_usuario)
evento = Evento.objects.filter(usuario=usuario).values('id', 'titulo')
return JsonResponse(list(evento), safe=False)
def fetch_restaurant(request, slug=''):
if slug == 'not-found':
return JsonResponse({}, status=404)
return JsonResponse(restaurant_svc.fetch(slug))
def list_groups(request):
return JsonResponse({'data': group_svc.list_groups(request.user)})
def actualizarTarea(request, tareid):
try:
with transaction.atomic():
estado = 0
tarea = models.Task.objects.get(pk=tareid)
restriction = models.TaskRestriction.objects.get(
pk=request.POST.get('task_restriction_id'))
restriction.start_time = request.POST.get('tarfechainicio')
restriction.task_end_date = request.POST.get('tarfechacierre')
restriction.start_time = request.POST.get('HoraInicio')
restriction.end_time = request.POST.get('HoraCierre')
restriction.save()
taskpriority = models.TaskPriority.objects.get(
pk=request.POST.get('task_priority_id'))
tasktipe = models.TaskType.objects.get(
pk=request.POST.get('task_type_id'))
projecto = models.Project.objects.get(
pk=request.POST.get('project_id'))
tarea.task_name = request.POST.get('task_name')
tarea.task_type = tasktipe
tarea.task_quantity = request.POST.get('task_quantity')
tarea.project = projecto
tarea.task_description = request.POST.get('task_description')
tarea.task_priority = taskpriority
tarea.task_restriction = restriction
tarea.save()
"""
if estado == 2 and tarea.tareestado != 2:
if validarTarea(tarea):
tarea.tareestado = estado
tarea.save()
else:
tarea.tareestado = estado
tarea.save()
# Verificando que el recurso haya sido llamado desde Gestión de Cambios
if request.POST.get('gestionCambio', None) is not None:
# Obtener los usuarios que hacen del proyecto
usuarios = obtenerEmailsEquipo(tarea.proyid)
# Detalle del Cambio
detalle = "Encuestas Objetivo: {}".format(tarea.tarerestriccant)
# Enviar Notificaciones
gestionCambios(usuarios, 'tarea', tarea.task_name, 1, detalle)"""
response = {
'code': 200,
'tarea': serializers.serialize('python', [tarea])[0],
'status': 'success'
}
except ObjectDoesNotExist as e:
response = {'code': 404, 'message': str(e), 'status': 'error' + str(e)}
except ValidationError as e:
try:
errors = dict(e)
except ValueError:
errors = list(e)[0]
response = {'code': 400, 'errors': errors, 'status': 'error'}
except IntegrityError as e:
response = {'code': 500, 'message': str(e), 'status': 'error'}
return JsonResponse(response, safe=False, status=response['code'])
def lista(request):
usuario = request.user
evento = Envento.objects.all().values('id', 'titulo')
return JsonResponse(list(evento), safe=False)
def category_detail(request , category_id):
try:
category = Category.objects.get(id=category_id)
except Category.DoesNotExist as e:
return JsonResponse({'error': str(e)})
return JsonResponse(category.to_json())
def product_detail(request, product_id):
try:
product = Product.objects.get(id=product_id)
except Product.DoesNotExist as e:
return JsonResponse({'error': str(e)})
return JsonResponse(product.to_json())
def get_alerts(request, userid):
alerts = Alert.objects.filter(user=userid)
serializer = serialize("json", alerts)
return JsonResponse({'alerts': serializer},
safe=False,
status=status.HTTP_200_OK)
}
file = request.FILES.get('file')
if not file:
res['code'] = -2
res['res_msg'] = u'请先选择文件！'
else:
try:
res['list'] = handle_uploaded_file(file)
except Exception, e:
logger.info(e)
res['code'] = -3
res['res_msg'] = u'文件格式有误！'
else:
res['code'] = 0
return JsonResponse(res)
def handle_uploaded_file(f):
ret = []
with open('./name', 'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
with open('./name', 'r') as file:
for line in file:
line = line.decode('gbk')
# line = unicode(line, errors='ignore')
ret.append(line.strip())
return ret
def post(self, request):
"""支付"""
if not request.user.is_authenticated():
return JsonResponse({'code': 1, 'errmsg': '请先登录'})
# 获取请求参数
order_id = request.POST.get('order_id')
# 判断参数合法性
if not order_id:
return JsonResponse({'code': 2, 'errmsg': '订单id不能为空'})
# 查询订单对象
try:
order = OrderInfo.objects.get(
order_id=order_id,
status=1, # 1表示订单是未支付
user=request.user # 指定为该用户的订单
)
except OrderInfo.DoesNotExist:
return JsonResponse({'code': 3, 'errmsg': '无效订单，无法支付'})
# 1. 初始化
from alipay import AliPay
app_private_key_string = open("apps/orders/app_private_key.pem").read()
alipay_public_key_string = open(
"apps/orders/alipay_public_key.pem").read()
alipay = AliPay(
appid="2016091500514094", # 指定沙箱应用id，后期指定为自己创建应用的id
app_notify_url=None, # 默认回调url
app_private_key_string=app_private_key_string,
alipay_public_key_string=alipay_public_key_string,
# 支付宝的公钥，验证支付宝回传消息使用，不是你自己的公钥,
sign_type="RSA2", # RSA 或者 RSA2 # 使用RSA测试会有问题
debug=True # 默认False, 如果是True表示使用沙箱环境
)
# todo:调用第三方sdk查询支付结果
while True:
dict_data = alipay.api_alipay_trade_query(out_trade_no=order_id)
code = dict_data.get('code')
trade_status = dict_data.get('trade_status')
trade_no = dict_data.get('trade_no') # 支付交易号，保存到生鲜项目订单信息表中
# 10000接口调用成功
if code == '10000' and trade_status == 'TRADE_SUCCESS':
# 订单支付成功，修改订单状态为已支付
order.status = 4
order.trade_no = trade_no
order.save() # 修改订单信息表
return JsonResponse({'code': 0, 'message': '支付成功'})
elif (code == '10000'
and trade_status == 'WAIT_BUYER_PAY') or code == '40004':
# 40004暂时查询失败，等一会查询，可能就成功
# WAIT_BUYER_PAY等待买家付款
sleep(2)
print(code, trade_status)
continue
else:
# 支付失败
print(code, trade_status)
return JsonResponse({
'code': 1,
'errmsg': '支付失败：code=%s' % code
})
def all4cats_list_published(request):
all4cats = All4Cats.objects.filter(published=True)
if request.method == 'GET':
all4cats_serializer = All4CatsSerializer(all4cats, many=True)
return JsonResponse(all4cats_serializer.data, safe=False)
def post(self, request):
# 登录判断
if not request.user.is_authenticated():
return JsonResponse({'code': 1, 'errmsg': '请先登录'})
# 获取请求参数：address_id, pay_method, sku_ids_str
address_id = request.POST.get('address_id')
pay_method = request.POST.get('pay_method')
sku_ids_str = request.POST.get('sku_ids_str')
# 校验参数不能为空
if not all([address_id, pay_method, sku_ids_str]):
return JsonResponse({'code': 2, 'errmsg': '参数不能为空'})
# 判断地址是否存在
try:
address = Address.objects.get(id=address_id)
except Address.DoesNotExist:
return JsonResponse({'code': 3, 'errmsg': '该地址不存在'})
# 新增保存点
point = transaction.savepoint()
try:
# todo: 修改订单信息表: 保存订单数据到订单信息表中(新增一条数据)
total_count = 0
total_amount = 0
trans_cost = 10
# 当前时间+用户id
order_id = datetime.now().strftime('%Y%m%d%H%M%S') + str(
request.user.id)
order = OrderInfo.objects.create(
order_id=order_id,
total_count=total_count,
total_amount=total_amount,
trans_cost=trans_cost,
pay_method=pay_method,
user=request.user,
address=address,
)
# 从Redis查询出购物车数据
# 注意: 返回的是字典, 键值都为bytes类型
# cart_1 = {1: 2, 2: 2}
strict_redis = get_redis_connection() # type:StrictRedis
key = 'cart_%s' % request.user.id
sku_ids = sku_ids_str.split(',') # str->list
# todo: 核心业务: 遍历每一个商品, 并保存到订单商品表
for sku_id in sku_ids:
# 查询订单中的每一个商品
try:
sku = GoodsSKU.objects.get(id=sku_id)
except GoodsSKU.DoesNotExist:
# 回滚到保存点，撤销所有的sql操作
transaction.savepoint_rollback(point)
return JsonResponse({'code': 4, 'errmsg': '商品不存在'})
# 获取商品数量，并判断库存
count = strict_redis.hget(key, sku_id)
count = int(count)
if count > sku.stock:
# 回滚到保存点，撤销所有的sql操作
transaction.savepoint_rollback(point)
return JsonResponse({'code': 5, 'errmsg': '库存不足'})
# todo: 修改订单商品表: 保存订单商品到订单商品表（新增多条数据）
OrderGoods.objects.create(
count=count,
price=sku.price,
order=order,
sku=sku,
)
# todo: 修改商品sku表: 减少商品库存, 增加商品销量
sku.stock -= count
sku.sales += count
sku.save()
# 累加商品数量和总金额
total_count += count
total_amount += (sku.price * count)
# todo: 修改订单信息表: 修改商品总数量和总金额
order.total_count = total_count
order.total_amount = total_amount
order.save()
except:
# 回滚到保存点，撤销所有的sql操作
transaction.savepoint_rollback(point)
return JsonResponse({'code': 6, 'errmsg': '创建订单失败'})
transaction.savepoint_commit(point)
# 从Redis中删除购物车中的商品
# cart_1 = {1: 2, 2: 2}
# redis命令: hdel cart_1 1 2
# 列表 -> 位置参数
strict_redis.hdel(key, *sku_ids)
# 订单创建成功， 响应请求，返回json
return JsonResponse({'code': 0, 'message': '创建订单成功'})
def post(self, request):
"""订单创建"""
# 判断用户是否登录
user = request.user
if not user.is_authenticated:
# 用户未登录
return JsonResponse({'res': 0, 'errmsg': '用户未登录'})
# 获取参数
addr_id = request.POST.get('addr_id')
pay_method = request.POST.get('pay_method')
sku_ids = request.POST.get('sku_ids')
# 校验参数
if not all([addr_id, pay_method, sku_ids]):
return JsonResponse({'res': 1, 'errmsg': '参数不完整'})
# 校验支付方式
if pay_method not in OrderInfo.PAY_METHOD.keys():
return JsonResponse({'res': 2, 'errmsg': '非法的支付方式'})
# 校验地址
try:
addr = Address.objects.get(id=addr_id)
except Address.DoesNotExist:
#地址不存在
return JsonResponse({'res': 3, 'errmsg': '地址非法'})
# todo: 创建订单核心业务
# 用户每下一个订单，就需要向df_order_info表中加入一条记录；用户有几个商品，就需要向df_order_goods表中加入几条记录
# 组织参数
# 订单id：20171122181639+用户id
order_id = datetime.now().strftime('%Y%m%d%H%M%S') + str(user.id)
# 运费
transit_price = 10
# 总数目和总金额
total_count = 0
total_price = 0
# 设置django事务点
save_id = transaction.savepoint()
try:
# todo: 向df_order_info表中加入一条记录
order = OrderInfo.objects.create(order_id=order_id,
user=user,
addr=addr,
pay_method=pay_method,
total_count=total_count,
total_price=total_price,
transit_price=transit_price)
# todo: 用户有几个商品，就需要向df_order_goods表中加入几条记录
conn = get_redis_connection('default')
cart_key = 'cart_%d' % user.id
sku_ids = sku_ids.split(',')
for sku_id in sku_ids:
# 获取商品的信息
try:
# select * from fd_goods_sku where id = sku_id for update; 悲观锁
sku = GoodsSKU.objects.select_for_update().get(id=sku_id)
except GoodsSKU.DoesNotExist:
transaction.savepoint_rollback(save_id)
return JsonResponse({'res': 4, 'errmsg': '商品不存在'})
# 从redis中获取用户所要购买的商品的数量
count = conn.hget(cart_key, sku_id)
# todo: 判断商品的库存
if int(count) > sku.stock:
transaction.savepoint_rollback(save_id)
return JsonResponse({'res': 6, 'errmsg': '库存不足'})
# todo: 向df_order_goods表中加入几条记录
OrderGoods.objects.create(order=order,
sku=sku,
count=count,
price=sku.price)
# todo: 更新商品的库存和销量
sku.stock -= int(count)
sku.sales += int(count)
sku.save()
# todo: 累加计算商品的总数和总价格
amount = sku.price * int(count)
total_count += int(count)
total_price += amount
# todo: 更新商品表中的商品的总数量和总价格
order.total_count = total_count
order.total_price = total_price
order.save()
except Exception as e:
transaction.savepoint_rollback(save_id)
return JsonResponse({'res': 7, 'errmsg': '下单失败'})
# 提交事务
transaction.savepoint_commit(save_id)
# todo: 清除用户购物车(redis)中的商品信息
conn.hdel(cart_key, *sku_ids)
# 返回应答
return JsonResponse({'res': 5, 'message': '订单创建成功'})
def form_invalid(self, form):
# Get initial response
response = super(EditObjectModalView, self).form_invalid(form)
data = {'is_valid': False, 'responseText': response.rendered_content}
return JsonResponse(data)
def post(self, request, *args, **kwargs):
cart = self.get_object()
cart.deleted = True
cart.save()
return JsonResponse({"status": "success"}, status=200)
def admin_coupon(request):
admin_user = request.user
if request.method == "GET":
if not (admin_user.is_authenticated() and admin_user.is_staff):
return redirect(
reverse('admin:login') + "?next=" + reverse('admin_coupon'))
return render(request, "admin_coupon.html")
if request.method == "POST":
res = {}
if not request.is_ajax():
raise Http404
if not (admin_user.is_authenticated() and admin_user.is_staff):
res['code'] = -1
res['url'] = reverse('admin:login') + "?next=" + reverse(
'admin_coupon')
return JsonResponse(res)
if not admin_user.has_admin_perms('002'):
res['code'] = -5
res['res_msg'] = u'您没有操作权限！'
return JsonResponse(res)
event_id = request.POST.get('id', None)
cash = request.POST.get('cash', None)
score = request.POST.get('score', None)
type = request.POST.get('type', None)
reason = request.POST.get('reason', None)
type = int(type)
if not event_id or type == 1 and not (
cash and
score) or type == 2 and not reason or type != 1 and type != 2:
res['code'] = -2
res['res_msg'] = u'传入参数不足，请联系技术人员！'
return JsonResponse(res)
event = UserEvent.objects.get(id=event_id)
event_user = event.user
log = AuditLog(user=admin_user, item=event)
translist = None
scoretranslist = None
if type == 1:
try:
cash = float(cash) * 100
cash = int(cash)
score = int(score)
except:
res['code'] = -2
res['res_msg'] = u"操作失败，输入不合法！"
return JsonResponse(res)
if cash < 0 or score < 0:
res['code'] = -2
res['res_msg'] = u"操作失败，输入不合法！"
return JsonResponse(res)
if event.audit_state != '1':
res['code'] = -3
res['res_msg'] = u'该项目已审核过，不要重复审核！'
return JsonResponse(res)
if event.translist.exists():
logger.critical("Returning cash is repetitive!!!")
res['code'] = -3
res['res_msg'] = u"操作失败，返现重复！"
else:
log.audit_result = True
translist = charge_money(event_user, '0', cash, u'优惠券兑换')
scoretranslist = charge_score(event_user, '0', score, u'优惠券兑换')
if translist and scoretranslist:
event.audit_state = '0'
translist.user_event = event
translist.save(update_fields=['user_event'])
scoretranslist.user_event = event
scoretranslist.save(update_fields=['user_event'])
res['code'] = 0
project = event.content_object.project
msg_content = u'您提交的"' + project.title + u'"兑换申请已审核通过。'
Message.objects.create(user=event_user,
content=msg_content,
title=u"优惠券兑换审核")
else:
res['code'] = -4
res['res_msg'] = "注意，重复提交时只提交失败项目，成功的可以输入0。\n"
if not translist:
logger.error(u"Charging cash is failed!!!")
res['res_msg'] += u"现金记账失败，请检查输入合法性后再次提交！"
if not scoretranslist:
logger.error(u"Charging score is failed!!!")
res['res_msg'] += u"积分记账失败，请检查输入合法性后再次提交！"
else:
event.audit_state = '2'
log.audit_result = False
log.reason = reason
res['code'] = 0
project = event.content_object.project
msg_content = u'您提交的"' + project.title + u'"兑换申请审核未通过，原因：' + reason
Message.objects.create(user=event_user,
content=msg_content,
title=u"优惠券兑换审核")
if res['code'] == 0:
admin_event = AdminEvent.objects.create(admin_user=admin_user,
custom_user=event_user,
event_type='10')
if translist:
translist.admin_event = admin_event
translist.save(update_fields=['admin_event'])
if scoretranslist:
scoretranslist.admin_event = admin_event
scoretranslist.save(update_fields=['admin_event'])
log.admin_item = admin_event
log.save()
event.audit_time = log.time
event.save(update_fields=['audit_state', 'audit_time'])
return JsonResponse(res)
def category_list(request):
categories = Category.objects.all()
categories_json = [category.to_json() for category in categories]
return JsonResponse(categories_json, safe=False)
def deliver_coupon(request):
admin_user = request.user
if request.method == 'GET':
if not (admin_user.is_authenticated() and admin_user.is_staff):
return redirect(
reverse('admin:login') + "?next=" + reverse('admin_index'))
else:
return render(request, 'deliver_coupon.html',
{'type_list': COUPON_TYPE})
elif request.method == 'POST':
result = {'code': 0}
if not (admin_user.is_authenticated() and admin_user.is_staff):
result['code'] = -4
result['res_msg'] = u'请登录！'
return JsonResponse(result)
if not admin_user.has_admin_perms('006'):
result['code'] = -5
result['res_msg'] = u'您没有操作权限！'
return JsonResponse(result)
coupon_type = request.POST.get('selecttype')
project_id = request.POST.get('selectproject')
if coupon_type is None or project_id is None:
raise Http404
else:
project_id = int(project_id)
coupon_type = str(coupon_type)
project = CouponProject.objects.get(id=project_id)
success_count = 0
fail_list = []
if coupon_type == '0' or coupon_type == '1':
select_user = request.POST.get('selectuser')
if select_user is None:
raise Http404
else:
select_user = str(select_user)
if select_user == '1':
for user in MyUser.objects.all():
Coupon.objects.create(user=user, project=project)
msg_content = u'您收到一张优惠券：' + project.title + u'，到期日为' + \
project.endtime.strftime("%Y-%m-%d") + u"，请及时使用。"
Message.objects.create(user=user,
content=msg_content,
title=u"新的优惠券")
success_count += 1
elif select_user == '2':
select_list_str = request.POST.get('users')
if select_list_str is None:
raise Http404
else:
select_list_str = str(select_list_str)
select_list = select_list_str.strip().split('\n')
user_set = set([])
for user in select_list:
if user:
user_set.add(user)
for username in user_set:
try:
user = MyUser.objects.get(username=username)
Coupon.objects.create(user=user, project=project)
msg_content = u'您收到一张优惠券：' + project.title + u'，到期日为' + \
project.endtime.strftime("%Y-%m-%d") + u"，请及时使用。"
Message.objects.create(user=user,
content=msg_content,
title=u"新的优惠券")
except:
fail_list.append(username)
else:
success_count += 1
elif coupon_type == '2':
select_list_str = request.POST.get('codes')
if select_list_str is None:
raise Http404
else:
select_list_str = str(select_list_str)
select_list = select_list_str.strip().split('\n')
code_set = set([])
for code in select_list:
if code:
code_set.add(code)
for code in code_set:
Coupon.objects.create(project=project, exchange_code=code)
success_count += 1
result.update({'succ_num': success_count, 'fail_list': fail_list})
return JsonResponse(result)
def product_list(request):
products = Product.objects.all()
products_json = [product.to_json() for product in products]
return JsonResponse(products_json, safe=False)
def search_users(request):
data = user_svc.search(request.user, request.GET.get('query'))
return JsonResponse({'data': data})
def listadoTareas(request):
try:
# Obtener usuario autenticado
usuario = usuarioAutenticado(request)
person = models.Person.objects.get(user__userid=usuario.userid)
tareasUsuario = []
proyectosUsuario = []
n = ""
# Superadministrador
if str(person.role_id) == ROL_SUPER_ADMIN:
tareasUsuario = []
n = "select tk.* from opx.task as tk order by tk.task_creation_date DESC;"
# Consulta de proyectos para un usuario proyectista
elif str(person.role_id) == ROL_PROYECTISTA:
n = "select tk.*, restric.* \
from opx.person as persona \
inner join opx.project as proyecto on proyecto.proj_owner_id = persona.pers_id \
inner join opx.task as tk on tk.project_id = proyecto.proj_id \
inner join opx.task_restriction as restric on tk.task_restriction_id = restric.restriction_id \
where persona.pers_id = '" + str(
person.pers_id) + "' order by tk.task_creation_date DESC;"
# Consulta de proyectos para un usuario voluntario o validador
elif str(person.role_id) == ROL_VOLUNTARIO or str(
person.pers_id) == ROL_VALIDADOR:
n = "select distinct tk.*, restric.* \
from opx.person as person \
inner join opx.team_person as tp on person.pers_id = tp.person_id \
inner join opx.project_team as pt on tp.team_id = pt.team_id \
inner join opx.task as tk on tk.project_id = pt.project_id \
inner join opx.task_restriction as restric on tk.task_restriction_id = restric.restriction_id \
where person.pers_id = '" + str(
person.pers_id) + "' order by tk.task_creation_date DESC;"
# ================ Obtener página validación de la misma ========================
page = request.GET.get('page')
if (page is None):
page = 1
all = request.GET.get('all')
with connection.cursor() as cursor:
cursor.execute(n)
# formatear respuesta de base de datos
tareas = dictfetchall(cursor)
# Progreso de las Tareas
for t in tareas:
t['task_type_name'] = (models.TaskType.objects.get(
pk=t['task_type_id'])).task_type_name
t['instrument_name'] = (models.Instrument.objects.get(
pk=t['instrument_id'])).instrument_name
t['proj_name'] = (models.Project.objects.get(
pk=t['project_id'])).proj_name
t['priority_name'] = (models.TaskPriority.objects.get(
pk=t['task_priority_id'])).priority_name
t['task_completness'] = t['task_completness'] * 100
# Obtener Búsqueda y validación de la misma
search = request.GET.get('search')
if search is not None:
tareas = models.Task.objects.filter(task_name__icontains=search)
tareas = list(tareas.values())
if all is not None and all == "1":
data = {'code': 200, 'tareas': tareas, 'status': 'success'}
else:
# Obtener Página
paginator = Paginator(tareas, 10)
# Obtener lista de tareas
tareas = paginator.page(page).object_list
data = {
'code': 200,
'paginator': {
'currentPage': page,
'perPage': paginator.per_page,
'lastPage': paginator.num_pages,
'total': paginator.count
},
'tareas': tareas,
'status': 'success'
} # Obtener Búsqueda y validación de la misma
except EmptyPage:
data = {
'code': 400,
'message': 'Página inexistente',
'status': 'error'
}
return JsonResponse(data, safe=False, status=data['code'])
def process_view(self, request, view_func, view_args, view_kwargs):
"""
Validate only the token introspect.
:param request: django request
:param view_func:
:param view_args: view args
:param view_kwargs: view kwargs
:return:
"""
print ('DEBUG:', request)
# do not block the access to root!
if request.path_info == '/':
logger.debug('** exclude path found, skipping')
return None
# CONTINGENCY SOLUTION!!! review API to avoid this
# if request.path_info[-7:] == '/series':
# return None
whitelist = [
'/api/v1/api',
'/api/v1/alive',
'/api/v1/ready',
'/oformat/WORD/documentation',
'/oformat/EXCEL/documentation',
'/export_download'
]
for iwhite in whitelist:
if request.path_info.endswith(iwhite):
print ('skipped:', request.path_info)
return None
if hasattr(settings, 'KEYCLOAK_BEARER_AUTHENTICATION_EXEMPT_PATHS'):
path = request.path_info.lstrip('/')
if any(re.match(m, path) for m in
settings.KEYCLOAK_BEARER_AUTHENTICATION_EXEMPT_PATHS):
logger.debug('** exclude path found, skipping')
return None
try:
roles = view_func.cls.roles
except AttributeError as e:
return JsonResponse({"detail": NotAuthenticated.default_detail}, status=NotAuthenticated.status_code)
if 'HTTP_AUTHORIZATION' not in request.META:
return JsonResponse({"detail": NotAuthenticated.default_detail}, status=NotAuthenticated.status_code)
auth_header = request.META.get('HTTP_AUTHORIZATION').split()
token = auth_header[1] if len(auth_header) == 2 else auth_header[0]
try:
userinfo = self.keycloak.userinfo(token)
except KeycloakError as e:
return JsonResponse({"detail": AuthenticationFailed.default_detail}, status=AuthenticationFailed.status_code)
has_role = True
for role in roles:
if role not in userinfo['groups']:
has_role = False
# In case we need to verify token. But since we verify it by using userinfo call, it is not necessary atm.
# KEYCLOAK_PUBLIC_KEY = self.client_public_key
# options = {"verify_signature": True, "verify_aud": True, "verify_exp": True}
# token_info = self.keycloak.decode_token(token, key=KEYCLOAK_PUBLIC_KEY, options=options)
# if token_info['realm_access'] and token_info['realm_access']['roles']:
# print(token_info['realm_access']['roles'])
if has_role:
return None
# User Permission Denied
return JsonResponse({"detail": PermissionDenied.default_detail}, status=PermissionDenied.status_code)
def get_data(request):
data = {
"sales": 100,
"customers": 10,
}
return JsonResponse(data)
def complete_transfer(request, stripe_id):
t = Transfer.objects.get(stripe_id=stripe_id)
t.metadata['completed'] = not t.metadata.get('completed', None)
t.save()
return JsonResponse({'completed': t.metadata['completed']})
def play_game(request, game_id):
# return HttpResponse("play_game")
game = get_object_or_404(Game, id=game_id)
whether_owned = request.user.user_profile._ownedGames.filter(
id=game_id).exists()
if not whether_owned:
messages.error(request, "Sorry, you don't own the game.")
return HttpResponseRedirect(reverse("game_list"))
if request.method == 'GET':
high_scores = Game_Score.objects.filter(
played_game=game).order_by("-score")[0:10]
ranking = [s.to_json() for s in high_scores]
if Game_Score.objects.filter(
played_game=game, _player=request.user.user_profile).exists():
player_highest_score = Game_Score.objects.filter(
played_game=game,
_player=request.user.user_profile).order_by("-score")[0]
else:
player_highest_score = 0
context = {
'game': game.to_json(),
'game_url': game.url,
'ranking': ranking,
"player_highest_score": player_highest_score
}
return render(request, "game/play_game.html", context)
elif request.method == 'POST':
response = {"error": None, "result": None}
if request.POST.get('messageType') == 'SCORE':
scoreForm = ScoreForm(request.POST)
if scoreForm.is_valid():
Game_Score.objects.create(
played_game=game,
score=scoreForm.cleaned_data['score'],
played_time=timezone.now(),
_player=request.user.user_profile)
else:
response['error'] = scoreForm.errors
return JsonResponse(response)
elif request.POST.get('messageType') == 'SAVE':
saveForm = SaveForm(request.POST)
if saveForm.is_valid():
saved_game = Saved_Game.objects.update_or_create(
played_game=game, _player=request.user.user_profile)[0]
saved_game.saved_time = timezone.now()
saved_game.state = saveForm.cleaned_data['gameState']
saved_game.save()
else:
response['error'] = saveForm.errors
return JsonResponse(response)
elif request.POST.get('messageType') == 'LOAD_REQUEST':
saved_game = Saved_Game.objects.filter(
played_game=game,
_player=request.user.user_profile).order_by("-saved_time")
if saved_game.exists():
response['result'] = saved_game[0].state
else:
response['error'] = "No saved game state."
return JsonResponse(response)
else:
response['error'] = "Invalid message type."
return JsonResponse(response)
else:
return HttpResponse("Invalid request method")
def new_dog(request):
if request.method == 'GET':
user = request.user
dog_dict = {}
count = 0
user_profile = UserProfile.objects.get(user=user)
dogs = Dog.objects.filter(owner=user_profile)
for dog in dogs:
add = {
'name': dog.dog_name,
'age': dog.age,
'sex': dog.sex,
'size': dog.size,
'temperment': dog.temperment,
'crate_trained': dog.crate_trained,
'details': dog.details,
'id': dog.id
}
dog_dict.update({count: add})
count += 1
return JsonResponse(dog_dict)
data = request.body
data = str(data, 'utf-8')
form = json.loads(data)
dog_name = form.get('dog_name').title()
age = form.get('age')
sex = form.get('sex')
size = form.get('size')
temperment = form.get('temperment')
crate_trained = bool(form.get('crate_trained'))
details = form.get('details')
user_profile = UserProfile.objects.get_or_create(user=request.user)[0]
if not age.isdigit(
) or sex not in 'MF' or size not in 'SML' or dog_name == '':
return JsonResponse({'message': 'Invalid Input'})
added = Dog.objects.filter(owner=user_profile, dog_name=dog_name).exists()
added2 = Dog.objects.filter(owner=user_profile, dog_name=dog_name)
if added:
return update_dog(request)
new_pupp = Dog(owner=user_profile,
dog_name=dog_name,
age=age,
sex=sex,
size=size,
temperment=temperment,
crate_trained=crate_trained,
details=details)
new_pupp.save()
return JsonResponse({'message': 'New Dog Added'})
def find_restaurant(request):
return JsonResponse(
{'data': restaurant_svc.find(request.user, request.GET)})
def update_user(request):
if request.method == 'GET':
user = request.user
user_dict = {}
profile_exists = UserProfile.objects.filter(user=user).count()
if profile_exists == 1:
user_profile = UserProfile.objects.get(user=user)
user_dict = {
'phone_number': user_profile.phone_number,
'first_name': user_profile.first_name,
'last_name': user_profile.last_name,
'address': user_profile.address,
'city': user_profile.city,
'zipcode': user_profile.zipcode,
'share_pupps': user_profile.share_pupps
}
return JsonResponse(user_dict)
data = request.body
data = str(data, 'utf-8')
form = json.loads(data)
count = 0
message = 'User Profile Updated!'
user = request.user
user_dict = {
'phone_number': form.get('phone_number'),
'first_name': form.get('first_name'),
'last_name': form.get('last_name'),
'address': form.get('address'),
'city': form.get('city'),
'zipcode': form.get('zipcode'),
'share_pupps': form.get('share_pupps')
}
user_profile = UserProfile.objects.get_or_create(user=user)[0]
updated_user = UserProfile.objects.filter(user=user).values()
for item in updated_user:
for thing in item:
if thing in user_dict:
if not user_dict[thing]:
user_dict[thing] = item[thing]
count += 1
if count == 7:
message = 'No Data Input'
updated_user = UserProfile.objects.filter(user=user).update(
user=user,
phone_number=user_dict['phone_number'],
first_name=user_dict['first_name'],
last_name=user_dict['last_name'],
address=user_dict['address'],
city=user_dict['city'],
zipcode=user_dict['zipcode'],
share_pupps=user_dict['share_pupps'])
# updated_user.save()
return JsonResponse({'message': message, 'user_info': user_dict})
def get_admin_coupon_page(request):
res = {
'code': 0,
}
user = request.user
if not (user.is_authenticated() and user.is_staff):
res['code'] = -1
res['url'] = reverse('admin:login') + "?next=" + reverse(
'admin_coupon')
return JsonResponse(res)
page = request.GET.get("page", None)
size = request.GET.get("size", 10)
state = request.GET.get("state", '1')
projecttype = request.GET.get("projecttype", '0')
try:
size = int(size)
except ValueError:
size = 10
if not page or size <= 0 or not state:
raise Http404
item_list = []
item_list = UserEvent.objects
startTime = request.GET.get("startTime", None)
endTime = request.GET.get("endTime", None)
startTime2 = request.GET.get("startTime2", None)
endTime2 = request.GET.get("endTime2", None)
if startTime and endTime:
s = datetime.datetime.strptime(startTime, '%Y-%m-%dT%H:%M')
e = datetime.datetime.strptime(endTime, '%Y-%m-%dT%H:%M')
item_list = item_list.filter(time__range=(s, e))
if startTime2 and endTime2:
s = datetime.datetime.strptime(startTime2, '%Y-%m-%dT%H:%M')
e = datetime.datetime.strptime(endTime2, '%Y-%m-%dT%H:%M')
item_list = item_list.filter(audit_time__range=(s, e))
username = request.GET.get("username", None)
if username:
item_list = item_list.filter(user__username=username)
mobile = request.GET.get("mobile", None)
if mobile:
item_list = item_list.filter(user__mobile=mobile)
companyname = request.GET.get("companyname", None)
if companyname:
item_list = item_list.filter(
coupon__project__provider__contains=companyname)
projectname = request.GET.get("projectname", None)
if projectname:
item_list = item_list.filter(
coupon__project__title__contains=projectname)
adminname = request.GET.get("adminname", None)
if adminname:
item_list = item_list.filter(audited_logs__user__username=adminname)
if projecttype == '1':
item_list = item_list.filter(coupon__type='0')
if projecttype == '2':
item_list = item_list.filter(coupon__type='1')
item_list = item_list.filter(
event_type='4',
audit_state=state).select_related('user').order_by('time')
paginator = Paginator(item_list, size)
try:
contacts = paginator.page(page)
except PageNotAnInteger:
# If page is not an integer, deliver first page.
contacts = paginator.page(1)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
contacts = paginator.page(paginator.num_pages)
data = []
for con in contacts:
coupon = con.content_object
i = {
"username":
con.user.username,
"mobile":
con.user.mobile,
"type":
coupon.project.get_ctype_display(),
"company":
coupon.project.provider,
"project":
coupon.project.title,
"mobile_sub":
con.invest_account,
"remark_sub":
con.remark,
"time_sub":
con.time.strftime("%Y-%m-%d %H:%M"),
"state":
con.get_audit_state_display(),
"admin":
u'无' if con.audit_state == '1' or not con.audited_logs.exists()
else con.audited_logs.first().user.username,
"time_admin":
u'无' if con.audit_state == '1' or not con.audit_time else
con.audit_time.strftime("%Y-%m-%d %H:%M"),
"amount":
coupon.project.amount,
"invest_amount":
con.invest_amount,
"invest_term":
con.invest_term,
"return_amount":
u"无" if con.audit_state != '0' or not con.translist.exists() else
con.translist.first().transAmount,
"score":
u'无' if con.audit_state != '0' or not con.score_translist.exists()
else con.score_translist.first().transAmount,
"id":
con.id,
"remark":
con.remark or u'无' if con.audit_state != '2' or
not con.audited_logs.exists() else con.audited_logs.first().reason,
}
data.append(i)
if data:
res['code'] = 1
res["pageCount"] = paginator.num_pages
res["recordCount"] = item_list.count()
res["data"] = data
return JsonResponse(res)
def customer_list_age(request, age):
customers = Customer.objects.filter(age=age)
if request.method == 'GET':
customers_serializer = CustomerSerializer(customers, many=True)
return JsonResponse(customers_serializer.data, safe=False)
