def change_language(request):
"""
This is a modified version of i18n's version of set_language which
supports GET requests as well.
Original description:
Redirect to a given url while setting the chosen language in the
session or cookie. The url and the language code need to be
specified in the request parameters.
"""
response = HttpResponseRedirect(get_next_url(request))
lang_code = request.POST.get('language', request.GET.get("language", None))
if lang_code and check_for_language(lang_code):
if hasattr(request, 'session'):
request.session[LANGUAGE_SESSION_KEY] = lang_code
else:
cookieKwargs = {}
_set_key(cookieKwargs, "max_age", "LANGUAGE_COOKIE_AGE")
_set_key(cookieKwargs, "path", "LANGUAGE_COOKIE_PATH")
_set_key(cookieKwargs, "domain", "LANGUAGE_COOKIE_DOMAIN")
response.set_cookie(
settings.LANGUAGE_COOKIE_NAME, lang_code, **cookieKwargs
)
return response
def process_response(self, request, response):
if request.method == 'POST':
language = request.POST.get('language')
action = request.POST.get('action')
if action == 'set_language' and check_for_language(language):
host = request.get_host()
next_url = request.GET.get('next', None)
referer = request.META.get('HTTP_REFERER', None)
if next_url:
if is_safe_url(url = next_url, host = host):
response = HttpResponseRedirect(next_url)
elif referer:
if is_safe_url(url = referer, host = host):
referer_url = urlparse(referer)[2]
try:
# http://wenda.soso.io/questions/275666/django-templates-get-current-url-in-another-language
view = resolve(referer_url)
with translation.override(language):
next_url = reverse(view.view_name, args = view.args, kwargs = view.kwargs)
response = HttpResponseRedirect(next_url)
except (Resolver404, NoReverseMatch):
pass
if hasattr(request, 'session'):
request.session[translation.LANGUAGE_SESSION_KEY] = language
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, language, max_age = settings.LANGUAGE_COOKIE_AGE, path = settings.LANGUAGE_COOKIE_PATH, domain = settings.LANGUAGE_COOKIE_DOMAIN)
return response
def get(self, *args, **kwargs):
lang = kwargs.pop('lang')
next_url = self.request.GET.get('next')
if (next_url or not self.request.is_ajax()) and not is_safe_url(url=next_url, host=self.request.get_host()):
next_url = self.request.META.get('HTTP_REFERER')
if next_url:
next_url = urlunquote(next_url) # HTTP_REFERER may be encoded.
if not is_safe_url(url=next_url, host=self.request.get_host()):
next_url = '/'
response = HttpResponseRedirect(next_url) if next_url else HttpResponse(status=204)
if lang and check_for_language(lang):
if next_url:
if lang == 'ru':
next_trans = re.sub("/en/", "/", next_url)
else:
next_trans = translate_url(next_url, lang)
if next_trans != next_url:
response = HttpResponseRedirect(next_trans)
translation.activate(lang)
if hasattr(self.request, 'session'):
self.request.session[translation.LANGUAGE_SESSION_KEY] = lang
else:
response.set_cookie(
settings.LANGUAGE_COOKIE_NAME, lang,
max_age=settings.LANGUAGE_COOKIE_AGE,
path=settings.LANGUAGE_COOKIE_PATH,
domain=settings.LANGUAGE_COOKIE_DOMAIN,
)
return response
def login(req):
if req.method =='POST':
username = req.POST.get('username')
password = req.POST.get('password')
user = auth.authenticate(username=username,password=password)
if user is not None:
response = HttpResponseRedirect('/index/')
u = auth.admin.User.get_short_name(user)
print u
response.set_cookie("username", u, 3600)
return response
else:
return HttpResponseRedirect('/login/')
return render_to_response('login.htm',{})
def login(request):
"""
登录页面
:param request:
:return:
"""
if request.method == "POST":
username = request.POST['username']
password = request.POST['password']
key = checkUserPassword(username, password)
print('login key ', key)
if key:
response = HttpResponseRedirect('/ClubInterface/index/')
response.set_cookie('key', value=key)
response.set_cookie('name', value=username)
return response
else:
return HttpResponse("ERROR")
else:
return render(request, 'ClubInterface/login.html')
def process_response(self, request, response):
"""
Set compact P3P policies and save auth token to cookie.
P3P is a WC3 standard (see http://www.w3.org/TR/P3P/), and although largely ignored by most
browsers it is considered by IE before accepting third-party cookies (ie. cookies set by
documents in iframes). If they are not set correctly, IE will not set these cookies.
"""
if hasattr(request, "facebook") and request.facebook and request.facebook.oauth_token:
if "code" in request.REQUEST:
""" Remove auth related query params """
path = get_full_path(request, remove_querystrings=['code', 'web_canvas'])
response = HttpResponseRedirect(path)
response.set_cookie('facebook_oauth_token', request.facebook.oauth_token.token)
else:
response.delete_cookie('facebook_oauth_token')
response['P3P'] = 'CP="IDC CURa ADMa OUR IND PHY ONL COM STA"'
return response
def post(self, request):
source_url = request.POST.get('url', '')
if not source_url:
return HttpResponseBadRequest()
if not settings.COOKIE_NAME_FOR_UUID in self.request.COOKIES.keys():
user_uuid = uuid.uuid4()
else:
user_uuid = request.COOKIES.get(settings.COOKIE_NAME_FOR_UUID)
if request.user.is_authenticated():
# associate url with user
ShortenUrl.objects.shorten_url(url=source_url, user=request.user)
else:
# associate url with user_uuid when user is not authenticated
ShortenUrl.objects.shorten_url(url=source_url, user_uuid=user_uuid)
response = HttpResponseRedirect(reverse('index'))
response.set_cookie(settings.COOKIE_NAME_FOR_UUID, user_uuid, max_age=31536000)
return response
def logout(req):
response = HttpResponseRedirect('/login/')
response.delete_cookie('username')
return response
def logout(req):
response = HttpResponseRedirect("/")
response.delete_cookie("username", "/")
response.delete_cookie("userid", "/")
return response
def index(request): #Generates the index page
if request.user.is_authenticated:
return HttpResponseRedirect('/courses')
return render(request, 'index.html')
def user_upload_avatar(request):
if not is_authenticated(request):
return HttpResponseRedirect('..')
nav = 'upload_avatar'
user = get_login_user(request)
return render_to_response('user/upload_avatar.html', locals())
def inactivar_taller(request, taller_id):
taller = Taller.objects.get(id=taller_id)
taller.estado = 1
taller.save()
return HttpResponseRedirect(reverse_lazy('tallers:taller'))
def get(self, request, *args, **kwargs):
if self.request.user.is_authenticated():
return HttpResponseRedirect(reverse('helpdesk'))
context = self.get_context_data(**kwargs)
return self.render_to_response(context)
def user_info(request):
if not is_authenticated(request):
return HttpResponseRedirect('..')
nav = 'info'
return HttpResponseRedirect('info_update')
def signout(request): #로그아웃 기능
logout(request)
return HttpResponseRedirect(reverse('index'))
def get(self, request, *args, **kwargs):
shipment = self.get_object()
return HttpResponseRedirect(get_model_url(shipment.order))
def wrapper(request):
if request.oauth_user is None: # 重定向到微信认证页面
return HttpResponseRedirect(reverse('authenticate'))
else:
return func(request)
def logout(self, request):
self.logger.info('用户' + request.session['username'] + '退出登录成功')
from django.contrib import auth
auth.logout(request)
return HttpResponseRedirect(reverse('login'))
def profile(request):
if request.user.is_authenticated():
return HttpResponseRedirect("/home",
{'success': 'Successfully LoggedIn.'})
else:
return render(request, 'login.html')
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.1/howto/static-files/
STATIC_ROOT = os.path.join(BASE_DIR, "staticfiles")
STATIC_URL = "/static/"
STATICFILES_STORAGE = "whitenoise.storage.CompressedManifestStaticFilesStorage"
STRIPE_PUBLIC_KEY = "pk_test_4kN2XG1xLysXr0GWDB07nt61"
SENDGRID_EMAIL_USERNAME = config("EMAIL_HOST_USER")
SENDGRID_EMAIL_HOST = "smtp.sendgrid.net"
SENDGRID_EMAIL_PASSWORD = "******"
SENDGRID_EMAIL_PORT = 587
EMAIL_USE_TLS = True
# DEFAULT_FROM_EMAIL = config("DEFAULT_FROM_EMAIL")
SENDGRID_API_KEY = config("SENDGRID_API_KEY")
SERVER_EMAIL = "*****@*****.**"
LOGIN_REDIRECT_URL = HttpResponseRedirect("http://localhost:3000")
STRIPE_WEBHOOK_SECRET = "whsec_8KHXs8U07a2iRz4fequVxXo1tjN3PLRM"
CORS_ORIGIN_WHITELIST = config(
'CORS_ORIGIN_WHITELIST', cast=lambda v: [s.strip() for s in v.split(',')])
def form_valid(self, form):
form.save()
return HttpResponseRedirect(self.success_url)
def add_reviews(request: HttpRequest, type: str, id: int) -> HttpResponse:
initial = {}
context = {}
if request.method == "POST":
form = ReviewForm(request.POST)
if type == 'reservation':
hotel_id = RoomReservation.objects.get(rr_id=id).hotel_id_id
hotel = get_object_or_404(Hotel, pk=hotel_id)
room_no = RoomReservation.objects.get(rr_id=id).room_no_id
#room = get_object_or_404(Room,room_no= room_no)
room_res = get_object_or_404(RoomReservation, pk=id)
roomreview, created = RoomReview.objects.get_or_create(
cid=request.user, rr_id=room_res)
if form.is_valid():
roomreview.hotel_id = hotel
roomreview.rr_id = room_res
roomreview.rating = form.data['rating']
roomreview.text_content = form.data['text']
roomreview.cid = request.user
roomreview.save()
return HttpResponseRedirect(f'/reservations/review/')
if type == 'service':
svc_id = get_object_or_404(ReservationService, pk=id)
servicereview, created = ServiceReview.objects.get_or_create(
cid=request.user, sid=svc_id)
if form.is_valid():
servicereview.cid = request.user
servicereview.sid = svc_id
servicereview.rating = form.data['rating']
servicereview.text_content = form.data['text']
servicereview.cid = request.user
servicereview.save()
return HttpResponseRedirect(f'/reservations/review')
if type == 'breakfast':
brk_id = get_object_or_404(ReservationBreakfast, pk=id)
breakfastreview, created = BreakfastReview.objects.get_or_create(
cid=request.user, bid=brk_id)
if form.is_valid():
breakfastreview.cid = request.user
breakfastreview.bid = brk_id
breakfastreview.rating = form.data['rating']
breakfastreview.text_content = form.data['text']
breakfastreview.cid = request.user
breakfastreview.save()
return HttpResponseRedirect(f'/reservations/review')
return HttpResponse('something unexptected.')
else:
user = request.user
initial['user'] = user
form = ReviewForm(initial=initial)
if type == 'reservation':
room_reservations = form.get_room_reservations(user)
values = room_reservations.get(id)
form.fields['hotel_id'] = CharField(
initial=values[0],
required=False,
widget=forms.TextInput(attrs={'readonly': 'readonly'}))
form.fields['room_no'] = CharField(
initial=values[1],
required=False,
widget=forms.TextInput(attrs={'readonly': 'readonly'}))
if type == 'service':
room_services = form.get_room_services(user)
values = room_services.get(id)
form.fields['reserviation_id'] = CharField(
initial=values[0],
required=False,
widget=forms.TextInput(attrs={'readonly': 'readonly'}))
form.fields['service'] = CharField(
initial=values[1],
required=False,
widget=forms.TextInput(attrs={'readonly': 'readonly'}))
if type == 'breakfast':
room_breakfasts = form.get_room_breakfast(user)
values = room_breakfasts.get(id)
form.fields['reserviation_id'] = CharField(
initial=values[0],
required=False,
widget=forms.TextInput(attrs={'readonly': 'readonly'}))
form.fields['breakfast'] = CharField(
initial=values[1],
required=False,
widget=forms.TextInput(attrs={'readonly': 'readonly'}))
context['form'] = form
return render(request, 'add_reviews.html', context)
def post(self, request, *args, **kwargs):
shipment = self.get_object()
shipment.soft_delete()
messages.success(request,
_("Shipment %s has been deleted.") % shipment.pk)
return HttpResponseRedirect(get_model_url(shipment.order))
def forms_valid(self, forms, form_name):
form_valid_method = "%s_form_valid" % form_name
if hasattr(self, form_valid_method):
return getattr(self, form_valid_method)(forms[form_name])
else:
return HttpResponseRedirect(self._get_success_url(form_name))
def get(self, request):
# django自带的logout
logout(request)
# 重定向到首页
return HttpResponseRedirect(reverse('index'))
def logout(request):
if 'user' in request.session:
del request.session['user']
return HttpResponseRedirect('.')
def post(self, request):
contact_name = request.POST.get("member")
return HttpResponseRedirect("groups/search/?name=" + contact_name)
def user_change_password(request):
if not is_authenticated(request):
return HttpResponseRedirect('..')
nav = 'change_password'
user = get_login_user(request)
return render_to_response('user/change_password.html', locals())
def form_valid(self, form, detalle_venta_form_set):
#obtenemos la ultima de su serie prara generar un nuevo numero
qsComp_last = Venta.objects.filter(
lfact=form.instance.titular.letra).order_by('nfact').last()
if qsComp_last:
form.instance.nfact = qsComp_last.nfact + 1
else:
form.instance.nfact = 1
form.instance.lfact = form.instance.titular.letra
self.object = form.save()
detalle_venta_form_set.instance = self.object
detalle_venta_form_set.save()
total_base = 0
detalles = DetalleVenta.objects.filter(
venta=self.object).order_by('pk')
for detalle in detalles:
d = {
'producto': detalle.producto,
'cantidad': detalle.cantidad,
'precio_venta': detalle.precio_venta
}
# Restamos los kilos de cada detalle en su almacen (silo)
detalle.producto.kilos -= detalle.cantidad
detalle.producto.save()
# si el producto sale de un silo con lote
if detalle.producto.lote:
detalle.lote_heredado = detalle.producto.lote
print("detalle lote", detalle.lote_heredado)
detalle.save()
#detalle.save(update_fields=["lote_heredado"])
#DetalleVenta.objects.get(pk=detalle.pk).save(update_fields=["lote_heredado"])
Historico.objects.create(venta=detalle.venta,
producto=detalle.producto,
cantidad=detalle.cantidad,
precio_venta=detalle.precio_venta,
fecha=detalle.fecha,
lote_heredado=detalle.lote_heredado,
kilos_actuales=detalle.producto.kilos)
#calculamos su precio base
total_detalle = detalle.cantidad * detalle.precio_venta
print("valores en €")
print(detalle.producto, total_detalle)
total_base = total_base + total_detalle
print("base ", total_base)
#aplicamos impuestos
form.instance.base = total_base
form.instance.imp_aplicado = total_base * form.instance.impuestos.impuesto1 / 100
print("valor de impuestto 1 ", form.instance.imp_aplicado)
#Comprobamos si hay un segundo impuesto a aplicar
if form.instance.impuestos.impuesto2:
if form.instance.impuestos.se_calcula_con == "BASE":
form.instance.imp_aplicado = form.instance.imp_aplicado + total_base * form.instance.impuestos.impuesto2 / 100
print("calculando impuesto 2 BASE ",
form.instance.imp_aplicado)
if form.instance.impuestos.se_calcula_con == "TOTAL":
form.instance.imp_aplicado = form.instance.imp_aplicado + (
form.instance.imp_aplicado +
total_base) * form.instance.impuestos.impuesto2 / 100
print("calculando impuesto 2 TOTAL",
form.instance.imp_aplicado)
form.instance.total = total_base + form.instance.imp_aplicado
print("impuestos ", form.instance.imp_aplicado)
print("total", form.instance.total)
form.instance.save()
return HttpResponseRedirect(self.success_url)
def user_management(request):
user = request.session.get('user')
if user is None:
return HttpResponseRedirect('login')
if user['role']['id'] not in (User.ADMINISTRATOR, ):
return HttpResponseRedirect('')
role_options = [{
'name': '',
'display_name': u'全部'
}, {
'name': 'admin',
'display_name': u'管理员',
'id': User.ADMINISTRATOR
}, {
'name': 'doctor',
'display_name': u'医生',
'id': User.DOCTOR
}, {
'name': 'advisor',
'display_name': '咨询师',
'id': User.ADVISOR
}, {
'name': 'patient',
'display_name': '微服务用户',
'id': User.PATIENT
}]
roles = role_options[1:]
current_role = request.GET.get('role', '')
query = request.GET.get('query', '')
all_users = User.objects.filter(deleted=0)
users = all_users
if query:
users = users.filter(
Q(name__contains=query) | Q(guid__contains=query)
| Q(username__contains=query))
if current_role == 'admin':
users = users.filter(role=User.ADMINISTRATOR)
elif current_role == 'doctor':
users = users.filter(role=User.DOCTOR)
elif current_role == 'advisor':
users = users.filter(role=User.ADVISOR)
elif current_role == 'patient':
users = users.filter(role=User.PATIENT)
users = map(lambda u: view_model(u), users)
# For some special roles, they have their own behaviors
all_overseers = map(
lambda u: view_model(u),
filter(lambda u: u.role in (User.DOCTOR, User.ADVISOR), all_users))
patient_users = filter(lambda u: u['role']['name'] == 'patient', users)
for p_user in patient_users:
patient = Patient.objects.get(user_id=p_user['id'])
p_user['overseers'] = map(
lambda r: view_model(r.overseer),
RE_OverseePatients.objects.filter(patient_id=patient.id,
overseer__deleted=0,
deleted=0))
# p_user['overseer_ids'] = map(lambda u: u.id, p_user['overseers'])
p_user['patient'] = patient
doctor_and_advisor_users = filter(
lambda u: u['role']['name'] in ('doctor', 'advisor'), users)
for overseer in doctor_and_advisor_users:
oversee_records = RE_OverseePatients.objects.filter(
overseer_id=overseer['id'], patient__deleted=0, deleted=0)
overseeing_patients = map(lambda r: r.patient, oversee_records)
overseer['overseeing_patients'] = overseeing_patients
all_patients = Patient.objects.filter(deleted=0)
return render_to_response('user_management.html', locals())
def form_valid(self, form, detalle_compra_form_set):
#obtenemos la ultima de su serie prara generar un nuevo numero
qsComp_last = Compra.objects.filter(
lfact=form.instance.titular.letra).order_by('nfact').last()
if qsComp_last:
form.instance.nfact = qsComp_last.nfact + 1
else:
form.instance.nfact = 1
form.instance.lfact = form.instance.titular.letra
self.object = form.save()
detalle_compra_form_set.instance = self.object
detalle_compra_form_set.save()
total_base = 0
detalles = DetalleCompra.objects.filter(
compra=self.object).order_by('pk')
for detalle in detalles:
d = {
'producto': detalle.producto,
'cantidad': detalle.cantidad,
'precio_compra': detalle.precio_compra
}
#sumamos los kilos de cada detalle en su almacen(silo)
#p = Producto.objects.get(descripcion=detalle.producto)
#p.kilos = p.kilos + detalle.cantidad
#p.save()
detalle.producto.kilos += detalle.cantidad
detalle.producto.save()
# si el producto entra a un silo con lote
if detalle.producto.lote:
detalle.lote_heredado = detalle.producto.lote
print("detalle lote", detalle.lote_heredado)
detalle.save()
#detalle.save(update_fields=["lote_heredado"])
#DetalleVenta.objects.get(pk=detalle.pk).save(update_fields=["lote_heredado"])
#qs = DetalleVenta.objects.get(pk =detalle.pk)
#print("guardado en historico ", qs.producto, qs.cantidad, qs.precio_venta, qs.lote_heredado)
Historico.objects.create(compra=detalle.compra,
producto=detalle.producto,
cantidad=detalle.cantidad,
precio_compra=detalle.precio_compra,
fecha=detalle.fecha,
lote_heredado=detalle.lote_heredado,
kilos_actuales=detalle.producto.kilos)
#calculamos su precio base
total_detalle = detalle.cantidad * detalle.precio_compra
print("valores en €")
print(detalle.producto, total_detalle)
total_base = total_base + total_detalle
print("base ", total_base)
#aplicamos impuestos
form.instance.base = total_base
form.instance.imp_aplicado = total_base * form.instance.impuestos.impuesto1 / 100
print("valor de impuestto 1 ", form.instance.imp_aplicado)
#Comprobamos si hay un segundo impuesto a aplicar
if form.instance.impuestos.impuesto2:
if form.instance.impuestos.se_calcula_con == "BASE":
form.instance.imp_aplicado = form.instance.imp_aplicado + total_base * form.instance.impuestos.impuesto2 / 100
print("calculando impuesto 2 BASE ",
form.instance.imp_aplicado)
if form.instance.impuestos.se_calcula_con == "TOTAL":
form.instance.imp_aplicado = form.instance.imp_aplicado + (
form.instance.imp_aplicado +
total_base) * form.instance.impuestos.impuesto2 / 100
print("calculando impuesto 2 TOTAL",
form.instance.imp_aplicado)
form.instance.total = total_base + form.instance.imp_aplicado
print("impuestos ", form.instance.imp_aplicado)
print("total", form.instance.total)
form.instance.save()
############# PDF ###################
# obtenemos los detalles de esta facuta para crear un nested dict
detalles = DetalleCompra.objects.filter(compra=form.instance.pk)
lineas = {}
i = 1
for d in detalles:
detalle_total = d.precio_compra * d.cantidad
lineas['linea' + str(i)] = {
'producto': d.producto.variedad,
'cantidad': d.cantidad,
'precio': d.precio_compra,
'total': detalle_total,
'lote_heredado': d.lote_heredado
}
i = i + 1
compra = Compra.objects.get(pk=form.instance.pk)
context = {
'numero': compra.nfact,
'fecha': compra.fecha,
'forma_pago': compra.forma_pago,
'titular_nombre': compra.titular.nombre,
'titular_cif': compra.titular.cif,
'titular_direccion': compra.titular.direccion,
'proveedor_nombre': compra.proveedor.razon_social,
'proveedor_ruc': compra.proveedor.ruc,
'proveedor_direccion': compra.proveedor.direccion,
'proveedor_certificado': compra.proveedor.entidad_certificadora,
'base': compra.base,
'impuestos': compra.impuestos,
'imp_aplicado': compra.imp_aplicado,
'total': compra.total,
'lineas': lineas
}
print(context)
'''context = {
'acta': qsacta,
'laboratorio': qslaboratorio,
'muestreo': qsmuestreo,
'pk': pk,
'tipo': tipo
}'''
template_path = 'plantilla_email.html'
template = get_template(template_path)
# html = template.render(form.instance.__dict__)
html = template.render(context)
# print(form.instance.__dict__)
## definir los datos del diccionario, este no sirve
## hacer bien los estilos, los de boostrap no funcionan
## los estilos que soporta estan bastante limitados
## https://xhtml2pdf.readthedocs.io/en/latest/reference.html#supported-css-properties
ndocumento1 = "factura" + str(form.instance.nfact) + ".pdf"
#ddocumento = os.path.join(settings.MEDIA_ROOT, ndocumento1)
ddocumento = ndocumento1
outFilename = ddocumento
outFile = open(outFilename.encode("utf-8"), "w+b")
pisaStatus = pisa.CreatePDF(html.encode('utf-8'),
dest=outFile,
encoding='utf-8')
outFile.close()
ndocumento = ddocumento
# ddocumento = os.path.join(settings.MEDIA_ROOT, ndocumento)
leerdocumento = open(ddocumento.encode("utf-8"), "rb").read()
############### EMAIL ##################33
b = base64.b64encode(leerdocumento).decode("utf-8", "ignore")
nombredocumento = "factura" + str(form.instance.nfact) + ".pdf"
email = "*****@*****.**"
asunto = "Factura de compra"
cuerpo = "Buenos dias, adjuntamos factura de compra"
body = cuerpo
# Replace this texto in plantilla cuerpo
body_content = mark_safe(body)
html_content = mark_safe(body_content)
remitente = settings.EMAIL_HOST_USER
destinatario = email
try:
msg = EmailMessage(asunto, html_content, remitente, [destinatario])
msg.attach(nombredocumento, leerdocumento, "application/pdf")
msg.content_subtype = "pdf" # Main content is now text/html
msg.encoding = 'utf-8'
msg.send()
print("mensaje enviado ")
except Exception as e:
print("no se ha podido enviar ", e)
return HttpResponseRedirect(self.success_url)
def get(self, request, *args, **kwargs):
return HttpResponseRedirect(self.get_object().url)
def view_resumes(request, job_post_id):
job_post = get_object_or_404(JobPost, id=job_post_id)
selected_skills = []
agency_resumes = AppliedJobs.objects.filter(job_post=job_post)
if request.POST.get('recruiters'):
agency_resumes = agency_resumes.filter(
applicant__uploaded_by_id=request.POST.get('recruiters'))
if request.POST.get('experience'):
agency_resumes = agency_resumes.filter(
applicant__experience=request.POST.get('experience'))
if request.POST.getlist('skills'):
skills = Skill.objects.filter(id__in=request.POST.getlist('skills'))
agency_resumes = agency_resumes.filter(applicant__skill__in=skills)
selected_skills = request.POST.getlist('skills')
if request.POST.get('apply_job'):
if request.POST.get('jobposts_type'):
for each in request.POST.getlist('apply_job'):
agency_applicant = AgencyApplicants.objects.get(
id=each, job_post=job_post)
agency_applicant.status = request.POST.get('jobposts_type')
agency_applicant.save()
agency_applicant.applicant.status = 'Pending'
agency_applicant.applicant.save()
if str(request.POST.get('jobposts_type')) == 'Hired':
applicants = AgencyApplicants.objects.filter(
id__in=request.POST.getlist('apply_job')).values_list('applicant', flat=True)
applicant_agency_resumes = AgencyResume.objects.filter(
id__in=applicants)
applicant_agency_resumes.update(
status=request.POST.get('jobposts_type'))
no_of_jobs = len(agency_resumes)
items_per_page = 10
no_pages = int(math.ceil(float(len(agency_resumes)) / items_per_page))
try:
if int(request.GET.get('page')) > (no_pages + 2):
page = 1
return HttpResponseRedirect(reverse('jobs:index'))
else:
page = int(request.GET.get('page'))
except:
page = 1
agency_resumes = agency_resumes[
(page - 1) * items_per_page:page * items_per_page]
prev_page, previous_page, aft_page, after_page = get_prev_after_pages_count(
page, no_pages)
skills = Skill.objects.filter(status='Active')
recruiters = User.objects.filter(company=request.user.company)
return render(request, "recruiter/company/job_resume_view.html", {'job_post': job_post,
'agency_resumes': agency_resumes,
'recruiters': recruiters,
'years': YEARS,
'skills': skills,
'aft_page': aft_page,
'after_page': after_page,
'prev_page': prev_page,
'previous_page': previous_page,
'current_page': page,
'last_page': no_pages,
'no_of_jobs': no_of_jobs,
'status': POST,
'selected_skills': selected_skills
})
def logout_view(request):
logout(request)
return HttpResponseRedirect(reverse("loginView"))
def add(self, request):
title_name = "新增" + self.model_cnname + "信息："
if request.method == 'POST':
post_form = self.import_forms(request.POST, request.FILES)
if post_form.is_valid():
# 这段代码完全是为了处理字段类型为filefiled，如果不需要使用filefiled的话，直接post_form.save()
new_value = {}
media_dir = MEDIA_ROOT.replace(BASE_DIR + '/', '')
for key in self.detail_field_list:
post_key = key.replace('_id', '')
# 对于外键来说，字段名是以_id结尾的，但forms提交是不带_id的，需要根据外键表的名字查找外键表的ID，然后判断和数据库是否一致，如果一致不修改。让request.POST字典的key和detail_field_list相同，让新字典的key值等于post的post_key相等
if hasattr(
self,
'filefield_dict') and key in self.filefield_dict:
# 处理filefield
filename = key + '_' + str(request.FILES[key])
# 文件名，字段名+上传文件名
file = request.FILES[key]
upload_dir = MEDIA_ROOT + '/upload/' + self.app_name + '/' + self.model_name + '/' + request.POST.get(
'name') + '/'
# 上传目录，MEDIA_ROOT/upload/app名/modles名/字段name的值/
from .webpage import uploadfile
fullfilename = uploadfile(file, filename, upload_dir)
# 最终目录为MEDIA_ROOT.replace(BASE_DIR,'')/upload/app名/modles名/字段name的值/字段名_上传文件名，防止出现重复替换操作
value = media_dir + '/upload/' + self.app_name + '/' + self.model_name + '/' + request.POST.get(
'name') + '/' + filename
# 数据库中写相对路径
else:
value = request.POST.get(post_key)
value_str = str(value)
# 日期转换
if re.search('^[0-9][0-9][0-9][0-9]/[0-1][0-9]',
value_str):
from .handle_datetime import date_convert
value = date_convert(value_str, '%Y-%m-%d')
new_value[key] = value
try:
self.import_models.objects.create(**new_value)
except Exception as e:
write_log(
'warning', self.op_user, self.model_cnname +
'新增数据失败，' + str(new_value) + '，原因如下：\n' + str(e))
# post_form.save()
return HttpResponseRedirect(reverse('list_' + self.model_name))
else:
errors_message = post_form.errors
write_log(
'warning', self.op_user, self.model_cnname + '新增失败' +
str(post_form) + '，原因如下：\n' + str(errors_message))
return render(request, 'result.html',
{'error_message': str(errors_message)})
else:
get_form = self.import_forms()
request_dict = {'title_name': title_name, 'get_form': get_form}
return render(request, 'add_edit.html', request_dict)
def get(self, request):
response = HttpResponseRedirect('/')
response.set_cookie('sessionid', None)
return response
def edit(self, request):
edit_id = request.GET.get('id')
query_set = self.import_models.objects.select_related().using(
'mysql_read').filter(id=edit_id).values().distinct()
query_set = list(query_set)[0]
if request.method == 'GET':
url_front = self.app_basedir + self.model_name
title_name = '编辑' + self.model_cnname + '【' + query_set[
'name'] + '】信息：'
try:
instance = self.import_models.objects.select_related().using(
'mysql_read').get(id=edit_id)
get_form = self.import_forms(instance=instance)
request_dict = {
'title_name': title_name,
'get_form': get_form,
'url_front': url_front
}
return render(request, 'add_edit.html', request_dict)
except Exception as e:
write_log(
'warning', self.op_user,
self.model_cnname + '编辑:' + str(edit_id) + '失败' + str(e))
return HttpResponseRedirect(reverse('list_' + self.model_name))
if request.method == 'POST':
new_value = {}
media_dir = MEDIA_ROOT.replace(BASE_DIR + '/', '')
for key in self.detail_field_list:
post_key = key.replace('_id', '')
query_value = query_set[key]
query_value = str(query_value)
if not query_value:
query_value = ''
if hasattr(self,
'filefield_dict') and key in self.filefield_dict:
# 这个if的内容主要处理文件上传，即字段类型为filefiled的。
try:
# 使用try是因为在编辑时，不上传图片，导致报错
filename = key + '_' + str(request.FILES[key])
# 文件名，字段名+上传文件名
file = request.FILES[key]
upload_dir = MEDIA_ROOT + '/upload/' + self.app_name + '/' + self.model_name + '/' + request.POST.get(
'name') + '/'
# 上传目录，MEDIA_ROOT/upload/app名/modles名/字段name的值/
from library.webpage import uploadfile
fullfilename = uploadfile(file, filename, upload_dir)
# 最终目录为MEDIA_ROOT.replace(BASE_DIR,'')/upload/app名/modles名/字段name的值/字段名_上传文件名，防止出现重复替换操作
new_value[
key] = media_dir + '/upload/' + self.app_name + '/' + self.model_name + '/' + request.POST.get(
'name') + '/' + filename
# 数据库中写相对路径
except:
# 如果没有上传文件，把新值等于数据库中的值
new_value[key] = query_value
elif hasattr(self,
'deny_edit_list') and key in self.deny_edit_list:
# 属于禁止修改的字段，不允许修改
pass
elif hasattr(self, 'forgkey_field_list'
) and post_key in self.forgkey_field_list:
# 对于外键来说，数据库中的字段名是以_id结尾的，但forms提交是不带_id的，需要根据外键表的名字查找外键表的ID，然后判断和数据库是否一致，如果一致不修改
post_value = request.POST.get(post_key)
if query_value != str(post_value):
if post_value == '':
new_value[key] = ''
else:
new_value[key] = int(post_value)
else:
value = request.POST.get(key)
value_str = str(value)
if re.search('^[0-9][0-9][0-9][0-9]/[0-1][0-9]',
value_str):
from library.handle_datetime import date_convert
value = date_convert(value_str, '%Y-%m-%d')
if query_value != str(value):
new_value[key] = value
if new_value:
try:
self.import_models.objects.filter(id=edit_id).update(
**new_value)
except Exception as e:
write_log(
'warning', self.op_user, self.model_cnname + '修改ID:' +
edit_id + '失败，' + str(new_value) + '，原因如下：\n' + str(e))
else:
write_log('debug', self.op_user,
self.model_cnname + '无需修改ID:' + edit_id + '，数据没有更新')
return HttpResponseRedirect(reverse('list_' + self.model_name))
def init_yup_web_payment(request, *args, **kwargs):
api_url = getattr(settings, 'YUP_API_URL',
'https://33026.tagpay.fr/online/online.php')
yup = json.loads(PaymentMean.objects.get(slug=YUP).credentials)
phone = UNKNOWN_PHONE
service = get_service_instance()
request.session['phone'] = phone
amount = int(request.session['amount'])
model_name = request.session['model_name']
object_id = request.session['object_id']
if request.user.is_authenticated():
username = request.user.username
language = request.user.language
else:
username = None
language = 'en'
# Request a session id
try:
params = {'merchantid': yup['merchant_id']}
session_id_request = requests.get(api_url, params=params, verify=False)
except requests.exceptions.HTTPError as errh:
logger.error("YUP: Http Error:", errh)
return HttpResponseRedirect(request.session['cancel_url'])
except requests.exceptions.ConnectionError as errc:
logger.error("Error Connecting:", errc)
return HttpResponseRedirect(request.session['cancel_url'])
except requests.exceptions.Timeout as errt:
logger.error("Timeout Error:", errt)
return HttpResponseRedirect(request.session['cancel_url'])
except requests.exceptions.RequestException as err:
logger.error("OOps: Something Else", err)
return HttpResponse(request.session['cancel_url'])
session_id_resp_message = session_id_request.text
if session_id_resp_message[:2] == "NO":
logger.debug(
"YUP: Unable to provide a session with %s as Merchand ID" %
(yup['merchant_id']))
logger.debug("YUP: SERVER ERR TEXT is : %s" % session_id_resp_message)
return HttpResponse(
"Error, YUP: Unable to provide a session with %s as Merchand ID; Please check and restart"
% (yup['merchant_id']))
else:
logger.debug("YUP: Session ID OK; ")
session_id = session_id_resp_message.replace('OK:', '')
payments_conf = getattr(settings, 'PAYMENTS', None)
if payments_conf:
conf = request.session['payment_conf']
path = payments_conf[conf]['after']
else:
path = getattr(settings, 'MOMO_AFTER_CASH_OUT')
with transaction.atomic(using='wallets'):
try:
momo_tx = MoMoTransaction.objects.using('wallets').get(
object_id=object_id)
except MoMoTransaction.DoesNotExist:
momo_tx = MoMoTransaction.objects.using('wallets').create(
service_id=service.id,
type=MoMoTransaction.CASH_OUT,
phone=phone,
amount=amount,
model=model_name,
object_id=object_id,
wallet=YUP,
username=username,
callback=path)
except MoMoTransaction.MultipleObjectsReturned:
momo_tx = MoMoTransaction.objects.using('wallets').filter(
object_id=object_id)[0]
request.session['tx_id'] = momo_tx.id
accept_url = request.session['return_url']
# accept_url += '/%d' % momo_tx.id
company_name = slugify(service.config.company_name).replace('-', ' ')
logger.debug("YUP: Initiating paymentof %dF with %s as Merchand ID" %
(amount, yup['merchant_id']))
context = {
'api_url': api_url,
'sessionid': session_id,
'merchantid': yup['merchant_id'],
'amount': amount,
'currency': CURRENCY,
'purchaseref': object_id,
'phone': phone,
'brand': company_name,
'description': '',
'declineurl': request.session['cancel_url'],
'cancelurl': request.session['cancel_url'],
'accepturl': accept_url,
'text': '',
'language': language
}
return render(request, 'billing/yup/do_redirect.html', context)
def post(self, request: HttpRequest, *args: Tuple, **kwargs: Dict[str,
Any]):
form = ReservationForm(request.POST)
hotel = get_object_or_404(Hotel, hotel_id=kwargs['hotel_id'])
# NOTE: refactor these fields
svcs = form.get_services(hotel)
form.fields['service'] = MultipleChoiceField(
required=False,
choices=svcs,
widget=forms.CheckboxSelectMultiple())
bkfst = form.get_breakfast(hotel)
form.fields['breakfast'] = EmptyChoiceField(
required=False, choices=bkfst,
empty_label='---- none ----') #, widget=CheckboxInput()) #
rooms = form.get_rooms(hotel)
form.fields['room_choice'] = ChoiceField(required=True, choices=rooms)
if len(rooms) > 0:
disc = form.get_discounts(rooms[0][0], form.fields['check_in'],
form.fields['check_out'])
form.fields['discount'] = CharField(
initial=disc,
required=False,
widget=forms.TextInput(attrs={'readonly': 'readonly'}))
# END refactor
user = request.user
context = {}
messages = []
context = {'form': form}
if form.is_valid():
if form.cleaned_data['check_in'] < datetime.datetime.today().date(
):
messages.append('check in today or future')
if form.cleaned_data['check_in'] >= form.cleaned_data['check_out']:
messages.append('check out must be greater than check in')
# checks: cc date in future
cc_exp_date = datetime.date(
int(form.cleaned_data['credit_card_year']),
int(form.cleaned_data['credit_card_month']), 1)
if cc_exp_date < datetime.date.today():
messages.append('credit card date must be greater than today')
# we can now persist.
if len(messages) == 0:
s_list = []
for s in form.cleaned_data['service']:
s_list.append(Service.objects.get(pk=s))
new_booking = BookingRequest(
hotel,
form.cleaned_data['room_choice'],
form.cleaned_data['credit_card_number'],
form.cleaned_data['credit_card_type'],
form.cleaned_data['credit_card_month'],
form.cleaned_data['credit_card_year'],
form.cleaned_data['credit_card_code'],
form.cleaned_data['credit_card_address'],
form.cleaned_data['credit_card_name'],
request.user,
datetime.date.today(),
form.cleaned_data['check_in'],
form.cleaned_data['check_out'],
form.cleaned_data['breakfast'],
form.cleaned_data['breakfast_number_orders'],
s_list,
)
# order of saving:
# 1. credit card x
# 2. reservation x
# 3. room_reservation x
# 4. rresb_breakfast x
# 5. rresv_service x
@transaction.atomic
def save_reservation(n_req: BookingRequest):
card = CreditCard()
card.address = n_req.credit_card_address
card.cc_number = n_req.credit_card_number
card.cc_type = n_req.credit_card_type
card.cv_code = n_req.credit_card_code
exp_date = datetime.date(int(n_req.credit_card_year),
int(n_req.credit_card_month), 1)
card.expiration_date = exp_date
card.save()
resv = Reservation()
resv.cid = n_req.cust_id
resv.r_date = n_req.res_date
# grab the key
resv.cc_number = card
resv.save()
room = Room.objects.get(pk=n_req.room)
rr_resv = RoomReservation()
rr_resv.check_in_date = n_req.check_in
rr_resv.check_out_date = n_req.check_out
rr_resv.hotel_id = n_req.hotel
# grab the key
rr_resv.room_no = room
rr_resv.invoice_number = resv
rr_resv.save()
# breakfast
if len(n_req.breakfast) > 0:
br = ReservationBreakfast()
br.bid = Breakfast.objects.get(pk=n_req.breakfast)
br.nooforders = n_req.breakfast_number_orders
br.rr_id = rr_resv # resv
br.save()
# services
for s in n_req.svc_id:
resv_svc = ReservationService()
resv_svc.sid = s
resv_svc.rr_id = rr_resv # resv
resv_svc.sprice = s.s_price
resv_svc.save()
save_reservation(new_booking)
return HttpResponseRedirect(f'/reservations/bookings/')
context['messages'] = messages
return render(request, 'bookhotel.html', context)
else:
messages.append('form is invalid')
for e in form.errors:
messages.append(e)
context['messages'] = messages
return render(request, 'bookhotel.html', context)
def product_view(request, slug):
product = get_object_or_404(Product, slug=slug)
if product.draft and (not request.user.is_authenticated() or not request.user.is_staff):
raise Http404
if product.member_only and (not request.user.is_authenticated() or not request.user.is_member):
raise Http404
sale = get_sale(request) or Sale()
if sale.pk and product.quantifiable:
# See if we have any order lines already saved for this product
# if it's quantifiable. Otherwise, we don't let them edit it except
# by going to the cart and deleting it; instead, they can add a new
# one.
order_lines = []
for price in product.prices.all():
try:
order_lines.append(OrderLine.objects.get(sale=sale, product=product, price=price))
except OrderLine.DoesNotExist:
order_lines.append(OrderLine(product=product, price=price))
if not order_lines:
try:
order_lines.append(OrderLine.objects.get(sale=sale, product=product, price=None))
except OrderLine.DoesNotExist:
order_lines.append(OrderLine(product=product, price=None))
else:
order_lines = [OrderLine(product=product, price=price) for price in product.prices.all()]
if not order_lines:
order_lines.append(OrderLine(product=product))
if request.method == 'POST':
forms = [OrderLineForm(instance=x, data=request.POST) for x in order_lines]
if all(form.is_valid() for form in forms):
print("VALID!") # FIXME
# Did they actually order anything?
if any(form.has_any() for form in forms):
# YES!
# We want a sale!
if not sale.pk:
sale = Sale.objects.create()
for form in forms:
if form.has_any():
form.instance.sale = sale
form.save()
# Did they change any existing items to zero?
for form in forms:
if not form.has_any():
if form.instance.pk:
form.instance.delete()
if sale.pk:
response = HttpResponseRedirect(reverse('store'))
response.set_signed_cookie('sale', sale.pk, salt=settings.SECRET_KEY)
return response
return redirect(reverse('store'))
else:
print("SOME FORM IS NOT VALID") # FIXME
for form in forms:
print(form.errors)
else:
forms = [OrderLineForm(instance=x) for x in order_lines]
context = {
'product': product,
'forms': forms,
'sale': sale,
'PRICE_ONE': Product.PRICE_ONE,
'PRICE_MULTIPLE': Product.PRICE_MULTIPLE,
'PRICE_USER': Product.PRICE_USER,
}
response = render(request, 'store/product.html', context)
if sale.pk:
response.set_signed_cookie('sale', sale.pk, salt=settings.SECRET_KEY)
return response
def logout(request):
logout_user(request)
return HttpResponseRedirect("/")