def contacto(request):
"""
Formulario de contacto
"""
AreasFormSet = modelformset_factory(ViewPort, form=AreaInteresForm, extra=0)
TelefonoFormSet = modelformset_factory(Telefono, form=TelefonoForm)
if request.method == 'POST' and "contacto_submit" in request.POST:
form = ContactoForm(request.POST)
formset_areas = AreasFormSet(request.POST, prefix="area")
formset_telefonos = TelefonoFormSet(request.POST, prefix="tel")
if form.is_valid() and formset_telefonos.is_valid() and \
formset_areas.is_valid():
form.save(request, formset_telefonos, formset_areas)
return direct_response(request, 'portal/contacto_exito.html')
elif request.method == "POST" and "contacto_proyecto_id" in request.POST:
proyecto = Proyecto.objects.get(id=request.POST["contacto_proyecto_id"])
form = ContactoForm(initial={'proyecto': proyecto.id,
"rubros_interes": [proyecto.rubro]})
else:
form = ContactoForm()
formset_areas = AreasFormSet(queryset=ViewPort.objects.none(),
prefix="area")
formset_telefonos = TelefonoFormSet(queryset=Telefono.objects.none(),
prefix="tel")
return direct_response(request, 'portal/contacto.html',
{'form': form,
'formset_telefonos': formset_telefonos,
'formset_areas': formset_areas})
def topology(request):
"""
Get a topology for neural network from genetic algorithms
"""
if request.method == "POST":
form = TopologyForm(request.POST)
if form.is_valid():
genome = G1DList.G1DList(4)
genome.setParams(rangemin=1, rangemax=10)
genome.evaluator.set(eval_func)
ga = GSimpleGA.GSimpleGA(genome)
ga.selector.set(Selectors.GRouletteWheel)
ga.setGenerations(form.cleaned_data['generations'])
ga.terminationCriteria.set(GSimpleGA.ConvergenceCriteria)
ga.evolve(freq_stats=1)
best_topology = ga.bestIndividual()
return direct_response(request, "common/topology.html",
{"form": form,
"output": False})
else:
form = TopologyForm()
return direct_response(request, "common/topology.html",
{"form": form,
"output": False})
def registro(request):
"""
Registro de un usuario
"""
AreasFormSet = modelformset_factory(ViewPort, form=AreaInteresForm, extra=0)
TelefonoFormSet = modelformset_factory(Telefono, form=TelefonoForm)
if request.method == 'POST' and "registro_submit" in request.POST:
form = RegistroClienteForm(request.POST)
formset_areas = AreasFormSet(request.POST, prefix="area")
formset_telefonos = TelefonoFormSet(request.POST, prefix="tel")
if form.is_valid() and formset_telefonos.is_valid() and \
formset_areas.is_valid():
form.save(formset_telefonos, formset_areas)
return direct_response(request, 'usuarios/confirmacion.html')
elif request.method == "POST" and "registro_rubro_id" in request.POST:
rubro = Rubro.objects.get(id=request.POST["registro_rubro_id"])
form = RegistroClienteForm(initial={"rubros_interes": [rubro]})
else:
form = RegistroClienteForm()
formset_areas = AreasFormSet(queryset=ViewPort.objects.none(),
prefix="area")
formset_telefonos = TelefonoFormSet(queryset=Telefono.objects.none(),
prefix="tel")
return direct_response(request, 'usuarios/registro.html',
{'form': form,
'formset_telefonos': formset_telefonos,
'formset_areas': formset_areas})
def inicio(request):
"""
Muestra 3 productos destacados al azar
"""
usuario_invalido = False
productos = Producto.objects.filter(destacado=True).order_by("?")[:3]
if request.method == 'POST':
nombre = request.POST['usuario']
password = request.POST['password']
usuario = authenticate(username=nombre, password=password)
if usuario is not None:
if usuario.is_active:
login(request, usuario)
else:
return direct_response(request, "common/inicio.html",
{"productos": productos,
"usuario_invalido": usuario_invalido,
"titulo": "Inicio"})
else:
usuario_invalido = True
#Prueba de error 500
#x = Producto.objects.get(Id=8000)
return direct_response(request, "common/inicio.html",
{"productos": productos,
"usuario_invalido": usuario_invalido,
"titulo": "Inicio"})
def training(request):
"""
View to load and preview data to the hybrid system
"""
if request.method == 'POST':
form = TrainingForm(request.POST, request.FILES)
# TODO: dos capas ocultas de 10 y 2 nodos con 25 iteraciones, óptimo
if form.is_valid():
# Obtener el conjunto de entrenamiento, de pruebas y los targets
sampleset = SampleSet(form.cleaned_data['wavelet'])
inputs = sampleset.get_learn_set(request.FILES['learn_file'])
targets = sampleset.get_targets("%s/sets/target_set.txt" % settings.MEDIA_ROOT)
# Crear la red neuronal con la topología elegida
hidden1 = form.cleaned_data['hidden1_nn']
hidden2 = form.cleaned_data['hidden2_nn']
net = NeuralNet()
net.init_layers(sampleset.get_input_len(), [hidden1, hidden2], 1)
net.randomize_network()
net.learnrate = form.cleaned_data['learnrate']
net.randomize_network()
net.set_all_inputs(inputs)
net.set_all_targets(targets)
net.set_learn_range(0, 79)
net.set_test_range(79, 89)
net.layers[1].set_activation_type(form.cleaned_data['activation'])
output = net.learn(epochs=form.cleaned_data['epochs'],
show_epoch_results=True,
random_testing=True)
# Guardar la red neuronal
net.save("%s/nn/neuralnet.txt" % settings.MEDIA_ROOT)
# Plot and save the mse
plot(range(1, len(net.accum_mse) + 1, 1), net.accum_mse)
xlabel("Iteraciones")
ylabel('Error')
grid(True)
title(u"Mean Squared Error por iteración")
savefig("%s/img/mse.png" % settings.MEDIA_ROOT)
close('all')
return direct_response(request, 'common/training.html',
{'form': form,
'output': output})
else:
form = TrainingForm()
try:
os.remove("%s/img/mse.png" % settings.MEDIA_ROOT)
except OSError:
pass
return direct_response(request, 'common/training.html',
{'form': form,
'output': False})
def simulation(request):
"""
Simulation over an neural network
"""
if request.method == 'POST':
form = SimulationForm(request.POST, request.FILES)
if form.is_valid():
# Read data
data = request.FILES['sim_file'].read().split()
data = [int(point) for point in data]
# Compress data
wavelet = Wavelet('db4')
compress_data = wavedec(data, wavelet, level=5)
compress_data = [i/10 for i in list(compress_data[0])]
# Plot data and compress data
subplot(121)
plot(data)
title("Espectro Raman original")
grid(True)
xlabel("Wavenumber")
ylabel("Intensidad")
#margins(300, 600)
subplot(122)
plot(compress_data)
title("Espectro comprimido")
grid(True)
xlabel("Wavenumber")
ylabel("Intensidad")
#margins(80, 25)
savefig("%s/img/datavscompress.png" % settings.MEDIA_ROOT)
close('all')
# Load neural network and simulate with an input
net = NeuralNet()
net.load("%s/nn/neuralnetop.txt" % settings.MEDIA_ROOT)
output = net.simulation(compress_data)
form = SimulationForm()
return direct_response(request, 'common/simulation.html',
{'form': form,
'result': output[0],})
else:
form = SimulationForm()
try:
os.remove("%s/img/datavscompress.png" % settings.MEDIA_ROOT)
except OSError:
pass
return direct_response(request, 'common/simulation.html',
{'form': form,
'result': False})
def chat(request):
"""
Chat con los administradores de servicio
"""
if request.method == "POST":
form_chat = ChatForm(request.POST)
if form_chat.is_valid():
return direct_response(request, "portal/iframes/chat.html",
{'form_chat': form_chat})
else:
form_chat = ChatForm()
return direct_response(request, "portal/iframes/chat.html",
{'form_chat': form_chat})
def add_fotos(self, request, app, model, id):
"""
página que muestra la herramienta para subir y editar fotos
"""
Model = get_model(app, model)
obj = get_object_or_404(Model, id=id)
form_add = AdminFotoForm()
form_del = AdminDeleteFotoForm()
if request.method == 'POST':
if 'delete' not in request.POST:
form_add = AdminFotoForm(request.POST, request.FILES)
if form_add.is_valid():
form_add.saveTo(obj)
form_add = AdminFotoForm()
form_add.success = True
else:
form_del = AdminDeleteFotoForm(request.POST)
if form_del.is_valid():
form_del.save()
form_del = AdminDeleteFotoForm()
form_del.success = True
fotos = obj.fotos.all()
return direct_response(request, 'add_photos.html', {'form_add': form_add,
'form_del': form_del,
'fotos': fotos})
def ser_perfil_privado(request, **kwargs):
"""
Muestra todos los datos del perfil de un servicio editables para su
administrador, además la posibilidad de contestar opiniones sobre el
servicio
"""
admin = get_object_or_404(AdministradorServicio, user=request.user)
servicio = admin.servicio
opiniones = Opinion.objects.filter(servicio=servicio)
if request.method == "POST" and not kwargs["cambio_form"].is_bound:
ubicacion_form = UbicacionForm(request.POST,
instance=servicio.ubicacion)
servicio_form = ServicioEdicionForm(request.POST, instance=servicio)
if ubicacion_form.is_valid() and servicio_form.is_valid():
servicio.edit(servicio_form, ubicacion_form, request.session)
else:
ubicacion_form = UbicacionForm(instance=servicio.ubicacion)
servicio_form = ServicioEdicionForm(instance=servicio)
return direct_response(
request, "servicios/privado/ser_perfil_privado.html", {
"servicio": servicio,
"opiniones": get_paginated(request, opiniones, 4),
"ubicacion_form": ubicacion_form,
"servicio_form": servicio_form,
"cambio_form": kwargs["cambio_form"]
})
def fb_channel(request):
"""
Template para fijar la fecha de caducidad de las cookies utilizadas por fbsdk
Debe tener una fecha de expiración muy alta
"""
return direct_response(request, "usuarios/fb_channel.html")
def usuario_intereses(request):
"""
Edita los intereses de un usuario
"""
AreasFormSet = modelformset_factory(ViewPort, form=AreaInteresForm, extra=0)
cliente = get_object_or_404(Cliente, usuario=request.user)
areas = cliente.areas_interes.all()
if request.method == "POST":
form = InteresesClienteForm(request.POST)
formset = AreasFormSet(request.POST, queryset=areas)
if form.is_valid() and formset.is_valid():
form.save(cliente, formset)
formset = AreasFormSet(queryset=cliente.areas_interes.all())
else:
form = InteresesClienteForm(
initial={
'recibir_email': cliente.recibir_email,
'rastrear_proyectos': cliente.rastrear_proyectos,
}
)
formset = AreasFormSet(queryset=cliente.areas_interes.all())
return direct_response(request, "usuarios/iframes/usuario_intereses.html",
{"form": form,
"formset": formset,
"areas": areas,
"rubros": cliente.rubros.all()})
def plano_item(request, item_id):
"""
muestra la pagina con el item dibujado en su plano correspondiente
Ofertas:
Verifica que no este en oferta el item filtrando sus ofertas con fecha_fin
mayor a hoy, y filtrando las ofertas con fecha_inicio mayor o igual a hoy.
Dato que las ofertas de un tipo de item con pueden superponerse con las
de inicio y fin, de obtenerse un resultado este sera unico
"""
item = get_object_or_404(Item, id=item_id)
proyecto = item.plano.proyecto
img_path = item.tipo_item.foto.extra_thumbnails\
.get('small_upscale').absolute_url
poligon = item.poligono.get_points_list(True)
color = item.poligono.color_relleno
#polColors = [i.poligono.color_relleno for i in queryItems]
try:
oferta = item.tipo_item.oferta_set.filter(
fecha_fin__gt=date.today() ).filter(
fecha_inicio__gte=date.today() )[0]
except:
oferta = ''
# if request.user.is_anonymous():
return direct_response(request, "proyectos/plano_item.html",
{'item':item,
'img_path':img_path, 'poligon':poligon,
'color':color, 'proyecto':proyecto,
'oferta':oferta,})
def resultados(request, rubro_id=None):
"""
Resultados de la búsqueda de proyectos
"""
rubro = get_object_or_none(Rubro, id=rubro_id)
if request.method == "POST":
form = BusquedaForm(request.POST)
if form.is_valid():
resultado = form.save()
request.session["resultado"] = resultado
else:
form = BusquedaForm()
if "resultado" in request.session:
resultado = request.session["resultado"]
else:
resultado = Proyecto.accepted.all()
if rubro:
resultado = resultado.filter(rubro=rubro)
return direct_response(request, 'proyectos/resultados.html',
{'resultado': get_paginated(request, resultado, 3),
'resultados_sp': resultado,
'form': form,
'cliente': Cliente.get_authenticated(request),
'rubros': Rubro.objects.all(),
'rubro_activo': rubro,
'rango_venta': Proyecto.get_rango_precio(u"V"),
'rango_renta': Proyecto.get_rango_precio(u"R"),})
def nosotros(request):
"""
Vista informativa con datos de la inmobiliaria
"""
return direct_response(request, 'portal/nosotros.html',
{'desarrollados': Desarrollado.objects.all(),
'inmobiliaria': Inmobiliaria.objects.latest("id")})
def usuario_editar(request):
"""
Edita los datos básicos de un usuario
"""
TelefonoFormSet = modelformset_factory(Telefono)
if request.method == 'POST':
form = EditarClienteForm(request.POST)
formset = TelefonoFormSet(request.POST)
if form.is_valid() and formset.is_valid():
form.save(request.user, formset)
else:
cliente = get_object_or_404(Cliente, usuario=request.user)
form = EditarClienteForm(
initial={
'nombre': request.user.first_name,
'apellido': request.user.last_name,
'email': request.user.email,
'direccion': cliente.direccion,
'provincia': cliente.provincia,
}
)
formset = TelefonoFormSet(queryset=cliente.telefonos.all())
return direct_response(request, 'usuarios/iframes/usuario_editar.html',
{'form': form,
'formset': formset})
def informe_agente(request):
"""
Formulario que un agente llena para envíar un mail al administrador del
sitio informando de la separación de lotes
"""
if request.method == 'POST':
form = InformeForm(request.POST)
if form.is_valid():
#Envío del e-mail
subject = 'Agente Inmobiliario: ' + \
form.cleaned_data['nombre_agente']
data = (form.cleaned_data['nombre_agente'],
form.cleaned_data['nombre_contacto'],
form.cleaned_data['telefono'],
form.cleaned_data['email'],
form.cleaned_data['asunto'])
# TODO: el mail de envío y recepción deben ser cambiados
send_html_mail(subject, 'informe_agente_email.html', data,
'*****@*****.**', ['*****@*****.**'])
return HttpResponseRedirect(reverse('inicio'))
else:
form = InformeForm()
return direct_response(request, 'agentes/informe_agente.html',
{'form': form,
'titulo': 'Formulario Agente'})
def contacto(request):
"""
Formulario de contacto con la empresa
"""
if request.method == 'POST':
form = ContactoForm(request.POST)
if form.is_valid():
#Envío del e-mail
subject = 'Contacto via web con ' + form.cleaned_data['nombre']
data = (form.cleaned_data['dirigido_a'],
form.cleaned_data['departamento'],
form.cleaned_data['nombre'],
form.cleaned_data['direccion'],
form.cleaned_data['telefono'],
form.cleaned_data['email'],
form.cleaned_data['mensaje'])
# TODO: el mail de envío y recepción deben ser cambiados
send_html_mail(subject, 'contacto.html', data,
'*****@*****.**', ['*****@*****.**'])
return HttpResponseRedirect(reverse('inicio'))
else:
form = ContactoForm()
return direct_response(request, 'common/contacto.html',
{'form': form,
'titulo': 'Contacto'})
def galeria_proyectos(request, estado, id_proyecto = None):
"""
Galería de los proyectos
"""
# Buscar el tipo de proyecto
principal = ""
estado_char = ""
for est in Proyecto.ESTADO_CHOICES:
if est[1].lower() == estado.lower():
estado_char = est[0]
break
proyectos = Proyecto.objects.filter(estado = estado_char).order_by('principal').reverse()
if id_proyecto:
principal = get_object_or_404(Proyecto,
estado = estado_char,
id = id_proyecto)
else:
try:
principal = Proyecto.objects.get(estado = estado[0], principal = 'True')
except Proyecto.DoesNotExist:
try:
principal = Proyecto.objects.filter(estado = estado_char).order_by('?')[0]
except IndexError:
pass
return direct_response(request, 'proyectos/galeria_proyectos.html',
{'proyectos': proyectos,
'principal': principal,
'tipo_proyecto': estado,
'titulo': u'Galería: %s' % estado})
def videos(request, proyecto_id):
"""
Devuelve los videos de un proyecto en un slider
"""
videos = get_object_or_404(Proyecto, id=proyecto_id).videos.all()
return direct_response(request, "proyectos/iframes/slider_videos.html",
{"videos": videos})
def solicitud(request, item_id):
"""
muestra la pagina con el formulario para separar item
verifica que el item existe y esta disponible, antes de realizar cualquier
procesamiento
Ofertas:
Verifica si esta en oferta el item filtrando sus ofertas con fecha_fin
mayor a hoy, y filtrando las ofertas con fecha_inicio mayor o igual a hoy.
Dato que las ofertas de un tipo de item con pueden superponerse con las
de inicio y fin, de obtenerse un resultado este sera unico
"""
item = get_object_or_404(Item, id=item_id)
proyecto = item.plano.proyecto
if item.estado != u'D':
return HttpResponseRedirect(item.plano.proyecto.get_absolute_url())
img_path = item.tipo_item.foto.extra_thumbnails\
.get('small_upscale').absolute_url
poligon = item.poligono.get_points_list(True)
try:
oferta = item.oferta_set.filter(
fecha_fin__gt=date.today(), fecha_inicio__lte=date.today(),
item__estado=u'D')[0]
except:
oferta = ''
form = SolicitudForm()
if request.user.is_anonymous():
return direct_response(request, "proyectos/solicitud.html",
{'form':form, 'anonimo':True, 'item':item,
'img_path':img_path, 'poligon':poligon,
'proyecto':proyecto, 'oferta':oferta,})
if request.method == 'POST':
cliente = get_object_or_404(Cliente, usuario=request.user)
postRequest = request.POST.copy()
postRequest['cliente'], postRequest['item'] = cliente.id, item.id
form = SolicitudForm(postRequest)
if form.is_valid():
form.save(cliente, item)
return HttpResponseRedirect(
reverse('proyectos_solicitud_enviada', args=[item_id]) )
return direct_response(request, "proyectos/solicitud.html",
{'form':form, 'anonimo':False, 'item':item,
'img_path':img_path, 'poligon':poligon,
'proyecto':proyecto, 'oferta':oferta,})
def producto(request, id):
"""
Muestra uno de los productos en oferta en una tabla según su id
"""
producto = Producto.objects.get(id=id)
return direct_response(request, "productos/oferta_unitaria.html",
{"productos": producto,
"titulo": "Oferta Laboratorios La cooper"})
def items_proyecto(request, proyecto_id):
"""
Devuelve items paginados de un proyecto
"""
items = Item.objects.filter(plano__proyecto__id=proyecto_id)
return direct_response(request, "proyectos/iframes/items_proyecto.html",
{"items": get_paginated(request, items, 8)})
def nosotros(request):
"""
Información de la empresa
"""
empresa = get_list_or_404(Empresa)
return direct_response(request, "empresa/nosotros.html",
{"empresa": empresa[0],
"titulo": "Nosotros"})
def ofertas(request):
"""
muestra todas las ofertas para los feeds
"""
productos = Producto.objects.filter(estado="O")
return direct_response(request,"productos/ofertas.html",
{"productos": productos,
"titulo": "Ofertas Laboratorios La cooper"})
def usuario_subscripciones(request):
"""
Edita las subscripciones a proyectos del usuario
"""
cliente = get_object_or_404(Cliente, usuario=request.user)
afiliaciones = cliente.proyectos.all()
return direct_response(request, 'usuarios/iframes/usuario_subscripciones.html',
{'afiliaciones': get_paginated(request, afiliaciones, 3)})
def giant_es(request):
proyectos = Proyecto.objects.filter(estado = "A")
empresa = Empresa.objects.get(id = 1)
return direct_response(request, 'common/giant_es.html',
{'proyectos': proyectos,
'empresa':empresa,
'mostrar_swf': request.session['open_swf'],
'titulo': 'Giant es...'})
def tag_detail(request, tag, page=None, **kwargs):
"""
Muestra las entradas relacionadas con una tag
"""
entries = Entry.published.filter(tags__contains=tag)
return direct_response(request, "zinnia/portal/tags.html",
{"entries": get_paginated(request, entries, 5),
"tag": tag})
def perfil_privado_usuario(request):
"""
Perfil privado de un usuario
"""
cliente = get_object_or_404(Cliente, usuario=request.user)
noticias = Entry.published.all()
return direct_response(request, 'usuarios/perfil_privado_usuario.html',
{'noticias': get_paginated(request, noticias, 2)})
def marcas(request):
"""
Lista de marcas y su descripción
"""
marcas = Marca.objects.all()
return direct_response(request, "marcas/marcas.html",
{"marcas": marcas,
"titulo": "Marcas"})
def lista_posts(request):
"""
Muestra la lista de todos los posts ordenados inversamente a su fecha de
publicación
"""
indice_posts = Post.objects.all().order_by('-id')
return direct_response(request, "blog/lista_posts.html",
{"indice_posts": indice_posts,
"titulo": "Lista de posts"})
def inicio(request):
"""
Vista de inicio
"""
return direct_response(request, 'portal/inicio.html',
{'destacados': Proyecto.get_destacados(4),
'form': BusquedaForm(),
'rango_renta': Proyecto.get_rango_precio(u"R"),
'rango_venta': Proyecto.get_rango_precio(u"V"),})
def add_winner(self, request, category_id):
"""
Muestra una pagina con las fotos panoramicas subidas hasta la
temporada 10.
Permitiendo seleccionar a las ganadoras finales
"""
#considering all panoramics photos uploaded before the beginning of the
#voting period 10, it was 2011-8-1 12:00:00 a.m.
object_list = Foto.objects.filter(panoramica=True).filter(
estado='M').filter(
fecha__lt=datetime.datetime(2011, 8, 1, 12, 0, 0))
PanoramicsFormSet = formset_factory(PanoramicWinnerForm, extra=0)
if not category_id:
category_id = 0
if request.method == 'GET':
if int(category_id) != 0:
object_list = object_list.filter(categoria__id=category_id)
if request.method == 'POST':
formset = PanoramicsFormSet(request.POST)
if int(formset.data['category']) != 0:
object_list = object_list.filter(
categoria__id=int(formset.data['category']))
if formset.is_valid():
for form in formset.forms:
form.save()
messages.info(request, 'Operación exitosa.')
return HttpResponseRedirect('/admin/fotos/panoramicwinner/')
else:
li = []
selected = 0
comentario = ''
winner = 0
finalistas = PanoramicWinner.objects.all()
for f in object_list:
query = finalistas.filter(codigo_foto=f)
if query:
selected = 1
comentario = query[0].comentario
winner = query[0].winner
li.append({
'foto_id': f.id,
'selected': selected,
'comentario': comentario,
'winner': winner
})
selected = 0
comentario = ''
winner = 0
formset = PanoramicsFormSet(initial=li)
return direct_response(
request, "admin/panoramicWinner/add_form.html", {
"fotos_list": object_list,
"formset": formset,
"formset_list": formset.forms,
"category_list": Categoria.objects.all(),
"cat_id": int(category_id)
})
def add_winner(self, request, category_id):
"""
muestra una pagina con las fotos ganadoras de las 10 temporadas
permitiendo seleccionar a las ganadoras finales
"""
object_list = Foto.objects.filter(ganadora_temporada__isnull=False)
FinalistasFormSet = formset_factory(GanadorFinalistaForm, extra=0)
if not category_id:
category_id = 0
if request.method == 'GET':
if int(category_id) != 0:
object_list = object_list.filter(categoria__id=category_id)
if request.method == 'POST':
formset = FinalistasFormSet(request.POST)
if int(formset.data['category']) != 0:
object_list = object_list.filter(
categoria__id=int(formset.data['category']))
if formset.is_valid():
for form in formset.forms:
form.save()
messages.info(request, 'Operación exitosa.')
return HttpResponseRedirect('/admin/fotos/granganador/')
else:
li = []
selected = 0
comentario = ''
winner = 0
finalistas = GranGanador.objects.all()
for f in object_list:
query = finalistas.filter(codigo_foto=f)
if query:
selected = 1
comentario = query[0].comentario
winner = query[0].winner
li.append({
'foto_id': f.id,
'selected': selected,
'comentario': comentario,
'winner': winner
})
selected = 0
comentario = ''
winner = 0
formset = FinalistasFormSet(initial=li)
return direct_response(
request, "admin/granganador/add_form.html", {
"fotos_list": object_list,
"formset": formset,
"formset_list": formset.forms,
"category_list": Categoria.objects.all(),
"cat_id": int(category_id)
})
def ser_editar_fotos(request, **kwargs):
"""
Muestra un editor de las fotos cargadas al perfil así como un formulario
para subir fotos nuevas
"""
admin = get_object_or_404(AdministradorServicio, user=request.user)
galeria = Foto.objects.filter(servicio=admin.servicio)
if request.method == "POST" and not kwargs["cambio_form"].is_bound:
if "guardar" in request.POST:
guardar_form = FotoForm(request.POST, request.FILES)
if guardar_form.is_valid():
Foto.save_form(guardar_form, admin.servicio)
guardar_form = FotoForm()
editar_form = EditFotoForm(prefix="edit")
panoramica_form = ServicioPanoramicaForm(instance=admin.servicio)
elif "editar" in request.POST:
foto = Foto.objects.get(id=request.POST["edit-id"])
editar_form = EditFotoForm(request.POST,
instance=foto,
prefix="edit")
if editar_form.is_valid():
foto.edit(editar_form)
editar_form = EditFotoForm(prefix="edit")
guardar_form = FotoForm()
panoramica_form = ServicioPanoramicaForm(instance=admin.servicio)
elif "panoramica" in request.POST:
panoramica_form = ServicioPanoramicaForm(request.POST,
request.FILES,
instance=admin.servicio)
if panoramica_form.is_valid():
panoramica_form.save()
guardar_form = FotoForm()
editar_form = EditFotoForm(prefix="edit")
else:
panoramica_form = ServicioPanoramicaForm(instance=admin.servicio)
guardar_form = FotoForm()
editar_form = EditFotoForm(prefix="edit")
return direct_response(
request, "servicios/privado/ser_editar_fotos.html", {
"servicio": admin.servicio,
"galeria": galeria,
"panoramica_form": panoramica_form,
"guardar_form": guardar_form,
"editar_form": editar_form,
"cambio_form": kwargs["cambio_form"]
})
def ser_perfil_publico(request, id_servicio):
"""
Muestra el perfil público de alguno de los servicios donde se puede puntuar
el servicio y dejar opiniones
"""
servicio = get_object_or_404(Servicio, id=id_servicio, estado=u"A")
opiniones = Opinion.objects.filter(servicio=servicio, moderado=True)
destacados = Servicio.accepted.filter(destacado=True).order_by("?")[:5]
puntaje = Puntaje.get_or_none(servicio, request.user)
comentado = False
msg_enviado = False
if request.method == "POST":
if "opinion" in request.POST:
opinion_form = OpinionForm(request.POST)
puntuacion_form = PuntajeForm(request.POST, instance=puntaje)
if opinion_form.is_valid() and puntuacion_form.is_valid(
) or not puntuacion_form:
Opinion.save_form(opinion_form, servicio, request.user)
Puntaje.save_form(puntuacion_form, servicio, request.user,
puntaje)
opinion_form = OpinionForm()
puntuacion_form = PuntajeForm(instance=puntaje)
request.user.get_profile().add_points(5)
if AdministradorServicio.objects.filter(
servicio=servicio).exists():
contacto_form = ContactoForm()
else:
contacto_form = None
comentado = True
elif "contacto" in request.POST:
contacto_form = ContactoForm(request.POST)
if contacto_form.is_valid():
sendHtmlMail(
"*****@*****.**",
u"You've received a contact request",
"ser_contacto_mail_%s.html" %
servicio.administradorservicio.idioma, {
"datos": contacto_form.cleaned_data,
"nombre_sitio": Site.objects.get_current().domain,
"email": servicio.administradorservicio.user.email,
},
servicio.administradorservicio.user.email,
path="servicios/email_templates/")
msg_enviado = True
contacto_form = ContactoForm()
request.user.get_profile().add_points(5)
opinion_form = OpinionForm()
puntuacion_form = PuntajeForm()
else:
servicio.add_vista(request)
opinion_form = OpinionForm()
puntuacion_form = PuntajeForm(instance=puntaje)
if AdministradorServicio.objects.filter(servicio=servicio).exists():
contacto_form = ContactoForm()
else:
contacto_form = None
return direct_response(
request, "servicios/ser_perfil_publico.html", {
"servicio": servicio,
"galeria": Foto.objects.filter(servicio=servicio, moderado=True),
"caracteristicas": servicio.caracteristicas.all(),
"opiniones": get_paginated(request, opiniones, 4),
"destacados": destacados,
"resultados": Servicio.get_search(request.session)[:3],
"opinion_form": opinion_form,
"puntuacion_form": puntuacion_form,
"contacto_form": contacto_form,
"msg_enviado": msg_enviado,
"comentado": comentado,
"fans": servicio.get_fans()
})
def ser_inicio(request):
"""
Muestra la página de inicio de servicios y procesa búsquedas de servicios,
login de administradores de servicio y registro de nuevos servicios por
parte de los usuarios
"""
html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)
captcha_error = None
if request.method == "POST":
if "login" in request.POST:
login_form = LoginForm(request.POST)
if login_form.is_valid():
user = authenticate(
username=login_form.cleaned_data['email'],
password=login_form.cleaned_data['contrasena'])
if user is not None:
if user.is_active:
login(request, user)
admin = AdministradorServicio.objects.get(user=user)
request.session['django_language'] = admin.idioma
translation.activate(admin.idioma)
return HttpResponseRedirect(
reverse("ser_perfil_privado"))
else:
login_form.errors["email"] = [
_(u"Your user account has not been \
activated, check your e-mail"
)
]
else:
login_form.errors["email"] = [
_(u"Your username or password is incorrect")
]
busqueda_form = BusquedaForm()
nuevo_servicio_form = ServicioPublicoForm()
ubicacion_form = UbicacionForm()
recuperar_form = RecuperarForm()
elif "nuevo_servicio" in request.POST:
check_captcha = captcha.submit(
request.POST['recaptcha_challenge_field'],
request.POST['recaptcha_response_field'],
settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'])
if check_captcha.is_valid is False:
captcha_error = _(u"Written words are incorrect")
###begin escape for django' tests
if settings.DEBUG == False and 'appTest' in request.POST:
captcha_error = None
###end escape for django' tests
nuevo_servicio_form = ServicioPublicoForm(request.POST,
request.FILES)
ubicacion_form = UbicacionForm(request.POST)
if nuevo_servicio_form.is_valid() and ubicacion_form.is_valid(
) and not captcha_error:
servicio = Servicio.save_form(nuevo_servicio_form,
ubicacion_form,
estado=u"A")
Actividad.register(u"R", servicio)
nuevo_servicio_form = ServicioPublicoForm()
ubicacion_form = UbicacionForm()
busqueda_form = BusquedaForm()
login_form = LoginForm()
recuperar_form = RecuperarForm()
elif "recuperar" in request.POST:
recuperar_form = RecuperarForm(request.POST)
if recuperar_form.is_valid():
try:
usuario = AdministradorServicio.objects.get(
user__email=recuperar_form.cleaned_data['email'])
sendHtmlMail("*****@*****.**",
_(u"New password for Machu Picchu 100"),
"ser_recuperar_mail_%s.html" % usuario.idioma,
{
"usuario": usuario,
"password": make_password(),
"sitio": Site.objects.get_current()
},
recuperar_form.cleaned_data['email'],
path="servicios/email_templates/")
except AdministradorServicio.DoesNotExist:
recuperar_form.errors["email"] = [
_(u"The e-mail account does not \
belong to any registered manager"
)
]
login_form = LoginForm()
nuevo_servicio_form = ServicioPublicoForm()
ubicacion_form = UbicacionForm()
busqueda_form = BusquedaForm()
else:
busqueda_form = BusquedaForm()
login_form = LoginForm()
nuevo_servicio_form = ServicioPublicoForm()
ubicacion_form = UbicacionForm()
recuperar_form = RecuperarForm()
return direct_response(
request, "servicios/ser_inicio.html", {
"busqueda_form": busqueda_form,
"login_form": login_form,
"nuevo_servicio_form": nuevo_servicio_form,
"html_captcha": html_captcha,
"captcha_error": captcha_error,
"ubicacion_form": ubicacion_form,
"recuperar_form": recuperar_form,
"actividades": get_paginated(request, Actividad.objects.all(), 5),
"destacados":
Servicio.objects.filter(destacado=True).order_by('?')[:3],
"valorados": Servicio.objects.all().order_by('-puntuacion')[:3],
"ubicaciones_comunes": UbicacionComun.objects.all()
})
def ser_perfiles(request, filtro, id_tipo=None):
"""
Muestra la página de resultados de una búsqueda, en caso de especificar
un tipo de servicio se habilitará otra de las pestañas, los resultados serán
paginados
"""
if "busqueda" in request.session:
busqueda = request.session["busqueda"]
else:
busqueda = {
"direccion": _(u"all locations"),
"tipo": None,
"latitud": "-16.3167",
"longitud": "-71.55",
"filtro": "puntuacion"
}
if request.method == "POST":
busqueda_form = BusquedaForm(request.POST)
resultados = Servicio.accepted.all()
if busqueda_form.is_valid():
if busqueda_form.cleaned_data["ubicacion"]:
if not busqueda_form.cleaned_data["location"]:
busqueda_form.errors["ubicacion"] = _(
u"Your request cannot \
be processed if you don't enable javascript in your explorer"
)
else:
(busqueda["latitud"], busqueda["longitud"]) = \
busqueda_form.cleaned_data['location'].split(",")
(lo_lat, lo_lng, hi_lat, hi_lng) = \
busqueda_form.cleaned_data['viewport'].split(",")
resultados = resultados.filter(
ubicacion__latitud__range=(lo_lat, hi_lat),
ubicacion__longitud__range=(lo_lng, hi_lng))
busqueda["direccion"] = busqueda_form.cleaned_data[
"ubicacion"]
else:
busqueda["direccion"] = _(u"all locations")
request.session["resultados"] = resultados
if busqueda_form.cleaned_data['tipo']:
busqueda["tipo"] = busqueda_form.cleaned_data['tipo']
resultados = resultados.filter(tipo_servicio=busqueda["tipo"])
else:
busqueda["tipo"] = None
resultados = resultados.order_by("-%s" % filtro)
request.session["busqueda"] = busqueda
else:
if "resultados" in request.session and id_tipo:
resultados = request.session["resultados"]
else:
resultados = Servicio.accepted.all()
if id_tipo:
busqueda["tipo"] = get_object_or_404(TipoServicio, id=id_tipo)
resultados = resultados.filter(tipo_servicio=busqueda["tipo"])
else:
busqueda["tipo"] = None
busqueda["filtro"] = filtro
resultados = resultados.order_by("-%s" % filtro)
request.session["busqueda"] = busqueda
busqueda_form = BusquedaForm()
if resultados.filter(destacado=True).exists():
destacado = resultados.filter(destacado=True).order_by("?")[0]
else:
destacado = None
return direct_response(
request, "servicios/ser_perfiles.html", {
"resultados": get_paginated(request, resultados, 4),
"all_results": resultados,
"tipos": TipoServicio.objects.all(),
"destacado": destacado,
"busqueda_form": busqueda_form,
"busqueda": busqueda,
"filtros": FILTROS
})
def ser_registro(request):
"""
Muestra el formulario de registro para un nuevo servicio, envía un email de
confirmación al cliente para validar la cuenta
"""
html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)
ser_captcha_error = None
if request.method == "POST":
if request.POST['instance']:
servicio_id = request.POST['instance']
if AdministradorServicio.objects.filter(
servicio__id=servicio_id).exists():
return HttpResponseRedirect(reverse('ser_registro'))
else:
servicio_instance = Servicio.accepted.get(id=servicio_id)
form_registro = ServicioPrivadoForm(request.POST,
request.FILES,
instance=servicio_instance)
form_ubicacion = UbicacionForm(
request.POST, instance=servicio_instance.ubicacion)
else:
form_registro = ServicioPrivadoForm(request.POST, request.FILES)
form_ubicacion = UbicacionForm(request.POST)
check_captcha = captcha.submit(
request.POST['recaptcha_challenge_field'],
request.POST['recaptcha_response_field'],
settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'])
if check_captcha.is_valid is False:
ser_captcha_error = _(u"Written words are incorrect")
###begin escape for django' tests
if settings.DEBUG == False and 'appTest' in request.POST:
ser_captcha_error = None
###end escape for django' tests
if form_registro.is_valid() and form_ubicacion.is_valid(
) and not ser_captcha_error:
servicio = Servicio.save_form(form_registro, form_ubicacion)
admin = AdministradorServicio.save_form(form_registro, servicio)
sendHtmlMail("*****@*****.**",
_(u"Manager registration in MP100"),
"ser_regadmin_mail_%s.html" % admin.idioma, {
"nombre": servicio.nombre,
"sitio": Site.objects.get_current(),
"email": form_registro.cleaned_data['email']
},
form_registro.cleaned_data['email'],
path="servicios/email_templates/")
return direct_response(request, "servicios/ser_confirmacion.html")
else:
form_registro = ServicioPrivadoForm()
form_ubicacion = UbicacionForm()
return direct_response(
request, "servicios/ser_registro.html", {
"form_registro": form_registro,
"form_ubicacion": form_ubicacion,
"html_captcha": html_captcha,
"ser_captcha_error": ser_captcha_error
})
