# Create your views here.
# encoding:utf-8
from pyjasperclient import JasperClient
from django.http import HttpResponseRedirect, HttpResponse
from django.utils.encoding import smart_str
from servicio.models import Alumno, Area, Pregunta, Resultado, Respuesta
from servicio.forms import *
from django.http import HttpResponseRedirect, HttpResponse
from django.template import RequestContext, loader
from django.shortcuts import get_object_or_404, render, render_to_response, redirect
from django.core.urlresolvers import reverse, reverse_lazy
from django.forms import ModelForm
from django.forms.formsets import formset_factory
from django.db.models import Count
from django.contrib import messages
from django.forms import ModelForm
from django.contrib import auth
from django.contrib.auth.decorators import login_required
from django.template.response import TemplateResponse
from datetime import datetime
from django.core.paginator import Paginator, InvalidPage, EmptyPage
from django.core.mail import send_mail, BadHeaderError, EmailMultiAlternatives  #libreria para correo
from django.conf import settings
from django.views.generic import ListView, DetailView, CreateView, View


def login(request):
	if request.method == 'POST':

		username = request.POST['username']
		password = request.POST['password']
		user = auth.authenticate(username=username, password=password)
		mensaje = ''
		if user is not None and user.is_active:
			# Correct password, and the user is marked "active"
			auth.login(request, user)
			# Redirect to a success page.
			return HttpResponseRedirect('/areas/administrador/')
		else:
			messages.error(request, 'error de autenticacion')
		return TemplateResponse(request, 'index.html', {'msj': mensaje})
	else:

		return HttpResponseRedirect('/areas/acceder/')


"""
Desloguea al usuario y regresa al template principal.html

"""


@login_required(login_url='/areas/acceder/')
def administrador(request):
	mensaje = ''
	return TemplateResponse(request, 'dashboard_base.html', {'msj': mensaje})


@login_required(login_url='/areas/')
def logout(request):
	auth.logout(request)
	template = loader.get_template('principal.html')
	context = RequestContext(request, {})

	return HttpResponse(template.render(context))


"""
Se manda a llamar al template index.html para iniciar sesion

"""


def acceder(request):
	return render_to_response('index.html', context_instance=RequestContext(request))


def principal(request):
	template = loader.get_template('principal.html')
	context = RequestContext(request, {
	})
	return HttpResponse(template.render(context))


@login_required(login_url='/areas/acceder/')
def perfil(request, user_id):
	return TemplateResponse(request, 'perfil.html')


'''
Se manda a llamar al template cuestionarioform.html que es el formulario para registrar el cuestionario y luego
devuelve todos los registros con el template mostrarcuestionario.html
'''


@login_required(login_url='/areas/acceder/')
def crearcuestionario(request):
	if request.method == 'POST':
		form = CuestionarioForm(request.POST)
		if form.is_valid():
			form.save()
			datos = Cuestionario.objects.all()
			messages.success(request, 'Cuestionario registrada')
			return HttpResponseRedirect('/areas/mostrarcuestionario/')
	else:
		form = CuestionarioForm()

	area_side = 'closed'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'active'
	return render_to_response('cuestionarioform.html',
							  {'form': form, 'area_side': area_side, 'menu_alumno': menu_alumno,
							   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))


'''
Muestra todos los cuestionarios registrados, con el template mostrarcuestionario.html
'''


@login_required(login_url='/areas/acceder/')
def mostrarcuestionario(request):
	area_side = 'closed'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'active'
	datos = Cuestionario.objects.all().order_by('id')
	return render_to_response('mostrarcuestionario.html',
							  {'datos': datos, 'area_side': area_side, 'menu_alumno': menu_alumno,
							   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))


'''
Muestra los datos de un cuestionario, permite su edicion, y vuelve a mostrar
el template con todas los cuestionarios registrados
'''


@login_required(login_url='/areas/acceder/')
def editarcuestionario(request, cuestionario_id):
	area_side = 'closed'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'active'
	cuestionario = Cuestionario.objects.get(pk=cuestionario_id)
	if request.method == 'POST':
		form = CuestionarioForm(request.POST, instance=cuestionario)
		if form.is_valid():
			form.save()
			datos = Cuestionario.objects.all()
			messages.success(request, 'Se actualizo el cuestionario')
			return HttpResponseRedirect('/areas/mostrarcuestionario/')
	else:
		form = CuestionarioForm(instance=cuestionario)
	return render_to_response('cuestionarioform.html',
							  {'form': form, 'cuestionario': cuestionario, 'area_side': area_side,
							   'menu_alumno': menu_alumno, 'menu_pregunta': menu_pregunta,
							   'menu_respuesta': menu_respuesta, 'menu_resultado': menu_resultado},
							  context_instance=RequestContext(request))


'''
Permite eliminar un registro del modelo:cuestionario y muestra nuevamente  los cuestionarios registrados
'''


@login_required(login_url='/areas/acceder/')
def borrarcuestionario(request, cuestionario_id):
	cuestionario = Cuestionario.objects.get(pk=cuestionario_id)



	cuestionario.delete()


	datos = Cuestionario.objects.all()
	messages.warning(request, 'Se elimino el cuestionario')
	return HttpResponseRedirect('/areas/mostrarcuestionario/')


"""
Se manda a llamar al template areaform.html que es el formulario para registrar el area y luego
devuelve todos los registros con el template mostrararea.html
"""


@login_required(login_url='/areas/acceder/')
def creararea(request):
	if request.method == 'POST':
		form = AreaForm(request.POST)
		if form.is_valid():
			form.save()
			datos = Area.objects.all()
			messages.success(request, 'Área registrada')
			return HttpResponseRedirect('/areas/mostrararea/')
	else:
		form = AreaForm()

	area_side = 'active'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	return render_to_response('areaform.html', {'form': form, 'area_side': area_side, 'menu_alumno': menu_alumno,
												'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
												'menu_resultado': menu_resultado},
							  context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def mostrararea(request):
	area_side = 'active'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	datos = Area.objects.all().order_by('id')
	return render_to_response('mostrararea.html', {'datos': datos, 'area_side': area_side, 'menu_alumno': menu_alumno,
												   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
												   'menu_resultado': menu_resultado},
							  context_instance=RequestContext(request))


"""
Muestra los datos de un area especifica , permite su edicion, y vuelve a mostrar
el template con todas las areas registradas

"""


@login_required(login_url='/areas/acceder/')
def editararea(request, area_id):
	area_side = 'active'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	area = Area.objects.get(pk=area_id)
	if request.method == 'POST':
		form = AreaForm(request.POST, instance=area)
		if form.is_valid():
			form.save()
			datos = Area.objects.all()
			messages.success(request, 'Se actualizo el área')
			return HttpResponseRedirect('/areas/mostrararea/')
	else:
		form = AreaForm(instance=area)
	return render_to_response('areaform.html',
							  {'form': form, 'area': area, 'area_side': area_side, 'menu_alumno': menu_alumno,
							   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))


"""
Permite eliminar un registro del modelo:area y muestra nuevamente  las areas registradas

"""


@login_required(login_url='/areas/acceder/')
def borrararea(request, area_id):
	area = Area.objects.get(pk=area_id)
	area.delete()
	datos = Area.objects.all()
	messages.warning(request, 'Se elimino el área')
	return HttpResponseRedirect('/areas/mostrararea/')


"""
Se manda a llamar al template directivoform.html que es el formulario para registrar el directivo y luego
devuelve todos los registros con el template mostrardirectivo.html
"""


@login_required(login_url='/areas/acceder/')
def creardirectivo(request):
	if request.method == 'POST':
		form = DirectivoForm(request.POST)
		if form.is_valid():
			form.save()
			datos = Directivo.objects.all().order_by('nombre')
			messages.success(request, 'Directivo registrado')
			return HttpResponseRedirect('/areas/mostrardirectivo/')
	else:
		form = DirectivoForm()

	area_side = 'active'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	return render_to_response('directivoform.html', {'form': form, 'area_side': area_side, 'menu_alumno': menu_alumno,
													 'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
													 'menu_resultado': menu_resultado},
							  context_instance=RequestContext(request))


"""
Muestra todas las directivos registrados, con el template mostrardirectivo.html

"""


@login_required(login_url='/areas/acceder/')
def mostrardirectivo(request):
	area_side = 'active'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	datos = Directivo.objects.all().order_by('id')
	return render_to_response('mostrardirectivo.html',
							  {'datos': datos, 'area_side': area_side, 'menu_alumno': menu_alumno,
							   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado},
							  context_instance=RequestContext(request))


"""
Muestra los datos de un area especifica , permite su edicion, y vuelve a mostrar
el template con todas las areas registradas

"""


@login_required(login_url='/areas/acceder/')
def editardirectivo(request, directivo_id):
	area_side = 'active'
	menu_alumno = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	directivo = Directivo.objects.get(pk=directivo_id)
	if request.method == 'POST':
		form = DirectivoForm(request.POST, instance=directivo)
		if form.is_valid():
			form.save()
			datos = Directivo.objects.all()
			messages.success(request, 'Se actualizo el Directivo')
			return HttpResponseRedirect('/areas/mostrardirectivo/')
	else:
		form = DirectivoForm(instance=directivo)
	return render_to_response('directivoform.html',
							  {'form': form, 'directivo': directivo, 'area_side': area_side, 'menu_alumno': menu_alumno,
							   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))


"""
Permite eliminar un registro del modelo:Directivo y muestra nuevamente  las Directivos registrados

"""


@login_required(login_url='/areas/acceder/')
def borrardirectivo(request, directivo_id):
	directivo = Directivo.objects.get(pk=directivo_id)
	directivo.delete()
	datos = Directivo.objects.all()
	messages.warning(request, 'Se elimino el directivo')
	return HttpResponseRedirect('/areas/mostrardirectivo/')


"""
Se manda a llamar al template preguntaform.html que es el formulario para registrar las preguntas y luego
devuelve todos los registros con el template mostrarpregunta.html

"""


@login_required(login_url='/areas/acceder/')
def crearpregunta(request):
	if request.method == 'POST':
		form = CrearPreguntaForm(request.POST)
		if form.is_valid():

			respuesta = request.POST.get('respuesta')
			acierto = request.POST.get('acierto')

			if (acierto == None):
				acierto = False

			pregunta = form.save()

			res = Respuesta(pregunta=pregunta, nom_respuesta=respuesta, acierto=acierto)
			res.save()
			messages.success(request, 'Pregunta registrada')

			#return HttpResponseRedirect('/expediente/%s/datosmenor/'%(expediente.menor.id)
			return HttpResponseRedirect('/areas/%s/editarpreguntasres/'%(pregunta.id))
			#return HttpResponseRedirect('/areas/mostrarpregunta/')


	else:
		form = CrearPreguntaForm()
	pregunta_side = 'active'
	menu_alumno = 'closed'
	menu_area = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	return render_to_response('crearpreguntaform.html',
							  {'form': form}, context_instance=RequestContext(request))


"""
Muestra todas las preguntas registradas con las opciones de editar y eliminar

"""


@login_required(login_url='/areas/acceder/')
def mostrarpregunta(request):
	pregunta_side = 'active'
	menu_alumno = 'closed'
	menu_area = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	datos = Pregunta.objects.all().order_by('area')
	return render_to_response('mostrarpregunta.html',
							  {'datos': datos, 'pregunta_side': pregunta_side, 'menu_alumno': menu_alumno,
							   'menu_area': menu_area, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))





'''
funcion que actualiza y redirecciona asi mismo pero con el id de la pregunta que acaba de actualizar
'''
@login_required(login_url='/areas/acceder/')
def editarpreguntasres(request, pregunta_id):

	pregunta = Pregunta.objects.get(pk=pregunta_id)
	if request.method == 'POST':
		form = CrearPreguntaForm(request.POST, instance=pregunta)
		if form.is_valid():
			respuesta = request.POST.get('respuesta')
			acierto = request.POST.get('acierto')
			if (acierto == None):
				acierto = False
			pregunta=form.save()
			res = Respuesta(pregunta=pregunta, nom_respuesta=respuesta, acierto=acierto)
			res.save()
			messages.success(request, 'Pregunta registrada')
			return HttpResponseRedirect('/areas/%s/editarpreguntasres/'%(pregunta.id))
			#return HttpResponseRedirect('/areas/mostrarpregunta/')
		else:
				msj = 'Favor de llenar los campos requeridos'
				messages.success(request, msj)

	else:
		form = CrearPreguntaForm(instance=pregunta)
	return render_to_response('crearpreguntaform.html',
							  {'form': form, 'pregunta': pregunta}, context_instance=RequestContext(request))





"""
Devuelve una lista de respuesta, listaareas y la pregunta , que seran necesarias para crear dinamicamente el "preguntaform.html"
"""

@login_required(login_url='/areas/acceder/')
def editarpreguntas(request, pregunta_id):
	listarespuesta = Respuesta.objects.filter(pregunta_id=pregunta_id)
	pregunta = Pregunta.objects.get(pk=pregunta_id)
	listaareas = Area.objects.all()


	#res=Resultado.objects.all().filter(respuesta__pregunta__area=y.id )



	return render_to_response('preguntaform.html', {'listaareas': listaareas, 'listarespuesta': listarespuesta,'pregunta':pregunta}, context_instance=RequestContext(request))

'''
funcion que sirve para editar la pregunta, area y las respuestas
'''
@login_required(login_url='/areas/acceder/')
def editarpreguntarespuestas(request, pregunta_id):

	pregunta = request.POST.get("pregunta")
	area = request.POST.get("areas")
	a = Area.objects.get(pk=area)
	acierto = request.POST.getlist("acierto")

	if request.method == 'POST':

			pre = Pregunta(pk=pregunta_id, nombre_pregunta=pregunta, area=a)
			pre.save()

			res= Respuesta.objects.filter(pregunta_id=pregunta_id)

			for r in res:
				print(r,'r')
				if request.POST.get(u'%s' % r.id, ''):
					e1 = request.POST.get(u'%s' % r.id)
					e2 = request.POST.get(u'%s' % r)
					print(e1, 'e1')
					print(e2, 'e2')

					if (e2 == '1'):

						re = Respuesta(pk=r.id, pregunta_id=pregunta_id, nom_respuesta=e1, acierto = True)
						re.save()
					else:
						re = Respuesta(pk=r.id, pregunta_id=pregunta_id, nom_respuesta=e1, acierto = False)
						re.save()


			messages.success(request, 'Datos Actualizados')
			datos = Pregunta.objects.all().order_by('area')


			return HttpResponseRedirect('/areas/mostrarpregunta/')
	else:
		form = PreguntaForm(instance=pregunta)
	return render_to_response('preguntaform.html', {'form': form},
							  context_instance=RequestContext(request))


"""
Permite eliminar un registro del modelo:Pregunta y muestra nuevamente  las preguntas registradas

"""


@login_required(login_url='/areas/acceder/')
def borrarpregunta(request, pregunta_id):
	pregunta = Pregunta.objects.get(pk=pregunta_id)
	pregunta.delete()
	datos = Pregunta.objects.all().order_by('area')
	messages.warning(request, 'Se elimino la pregunta')
	return HttpResponseRedirect('/areas/mostrarpregunta/')


"""
Muestra todas las respuestas registradas con las opciones de editar y eliminar

"""


@login_required(login_url='/areas/acceder/')
def crearrespuesta(request):
	if request.method == 'POST':
		form = RespuestaForm(request.POST)
		if form.is_valid():  # valida  los datos del formulario

			form.save()
			datos = Respuesta.objects.all().order_by('pregunta')
			messages.success(request, 'Respuesta registrada')
			return HttpResponseRedirect('/areas/mostrarrespuesta/')
		#return render_to_response('mostrarrespuesta.html',{'datos':datos},context_instance=RequestContext(request))
	else:
		form = RespuestaForm()
	respuesta_side = 'active'
	menu_alumno = 'closed'
	menu_area = 'closed'
	menu_cuestionario = 'Active'
	menu_pregunta = 'closed'
	menu_resultado = 'closed'

	return render_to_response('respuestaform.html',
							  {'form': form, 'respuesta_side': respuesta_side, 'menu_alumno': menu_alumno,
							   'menu_area': menu_area, 'menu_pregunta': menu_pregunta, 'menu_resultado': menu_resultado,
							   'menu_cuestionario': menu_cuestionario}, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def mostrarrespuesta(request):
	datos = Respuesta.objects.all().order_by('pregunta')
	respuesta_side = 'active'
	menu_alumno = 'closed'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	return render_to_response('mostrarrespuesta.html',
							  {'datos': datos, 'respuesta_side': respuesta_side, 'menu_alumno': menu_alumno,
							   'menu_area': menu_area, 'menu_pregunta': menu_pregunta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))


"""
Muestra los datos de un respuesta especifica , permite su edicion, y vuelve a mostrar
el template con todas las respuesta registradas

"""


@login_required(login_url='/areas/acceder/')
def editarrespuesta(request, respuesta_id):

	respuesta = Respuesta.objects.get(pk=respuesta_id)
	pregunta = Pregunta.objects.get(pk=respuesta.pregunta.id)
	listarespuesta= Respuesta.objects.filter(pregunta_id=pregunta)
	listaareas=Area.objects.all()

	return render_to_response('preguntaform.html', {'listaareas': listaareas, 'listarespuesta': listarespuesta,'pregunta':pregunta}, context_instance=RequestContext(request))





"""
Permite eliminar un registro del modelo:Respuesta y muestra nuevamente  las respuestas registradas

"""


@login_required(login_url='/areas/acceder/')
def borrarrespuesta(request, respuesta_id):
	respuesta = Respuesta.objects.get(pk=respuesta_id)
	respuesta.delete()
	datos = Respuesta.objects.all().order_by('pregunta')
	messages.warning(request, 'Se elimino la respuesta')

	return HttpResponseRedirect('/areas/mostrarrespuesta/')

@login_required(login_url='/areas/acceder/')
def eliminarrespuestas(request, respuesta_id):
	respuesta = Respuesta.objects.get(pk=respuesta_id)
	respuesta.delete()
	datos = Respuesta.objects.all().order_by('pregunta')
	messages.warning(request, 'Se elimino la respuesta')

	return HttpResponseRedirect('/areas/mostrarpregunta/')

"""
Se manda a llamar al template respuestaform.html que es el formulario para registrar las respuestas y luego
devuelve todos los registros con el template mostrarrespuesta.html

"""


from django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def nuevoalumno(request):
	if request.method == 'POST':
		form = AlumnoForm(request.POST)
		if form.is_valid():
			#form.save()
			nombre_alumno = form.cleaned_data['nombre_alumno']
			appat = form.cleaned_data['appat']
			apma = form.cleaned_data['apma']
			area = request.POST.get("area")
			dependencia = form.cleaned_data['dependencia']
			d = request.POST.get('dependencia')
			c = form.cleaned_data['cuestionario']

			cuestionario =Cuestionario.objects.get(pk=c.id)




			#dependencia = form.cleaned_data['dependencia_id'],
			lista_preguntas = Pregunta.objects.filter(area__cuestionario_id=c).order_by('?')
			#lista_respuesta = Respuesta.objects.all()  # Se envia todos los datos necesarios para crear el cuestionario
			paqueteP=RequestContext(request,{'lista_preguntas':lista_preguntas, 'nombre_alumno':nombre_alumno,'appat':appat,'apma':apma,
				'dependencia':dependencia,'area':area,'cuestionario':cuestionario})
			#paqueteP = RequestContext(request,
									  #{'lista_preguntas': lista_preguntas, 'lista_respuesta': lista_respuesta, 'cuestionario': cuestionario})
			return render_to_response('Cuestionario.html', paqueteP, context_instance=RequestContext(request))

	else:
		form = AlumnoForm()
	return render_to_response('alumnoform.html', {'form': form}, context_instance=RequestContext(request))


"""
Muestra todas los alumnos  registrados con las opciones de editar y eliminar

"""


@login_required(login_url='/areas/acceder/')
def detallecuestionario(request, alumno_id):
	datos = Alumno.objects.get(id=alumno_id)

	lista_preguntas = Pregunta.objects.filter(area__cuestionario_id=datos.cuestionario.id)

	lista_resultados = Resultado.objects.filter(alumno_id=alumno_id)
	lista_respuestas = Respuesta.objects.filter(pregunta__in=lista_preguntas).exclude(resultado__in=lista_resultados)

	#for x in respuestas:
	#lista_respuestas = Respuesta.objects.filter(pk=x.respuesta_id)
	#for y in lista_respuestas:
	# print(y.pregunta,'pregunta')
	#print(y.nom_respuesta,'respuesta')
	#respuestas = Resultado.objects.filter(encuesta_id=pk)
	return render_to_response('detalle_cuestionario.html',
							  {'lista_resultados': lista_resultados, 'datos': datos, 'lista_preguntas': lista_preguntas,
							   'lista_respuestas': lista_respuestas}, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def mostraralumno(request):
	datos = Alumno.objects.all().order_by('id')

	alumno_side = 'active'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'
	return render_to_response('mostraralumno.html', {'datos': datos, 'alumno_side': alumno_side, 'menu_area': menu_area,
													 'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
													 'menu_resultado': menu_resultado},
							  context_instance=RequestContext(request))


"""
Muestra los datos de un alumno especifico , permite su edicion, y vuelve a mostrar
el template con todas los alumnos registrados

"""


@login_required(login_url='/areas/acceder/')
def detallealumno(request, alumno_id):
	datos = Alumno.objects.get(id=alumno_id)
	datosid = str(datos.id)
	con = Cuestionario.objects.filter(id=datos.cuestionario.id)
	#area = Area.objects.filter(cuestionario_id = con)

	ciclopreguntas = Pregunta.objects.filter(area__cuestionario__alumno__pk=alumno_id)

	for pregunta in ciclopreguntas:
		cicloresultado = Resultado.objects.filter(alumno__pk=alumno_id, respuesta__pregunta=pregunta)
		for resultado in cicloresultado:

			if resultado.cont_respuesta == 0:
				Resultado.objects.filter(alumno__pk=alumno_id, respuesta__pregunta=pregunta).update(cont_respuesta=0)

	for pregunta in ciclopreguntas:
		respuestascorrectas=Respuesta.objects.filter(pregunta=pregunta,acierto=True)
		resultadoscorrectos=Resultado.objects.filter(respuesta__pregunta=pregunta,respuesta__acierto=True,alumno__pk=alumno_id)

		if respuestascorrectas.count()!=resultadoscorrectos.count():
			resultadoscorrectos.update(cont_respuesta=0)



	#lista_alumnos= Alumno.objects.all().filter(alumno=alumno_id)
	lista_areas = Area.objects.filter(cuestionario_id=con)
	res = []
	total_area = []

	alum2 = {}
	total = {}
	alum = {}

	for y in lista_areas:

		res = Resultado.objects.values('respuesta__pregunta').filter(respuesta__pregunta__area=y.id, alumno=alumno_id,
											 cont_respuesta=1).annotate(preguntacount=Count('respuesta__pregunta'))



		alum[y.id] = res.count()

	alum2[alumno_id] = alum

	for y in lista_areas:
		total_area = Pregunta.objects.all().filter(area=y.id)

		total[y.id] = total_area.count()

	alumno_side = 'active'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'

	return render_to_response('detallealumno.html',
							  {'datosid': datosid, 'lista_areas': lista_areas, 'alum2': alum2, 'total': total,
							   'datos': datos, 'alumno_side': alumno_side, 'menu_area': menu_area,
							   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def graficaralumno(request, alumno_id):
	datos = Alumno.objects.get(id=alumno_id)
	datosid = str(datos.id)
	con = Cuestionario.objects.filter(id=datos.cuestionario.id)
	#area = Area.objects.filter(cuestionario_id = con)

	ciclopreguntas = Pregunta.objects.filter(area__cuestionario__alumno__pk=alumno_id)

	for pregunta in ciclopreguntas:
		cicloresultado = Resultado.objects.filter(alumno__pk=alumno_id, respuesta__pregunta=pregunta)
		for resultado in cicloresultado:

			if resultado.cont_respuesta == 0:
				Resultado.objects.filter(alumno__pk=alumno_id, respuesta__pregunta=pregunta).update(cont_respuesta=0)

	for pregunta in ciclopreguntas:
		respuestascorrectas=Respuesta.objects.filter(pregunta=pregunta,acierto=True)
		resultadoscorrectos=Resultado.objects.filter(respuesta__pregunta=pregunta,respuesta__acierto=True,alumno__pk=alumno_id)

		if respuestascorrectas.count()!=resultadoscorrectos.count():
			resultadoscorrectos.update(cont_respuesta=0)


	#lista_alumnos= Alumno.objects.all().filter(alumno=alumno_id)
	lista_areas = Area.objects.filter(cuestionario_id=con)
	res = []
	total_area = []

	alum2 = {}
	total = {}
	alum = {}

	for y in lista_areas:
		res = Resultado.objects.values('respuesta__pregunta').filter(respuesta__pregunta__area=y.id, alumno=alumno_id,
											 cont_respuesta=1).annotate(preguntacount=Count('respuesta__pregunta'))
		alum[y.id] = res.count()

	alum2[alumno_id] = alum

	for y in lista_areas:
		total_area = Pregunta.objects.all().filter(area=y.id)

		total[y.id] = total_area.count()

	alumno_side = 'active'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	menu_cuestionario = 'closed'

	return render_to_response('conteoRespuestas.html',
							  {'datosid': datosid, 'lista_areas': lista_areas, 'alum2': alum2, 'total': total,
							   'datos': datos, 'alumno_side': alumno_side, 'menu_area': menu_area,
							   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
							   'menu_resultado': menu_resultado}, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def editaralumno(request, alumno_id):
	alumno_side = 'active'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'
	alumno = Alumno.objects.get(pk=alumno_id)
	if request.method == 'POST':
		form = AlumnoForm(request.POST, instance=alumno)
		if form.is_valid():
			form.save()
			datos = Alumno.objects.all().order_by('id')
			messages.success(request, 'Se actualizo el alumno')
			return HttpResponseRedirect('/areas/mostraralumno/')
	else:
		form = AlumnoForm(instance=alumno)
	return render_to_response('alumnoform2.html', {'form': form, 'alumno_side': alumno_side, 'menu_area': menu_area,
												   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
												   'menu_resultado': menu_resultado},
							  context_instance=RequestContext(request))


"""
Permite eliminar un registro del modelo:Alumno y muestra nuevamente  los alumnos registrados

"""


@login_required(login_url='/areas/acceder/')
def borraralumno(request, alumno_id):
	alumno = Alumno.objects.get(pk=alumno_id)
	alumno.delete()
	datos = Alumno.objects.all().order_by('id')
	messages.warning(request, 'Se elimino el alumno')
	return HttpResponseRedirect('/areas/mostraralumno/')

def califica_pregunta(pregunta, respuesta):
	respuesta_correcta = pregunta.respuesta_set.get(acierto=True)
	return respuesta_correcta == respuesta

def resultado(request):  # recibe los datos que provienen del template cuestionario
	re = []
	r = []
	e = []

	if request.method == 'POST':
		lista_preguntas = request.POST.getlist('pregunta')

		nombre_alumno = request.POST.get('nombre_alumno')
		appat = request.POST.get('appat')
		apma = request.POST.get('apma')
		cuestionario = request.POST.get('cuestionario')
		dependencia = request.POST.get('dependencia')
		area = request.POST.get('area')

		c = Cuestionario.objects.get(pk=cuestionario)
		d = Dependencia.objects.get(pk=dependencia)
		alu = Alumno.objects.create(nombre_alumno=nombre_alumno, appat=appat, apma=apma, cuestionario_id=c.id, dependencia_id=d.id, area=area)
		a = alu.id

		for preguntas in lista_preguntas:

			if request.POST.getlist(u'%s' % preguntas, ''):

				e1 = request.POST.getlist(u'%s' % preguntas)

				for e in e1:
					res = Respuesta.objects.filter(pk=e, pregunta_id=preguntas)
					for r in res:

							if r.acierto == True:
								 re = Resultado()
								 re.alumno_id = a
								 re.respuesta_id = r.id
								 re.cont_respuesta = 1
								 re.save()


							else:
								 re = Resultado()
								 re.alumno_id = a
								 re.respuesta_id = r.id
								 re.cont_respuesta = 0
								 re.save()


		return HttpResponseRedirect(reverse('servicio:termino'))


def termino(request):
	paquete = {}
	return render_to_response('termino.html', paquete, context_instance=RequestContext(request))


@login_required(login_url='servicio:acceder')
def conteo_respuestas(request):
	lista_alumnos = Alumno.objects.all()
	lista_areas = Area.objects.all().order_by('id')
	#for x in lista_alumnos:
	#lista_areas=Area.objects.filter(cuestionario_id=x.cuestionario_id)
	#print x.cuestionario_id
	#print (lista_areas)
	#con = Cuestionario.objects.get(id__in = lista_alumnos.cuestionario_id)
	#print (con)



	res = []
	total_area = []

	alum2 = {}
	total = {}
	alum = {}

	for x in lista_alumnos:
		alum = {}

		for y in lista_areas:
			res = Resultado.objects.all().filter(respuesta__pregunta__area=y.id, alumno=x.id, cont_respuesta=1)

			alum[y.id] = res.count()

		alum2[x.id] = alum

	for y in lista_areas:
		total_area = Pregunta.objects.all().filter(area=y.id)
		total[y.id] = total_area.count()

	resultado_side = 'active'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_alumno = 'closed'
	paquete = {'lista_alumnos': lista_alumnos, 'lista_areas': lista_areas, 'alum2': alum2, 'total': total, 'alum': alum,
			   'resultado_side': resultado_side, 'menu_alumno': menu_alumno, 'menu_area': menu_area,
			   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta}
	#print paquete

	return render_to_response('conteoRespuestas.html', paquete, context_instance=RequestContext(request))


@login_required(login_url='servicio:acceder')
def conteo_respuestas_tabla(request):
	lista_alumnos = Alumno.objects.all()

	lista_areas = Area.objects.all().order_by('id')

	res = []
	total_area = []

	alum2 = {}
	total = {}
	alum = {}

	for x in lista_alumnos:
		alum = {}

		for y in lista_areas:
			res = Resultado.objects.all().filter(respuesta__pregunta__area=y.id, alumno=x.id, cont_respuesta=1)

			alum[y.id] = res.count()

		alum2[x.id] = alum

	for y in lista_areas:
		total_area = Pregunta.objects.all().filter(area=y.id)
		total[y.id] = total_area.count()

	resultado_side = 'active'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_alumno = 'closed'

	paquete = {'lista_alumnos': lista_alumnos, 'lista_areas': lista_areas, 'alum2': alum2, 'total': total,
			   'resultado_side': resultado_side, 'menu_area': menu_area, 'menu_pregunta': menu_pregunta,
			   'menu_respuesta': menu_respuesta, 'menu_alumno': menu_alumno}
	return render_to_response('conteoRespuestasTabla.html', paquete, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def principal_admin(request):
	lista_alumnos = Alumno.objects.all().order_by('-fecha')[:3]

	lista_areas = Area.objects.all().order_by('id')

	res = []
	total_area = []

	alum2 = {}
	total = {}
	alum = {}

	for x in lista_alumnos:
		alum = {}

		for y in lista_areas:
			res = Resultado.objects.filter(respuesta__pregunta__area=y.id, alumno=x.id, cont_respuesta=1)

			alum[y.id] = res.count()
		alum2[x.id] = alum

	for y in lista_areas:
		total_area = Pregunta.objects.all().filter(area=y.id)
		total[y.id] = total_area.count()
	inicio_side = 'active'
	menu_alumno = 'closed'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'

	paquete = {'lista_alumnos': lista_alumnos, 'lista_areas': lista_areas, 'alum2': alum2, 'total': total,
			   'inicio_side': inicio_side, 'menu_alumno': menu_alumno, 'menu_area': menu_area,
			   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta, 'menu_resultado': menu_resultado}

	return render_to_response('conteoRespuestas.html', paquete, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def buscarAlum(request):
	resultado_side = 'active'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_alumno = 'closed'
	if request.method == 'POST':

		form = FormularioBusqueda(request.POST, request.FILES)
		if form.is_valid():

			nombre_alumno = form.cleaned_data['nombre_alumno']
			appat = form.cleaned_data['appat']
			apma = form.cleaned_data['apma']
			lista_alumnos = Alumno.objects.all().filter(nombre_alumno__icontains=nombre_alumno, appat__icontains=appat,
														apma__icontains=apma)
			lista_areas = Area.objects.all().order_by('id')

			res = []
			total_area = []

			alum2 = {}
			total = {}
			alum = {}

			for x in lista_alumnos:
				alum = {}

				for y in lista_areas:
					res = Resultado.objects.all().filter(respuesta__pregunta__area=y.id, alumno=x.id, cont_respuesta=1)

					alum[y.id] = res.count()

					alum2[x.id] = alum

			for y in lista_areas:
				total_area = Pregunta.objects.all().filter(area=y.id)
				total[y.id] = total_area.count()

			paquete = {'lista_alumnos': lista_alumnos, 'lista_areas': lista_areas, 'alum2': alum2, 'total': total,
					   'nombre_alumno': nombre_alumno, 'resultado_side': resultado_side, 'menu_area': menu_area,
					   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta, 'menu_alumno': menu_alumno}

			return render_to_response('conteoRespuestas.html', paquete, context_instance=RequestContext(request))


	else:
		form = FormularioBusqueda()  #debo retornar a la platilla de busqueda
	return render_to_response('buscar.html', {'form': form, 'resultado_side': resultado_side, 'menu_area': menu_area,
											  'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta,
											  'menu_alumno': menu_alumno}, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def pagina(request):
	lista_preguntas = Pregunta.objects.all().order_by('?')
	lista_respuesta = Respuesta.objects.all()  # Se envia todos los datos necesarios para crear el cuestionario
	paqueteP = RequestContext(request, {'lista_preguntas': lista_preguntas, 'lista_respuesta': lista_respuesta})
	return render_to_response('Cuestionario2.html', paqueteP, context_instance=RequestContext(request))


@login_required(login_url='/areas/acceder/')
def mostrarResultado(request, alumno_id):
	lista_alumnos = Alumno.objects.all().filter(alumno=alumno_id)
	lista_areas = Area.objects.all().order_by('id')

	res = []
	total_area = []

	alum2 = {}
	total = {}
	alum = {}

	for x in lista_alumnos:
		alum = {}

		for y in lista_areas:
			res = Resultado.objects.all().filter(respuesta__pregunta__area=y.id, alumno=x.id, cont_respuesta=1)

			alum[y.id] = res.count()

		alum2[x.id] = alum

	for y in lista_areas:
		total_area = Pregunta.objects.all().filter(area=y.id)
		total[y.id] = total_area.count()
	inicio_side = 'active'
	menu_alumno = 'closed'
	menu_area = 'closed'
	menu_pregunta = 'closed'
	menu_respuesta = 'closed'
	menu_resultado = 'closed'

	paquete = {'lista_alumnos': lista_alumnos, 'lista_areas': lista_areas, 'alum2': alum2, 'total': total,
			   'inicio_side': inicio_side, 'menu_alumno': menu_alumno, 'menu_area': menu_area,
			   'menu_pregunta': menu_pregunta, 'menu_respuesta': menu_respuesta, 'menu_resultado': menu_resultado}

	return render_to_response('conteoRespuestas.html', paquete, context_instance=RequestContext(request))


def envio(request, alumno_id=0):
	#correos = ",".join(["'"+s.email+"'" for s in obj.responsable.all()])
	#usuarios = ",\n".join([ s.first_name + " " +s.last_name for s in obj.responsable.all()])

	alumno = Alumno.objects.get(pk=alumno_id)

	con = Cuestionario.objects.filter(id=alumno.cuestionario.id)
	direc = Directivo.objects.filter(cuestionario_id=con)

	lista_areas = Area.objects.filter(cuestionario_id=con)
	#correo = 'mrpaxo297@gmail.com'
	correo = ",".join(["'" + s.correo + "'" for s in direc])
	text_content = ''

	#correos = ",".join(["'"+s.email+"'" for s in obj.responsable.all()])
	#try:
	#msj = str('a continuacion le envio los resultados del examen del Alumno %s %s %s %s .' %
	#(alumno.nombre_alumno, alumno.appat, alumno.apma, alumno.cuestionario.nombre_cuestionario),
	msj = 'A continuacion le envio los resultados del examen del Alumno : ' + '<br>' + '<br>'

	msj = msj + 'NOMBRE: ' + str(alumno.nombre_alumno) + '<br>'

	msj = msj + 'APELLIDO PATERNO: ' + str(alumno.appat) + '<br>'

	msj = msj + 'APELLIDO MATERNO: ' + str(alumno.apma) + '<br>'

	msj = msj + 'EXAMEN: ' + str(alumno.cuestionario.nombre_cuestionario) + '<br>'

	msj = msj + 'AREAS DEL EXAMEN: ' + '<br>' + '<br>'

	for y in lista_areas:
		res = Resultado.objects.values('respuesta__pregunta').filter(respuesta__pregunta__area=y.id, alumno=alumno_id,
											 cont_respuesta=1).annotate(preguntacount=Count('respuesta__pregunta'))
		#res = Resultado.objects.all().filter(respuesta__pregunta__area=y.id, alumno=alumno_id, cont_respuesta=1)
		res2 = Pregunta.objects.all().filter(area=y.id)
		#alum[x.id]=res.count()

		a = (res).count()
		b = (res2).count()

		msj = msj + smart_str(y.nombre_area) + '<br>'

		msj = msj + str(a) + ' aciertos ' + ' de ' + str(b) + ' preguntas ' + '<br>' + '<br>'

	subject = request.POST.get('subject', 'Resultado de examen')
	message = request.POST.get('message', msj)
	#from_email = request.POST.get('from_email', 'mrpaxo297@gmail.com')
	from_email = request.POST.get('from_email', 'dgtic@tabasco.gob.mx')
	var_email = str(correo)
	'''if subject and message and from_email:
		try:
			send_mail(subject, message, from_email, [var_email])
			messages.info(request, 'El correo fue enviado')
			return HttpResponseRedirect('/areas/mostraralumno/')
		except BadHeaderError:
			return HttpResponse('Invalid header found.')

	else:
		return HttpResponse('Make sure all fields are entered and valid.')
		#except:
		messages.info(request, 'Error')
		return HttpResponseRedirect('/areas/conteo/')'''
	try:
		for s in direc:
			subject, from_email, to = 'Examen asignado (%s)' % s.cuestionario.nombre_cuestionario, 'dgtic@tabasco.gob.mx', s.correo
			msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
			msg.attach_alternative(message, "text/html")
			msg.send()

			messages.success(request, 'Se ha enviado la informacion ')
		#send_mail(subject, message, from_email, [str(responsablefor.email)])

	except BadHeaderError:
		pass__author__ = 'paco'

	return HttpResponseRedirect('/areas/mostraralumno/')


class JasperMix(object):
	url = settings.JASPERSERVER
	username = 'jasperadmin'
	password = 'jasperadmin'

	def generateReport(self, path, namefile, params={}, tipo=None):
		"""
		Gennara reportes atravez del jasperserver
		:param path:
		:param namefile:
		:param params:
		:param tipo: default is PDF
		"""

		j = JasperClient(self.url, self.username, self.password)

		ret = j.runReport(path, ("PDF" if not tipo else tipo), params)

		f = file(namefile, 'w')

		f.write(ret['data'])

		f.close()


class imprimir(View, JasperMix):
	def get(self, request, *args, **kwargs):


		alumno_id = kwargs.get('alumno_id')

		print settings.MEDIA_ROOT

		try:
			self.generateReport(
				'/exameninformatico/produccion/resultado',
				settings.MEDIA_ROOT + 'resultado' + str(alumno_id) + '.PDF',
				{
					'alumno_id': alumno_id
				},
				'PDF'
			)

			return HttpResponseRedirect('/media/resultado' + str(alumno_id) + '.PDF')
		except Exception, e:
			messages.error(self.request, 'ocurrio un error durante la carga del reporte: [%s]' % str(e))
			return HttpResponseRedirect(reverse('servicio:mostraralumno'))