def actualizar_burdownchart_sprint(request,id_sprint):
"""
Permite la creacion o actualizacion del burndown chart
:param request:
:param id_sprint:
:return:
"""
sprint_seleccionado = Sprint.objects.get(id=id_sprint)
fecha_sprint_inicio = datetime.combine(sprint_seleccionado.fecha_inicio , datetime.min.time())
fecha_sprint_fin = datetime.combine(sprint_seleccionado.fecha_fin , datetime.min.time())
fecha_actual = datetime.now()
dias_utilizados = fecha_actual - fecha_sprint_inicio
dias_utilizados = dias_utilizados.days
dias_restantes = fecha_sprint_fin - fecha_actual
error = 'ninguno'
burn_existente_fecha = BurndownChartSprint()
try:
burn_existente_fecha = BurndownChartSprint.objects.get(id_sprint=sprint_seleccionado.id,dia = dias_restantes.days+1)
except:
pass
if request.method == 'POST':
if request.POST.get('horas_trabajadas') is not None:
#se guarda el burndown chart
try:
burn_existente_fecha = BurndownChartSprint.objects.get(id_sprint=sprint_seleccionado.id,dia = dias_restantes.days+1)
#Si trae quiere decir que existe y solo se actualizara ese burndown chart
burn_existente_fecha.horas_trabajadas=request.POST.get('horas_trabajadas')
burn_existente_fecha.save()
Sistema().registrar("Modificado burn down chart de sprint " + sprint_seleccionado.nombre_sprint, request.user.username,
"Ninguno")
except:
#Caso contrario se creara el burndown chart
BurndownChartSprint(id_sprint=sprint_seleccionado.id,dia = dias_restantes.days+1,horas_trabajadas=request.POST.get('horas_trabajadas')).save()
Sistema().registrar("Modificado burn down chart de sprint " + sprint_seleccionado.nombre_sprint, request.user.username,
"Ninguno")
redireccion = reverse('listar_sprint', args=[sprint_seleccionado.id_proyecto_id])
return HttpResponseRedirect(redireccion)
elif request.POST.get('horas_trabajadas') is None:
error = "horas"
context = {"burn":burn_existente_fecha,"sprint":sprint_seleccionado,'fecha':dias_utilizados,'dia_actual':dias_utilizados+1,'dias_restantes':dias_restantes.days,'error':error}
return render(request, "Gestion_de_BurndownChart/actualizar_burndown_chart_sprint.html",context)
context = {"burn":burn_existente_fecha,"sprint":sprint_seleccionado,'fecha':dias_utilizados,'dia_actual':dias_utilizados+1,'dias_restantes':dias_restantes.days,'error':error}
return render(request, "Gestion_de_BurndownChart/actualizar_burndown_chart_sprint.html",context)
def modificar_rol_view(request, id_rol):
"""
permite la modificacion de un rol a los usuarios con permisos adecuados
:param request:
:param id_proyecto:
:return:
"""
rol_seleccionado = Group.objects.get(pk=id_rol)
if request.method == 'POST' and 'Cancelar' in request.POST:
return HttpResponseRedirect('/listar_roles/')
if request.method == 'POST' and 'Guardar' in request.POST:
formulario = RolForm(request.POST, instance=rol_seleccionado)
if formulario.is_valid():
Sistema().registrar("Modificado rol " + rol_seleccionado.name,
request.user.username, "Ninguno")
formulario.save(rol_seleccionado)
return HttpResponseRedirect('/listar_roles/')
return HttpResponseRedirect('/listar_roles/')
formulario = RolForm(instance=rol_seleccionado)
return render_to_response("Gestion_de_roles/modificar_rol.html",
{"formulario": formulario},
context_instance=RequestContext(request))
def login_view(request):
"""
Redirecciona a la interfaz de logueo y obtiene los parametros del usuario para verificar
:param request:
:return:
"""
username = password = ''
status = "valido"
if request.POST and 'Entrar' in request.POST:
username = request.POST.get('username')
password = request.POST.get('password')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
Sistema().registrar("Ingreso al sistema el usuario "+ username+" ",request.user.username,"none")
return HttpResponseRedirect('/home/')
else:
status = "no activo"
return render_to_response('Sistema/login.html', {'username': username, 'status': status},
context_instance=RequestContext(request))
else:
status = "invalido"
return render_to_response('Sistema/login.html', {'username': username, 'status': status},
context_instance=RequestContext(request))
if request.POST and 'olvide' in request.POST:
status = "olvide"
return render_to_response('Sistema/login.html', {'status': status},
context_instance=RequestContext(request))
return render_to_response('Sistema/login.html', {'username': username, 'status': status},
context_instance=RequestContext(request))
def logout_view(request):
"""
Redirecciona al usuario a la interfaz de logueo cerrando la sesion
:param request:
:return:
"""
Sistema().registrar("Salio del sistema el usuario "+ request.user.username+" ",request.user.username,"none")
logout(request)
return render_to_response("Sistema/login.html", locals(), context_instance=RequestContext(request))
def modificar_tablero_kanban_view(request, id_tablero):
"""
Permite la modificacion de un tablero kanban especificado a la hora de seleccionar
:param request:
:param id_tablero:
:return:
"""
tablero = TableroKanban.objects.get(pk=id_tablero)
flujo = Flujo.objects.get(pk=tablero.id_flujo.id)
actividades = Actividad.objects.filter(id_Flujo_id=flujo.id)
sprint = Sprint.objects.get(pk=tablero.id_sprint.id)
proyecto_seleccionado = Proyecto.objects.get(pk=tablero.id_proyecto.id)
error = "Ninguno"
if request.method == 'POST' and 'Cancelar' in request.POST:
return HttpResponseRedirect('/listar_proyecto_kanban/')
if request.method == 'POST' and 'Guardar' in request.POST:
if request.POST.get('nombre_tablero') is not None and request.POST.get(
'sprint') is not None and request.POST.get(
"flujo") is not None:
tablero.nombre_tablero = request.POST.get('nombre_tablero')
tablero.estado_tablero = request.POST.get('estado')
tablero.id_sprint = Sprint.objects.get(
pk=request.POST.get("sprint"))
tablero.id_flujo = Flujo.objects.get(pk=request.POST.get("flujo"))
tablero.id_proyecto = Proyecto.objects.get(
pk=tablero.id_proyecto.id)
tablero.nombre_proyecto = Proyecto.objects.get(
pk=tablero.id_proyecto.id).nombre_proyecto
tablero.save()
Sistema().registrar("Modificado tablero " + tablero.nombre_tablero,
request.user.username, "Ninguno")
redireccion = reverse('listar_tablero_kanban_proyecto',
args=[tablero.id_proyecto.id])
return HttpResponseRedirect(redireccion)
else:
error = "Incompleto"
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujo,
"sprints": sprint,
"error": error
}
return render_to_response(
"Gestion_de_tablero_kanban/modificar_tablero.html",
context,
context_instance=RequestContext(request))
def eliminar_rol_view(request,
id_rol,
template_name='Gestion_de_roles/eliminar_rol.html'):
"""
La funcion Eliminar elimina un rol seleccionado
:param id_rol: el id del rol que sera eliminado
:return:
"""
rol_seleccionado = Group.objects.get(pk=id_rol)
nombre = rol_seleccionado.name
if request.method == 'POST' and 'Aceptar' in request.POST:
Group.delete(rol_seleccionado)
Sistema().registrar("Eliminado rol " + rol_seleccionado.name,
request.user.username, "Ninguno")
return HttpResponseRedirect('/listar_roles/')
else:
return render(request, template_name, {'nombre': nombre})
def eliminar_usuario_view(
request,
id_usuario,
template_name='Gestion_de_usuarios/eliminar_usuario.html'):
"""
La funcion Eliminar en realidad solo cambia el estado del usuario en la base de datos
dejandolo inactivo, a fin de tener un registro sobre el historial de los usuarios creados.
:param id_usuario: el id del usuario que sera modificado
:return:
"""
usuario_seleccionado = Usuario.objects.get(pk=id_usuario)
nombre = usuario_seleccionado.username
if request.method == 'POST' and 'Aceptar' in request.POST:
usuario_seleccionado.is_active = False
usuario_seleccionado.save()
Sistema().registrar("desactivado usuario " + nombre + " ",
request.user.username, "none")
return HttpResponseRedirect('/listar_usuarios/')
else:
return render(request, template_name, {'nombre': nombre})
def consultar_release_view(request, id_release):
"""
Permite la consulta de un release a partir del proyecto que es seleccionado
:param request:
:param id_proyecto:
:return:
"""
release_seleccionado = Release.objects.get(pk=id_release)
userstories_de_release = release_seleccionado.userstory_set.all()
context = {
'release': release_seleccionado,
'userstories': userstories_de_release
}
Sistema().registrar("Consuldta de " + release_seleccionado.nombre,
request.user.username, "Ninguno")
return render(request, 'Gestion_de_Releases/consultar_release.html',
context)
def listar_releases_view(request, id_proyecto):
"""
Permite listar releases de un proyecto seleccinado
:param request:
:param id_proyecto:
:return:
"""
proyecto_seleccionado = Proyecto.objects.get(pk=id_proyecto)
if request.method == 'POST':
form = Release_Buscar_form(request.POST)
if form.is_valid():
busqueda = form.cleaned_data.get('Busqueda')
if busqueda == '':
releases = Release.objects.filter(
proyecto=proyecto_seleccionado)
else:
releases = Release.objects.filter(
proyecto=proyecto_seleccionado).filter(nombre=busqueda)
else:
form = Release_Buscar_form()
else:
form = Release_Buscar_form()
releases = Release.objects.filter(proyecto=proyecto_seleccionado)
Sistema().registrar(
"Listado de Releases del proyecto " +
proyecto_seleccionado.nombre_proyecto, request.user.username,
"Ninguno")
context = {
'form': form,
'releases': releases,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto
}
return render(request,
'Gestion_de_Releases/lista_releases_de_proyecto.html',
context)
def eliminar_sprint_view(request, id_proyecto, id_sprint):
"""
Permite la eliminacion de un sprint especificado en el id_sprint perteneciente al
proyecto con id id_proyecto
:param request:
:param id_proyecto:
:param id_sprint:
:return:
"""
sprint_seleccionado = Sprint.objects.get(pk=id_sprint)
nombre = sprint_seleccionado.nombre_sprint
if request.method == 'POST' and 'Aceptar' in request.POST:
sprint_seleccionado.delete()
Sistema().registrar("Eliminado sprint " + nombre, request.user.username, "Ninguno")
redireccion = reverse('listar_sprint', args=[id_proyecto])
return HttpResponseRedirect(redireccion)
if request.method == 'POST' and 'Cancelar' in request.POST:
redireccion = reverse('listar_sprint', args=[id_proyecto])
return HttpResponseRedirect(redireccion)
return render(request, "Gestion_de_sprints/eliminar_sprint.html", {'nombre': nombre})
def crear_rol_view(request):
"""
Permite la creacion de un rol
:param request:
:return:
"""
if request.method == 'POST' and 'Cancelar' in request.POST:
return HttpResponseRedirect('/home/')
if request.method == 'POST' and 'Guardar' in request.POST:
formulario = RolForm(request.POST)
if formulario.is_valid():
formulario.save()
Sistema().registrar("Creado rol ", request.user.username,
"Ninguno")
return HttpResponseRedirect('/listar_roles/')
formulario = RolForm()
return render_to_response(
"Gestion_de_roles/crear_rol.html",
{'formulario': formulario},
context_instance=RequestContext(request),
)
def modificar_proyecto_view(request, id_proyecto):
"""
permite la modificacion de un proyecto que no posea un estado de finalizado o cancelado a los usuarios con permisos adecuados
:param
request:
:param id_proyecto:
:return:
"""
usuario = request.user
proyecto_seleccionado = Proyecto.objects.get(pk=id_proyecto)
formulario_original = proyecto_seleccionado
cliente_proyecto = proyecto_seleccionado.cliente
if (not usuario.has_perm('GestiondeProyectos.modificar_proyecto')
or proyecto_seleccionado.scrum_master.id != usuario.id
) and not usuario.groups.filter(name='Administrador').exists():
msg = 'El usuario no tiene permiso para modificar el proyecto'
return render(request, 'Sistema/403.html', {'msg': msg})
if request.method == 'POST' and 'Cancelar' in request.POST:
return HttpResponseRedirect('/listar_proyecto')
if request.method == 'POST' and 'Guardar' in request.POST:
formulario = ModificarProyectoForm(request.POST,
instance=proyecto_seleccionado)
#Control para que no pase de estado activo a pendiente
if (formulario_original.estado_proyecto.upper == "ACTIVO"
and request.POST.get('estado_proyecto').upper == "PENDIENTE"):
mensaje = "estado_activo_pendiente"
formulario = ModificarProyectoForm(instance=proyecto_seleccionado)
context = {
'formulario': formulario,
'id_proyecto': id_proyecto,
"error": mensaje,
'cliente': cliente_proyecto
}
return render_to_response(
'Gestion_de_Proyectos/modificar_proyecto.html',
context,
context_instance=RequestContext(request))
#Control para que la fecha de inicio sea mayor a la fecha de finalizacion
if request.POST.get('fecha_inicio') >= request.POST.get(
'fecha_finalizacion'):
context = {
'formulario': formulario,
'error': 'fechas',
'id_proyecto': id_proyecto
}
return render(request,
'Gestion_de_Proyectos/modificar_proyecto.html',
context)
#Control para que en caso de modificarse el equipo de desarrollo no se deje sin seleccionar al equipo
if request.POST.getlist('equipo_desarrollo') is None:
context = {
'formulario': formulario,
'error': 'equipo',
'id_proyecto': id_proyecto
}
return render(request,
'Gestion_de_Proyectos/modificar_proyecto.html',
context)
#Control para que se coloque una descripcion del proyecto
if request.POST.get('descripcion_proyecto') is None:
context = {
'formulario': formulario,
'error': 'descripcion',
'id_proyecto': id_proyecto
}
return render(request,
'Gestion_de_Proyectos/modificar_proyecto.html',
context)
print(request.POST.get('estado_proyecto'))
#Control de que si el proyecto pasa a estado finalizado todos los sprints y us deben ser finalizados
if request.POST.get('estado_proyecto').upper() == 'FINALIZADO':
existen_sprints_activos_o_pendientes = False
try:
sprints_proyecto = Sprint.objects.filter(
id_proyecto=id_proyecto)
for item in sprints_proyecto:
if item.estado.upper() == 'PENDIENTE' or item.estado.upper(
) == 'ACTIVO':
existen_sprints_activos_o_pendientes = True
if existen_sprints_activos_o_pendientes:
mensaje = "sprints_activos_o_pendientes"
context = {
'formulario': formulario,
'error': mensaje,
'id_proyecto': id_proyecto
}
return render(
request,
'Gestion_de_Proyectos/modificar_proyecto.html',
context)
except:
pass
try:
us_proyecto = UserStory.objects.filter(proyecto_id=id_proyecto)
existen_us_activos_o_pendientes = False
for item in us_proyecto:
if item.estado.upper() == 'PENDIENTE' or item.estado.upper(
) == 'ACTIVO':
existen_us_activos_o_pendientes = True
if existen_us_activos_o_pendientes:
mensaje = "us_activos_o_pendientes"
context = {
'formulario': formulario,
'error': mensaje,
'id_proyecto': id_proyecto
}
return render(
request,
'Gestion_de_Proyectos/modificar_proyecto.html',
context)
except:
pass
if not request.POST.get('scrum_master') is None:
proyecto_seleccionado.scrum_master = Usuario.objects.get(
pk=request.POST.get('scrum_master'))
proyecto_seleccionado.fecha_finalizacion = request.POST.get(
'fecha_finalizacion')
proyecto_seleccionado.descripcion_proyecto = request.POST.get(
'descripcion_proyecto')
proyecto_seleccionado.cliente = Usuario.objects.get(
pk=(request.POST.get('cliente')))
equipo_seleccionado = request.POST.getlist('equipo_desarrollo')
proyecto_seleccionado.equipo_desarrollo.clear()
proyecto_seleccionado.estado_proyecto = request.POST.get(
'estado_proyecto')
for item in equipo_seleccionado:
participante = Usuario.objects.get(pk=item)
proyecto_seleccionado.equipo_desarrollo.add(participante)
proyecto_seleccionado.save()
Sistema().registrar(
"Modificado proyecto " + request.POST.get('nombre_proyecto'),
request.user.username, "Ninguno")
return HttpResponseRedirect('/listar_proyecto')
formulario = ModificarProyectoForm(instance=proyecto_seleccionado)
context = {
'formulario': formulario,
'id_proyecto': id_proyecto,
'cliente': cliente_proyecto
}
return render_to_response('Gestion_de_Proyectos/modificar_proyecto.html',
context,
context_instance=RequestContext(request))
def modificar_usuario_view(request, id_usuario):
"""
Redirecciona al usuario la modificacion de un usuario especifico
:param id_usuario: el id del usuario que sera modificado
:return:
"""
grupos_permisos = Group.objects.all()
#Se obtienen los datos del usuario
usuario_seleccionado = Usuario.objects.get(pk=id_usuario)
roles_asignados = usuario_seleccionado.groups.all()
usuario_pass_hash = usuario_seleccionado.password
if request.method == 'POST' and 'Cancelar' in request.POST:
return HttpResponseRedirect('/listar_usuarios/')
if request.method == 'POST' and 'Guardar' in request.POST:
usuario_seleccionado.username = request.POST.get('username')
usuario_seleccionado.first_name = request.POST.get('firstname')
usuario_seleccionado.telefono = request.POST.get('telefono')
usuario_seleccionado.observacion = request.POST.get('observacion')
usuario_seleccionado.domicilio = request.POST.get('domicilio')
usuario_seleccionado.password = request.POST.get('password')
usuario_seleccionado.last_name = request.POST.get('lastname')
usuario_seleccionado.email = request.POST.get('email')
roles_asignados = request.POST.getlist('agregar')
if request.POST.get('activo'):
usuario_seleccionado.is_active = True
else:
usuario_seleccionado.is_active = False
#Controlara que se haya asignado un rol como minimo al modificar
if len(roles_asignados) == 0:
return render_to_response(
"Gestion_de_usuarios/modificar_usuario.html", {
'error': "roles",
'usuario': usuario_seleccionado,
'grupos': grupos_permisos,
'roles': roles_asignados
},
context_instance=RequestContext(request))
#Controla que no se hayan dejado en blanco ningun campo
if usuario_seleccionado.username != '' and usuario_seleccionado.password != '' and usuario_seleccionado.last_name != '' and usuario_seleccionado.email != '':
usuario_seleccionado.groups.clear()
#Se agrega el rol que poseera el usuario
for item in roles_asignados:
group = Group.objects.get(pk=item)
usuario_seleccionado.groups.add(group)
if usuario_seleccionado.password != usuario_pass_hash:
usuario_seleccionado.password = make_password(
usuario_seleccionado.password, salt=None, hasher='default')
usuario_seleccionado.save()
Sistema().registrar(
"modificado usuario " + usuario_seleccionado.username + " ",
request.user.username, "none")
return HttpResponseRedirect('/listar_usuarios/')
else:
return render_to_response(
"Gestion_de_usuarios/modificar_usuario.html", {
'error': "vacio",
'usuario': usuario_seleccionado,
'grupos': grupos_permisos,
'roles': roles_asignados
},
context_instance=RequestContext(request))
return render_to_response("Gestion_de_usuarios/modificar_usuario.html", {
"usuario": usuario_seleccionado,
'grupos': grupos_permisos,
'roles': roles_asignados
},
context_instance=RequestContext(request))
def crear_tablero_kanban_view(request, id_proyecto):
"""
Permite la generacion de un tablero kanban al proyecto que posee el id de id_proyecto
:param request:
:param id_proyecto:
:return:
"""
proyecto_seleccionado = Proyecto.objects.get(pk=id_proyecto)
flujos = Flujo.objects.filter(id_Proyecto=id_proyecto)
sprints = Sprint.objects.filter(id_proyecto=id_proyecto, estado="Activo")
sprints_copy = []
tablero = TableroKanban()
error = "Ninguno"
#Controla que no exista otro sprint que se encuentre activo
lista_sprint = list(Sprint.objects.filter(id_proyecto=id_proyecto))
sprints_activos = []
for item in lista_sprint:
if item.estado == "ACTIVO":
sprints_activos.append(item)
if len(sprints_activos) >= 1:
error = "sprint activo"
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error
}
return render_to_response(
"Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
#Controla que existan sprint antes de realizar la creacion del tablero
if len(sprints) == 0:
error = "cree sprint"
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error
}
return render_to_response(
"Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
uss = []
#Obtiene los us que fueron asignados a ese sprint
for item in sprints:
uss = UserStory.objects.filter(proyecto_id=id_proyecto,
nombre_sprint=item.nombre_sprint)
if len(uss) > 0:
sprints_copy.append(item)
for item in uss:
if item.usuario_asignado_id:
error == "ningun_usuario"
if error == "ningun_usuario":
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error
}
return render_to_response(
"Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
sprints = sprints_copy
#Controla que existan mas de un US dentro del sprint
if len(sprints) == 0:
error = "asigne us"
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error
}
return render_to_response(
"Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
#Controla que existan flujos para la creacion del tablero kanban
if len(flujos) == 0:
error = "asigne flujo"
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error
}
return render_to_response(
"Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
if request.method == 'POST' and 'Guardar' in request.POST:
if request.POST.get('nombre_tablero') is not None and request.POST.get(
'sprint') is not None and request.POST.get(
"flujo") is not None:
try:
error = "Contenido"
tablero1 = TableroKanban.objects.get(
id_proyecto_id=id_proyecto,
id_sprint_id=request.POST.get('sprint'),
id_flujo_id=request.POST.get('flujo'))
#Si pasa esta linea quiere decir que existe un tablero con las mismas caracteristicas en el proyecto, debe mostrar el error
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error,
'tablero_copy': tablero1
}
return render_to_response(
"Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
except:
#Si salta la excepcion quiere decir que no existe un tablero con el mismo contenido, por tanto puede continuar
pass
try:
#va a buscar en la bd si existe el tablero con el nombre indicado, de esa manera se
#controla que los nombre de los tableros no coincidan
error = "Nombre"
tablero2 = TableroKanban.objects.get(
nombre_tablero=request.POST.get('nombre_tablero'))
#si pasa a esta linea quiere decir que el tablero existe, debe mostrar un cuadro indicando el error
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error,
'tablero_copy': tablero1
}
return render_to_response(
"Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
except:
pass
tablero.nombre_tablero = request.POST.get('nombre_tablero')
tablero.estado_tablero = request.POST.get('estado')
sprint = Sprint.objects.get(pk=request.POST.get("sprint"))
flujo = Flujo.objects.get(pk=request.POST.get("flujo"))
flujo.id_sprint = sprint.id
flujo.save()
uss = UserStory.objects.filter(
proyecto_id=id_proyecto,
nombre_sprint=sprint.nombre_sprint)
actividades = list(Actividad.objects.filter(id_Flujo_id=flujo))
for us in uss:
if us.estado != "En Curso":
us.estado = "En Curso"
us.id_flujo = flujo.id
us.id_actividad = actividades[0].id
us.save()
tablero.id_sprint = sprint
tablero.id_flujo = flujo
tablero.id_proyecto = Proyecto.objects.get(pk=id_proyecto)
tablero.nombre_proyecto = Proyecto.objects.get(
pk=id_proyecto).nombre_proyecto
tablero.save()
Sistema().registrar(
"Creado tablero kanban " +
request.POST.get('nombre_tablero') + " para proyecto " +
Proyecto.objects.get(pk=id_proyecto).nombre_proyecto,
request.user.username, "Ninguno")
redireccion = reverse('listar_tablero_kanban_proyecto',
args=[id_proyecto])
return HttpResponseRedirect(redireccion)
else:
error = "Incompleto"
context = {
'tablero': tablero,
"proyecto": proyecto_seleccionado,
"flujos": flujos,
"sprints": sprints,
"error": error
}
return render_to_response("Gestion_de_tablero_kanban/crear_tablero.html",
context,
context_instance=RequestContext(request))
def modificar_sprint_view(request, id_proyecto, id_sprint):
"""
Permite la modificacion de ciertos atributos que posee un sprint que es especificado por el id id_sprint
y pertenece al proyecto con id id_proyecto
:param request:
:param id_proyecto:
:param id_sprint:
:return:
"""
proyecto_seleccionado = Proyecto.objects.get(pk=id_proyecto)
sprint_seleccionado = Sprint.objects.get(pk=id_sprint)
estado_inicial = sprint_seleccionado.estado
numero_de_sprint = sprint_seleccionado.numero_sprint
if request.method == 'POST' and 'Guardar' in request.POST:
formulario = modificar_sprint_form(request.POST, instance=sprint_seleccionado)
if formulario.is_valid():
fecha_inicio_temp = request.POST.get('fecha_inicio')
fecha_fin_temp = request.POST.get('fecha_fin')
#Se controlara que no existan 2 sprint con estados activos
if request.POST.get('estado').upper() == "ACTIVO":
otros_activos = Sprint.objects.filter(id_proyecto_id=id_proyecto ,estado="Activo")
if(len(otros_activos) > 0):
error = "activo"
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': error,'sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
#Se controla que la fecha de inicio del sprint sea menor a la fecha de fin del sprint
if control_fecha(fecha_inicio_temp,fecha_fin_temp) == False:
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'fechas','sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
#Se controla que la fecha de inicio del sprint sea menor a la fecha de fin del proyecto
if control_fecha(fecha_inicio_temp, str(proyecto_seleccionado.fecha_finalizacion)) == False:
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto,'error': 'finalizacion_proyecto', 'sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
#Se controla que la fecha de inicio del sprint sea superior a la fecha de inicio del proyecto
if control_fecha(str(proyecto_seleccionado.fecha_inicio),fecha_inicio_temp) == False:
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto,'error': 'inicio_proyecto', 'sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
#Se controla que la fecha de fin del sprint sea menor a la fecha de fin del proyecto
if control_fecha(fecha_fin_temp, str(proyecto_seleccionado.fecha_finalizacion)) == False:
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto,'error': 'fin_proyecto', 'sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
#Se controla que no vuelva a un estado pendiente si posee un estado activo
if estado_inicial.upper() == "ACTIVO" and request.POST.get('estado').upper() == "PENDIENTE":
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto,'error': 'estado', 'sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
#Se controla que no vuelva a un estado pendiente si posee un estado activo
if estado_inicial.upper() != "ACTIVO" and request.POST.get('estado').upper() == "FINALIZADO":
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto,'error': 'estado_salteado', 'sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
#Se reasignara los US si se cambia a estado finalizado
if request.POST.get('estado').upper() == "FINALIZADO":
equipo = Usuario.objects.filter(equipo_desarrollo=sprint_seleccionado.id_proyecto_id)
uss = list(UserStory.objects.filter(nombre_sprint=sprint_seleccionado.nombre_sprint))
ultima_actividad = []
completados_todos = True
mayor_size = 0
error = "Ninguno"
us_no_finalizados = []
porcentaje_total = 100
horas_en_un_dia = 12
for us in uss:
if us.porcentaje_realizado < porcentaje_total:
completados_todos = False
us_no_finalizados.append(us)
ultima_actividad.append(Actividad.objects.get(id=us.id_actividad or 0))
try:
#Se realiza en un try porque us.horas_dedicadas puede ser 0
dias_trabajados = horas_en_un_dia/us.horas_dedicadas
except:
dias_trabajados = 0
dias_restantes = us.size - dias_trabajados
if dias_restantes > mayor_size:
mayor_size = dias_restantes
uss = us_no_finalizados
lista = zip(uss,ultima_actividad)
if completados_todos == False:
#existen US que no finalizaron
try:
prox_sprint = Sprint.objects.get(numero_sprint=numero_de_sprint+1)
for us in uss:
if us.porcentaje_realizado < porcentaje_total:
us.nombre_sprint = prox_sprint.nombre_sprint
us.save()
formulario.save()
Sistema().registrar("Modificado Sprint " + sprint_seleccionado.nombre_sprint , request.user.username, "Ninguno")
context = {'equipo':equipo,'lista':lista,'prox_sprint':prox_sprint,'error':error,'mayor_size':mayor_size}
except:
error = "falta_sprint"
context = {'equipo':equipo,'lista':lista,'error':error,'mayor_size':mayor_size}
return render(request,'Gestion_de_sprints/reasignacion_de_us.html',context)
if completados_todos == True:
formulario.save()
Sistema().registrar("Modificado Sprint " + sprint_seleccionado.nombre_sprint , request.user.username, "Ninguno")
redireccion = reverse('listar_sprint', args=[id_proyecto])
return HttpResponseRedirect(redireccion)
formulario.save()
Sistema().registrar("Modificado Sprint " + sprint_seleccionado.nombre_sprint , request.user.username, "Ninguno")
redireccion = reverse('listar_sprint', args=[id_proyecto])
return HttpResponseRedirect(redireccion)
else:
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'camposobligatorios',
'sprint': sprint_seleccionado}
return render(request, 'Gestion_de_sprints/modificar_sprint.html', context)
formulario = modificar_sprint_form(instance=sprint_seleccionado)
context = {'formulario': formulario, 'proyecto': proyecto_seleccionado, 'error': 'ninguno',
'sprint': sprint_seleccionado}
return render_to_response("Gestion_de_sprints/modificar_sprint.html", context,
context_instance=RequestContext(request))
def crear_release_view(request, id_proyecto):
"""
Permite crear un release en un proyecto seleccinado
:param request:
:param id_proyecto:
:return:
"""
releases = Release.objects.all().order_by('-fecha')
if len(releases):
version_anterior = "La version del release anterior es el " + releases[
0].version
else:
version_anterior = "Este es el primer Release del proyecto"
userstories = UserStory.objects.filter(proyecto=id_proyecto).filter(
estado='APROBADO').filter(release__isnull=True)
proyecto_seleccionado = Proyecto.objects.get(pk=id_proyecto)
if request.method == 'POST' and 'Guardar' in request.POST:
nombre = request.POST.get('nombre_release')
version = request.POST.get('version_release')
descripcion = request.POST.get('descripcion_release')
us_seleccionados_id = request.POST.getlist('us_seleccionados')
if nombre == '' or version == '' or descripcion == '':
context = {
'version_anterior': version_anterior,
'userstories': userstories,
'error': 'campos',
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto
}
return render(request, 'Gestion_de_Releases/crear_release.html',
context)
if len(us_seleccionados_id) == 0:
context = {
'version_anterior': version_anterior,
'userstories': userstories,
'error': 'seleccion_us',
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto
}
return render(request, 'Gestion_de_Releases/crear_release.html',
context)
release = Release(nombre=nombre,
version=version,
descripcion=descripcion,
proyecto=proyecto_seleccionado)
release.save()
for us_seleccionado_id in us_seleccionados_id:
us_tmp = UserStory.objects.get(pk=us_seleccionado_id)
us_tmp.release = release
us_tmp.save()
Sistema().registrar(
"Creacion de Release en el proyecto " +
proyecto_seleccionado.nombre_proyecto, request.user.username,
"Ninguno")
redireccion = reverse('listar_releases_proyecto', args=[id_proyecto])
return HttpResponseRedirect(redireccion)
context = {
'version_anterior': version_anterior,
'userstories': userstories,
'error': 'ninguno',
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto
}
return render(request, 'Gestion_de_Releases/crear_release.html', context)
def cambio_us_actividad_estado_tablero_kanban_view(request, id_tablero, id_us):
"""
Permite cambiar de actividad el US al usuario que posea los permisos adecuados
:param request:
:param id_tablero:
:param id_us:
:return:
"""
us = UserStory.objects.get(pk=id_us)
tablero = TableroKanban.objects.get(pk=id_tablero)
flujo = Flujo.objects.get(pk=tablero.id_flujo.id)
actividades = Actividad.objects.filter(id_Flujo_id=flujo.id)
copy_actividades = list(actividades)
rol = ""
ultima_actividad = Actividad.objects.get(id=us.id_actividad)
siguiente_actividad = ultima_actividad
us_completado = False
#Se obtiene el rol del usuario para limitar las vistas
for permiso in request.user.groups.all():
if permiso.name == "Scrum Master":
rol = "Scrum Master"
break
if permiso.name == "Desarrollador":
rol = "Desarrollador"
#Se obtendra la siguiente actividad a realizar cuando el US posea estado Done
if us.estado_en_actividad == 'Done':
for index in range(len(copy_actividades)):
if ultima_actividad == copy_actividades[index]:
if len(copy_actividades) > index + 1:
siguiente_actividad = copy_actividades[index + 1]
break
if us.id_actividad == copy_actividades.pop(
).id and us.estado_en_actividad == "Done":
us_completado = True
######################
#rol = "Desarrollador"
######################
if request.method == 'POST':
if us_completado and rol == "Desarrollador":
estado_en_actividad = "Done"
else:
estado_en_actividad = request.POST.get('estado') or "ToDo"
if request.POST.get('comentario') == "":
error = "comentario"
context = {
'tablero': tablero,
'actividades': actividades,
"siguiente_actividad": siguiente_actividad,
'error': error,
'us': us,
"rol": rol,
"us_completado": us_completado
}
return render(
request,
'Gestion_de_tablero_kanban/cambio_actividad_estado.html',
context)
contenido_comentario = request.POST.get('comentario')
comentario = Comentario(comentario=contenido_comentario,
autor=request.user.username,
us_id=id_us)
comentario.save()
id_actividad = request.POST.get('actividad') or us.id_actividad
us.id_actividad = id_actividad
us.porcentaje_realizado = request.POST.get('porcentaje_realizado')
us.horas_dedicadas = request.POST.get('horas_dedicadas')
us.estado_en_actividad = estado_en_actividad
us.save()
if int(us.porcentaje_realizado) == 100:
proyecto = Proyecto.objects.get(id=us.proyecto_id)
scrum_master = Usuario.objects.get(id=proyecto.scrum_master.id)
enviar_notificacion("Finalizacion de US ", us.nombre,
scrum_master.email, '*****@*****.**')
#Se debe agregar un comentario o un archivo para que se guarde el cambio de estado
#Seccion para agregar un archivo a un US para realizar el cambio de actividad o estado
if request.POST.get('image') is not None:
fecha_path = str(datetime_safe.date.today()).split("-")
archivo_request = request.FILES['image']
archivo_a_adjuntar = FileAttached_model()
archivo_a_adjuntar.file = archivo_request
archivo_a_adjuntar.file_name = archivo_request.name
archivo_a_adjuntar.file_path = settings.MEDIA_URL + 'subidos/' + fecha_path[
0] + '/' + fecha_path[1] + '/' + fecha_path[2] + '/'
#archivo_a_adjuntar.save()
#if request.POST.get('image') is None and request.POST.get('comentario'):
#print error, debe ingresar uno de los dos para guardar el cambio de estado o actividad del US
Sistema().registrar(
"Cambio US " + us.nombre + " a actividad " +
ultima_actividad.nombre_actividad + " con estado " +
us.estado_en_actividad, request.user.username, "Ninguno")
redireccion = reverse('visualizar_tablero_kanban', args=[id_tablero])
return HttpResponseRedirect(redireccion)
context = {
'tablero': tablero,
'actividades': actividades,
"siguiente_actividad": siguiente_actividad,
'us': us,
"rol": rol,
"us_completado": us_completado
}
return render(request,
'Gestion_de_tablero_kanban/cambio_actividad_estado.html',
context)
def crear_sprint_view(request, id_proyecto):
"""
Permite la creacion de un sprint de limitando a un proyecto en especifico
:param request:
:param id_proyecto:
:return:
"""
proyecto_seleccionado = Proyecto.objects.get(pk=id_proyecto)
if request.method == 'POST' and 'Guardar' in request.POST:
formulario = sprint_form(request.POST)
if formulario.is_valid():
nombre_sprint_temp = request.POST.get('nombre_sprint')
fecha_inicio_temp = request.POST.get('fecha_inicio')
fecha_fin_temp = request.POST.get('fecha_fin')
#Se controla que la fecha de inicio del sprint sea menor a la fecha de fin del sprint
if control_fecha(fecha_inicio_temp,fecha_fin_temp) == False:
context = {'formulario': formulario, 'nro_sprint': proyecto_seleccionado.cantidad_sprints+1,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'fechas'}
return render(request, 'Gestion_de_sprints/crear_sprint.html', context)
#Se controla que la fecha de inicio del sprint sea menor a la fecha de fin del proyecto
if control_fecha(fecha_inicio_temp, str(proyecto_seleccionado.fecha_finalizacion)) == False:
context = {'formulario': formulario, 'nro_sprint': proyecto_seleccionado.cantidad_sprints+1,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'finalizacion_proyecto'}
return render(request, 'Gestion_de_sprints/crear_sprint.html', context)
#Se controla que la fecha de inicio del sprint sea superior a la fecha de inicio del proyecto
if control_fecha(str(proyecto_seleccionado.fecha_inicio),fecha_inicio_temp) == False:
context = {'formulario': formulario, 'nro_sprint': proyecto_seleccionado.cantidad_sprints+1,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'inicio_proyecto'}
return render(request, 'Gestion_de_sprints/crear_sprint.html', context)
#Se controla que la fecha de fin del sprint sea menor a la fecha de fin del proyecto
if control_fecha(fecha_fin_temp, str(proyecto_seleccionado.fecha_finalizacion)) == False:
context = {'formulario': formulario, 'nro_sprint': proyecto_seleccionado.cantidad_sprints+1,'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'fin_proyecto'}
return render(request, 'Gestion_de_sprints/crear_sprint.html', context)
try:
#Si ya existe un sprint con este nombre y en el mismo proyecto no va a explotar, quiere decir que esta mal, si no existe se puede guardar
sprint_prueba = Sprint.objects.get(nombre_sprint=nombre_sprint_temp,id_proyecto_id=id_proyecto)
context = {'formulario': formulario, 'nro_sprint': proyecto_seleccionado.cantidad_sprints+1,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'nombre'}
return render(request, 'Gestion_de_sprints/crear_sprint.html', context)
except:
pass
numero_sprint = proyecto_seleccionado.cantidad_sprints + 1
sprint = Sprint(nombre_sprint=nombre_sprint_temp, fecha_inicio=fecha_inicio_temp, fecha_fin=fecha_fin_temp,
id_proyecto=proyecto_seleccionado,numero_sprint=numero_sprint)
sprint.estado = "Pendiente"
sprint.save()
proyecto_seleccionado.cantidad_sprints+=1
proyecto_seleccionado.save()
Sistema().registrar("Creado Sprint " + sprint.nombre_sprint , request.user.username, "Ninguno")
redireccion = reverse('listar_sprint', args=[id_proyecto])
return HttpResponseRedirect(redireccion)
else:
context = {'formulario': formulario, 'nro_sprint': proyecto_seleccionado.cantidad_sprints+1,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto, 'error': 'camposobligatorios'}
return render(request, 'Gestion_de_sprints/crear_sprint.html', context)
formulario = sprint_form()
context = {'formulario': formulario, 'nro_sprint': proyecto_seleccionado.cantidad_sprints+1,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto}
return render_to_response("Gestion_de_sprints/crear_sprint.html", context, context_instance=RequestContext(request))
def modificar_userstory_view(request, id_userStory):
"""
Permite realizar la modificacion de un user story
:param request:
:return:
"""
usuario = request.user
us_seleccionado = UserStory.objects.get(pk=id_userStory)
proyecto = us_seleccionado.proyecto
upload_form = FileAttached_form()
usuario_es_scrum = proyecto.scrum_master.id == usuario.id
usuario_es_desarrollador = proyecto.equipo_desarrollo.filter(
pk=usuario.id).exists()
archivo = ''
if not usuario_es_scrum and not usuario_es_desarrollador:
print("chau!")
if request.method == 'POST' and 'Guardar' in request.POST:
nombre = request.POST.get('nombre')
descripcion = request.POST.get('descripcion')
prioridad = request.POST.get('prioridad')
estado = request.POST.get('estado')
valor_de_negocio = request.POST.get('valor_de_negocio')
valor_tecnico = request.POST.get('valor_tecnico')
porcentaje_realizado = request.POST.get('porcentaje_realizado')
usuario_asignado = request.POST.get('usuario_asignado')
size = request.POST.get('size')
comentario_us = request.POST.get('comentario')
horas_trabajadas = request.POST.get('horas_trabajadas')
try:
sprint_seleccionado = Sprint.objects.get(
id=request.POST.get('sprint'))
nombre_sprint = sprint_seleccionado.nombre_sprint
except:
nombre_sprint = "No Asignado"
try:
if FileAttached_model.objects.get(userstory_id=0) != None:
archivo = FileAttached_model.objects.get(userstory_id=0)
archivo.userstory_id = id_userStory
archivo.save()
except:
pass
if usuario_es_scrum:
formulario = ModificarUserStoryForm(
us_seleccionado.proyecto,
us_seleccionado.estado,
us_seleccionado.porcentaje_realizado,
sprint_inicial=us_seleccionado.nombre_sprint,
instance=us_seleccionado)
if nombre == '' or descripcion == '' or size == '' or horas_trabajadas == '':
context = {
'formulario': formulario,
'error': 'campos',
'userstory': us_seleccionado,
'usuario_es_scrum': usuario_es_scrum,
'usuario_es_desarrollador': usuario_es_desarrollador
}
return render(
request, 'Gestion_de_UserStories/modificar_userstory.html',
context)
us_seleccionado.nombre = nombre
us_seleccionado.descripcion = descripcion
us_seleccionado.prioridad = prioridad
us_seleccionado.estado = estado
us_seleccionado.valor_de_negocio = valor_de_negocio
us_seleccionado.valor_tecnico = valor_tecnico
us_seleccionado.porcentaje_realizado = porcentaje_realizado
us_seleccionado.nombre_sprint = nombre_sprint
if comentario_us != "":
comentario = Comentario(comentario=comentario_us,
autor=request.user.username,
us_id=id_userStory)
comentario.save()
if not usuario_asignado is None:
if usuario_asignado == '':
us_seleccionado.usuario_asignado = None
else:
us_seleccionado.usuario_asignado = Usuario.objects.get(
pk=usuario_asignado)
us_seleccionado.size = size
us_seleccionado.horas_dedicadas += int(horas_trabajadas)
us_seleccionado.save()
Sistema().registrar("Se modifico User Story",
request.user.username, "Ninguno")
else:
formulario = ModificarUserStoryFormDesarrollador(
us_seleccionado.estado, us_seleccionado.porcentaje_realizado)
if horas_trabajadas == '':
context = {
'formulario': formulario,
'error': 'campos',
'userstory': us_seleccionado,
'usuario_es_scrum': usuario_es_scrum,
'usuario_es_desarrollador': usuario_es_desarrollador
}
return render(
request, 'Gestion_de_UserStories/modificar_userstory.html',
context)
us_seleccionado.porcentaje_realizado = request.POST.get(
'porcentaje_realizado')
us_seleccionado.horas_dedicadas += int(horas_trabajadas)
us_seleccionado.estado = estado
us_seleccionado.save()
Sistema().registrar("Se modifico User Story ",
request.user.username, "Ninguno")
redireccion = reverse('listar_userstories_proyecto',
args=[us_seleccionado.proyecto.id])
return HttpResponseRedirect(redireccion)
if request.method == 'POST' and 'Upload' in request.POST:
if request.FILES:
fecha_path = str(datetime_safe.date.today()).split("-")
archivo_request = request.FILES['image']
archivo = FileAttached_model()
archivo.file = archivo_request
archivo.file_name = archivo_request.name
archivo.file_path = settings.MEDIA_URL + 'subidos/' + fecha_path[
0] + '/' + fecha_path[1] + '/' + fecha_path[2] + '/'
archivo.file_type = archivo_request.content_type
archivo.save()
formulario_lleno = ModificarUserStoryForm(
us_seleccionado.proyecto,
us_seleccionado.estado,
us_seleccionado.porcentaje_realizado,
sprint_inicial=us_seleccionado.nombre_sprint,
instance=us_seleccionado)
return render_to_response(
"Gestion_de_UserStories/modificar_userstory.html", {
'formulario': formulario_lleno,
'userstory': us_seleccionado,
'usuario_es_scrum': usuario_es_scrum,
'usuario_es_desarrollador': usuario_es_desarrollador
},
context_instance=RequestContext(request))
else:
print('No files')
if usuario_es_scrum:
formulario = ModificarUserStoryForm(
us_seleccionado.proyecto,
us_seleccionado.estado,
us_seleccionado.porcentaje_realizado,
sprint_inicial=us_seleccionado.nombre_sprint,
instance=us_seleccionado)
else:
formulario = ModificarUserStoryForm(
us_seleccionado.proyecto,
us_seleccionado.estado,
us_seleccionado.porcentaje_realizado,
sprint_inicial=us_seleccionado.nombre_sprint,
instance=us_seleccionado)
context = {
'formulario': formulario,
'userstory': us_seleccionado,
'usuario_es_scrum': usuario_es_scrum,
'usuario_es_desarrollador': usuario_es_desarrollador,
'upload_form': upload_form
}
return render_to_response(
"Gestion_de_UserStories/modificar_userstory.html",
context,
context_instance=RequestContext(request))
def asignar_user_story_a_sprint(request, id_sprint):
"""
Permite realizar al usuario con los permisos adecuados la asignacion de un US a un Sprint
:param request:
:param id_userStory:
:param id_proyecto:
:return:
"""
error="ninguno"
sprint = Sprint.objects.get(id=id_sprint)
fecha = sprint.fecha_fin - sprint.fecha_inicio
userStories = UserStory.objects.filter(proyecto_id=sprint.id_proyecto,nombre_sprint='No Asignado').order_by('prioridad')
userStories_copy = list(userStories)
#Se agregara a la lista los US que fueron reasignados en sprints anteriores
userReasignados = UserStory.objects.filter(proyecto_id=sprint.id_proyecto,nombre_sprint=sprint.nombre_sprint)
for us in userReasignados:
userStories_copy.append(us)
userStories = userStories_copy
proyecto = Proyecto.objects.get(id=sprint.id_proyecto.id)
usuario_equipo = Usuario.objects.filter(equipo_desarrollo=proyecto.id)
flujos = Flujo.objects.filter(id_Proyecto_id=proyecto.id)
if request.method == 'POST' and "Volver" in request.POST:
redireccion = reverse('listar_todos_sprint' )
return HttpResponseRedirect(redireccion)
if request.method == 'POST' and "Guardar" in request.POST:
usuarios = request.POST.getlist('usuario')
flujos_seleccionados = request.POST.getlist('flujo')
uss = request.POST.getlist('agregar')
flujos_copy = []
for flujo in flujos_seleccionados:
if flujo != "---":
flujos_copy.append(flujo)
flujos_seleccionados = flujos_copy
usuarios_copy = []
for usuario in usuarios:
if usuario != "---":
usuarios_copy.append(usuario)
usuarios = usuarios_copy
if len(usuarios) != len(uss):
#Debe seleccionar tantos usuarios como checkbox marco
error = "cantidad_diferente_"
for (us,usuario,flujo_seleccionado) in zip(uss,usuarios,flujos_seleccionados):
userStory = UserStory.objects.get(id=us)
userStory.nombre_sprint = sprint.nombre_sprint
userStory.usuario_asignado = Usuario.objects.get(id=usuario)
userStory.id_flujo = flujo_seleccionado
userStory.save()
Sistema().registrar("Asginado US " + userStory.nombre+" a usuario "+Usuario.objects.get(id=usuario).username , request.user.username, "Ninguno")
redireccion = reverse('listar_todos_sprint' )
return HttpResponseRedirect(redireccion)
return render_to_response("Gestion_de_sprints/asignar_us_sprint.html", {"userstories": userStories,"flujos":flujos,"sprint":sprint,"equipo":usuario_equipo,"duracion_sprint":fecha.days,'error':error},
context_instance=RequestContext(request))
def crear_userstory_view(request, id_proyecto):
"""
La funcion Crear User Story recibe 2 parametros los cuales son, la peticion natural del protocolo HTTP que contiene
todos los formularios y campos definidos en la pagina visitada por el cliente, ademas
recibe el identificador del proyecto al cual se desea agregar un User Story.
:param request:
:param id_proyecto:
:return:
"""
proyecto_seleccionado = Proyecto.objects.get(pk=id_proyecto)
formulario = CrearUserStoryForm(proyecto_seleccionado)
upload_form = FileAttached_form()
archivo = ''
error = 'sinerrores'
if request.method == 'POST' and 'Guardar' in request.POST:
formulario = CrearUserStoryForm(proyecto_seleccionado, request.POST)
if formulario.is_valid():
nombre = request.POST.get('nombre')
descripcion = request.POST.get('descripcion')
prioridad = request.POST.get('prioridad')
valor_tecnico = request.POST.get('valor_tecnico')
valor_de_negocio = request.POST.get('valor_de_negocio')
usuario_asignado = None
proyecto = proyecto_seleccionado
size = request.POST.get('size')
newuserstory = UserStory(nombre=nombre,
descripcion=descripcion,
prioridad=prioridad,
valor_de_negocio=valor_de_negocio,
valor_tecnico=valor_tecnico,
usuario_asignado=usuario_asignado,
proyecto=proyecto,
size=size)
try:
#Si me trae el siguiente us_prueba, quiere decir que ya existe en la BD, se debe cambiar el nombre
us_prueba = UserStory.objects.get(nombre=nombre,
proyecto=proyecto)
error = 'nombre'
formulario = CrearUserStoryForm(proyecto_seleccionado)
context = {
'formulario': formulario,
'error': error,
'id_proyecto': id_proyecto,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto
}
return render(request,
'Gestion_de_UserStories/crear_userstory.html',
context)
except:
pass
newuserstory.save()
try:
if FileAttached_model.objects.filter(userstory_id=0) != None:
archivo_unico = FileAttached_model.objects.get(
userstory_id=0)
archivo_unico.userstory_id = newuserstory.id
archivo_unico.save()
else:
print('no archivo')
except:
pass
codigo = generarcodigo(newuserstory.id,
proyecto_seleccionado.codigo_proyecto)
newuserstory.codigo = codigo
newuserstory.save()
Sistema().registrar("Creado User Story " + nombre,
request.user.username, "Ninguno")
redireccion = reverse('listar_userstories_proyecto',
args=[id_proyecto])
return HttpResponseRedirect(redireccion)
else:
error = 'campos'
print(formulario.errors)
formulario = CrearUserStoryForm(proyecto_seleccionado)
context = {
'formulario': formulario,
'error': error,
'id_proyecto': id_proyecto,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto
}
if request.method == 'POST' and 'Upload' in request.POST:
if request.FILES:
fecha_path = str(datetime_safe.date.today()).split("-")
archivo_request = request.FILES['image']
archivo = FileAttached_model()
archivo.file = archivo_request
archivo.file_name = archivo_request.name
archivo.file_path = settings.MEDIA_URL + 'subidos/' + fecha_path[
0] + '/' + fecha_path[1] + '/' + fecha_path[2] + '/'
archivo.file_type = archivo_request.content_type
archivo.save()
formulario_lleno = CrearUserStoryForm(proyecto_seleccionado,
request.POST)
#print(formulario_lleno.nombre)
return render_to_response(
"Gestion_de_UserStories/crear_userstory.html", {
'formulario': formulario_lleno,
'error': error,
'id_proyecto': id_proyecto,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto
},
context_instance=RequestContext(request))
else:
print('No files')
context = {
'formulario': formulario,
'error': error,
'id_proyecto': id_proyecto,
'nombre_proyecto': proyecto_seleccionado.nombre_proyecto,
'form_popup': upload_form
}
return render(request, 'Gestion_de_UserStories/crear_userstory.html',
context)
def crear_proyecto_view(request):
"""
Permite la creacion de un proyecto
:param request:
:return:
"""
usuario = request.user
if not usuario.has_perm('GestiondeProyectos.crear_proyecto'):
msg = 'El usuario no tiene permiso para crear proyectos'
return render(request, 'Sistema/403.html', {'msg': msg})
if request.method == 'POST' and 'Cancelar' in request.POST:
return HttpResponseRedirect('/home')
if request.method == 'POST' and 'Guardar' in request.POST:
formulario = CrearProyectoForm(request.POST)
if request.POST.get('cliente') is None:
context = {'formulario': formulario, 'error': 'cliente'}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html',
context)
if request.POST.get('equipo_desarrollo') is None:
context = {'formulario': formulario, 'error': 'equipo_desarrollo'}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html',
context)
if request.POST.get('scrum_master') is None:
context = {'formulario': formulario, 'error': 'scrum_master'}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html',
context)
if request.POST.get('fecha_inicio') >= request.POST.get(
'fecha_finalizacion'):
context = {'formulario': formulario, 'error': 'fechas'}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html',
context)
nombre_proyecto = request.POST.get('nombre_proyecto')
codigo_proyecto = request.POST.get('codigo_proyecto')
if Proyecto.objects.filter(nombre_proyecto=nombre_proyecto):
context = {'formulario': formulario, 'error': 'nombre'}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html',
context)
if Proyecto.objects.filter(codigo_proyecto=codigo_proyecto):
context = {'formulario': formulario, 'error': 'codigo'}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html',
context)
if formulario.is_valid():
formulario.save()
Sistema().registrar(
"Creado proyecto " + request.POST.get('nombre_proyecto'),
request.user.username, "Ninguno")
return HttpResponseRedirect('listar_proyecto')
else:
context = {'formulario': formulario, 'error': 'otro'}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html',
context)
formulario = CrearProyectoForm()
context = {'formulario': formulario}
return render(request, 'Gestion_de_Proyectos/crear_proyecto.html', context)
def crear_usuario_view(request):
"""
Redirecciona a la interfaz para la creacion de un usuario nuevo
:param request:
:return:
"""
grupo_de_permisos = Group.objects.all()
if request.method == 'POST' and 'Cancelar' in request.POST:
if request.POST.get('username') != '':
username = request.POST.get('username')
try:
temp_user = Usuario.objects.get(username=username)
temp_user.delete()
except:
None
return HttpResponseRedirect('/home/')
#Primero creara un usuario de forma temporal para poder asignar los permisos que sean elegidos
if request.method == 'POST' and 'Guardar' in request.POST:
username = request.POST.get('username')
password = make_password(request.POST.get('password'),
salt=None,
hasher='default')
lastname = request.POST.get('lastname')
email = request.POST.get('email')
activo = request.POST.get('activo')
roles_asignados = request.POST.getlist('agregar')
#Controla que el usuario a crear sea unico
if User.objects.filter(username=username).exists():
return render_to_response("Gestion_de_usuarios/crear_usuario.html",
{
'error': 'existente',
'disponibles': grupo_de_permisos
},
context_instance=RequestContext(request))
#Controlara que se haya seleccionado al menos un rol
if len(roles_asignados) == 0:
return render_to_response("Gestion_de_usuarios/crear_usuario.html",
{
'error': 'roles',
'disponibles': grupo_de_permisos
},
context_instance=RequestContext(request))
#Controla que no se hayan dejado en blanco ningun campo
if username != '' and password != '' and lastname != '' and email != '':
# Se creara el usuario
user = Usuario(username=username, password=password, email=email)
user.first_name = request.POST.get('firstname')
user.last_name = lastname
#Si no se elige una de las opciones se tomara usuario desactivado por defecto
if activo == 'true':
user.is_active = True
else:
user.is_active = False
user.is_staff = True
user.is_superuser = False
user.save()
Sistema().registrar("creado usuario " + username + " ",
request.user.username, "none")
#Se agrega el rol que poseera el usuario
for item in roles_asignados:
group = Group.objects.get(pk=item)
user.groups.add(group)
return HttpResponseRedirect('/listar_usuarios/')
#return render_to_response("Gestion_de_usuarios/crear_usuario.html", {'error': 'ninguno', 'disponibles': grupo_de_permisos},context_instance=RequestContext(request))
else:
return render_to_response("Gestion_de_usuarios/crear_usuario.html",
{
'error': 'vacio',
'disponibles': grupo_de_permisos
},
context_instance=RequestContext(request))
return render_to_response("Gestion_de_usuarios/crear_usuario.html",
{'disponibles': grupo_de_permisos},
context_instance=RequestContext(request))
