def token_new(request):
if request.method == 'POST':
username = request.POST.get('username')
password = request.POST.get('password')
if username and password:
user = authenticate(username=username, password=password)
if user:
TOKEN_CHECK_ACTIVE_USER = getattr(settings,
"TOKEN_CHECK_ACTIVE_USER",
False)
if TOKEN_CHECK_ACTIVE_USER and not user.is_active:
return JsonResponseForbidden("User account is disabled.")
data = {
'token': token_generator.make_token(user),
'user': user.pk,
}
return JsonResponse(data)
else:
return JsonResponseUnauthorized(
"Unable to log you in, please try again.")
else:
return JsonError(
"Must include 'username' and 'password' as POST parameters.")
else:
return JsonError("Must access via a POST request.")
def addGrade(request):
"""
courseid: <courseid>
homeworkid: <homeworkid>
optional:
points_received: <# points>
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
if not 'courseid' in data:
return JsonError("A courseid field is required to create a grade.")
if not 'homeworkid' in data:
return JsonError("A homeworkid field is required to create a grade.")
if not Course.objects.filter(id=data['courseid']).exists():
return JsonError("The courseid provided for the grade isn't valid.")
if not Homework.objects.filter(id=data['homeworkid']).exists():
return JsonError("The homeworkid provided for the grade isn't valid.")
grade = Grade(course=Course.objects.get(id=data['courseid']),
homework=Homework.objects.get(id=data['homeworkid']),
user=request.user)
if 'points_received' in data:
grade.points_received = data['points_received']
grade.save()
return JsonResponse({"data": {"id": grade.id}, "success": True})
def token_check(request):
if request.method == 'GET':
token = request.GET.get('token')
user = request.GET.get('user')
if token is not None and user is not None:
if authenticate(pk=user, token=token) is not None:
return JsonSuccess()
else:
return JsonError("Token did not match user.")
else:
return JsonError(
"Must include 'user' and 'token' parameters with request.")
elif request.method == 'POST':
token = request.POST.get('token')
user = request.POST.get('user')
if token is not None and user is not None:
if authenticate(pk=user, token=token) is not None:
return JsonSuccess()
else:
return JsonError("Token did not match user.")
else:
return JsonError(
"Must include 'user' and 'token' parameters with request.")
else:
return JsonError("Must access via a POST or GET request.")
def addHomework(request):
"""
categoryid: <categoryid>
name: <name>
optional:
points_possible: <# points possible>
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
if not 'name' in data:
return JsonError("A name field is required to create a homework.")
if not 'categoryid' in data:
return JsonError(
"A categoryid field is required to create a homework.")
if len(data['name']) < 4:
return JsonError("The name provided for the homework is too short.")
if not Category.objects.filter(id=data['categoryid']).exists():
return JsonError(
"The categoryid provided for the homework isn't valid.")
homework = Homework(name=data['name'],
category=Category.objects.get(id=data['categoryid']))
if 'points_possible' in data:
homework.points_possible = data['points_possible']
homework.save()
return JsonResponse({"data": {"id": homework.id}, "success": True})
def delete(request, id):
if request.method != "POST":
return JsonError("Only POST is allowed")
post = request.POST
try:
exp = Expense.objects.get(pk=id)
print(exp)
exp.delete()
except Expense.DoesNotExist:
return JsonError("Invalid id")
return JsonResponse({})
def save_complemento(request):
if request.method == "POST":
try:
producto = Productos.objects.get(
ns_imei=request.POST.get("ns_imei"))
except:
producto = Productos()
producto.ns_imei = request.POST["ns_imei"]
producto.detalle = request.POST["detalle"]
producto.precio_venta = request.POST["precio_venta"].replace(",", ".")
producto.es_unico = False
producto.estado = "VT"
producto.save()
compra = Compras(codigo_compra=request.POST["codigo_compra"],
producto_id=producto.id,
usuario_id=request.user.id)
compra.save()
datos = {
"result": True,
"codigo_compra": compra.codigo_compra,
"modelo": unicode(producto),
"ns_imei": producto.ns_imei,
"precio": str(producto.precio_venta),
"tipo": producto.get_descripcion_tipo(),
"descuento": str(producto.descuento),
"es_unico": producto.es_unico
}
return JsonResponse(datos)
return JsonError("Solo puede ser peticiones POST")
def getfiles(request):
if request.method != 'POST' or not 'ID' in request.POST:
return JsonError("Este servidor solo acepta peticiones POST")
id_file = request.POST["ID"]
path = FileController.getPath(id_file)
file_path = os.path.join(settings.MEDIA_ROOT, path)
if os.path.exists(file_path):
with open(file_path, 'rb') as fh:
response = HttpResponse(fh.read(),
content_type="application/octet-stream")
response[
'Content-Disposition'] = 'inline; filename=' + os.path.basename(
file_path)
return response
return JsonError("Pagina no encontrada o un error inesperado")
def get_documento_firma(request):
if request.method == "POST":
dni = request.POST["data"]
clientes = Clientes.objects.filter(DNI=dni)
pk = -1
if len(clientes) >0:
pk = clientes[0].pk
compras = Compras.objects.filter(Q(vendedor_id=pk) & Q(firma=""))
if len(compras) > 0:
vendedor = compras[0].get_vendedor()
producto = compras[0].producto
return JsonResponse({"result":
[{"nombre": cliente.nombre_completo,
"compra_id": compras[0].id,
"nombre": vendedor["nombre"],
"telefono": vendedor['telefono'],
"DNI": vendedor["DNI"].upper(),
"domicilio": vendedor['domicilio'],
"modelo": str(producto),
"ns_imei": producto.ns_imei,
"precio": producto.precio_compra}]})
else:
return JsonResponse({"result": []})
else:
return JsonError("Solo acepta peticiones POST")
def token(request, token, user):
try:
user = User.objects.get(pk=user)
except User.DoesNotExist:
return JsonError("User does not exist.")
TOKEN_CHECK_ACTIVE_USER = getattr(settings, "TOKEN_CHECK_ACTIVE_USER",
False)
if TOKEN_CHECK_ACTIVE_USER and not user.is_active:
return JsonError("User account is disabled.")
if token_generator.check_token(user, token):
return JsonResponse({})
else:
return JsonError("Token did not match user.")
def secrets(request):
user_id = request.GET['user']
user = get_object_or_404(User, pk=user_id)
if request.method == strings.POST:
description = request.POST['description']
secret = user.secret_set.create(description=description)
dict = {}
dict[strings.ID] = secret.id
return JsonResponse(dict)
elif request.method == strings.GET:
secrets = Secret.objects.filter(user__id=user.id)
listofsecrets = []
dictofsecrets = {}
for secret in secrets:
listofsecrets.append(
utility.Secret(secret.id, secret.description,
str(secret.pub_date)).__dict__)
dictofsecrets["secrets"] = listofsecrets
return JsonResponse(dictofsecrets)
else:
return JsonError("only can have post and get requests")
def get_producto(request):
ns_imei = request.POST['ns_imei']
datos = {}
try:
producto = Productos.objects.filter(Q(ns_imei__icontains=ns_imei))
producto = producto[0]
except:
return JsonError("No se ha encontrado coincidencias")
compras = Compras.objects.filter(producto__pk=producto.pk)
if len(compras) > 0:
codigo_compra = compras[0].codigo_compra
else:
codigo_compra = producto.id + 303450
datos = {
"result": True,
"codigo_compra": codigo_compra,
"modelo": unicode(producto),
"ns_imei": producto.ns_imei,
"precio": str(producto.precio_venta),
"tipo": producto.get_descripcion_tipo(),
"descuento": str(producto.descuento),
"es_unico": producto.es_unico,
"estado": producto.estado,
"id": producto.id
}
return JsonResponse(datos)
def save_modelo(request):
from tokenapi.http import JsonResponse, JsonError
f_modelo = ModelosForm(request.POST)
if f_modelo.is_valid():
modelo = f_modelo.save()
return JsonResponse({'id': modelo.id})
else:
return JsonError("formulario no valido")
def register(request):
"""
"username": username
"password": password
"email": email
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
#Username
if not 'username' in data:
return JsonError("'username' is a required field.")
if len(data['username']) < 4 or len(data['username']) > 25:
return JsonError("Usernames must be between 4 and 25 characters.")
if User.objects.filter(username=data['username']).exists():
return JsonError("Username already exists")
if not 'password' in data:
return JsonError("'password' is a required field.")
if len(data['password']) < 5:
return JsonError("A password must be at least 5 characters long.")
if not 'email' in data:
return JsonError("'email' is a required field.")
if len(data['email']) < 5:
return JsonError("Email is too short")
user = User(username=data['username'], email=data['email'])
user.set_password(data['password'])
user.save()
return JsonResponse({"success": True, "data": {"id": user.id}})
def qson_django(request):
if request.method != 'POST' or not 'data' in request.POST:
return JsonError("Este servidor solo acepta peticiones POST")
data = json.loads(request.POST.get("data"))
JSONResponse = {}
qson_helper = QSonHelperDjango()
JSONResponse = qson_helper.decode_qson(data)
http = JsonResponse(JSONResponse)
return http
def modificar_precio_venta(request, id_producto):
if request.method == "POST":
producto = Productos.objects.get(pk=id_producto)
producto.estado = "VT"
producto.precio_venta = request.POST["precio_venta"]
producto.save()
return JsonResponse({'precio': producto.precio_venta})
else:
return JsonError("solo peticiones post")
def addCourse(request):
"""
name: coursename
school: school name
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
if not 'name' in data:
return JsonError("A name field is required to create a course.")
if not 'school' in data:
return JsonError("A school field is required to create a course.")
if len(data['name']) < 4:
return JsonError("The name provided for the course is too short.")
if len(data['school']) < 4:
return JsonError("The name provided for the school is too short.")
course = Course(name=data['name'], school=data['school'])
course.save()
return JsonResponse({"data": {"id": course.id}, "success": True})
def get(request):
"""Return laptimes according to requested car/track combo."""
if request.method != 'GET':
return JsonError('Only GET method is allowed.')
try:
track = Track.objects.filter(ac_name=request.GET['track'],
layout=request.GET.get('layout') or '')
car = Car.objects.filter(ac_name=request.GET['car'])
except KeyError as err:
return JsonError('Missing <{}> argument.'.format(err.args[0]))
if track.count() == 0 or car.count() == 0:
msg = 'No laptimes found.'
logger = logging.getLogger(__name__)
logger.warning(msg, extra={'request': request, 'stack': True})
return JsonError(msg)
serializer = LaptimeSerialiser(
Laptime.objects.filter(car=car, track=track).order_by('user', 'time') \
.distinct('user'),
many=True
)
return JsonResponse(serializer.data, status=200)
def edit(request, id):
if request.method != "POST":
return JsonError("Only POST is allowed")
post = request.POST
try:
exp = Expense.objects.get(pk=id)
if post['shop'] != exp.shop:
shop = Shop.objects.get_or_create(name=post['shop'])[0]
exp.shop = shop
exp.date = post['date']
exp.expenseitem_set.clear()
for name, price, category in json.loads(post['items']):
exp.expenseitem_set.create(name=name,
price=price,
category=category)
exp.save()
print(exp)
exp = Expense.objects.get(pk=id)
print(exp)
except KeyError as e:
return JsonError("The following key is not found %s" % e)
except Expense.DoesNotExist:
return JsonError("Invalid id")
return JsonResponse({})
def add_setup(request):
"""Add a new setup to an existing laptime."""
if request.method != 'POST':
return JsonError('Only POST method is allowed.')
logger = logging.getLogger(__name__)
try:
data = json.loads(request.body.decode('utf-8'))
except json.decoder.JSONDecodeError:
msg = "Bad data. Can't load parameters."
logger.warning(msg,
exc_info=True,
extra={
'request': request,
'stack': True
})
return JsonError(msg)
try:
setup, laptime_id = data['car_setup'], data['laptime_id']
except KeyError as err:
return JsonError('Missing <{}> argument.'.format(err.args[0]))
try:
laptime = Laptime.objects.get(pk=laptime_id)
except Laptime.DoesNotExist:
return JsonError('Laptime not found')
if laptime.car_setup is not None:
return JsonError('Setup already exists for the laptime.')
car_setup, created = Setup.objects.get_or_create(car=laptime.car,
track=laptime.track,
**setup)
laptime.car_setup = car_setup
laptime.save()
return JsonResponse(dict(message='Setup was saved for the laptime.'))
def addCategory(request):
"""
name: category name
Optional:
weight: <weight>
"""
if check(request) is not None:
return check(request)
data = json.loads(request.body.decode('utf-8'))
if not 'name' in data:
return JsonError("A name field is required to create a category.")
if len(data['name']) < 4:
return JsonError("The name provided for the category is too short.")
cat = Category(name=data['name'])
if 'weight' in data:
cat.weight = float(data['weight'])
cat.save()
return JsonResponse({"data": {"id": cat.id}, "success": True})
def upload_test_result(request):
if request.method == 'POST':
form = TestResultUploadForm(request.POST)
if form.is_valid():
repo_url = form.cleaned_data['repository_url']
repo_name = '/'.join(repo_url.split('/')[3:5])
branch_url = repo_url + '/trees/' + form.cleaned_data['branch_name']
commit_url = repo_url + '/trees/' + form.cleaned_data['commit_sha']
test_results = {
'package': {
'name': form.cleaned_data['package'],
},
'repository': {
'name': repo_name,
'url': repo_url,
},
'branch': {
'name': form.cleaned_data['branch_name'],
'url': branch_url,
},
'commit': {
'name': form.cleaned_data['commit_sha'],
'url': commit_url,
},
'execution': {
'name': form.cleaned_data['execution_name'],
'url': form.cleaned_data['execution_url'],
},
'environment': {
'name': form.cleaned_data['environment_name'],
},
'results_url': form.cleaned_data['results_file_url'],
}
from testresults.importer import import_test_results
execution = import_test_results.delay(test_results)
return JsonResponse({'execution_id': execution.id})
else:
return JsonError('Only POST is allowed')
#form = TestResultUploadForm()
context = RequestContext(request, {'form': form})
return render_to_response('testresults/upload_test_result.html', context)
def set_review(request):
"""
Set review by user
"""
user = request.user
if not user.is_authenticated():
return JsonError("PermissionDenied")
review = Review()
review.title = request.POST.get("title")
review.rating = request.POST.get("rating")
review.summary = request.POST.get("summary")
review.ip_address = get_client_ip(request)
review.reviewer = user
review.company_id = request.POST.get("company_id")
review.save()
return JsonResponse({'status': 'success', 'review_id': review.id})
def detail(request, secret_id):
try:
user_id = request.GET['user']
except:
return JsonError("key error")
try:
user = get_object_or_404(User, pk=user_id)
except ObjectDoesNotExist:
return JsonError("User " + user_id + "does not exist")
if request.method == strings.POST:
description = request.POST['description']
try:
selected_secret = user.secret_set.get(pk=secret_id)
except (ObjectDoesNotExist):
return JsonError("Secret id " + secret_id + " does not exist")
selected_secret.description = description
selected_secret.save()
return JsonResponse({})
elif request.method == strings.GET:
try:
selected_choice = user.secret_set.get(pk=secret_id)
except (ObjectDoesNotExist):
return JsonError("Secret id " + secret_id + " does not exist")
secret = utility.Secret(selected_choice.id,
selected_choice.description,
str(selected_choice.pub_date)).__dict__
return JsonResponse(secret)
elif request.method == strings.DELETE:
try:
selected_secret = user.secret_set.get(pk=secret_id)
except (ObjectDoesNotExist):
return JsonError("Secret id " + secret_id + " does not exist")
selected_secret.delete()
return JsonResponse({})
else:
return JsonError("Only can post, put, get, delete")
def expense_list_json(request, type):
print(request.user)
expenses = Expense.objects.for_user(request.user)
if type == 'all':
expenses = expenses.all()
groups = listify(expenses, True)
elif type == 'place':
shops = Shop.objects.filter(lat__isnull=False,
lon__isnull=False).annotate(
Sum('expense__expenseitem__price'))
groups = []
for shop in shops:
groups.append((shop.name, shop.lat, shop.lon,
str(shop.expense__expenseitem__price__sum)))
elif type == 'day':
expenses = expenses.order_by('date').all()
groups = []
for k, g in groupby(expenses, lambda x: x.date):
groups.append((str(k), listify(g)))
else:
return JsonError("Invalid request")
return JsonResponse(groups)
def _wrapped_view(request, *args, **kwargs):
user = None
token = None
basic_auth = request.META.get('HTTP_AUTHORIZATION')
user = request.POST.get('user', request.GET.get('user'))
token = request.POST.get('token', request.GET.get('token'))
if not (user and token) and basic_auth:
auth_method, auth_string = basic_auth.split(' ', 1)
if auth_method.lower() == 'basic':
auth_string = b64decode(auth_string.strip())
user, token = auth_string.decode().split(':', 1)
if not (user and token):
return JsonError("Must include 'user' and 'token' parameters with request.")
user = authenticate(pk=user, token=token)
if user:
request.user = user
return view_func(request, *args, **kwargs)
return JsonResponseUnauthorized("You are unauthorized to view this page.")
def get_ventas_chart(request):
if request.method == "POST":
years = 0
month = 0
ventas = 0
compras = 0
base_imponible = 0
importe_iva = 0
importe = 0
try:
years = request.POST["years"]
month = request.POST["month"]
ventas = Ventas.objects.filter(
fecha_salida__month__gte=month,
fecha_salida__year__gte=years,
fecha_salida__month__lte=month,
fecha_salida__year__lte=years,
)
ventas, compras = get_total_neto(ventas)
importe = float("{0:.2f}".format((float(ventas) - float(compras))))
base_imponible, importe_iva = desglose_iva(importe)
except Exception as e:
print(e)
return JsonResponse({
"years": years,
"month": month,
'ventas': ventas,
'compras': float(compras),
"importe": importe,
"beneficio": base_imponible,
"iva": importe_iva
})
return JsonError("Solo peticiones post")
def save_actuacion(request):
if request.method == "POST":
try:
actuacion = Reparaciones.objects.get(codigo=request.POST.get("codigo"))
except:
actuacion = Reparaciones()
actuacion.codigo=request.POST["codigo"]
actuacion.detalle=request.POST["detalle"]
actuacion.precio=request.POST["precio"].replace(",",".")
actuacion.save()
datos = {
"result": True,
"pk": actuacion.pk,
"codigo": actuacion.codigo,
"can": 1,
"descuento": 0,
"detalle": actuacion.detalle,
"precio": actuacion.precio,
}
return JsonResponse(datos)
return JsonError("Solo puede ser peticiones POST")
def get_producto_abonar(request):
ns_imei = request.POST['ns_imei']
cliente_id = request.session["accion_abonos_pk_cliente"]
datos = {}
try:
producto = Productos.objects.get(ns_imei=ns_imei)
except:
return JsonError("No se ha encontrado coincidencias")
linea = LineasVentas.objects.filter(
Q(ns_imei=ns_imei) & Q(venta__cliente_id=cliente_id))[0]
datos = {
"result": True,
"codigo_compra": linea.codigo_compra,
"modelo": unicode(producto),
"ns_imei": producto.ns_imei,
"precio": linea.p_unidad,
"descuento": linea.descuento,
"tipo": producto.get_descripcion_tipo(),
"es_unico": producto.es_unico
}
return JsonResponse(datos)
def arquear(request):
if request.method == 'POST':
arq = json.loads(request.POST["data"])
efectivo = Pedidos.objects.filter(estado__contains="PG_")
efectivo = efectivo.exclude(modo_pago="Tarjeta").aggregate(
Sum("total"))
efectivo = efectivo[
"total__sum"] if efectivo["total__sum"] != None else 0
tarjeta = Pedidos.objects.filter(estado__contains="PG_")
tarjeta = tarjeta.exclude(modo_pago="Efectivo").aggregate(Sum("total"))
tarjeta = tarjeta["total__sum"] if tarjeta["total__sum"] != None else 0
caja_dia = float(efectivo) + float(tarjeta) + float(
arq['caja_dia']) + float(arq['tarjeta'])
ef_fisico = float(arq['efectivo']) - float(arq['cambio'])
tarjeta = float(tarjeta) + float(arq['tarjeta'])
ef_tickado = float(efectivo) + float(arq['caja_dia'])
descuadre = (ef_fisico + float(arq['total_gastos'])) - ef_tickado
arqueo = Arqueos(
**{
'caja_dia': caja_dia,
'efectivo': ef_fisico,
'cambio': arq['cambio'],
'total_gastos': arq['total_gastos'],
'tarjeta': tarjeta,
'descuadre': descuadre,
})
arqueo.save()
for c in arq["conteo"]:
conteo = Conteo(**c)
conteo.save()
arqueo.conteo.add(conteo)
for c in arq["extras"]:
c["importe"] = c["importe"].replace(",", ".")
e = PedidosExtra(**c)
e.save()
arqueo.pedidosextra.add(e)
for c in arq["gastos"]:
g = Gastos(**c)
g.save()
arqueo.gastos.add(g)
for c in Pedidos.objects.filter(estado__contains="PG_"):
c.estado = "AR_SN"
c.save()
arqueo.pedidos.add(c)
desglose = []
retirar = 0
for ls in arq["conteo"]:
if ef_fisico - retirar > 0.1:
total_linea = ls["total"]
subtotal = retirar + total_linea
if subtotal <= ef_fisico:
retirar += total_linea
desglose.append(ls)
else:
subtotal = ef_fisico - retirar
tipo = float(ls["tipo"])
num = int(subtotal / tipo)
if num > 0:
total_linea = num * tipo
retirar += total_linea
desglose.append({
"can": num,
"tipo": tipo,
"total": total_linea,
"texto_tipo": ls["texto_tipo"]
})
return JsonResponse({'desglose': desglose})
return JsonError("NO ESTA AUTORIZADO")
def token(request, token, user):
if authenticate(pk=user, token=token) is not None:
return JsonResponse({})
else:
return JsonError("Token did not match user.")
