code stringlengths 1 1.72M | language stringclasses 1 value |
|---|---|
'''
Created on 20/06/2013
@author: belentwi
'''
'''
Created on 20/06/2013
@author: belentwi
'''
import os
# cur_dir = os.path.dirname(os.path.abspath(__file__))
from reportlab.lib.pagesizes import A4
from reportlab.lib.units import cm
from reportlab.lib.enums import TA_CENTER, TA_RIGHT
from geraldo import Report, ReportBand, Label, ObjectValue, SystemField, FIELD_ACTION_COUNT, BAND_WIDTH
class HistorialReport(Report):
title = 'Historial del Item'
class band_begin(ReportBand):
height = 1 * cm
elements = [
Label(text='', top=0.1 * cm,
left=8 * cm),
]
class band_summary(ReportBand):
height = 0.7 * cm
elements = [
Label(text="En total", top=0.1 * cm, left=0),
ObjectValue(attribute_name='nombre', top=0.1 * cm, left=3 * cm,
action=FIELD_ACTION_COUNT,
display_format='%s registros encontrados'),
]
borders = {'all': True}
class band_page_header(ReportBand):
height = 1.3 * cm
elements = [
SystemField(expression='%(report_title)s', top=0.1 * cm,
left=0, width=BAND_WIDTH, style={'fontName': 'Helvetica-Bold',
'fontSize': 14, 'alignment': TA_CENTER}),
Label(text="Fase", top=0.8 * cm, left=0 * cm),
Label(text="Id Item", top=0.8 * cm, left=1.5 * cm),
Label(text="Nombre", top=0.8 * cm, left=3 * cm),
Label(text="Costo", top=0.8 * cm, left=5* cm),
Label(text="Estado", top=0.8 * cm, left=6.5 * cm),
Label(text="Version", top=0.8 * cm, left=8 * cm),
Label(text="Prioridad", top=0.8 * cm, left=9.5 * cm),
Label(text="Id Padre", top=0.8 * cm, left=11 * cm),
Label(text="Id Antecesor", top=0.8 * cm, left=12.5 * cm),
Label(text="Fecha Modificacion", top=0.8 * cm, left=15 * cm),
]
borders = {'bottom': True}
class band_page_footer(ReportBand):
height = 0.5 * cm
elements = [
Label(text='Sistema de Administracion de Proyectos', top=0.1 * cm, left=0),
SystemField(expression='Pagina %(page_number)d de %(page_count)d', top=0.1 * cm,
width=BAND_WIDTH, style={'alignment': TA_RIGHT}),
]
borders = {'top': True}
class band_detail(ReportBand):
height = 0.5 * cm
elements = [
ObjectValue(attribute_name='fase.nombre', top=0, left=0 * cm),
ObjectValue(attribute_name='id_item', top=0, left=2* cm, width=7 * cm),
ObjectValue(attribute_name='nombre', top=0, left= 3* cm, width=7 * cm),
ObjectValue(attribute_name='costo', top=0, left=5 * cm, width=7 * cm),
ObjectValue(attribute_name='estado', top=0, left=6.5 * cm, width=7 * cm),
ObjectValue(attribute_name='version', top=0, left=8.5 * cm, width=7 * cm),
ObjectValue(attribute_name='prioridad', top=0, left=9.5 * cm, width=7 * cm),
ObjectValue(attribute_name='padre_id', top=0, left=11 * cm, width=7 * cm),
ObjectValue(attribute_name='antecesor_id', top=0, left=12.5 * cm, width=7 * cm),
ObjectValue(attribute_name='fecha_modificacion', top=0, left=15 * cm, width=7 * cm),
]
| Python |
'''
Created on 18/05/2013
@author: belentwi
'''
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from flask_wtf import TextAreaField
from flask_wtf import SelectField
from app.validators import Required
class SolicitudBuscar(Form):
"""
Formulario de busqueda de una solicitud de cambio
"""
id = TextField()
impacto_total = TextField()
costo_total = TextField()
observacion = TextField()
estado = TextField()
class CrearSolicitud(Form):
"""
Formulario de creacion de una solicitud de cambio
"""
observacion = TextAreaField()
items = SelectMultipleField('Items:', [Required()],
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
class ConsultarSolicitud(Form):
"""
Formulario de consulta de una solicitud de cambio
"""
impacto_total = TextField()
costo_total = TextField()
observacion = TextAreaField()
estado = TextField()
creador = TextField()
items = SelectMultipleField('Items:',
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
class VotacionSolicitud(Form):
"""
Formulario de votacion de una solicitud de cambio
"""
opciones = SelectField()
| Python |
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from app.validators import Required
from app.validators import length
class FaseBuscar(Form):
"""
#===========================================================================
# Formulario de busqueda de fases
#===========================================================================
"""
id = TextField()
nombre = TextField([(Required()) and length(min=0, max=50)])
estado = TextField([(Required()) and length(min=0, max=20)])
otros = TextField()
class FaseCrear(Form):
"""
#==============================
# Formulario para la creacion
#=============================
"""
nombre = TextField('Nombre de fase:', [(Required()) and length(min=0, max=50)])
estado = TextField('Estado de fase:', [(Required()) and length(min=0, max=20)])
fechainicio = TextField('Fecha Inicio:')
fechafin = TextField('Fecha Fin:')
class FaseModificar(Form):
"""
#==============================
# Formulario para modificar una fase
#=============================
"""
nombre = TextField('Nombre de fase:', [(Required()) and length(min=0, max=50)])
estado = SelectField('Estado:')
fechainicio = TextField('Fecha Inicio:')
fechafin = TextField('Fecha Fin:')
class FaseConsultar(Form):
"""
#======================================
# Formulario para la consulta de fases
#====================================== """
nombre = TextField('Nombre de fase:')
estado = TextField('Estado de fase:')
posicion = TextField('Posicion de fase')
fechainicio = TextField('Fecha Inicio:')
fechafin = TextField('Fecha Fin:')
tipoItems = SelectMultipleField('TipoItems de la fase seleccionada:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
items = SelectMultipleField('Items de la fase seleccionada:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
proyecto = TextField()
class FaseSeleccionar(Form):
fases = SelectMultipleField('Fases:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.RadioInput())
class FaseImportar(Form):
"""
#===========================================================================
# Formulario para la creacion a partir de la importacion de fase
#===========================================================================
"""
nombre = TextField('Nombre de fase:', [(Required()) and length(min=0, max=50)])
estado = TextField('Estado de fase:')
fechainicio = TextField('Fecha Inicio:')
fechafin = TextField('Fecha Fin:')
tipoItems = SelectMultipleField('TipoItems de la fase seleccionada:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
items = SelectMultipleField('Items de la fase seleccionada:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
fase = TextField()
| Python |
from flask_wtf import Form
from flask_wtf import EqualTo
from flask_wtf import PasswordField
from flask_wtf import TextField
from flask_wtf import SelectMultipleField
from flask_wtf import SubmitField
from flask_wtf import widgets
from app.validators import Required
from app.validators import length
from app.validators import Email
class UsuarioBuscar(Form):
"""
Formulario de busqueda de usuarios
"""
id = TextField()
nombre = TextField()
email = TextField()
estado = TextField()
class UsuarioEditable(Form):
"""
Formulario para la creacion de usuarios
"""
nombre = TextField('Nombre de usuario:', [Required(), length(min=0, max=50)])
email = TextField('Direccion de e-mail:', [Email(), length(min=0, max=50)])
contrasenha = PasswordField('Clave:', [Required(), length(min=0, max=120)])
confirm = PasswordField('Repita la clave:', [
Required(),
EqualTo('contrasenha', message='Las claves no son iguales')
])
pregunta = TextField('Pregunta de seguridad:', [Required() , length(min=0, max=80)])
respuesta = TextField('Respuesta:', [Required(), length(min=0, max=80)])
roles = SelectMultipleField('Roles:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
class UsuarioNoEditable(Form):
"""
Formulario para la consulta de usuarios
"""
nombre = TextField('Nombre de usuario:')
estado = TextField('Estado:')
email = TextField('Direccion de e-mail:')
roles = SelectMultipleField('Roles:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
class UsuarioModificacion(Form):
"""
Formulario para la modificacion de usuarios
"""
nombre = TextField('Nombre de usuario:', [Required(), length(min=0, max=50)])
email = TextField('Direccion de e-mail:', [Email(), length(min=0, max=50)])
pregunta = TextField('Pregunta de seguridad:', [Required() , length(min=0, max=80)])
respuesta = TextField('Respuesta:', [Required(), length(min=0, max=80)])
roles = SelectMultipleField('Roles:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
class UsuarioClave(Form):
"""
Formulario para la modificacion de clave de usuarios
"""
contrasenha = PasswordField('Clave:', [Required(), length(min=0, max=120)])
confirm = PasswordField('Repita la clave:', [
Required(),
EqualTo('contrasenha', message='Las claves no son iguales')
])
| Python |
'''
Created on 10/04/2013
@author: mirta
'''
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from flask_wtf import TextAreaField
from app.validators import Required
from app.validators import length
class RolBuscar(Form):
"""
Formulario de busqueda de roles
"""
id = TextField()
nombre = TextField()
class RolEditable(Form):
"""
Formulario para la creacion y modificacion de roles
"""
nombre = TextField('Nombre de rol:', [Required(), length(min=0, max=50)])
descripcion = TextAreaField('Descripcion:',[length(min=0, max=120)])
permisos = SelectMultipleField('Permisos:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
class RolNoEditable(Form):
"""
Formulario para la consulta y la eliminacion de roles
"""
nombre = TextField('Nombre de rol:')
descripcion = TextAreaField('Descripcion:')
permisos = SelectMultipleField('Permisos:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
| Python |
'''
Created on 29/04/2013
@author: belentwi
'''
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectField
from app.validators import Required
from app.validators import length
class AtributoBuscar(Form):
"""
Formulario de busqueda de atributos
"""
id = TextField()
nombre = TextField()
tipo = TextField()
descripcion = TextField()
class AtributoEditable(Form):
"""
Formulario para la creacion y modificacion de atributos
"""
nombre = TextField('Nombre:',[(Required())])
tipo = SelectField('Tipo', [Required()])
descripcion = TextField('Descripcion', [length(min=0, max=100)])
class AtributoNoEditable(Form):
"""
Formulario para la creacion y modificacion de atributos
"""
nombre = TextField('Nombre:')
tipo = TextField('Tipo')
descripcion = TextField('Descripcion', [length(min=0, max=100)])
| Python |
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import PasswordField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from flask_wtf import EqualTo
from app.validators import Required
from app.validators import length
class LoginForm(Form):
"""
Representa el formulario para el login de la aplicacion
"""
nombre = TextField('Nombre de usuario', [Required(), length(min=0, max=50)])
contrasenha = PasswordField('Clave', [Required(), length(min=0, max=120)])
class IngresarUsuarioForm(Form):
"""
Representa el formulario para el ingreso del usuario al cual se le quiere cambiar la
contrasenha
"""
nombre = TextField('Nombre de usuario', [Required(), length(min=0, max=50)])
class CambiarContrasenhaForm(Form):
"""
Representa el formulario para realizar el cambio de contrasenha de un usuario
"""
pregunta = TextField('Pregunta')
respuesta = TextField('Respuesta', [Required(), length(min=0, max=80)])
contrasenha = PasswordField('Clave', [Required(), length(min=0, max=120)])
confirm = PasswordField('Repita la clave', [
Required(),
EqualTo('contrasenha', message='Las claves no son iguales')
])
class ElegirProyectoForm(Form):
proyectos = SelectMultipleField('Proyectos:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.RadioInput())
| Python |
'''
Created on 29/04/2013
@author: mirta
'''
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from app.validators import Required
#from app.validators import length
class RelacionBuscar(Form):
"""
Formulario de busqueda de items
"""
id = TextField()
nombre = TextField()
fase = TextField()
class RelacionEditable(Form):
items = SelectMultipleField('Items:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.RadioInput()) | Python |
'''
Created on 04/04/2013
@author: belentwi
'''
from flask_wtf import Form
from flask_wtf import TextField
class EntidadBuscar(Form):
"""
Formulario de busqueda de entidades
"""
id = TextField()
nombre = TextField()
| Python |
'''
Created on 19/05/2013
@author: mirta
'''
from flask_wtf import Form
#from flask_wtf import TextField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from flask_wtf import TextAreaField
from app.validators import Required
from app.validators import length
class ComiteEditable(Form):
"""
Formulario para la creacion y modificacion de comites
"""
miembros = SelectMultipleField('Miembros:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
observacion = TextAreaField('Observacion:',[length(min=0, max=120)])
class ComiteConsultar(Form):
"""
Formulario para la consulta de miembros
"""
miembros = SelectMultipleField('Miembros:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option()) | Python |
'''
Created on 14/04/2013
@author: belentwi
'''
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from flask_wtf import IntegerField
from app.validators import Required
class ProyectoBuscar(Form):
"""
Formulario de busqueda de proyectos
"""
id = TextField()
nombre = TextField()
estado = TextField()
costo = IntegerField()
presupuesto = IntegerField()
fecha_inicio = TextField()
fecha_fin = TextField()
lider = TextField()
entidad = TextField()
class ProyectoCrear(Form):
"""
Formulario de creacion de proyectos
"""
nombre = TextField('Nombre:', [Required()])
presupuesto = IntegerField('Presupuesto:', [Required()] )
fecha_inicio = TextField('Fecha Inicio:')
fecha_fin = TextField('Fecha Fin:')
lideres = SelectField('Lider:')
class ProyectoModificar(Form):
"""
Formulario de modificacion de proyectos
"""
nombre = TextField('Nombre:', [Required()])
estado = SelectField('Estado:')
costo = IntegerField('Costo')
presupuesto = IntegerField('Presupuesto:', [Required()] )
fecha_inicio = TextField('Fecha Inicio:')
fecha_fin = TextField('Fecha Fin:')
lideres = SelectField('Lider:')
class ProyectoMiembros(Form):
"""
Formulario de asignacion y desasignacion de miembros al proyecto
"""
miembros = SelectMultipleField('Usuarios:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
proyecto = TextField('Proyecto Seleccionado:')
class ProyectoConsultar(Form):
"""
Formulario de consulta de proyectos
"""
nombre = TextField('Nombre:')
estado = TextField('Estado:')
costo = IntegerField('Costo')
presupuesto = IntegerField('Presupuesto:')
fecha_inicio = TextField('Fecha Inicio:')
fecha_fin = TextField('Fecha Fin:')
lideres = TextField('Lider:')
miembros = SelectMultipleField('Miembros:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
fases = SelectMultipleField('Fases:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
| Python |
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectField
from flask_wtf import TextAreaField
from app.validators import Required
from app.validators import length
class PermisoBuscar(Form):
"""
Formulario de busqueda de permisos
"""
id = TextField()
nombre = TextField([(Required()) and length(min=0, max=50)])
descripcion = TextField()
entidad = TextField()
class PermisoEditable(Form):
"""
Formulario para la creacion y modificacion de permisos
"""
nombre = SelectField('Permiso', [Required()])
descripcion = TextAreaField('Descripcion:',[length(min=0, max=50)])
entidad = SelectField('Entidad', [Required()])
class PermisoNoEditable(Form):
"""
Formulario para la consulta y la eliminacion de permisos
"""
nombre = TextField('Nombre del permiso:')
descripcion = TextAreaField('Descripcion:')
entidad = TextField('Entidad:')
| Python |
'''
Created on 01/05/2013
@author: belentwi
'''
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import IntegerField
from flask_wtf import SelectField
from flask_wtf import FileField
from flask_wtf import TextAreaField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from app.validators import Required
from app.validators import length
class ItemBuscar(Form):
"""
Formulario de busqueda de items
"""
id = TextField()
nombre = TextField()
version = TextField()
prioridad = TextField()
costo = TextField()
complejidad = TextField()
duracion = TextField()
estado = TextField()
descripcion = TextField()
observacion = TextField()
numero = TextField()
fecha_creacion = TextField()
fase = TextField()
linea_base = TextField()
class ItemCrear(Form):
"""
Formulario de creacion de items
"""
nombre = TextField('Nombre', [(Required()) and length(min=0, max=50)])
prioridad = SelectField('Prioridad:')
costo = IntegerField('Costo', [Required()])
complejidad = TextField('Complejidad', [Required()])
duracion = TextField('Duracion', [Required()])
descripcion = TextField('Descripcion')
observacion = TextField('Observacion')
class ItemNoEditable(Form):
"""
Formulario de consulta de items
"""
nombre = TextField('Nombre:')
tipo = TextField('Tipo:')
prioridad = TextField('Prioridad:')
costo = IntegerField('Costo:')
version = TextField('Version')
fecha_creacion = TextField('Fecha Creacion:')
complejidad = TextField('Complejidad:')
duracion = TextField('Duracion:')
descripcion = TextField('Descripcion:')
observacion = TextField('Observacion:')
estado = TextField('Estado:')
class ItemEditable(Form):
"""
Formulario de edicion de items
"""
nombre = TextField('Nombre:')
prioridad = SelectField('Prioridad:')
costo = IntegerField('Costo:')
estado = SelectField('Estado:')
complejidad = TextField('Complejidad:')
duracion = TextField('Duracion:')
descripcion = TextField('Descripcion:')
observacion = TextField('Observacion:')
class F(ItemCrear):
pass
class G(ItemNoEditable):
pass
class H(ItemEditable):
pass
class ElegirFaseForm(Form):
"""
Formulario de seleccion de fases
"""
fases = TextField()
class ElegirTipoItem(Form):
"""
Formulario de seleccion de fases
"""
tiposItems = TextField()
class ArchivoForm(Form):
archivo = FileField("Seleccione un archivo")
class ItemVerHistorial(Form):
"""
Formulario donde se visualizara el historial del item
"""
nombre = TextField('Item:')
estados = SelectMultipleField('Estados del item:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
datos = SelectMultipleField('Prioridad, Costo y complejidad del item:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
descripcion = SelectMultipleField('Descripcion, Observaciones:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
antecesores = SelectMultipleField('Antecesores del item:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
padres = SelectMultipleField('Padres del item:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
class SeleccionarVersionItem(Form):
versiones = SelectMultipleField('Versiones del Item:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.RadioInput())
item = TextField('Item seleccionado:')
class ReversionItem(Form):
"""
Formulario de reversion de items
"""
nombre = TextField('Nombre:')
prioridad = TextField('Prioridad:')
costo = TextField('Costo:')
#estado = TextField('Estado:')
complejidad = TextField('Complejidad:')
duracion = TextField('Duracion:')
| Python |
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
from app.validators import Required
from app.validators import length
class TipoItemBuscar(Form):
"""
#===========================================================================
# Formulario de busqueda de Tipo Items
#===========================================================================
"""
id = TextField()
nombre = TextField([(Required()) and length(min=0, max=50)])
class SeleccionarFase(Form):
fases = SelectMultipleField('Fases:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.RadioInput())
class TipoItemEditable(Form):
"""
#===========================================================================
# Formulario para la creacion y modificacion de tipo items
#===========================================================================
"""
nombre = TextField('Nombre de Tipo Item:', [(Required()) and length(min=0, max=50)])
atributos = SelectMultipleField('Atributos:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
fase = TextField()
class TipoItemNoEditable(Form):
"""
#===========================================================================
# Formulario para la consulta y la eliminacion de tipo items
#===========================================================================
"""
nombre = TextField('Nombre de fase:')
atributos = SelectMultipleField('Atributos:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
fase = TextField()
class SeleccionarTipoItem(Form):
tipoItems = SelectMultipleField('Tipo de Item:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.RadioInput())
fase = TextField('Fase seleccionada:')
class ImportarTipoItem(Form):
"""
#===========================================================================
# Formulario para la creacion a partir de la importacion de tipo items
#===========================================================================
"""
nombre = TextField('Nombre de Tipo Item:', [(Required()) and length(min=0, max=50)])
atributos = SelectMultipleField('Atributos:', coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.Option())
fase = TextField('Fase seleccionada:')
| Python |
'''
Created on 09/05/2013
@author: mirta
'''
from flask_wtf import Form
from flask_wtf import TextField
from flask_wtf import SelectMultipleField
from flask_wtf import widgets
#from flask_wtf import TextAreaField
from app.validators import Required
from app.validators import length
class LbBuscar(Form):
"""
Formulario de busqueda de roles
"""
id = TextField()
nombre = TextField()
estado = TextField()
fase = TextField()
class LbFases(Form):
"""
Formulario para la seleccion de fase en donde se pueden crear las lineas base
"""
fases = SelectMultipleField('Fases:', [Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.RadioInput())
class LbEditable(Form):
"""
Formulario para la creacion de lineas base
"""
nombre = TextField('Nombre de linea base:', [Required(), length(min=0, max=50)])
items = SelectMultipleField('Items:',[Required()], coerce=int,
widget=widgets.ListWidget(prefix_label=False), option_widget=widgets.CheckboxInput())
| Python |
'''
Created on 17/05/2013
@author: belentwi
'''
from app import db
class AtributoItem(db.Model):
"""
Clase que representa la tabla atributo de la base de datos
"""
__tablename__ = 'atributo_item'
id = db.Column(db.Integer, primary_key=True)
id_item = db.Column(db.Integer)
id_atributo = db.Column(db.Integer)
version = db.Column(db.Integer)
valor = db.Column(db.String(50))
def __init__(self, id_item=None, id_atributo=None, version = None, valor= ''):
self.id_atributo = id_atributo
self.id_item = id_item
self.version = version
self.valor = valor
| Python |
'''
Created on 30/04/2013
@author: mirta
'''
from app import db
from app.models.fase import Fase
from app.models.linea_base import LineaBase
from app.models.tipoItem import TipoItem
class Historial(db.Model):
__tablename__ = 'historial'
id = db.Column(db.Integer, primary_key=True)
id_item = db.Column(None, db.ForeignKey("item.id"), nullable=True)
nombre = db.Column(db.String(50))
version = db.Column(db.String(50))
prioridad = db.Column(db.String(50))
costo = db.Column(db.Float)
complejidad = db.Column(db.String(50))
duracion = db.Column(db.String(50))
estado = db.Column(db.String(50))
descripcion = db.Column(db.String(120))
observacion = db.Column(db.String(120))
numero = db.Column(db.Integer)
fecha_creacion = db.Column(db.Date)
antecesor_id = db.Column(None, db.ForeignKey("item.id"), nullable=True)
padre_id = db.Column(None, db.ForeignKey("item.id"), nullable=True)
fecha_modificacion = db.Column(db.Date)
#antecesor = db.Column(db.Integer)
#padre = db.Column(db.Integer)
fase_id = db.Column(None, db.ForeignKey("fase.id"), nullable=True)
fase = db.relation(Fase, backref=db.backref('fase_historial'))
linea_base_id = db.Column(None, db.ForeignKey("linea_base.id"), nullable=True)
linea_base = db.relation(LineaBase, backref=db.backref('lb_historial'))
tipo_id = db.Column(None, db.ForeignKey("tipo_item.id"), nullable=True)
tipo = db.relation(TipoItem, backref=db.backref('tipo_item'))
def __init__(self, nombre=None, version=None, prioridad=None, costo=None, complejidad=None,
duracion=None, estado=None, descripcion=None, observacion=None, numero=None,
fecha_creacion=None, antecesor_id=None, padre_id=None, fase=None, linea_base=None,
fecha_modificacion=None, tipo = None):
self.nombre = nombre
self.version = version
self.prioridad = prioridad
self.costo = costo
self.complejidad = complejidad
self.duracion = duracion
self.estado = estado
self.descripcion = descripcion
self.observacion = observacion
self.numero = numero
self.fecha_creacion = fecha_creacion
self.antecesor_id = antecesor_id
self.padre_id = padre_id
self.fase = fase
self.linea_base = linea_base
self.fecha_modificacion = fecha_modificacion
self.tipo = tipo
def __repr__(self):
return '<Item %r>' % (self.nombre)
def setNombre(self, nombre):
self.nombre = nombre
def setAntecesor(self, antecesor_id):
self.antecesor_id = antecesor_id
def setPadre(self, padre_id):
self.padre_id = padre_id
def setEstado(self, estado):
self.estado = estado
def setVersion(self, version):
self.version = version
def setComplejidad(self, complejidad):
self.complejidad = complejidad
def setCosto(self, costo):
self.costo = costo
def setDuracion(self, duracion):
self.duracion = duracion
def setDescripcion(self, descripcion):
self.descripcion = descripcion
def setObservacion(self, observacion):
self.observacion = observacion
def setNumero(self, numero):
self.numero = numero
def setPrioridad(self, prioridad):
self.prioridad = prioridad
def setFechaCreacion(self, fecha):
self.fecha_creacion = fecha
def setFase(self, fase):
self.fase = fase
def setLb(self, lb):
self.linea_base = lb
def setFechaModificacion(self, fecha):
self.fecha_modificacion = fecha
def setItemId(self, id_item):
self.id_item = id_item | Python |
'''
Created on 26/04/2013
@author: mirta
'''
from app import db
from app.models.fase import Fase
from app.models.linea_base import LineaBase
from app.models.archivo import Archivo
from app.models.tipoItem import TipoItem
association_table = db.Table('item_archivo', db.Model.metadata,
db.Column('item_id', db.Integer, db.ForeignKey('item.id')),
db.Column('archivo_id', db.Integer, db.ForeignKey('archivo.id'))
)
class Item(db.Model):
__tablename__ = 'item'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50))
version = db.Column(db.String(50))
prioridad = db.Column(db.String(50))
costo = db.Column(db.Integer)
complejidad = db.Column(db.String(50))
duracion = db.Column(db.String(50))
estado = db.Column(db.String(50))
descripcion = db.Column(db.String(120))
observacion = db.Column(db.String(120))
numero = db.Column(db.Integer)
fecha_creacion = db.Column(db.Date)
antecesor_id = db.Column(None, db.ForeignKey("item.id"), nullable=True)
padre_id = db.Column(None, db.ForeignKey("item.id"), nullable=True)
tipo_id = db.Column(None, db.ForeignKey("tipo_item.id"), nullable=True)
tipo = db.relation(TipoItem, backref=db.backref('tipo'))
fase_id = db.Column(None, db.ForeignKey("fase.id"), nullable=True)
fase = db.relation(Fase, backref=db.backref('items'))
linea_base_id = db.Column(None, db.ForeignKey("linea_base.id"), nullable=True)
linea_base = db.relation(LineaBase, backref=db.backref('linea_base'))
archivos = db.relationship(Archivo,
secondary=association_table,
backref="item")
__table_args__ = (db.UniqueConstraint('id','nombre', 'numero', 'fase_id', 'tipo_id', 'version', name='key_item'),
)
def __init__(self, nombre='', version='',
prioridad='', costo=None, complejidad='',
duracion='', estado='', descripcion='', observacion='', numero=None,
fecha_creacion=None, fase=None, tipo = None, antecesor_id=None, padre_id=None, linea_base=None):
self.nombre = nombre
self.version = version
self.prioridad = prioridad
self.costo = costo
self.complejidad = complejidad
self.duracion = duracion
self.estado = estado
self.descripcion = descripcion
self.observacion = observacion
self.numero = numero
self.fecha_creacion = fecha_creacion
self.fase = fase
self.tipo = tipo
self.antecesor_id = antecesor_id
self.padre_id = padre_id
self.linea_base = linea_base
def __repr__(self):
return '<Item %r>' % (self.nombre)
def setNombre(self, nombre):
self.nombre = nombre
def setAntecesor(self, antecesor_id):
self.antecesor_id = antecesor_id
def setPadre(self, padre_id):
self.padre_id = padre_id
def setEstado(self, estado):
self.estado = estado
def setVersion(self, version):
self.version = version
def add_archivo(self, archivo):
if self.archivos is None:
self.archivos = []
self.archivos.append(archivo) | Python |
'''
Created on 29/04/2013
@author: belentwi
'''
from app import db
class Atributo(db.Model):
"""
Clase que representa la tabla atributo de la base de datos
"""
__tablename__ = 'atributo'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50), unique=True)
descripcion = db.Column(db.String(100))
tipo = db.Column(db.String(50))
def __init__(self, nombre='', tipo='', descripcion = ''):
"""
Constructor de la clase Entidad
"""
self.nombre = nombre
self.tipo = tipo
self.descripcion = descripcion
def __repr__(self):
return '<Atributo %r>' % (self.nombre) | Python |
'''
Created on 03/05/2013
@author: mirta
'''
from app import db
class Archivo (db.Model):
__tablename__ = "archivo"
id = db.Column(db.Integer, primary_key=True)
datos = db.Column(db.Binary)
nombre = db.Column(db.String)
tipo = db.Column(db.String)
def __init__(self, nombre, datos, tipo):
self.datos = datos;
self.nombre = nombre;
self.tipo = tipo | Python |
'''
Created on 10/04/2013
@author: mirta
'''
from app import db
from app.models.permiso import Permiso
association_table = db.Table('rol_permiso', db.Model.metadata,
db.Column('rol_id', db.Integer, db.ForeignKey('rol.id')),
db.Column('permiso_id', db.Integer, db.ForeignKey('permiso.id'))
)
class Rol(db.Model):
"""
Clase que representa la tabla rol de la base de datos
"""
__tablename__ = 'rol'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50), unique=True)
descripcion = db.Column(db.String(120))
permiso = db.relationship(Permiso,
secondary=association_table,
backref="rol")
def __init__(self, nombre=None, descripcion=None, permiso=None):
"""
Constructor de la clase Entidad
:param nombre:
Nombre de la entidad rol
:param descripcion:
Descripcion de la entidad rol
:param permisos:
Lista de permisos que tiene la entidad rol
"""
self.nombre = nombre
self.descripcion = descripcion
self.permiso = permiso
def __repr__(self):
return '<Rol %r>' % (self.nombre)
def setNombre(self, nombre):
"""
Setea el nombre de la entidad rol
:param nombre:
nombre del rol
"""
self.nombre = nombre
def setDescripcion(self, descripcion):
"""
Setea la descripcion de la entidad rol
:param descripcion:
descripcion del rol
"""
self.descripcion = descripcion
def setPermisos(self, permisos):
"""
Setea la lista de permisos de la entidad rol
:param permisos:
lista de permisos del rol
"""
self.permiso = permisos
| Python |
'''
Created on 29/04/2013
@author: mirta
'''
from app import db
from app.models.fase import Fase
class LineaBase(db.Model):
__tablename__ = 'linea_base'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50))
estado = db.Column(db.String(50))
fecha_creacion = db.Column(db.Date)
fase_id = db.Column(None, db.ForeignKey("fase.id"), nullable=True)
fase = db.relation(Fase, backref=db.backref('fase_LB'))
def __init__(self, nombre=None, estado=None, fase=None):
self.nombre = nombre
self.estado = estado
self.fase = fase
def __repr__(self):
return '<LineaBase %r>' % (self.nombre)
def setNombre(self, nombre):
self.nombre = nombre
def setEstado(self, estado):
self.estado = estado
def setFase(self, fase):
self.fase = fase | Python |
from app import db
class Entidad(db.Model):
"""
Clase que representa la tabla entidad de la base de datos
"""
__tablename__ = 'entidad'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50), unique=True)
permiso = db.relationship("Permiso", backref="parent")
def __init__(self, nombre=None):
"""
Constructor de la clase Entidad
@param nombre: el nombre de la entidad
"""
self.nombre = nombre
def __repr__(self):
return '<Entidad %r>' % (self.nombre)
| Python |
'''
Created on 24/05/2013
@author: belentwi
'''
from app import db
class Voto(db.Model):
"""
Clase que representa la voto de la base de datos
"""
__tablename__ = 'voto'
id = db.Column(db.Integer, primary_key=True)
id_solicitud = db.Column(db.Integer)
id_usuario = db.Column(db.Integer)
voto = db.Column(db.Integer)
__table_args__ = (db.UniqueConstraint('id_solicitud', 'id_usuario', name='voto_key'),)
def __init__(self, id_solicitud=None, id_usuario=None, voto = None):
self.id_solicitud = id_solicitud
self.id_usuario = id_usuario
self.voto = voto | Python |
from app import db
from app.models.atributo import Atributo
from app.models.proyecto import Proyecto
from app.models.fase import Fase
#relacion con la tabla atributos
association_table = db.Table('tipo_item_atributo', db.Model.metadata,
db.Column('tipo_item_id', db.Integer, db.ForeignKey('tipo_item.id')),
db.Column('atributo_id', db.Integer, db.ForeignKey('atributo.id'))
)
class TipoItem(db.Model):
"""
Clase que representa la tabla TipoItem de la base de datos
"""
__tablename__ = 'tipo_item'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50))
atributo = db.relationship(Atributo,
secondary=association_table,
backref="atributo")
proyecto_id = db.Column(None, db.ForeignKey("proyecto.id"), nullable=True)
proyecto = db.relation(Proyecto, backref=db.backref('proyecto'))
fase_id = db.Column(None, db.ForeignKey("fase.id"), nullable=True)
fase = db.relation(Fase, backref=db.backref('fase'))
__table_args__ = (db.UniqueConstraint('nombre', 'proyecto_id', name='tipoitemProyecto'),)
__table_args__ = (db.UniqueConstraint('nombre', 'fase_id', name='tipoitemFase'),)
"""
Constructor de la clase Atributo
"""
def __init__(self, nombre=None, atributos=None, proyecto =None, fase =None ):
"""
:param nombre:
Nombre del atributo
:param atributos:
Lista de atributos que tiene el tipo item
:param proyecto:
proyecto al que pertenece el tipo de item
:param fase:
fase al que se asigna el tipo de item
"""
self.nombre = nombre
self.atributo = atributos
self.proyecto = proyecto
self.fase = fase
def __repr__(self):
return '<TipoItem %r>' % (self.nombre)
def setNombre(self, nombre):
"""
Setea el nombre del tipo de item
:param nombre:
nombre del tipo de item
"""
self.nombre = nombre
def setAtributo(self, atributo):
"""
Setea la lista de atributos del tipo Item
:param atributo:
lista de atributo del tipo Item
"""
self.atributo = atributo
| Python |
from app import db
from app.models.entidad import Entidad
class Permiso(db.Model):
"""
Clase que representa la tabla permiso de la base de datos
"""
__tablename__ = 'permiso'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50))
descripcion = db.Column(db.String(50))
entidad_id = db.Column(None, db.ForeignKey("entidad.id"), nullable=True)
entidad = db.relation(Entidad, backref=db.backref('entidad'))
__table_args__ = (db.UniqueConstraint('nombre', 'entidad_id', name='combinacion'),
)
def __init__(self, nombre=None,descripcion = None, entidad = None):
"""
Constructor de la clase Permiso
"""
self.nombre = nombre
self.descripcion = descripcion
self.entidad = entidad
def __repr__(self):
return '<Permiso %r>' % (self.nombre) + '<Entidad %r>' %(self.entidad_id)
def setNombre(self, nombre):
"""
Setea el nombre del permiso
:param nombre:
nombre del permiso
"""
self.nombre = nombre
def setDescripcion(self, descripcion):
"""
Setea la descripcion del permiso
:param descripcion:
descripcion del permiso
"""
self.descripcion = descripcion
def setEntidad(self, entidad):
"""
Setea la entidad relacionada al permiso
:param entidad:
entidad relacionada al permiso
"""
self.entidad = entidad
| Python |
'''
Created on 14/04/2013
@author: belentwi
'''
from app import db
from app.models.usuario import Usuario
from app.models.comite_de_cambio import ComiteDeCambio
from app.models.entidad import Entidad
association_usuario = db.Table('proyecto_usuario', db.Model.metadata,
db.Column('proyecto_id', db.Integer, db.ForeignKey('proyecto.id')),
db.Column('usuario_id', db.Integer, db.ForeignKey('usuario.id'))
)
class Proyecto(db.Model):
"""
Clase que representa la tabla proyecto de la base de datos
"""
__tablename__ = 'proyecto'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50), unique=True)
estado = db.Column(db.String(50))
costo = db.Column(db.Integer)
presupuesto = db.Column(db.Integer)
fecha_inicio = db.Column(db.Date)
fecha_fin = db.Column(db.Date)
miembros = db.relationship(Usuario,
secondary=association_usuario,
backref="proyecto")
lider_id = db.Column(None, db.ForeignKey("usuario.id"), nullable=True)
lider = db.relation(Usuario, backref=db.backref('usuario'))
entidad_id = db.Column(None, db.ForeignKey("entidad.id"), nullable=True)
entidad = db.relation(Entidad, backref=db.backref('entidad_proyecto'))
comite_id = db.Column(None, db.ForeignKey("comite_de_cambio.id"), nullable=True)
comite = db.relation(ComiteDeCambio, backref=db.backref('comite_de_cambio'))
def __init__(self, nombre=None, estado=None, costo=None, presupuesto=None, fecha_inicio=None, fecha_fin=None, lider=None, entidad=None, comite=None, miembros = []):
"""
Constructor de la clase Proyecto.
@param nombre: nombre del proyecto.
@param estado: estado del proyecto. Inicialmente se setea a Pendiente.
@param costo: costo del proyecto. Inicialmente se setea a cero.
@param presupuesto: presupuesto del proyecto.
@param fecha_inicio: la fecha en que iniciara el proyecto.
@param fecha_fin: la fecha en que culminara el proyecto.
@param lider: el usuario lider del proyecto.
@param entidad:la entidad asociada al proyecto.
"""
self.nombre = nombre
self.estado = estado
self.costo = costo
self.presupuesto = presupuesto
self.fecha_inicio = fecha_inicio
self.fecha_fin = fecha_fin
self.lider = lider
self.entidad = entidad
self.comite = comite
self.miembros = miembros
def setMiembros(self, miembros):
"""
Setea la lista de miembros del proyecto
:param miembros:
lista de miembros del proyecto
"""
self.miembros = miembros
| Python |
from app import db
from app.models.rol import Rol
association_table = db.Table('usuario_rol', db.Model.metadata,
db.Column('usuario_id', db.Integer, db.ForeignKey('usuario.id')),
db.Column('rol_id', db.Integer, db.ForeignKey('rol.id'))
)
class Usuario(db.Model):
"""
Esta clase representa la tabla de usuarios de la base de datos
"""
__tablename__ = 'usuario'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50), unique=True)
email = db.Column(db.String(50))
contrasenha = db.Column(db.String(120))
pregunta = db.Column(db.String(80))
respuesta = db.Column(db.String(80))
estado = db.Column(db.String(12))
roles = db.relationship(Rol,
secondary=association_table,
backref="usuario")
def __init__(self, nombre=None, email=None, contrasenha=None, pregunta=None, respuesta=None, estado=None, roles=None):
"""
Este metodo se utiliza para construir un registro de usuario
"""
self.nombre = nombre
self.email = email
self.contrasenha = contrasenha
self.pregunta = pregunta
self.respuesta = respuesta
self.estado = estado
self.roles = roles
def setContrasenha(self, contrasenha):
"""
Este metodo se utiliza para establecer la contrasenha de un usuario
"""
self.contrasenha = contrasenha
def setEstado(self, estado):
"""
Este metodo se utiliza para establecer el estado de un usuario
"""
self.estado = estado
def setNombre(self, nombre):
"""
Este metodo se utiliza para establecer el nombre de un usuario
"""
self.nombre = nombre
def setEmail(self, email):
"""
Este metodo se utiliza para establecer el email de un usuario
"""
self.email = email
def setPregunta(self, pregunta):
"""
Este metodo se utiliza para establecer la pregunta secreta de un usuario
"""
self.pregunta = pregunta
def setRespuesta(self, respuesta):
"""
Este metodo se utiliza para establecer la respuesta de un usuario
"""
self.respuesta = respuesta
def setRoles(self, roles):
"""
Este metodo se utiliza para establecer los roles de un usuario
"""
self.roles = roles
| Python |
'''
Created on 14/05/2013
@author: mirta
'''
from app import db
class HistorialLineaBase(db.Model):
__tablename__ = 'historial_lb'
id = db.Column(db.Integer, primary_key=True)
id_lb = db.Column(None, db.ForeignKey("linea_base.id"), nullable=True)
operacion = db.Column(db.String(100))
usuario = db.Column(db.String(50))
fecha = db.Column(db.Date)
def __init__(self, id_lb=None, operacion=None, usuario=None, fecha=None):
self.id_lb = id_lb
self.operacion = operacion
self.usuario = usuario
self.fecha = fecha
| Python |
from app import db
from app.models.proyecto import Proyecto
from app.models.entidad import Entidad
class Fase(db.Model):
"""
Clase que representa la tabla fase de la base de datos
"""
__tablename__ = 'fase'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(50))
posicion = db.Column(db.Integer)
estado = db.Column(db.String(20))
fechainicio = db.Column(db.Date)
fechafin = db.Column(db.Date)
proyecto_id = db.Column(None, db.ForeignKey("proyecto.id"), nullable=True)
proyecto = db.relation(Proyecto, backref=db.backref('fases'))
entidad_id = db.Column(None, db.ForeignKey("entidad.id"), nullable=True)
entidad = db.relation(Entidad, backref=db.backref('entidad_fase'))
__table_args__ = (db.UniqueConstraint('nombre', 'proyecto_id', name='faseProyecto'),
)
def __init__(self, nombre=None, posicion=None, estado=None, fechainicio=None, fechafin=None, proyecto =None, entidad=None):
"""
Constructor de la clase Fase
:param nombre:
Nombre de la fase
:param posicion:
posicion dentro del proyecto de la fase
:param estado:
estado de la fase
:param fechainicio:
fecha de inicio de la fase
:param fechafin:
fecha de finalizacion de la fase
:param proyecto:
proyecto al que pertenece la fase
"""
self.nombre = nombre
self.posicion = posicion
self.estado = estado
self.fechainicio = fechainicio
self.fechafin = fechafin
self.proyecto = proyecto
self.entidad = entidad
def __repr__(self):
return '<Fase %r>' % (self.nombre)
def setNombre(self, nombre):
"""
Setea el nombre de la fase
:param nombre:
nombre de la fase
"""
self.nombre = nombre
def setEstado(self, estado):
"""
Setea el estado de la fase
:param estado:
estado de la fase
"""
self.estado = estado
def setPosicion(self, posicion):
"""
Setea la posicion de la fase
:param posicion:
posicion de la fase
"""
self.posicion = posicion
def setFechainicio(self, fechainicio):
"""
Setea la fecha de inicio de la fase
:param fechainicio:
fechainicio de la fase
"""
self.fechainicio = fechainicio
def setFechafin(self, fechafin):
"""
Setea la fecha de fin de la fase
:param fechafin:
fechafin de la fase
"""
self.fechafin = fechafin
def setEntidad(self, entidad):
"""
Setea la entidad de la fase
:param entidad:
entidad de la fase
"""
self.entidad = entidad | Python |
'''
Created on 21/06/2013
@author: belentwi
'''
class SolicitudCambioReporte:
def __init__(self, id = None, observacion ='', linea_base = '', creador = None, voto = '', estado = None):
self.id = id
self.observacion = observacion
self.linea_base = linea_base
self.creador = creador
self.voto = voto
self.estado = estado
def getId(self):
return self.id
def setId(self, id):
self.id = id
def getObservacion(self):
return self.observacion
def setObservacion(self, observacion):
self.observacion = observacion
def getLineaBase(self):
return self.c
def setLineBase(self, linea_base):
self.linea_base = linea_base
def getCreador(self):
return self.creador
def setCreador(self, creador):
self.creador = creador
def getVoto(self):
return self.voto
def setVoto(self, voto):
self.voto = voto
def getEstado(self):
return self.estado
def setEstado(self, estado):
self.estado = estado
def __getitem__(self, item):
return (self.id, self.observacion, self.linea_base, self.creador, self.voto, self.estado)[item]
| Python |
'''
Created on 14/04/2013
@author: belentwi
'''
from app import db
from app.models.usuario import Usuario
association_usuario = db.Table('comite_usuario', db.Model.metadata,
db.Column('comite_id', db.Integer, db.ForeignKey('comite_de_cambio.id')),
db.Column('usuario_id', db.Integer, db.ForeignKey('usuario.id'))
)
class ComiteDeCambio(db.Model):
"""
Clase que representa la tabla comite_de_cambio de la base de datos
"""
__tablename__ = 'comite_de_cambio'
id = db.Column(db.Integer, primary_key=True)
observacion = db.Column(db.String(120))
miembros = db.relationship(Usuario,
secondary=association_usuario,
backref="comite_de_cambio")
cantidad_miembros = db.Column(db.Integer)
def __init__(self, observacion = None, miembros=None, cantidad_miembros=None):
self.observacion = observacion
self.miembros = miembros
self.cantidad_miembros = cantidad_miembros
| Python |
'''
Created on 18/05/2013
@author: belentwi
'''
from app import db
from app.models.item import Item
from app.models.usuario import Usuario
from app.models.proyecto import Proyecto
association_table = db.Table('solicitud_item', db.Model.metadata,
db.Column('item_id', db.Integer, db.ForeignKey('item.id')),
db.Column('solicitud_id', db.Integer, db.ForeignKey('solicitud_cambio.id'))
)
class SolicitudCambio(db.Model):
__tablename__ = 'solicitud_cambio'
id = db.Column(db.Integer, primary_key=True)
impacto_total = db.Column(db.String(50))
costo_total = db.Column(db.Integer)
estado = db.Column(db.String(50))
observacion = db.Column(db.String(50))
items = db.relationship(Item,
secondary=association_table,
backref="solicitud")
creador_id = db.Column(None, db.ForeignKey("usuario.id"), nullable=True)
creador = db.relation(Usuario, backref=db.backref('creador'))
proyecto_id = db.Column(None, db.ForeignKey("proyecto.id"), nullable=True)
proyecto = db.relation(Proyecto, backref=db.backref('proyectoSolicitud'))
cantidad_votos = db.Column(db.Integer)
def __init__(self, impacto_total = '', costo_total = None, estado = '', observacion = '', items = None, creador = None, proyecto = None):
self.impacto_total = impacto_total
self.costo_total = costo_total
self.estado = estado
self.observacion = observacion
self.items = items
self.creador = creador
self.cantidad_votos = 0
self.proyecto = proyecto
| Python |
'''
Created on 05/04/2013
@author: belentwi
'''
import unittest
from app import app
from test_helper import login
from test_helper import get_id_when_radio_exist
class TestCase(unittest.TestCase):
"""
Clase de Pruebas Unitarias que corresponde al Modulo de Entidades
"""
def setUp(self):
"""
Metodo invocado antes del inicio del test de la aplicacion.
Crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
self.app = app.test_client()
self.acceso = login(self.app)
def tearDown(self):
"""
Metodo invocado cuando finaliza el test de la aplicacion.
Se indican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_entidades_page(self):
"""
Metodo que trata de obtener la pagina de Administracion de Entidades de la aplicacion
"""
print "Test get entidades page"
rv = self.app.get('/entidades/administracion/')
print rv._status
self.assertEqual(rv._status, '200 OK')
if __name__ == '__main__':
unittest.main() | Python |
import unittest
from app import app
from test_helper import login
from test_helper import get_id_when_radio_exist
#Id del rol con el que probara
ID_ROL = '1'
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para los casos de uso de Usuario.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_roles(self):
"""
Controla que se pueda acceder a los usuarios
"""
request = self.app.get('/usuario/administracion/', follow_redirects=True)
#assert 'admin' in request.data
self.assertEqual(request._status, '200 OK')
def test_crear_usuario(self):
"""
Controla que se puede crear un usuario, y luego verifica si el usuario fue
anhadido, se debe tener en cuenta que si el usuario no se lista luego de ser creado el
test fallara. Ademas, que de que se intenta crear un usuario con el rol con id [1].
Si este id no existe fallara
"""
print "Probando crear un usuario"
request = self._crear_usuario('test usuario', 'test@test.com', 'dia?', 'lunes', 'test',
'test', ID_ROL)
print "Respuesta satisfactoria, verificando si creo el usuario"
request_all = self.app.get('/usuario/administracion/', follow_redirects=True)
assert 'test usuario' in request_all.data
print "Usuario creado correctamente"
def test_crear_usuario_duplicado(self):
"""
Test que prueba si se pueden crear usuarios duplicados
"""
#Ahora probamos volver a crear
print "Creacion de usuario con nombre repetido"
request = self._crear_usuario('test usuario', 'test@test.com', 'dia?', 'lunes', 'test',
'test', ID_ROL)
print "Respuesta satisfactoria, verificando si dejo crear el usuario"
assert 'El nombre de usuario ya existe, elija otro' in request.data
print "Verificacion completa, no se pueden crear dos usuarios con el mismo nombre"
def test_desactivar_usuario(self):
"""
Test que verifica si se puede desactivar un usuario
"""
print "Creando usuario con nombre test usuario 2."
request = self._crear_usuario('test usuario 2', 'test@test.com', 'dia?', 'lunes', 'test',
'test', ID_ROL)
print "Verificando si se creo el usuario"
all_request = self._get()
assert 'test usuario 2' in all_request.data
print "Usuario creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'test usuario 2')
path = 'usuario/desactivar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'El usuario ha sido desactivado con exito' in borrar_request.data
def test_desactivar_duplicado(self):
"""
Test que verifica si se puede desactivar un usuario desactivado
"""
print "Creando usuario con nombre test usuario 2."
request = self._crear_usuario('test usuario 3', 'test@test.com', 'dia?', 'lunes', 'test',
'test', ID_ROL)
print "Verificando si se creo el usuario"
all_request = self._get()
assert 'test usuario 3' in all_request.data
print "Usuario creado exitosamente"
print "Desactivando el usuario creado recientemente"
_id = get_id_when_radio_exist(all_request, 'test usuario 3')
path = 'usuario/desactivar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'El usuario ha sido desactivado con exito' in borrar_request.data
print "Volviendo a desactivar el usuario desactivado"
_id = get_id_when_radio_exist(all_request, 'test usuario 3')
path = 'usuario/desactivar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'El usuario ya se encuentra con el estado DESACTIVADO' in borrar_request.data
def _crear_usuario(self, nombre='test usuario', email='test@test.com', pregunta='dia?', respuesta='lunes', contrasenha='test', confirm='test', roles=ID_ROL):
"""
Metodo que solo sirve para crear un usuario, lo crea y retorna la respuesta
@param nombre: nombre del nuevo usuario
@param email: direccion de correo del nuevo usuario
@param pregunta: pregunta de seguridad del nuevo usuario
@param respuesta: respuesta a la pregunta de seguridad del nuevo usuario
@param contrasenha: contrasenha de acceso al sistema del nuevo usuario
@param confirm: confirmacion de la nueva contrasenha
@param roles: lista de roles que poseera el nuevo usuario en el sistema
"""
request = self.app.post('/usuario/crear/', data=dict(
nombre=nombre,
email=email,
pregunta=pregunta,
respuesta=respuesta,
contrasenha=contrasenha,
confirm=confirm,
roles=roles), follow_redirects=True)
return request
def _get(self, url ='/usuario/administracion/'):
"""
Metodo que obtiene la pagina de administracion de usuarios
@param url: url de la pagina de administracion de usuarios
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
import unittest
from app import app
from test_helper import login
from test_helper import get_id_when_radio_exist
#Id del permiso con el que probara
ID_PERMISSION = '2'
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Rol.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_roles(self):
"""
Controla que se pueda acceder a los roles, ademas verifica que almenos
el rol de administrador este creado
"""
request = self.app.get('/rol/administracion', follow_redirects=True)
assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_crear_rol(self):
"""
Controla que se puede crear un rol, y luego verifica si el rol fue
anhadido, atender que si el rol no se lista luego de ser creado el
test fallara.
Ademas atender que el intenta crear un rol con el permiso con id [1,2]
si este id no existe fallara
"""
print "Probando crear un rol"
request = self._crear_rol('test rol', 'este es un rol de prueba', ID_PERMISSION)
print "Respuesta satisfactoria, verificando si creo el rol"
request_all = self.app.get('/rol/administracion', follow_redirects=True)
assert 'test rol' in request_all.data
print "Rol creado correctamente"
def test_crear_rol_duplicado(self):
"""
Test que prueba si se pueden crear roles duplicados
"""
#Ahora probamos vovler a crear
print "Creacion de rol con nombre repetido"
request = self._crear_rol('test rol', 'este es un rol de prueba', ID_PERMISSION)
print "Respuesta satisfactoria, verificando si dejo crear el rol"
assert 'El nombre de rol ya existe, elija otro' in request.data
print "Verificacion completa, no se pueden crear dos roles con el mismo nombre"
def test_eliminar_rol(self):
"""
Test que verifica si se puede eliminar un rol
"""
print "Creando rol con nombre 'rol test 2'."
crear_request = self._crear_rol('rol test 2', 'borrar', ID_PERMISSION)
print "Verificando si se creo el rol"
all_request = self._get()
assert 'rol test 2' in all_request.data
print "Rol creado exitosament"
_id = get_id_when_radio_exist(all_request, 'rol test 2')
path = 'rol/eliminar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'El rol ha sido eliminado con exito' in borrar_request.data
def _crear_rol(self, nombre='test rol', descripcion='este es un rol de prueba', permisos=ID_PERMISSION):
"""
Metodo que solo sirve para crear un rol, lo crea y retorna la respuesta
@param nombre: nombre del nuevo rol
@param descripcion: descripcion del nuevo rol
@param premisos: permisos del nuevo rol
"""
request = self.app.post('/rol/crear/', data=dict(
nombre=nombre,
descripcion=descripcion,
permisos=permisos), follow_redirects=True)
return request
def _get(self, url ='/rol/administracion'):
"""
Metodo que obtiene la pagina de administracion de roles
@param url: url de la pagina de administracion de roles
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 05/04/2013
@author: belentwi
'''
import unittest
from app import app
from test_helper import login
class TestCase(unittest.TestCase):
"""
Clase de Pruebas Unitarias que corresponde al Modulo de Entidades
"""
def setUp(self):
"""
Metodo invocado antes del inicio del test de la aplicacion.
Crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
self.app = app.test_client()
self.acceso = login(self.app)
def tearDown(self):
"""
Metodo invocado cuando finaliza el test de la aplicacion.
Se indican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_permiso_page(self):
"""
Metodo que trata de obtener la pagina de Administracion de Permisos de la aplicacion
"""
print "Test get permisos page"
rv = self.app.get('/permisos/administracion/')
print rv._status
self.assertEqual(rv._status, '200 OK')
def test_get_crear_permiso_page(self):
"""
Metodo que trata de obtener la pagina de Creacion de Permisos de la aplicacion
"""
print "Test get crear permisos page"
rv = self.app.get('/permisos/crear/')
print rv._status
self.assertEqual(rv._status, '200 OK')
if __name__ == '__main__':
unittest.main() | Python |
import unittest
from app import app
from werkzeug import generate_password_hash
class TestCase(unittest.TestCase):
"""
TestCase, utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
Se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
def tearDown(self):
"""
Se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
#os.close(self.db_fd)
#os.unlink(DATABASE)
print "Terminando test"
def test_get_login_page(self):
"""
Este metodo realiza el test de obtencion de la pagina de login de la aplicacion
"""
print "Test get login page"
rv = self.app.get('/acceso/login/')
#print rv.data
print rv._status
self.assertEqual(rv._status, '200 OK')
def test_get_ingresar_usuario_page(self):
"""
Este metodo realiza el test de obtencion de la pagina ingresar_usuario de la
aplicacion
"""
print "Test get ingresar usuario page"
rv = self.app.get('/acceso/usuario/')
print rv._status
self.assertEqual(rv._status, '200 OK')
#def test_get_cambiar_contrasenha_page(self):
#"""
#Este metodo realiza el test de obtencion de la pagina cambiar_contrasenha de la
#aplicacion
#"""
#print "Test get cambiar de contrasenha page"
#rv = self.app.get('/acceso/contrasenha/<nombre>/')
#print rv._status
#self.assertEqual(rv._status, '200 OK')
def login(self, nombre, contrasenha):
"""
Este metodo realiza el test de ingreso a la pagina login de la aplicacion, recibe
como parametros el nombre de usuario y la contrasenha
"""
print "Test de login"
return self.app.post('/acceso/login/', data=dict(
nombre=nombre,
contrasenha=contrasenha
), follow_redirects=True)
def test_datos_login(self):
"""
Este metodo realiza el test de ingreso de datos a la pagina login de la aplicacion
"""
print "Test de ingreso de datos del login"
rv = self.login('usu_1', generate_password_hash('usu_1'))
print rv._status
self.assertEqual(rv._status, '200 OK')
#def ingresar_usuario(self, nombre):
# """
# Este metodo realiza el test de ingreso a la pagina ingresar_usuario de la aplicacion,
# recibe como parametros el nombre de usuario
# """
# print "Test de ingresar_usuario"
# return self.app.post('/acceso/usuario/', data=dict(
# nombre=nombre,
# ))
#def test_datos_ingresar_usuario(self):
# """
# Este metodo realiza el test de ingreso de datos a la pagina ingresar_usuario de la
# aplicacion
# """
# print "Test de ingreso de datos para ingresar_usuario"
# rv = self.ingresar_usuario('admin')
# print rv._status
# self.assertEqual(rv._status, '200 OK')
def test_get_elegir_proyecto_page(self):
self.test_datos_login()
#print rv._status
print "Test get elegir proyecto page"
rv = self.app.get('/acceso/proyecto/')
print rv._status
self.assertEqual(rv._status, '200 OK')
def elegir_proyecto(self, proyecto):
"""
Este metodo realiza el test de ingreso de datos a la pagina elegir proyecto de la aplicacion,
:param usuario:
Usuario que debe decidir entre los proyectos que sea miembro
"""
print "Test de login"
return self.app.post('/acceso/proyecto/', data=dict(
proyectos = proyecto
), follow_redirects=True)
def test_datos_elegir_proyecto(self):
"""
Este metodo realiza el test de ingreso de datos a la pagina elegir_proyecto de la
aplicacion
"""
print "Test de ingreso de datos para elegir_proyecto"
rv = self.elegir_proyecto('1')
print rv._status
print rv
self.assertEqual(rv._status, '200 OK')
#def test_get_pagina_principal_page(self):
#self.test_datos_login()
#print rv._status
#print "Test get elegir proyecto page"
#rv = self.app.get('/acceso/sap/')
#print rv._status
#self.assertEqual(rv._status, '200 OK')
#def ingresar_contrasenha(self, respuesta, contrasenha, confirm):
# """
# Este metodo realiza el test de ingreso a la pagina ingresar_contrasenha de la
# aplicacion, recibe como parametros una respuesta, una contrasenha y una repeticion
# de la contrasenha
# """
# print "Test de ingresar_contrasenha"
# return self.app.post('/acceso/contrasenha/<nombre>/', data=dict(
# respuesta=respuesta, contrasenha=contrasenha, confirm=confirm
# ))
#def test_datos_ingresar_contrasenha(self):
# """
# Este metodo realiza el test de ingreso de datos a la pagina ingresar_contrasenha de
# la aplicacion
# """
# print "Test de ingreso de datos para ingresar_contrasenha"
# rv = self.ingresar_contrasenha('azul',generate_password_hash('ad'),
# generate_password_hash('ad') )
# print rv._status
# self.assertEqual(rv._status, '200 OK')
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 04/06/2013
@author: mirta
'''
import unittest
from app import app
from test_helper2 import login
from test_helper2 import elegir_proyecto
from test_helper2 import get_id_when_radio_exist
from app.models.fase import Fase
from app.models.proyecto import Proyecto
from app.models.tipoItem import TipoItem
from app.models.usuario import Usuario
PROYECTO = Proyecto.query.filter_by(nombre='Proyecto pyunit').first()
FASE= Fase.query.filter_by(nombre='Fase 2', proyecto_id=PROYECTO.id).first()
TIPO= TipoItem.query.filter_by(fase_id=FASE.id).first()
USUARIO = Usuario.query.filter_by(nombre='testpy').first()
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Fase.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
self.proyecto = elegir_proyecto(self.app, PROYECTO.id)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_items(self):
"""
Controla que se pueda acceder a las fases
"""
request = self.app.get('/item/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_consultar_item(self):
"""
Test que verifica si se puede consultar una fase
"""
#crear_request = self._crear_proyecto(nombre='test proyecto3', presupuesto='2000', lideres=ID_USUARIO)
print "Consultamos la fase con nombre Fase 1"
all_request = self._get()
assert 'Item pyunit' in all_request.data
#print "Proyecto creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'Item pyunit')
path = 'item/consultar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Consultar Item' in borrar_request.data
def _get(self, url ='/item/administracion/'):
"""
Metodo que obtiene la pagina de administracion de fases
@param url: url de la pagina de administracion de fases
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 03/06/2013
@author: mirta
'''
import unittest
from app import app
from test_helper import login
from test_helper import get_id_when_radio_exist
from app.models.usuario import Usuario
#ID_USUARIO = '2'
USUARIO = Usuario.query.filter_by(nombre='usu_1').first()
ID_USUARIO = USUARIO.id
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Proyecto.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_proyectos(self):
"""
Controla que se pueda acceder a los proyectos
"""
request = self.app.get('/proyecto/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_crear_proyecto(self):
"""
Controla que se puede crear un proyecto, y luego verifica si el proyecto fue
anhadido.
"""
print "Probando crear un proyecto"
request = self._crear_proyecto(nombre='test proyecto', presupuesto='2000', lideres=ID_USUARIO)
print "Respuesta satisfactoria, verificando si creo el proyecto"
request_all = self.app.get('/proyecto/administracion/', follow_redirects=True)
assert 'test proyecto' in request_all.data
print "Proyecto creado correctamente"
def test_eliminar_proyecto(self):
"""
Test que verifica si se puede eliminar un proyecto
"""
print "Creando proyecto con nombre 'test proyecto2'."
crear_request = self._crear_proyecto(nombre='test proyecto2', presupuesto='2000', lideres=ID_USUARIO)
print "Verificando si se creo el proyecto"
all_request = self._get()
assert 'test proyecto2' in all_request.data
print "Proyecto creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'test proyecto2')
path = 'proyecto/eliminar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Se ha eliminado el proyecto exitosamente' in borrar_request.data
def test_consultar_proyecto(self):
"""
Test que verifica si se puede consultar un proyecto
"""
print "Creando proyecto con nombre 'test atributo2'."
crear_request = self._crear_proyecto(nombre='test proyecto3', presupuesto='2000', lideres=ID_USUARIO)
print "Verificando si se creo el proyecto"
all_request = self._get()
assert 'test proyecto3' in all_request.data
print "Proyecto creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'test proyecto3')
path = 'proyecto/consultar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Consulta de Proyecto' in borrar_request.data
def test_seleccionar_miembros(self):
all_request = self._get()
assert 'test proyecto' in all_request.data
print "Proyecto creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'test proyecto')
path = 'proyecto/seleccionar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Seleccionar miembros para el proyecto' in borrar_request.data
self._seleccionar_miembros(path, miembros=ID_USUARIO)
borrar_request = self._get(path)
#print borrar_request.data
#assert 'Se ha eliminado el proyecto exitosamente' in borrar_request.data
#assert 'Se ha actualizado con exito los datos de miembros para el proyecto seleccionado' in borrar_request.data
def _crear_proyecto(self, nombre='test proyecto', presupuesto='2000', lideres=ID_USUARIO):
"""
Metodo para crear un proyecto, lo crea y retorna la respuesta
@param nombre: nombre del nuevo proyecto
@param presupuesto: presupuesto estimado del nuevo proyecto
@param lideres: id del lider del nuevo proyecto
"""
request = self.app.post('/proyecto/crear/', data=dict(
nombre=nombre,
presupuesto=presupuesto,
lideres=lideres), follow_redirects=True)
return request
def _seleccionar_miembros(self, path, miembros=ID_USUARIO):
request = self.app.post(path, data=dict(
miembros=miembros), follow_redirects=True)
return request
def _get(self, url ='/proyecto/administracion/'):
"""
Metodo que obtiene la pagina de administracion de proyectos
@param url: url de la pagina de administracion de proyectos
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 04/06/2013
@author: mirta
'''
import unittest
from app import app
from test_helper2 import login
from test_helper2 import elegir_proyecto
from test_helper2 import get_id_when_radio_exist
ID_USUARIO='6'
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Comite de Cambio.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
self.proyecto = elegir_proyecto(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_comite(self):
"""
Controla que se pueda acceder a la pagina principal de comite de cambio
"""
request = self.app.get('/comite/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_crear_comite(self):
"""
Controla que se puede crear una un comite, y luego verifica si la fase fue
anhadida.
"""
print "Probando crear comite de cambio"
request = self._crear_comite(miembros=ID_USUARIO, observacion='comite test pyunit')
self.assertEqual(request._status, '200 OK')
print "Comite creado correctamente"
def test_volver_crear(self):
"""
Test que verifica que no se pueda volver a crear un comite en un proyecto
"""
print "Probando crear un comite de nuevo"
request = self._crear_comite(miembros=ID_USUARIO, observacion='comite test pyunit')
assert 'El proyecto ya cuenta con un comite de cambio' in request.data
print "Respuesta satisfactoria"
def _crear_comite(self,miembros=ID_USUARIO, observacion='comite test pyunit'):
"""
Metodo para crear un comite, lo crea y retorna la respuesta
@param miembros: id de los miembros del nuevo comite
@param observacion: observacion acerca del nuevo comite
"""
request = self.app.post('/comite/crear/', data=dict(
miembros=miembros,
observacion=observacion), follow_redirects=True)
return request
def _get(self, url ='/comite/administracion/'):
"""
Metodo que obtiene la pagina de administracion de comite
@param url: url de la pagina de administracion de comite
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 03/06/2013
@author: mirta
'''
import unittest
from app import app
from test_helper2 import login
from test_helper2 import elegir_proyecto
from test_helper2 import get_id_when_radio_exist
from app.models.proyecto import Proyecto
PROYECTO = Proyecto.query.filter_by(nombre='Proyecto pyunit').first()
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Fase.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
self.proyecto = elegir_proyecto(self.app, PROYECTO.id)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_fases(self):
"""
Controla que se pueda acceder a las fases
"""
request = self.app.get('/fases/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_crear_fase(self):
"""
Controla que se puede crear una fase, y luego verifica si la fase fue
anhadida.
"""
print "Probando crear una fase"
request = self._crear_fase(nombre='test fase', posicion='3')
print "Respuesta satisfactoria, verificando si creo la fase"
request_all = self.app.get('/fases/administracion/', follow_redirects=True)
assert 'test fase' in request_all.data
print "Fase creado correctamente"
def test_eliminar_fase(self):
"""
Test que verifica si se puede eliminar una fase
"""
print "Eliminando la fase con nombre Fase 1"
all_request = self._get()
assert 'Fase 1' in all_request.data
#print "Proyecto creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'Fase 1')
path = 'fases/eliminar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'La fase ha sido eliminada con exito' in borrar_request.data
def test_consultar_fase(self):
"""
Test que verifica si se puede consultar una fase
"""
#crear_request = self._crear_proyecto(nombre='test proyecto3', presupuesto='2000', lideres=ID_USUARIO)
print "Consultamos la fase con nombre Fase 1"
all_request = self._get()
assert 'Fase 1' in all_request.data
#print "Proyecto creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'Fase 1')
path = 'fases/consultar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Consulta de Fase' in borrar_request.data
def _crear_fase(self, nombre='test fase', posicion='3'):
"""
Metodo para crear una fase, lo crea y retorna la respuesta
@param nombre: nombre de la nueva fase
@param posicion: posicion de la nueva fase en el proyecto
"""
request = self.app.post('/fases/crear/', data=dict(
nombre=nombre,
posicion=posicion), follow_redirects=True)
return request
def _get(self, url ='/fases/administracion/'):
"""
Metodo que obtiene la pagina de administracion de fases
@param url: url de la pagina de administracion de fases
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 16/06/2013
@author: mirta
'''
import unittest
from app import app
from test_helper2 import login
from test_helper2 import elegir_proyecto
from test_helper2 import get_id_when_radio_exist
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Linea Base.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
self.proyecto = elegir_proyecto(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_linea_base(self):
"""
Controla que se pueda acceder a la pagina principal de linea base
"""
request = self.app.get('/lineabase/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_informe_linea_base(self):
"""
Test que verifica si se puede consultar una linea base
"""
#crear_request = self._crear_proyecto(nombre='test proyecto3', presupuesto='2000', lideres=ID_USUARIO)
print "Consultamos la linea base con nombre LineaBase pyunit"
all_request = self._get()
assert 'LineaBase pyunit' in all_request.data
#print "Proyecto creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'LineaBase pyunit')
path = 'lineabase/informe/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Historial de linea base:' in borrar_request.data
def _get(self, url ='/lineabase/administracion/'):
"""
Metodo que obtiene la pagina de administracion de linea base
@param url: url de la pagina de administracion de linea base
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 14/06/2013
@author: mirta
'''
import unittest
from app import app
from test_helper2 import login
from test_helper2 import elegir_proyecto
from test_helper2 import get_id_when_radio_exist
from app.models.proyecto import Proyecto
from app.models.fase import Fase
from app.models.item import Item
PROYECTO = Proyecto.query.filter_by(nombre='Proyecto pyunit').first()
FASES = Fase.query.filter_by(proyecto_id=PROYECTO.id)
FASES = FASES.all()
for fase in FASES:
if (fase.nombre=='Fase 2'):
FASE = fase
ITEMS = Item.query.filter_by(fase_id=FASE.id)
ITEMS = ITEMS.all()
for item in ITEMS:
if (item.nombre == 'Item pyunit 2'):
ITEM = item
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Solicitud de Cambio.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
self.proyecto = elegir_proyecto(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_solicitud(self):
"""
Controla que se pueda acceder a la pagina principal de solicitud de cambio
"""
request = self.app.get('/solicitud/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_crear_solicitud(self):
"""
Controla que se pueda crear una solicitud de cambio, y luego verifica si la
solicitud fue anhadida.
"""
print "Probando crear solicitud de cambio"
request = self._crear_solicitud(items=ITEM.id, observacion='solicitud test pyunit')
self.assertEqual(request._status, '200 OK')
print "Solicitud creada correctamente"
def _crear_solicitud(self,items=ITEM.id, observacion='solicitud test pyunit'):
"""
Metodo para crear una solicitud, lo crea y retorna la respuesta
@param items: id de los items de la nueva solicitud de cambio
@param observacion: observacion acerca de la nuevo solicitud de cambio
"""
request = self.app.post('/solicitud/crear/', data=dict(
items=items,
observacion=observacion), follow_redirects=True)
return request
def _get(self, url ='/solicitud/administracion/'):
"""
Metodo que obtiene la pagina de administracion de solicitud de cambio
@param url: url de la pagina de administracion de solicitud de cambio
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 20/04/2013
@author: mirta
'''
import unittest
from app import app
class TestCase(unittest.TestCase):
"""
TestCase, utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
Se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
def tearDown(self):
"""
Se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
#os.close(self.db_fd)
#os.unlink(DATABASE)
print "Terminando test"
def test_get_login_page(self):
"""
Este metodo realiza el test de obtencion de la pagina de login de la aplicacion
"""
print "Test get login page"
rv = self.app.get('/acceso/login/')
#print rv.data
print rv._status
self.assertEqual(rv._status, '200 OK')
def test_get_ingresar_usuario_page(self):
"""
Este metodo realiza el test de obtencion de la pagina ingresar_usuario de la
aplicacion
"""
print "Test get ingresar usuario page"
rv = self.app.get('/acceso/usuario/')
print rv._status
self.assertEqual(rv._status, '200 OK')
#def test_get_cambiar_contrasenha_page(self):
#"""
#Este metodo realiza el test de obtencion de la pagina cambiar_contrasenha de la
#aplicacion
#"""
#print "Test get cambiar de contrasenha page"
#rv = self.app.get('/acceso/contrasenha/<nombre>/')
#print rv._status
#self.assertEqual(rv._status, '200 OK')
def login(self, nombre, contrasenha):
"""
Este metodo realiza el test de ingreso a la pagina login de la aplicacion, recibe
como parametros el nombre de usuario y la contrasenha
"""
print "Test de login"
return self.app.post('/acceso/login/', data=dict(
nombre=nombre,
contrasenha=contrasenha
), follow_redirects=True)
def test_datos_login(self):
"""
Este metodo realiza el test de ingreso de datos a la pagina login de la aplicacion
"""
print "Test de ingreso de datos del login"
rv = self.login('admin','admin')
print rv._status
self.assertEqual(rv._status, '200 OK')
def ingresar_usuario(self, nombre):
"""
Este metodo realiza el test de ingreso a la pagina ingresar_usuario de la aplicacion,
recibe como parametros el nombre de usuario
"""
print "Test de ingresar_usuario"
return self.app.post('/acceso/usuario/', data=dict(
nombre=nombre,
), follow_redirects=True)
def test_datos_ingresar_usuario(self):
"""
Este metodo realiza el test de ingreso de datos a la pagina ingresar_usuario de la
aplicacion
"""
print "Test de ingreso de datos para ingresar_usuario"
rv = self.ingresar_usuario('admin')
print rv._status
self.assertEqual(rv._status, '200 OK')
def test_get_elegir_proyecto_page(self):
#self.test_datos_login()
#print rv._status
print "Test get elegir proyecto page"
rv = self.app.get('/acceso/proyecto/')
print rv._status
self.assertEqual(rv._status, '200 OK')
def elegir_proyecto(self, proyecto):
"""
Este metodo realiza el test de ingreso de datos a la pagina elegir proyecto de la aplicacion,
:param usuario:
Usuario que debe decidir entre los proyectos que sea miembro
"""
print "Test de login"
return self.app.post('/acceso/proyecto/', data=dict(
proyectos = proyecto
), follow_redirects=True)
def test_datos_elegir_proyecto(self):
"""
Este metodo realiza el test de ingreso de datos a la pagina elegir_proyecto de la
aplicacion
"""
print "Test de ingreso de datos para elegir_proyecto"
rv = self.elegir_proyecto('1')
print rv._status
self.assertEqual(rv._status, '200 OK')
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 16/06/2013
@author: mirta
'''
import unittest
from app import app
from test_helper2 import login
from test_helper2 import elegir_proyecto
from test_helper2 import get_id_when_radio_exist
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Relaciones.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
self.proyecto = elegir_proyecto(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_relaciones(self):
"""
Controla que se pueda acceder a la pagina principal de relaciones
"""
request = self.app.get('/relacion/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def _get(self, url ='/relacion/administracion/'):
"""
Metodo que obtiene la pagina de administracion de relaciones
@param url: url de la pagina de administracion de relaciones
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 23/05/2013
@author: mirta
'''
import unittest
from app import app
from test_helper import login
from test_helper import get_id_when_radio_exist
#Id del permiso con el que probara
ID_TIPO = '1'
class TestCase(unittest.TestCase):
"""
Clase que implementa los test para el caso de uso Atributo.
Utilizamos esta clase para realizar las pruebas de nuestra aplicacion SAP
"""
def setUp(self):
"""
se llama a este metodo antes de iniciar el test de la aplicacion
, este metodo crea un nuevo cliente de prueba.
Se especifican las acciones a ser tomadas antes de iniciar el test
"""
print "Iniciando test"
#self.db_fd, app.config['DATABASE'] = tempfile.mkstemp()
self.app = app.test_client()
self.acceso = login(self.app)
def tearDown(self):
"""
se llama a este metodo al terminar el test el test de la aplicacion,
en el se especifican las acciones a ser tomadas al finalizar el test
"""
print "Terminando test"
def test_get_all_atributos(self):
"""
Controla que se pueda acceder a los atributos
"""
request = self.app.get('/atributo/administracion/', follow_redirects=True)
#assert 'Administrador' in request.data
self.assertEqual(request._status, '200 OK')
def test_crear_atributo(self):
"""
Controla que se puede crear un atributo, y luego verifica si el atributo fue
anhadido.
"""
print "Probando crear un atributo"
request = self._crear_atributo(nombre='test atributo', tipo=ID_TIPO)
print "Respuesta satisfactoria, verificando si creo el atributo"
request_all = self.app.get('/atributo/administracion/', follow_redirects=True)
assert 'test atributo' in request_all.data
print "Atributo creado correctamente"
def test_eliminar_atributo(self):
"""
Test que verifica si se puede eliminar un atributo
"""
print "Creando atributo con nombre 'test atributo2'."
crear_request = self._crear_atributo(nombre='test atributo2', tipo=ID_TIPO)
print "Verificando si se creo el atributo"
all_request = self._get()
assert 'test atributo2' in all_request.data
print "Atributo creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'test atributo2')
path = 'atributo/eliminar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Se ha eliminado el atributo exitosamente' in borrar_request.data
def test_consultar_atributo(self):
"""
Test que verifica si se puede eliminar un atributo
"""
print "Creando atributo con nombre 'test atributo2'."
crear_request = self._crear_atributo(nombre='test atributo3', tipo=ID_TIPO)
print "Verificando si se creo el atributo"
all_request = self._get()
assert 'test atributo3' in all_request.data
print "Atributo creado exitosamente"
_id = get_id_when_radio_exist(all_request, 'test atributo3')
path = 'atributo/consultar/{0}/'.format(_id)
#print "------------------------------"
#print path
borrar_request = self._get(path)
#print borrar_request.data
assert 'Aceptar' in borrar_request.data
def _crear_atributo(self, nombre='test atributo', tipo=ID_TIPO):
"""
Metodo para crear un ratributo, lo crea y retorna la respuesta
@param nombre: nombre del nuevo atributo
@param tipo: id del tipo que sera el nuevo atributo
"""
request = self.app.post('/atributo/crear/', data=dict(
nombre=nombre,
tipo=tipo), follow_redirects=True)
return request
def _get(self, url ='/atributo/administracion/'):
"""
Metodo que obtiene la pagina de administracion de atributos
@param url: url de la pagina de administracion de atributos
"""
return self.app.get(url, follow_redirects=True)
if __name__ == '__main__':
unittest.main() | Python |
'''
Created on 18/06/2013
@author: mirta
'''
class Arista:
def __init__(self, origen, destino, tipo):
self.origen = origen
self.destino = destino
self.tipo = tipo
#Convertimos un nodo a un mapa
def construir_arista(origen, destino, tipo):
return {
'origen' : origen,
'destino' : destino,
'tipo' : tipo
}
#Convertimos una lista de Nodos a una lista de mapas (para jsonificar)
def construir_lista_arista(aristas):
result = []
for arista in aristas:
result.append(construir_arista(arista.origen, arista.destino, arista.tipo))
return result
#Construimos unos cuantos nodos
#nodo1 = Nodo('1', 'nodo 1', '200');
#nodo2 = Nodo('2', 'nodo 2', '300');
#nodo3 = Nodo('3', 'nodo 3', '400');
#esto es lo que recibimos de la db guau
#nodos = [ nodo1, nodo2, nodo3 ]
#print json.dumps(construir_lista(nodos)) | Python |
'''
Created on 29/04/2013
@author: mirta
'''
from datetime import date
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from flask import current_app
from app import db
from app.security import g
from app.security import permission
from app.wtforms.relacion_forms import RelacionBuscar
from app.wtforms.relacion_forms import RelacionEditable
from app.models.item import Item
from app.models.fase import Fase
from app.models.linea_base import LineaBase
from app.models.historial import Historial
from app.models.permiso import Permiso
mod = Blueprint('relaciones', __name__, url_prefix='/relacion')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_RELACIONES')
def administracion_relacion():
"""
Muestra en pantalla los items que existen en el proyecto con el cual se logueo el usuario.
Si no recibe algun filtro como parametro, lista todos los items.
Si recibe algun filtro, muestra los items que cumplen con el filtro indicado
"""
if g.proyecto==None:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos el formulario
form = RelacionBuscar(request.form)
# Obtenemos el filtro
nombreFilter = form.nombre.data
faseFilter = form.fase.data
if(nombreFilter == None):
nombreFilter = ''
if(faseFilter == None):
faseFilter = ''
items = Item.query.filter(Item.nombre.like( '%'+nombreFilter+'%' ), Item.estado=='Activo').join(Fase).filter(Fase.nombre.like('%' + faseFilter + '%'), Fase.proyecto_id == proyecto_seleccionado.id)
items = items.all()
return render_template('relacion/administracion_relacion.html', form = form, items = items)
@mod.route('/crear/<item>/', methods=['GET', 'POST'])
def crear_relacion(item):
"""
Crea una relacion entre items, muestra todos lo items con los cuales el item seleccionado
se puede relacionar actualmente
@param item: id del item que se quiere relacionar
"""
# Obtenemos el item seleccionado
item_seleccionado = Item.query.filter_by(id=item).first()
# Obtenemos la fase del item seleccionado
fase_item_seleccionado = Fase.query.filter_by(id = item_seleccionado.fase.id).first()
# Verificamos si el usuario tiene permisos para modificar los items de la fases
if(verificar_autorizacion_fase(usuario=g.user, fase=fase_item_seleccionado, permisoRequerido='MODIFICAR')):
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
if(proyecto_seleccionado.estado != 'Pendiente'):
flash('No se puede modificar los item del proyecto seleccionado')
return redirect(url_for('relaciones.administracion_relacion'))
if(item_seleccionado.antecesor_id != None and item_seleccionado.padre_id != None):
flash('El item ya posee antecesor y padre')
return redirect(url_for('relaciones.administracion_relacion'))
# Obtenemos el formulario
form = RelacionEditable(request.form)
#items =Item.query.all()
lista_items = []
# Si el item no pertecene a la fase 1 del proyecto y no posee un antecesor
# obtenemos la fase anterior y la lineas bases de esa fase
if item_seleccionado.fase.posicion > 1 and item_seleccionado.antecesor_id==None:
fase = Fase.query.filter_by(proyecto_id=proyecto_seleccionado.id, posicion=item_seleccionado.fase.posicion - 1).first()
lb = LineaBase.query.filter_by(fase_id=fase.id)
lb = lb.all()
# Si existen lineas bases en esa fase
if lb!=None:
# Recorremos cada linea base y preguntamos si su estado es Cerrada, si es asi
# obtenemos los items de las lineas base para una relacion antecesor - sucesor
for lb_ind in lb:
if lb_ind.estado=='Abierta':
items_lb = Item.query.filter_by(linea_base_id=lb_ind.id)
items_lb = items_lb.all()
# Si la lista de items de la linea base no es nula, agregamos a la opciones
# para crear la relacion
if items_lb != None:
for item_ind in items_lb:
nombre = item_ind.nombre + " " + item_ind.fase.nombre
lista_items.append((item_ind.id, nombre))
# Obtenemos la fase de item que se selecciono para relacionar y obtenemos sus items
# para una relacion padre-hijo
fase_seleccionada = Fase.query.filter_by(proyecto_id=proyecto_seleccionado.id, id=item_seleccionado.fase.id).first()
items = Item.query.filter_by(fase_id=fase_seleccionada.id)
items = items.all()
# Si el item seleccionado no posee un padre, obtenemos los items de su fase que no sea el mismo
for item_ind in items:
if (item_seleccionado.padre_id == None) and (item_ind!=item_seleccionado):
item_padre = Item.query.filter_by(id=item_ind.padre_id).first()
# Si el item no le tiene como padre al item seleccionado, lo agregamos en la lista de
# opciones de items con quien relacionar
if item_padre != item_seleccionado:
nombre = item_ind.nombre + " " + item_ind.fase.nombre
lista_items.append((item_ind.id, nombre))
if(lista_items==[]):
flash('No existen items para relacionar')
return redirect(url_for('relaciones.administracion_relacion'))
# Mostramos en la vista la lista total de los items permitidos
form.items.choices = lista_items
# Realizamos la validacion de datos del formulario
if form.validate_on_submit():
# Obtenemos el item a relacionar
item_a_relacionar = Item.query.filter_by(id=form.items.data[0]).first()
# Si ambos items son de la misma fase, se establece una relacion padre-hijo
if item_a_relacionar.fase_id == item_seleccionado.fase_id:
# Guardamos en el historial de items los datos del items antes de ser relacionado
historial_item = Historial()
historial_item.setAntecesor(item_seleccionado.antecesor_id)
historial_item.setComplejidad(item_seleccionado.complejidad)
historial_item.setCosto(item_seleccionado.costo)
historial_item.setDescripcion(item_seleccionado.descripcion)
historial_item.setDuracion(item_seleccionado.duracion)
historial_item.setEstado(item_seleccionado.estado)
historial_item.setFase(item_seleccionado.fase)
historial_item.setFechaCreacion(item_seleccionado.fecha_creacion)
historial_item.setFechaModificacion(date.today())
historial_item.setItemId(item_seleccionado.id)
historial_item.setLb(item_seleccionado.linea_base)
historial_item.setNombre(item_seleccionado.nombre)
historial_item.setNumero(item_seleccionado.numero)
historial_item.setObservacion(item_seleccionado.observacion)
historial_item.setPadre(item_seleccionado.padre_id)
historial_item.setPrioridad(item_seleccionado.prioridad)
historial_item.setVersion(item_seleccionado.version)
# Guardamos el nuevo registro
db.session.add(historial_item)
db.session.commit()
# Seteamos el atributo padre del item
item_seleccionado.setPadre(item_a_relacionar.id)
# Actualizamos la version del item
version = int(item_seleccionado.version) +1
item_seleccionado.setVersion(version)
# Guardamos los cambio
db.session.add(item_seleccionado)
db.session.commit()
else:
# Si ambos items no son de la misma fase
# Guardamos en el historial de items los datos del items antes de ser relacionado
historial_item = Historial()
historial_item.setAntecesor(item_seleccionado.antecesor_id)
historial_item.setComplejidad(item_seleccionado.complejidad)
historial_item.setCosto(item_seleccionado.costo)
historial_item.setDescripcion(item_seleccionado.descripcion)
historial_item.setDuracion(item_seleccionado.duracion)
historial_item.setEstado(item_seleccionado.estado)
historial_item.setFase(item_seleccionado.fase)
historial_item.setFechaCreacion(item_seleccionado.fecha_creacion)
historial_item.setFechaModificacion(date.today())
historial_item.setItemId(item_seleccionado.id)
historial_item.setLb(item_seleccionado.linea_base)
historial_item.setNombre(item_seleccionado.nombre)
historial_item.setNumero(item_seleccionado.numero)
historial_item.setObservacion(item_seleccionado.observacion)
historial_item.setPadre(item_seleccionado.padre_id)
historial_item.setPrioridad(item_seleccionado.prioridad)
historial_item.setVersion(item_seleccionado.version)
# Guardamos el nuevo registro
db.session.add(historial_item)
db.session.commit()
# Seteamos el antecesor del item
item_seleccionado.setAntecesor(item_a_relacionar.id)
# Actualizamos la version del item
version = int(item_seleccionado.version) +1
item_seleccionado.setVersion(version)
# Guardamos los cambios
db.session.add(item_seleccionado)
db.session.commit()
flash('La relacion ha sido registrada con exito')
return redirect(url_for('relaciones.administracion_relacion'))
return render_template("relacion/crear_relacion.html", form=form, item=item)
else:
flash('NO TIENE PERMISOS PARA MODIFICAR LA FASE SELECCIONADA')
return redirect(url_for('relaciones.administracion_relacion'))
@mod.route('/eliminar/<item>/', methods=['GET', 'POST'])
def eliminar_relacion(item):
"""
Elimina una relacion entre items, muestra todos lo items con los cuales el item
seleccionado tiene una relacion actualmente
@param item: id del item que se quiere relacionar
"""
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos la fase del item seleccionado
fase_item_seleccionado = Fase.query.filter_by(proyecto_id = proyecto_seleccionado.id).first()
current_app.logger.info(fase_item_seleccionado)
# Verificamos si el usuario tiene permisos para modificar los items de la fases
if(verificar_autorizacion_fase(g.user, fase_item_seleccionado, 'MODIFICAR')):
if(proyecto_seleccionado.estado != 'Pendiente'):
flash('No se puede modificar los item del proyecto seleccionado')
return redirect(url_for('relaciones.administracion_relacion'))
# Obtenemos el item seleccionado
item_seleccionado = Item.query.filter_by(id=item).first()
# Obtenemos el formulario
form = RelacionEditable(request.form)
items = []
# Obtenemos el padre y el antecesor del item selecionado
items.append( Item.query.filter_by(id=item_seleccionado.padre_id).first())
items.append( Item.query.filter_by(id=item_seleccionado.antecesor_id).first())
#Los procesamos para mostrar en la vista
lista_items = []
for item_ind in items:
if item_ind!=None:
nombre = item_ind.nombre + " " + item_ind.fase.nombre
lista_items.append((item_ind.id, nombre))
if(lista_items==[]):
flash('No existen items relacionados')
return redirect(url_for('relaciones.administracion_relacion'))
# Mostramos la lista de items con los cuales esta relacionado el item
form.items.choices = lista_items
# Validamos los datos ingresado en el formulario
if form.validate_on_submit():
# Obtenemos el item con el cual se desea eliminar la relacion
item_a_desrelacionar = Item.query.filter_by(id=form.items.data[0]).first()
# Si ambos items son de la misma fase, se rompe una relacion padre-hijo
if item_a_desrelacionar.fase_id == item_seleccionado.fase_id:
# Guardamos en el historial de items los datos del item antes de ser modificado
historial_item = Historial()
historial_item.setAntecesor(item_seleccionado.antecesor_id)
historial_item.setComplejidad(item_seleccionado.complejidad)
historial_item.setCosto(item_seleccionado.costo)
historial_item.setDescripcion(item_seleccionado.descripcion)
historial_item.setDuracion(item_seleccionado.duracion)
historial_item.setEstado(item_seleccionado.estado)
historial_item.setFase(item_seleccionado.fase)
historial_item.setFechaCreacion(item_seleccionado.fecha_creacion)
historial_item.setFechaModificacion(date.today())
historial_item.setItemId(item_seleccionado.id)
historial_item.setLb(item_seleccionado.linea_base)
historial_item.setNombre(item_seleccionado.nombre)
historial_item.setNumero(item_seleccionado.numero)
historial_item.setObservacion(item_seleccionado.observacion)
historial_item.setPadre(item_seleccionado.padre_id)
historial_item.setPrioridad(item_seleccionado.prioridad)
historial_item.setVersion(item_seleccionado.version)
# Guardamos el nuevo registro
db.session.add(historial_item)
db.session.commit()
# Eliminamos el padre del item
item_seleccionado.setPadre(None)
# Actualizamos la version del item
version = int(item_seleccionado.version) +1
item_seleccionado.setVersion(version)
# Guardamos la actualizacion
db.session.add(item_seleccionado)
db.session.commit()
else:
# Si ambos items son de fases distintas se rompe una relacion antecesor-sucesor
# Guardamos en el historial de items los datos del item antes de ser modificad
historial_item = Historial()
historial_item.setAntecesor(item_seleccionado.antecesor_id)
historial_item.setComplejidad(item_seleccionado.complejidad)
historial_item.setCosto(item_seleccionado.costo)
historial_item.setDescripcion(item_seleccionado.descripcion)
historial_item.setDuracion(item_seleccionado.duracion)
historial_item.setEstado(item_seleccionado.estado)
historial_item.setFase(item_seleccionado.fase)
historial_item.setFechaCreacion(item_seleccionado.fecha_creacion)
historial_item.setFechaModificacion(date.today())
historial_item.setItemId(item_seleccionado.id)
historial_item.setLb(item_seleccionado.linea_base)
historial_item.setNombre(item_seleccionado.nombre)
historial_item.setNumero(item_seleccionado.numero)
historial_item.setObservacion(item_seleccionado.observacion)
historial_item.setPadre(item_seleccionado.padre_id)
historial_item.setPrioridad(item_seleccionado.prioridad)
historial_item.setVersion(item_seleccionado.version)
# Guardamos el nuevo registro
db.session.add(historial_item)
db.session.commit()
# Eliminamos el antecesor del item
item_seleccionado.setAntecesor(None)
# Actualizamos la version del item
version = int(item_seleccionado.version) +1
item_seleccionado.setVersion(version)
# Guardamos la actualizacion
db.session.add(item_seleccionado)
db.session.commit()
flash('La relacion ha sido eliminada con exito')
return redirect(url_for('relaciones.administracion_relacion'))
return render_template("relacion/eliminar_relacion.html", form=form, item=item)
else:
flash('NO TIENE PERMISOS PARA MODIFICAR LA FASE SELECCIONADA')
return redirect(url_for('relaciones.administracion_relacion'))
def verificar_autorizacion_fase(usuario = None, fase = None, permisoRequerido = None):
"""
Verifica que el usuario posea pemisos para realizar una operacion determinada sobre una
fase
@param usuario: usuario que se logueo
@param fase: fase sobre la cual se desea realizar una operacion
@param permisoRequerido: permiso que debe poseer el usuario sobre la fase para que pueda
realizar la acccion
"""
autorizado = False
#============================================================================
# rolAdministrador = db.session.query(Rol).filter_by(nombre = 'Administrador de Sistema').first()
#
# if rolAdministrador in usuario.roles:
# autorizado = True
#
# else:
#============================================================================
permiso = db.session.query(Permiso).filter_by(nombre = permisoRequerido, entidad_id = fase.entidad_id).first()
# flash(permiso)
if(permiso != None):
for rol in usuario.roles:
if permiso in rol.permiso:
autorizado = True
return autorizado | Python |
'''
Created on 29/04/2013
@author: belentwi
'''
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from app.models.atributo import Atributo
from app.wtforms.atributo_forms import AtributoBuscar
from app.wtforms.atributo_forms import AtributoEditable
from app.wtforms.atributo_forms import AtributoNoEditable
from app.security import permission
from app import db
mod = Blueprint('atributos', __name__, url_prefix='/atributo')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_ATRIBUTOS')
def administracion_atributo():
"""
Muestra en pantalla los atributos que existen en la base de datos.
@param filtros: los filtros segun los cuales se mostraran los atributos.
@return: listado de los atributos segun los filtros indicados
"""
form = AtributoBuscar(request.form)
nombreFilter = form.nombre.data
tipoFilter = form.tipo.data
descripcionFilter = form.descripcion.data
if(nombreFilter == None):
nombreFilter = ''
if(tipoFilter == None):
tipoFilter = ''
if(descripcionFilter == None):
descripcionFilter = ''
atributos = Atributo.query.filter(Atributo.nombre.like( '%'+nombreFilter+'%' ), Atributo.tipo.like( '%'+tipoFilter+'%' ), Atributo.descripcion.like('%'+descripcionFilter+'%'))
atributos.all()
return render_template('atributo/administracion_atributo.html', form = form, atributos = atributos)
@mod.route('/crear/', methods=['GET', 'POST'])
@permission('CREAR_ATRIBUTO')
def crear_atributo():
"""
Muestra en pantalla el formulario de creacion de atributos, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre del nuevo atributo no exista en el
sistema y se hayan ingresado los datos obligatorios. Luego almacena en base de datos
"""
choicesTipos = (('1', 'String'), ('2', 'Integer'), ('3', 'Date'),)
# Obtenemos el formulario
form = AtributoEditable(request.form)
form.tipo.choices = choicesTipos
# Obtenemos todos los atributos existentes en la base de datos
atributos = Atributo.query.all()
if form.validate_on_submit():
contN=0
for atributo in atributos:
if atributo.nombre == form.nombre.data:
contN = contN + 1
if contN != 0:
flash("El nombre del atributo ya existe, elija otro", 'error-message')
# Redirigimos a la pagina de modificacion
return redirect(url_for('atributos.crear_atributo'))
else:
nombre = form.nombre.data
posicion = int(form.tipo.data)-1
tipo = choicesTipos[posicion][1]
descripcion = form.descripcion.data
atributo = Atributo(nombre, tipo, descripcion)
db.session.add(atributo)
db.session.commit()
flash('El atributo ha sido registrado con exito')
return redirect(url_for('atributos.administracion_atributo'))
return render_template("atributo/crear_atributo.html", form=form)
@mod.route('/eliminar/<atributo>/', methods=['GET', 'POST'])
@permission('ELIMINAR_ATRIBUTO')
def eliminar_atributo(atributo):
"""
Muestra en pantalla el formulario de eliminacion de atributos, se pide la confimacion del usuario
y se elimina el atributo.
@param atributo: id del atributo que se desea eliminar.
"""
atributo_seleccionado = Atributo.query.filter_by(id=atributo).first()
db.session.delete(atributo_seleccionado)
db.session.commit()
flash('Se ha eliminado el atributo exitosamente')
return redirect(url_for('atributos.administracion_atributo'))
@mod.route('/modificar/<atributo>/', methods=['GET', 'POST'])
@permission('MODIFICAR_ATRIBUTO')
def modificar_atributo(atributo):
"""
Muestra en pantalla el formulario de modificacion de atributos, se modifcan los campos requeridos y se guardan los cambios
@param atributo: id del atributo que se desea modificar.
"""
atributo_seleccionado = Atributo.query.filter_by(id=atributo).first()
form = AtributoNoEditable(request.form)
form.nombre.data = atributo_seleccionado.nombre
form.tipo.data = atributo_seleccionado.tipo
if form.validate_on_submit():
descripcion = form.descripcion.data
atributo_seleccionado.descripcion = descripcion
db.session.add(atributo_seleccionado)
db.session.commit()
flash('El atributo ha sido modificado con exito')
return redirect(url_for('atributos.administracion_atributo'))
form.descripcion.data = atributo_seleccionado.descripcion
return render_template("atributo/modificar_atributo.html", form=form)
@mod.route('/consultar/<atributo>/', methods=['GET', 'POST'])
@permission('CONSULTAR_ATRIBUTO')
def consultar_atributo(atributo):
"""
Muestra en pantalla los datos de un atributo
@param atributo: id del atributo que se desea consultado.
"""
atributo_seleccionado = Atributo.query.filter_by(id=atributo).first()
form = AtributoNoEditable(request.form)
form.nombre.data = atributo_seleccionado.nombre
form.tipo.data = atributo_seleccionado.tipo
form.descripcion.data = atributo_seleccionado.descripcion
return render_template("atributo/consultar_atributo.html", form=form) | Python |
'''
Created on 29/05/2013
@author: mirta
'''
from flask import Blueprint
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from app import db
from app.security import g
from app.models.item import Item
from app.models.fase import Fase
from app.models.permiso import Permiso
mod = Blueprint('calculo', __name__ , url_prefix='/calculo')
@mod.route('/individual/<item>/', methods=['GET', 'POST'])
def calculo_impacto_ind(item):
"""
Metodo que calcula el impacto que tendria cambiar o eliminar un item sobre el proyecto
@param item: id del item que se desea impactar
@return: los detalles del item a impactar, los items afectados e informacion sobre el costo
del impacto
"""
# Verificamos que el usuario tenga asociado un proyecto para que pueda ver la pagina
if g.user == None:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
# Obtenemos el item seleccionado por el usuario
item_seleccionado = Item.query.filter_by(id=item).first()
# Obtenemos la fase a la cual corresponde dicho item
fase = item_seleccionado.fase
# Verificamos que el usuario tenga permisos para ver detalles de la fase
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='VER')):
# Si tiene permisos entonces se realiza la accion seleccionada
# Primero obtenemos los items que seran afectados hacia adelante
lista_adelante = calculo_adelante(item_seleccionado, [])
# Luego obtenemos los items que seran afectados hacia atras
lista_atras = calculo_atras(item_seleccionado, [])
# Calculamos el costo del impacto hacia adelante
costo_adelante = calculo_costo(lista_adelante)
# Calculamos el costo del impacto hacia atras
costo_atras = calculo_costo(lista_atras)
# Calculamos el costo total del impacto
costo_impacto = costo_adelante + costo_atras + item_seleccionado.costo
#flash(costo_impacto)
# Ademas del costo total del impacto del items seleccionado, obtenemos otros datos
# como informaciones generales que seran mostrados en la vista al usuario
# Obtenemos todoas las fases del proyecti
lista_fases = Fase.query.filter_by(proyecto_id=g.proyecto.id)
lista_fases = lista_fases.all()
lista_items=[]
# Por cada fase del proyecto
for fase in lista_fases:
# Obtenemos los items de la fase
items = Item.query.filter_by(fase_id=fase.id)
items = items.all()
# Por cada item de la fase
for item in items:
# Agregamos a la lista de items del proyecto
lista_items.append(item)
# Calculamos el costo total del proyecto
costo_items_total = calculo_costo(lista_items)
# Calculamos el porcentaje del costo total que afecta el impacto del item
porcentaje = float(costo_impacto)/float(costo_items_total)*100
#flash(porcentaje)
# Mostramos todas estas informaciones al usuario
return render_template('calculo_impacto/impacto_individual.html', item=item_seleccionado,
lista_adelante=lista_adelante, lista_atras=lista_atras,
porcentaje=porcentaje, costo_impacto=costo_impacto)
else:
# Si no se tiene permisos para realizar la accion lo indicamos con un mensaje
# y redirigimos al usuario a la pagina de administracion de items
flash('No tiene permisos para ver esta informacion')
return redirect(url_for('items.administracion_item'))
mod.route('/grupo/<items>/', methods=['GET', 'POST'])
def calculo_impacto_grup(items):
"""
Metodo que calcula el impacto que tendra eliminar o cambiar un grupo de items en el proyecto
@param items: lista de items que se quieren impactar
@return: costo de impacto de la lista de items sobre el proyecto
"""
#solicitud_seleccionada = SolicitudCambio.query.filter_by(id=solicitud).first()
lista_adelante = []
lista_atras = []
lista_items = []
# Por cada item en la lista
for item in items:
# Obtnemos la lista de items que seran afectados hacia adelante si se impacta ese item
aux_adelante = calculo_adelante(item, [])
# Por cada uno de los items afectados
for aux in aux_adelante:
# Si ya no se encuentra en la lista general de items afectados hacia adelante
if not(aux in lista_adelante):
# Se agrega el item a la lista
lista_adelante.append(aux)
# Obtenemos la lista de items que seran afectados hacia atras si se impacta ese item
aux_atras = calculo_atras(item, [])
# Por cada uno de los items afectados
for aux in aux_atras:
# Si ya no se encuentra en la lista general de items afectados hacia atras
if not(aux in lista_atras):
# Se agrega el item a la lista
lista_atras.append(aux)
# Por cada uno de los items de la lista recibida
for item in items:
# Si el item no se encuentra ya en la lista de items afectados hacia adelante y hacia atras
if (not(item in lista_adelante)) and (not(item in lista_atras)):
# Se agrega a una lista global de items afectados
lista_items.append(item)
# Por cada item en los lista de afectados hacia adelante
for item in lista_adelante:
# Si no se encuentra en la lista global de items afectados
if (not(item in lista_items)):
# Se agrega a la lista
lista_items.append(item)
# Por cada item en los lista de afectados hacia atras
for item in lista_atras:
# Si no se encuentra en la lista global de items afectados
if (not(item in lista_items)):
# Se agrega a la lista
lista_items.append(item)
# Calculamos el costo hacia adelante
#costo_adelante = calculo_costo(lista_adelante)
#flash(costo_adelante)
# Calculamos el costo hacia atras
#costo_atras = calculo_costo(lista_atras)
#flash(costo_atras)
# Calculamos el costo del impacto de los items afectados
costo_impacto = calculo_costo(lista_items)
# Retornamos el costo del impacto de la lista de items
return costo_impacto
def calculo_adelante(item, lista_items):
"""
Metodo que obtiene todos los items que seran afectado hacia adelante por el impacto de un item
@param item: item que sera analizado hacia adelante
@param lista_items: lista de los items afectados, la cual sera actualizada
@return: lista de items afectadoa hacia adelante
"""
# Obtenemos los hijos del item recibido
hijos = Item.query.filter_by(padre_id=item.id)
hijos = hijos.all()
# Obtenemos los sucesores del item recibido
sucesores = Item.query.filter_by(antecesor_id=item.id)
sucesores = sucesores.all()
# Por cada uno de los hijos
for hijo in hijos:
# Si el hijo no se encuentra ya en la lista de items afectados
if hijo != None and (not(hijo in lista_items)):
# Se agrega a la lista
lista_items.append(hijo)
# Se llama recursivamente al metodo, pasando la lista actualizada y el hijo como
# item a analizar
calculo_adelante(hijo, lista_items)
# Por cada uno de los sucesores
for sucesor in sucesores:
# Si el sucesor no se encuentra ya en la lista de items afectados
if sucesor != None and (not(sucesor in lista_items)):
# Se agrega a la lista
lista_items.append(sucesor)
# Se llama recursivamente al metodo, pasando la lista actualizada y el sucesor como
# item a analizar
calculo_adelante(sucesor, lista_items)
# Retornamos la lista de items que seran afectados hacia adelante
return lista_items
def calculo_atras(item, lista_items):
"""
Metodo que obtiene todos los items que seran afectado hacia atras por el impacto de un item
@param item: item que sera analizado hacia atras
@param lista_items: lista de los items afectados, la cual sera actualizada
@return: lista de items afectadoa hacia atras
"""
# Obtenemos el padre del item a analizar
padre = Item.query.filter_by(id=item.padre_id).first()
# Si el padre no se encuentra ya en la lista de items afectados
if padre!= None and (not(padre in lista_items)):
# Lo agregamos a la lista
lista_items.append(padre)
# Se llama recursivamente al metodo, pasando la lista actualizada y el padre como
# item a analizar
calculo_atras(padre, lista_items)
# Obtenemos el antecesor del item a analizar
antecesor = Item.query.filter_by(id=item.antecesor_id).first()
# Si el anteccesor no se encuentra ya en la lista de items afectados
if antecesor != None and (not(antecesor in lista_items)):
# Lo agregamos a la lista
lista_items.append(antecesor)
# Se llama recursivamente al metodo, pasando la lista actualizada y el padre como
# item a analizar
calculo_atras(antecesor, lista_items)
# Retornamos la lista de items que seran afectados hacia atras
return lista_items
def calculo_costo(lista_items):
"""
Metodo que calcula el costo total de una lista de items
@param lista_items: lista de items cuyo costo total se desea calcular
@return: costo total de ls lista de items
"""
# Inicializamos el costo a cero
costo = 0
# Por cada item de la lista de items
for item in lista_items:
# Sumamos su costo al costo total
costo = costo + item.costo
# Retornamos el costo total
return costo
def verificar_autorizacion_fase(usuario = None, fase = None, permisoRequerido = None):
"""
Verifica que el usuario posea pemisos para realizar una operacion determinada sobre una
fase
@param usuario: usuario que se logueo
@param fase: fase sobre la cual se desea realizar una operacion
@param permisoRequerido: permiso que debe poseer el usuario sobre la fase para que pueda
realizar la acccion
"""
# Establecemos por defecto que el usuario logueado no esta autorizado para realizar la operacion
autorizado = False
#============================================================================
# rolAdministrador = db.session.query(Rol).filter_by(nombre = 'Administrador de Sistema').first()
#
# if rolAdministrador in usuario.roles:
# autorizado = True
#
# else:
#============================================================================
# Obtenemos el permisos con los elementos requeridos
permiso = db.session.query(Permiso).filter_by(nombre = permisoRequerido, entidad_id = fase.entidad_id).first()
# flash(permiso)
# Si existe dicho permiso
if(permiso != None):
# Por cada rol que posea el usuario logueado
for rol in usuario.roles:
# Si tiene ese permiso
if permiso in rol.permiso:
# Establecemos que esta autorizado para realizar la operacion
autorizado = True
return autorizado
| Python |
'''
Created on 14/04/2013
@author: belentwi
'''
from flask import Blueprint
from flask import request, flash
from flask import render_template
from flask import redirect
from flask import url_for
from app import db
from app.wtforms.proyecto_forms import ProyectoBuscar
from app.wtforms.proyecto_forms import ProyectoCrear
from app.wtforms.proyecto_forms import ProyectoModificar
from app.wtforms.proyecto_forms import ProyectoMiembros
from app.wtforms.proyecto_forms import ProyectoConsultar
from app.models.proyecto import Proyecto
from app.models.fase import Fase
from app.models.entidad import Entidad
from app.models.usuario import Usuario
from app.models.rol import Rol
from app.models.permiso import Permiso
from app.security import g
from app.security import permission
mod = Blueprint('proyectos', __name__, url_prefix='/proyecto')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_PROYECTOS')
def administracion_proyecto():
"""
Muestra en pantalla los proyectos que existen en la base de datos.
@param filtros: los filtros segun los cuales se mostraran los proyectos.
@return: listado de los proyectos segun los filtros indicados.
"""
form = ProyectoBuscar(request.form)
nombreFilter = form.nombre.data
liderFilter = form.lider.data
estadoFilter = form.estado.data
entidadFilter = form.entidad.data
if(nombreFilter == None):
nombreFilter = ''
if(liderFilter == None):
liderFilter = ''
if(estadoFilter == None):
estadoFilter = ''
if(entidadFilter == None):
entidadFilter = ''
rolAdministrador = db.session.query(Rol).filter_by(nombre = 'Administrador de Sistema').first()
if rolAdministrador in g.user.roles:
proyectos = Proyecto.query.filter(Proyecto.nombre.like('%'+nombreFilter+'%' ), Proyecto.estado.like('%'+estadoFilter+'%' ) ).join(Entidad).filter(Entidad.nombre.like('%' + entidadFilter + '%')).join(Usuario).filter(Usuario.nombre.like('%' + liderFilter + '%'))
else:
proyectos = Proyecto.query.filter(Proyecto.id == g.proyecto.id ).join(Entidad).filter(Entidad.nombre.like('%' + entidadFilter + '%')).join(Usuario).filter(Usuario.nombre.like('%' + liderFilter + '%'))
proyectos = proyectos.all()
return render_template('proyecto/administracion_proyecto.html', form = form, proyectos = proyectos)
@mod.route('/crear/', methods=['GET', 'POST'])
def crear_proyecto():
"""
Muestra en pantalla el formulario de creacion de proyectos, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre del nuevo proyecto no exista en el
sistema y se hayan ingresado los datos obligatorios. Luego almacena en base de datos.
"""
if(verificar_autorizacion( g.user, g.proyecto, 'CREAR_PROYECTO')):
choices = []
rolLider = db.session.query(Rol).filter_by(nombre = 'Lider Proyecto').first()
lideres = db.session.query(Usuario).filter(Usuario.roles.contains(rolLider), Usuario.estado != 'INACTIVO')
lideres.all()
for lider in lideres:
choices.append((str(lider.id), lider.nombre))
form = ProyectoCrear(request.form)
form.lideres.choices = choices
#obtenemos todos los proyectos del sistema
proyectos = Proyecto.query.all()
if form.validate_on_submit():
liderProyecto = Usuario.query.get(int(form.lideres.data))
nombre = form.nombre.data
#verificamos que el nombre del proyecto sea unico
contN=0
for proy in proyectos:
if proy.nombre == nombre:
contN=contN+1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre del Proyecto ya existe, ingrese otro", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('proyectos.crear_proyecto'))
estado = 'Pendiente'
costo = 0
presupuesto = int(form.presupuesto.data)
fecha_inicio = None
fecha_fin = None
if form.fecha_inicio.data != None and form.fecha_inicio.data != '':
if form.fecha_fin.data != None and form.fecha_fin.data != '':
fecha_inicio = form.fecha_inicio.data
fecha_fin = form.fecha_fin.data
if fecha_inicio > fecha_fin:
flash("La fecha inicial debe ser menor a la fecha final", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('proyectos.crear_proyecto'))
lider = liderProyecto
entidad = Entidad(nombre)
proyecto = Proyecto(nombre, estado, costo, presupuesto, fecha_inicio, fecha_fin, liderProyecto, entidad)
db.session.add(proyecto)
db.session.commit()
flash('El proyecto ha sido registrado con exito')
return redirect(url_for('proyectos.administracion_proyecto'))
return render_template("proyecto/crear_proyecto.html", form = form)
else:
flash('NO TIENE PERMISOS PARA CREAR PROYECTOS')
return redirect(url_for('proyectos.administracion_proyecto'))
@mod.route('/eliminar/<proyecto>/', methods=['GET', 'POST'])
def eliminar_proyecto(proyecto):
"""
Muestra en pantalla el formulario de eliminacion de proyectos, se pide la confimacion del usuario
y se elimina el proyecto.
@param proyecto: id del proyecto que se desea eliminar.
"""
if(verificar_autorizacion(g.user, g.proyecto, 'ELIMINAR')):
proyecto_seleccionado = Proyecto.query.filter_by(id=proyecto).first()
if(proyecto_seleccionado.estado != 'Cancelado' and proyecto_seleccionado.estado != 'Finalizado'):
proyecto_seleccionado.estado = 'Cancelado'
db.session.add(proyecto_seleccionado)
db.session.commit()
flash('Se ha eliminado el proyecto exitosamente')
else:
flash('El proyecto ya ha sido eliminado o finalizado')
return redirect(url_for('proyectos.administracion_proyecto'))
else:
flash('NO TIENE PERMISOS PARA ELIMINAR EL PROYECTO')
return redirect(url_for('proyectos.administracion_proyecto'))
@mod.route('/finalizar/<proyecto>/', methods=['GET', 'POST'])
def finalizar_proyecto(proyecto):
"""
Muestra en pantalla el formulario de finalizacion de proyectos, se pide la confimacion del usuario
y se finaliza el proyecto.
@param proyecto: id del proyecto que se desea finalizar.
"""
if(verificar_autorizacion(g.user, g.proyecto, 'MODIFICAR')):
proyecto_seleccionado = Proyecto.query.filter_by(id=proyecto).first()
if(proyecto_seleccionado.estado == 'Activo'):
fases = proyecto_seleccionado.fases
bandera = True
for fase in fases:
if(fase.estado != 'Finalizada'):
bandera = False
if(bandera):
proyecto_seleccionado.estado = 'Finalizado'
db.session.add(proyecto_seleccionado)
db.session.commit()
flash('Se ha finalizado el proyecto exitosamente')
else:
flash('No se puede finalizar el proyecto, cuenta con fases que no han sido finalizadas')
else:
flash('El proyecto no puede ser finalizado, no se encuentra en el estado Activo')
return redirect(url_for('proyectos.administracion_proyecto'))
else:
flash('NO TIENE PERMISOS PARA FINALIZAR EL PROYECTO')
return redirect(url_for('proyectos.administracion_proyecto'))
@mod.route('/modificar/<proyecto>/', methods=['GET', 'POST'])
def modificar_proyecto(proyecto):
"""
Muestra en pantalla el formulario de modificacion de proyectos.
@param proyecto: id del proyecto que se desea modificar.
@return: redirige a la pagina de Administracion de Proyectos.
"""
if(verificar_autorizacion(g.user, g.proyecto, 'MODIFICAR')):
proyecto_seleccionado = Proyecto.query.filter_by(id=proyecto).first()
if(proyecto_seleccionado.estado != 'Finalizado' and proyecto_seleccionado.estado != 'Cancelado' ):
rolLider = db.session.query(Rol).filter_by(nombre = 'Lider Proyecto').first()
lideres = db.session.query(Usuario).filter(Usuario.roles.contains(rolLider), Usuario.estado != 'INACTIVO', Usuario.id != proyecto_seleccionado.lider_id)
lideres.all()
liderProyecto = Usuario.query.get(proyecto_seleccionado.lider_id)
choicesLideres = []
choicesLideres.append((str(liderProyecto.id), liderProyecto.nombre))
for lider in lideres:
choicesLideres.append((str(lider.id), lider.nombre))
form = ProyectoModificar(request.form)
if proyecto_seleccionado.estado == 'Pendiente':
choicesEstados = (('1','Pendiente'), ('2', 'Activo'))
form.estado.choices = choicesEstados
elif proyecto_seleccionado.estado == 'Activo':
choicesEstados = (('1','Activo'), ('1','Activo'))
form.estado.choices = choicesEstados
#obtenemos todos los proyectos del sistema
proyectos = Proyecto.query.all()
form.lideres.choices = choicesLideres
if form.validate_on_submit():
proyecto_seleccionado.nombre = form.nombre.data
#verificamos que el nombre del proyecto sea unico
contN=0
for proy in proyectos:
if proy.id != proyecto_seleccionado.id:
if proy.nombre == proyecto_seleccionado.nombre:
contN=contN+1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre del Proyecto ya existe, ingrese otro", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('proyectos.crear_proyecto'))
posicionEstado = int(form.estado.data)
proyecto_seleccionado.estado = choicesEstados[posicionEstado-1][1]
proyecto_seleccionado.costo = form.costo.data
proyecto_seleccionado.presupuesto = form.presupuesto.data
if form.fecha_inicio.data != None and form.fecha_inicio.data != '':
if form.fecha_fin.data != None and form.fecha_fin.data != '':
proyecto_seleccionado.fecha_inicio = form.fecha_inicio.data
proyecto_seleccionado.fecha_fin = form.fecha_fin.data
if proyecto_seleccionado.fecha_inicio > proyecto_seleccionado.fecha_fin:
flash("La fecha inicial debe ser menor a la fecha final", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('proyectos.administracion_proyecto'))
liderProyecto = Usuario.query.get(int(form.lideres.data))
proyecto_seleccionado.lider = liderProyecto
db.session.add(proyecto_seleccionado)
db.session.commit()
flash('El proyecto ha sido registrado con exito')
return redirect(url_for('proyectos.administracion_proyecto'))
form.nombre.data = proyecto_seleccionado.nombre
form.costo.data = proyecto_seleccionado.costo
form.presupuesto.data = proyecto_seleccionado.presupuesto
form.fecha_inicio.data = proyecto_seleccionado.fecha_inicio
form.fecha_fin.data = proyecto_seleccionado.fecha_fin
return render_template("proyecto/modificar_proyecto.html", form = form)
else:
flash('El proyecto no puede ser modificado')
return redirect(url_for('proyectos.administracion_proyecto'))
else:
flash('NO TIENE PERMISOS PARA MODIFICAR EL PROYECTO SELECCIONADO')
return redirect(url_for('proyectos.administracion_proyecto'))
@mod.route('/consultar/<proyecto>/', methods=['GET', 'POST'])
def consultar_proyecto(proyecto):
"""
Muestra todos los datos relacionados a un proyecto.
@param proyecto: id del proyecto que se desea consultar.
"""
#obtenemos el formulario
form = ProyectoConsultar(request.form)
#obtenemos el proyecto seleccionado
proyecto_seleccionado = Proyecto.query.filter_by(id=proyecto).first()
#obtenemos el lider del proyecto
liderProyecto = Usuario.query.get(proyecto_seleccionado.lider_id)
#obtenemos las fases del proyecto seleccionado
fases = Fase.query.filter(Fase.proyecto==proyecto_seleccionado)
lista_fases=[]
for fase in fases:
lista_fases.append((fase.id,fase.nombre))
lista_miembros=[]
for miembro in proyecto_seleccionado.miembros:
lista_miembros.append((miembro.id,miembro.nombre))
form.nombre.data = proyecto_seleccionado.nombre
form.estado.data = proyecto_seleccionado.estado
form.costo.data = proyecto_seleccionado.costo
form.presupuesto.data = proyecto_seleccionado.presupuesto
form.fecha_inicio.data = proyecto_seleccionado.fecha_inicio
form.fecha_fin.data = proyecto_seleccionado.fecha_fin
form.lideres.data = liderProyecto.nombre
form.fases.choices = lista_fases
form.miembros.choices = lista_miembros
return render_template("proyecto/consultar_proyecto.html", form = form)
@mod.route('/seleccionar/<proyecto>/', methods=['GET', 'POST'])
def seleccionar_miembros(proyecto):
"""
Muestra una lista de usuarios que podran ser asignados y desasignados al proyecto.
@param proyecto: id del proyecto al que se asignaran miembros.
"""
if(verificar_autorizacion(g.user, g.proyecto, 'MODIFICAR')):
#obtenemos el proyecto seleccionado
proyecto_seleccionado = Proyecto.query.filter_by(id=proyecto).first()
if(proyecto_seleccionado.estado != 'Finalizado' and proyecto_seleccionado.estado != 'Cancelado' ):
# Obtenemos el formulario
form = ProyectoMiembros(request.form)
# Obtenemos todos los usuarios activos existentes en la base de datos
usuarios =Usuario.query.filter(Usuario.estado != 'INACTIVO')
# Hacemos una tupla con el nombre y el id del usuario
lista_usuarios=[]
for usuario in usuarios:
lista_usuarios.append((usuario.id, usuario.nombre))
# Asignamos la tupla de usuarios a la lista que va a ser visualizada en el checkbox
form.miembros.choices = lista_usuarios
if form.validate_on_submit():
# Obtenemos los miembros seleccionados para el proyecto
lista_miembros = []
for id_miembro in form.miembros.data:
miembro = Usuario.query.filter_by(id=id_miembro ).first()
lista_miembros.append(miembro )
#actualizamos los miembros para el proyecto
proyecto_seleccionado.setMiembros(lista_miembros)
db.session.add(proyecto_seleccionado)
db.session.commit()
flash('Se ha actualizado con exito los datos de miembros para el proyecto seleccionado')
return redirect(url_for('proyectos.administracion_proyecto'))
form.proyecto.data = proyecto_seleccionado.nombre
#obtenemos los miembros que el proyecto ya tiene asignado
miembros_act = []
for miembro_sec in proyecto_seleccionado.miembros:
miembros_act.append(miembro_sec.id)
#mostramos seleccionados en el checkbox los miembros que posee el proyecto
form.miembros.data = miembros_act
return render_template("proyecto/seleccionar_miembros.html", form = form)
else:
flash('No se pueden asignar ni desasignar miembros para el proyecto.'
+ 'El proyecto se encuentra con estado Cancelado o Finalizado')
return redirect(url_for('proyectos.administracion_proyecto'))
else:
flash('NO TIENE PERMISOS PARA ASIGNARM MIEMBROS AL PROYECTO SELECCIONADO')
return redirect(url_for('proyectos.administracion_proyecto'))
def verificar_autorizacion(usuario = None, proyecto = None, permisoRequerido = None):
"""
Verifica que el usuario tenga los permisos para realizar la accion indicada sobre una entidad seleccionada.
@param usuario: el id del usuario que desea realizar la accion.
@param proyecto: el proyecto en el cual se desea realizar la accion.
@param permisoRequerido: el permiso que se requiere para realizar la accion.
@return autorizado: un boolean que indica si el usuario puede realizar la acccion.
True si el usuario tiene el permiso requerido.
False si el usuario no tiene el permiso requerido.
"""
autorizado = False
rolAdministrador = db.session.query(Rol).filter_by(nombre = 'Administrador de Sistema').first()
if rolAdministrador in usuario.roles:
autorizado = True
else:
permiso = db.session.query(Permiso).filter_by(nombre = permisoRequerido, entidad_id = proyecto.entidad_id).first()
if(permiso != None):
for rol in usuario.roles:
if permiso in rol.permiso:
autorizado = True
return autorizado
| Python |
'''
Created on 26/04/2013
@author: mirta
'''
from flask import Blueprint
from flask import flash
from flask import request
from flask import render_template
from flask import redirect
from flask import url_for
from flask import Response
from flask import session
from datetime import date
from app import db
from app.security import permission
from app.security import g
from werkzeug import secure_filename
from app.wtforms.item_forms import ItemBuscar
from app.wtforms.item_forms import ItemCrear
from app.wtforms.item_forms import ElegirFaseForm
from app.wtforms.item_forms import ArchivoForm
from app.wtforms.item_forms import ElegirTipoItem
from app.wtforms.item_forms import F
from app.wtforms.item_forms import G
from app.wtforms.item_forms import H
from app.wtforms.item_forms import ItemVerHistorial
from app.wtforms.item_forms import SeleccionarVersionItem
from app.wtforms.item_forms import ReversionItem
from app.models.item import Item
from app.models.fase import Fase
from app.models.permiso import Permiso
from app.models.archivo import Archivo
from app.models.tipoItem import TipoItem
from app.models.atributo_item import AtributoItem
from app.models.atributo import Atributo
from app.models.historial import Historial
from app.models.rol import Rol
from app.reportes.item_reporte import ItemReport
from app.reportes.historial_reporte import HistorialReport
from geraldo.generators import PDFGenerator
from app.security import g
from app.security import permission
import os
from flask_wtf import TextField
from app.models import usuario
mod = Blueprint('items', __name__, url_prefix='/item')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_ITEMS')
def administracion_item():
"""
Muestra en pantalla los item que existen en la base de datos.
@param filtros: los filtros segun los cuales se mostraran los items.
@return: listado de los items segun los filtros indicados.
"""
proyecto_seleccionado = g.proyecto
if(proyecto_seleccionado != None):
form = ItemBuscar(request.form)
nombreFilter = form.nombre.data
versionFilter = form.version.data
prioridadFilter = form.prioridad.data
complejidadFilter = form.complejidad.data
duracionFilter = form.duracion.data
estadoFilter = form.estado.data
descripcionFilter = form.descripcion.data
faseFilter = form.fase.data
if(nombreFilter == None):
nombreFilter = ''
if(versionFilter == None):
versionFilter = ''
if(prioridadFilter == None):
prioridadFilter = ''
if(complejidadFilter == None):
complejidadFilter = ''
if(duracionFilter == None):
duracionFilter = ''
if(estadoFilter == None):
estadoFilter = ''
if(descripcionFilter == None):
descripcionFilter = ''
if(faseFilter == None):
faseFilter = ''
items = Item.query.filter(Item.nombre.like('%' + nombreFilter + '%'), Item.version.like('%' +versionFilter + '%'), Item.prioridad.like('%' +prioridadFilter + '%'), Item.complejidad.like('%' + complejidadFilter+ '%'), Item.duracion.like('%' + duracionFilter+ '%'), Item.estado.like('%' +estadoFilter + '%'), Item.descripcion.like('%' +descripcionFilter + '%')).join(Fase).filter(Fase.proyecto_id == proyecto_seleccionado.id)
items.all()
return render_template('item/administracion_item.html', form = form, items = items)
else:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
@mod.route('/crear/<tipo_item>/', methods=['GET', 'POST'])
def crear_item(tipo_item):
"""
Muestra en pantalla el formulario de creacion de items, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre del nuevo item no exista en el
sistema y se hayan ingresado los datos obligatorios. Luego almacena en base de datos.
@param fase_item: la fase en la que se quiere crear el item
"""
tipoItem = TipoItem.query.filter_by(id = tipo_item).first()
atributos = tipoItem.atributo
for atributo in atributos:
setattr(F, atributo.nombre, TextField(atributo.nombre))
fase = tipoItem.fase
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
prioridadChoices = (('1', 'Baja'), ('2', 'Normal'), ('3', 'Alta'))
form = F(request.form)
form.prioridad.choices = prioridadChoices
if form.validate_on_submit():
#obtener los items de la fase
items = []
items = Item.query.filter(Item.fase == fase)
items = items.all()
if(fase.estado != 'Finalizada'):
nombre = form.nombre.data
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if items != []:
for item in items:
if item.nombre == nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre del item ya existe dentro de la fase seleccionada, elija otro", 'error-message')
# Redirigimos a la pagina de administracion
return redirect(url_for('items.crear_item', tipo_item = tipoItem.id))
version = '1'
posicionPrioridad= int(form.prioridad.data)
prioridad = prioridadChoices[posicionPrioridad-1][1]
costo = int(form.costo.data)
complejidad = form.complejidad.data
duracion = form.duracion.data
descripcion = form.nombre.data
observacion = form.nombre.data
items = Item.query.filter_by(fase_id = fase.id)
fecha_creacion = date.today()
estado = 'Activo'
ultimo = 0
for item in items:
if(item.numero > ultimo):
ultimo = item.numero
numero = ultimo + 1
item = Item(nombre, version, prioridad, costo, complejidad, duracion, estado, descripcion, observacion, numero, fecha_creacion, fase, tipoItem)
db.session.add(item)
bandera = True
for atributo in atributos:
if(atributo.tipo == 'Integer'):
try:
valor_string = getattr(form, atributo.nombre).data
valor_int = int(valor_string)
atributoItem = AtributoItem(item.id, atributo.id, item.version, getattr(form, atributo.nombre).data )
db.session.add(atributoItem)
except ValueError:
flash('El valor introducido no es un entero')
flash('No se puede guardar el item')
bandera = False
else:
atributoItem = AtributoItem(item.id, atributo.id, item.version, getattr(form, atributo.nombre).data )
db.session.add(atributoItem)
if(bandera):
db.session.commit()
for atributo in atributos:
atributoItem = AtributoItem(item.id, atributo.id, item.version, getattr(form, atributo.nombre).data )
db.session.add(atributoItem)
db.session.commit()
flash('El item ha sido registrado con exito')
if(fase.estado == 'Pendiente'):
fase.estado = 'Activa'
db.session.add(fase)
db.session.commit()
return redirect(url_for('items.administracion_item'))
else:
flash('La fase ya ha sido finalizada, no se pueden agregar items')
else:
flash('No tiene permisos para crear items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
return render_template("item/crear_item.html", form = form, atributos = atributos)
@mod.route('/seleccionar_fase/', methods=['GET', 'POST'])
def seleccionar_fase():
"""
Muestra en pantalla las fases relacionadas a un proyecto. El usuario selecciona la fase
en la cual quiere crear el item
"""
form = ElegirFaseForm(request.form)
proyecto_login = g.proyecto
fases = proyecto_login.fases
return render_template("item/seleccionar_fase.html", form = form, fases = fases)
@mod.route('/seleccionar_tipo_item/<fase_item>/', methods=['GET', 'POST'])
def seleccionar_tipo_item(fase_item):
"""
Muestra en pantalla los tipos de items relacionados a una fase. El usuario selecciona el tipo de item
con el cual desea asociar el item
@param fase_item: la fase donde se desea crear el item
"""
form = ElegirTipoItem(request.form)
fase = Fase.query.filter_by(id = fase_item).first()
tiposItems = fase.fase
#return redirect(url_for('items.administracion_item'))
return render_template("item/seleccionar_tipo_item.html", form = form, tiposItems = tiposItems)
@mod.route('/consultar/<item_id>/', methods = ['GET', 'POST'])
def consultar_item(item_id):
"""
Muestra en pantalla los datos de un item
@param item_id: id del item que se desea consultar.
"""
item_seleccionado = Item.query.filter_by(id = item_id).first()
fase = item_seleccionado.fase
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
atributosItem = AtributoItem.query.filter_by(id_item = item_seleccionado.id, version = item_seleccionado.version).all()
if(atributosItem != None):
for atributoItem in atributosItem:
atributo = Atributo.query.filter_by(id = atributoItem.id_atributo).first()
setattr(G, atributo.nombre, TextField(atributo.nombre))
form = G(request.form)
if(atributosItem != None):
for atributoItem in atributosItem:
atributo = Atributo.query.filter_by(id = atributoItem.id_atributo).first()
getattr(form, atributo.nombre).data = atributoItem.valor
form.nombre.data = item_seleccionado.nombre
form.complejidad.data = item_seleccionado.complejidad
form.costo.data = item_seleccionado.costo
form.descripcion.data = item_seleccionado.descripcion
form.observacion.data = item_seleccionado.observacion
form.estado.data = item_seleccionado.estado
form.duracion.data = item_seleccionado.duracion
form.fecha_creacion.data = item_seleccionado.fecha_creacion
form.prioridad.data = item_seleccionado.prioridad
form.tipo.data = item_seleccionado.tipo.nombre
form.version.data = item_seleccionado.version
return render_template("item/consultar_item.html", form=form)
else:
flash('No tiene permisos para consultar items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
@mod.route('/modificar/<item_id>/', methods = ['GET', 'POST'])
def modificar_item(item_id):
"""
Muestra en pantalla los datos para la modificacion de un item
@param item: id del item que se desea modificar.
"""
item_seleccionado = Item.query.filter_by(id = item_id).first()
iditem = item_seleccionado.id
fase = item_seleccionado.fase
if(fase.estado != 'Finalizada' and item_seleccionado.estado == 'Activo'):
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
atributosItem = AtributoItem.query.filter_by(id_item = item_seleccionado.id, version = item_seleccionado.version).all()
prioridadChoices = (('1', 'Baja'), ('2', 'Normal'), ('3', 'Alta'))
choicesEstados = (('1','Activo'), ('2', 'Aprobado'), ('3','Bloqueado'), ('4','Revision'), ('5','Eliminado'))
if(atributosItem != None):
for atributoItem in atributosItem:
atributo = Atributo.query.filter_by(id = atributoItem.id_atributo).first()
setattr(H, atributo.nombre, TextField(atributo.nombre))
form = H(request.form)
form.prioridad.choices = prioridadChoices
form.estado.choices = choicesEstados
#obtener los items de la fase
#items = []
items = Item.query.filter(Item.fase == fase)
items = items.all()
if form.validate_on_submit():
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
#if items != []:
if items != None:
for item in items:
#if item_seleccionado.id != item.id:
if form.nombre.data == item.nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la creacion
#if contN != 0:
if (contN != 0 and form.nombre.data != item_seleccionado.nombre):
flash("El nombre del item ya existe dentro de la fase seleccionada, elija otro", 'error-message')
# Redirigimos a la pagina de administracion
return redirect(url_for('items.modificar_item', item_id = iditem))
historial_item = Historial()
historial_item.setAntecesor(item_seleccionado.antecesor_id)
historial_item.setComplejidad(item_seleccionado.complejidad)
historial_item.setCosto(item_seleccionado.costo)
historial_item.setDescripcion(item_seleccionado.descripcion)
historial_item.setDuracion(item_seleccionado.duracion)
historial_item.setEstado(item_seleccionado.estado)
historial_item.setFase(item_seleccionado.fase)
historial_item.setFechaCreacion(item_seleccionado.fecha_creacion)
historial_item.setFechaModificacion(date.today())
historial_item.setItemId(item_seleccionado.id)
historial_item.setLb(item_seleccionado.linea_base)
historial_item.setNombre(item_seleccionado.nombre)
historial_item.setNumero(item_seleccionado.numero)
historial_item.setObservacion(item_seleccionado.observacion)
historial_item.setPadre(item_seleccionado.padre_id)
historial_item.setPrioridad(item_seleccionado.prioridad)
historial_item.setVersion(item_seleccionado.version)
item_seleccionado.nombre = form.nombre.data
version_int = int(item_seleccionado.version)
version_int = version_int + 1
item_seleccionado.version = str(version_int)
posicionPrioridad= int(form.prioridad.data)
item_seleccionado.prioridad = prioridadChoices[posicionPrioridad-1][1]
item_seleccionado.costo = int(form.costo.data)
item_seleccionado.complejidad = form.complejidad.data
item_seleccionado.duracion = form.duracion.data
posicionEstado = int(form.estado.data)
item_seleccionado.estado = choicesEstados[posicionEstado-1][1]
item_seleccionado.descripcion = form.descripcion.data
item_seleccionado.observacion = form.observacion.data
db.session.add(item_seleccionado)
db.session.add(historial_item)
atributos = item_seleccionado.tipo.atributo
bandera = True
for atributo in atributos:
if(atributo.tipo == 'Integer'):
try:
valor_string = getattr(form, atributo.nombre).data
valor_int = int(valor_string)
except ValueError:
flash('El valor introducido no es un entero')
flash('No se pueden actualizar el item')
bandera = False
if(bandera):
db.session.commit()
atributos = item_seleccionado.tipo.atributo
for atributo in atributos:
atributoItem = AtributoItem(item_seleccionado.id, atributo.id, item_seleccionado.version, getattr(form, atributo.nombre).data )
db.session.add(atributoItem)
db.session.commit()
flash('El item ha sido modificado con exito')
return redirect(url_for('items.administracion_item'))
form.nombre.data = item_seleccionado.nombre
form.complejidad.data = item_seleccionado.complejidad
form.costo.data = item_seleccionado.costo
form.descripcion.data = item_seleccionado.descripcion
form.observacion.data = item_seleccionado.observacion
form.duracion.data = item_seleccionado.duracion
if(atributosItem != None):
for atributoItem in atributosItem:
atributo = Atributo.query.filter_by(id = atributoItem.id_atributo).first()
getattr(form, atributo.nombre).data = atributoItem.valor
return render_template("item/modificar_item.html", form=form)
else:
flash('No tiene permisos para modificar items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
else:
flash('Verifique que el estado de la fase y el item sean los necesarios')
return redirect(url_for('items.administracion_item'))
@mod.route('/eliminar/<item>/', methods=['GET', 'POST'])
def eliminar_item(item):
"""
Muestra en pantalla el formulario de eliminacion de items, se pide la confimacion del usuario
y se elimina el item.
@param item: id del item que se desea eliminar.
"""
itemSeleccionado = Item.query.filter_by(id = item).first()
itemsFase = Item.query.filter(Item.fase_id == itemSeleccionado.fase_id, Item.estado != 'Eliminado' ).all()
# Obtenemos la fase del item seleccionado
fase = Fase.query.filter_by(id = itemSeleccionado.fase_id).first()
# Verificamos si el usuario tiene permisos para modificar los items de la fases
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
for itemFase in itemsFase:
if(itemFase.numero > itemSeleccionado.numero):
itemFase.numero = itemFase.numero - 1
db.session.add(itemFase)
if(itemSeleccionado.estado == 'Activo'or itemSeleccionado.estado == 'Revision' ):
itemsHijos = Item.query.filter_by(padre_id = item).all()
for itemHijo in itemsHijos:
itemHijo.estado = 'Revision'
db.session.add(itemHijo)
itemsSucesores = Item.query.filter_by(antecesor_id = item).all()
for itemSucesor in itemsSucesores:
itemSucesor.estado = 'Revision'
db.session.add(itemSucesor)
itemSeleccionado.estado = 'Eliminado'
db.session.add(itemSeleccionado)
db.session.commit()
itemsFase = Item.query.filter(Item.fase_id == itemSeleccionado.fase_id, Item.estado != 'Eliminado' ).all()
if (len(itemsFase) == 0):
fase.estado = 'Pendiente'
db.session.add(fase)
db.session.commit()
flash('El item se ha eliminado exitosamente')
else:
flash('El item no puede ser eliminado')
else:
flash('No tiene permisos para crear items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
return redirect(url_for('items.administracion_item'))
@mod.route('/revivir/<item>/', methods=['GET', 'POST'])
def revivir_item(item):
itemSeleccionado = Item.query.filter_by(id = item).first()
#Obtenemos la fase del item seleccionado
fase = Fase.query.filter_by(id = itemSeleccionado.fase_id).first()
# Verificamos si el usuario tiene permisos para modificar los items de la fases
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
if(fase.estado != 'Finalizada'):
if(itemSeleccionado.estado == 'Eliminado'):
antecesor_id = itemSeleccionado.antecesor_id
if(antecesor_id != None):
antecesor = Item.query.filter_by(id = antecesor_id).first()
else:
antecesor = None
padre_id = itemSeleccionado.padre_id
if(padre_id != None):
padre = Item.query.filter_by(id = padre_id).first()
else:
padre = None
antecesor_bandera = False
padre_bandera = False
if(antecesor != None):
if(antecesor.estado != 'Eliminado'):
antecesor_bandera = True
else:
antecesor_bandera = True
if(padre != None):
if(padre.estado != 'Eliminado'):
padre_bandera = True
else:
padre_bandera = True
historial_item = Historial()
historial_item.setAntecesor(itemSeleccionado.antecesor_id)
historial_item.setComplejidad(itemSeleccionado.complejidad)
historial_item.setCosto(itemSeleccionado.costo)
historial_item.setDescripcion(itemSeleccionado.descripcion)
historial_item.setDuracion(itemSeleccionado.duracion)
historial_item.setEstado(itemSeleccionado.estado)
historial_item.setFase(itemSeleccionado.fase)
historial_item.setFechaCreacion(itemSeleccionado.fecha_creacion)
historial_item.setFechaModificacion(date.today())
historial_item.setItemId(itemSeleccionado.id)
historial_item.setLb(itemSeleccionado.linea_base)
historial_item.setNombre(itemSeleccionado.nombre)
historial_item.setNumero(itemSeleccionado.numero)
historial_item.setObservacion(itemSeleccionado.observacion)
historial_item.setPadre(itemSeleccionado.padre_id)
historial_item.setPrioridad(itemSeleccionado.prioridad)
historial_item.setVersion(itemSeleccionado.version)
atributos = itemSeleccionado.tipo.atributo
for atributo in atributos:
atributoItem = AtributoItem.query.filter_by(id_item=itemSeleccionado.id, id_atributo = atributo.id, version = itemSeleccionado.version).first()
atributoItemNuevo = AtributoItem(atributoItem.id_item, atributoItem.id_atributo, atributoItem.version + 1, atributoItem.valor )
db.session.add(atributoItemNuevo)
if(padre_bandera and antecesor_bandera):
itemSeleccionado.estado = 'Activo'
version_int = int(itemSeleccionado.version)
version_int = version_int + 1
itemSeleccionado.version = str(version_int)
mensaje = 'Se ha revivido el item exitosamente'
else:
itemSeleccionado.estado = 'Revision'
version_int = int(itemSeleccionado.version)
version_int = version_int + 1
itemSeleccionado.version = str(version_int)
mensaje = 'Se ha revivido el item con conflictos en sus relaciones, favor verificar las mismas'
db.session.add(itemSeleccionado)
db.session.add(historial_item)
db.session.commit()
flash(mensaje)
return redirect(url_for('items.administracion_item'))
else:
flash('El item no esta eliminado, por lo tanto no puede ser revivido')
return redirect(url_for('items.administracion_item'))
else:
flash('La fase del item seleccionado ya esta finalizada, no se pueden realizar cambios')
return redirect(url_for('items.administracion_item'))
else:
flash('No tiene permisos para crear items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
return redirect(url_for('items.administracion_item'))
@mod.route('/adjuntar/<item>/', methods=['GET', 'POST'])
def adjuntar_archivo(item):
"""
Muestra en pantalla el formulario para adjuntar archivos a un item.
@param item: id del item al cual se desea adjuntar el archivo.
"""
form = ArchivoForm()
item_seleccionado = Item.query.filter_by(id = item).first()
fase = Fase.query.filter_by(id = item_seleccionado.fase_id).first()
# Verificamos si el usuario tiene permisos para modificar los items de la fases
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
if request.method == 'GET':
return render_template('item/adjuntar_archivo.html', form = form, item = item_seleccionado)
else:
filename = secure_filename(form.archivo.data.filename)
file_data = form.archivo.data.read()
file_tipo = form.archivo.data.mimetype
#gger.info(form.archivo.data)
#current_app.logger.info(file_data)
archivo = Archivo(filename, file_data, file_tipo)
db.session.add(archivo)
item_seleccionado.add_archivo(archivo)
db.session.add(item_seleccionado)
db.session.commit()
flash(u'Archivo cargado exitosamente, {0}'.format(filename))
return render_template('item/adjuntar_archivo.html', form = form, item = item_seleccionado)
#print filename
#show_the_login_form()
else:
flash('No tiene permisos para modificar items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
return redirect(url_for('items.administracion_item'))
@mod.route('/bajar/<archivo>/')
def bajar_archivo(archivo):
"""
@param archivo: id del arhivo que se desea descargar
"""
a_bajar = Archivo.query.filter_by(id = archivo).first()
results = a_bajar.datos
generator = (cell for row in results
for cell in row)
#flash(u'Bajando archivo: {0}'.format(a_bajar.nombre))
return Response(generator,
mimetype=a_bajar.tipo,
headers={"Content-Disposition":
"attachment;filename={0}".format(a_bajar.nombre)})
@mod.route('/eliminar_archivo/<item>/<archivo>/')
def eliminar_archivo(item, archivo):
"""
Muestra en pantalla el formulario para la eliminacion archivos a de item.
@param item: id del item al cual se desea eliminar el archivo.
@param archivo: id del archivo que se desea eliminar
"""
item_seleccionado = Item.query.filter_by(id = item).first()
fase = Fase.query.filter_by(id = item_seleccionado.fase_id).first()
# Verificamos si el usuario tiene permisos para modificar los items de la fases
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
a_borrar = Archivo.query.filter_by(id = archivo).first()
nombre = a_borrar.nombre
db.session.delete(a_borrar)
db.session.commit()
flash(u'Archivo eliminado correctamente: {0}'.format(nombre))
return redirect(url_for('items.adjuntar_archivo', item=item))
else:
flash('No tiene permisos para modificar items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
return redirect(url_for('items.administracion_item'))
@mod.route('/historial/<item_id>/', methods = ['GET', 'POST'])
def historial_item(item_id):
item_seleccionado = Item.query.filter_by(id = item_id).first()
fase = item_seleccionado.fase
#obtenemos el formulario
form = ItemVerHistorial(request.form)
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
if(item_seleccionado.estado != None):
#obtenemos el historial del item seleccionado
historial = Historial.query.filter(Historial.id_item == item_seleccionado.id)
estados_item=[]
datos_item=[]
desc_item=[]
antec_item=[]
padre_item=[]
for histItem in historial:
if (histItem != None):
estados_item.append((histItem.id,histItem.version +" "+histItem.estado +" "+ str(histItem.fecha_creacion) +" "+ str(histItem.fecha_modificacion) ))
if(histItem.prioridad == None or histItem.prioridad == ''):
prioridad="Sin datos en prioridad"
else:
prioridad=histItem.prioridad
if(str(histItem.costo) == None or str(histItem.costo) == ''):
costo="Sin datos en costo"
else:
costo = str(histItem.costo)
if(histItem.complejidad == None or histItem.complejidad== ''):
complejidad="Sin datos en complejidad"
else:
complejidad=histItem.complejidad
datos_item.append((histItem.id,histItem.version +" "+prioridad+" "+costo+" "+complejidad) )
if(histItem.descripcion == None or histItem.descripcion == ''):
descripcion="Sin descripciones"
else:
descripcion=histItem.descripcion
if(histItem.observacion == None or histItem.observacion == ''):
observacion="Sin observaciones"
else:
observacion = histItem.observacion
desc_item.append((histItem.id,histItem.version +" "+descripcion+" "+ observacion ))
antecesor_id=histItem.antecesor_id
if(antecesor_id != None):
antecesor = Item.query.filter_by(id = antecesor_id).first()
else:
antecesor = "Sin antecesores"
padre_id=histItem.padre_id
if(padre_id != None):
padre = Item.query.filter_by(id = padre_id).first()
else:
padre = "Sin padres"
antec_item.append((histItem.id,histItem.version +" "+ antecesor))
padre_item.append((histItem.id,histItem.version +" "+ padre))
form.nombre.data = item_seleccionado.nombre
form.estados.choices = estados_item
form.datos.choices = datos_item
form.descripcion.choices=desc_item
form.antecesores.choices = antec_item
form.padres.choices = padre_item
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de fases
return redirect(url_for('items.administracion_item'))
#return render_template('item/historial_item.html', form = form,
# item_id = item_seleccionado.id)
return render_template('item/historial_item.html', items=historial)
else:
flash('El item seleccionado no se encuentra con estado Activo')
return redirect(url_for('items.administracion_item'))
else:
flash('No tiene permisos para consultar el historial de items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
@mod.route('/seleccionar/<item>/', methods=['GET', 'POST'])
def seleccionar_version(item):
"""
Muestra en pantalla las versiones de los items de una fase.
"""
#obtenemos el item seleccionado
item_seleccionado = Item.query.filter_by(id=item).first()
#obtenemos el historial del item seleccionado
historial = Historial.query.filter(Historial.id_item == item_seleccionado.id)
# Obtenemos la fase del item seleccionado
fase = Fase.query.filter_by(id = item_seleccionado.fase_id).first()
# Verificamos si el usuario tiene permisos para modificar los items de la fases
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
if(fase.estado != 'Finalizada'):
if (item_seleccionado.estado == 'Activo'):
# Obtenemos el formulario para listar las versiones de los items
form = SeleccionarVersionItem(request.form)
#obtenemos todas las versiones del item seleccionado
lista_versiones=[]
for version in historial:
lista_versiones.append((version.id,version.version))
# Asignamos esa tupla de versiones de items a la lista que va a ser visualizada
form.versiones.choices = lista_versiones
form.item.data = item_seleccionado.nombre
if form.validate_on_submit():
session['version_id'] = form.versiones.data
return redirect(url_for('items.revertir_item'))
return render_template('item/seleccionar_version.html', form = form)
else:
flash('El item seleccionado no se encuentra con estado Activo.')
return redirect(url_for('items.administracion_item'))
else:
flash('La fase del item seleccionado ya esta finalizada, no se pueden realizar cambios')
return redirect(url_for('items.administracion_item'))
else:
flash('No tiene permisos para revertir items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
@mod.route('/revertir/', methods=['GET', 'POST'])
def revertir_item():
#obtenemos el historial de la version seleccionada
id_version = session['version_id']
version_seleccionada = Historial.query.filter_by(id = id_version[0]).first()
#obtenemos el item de la version seleccionada
item_actual = Item.query.filter_by(id=version_seleccionada.id_item).first()
item = item_actual
# Obtenemos el formulario para revertir items
form = ReversionItem(request.form)
if(version_seleccionada.estado != 'Eliminado'):
if form.validate_on_submit():
#almacenamos los valores del item actual
historial_item = Historial()
historial_item.setAntecesor(item_actual.antecesor_id)
historial_item.setComplejidad(item_actual.complejidad)
historial_item.setCosto(item_actual.costo)
historial_item.setDescripcion(item_actual.descripcion)
historial_item.setDuracion(item_actual.duracion)
historial_item.setEstado(item_actual.estado)
historial_item.setFase(item_actual.fase)
historial_item.setFechaCreacion(item_actual.fecha_creacion)
historial_item.setFechaModificacion(date.today())
historial_item.setItemId(item_actual.id)
historial_item.setLb(item_actual.linea_base)
historial_item.setNombre(item_actual.nombre)
historial_item.setNumero(item_actual.numero)
historial_item.setObservacion(item_actual.observacion)
historial_item.setPadre(item_actual.padre_id)
historial_item.setPrioridad(item_actual.prioridad)
historial_item.setVersion(item_actual.version)
db.session.add(historial_item)
db.session.commit()
atributos = item_actual.tipo.atributo
for atributo in atributos:
atributoItem = AtributoItem.query.filter_by(id_item=item_actual.id, id_atributo = atributo.id, version = item_actual.version).first()
atributoItemNuevo = AtributoItem(atributoItem.id_item, atributoItem.id_atributo, atributoItem.version + 1, atributoItem.valor )
db.session.add(atributoItemNuevo)
#obtenemos la nueva version para el item
version_int = int(item_actual.version)
version_int = version_int + 1
#verificamos los estados de los antecesores y padres de la version seleccionada
antecesor_id = version_seleccionada.antecesor_id
if(antecesor_id != None):
antecesor = Item.query.filter_by(id = antecesor_id).first()
else:
antecesor = None
padre_id = version_seleccionada.padre_id
if(padre_id != None):
padre = Item.query.filter_by(id = padre_id).first()
else:
padre = None
antecesor_bandera = False
padre_bandera = False
if(antecesor != None):
if(antecesor.estado != 'Eliminado'):
antecesor_bandera = True
else:
antecesor_bandera = True
if(padre != None):
if(padre.estado != 'Eliminado'):
padre_bandera = True
else:
padre_bandera = True
if(padre_bandera and antecesor_bandera):
estado = 'Activo'
else:
estado = 'Revision'
#cargamos los datos del historial al item
item_actual.version = version_int
if antecesor!= None:
item_actual.antecesor_id = antecesor
if padre!= None:
item_actual.padre_id = padre
item_actual.complejidad = version_seleccionada.complejidad
item_actual.costo = version_seleccionada.costo
item_actual.descripcion = version_seleccionada.descripcion
item_actual.duracion = version_seleccionada.duracion
item_actual.estado = estado
item_actual.fecha_creacion = version_seleccionada.fecha_creacion
item_actual.prioridad = version_seleccionada.prioridad
item_actual.observacion = version_seleccionada.observacion
item_actual.numero = version_seleccionada.numero
db.session.add(item_actual)
db.session.commit()
flash('El item fue actualizado a la nueva version con exito.')
return redirect(url_for('items.administracion_item'))
else:
flash('La version seleccionada se encuentra con estado Eliminado.')
return redirect(url_for('items.administracion_item'))
# Mostramos en el formulario los datos actuales item seleccionado
form.nombre.data = version_seleccionada.nombre
form.complejidad.data = version_seleccionada.complejidad
form.prioridad.data = version_seleccionada.prioridad
form.costo.data = version_seleccionada.costo
form.duracion.data = version_seleccionada.duracion
return render_template('item/revertir_item.html', form = form)
@mod.route('/reporte_item/', methods=['GET', 'POST'])
def reporte_item():
"""
Genera un pdf con los items del proyecto, agrupados por fase
"""
proyecto = g.proyecto
idList = []
fases = proyecto.fases
for fase in fases:
idList.append(fase.id)
report = ItemReport(Item.query.filter(Item.fase_id.in_(idList)).order_by(Item.fase_id, Item.numero).all())
cur_dir = os.path.dirname(os.path.abspath(__file__))
reporte_dir = cur_dir + '/pdf'
nombre = 'reporte_item.pdf'
#-------------------------------- if reporte_dir.isfile('reporte_item.pdf'):
#----------------------------------------- nombre = 'reporte_item_2.pdf'
report.generate_by(PDFGenerator, filename=os.path.join(reporte_dir , nombre))
ruta = '/usr/bin/gnome-open ' + reporte_dir + '/' + nombre
os.system(ruta)
return redirect(url_for('items.administracion_item'))
@mod.route('/reporte_historial/<item_id>/', methods=['GET', 'POST'])
def reporte_historial(item_id):
"""
Genera un pdf con los items del proyecto, agrupados por fase
"""
item_seleccionado = Item.query.filter_by(id = item_id).first()
fase = item_seleccionado.fase
#obtenemos el formulario
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
if(item_seleccionado.estado != None):
#obtenemos el historial del item seleccionado
historial = Historial.query.filter(Historial.id_item == item_seleccionado.id)
report = HistorialReport(historial)
cur_dir = os.path.dirname(os.path.abspath(__file__))
reporte_dir = cur_dir + '/pdf'
nombre = 'reporte_historial.pdf'
report.generate_by(PDFGenerator, filename=os.path.join(reporte_dir , nombre))
ruta = '/usr/bin/gnome-open ' + reporte_dir + '/' + nombre
os.system(ruta)
return redirect(url_for('items.administracion_item'))
else:
flash('No tiene permisos para consultar el historial de items dentro de la fase seleccionada')
return redirect(url_for('items.administracion_item'))
def verificar_autorizacion_fase(usuario = None, fase = None, permisoRequerido = None):
autorizado = False
permiso = db.session.query(Permiso).filter_by(nombre = permisoRequerido, entidad_id = fase.entidad_id).first()
if(permiso != None):
for rol in usuario.roles:
if permiso in rol.permiso:
autorizado = True
return autorizado
| Python |
'''
Created on 24/05/2013
@author: belentwi
'''
from flask import Blueprint
from app import db
from app.models.voto import Voto
mod = Blueprint('votos', __name__, url_prefix='/votos') | Python |
'''
Created on 17/06/2013
@author: mirta
'''
#from flask import jsonify
import json
from app.nodo import Nodo
from app.nodo import construir_lista
from app.arista import Arista
from app.arista import construir_lista_arista
#import simplejson as json
from flask import Blueprint
#from flask import request, flash
from flask import render_template
#from flask import redirect
#from flask import url_for
from app.models.proyecto import Proyecto
from app.models.fase import Fase
from app.models.item import Item
#from app.models.entidad import Entidad
#from app.models.usuario import Usuario
#from app.models.rol import Rol
#from app.models.permiso import Permiso
from app.security import g
#from app.security import permission
mod = Blueprint('grafico', __name__, url_prefix='/grafico')
@mod.route('/items/<proyecto>/', methods=['GET', 'POST'])
def graficar_items(proyecto):
"""
Muestra graficamente los items de un proyecto con sus relaciones si lo hubiere
@param proyecto: id del proyecto cuyos items se quieren graficar
@return: el grafico con todos los items del proyecto y sus relaciones
"""
proyecto_seleccionado = Proyecto.query.filter_by(id=proyecto).first()
fases = Fase.query.filter_by(proyecto_id=proyecto_seleccionado.id)
fases = fases.all()
lista_nodos = []
lista_aristas = []
for fase in fases:
items = Item.query.filter_by(fase_id=fase.id)
items = items.all()
for item in items:
nodo = Nodo(str(item.id), item.nombre, str(item.costo))
lista_nodos.append(nodo)
if item.antecesor_id != None or item.antecesor_id == "":
arista = Arista(str(item.antecesor_id), str(item.id), 'Antecesor')
lista_aristas.append(arista)
if item.padre_id != None or item.antecesor_id == "":
arista = Arista(str(item.padre_id), str(item.id), 'Padre')
lista_aristas.append(arista)
return render_template('grafico/grafico.html', nodos=json.dumps(construir_lista(lista_nodos)),
aristas = json.dumps(construir_lista_arista(lista_aristas)))
#return { 'hola' : 'chau' }
#Construimos unos cuantos nodos
#nodo1 = Nodo('1', 'nodo 1', '200');
#nodo2 = Nodo('2', 'nodo 2', '300');
#nodo3 = Nodo('3', 'nodo 3', '400');
#esto es lo que recibimos de la db guau
#nodos = [ nodo1, nodo2, nodo3 ]
#return jsonify(construir_lista(nodos)) | Python |
'''
Created on 17/05/2013
@author: belentwi
'''
from flask import Blueprint
from app import db
from app.models.atributo_item import AtributoItem
mod = Blueprint('atributosItems', __name__, url_prefix='/atributosItems')
| Python |
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from app import db
from app.security import g
from app.wtforms.comite_cambio_forms import ComiteEditable
from app.wtforms.comite_cambio_forms import ComiteConsultar
from app.models.comite_de_cambio import ComiteDeCambio
from app.models.usuario import Usuario
mod = Blueprint('comites', __name__, url_prefix='/comite')
@mod.route('/administracion/', methods=['GET', 'POST'])
def administracion_cdc():
"""
Muestra en pantalla las operaciones que se pueden realizar con un comite de cambio:
Crear, Modificar, Consultar. Esta pagina solo podra ser vista por el lider del proyecto
en cuestion
"""
# Si el usuario no tiene asociado ningun proyecto o no es lider del proyecto
# con el que se logueo no se le permite ver la pagina
if g.proyecto==None or g.user.id!=g.proyecto.lider_id:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
return render_template('comite_cambio/administracion_cdc.html')
@mod.route('/crear/', methods=['GET', 'POST'])
def crear_cdc():
"""
Permita la creacion de un comite de cambio si es que este no existe aun en el proyecto.
Lista los usuarios que pueden ser miembros, por defecto esta marcado el lider del proyecto
quien es miembro obligatorio
"""
# Si el usuario no tiene asociado ningun proyecto o no es lider del proyecto
# con el que se logueo no se le permite ver la pagina
if g.proyecto==None or g.user.id!=g.proyecto.lider_id:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
# Obtenemos el proyecto con el que ingreso el usuario
proyecto_seleccionado = g.proyecto
# Obtenemos el comite asociado a ese proyecto
comite_existe = proyecto_seleccionado.comite
# Si ya existe el comite, informamos al usuario y lo redirigimos a la pagina de administracion
# de comite de cambio
if comite_existe != None:
flash("El proyecto ya cuenta con un comite de cambio")
return redirect(url_for('comites.administracion_cdc'))
# Si no existe un comite asociado al proyecto
else:
# Obtenemos el formulario
form = ComiteEditable(request.form)
# Obtnemos los miembros del proyecto
miembros_proyecto = proyecto_seleccionado.miembros
# Realizamos uns lista de los miembros del proyecto para mostrarle al usuario
lista_miembros_proyecto = []
for miembro in miembros_proyecto:
lista_miembros_proyecto.append((miembro.id, miembro.nombre))
# Mostramos la lista del miembros del proyecto al usuario
form.miembros.choices = lista_miembros_proyecto
# Validamos todos los datos ingresados al formulario por el usuario
if form.validate_on_submit():
# Obtenemos la cantidad de miembros que fueron seleccionados
cantidad_miembros = len(form.miembros.data)
# Si esa cantidad es par, informamos al usuario del problema y no le permitimos crear
# el comite por lo que lo redirigimos a la pagina de creacion de comite
if (cantidad_miembros%2) == 0:
flash('La cantidad de miembros del comite debe ser impar')
return redirect(url_for('comites.crear_cdc'))
# Si el numero seleccionado de miembros para el nuevo comite es impar
else:
# Verificamos si el lider el proyecto se encuentra entre los miembros seleccionados
# Si es asi, se crea el nuevo comite de cambio
if proyecto_seleccionado.lider_id in form.miembros.data:
# Realizamos una lista con todos lo usuarios que fueron seleccionados como
# miembros del proyecto
lista_miembros = []
for miembro in form.miembros.data:
# Por cada miembro seleccionado, traemos su usuario de la base de datos
usuario_miembro = Usuario.query.filter_by(id=miembro).first()
lista_miembros.append(usuario_miembro)
# Creamos el nuevo cmite con la observacion realizada por usuario y la lista
# de miembros seleccionados por el mismo
comite = ComiteDeCambio(form.observacion.data, lista_miembros, cantidad_miembros)
# Guardamos el comite de cambio en la base de datos
db.session.add(comite)
db.session.commit()
# Indicamos en el proyecto cual es su comite de cambio
proyecto_seleccionado.comite = comite
# Guardamos los cambios en la base de datos
db.session.add(proyecto_seleccionado)
db.session.commit()
# Desplegamos un mensaje indicando el exito de la operacion al usuario
flash('El comite ha sido registrado con exito')
return redirect(url_for('comites.administracion_cdc'))
# Si el lider del proyecto no esta entre los miembor seleccionados
# no permitimos la creacion del comite de cambio y se lo indicamos al usuario
else:
flash('El lider del proyecto debe ser miembro del comite')
return redirect(url_for('comites.crear_cdc'))
# Mostramos por defecto seleccionado al lider del proyecto como miembro del comite
form.miembros.data = [proyecto_seleccionado.lider_id]
return render_template('comite_cambio/crear_cdc.html', form=form)
@mod.route('/modificar/', methods=['GET', 'POST'])
def modificar_cdc():
"""
Permite la modificacion de los miembros de un comite de cambio, el lider de proyecto
debe ser miembro siempre
"""
# Si el usuario no tiene asociado ningun proyecto o no es lider del proyecto
# con el que se logueo no se le permite ver la pagina
if g.proyecto==None or g.user.id!=g.proyecto.lider_id:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
# Obtenemos el proyecto con el que ingreso el usuario
proyecto_seleccionado = g.proyecto
# Obtenemos el comite de cambio de ese proyecto
comite_existe = proyecto_seleccionado.comite
# Si no existe un comite de cambio asociado con el proyecto
if comite_existe == None:
# Se lo indicamos al usuario con un mensaje y lo redirigimos a la pagina de administracion
# de comite de cambio
flash("El proyecto no cuenta con un comite de cambio")
return redirect(url_for('comites.administracion_cdc'))
# Si existe un comite de cambio asociado con el proyecto
else:
# Obtenemos el formulario
form = ComiteEditable(request.form)
# Obtenemos lo miembros del proyecto
miembros_proyecto = proyecto_seleccionado.miembros
# Relizamos un lista de los miembros del proyecto para mostrarle al usuario
lista_miembros_proyecto = []
for miembro in miembros_proyecto:
lista_miembros_proyecto.append((miembro.id, miembro.nombre))
# Mostramos la lista de miembros del proyecto al usuario
form.miembros.choices = lista_miembros_proyecto
lista_miembros_seleccionados = []
for miembro in comite_existe.miembros:
lista_miembros_seleccionados.append(miembro.id)
# Validamos que los datos ingresados al usuario sean correctos
if form.validate_on_submit():
# Obtenemos la cantidad de miembros seleccionados por el usuario
cantidad_miembros = len(form.miembros.data)
# Si la cantidad seleccionada es par
if (cantidad_miembros) != comite_existe.cantidad_miembros:
# No se permite guardar los cambios. Se despliega un mensaje indicando al usuario
# el hecho
flash('La cantidad de miembros del comite debe ser %s' % comite_existe.cantidad_miembros )
return redirect(url_for('comites.modificar_cdc'))
# Si la cantidad de miembros seleccionados es impar
else:
# Se verifica si el lider de proyecto esta seleccionado como miembro
# Si lo esta, se realiza la modificacion
if proyecto_seleccionado.lider_id in form.miembros.data:
# Realizamos un lista con los miembros seleccionados por el usuario
lista_miembros = []
# Por cada miembro seleccionado
for miembro in form.miembros.data:
# Obtenemos su usuario de la base de datos y lo agregamos a la lista
usuario_miembro = Usuario.query.filter_by(id=miembro).first()
lista_miembros.append(usuario_miembro)
# Cambiamos el valor de la observacion por la que ingreso el usuario
comite_existe.observacion = form.observacion.data
# Cambiamos el los miembros del comite por los que selecciono el usuario
comite_existe.miembros = lista_miembros
# Guardamos los cambios en la base de datos
db.session.add(comite_existe)
db.session.commit()
# Indicamos al usuario el exito de la operacion, desplegando un mensaje
flash('El comite ha sido registrado con exito')
return redirect(url_for('comites.administracion_cdc'))
# Si el lider el proyecto no se encuentra como miembro del comite
else:
# No permitimos su modificacion, indicamos al usuario el hecho desplegando
# un mensaje
flash('El lider del proyecto debe ser miembro del comite')
return redirect(url_for('comites.modificar_cdc'))
# Mostramos al usuario la lista de miembros actuales el comite de cambio
form.miembros.data = lista_miembros_seleccionados
# Mostramos al usuario la observacion actual que posee el comite de cambio
form.observacion.data = comite_existe.observacion
return render_template('comite_cambio/modificar_cdc.html', form=form)
@mod.route('/consultar/', methods=['GET', 'POST'])
def consultar_cdc():
"""
Consulta los miembros que forman el comite de cambio
"""
# Si el usuario no tiene asociado ningun proyecto o no es lider del proyecto
# con el que se logueo no se le permite ver la pagina
if g.proyecto==None or g.user.id!=g.proyecto.lider_id:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
# Obtenemos el proyecto con el que ingreso el usuario
proyecto_seleccionado = g.proyecto
# Obtenemos el comite de cambio de ese proyecto
comite_existe = proyecto_seleccionado.comite
# Si no existe un comite de cambio asociado con el proyecto
if comite_existe == None:
# Se lo indicamos al usuario con un mensaje y lo redirigimos a la pagina de administracion
# de comite de cambio
flash("El proyecto no cuenta con un comite de cambio")
return redirect(url_for('comites.administracion_cdc'))
# Si existe un comite de cambio asociado con el proyecto
else:
# Obtenemos el formulario
form = ComiteConsultar(request.form)
# Obtenemos lo miembros del comite de cambio
miembros_comite = comite_existe.miembros
# Relizamos una lista de los miembros del comite para mostrar al usuario
lista_miembros_comite = []
for miembro in miembros_comite:
lista_miembros_comite.append((miembro.id, miembro.nombre))
# Validamos que los datos ingresados al usuario sean correctos
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de comite de cambios
return redirect(url_for('comites.administracion_cdc'))
# Mostramos al usuario la lista de miembros actuales el comite de cambio
form.miembros.choices = lista_miembros_comite
return render_template('comite_cambio/consultar_miembroscdc.html', form=form) | Python |
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from app import db
from app.security import permission
from app.wtforms.permiso_forms import PermisoBuscar
from app.wtforms.permiso_forms import PermisoEditable
from app.wtforms.permiso_forms import PermisoNoEditable
from app.models.permiso import Permiso
from app.models.entidad import Entidad
from app.models.rol import Rol
mod = Blueprint('permisos', __name__, url_prefix='/permisos')
#Lista de los nombre de los permisos por defecto del sistema
permisos_por_defecto = ['CREAR_USUARIO','MODIFICAR_USUARIO','DESACTIVAR_USUARIO','VER_USUARIO','CREAR_ROL','MODIFICAR_ROL','ELIMINAR_ROL','VER_ROL','CREAR_PERMISO','ELIMINAR_PERMISO','ACTIVAR_USUARIO']
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_PERMISOS')
def administracion_permiso():
"""
Muestra en pantalla los permisos que existen en la base de datos.
Si no recibe algun filtro como parametro, lista todos los permisos.
Si recibe algun filtro, muestra los permisos que cumplen con el filtro indicado
"""
# Obtenemos el formulario
form = PermisoBuscar(request.form)
# Obtenemos el filtro
nombreFilter = form.nombre.data
entidadFilter = form.entidad.data
if(nombreFilter == None):
nombreFilter = ''
if(entidadFilter == None):
entidadFilter = ''
# Recuperamor de la base de datos lo permisos que coinciden con el filtro
#===========================================================================
# permisos = Permiso.query.filter(Permiso.nombre.like( '%'+nombreFilter+'%' )).join(Entidad).filter(Entidad.nombre.like('%' + entidadFilter + '%'))
#===========================================================================
permisos = Permiso.query.filter(Permiso.nombre.like( '%'+nombreFilter+'%' ))
permisos = permisos.all()
return render_template('permiso/administracion_permiso.html', form = form, permisos = permisos)
@mod.route('/crear/', methods=['GET', 'POST'])
@permission('CREAR_PERMISO')
def crear_permiso():
"""
Muestra en pantalla el formulario de creacion de permisos, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre del nuevo permiso no exista en el
sistema y se hayan ingresado los datos obligatorios. Luego almacena en base de datos
"""
# Obtenemos el formulario
form = PermisoEditable(request.form)
choicesEntidades = []
choicesPermisos = [('1', 'VER'), ('2', 'MODIFICAR'), ('3','ELIMINAR')]
# Obtenemos todas las entidades existentes en la base de datos
#entidades = Entidad.query.filter(~(Entidad.id.in_(db.session.query(Permiso.entidad_id).filter().all())))
entidades = Entidad.query.filter()
entidades.all()
for entidad in entidades:
choicesEntidades.append((str(entidad.id), entidad.nombre))
form.entidad.choices = choicesEntidades
form.nombre.choices = choicesPermisos
if form.validate_on_submit():
cont = 0
descripcion = form.descripcion.data
posicion = int(form.nombre.data)-1
entidad = Entidad.query.get(int(form.entidad.data))
permisos = Permiso.query.filter_by(entidad_id=entidad.id)
permisos = permisos.all()
for permiso in permisos:
if permiso.nombre == choicesPermisos[posicion][1]:
cont = cont + 1
if cont == 0:
permiso = Permiso(choicesPermisos[posicion][1], descripcion,entidad)
db.session.add(permiso)
db.session.commit()
flash('El permiso ha sido registrado con exito')
return redirect(url_for('permisos.administracion_permiso'))
else:
flash('El permiso ya existe')
return redirect(url_for('permisos.crear_permiso'))
return render_template("permiso/crear_permiso.html", form=form)
@mod.route('/consultar/<permiso>/', methods=['GET', 'POST'])
@permission('VER_PERMISO')
def consultar_permiso(permiso):
"""
Muestra en pantalla el formulario de consulta de permisos, muestra todos los datos del
permiso seleccionado
:param permiso:
id del permiso que se desea consultar
"""
# Obtenemos el formulario
form = PermisoNoEditable(request.form)
#Obtenemos el permiso seleccionado
permiso_seleccionado = Permiso.query.filter_by(id=permiso).first()
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de permisos
return redirect(url_for('permisos.administracion_permiso'))
#Mostramos los datos actuales del permiso seleccionado
form.nombre.data = permiso_seleccionado.nombre
form.descripcion.data = permiso_seleccionado.descripcion
if permiso_seleccionado.entidad != None:
form.entidad.data = permiso_seleccionado.entidad.nombre
else:
form.entidad.data = "no posee entidad asociada"
return render_template('permiso/consultar_permiso.html', form = form,
permiso_seleccionado=permiso_seleccionado)
@mod.route('/modificar/<permiso>/', methods=['GET', 'POST'])
@permission('MODIFICAR_PERMISO')
def modificar_permiso(permiso):
"""
Muestra en pantalla el formulario de modificacion de permisos
:param permiso:
id del permiso seleccionado
"""
#Obtenemos el permiso seleccionado
permiso_seleccionado = Permiso.query.filter_by(id=permiso).first()
if permiso_seleccionado.nombre in permisos_por_defecto:
# Si el permiso seleccionado es un permiso por defecto no permitimos la modificacion
flash('No se puede modificar el permiso por defecto %s ' % permiso_seleccionado.nombre,
'error-message')
return redirect(url_for('permisos.administracion_permiso', permiso=permiso))
else:
# Obtenemos el formulario
form = PermisoNoEditable(request.form)
# Validamos los datos ingresados al formulario
if form.validate_on_submit():
# Realizamos los cambios en la descripcion del permiso
permiso_seleccionado.setDescripcion(form.descripcion.data)
#Almacenamos el permiso modificado en la base de datos
db.session.add(permiso_seleccionado)
db.session.commit()
# Retornamos a la pagina de administracion de roles
flash('El permiso ha sido registrado con exito')
return redirect(url_for('permisos.administracion_permiso'))
# Mostramos en el formulario los datos actuales del permiso seleccionado
form.nombre.data = permiso_seleccionado.nombre
form.descripcion.data = permiso_seleccionado.descripcion
form.entidad.data = permiso_seleccionado.entidad.nombre
return render_template('permiso/modificar_permiso.html', form = form,
permiso_seleccionado=permiso_seleccionado)
@mod.route('/eliminar/<permiso>/', methods=['GET', 'POST'])
@permission('ELIMINAR_PERMISO')
def eliminar_permiso(permiso):
"""
Muestra en pantalla el formulario de eliminacion de permisos.
:param permiso:
id del permiso que se desea eliminar
"""
#Obtenemos el permiso seleccionado
permiso_seleccionado = Permiso.query.filter_by(id=permiso).first()
if permiso_seleccionado.nombre in permisos_por_defecto:
# Si el permiso seleccionado es un permiso por defecto no permitimos la eliminacion
flash('No se puede elimninar el permiso por defecto %s' % permiso_seleccionado.nombre,
'error-message')
return redirect(url_for('permisos.administracion_permiso', permiso=permiso))
else:
# Obtenemos todos los roles de la base de datos
roles = Rol.query.all()
for rol in roles:
for per in rol.permiso:
if permiso_seleccionado.nombre in per.nombre:
#Si el permiso seleccionado se encuentra relacionado
#con algun rol no permitimos la eliminacion
flash('No se puede elimninar el permiso, se encuentra relacionado con un rol %s' % rol.nombre,
'error-message')
return redirect(url_for('permisos.administracion_permiso', permiso=permiso))
# Obtenemos el formulario
form = PermisoNoEditable(request.form)
# Mostramos el nombre del permiso
form.nombre.data = permiso_seleccionado.nombre
# Mostramos la descripcion del permiso
form.descripcion.data = permiso_seleccionado.descripcion
# Borramos de la base de datos el permiso
db.session.delete(permiso_seleccionado)
db.session.commit()
flash('El permiso ha sido eliminado')
# Redirigimos a la pagina de administracion de permisos
return redirect(url_for('permisos.administracion_permiso'))
| Python |
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from flask import session
from app import db
from app.security import permission
from app.security import g
from app.wtforms.tipoItem_forms import TipoItemBuscar
from app.wtforms.tipoItem_forms import SeleccionarFase
from app.wtforms.tipoItem_forms import TipoItemEditable
from app.wtforms.tipoItem_forms import TipoItemNoEditable
from app.wtforms.tipoItem_forms import SeleccionarTipoItem
from app.wtforms.tipoItem_forms import ImportarTipoItem
from app.models.fase import Fase
from app.models.tipoItem import TipoItem
from app.models.atributo import Atributo
mod = Blueprint('tipoItems', __name__, url_prefix='/tipoItems')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_TIPOITEMS')
def administracion_tipoItem():
"""
Muestra en pantalla los tipos de items del proyecto seleccionado.
Si no recibe algun filtro como parametro, lista todos los tipo de items.
Si recibe algun filtro, muestra el tipo de item que cumple con el filtro indicado
"""
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos todas las fases del proyecto seleccionado
fases =Fase.query.filter(Fase.proyecto == proyecto_seleccionado)
# Hacemos una tupla con el nombre de la fase y su id
lista_fases=[]
for fase in fases:
lista_fases.append((fase.id, fase.nombre))
if(lista_fases != []):
# Obtenemos el formulario
form = TipoItemBuscar(request.form)
# Obtenemos el filtro
nombreFilter = form.nombre.data
if(nombreFilter == None):
nombreFilter = ''
# Recuperamor de la base de datos los items que coinciden con el filtro
tipoItems = TipoItem.query.filter(TipoItem.nombre.like( '%'+nombreFilter+'%' ), TipoItem.proyecto_id == proyecto_seleccionado.id )
tipoItems = tipoItems.all()
return render_template('tipoItem/administracion_tipoItem.html', form = form, tipoItems = tipoItems)
else:
flash('El proyecto no cuenta con fases donde se asignaran los tipos de items. Debe crear las fases para el proyecto seleccionado')
return redirect(url_for('acceso.home'))
@mod.route('/seleccionarfasecrear/', methods=['GET', 'POST'])
@permission('CREAR_TIPOITEM')
def seleccionar_fase_crear():
"""
Muestra en pantalla las fase que existen en el proyecto seleccionado.
"""
# Obtenemos el formulario para listar las fases
form = SeleccionarFase(request.form)
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos todas las fases del proyecto seleccionado
fases =Fase.query.filter(Fase.proyecto == proyecto_seleccionado)
# Hacemos una tupla con el nombre de la fase y su id
lista_fases=[]
for fase in fases:
lista_fases.append((fase.id, fase.nombre))
# Asignamos esa tupla de fases a la lista que va a ser visualizada
form.fases.choices = lista_fases
if form.validate_on_submit():
# Obtenemos la fase seleccionada por el usuario
session['fase_id'] = form.fases.data
return redirect(url_for('tipoItems.crear_tipoItem'))
return render_template('tipoItem/seleccionar_fase.html', form = form)
@mod.route('/crear/', methods=['GET', 'POST'])
def crear_tipoItem():
"""
Muestra en pantalla el formulario de creacion de tipo de items, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre no existan para la fase seleccionada y se hayan ingresado
los datos obligatorios. Luego almacena en la base de datos
"""
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#obtenemos la fase a donde importaremos el tipo de item seleccionado
fase = session['fase_id']
fase_seleccionada = Fase.query.filter_by(id=fase[0]).first()
#el proyecto seleccionado y la fase seleccionada deben estar con estado Pendiente
if(proyecto_seleccionado.estado == 'Pendiente'):
if(fase_seleccionada.estado == 'Pendiente'):
# Obtenemos el formulario
form = TipoItemEditable(request.form)
# Obtenemos todos los tipo de items de la fase seleccionada
tipoItems =TipoItem.query.filter(TipoItem.fase == fase_seleccionada)
# Obtenemos todos los atributos existentes en la base de datos
atributos =Atributo.query.all()
# Hacemos una tupla con el nombre y el id del atributo
lista_atributos=[]
for atributo in atributos:
lista_atributos.append((atributo.id, atributo.nombre))
# Asignamos la tupla de atributos a la lista que va a ser visualizada en el checkbox
form.atributos.choices = lista_atributos
# Se valida los datos ingresados en el formulario
if form.validate_on_submit():
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if tipoItems != None:
for tipoind in tipoItems:
if form.nombre.data == tipoind.nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre del tipo de item ya existe, elija otro", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('tipoItems.crear_tipoItem', fase = fase_seleccionada.id))
# Si el nombre aun no existe
else:
# Obtenemos los atributos seleccionados por el usuario
lista_atributos = []
for id_atributo in form.atributos.data:
atributo = Atributo.query.filter_by(id=id_atributo).first()
lista_atributos.append(atributo)
nombre = form.nombre.data
# Creamos el tipo de item
tipoItem_carga = TipoItem(nombre,lista_atributos,proyecto_seleccionado, fase_seleccionada)
db.session.add(tipoItem_carga)
db.session.commit()
flash('El Tipo de Item ha sido registrado con exito')
# Una vez creado el tipo de item, se redirecciona a la pagina de administracion
return redirect(url_for('tipoItems.administracion_tipoItem'))
return render_template('tipoItem/crear_tipoItem.html', form = form, fase_seleccionada=fase_seleccionada)
else:
flash('No se pueden crear tipos de items para la fase seleccionada, la fase no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
else:
flash('No se pueden crear tipos de items para el proyecto seleccionado, el proyecto no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
@mod.route('/modificar/<tipoItem>/', methods=['GET', 'POST'])
@permission('MODIFICAR_TIPOITEM')
def modificar_tipoItem(tipoItem):
"""
Muestra en pantalla el formulario de modificacion de tipo de items, valida los datos ingresados por
el usuario, hace las validaciones del nombre del nuevo tipo de item, que no existan para la fase seleccionada
y se hayan ingresado los datos obligatorios. Luego almacena en base de datos los cambios
:param tipoItem:
id del tipo de item que se desea modificar
"""
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#Obtenemos el tipo de item seleccionado
tipoItem_seleccionado = TipoItem.query.filter_by(id=tipoItem).first()
#obtenemos la fase del tipo de item seleccionado
fase_seleccionada = Fase.query.filter_by(id=tipoItem_seleccionado.fase.id).first()
#el proyecto seleccionado y la fase seleccionada deben estar con estado Pendiente
if(proyecto_seleccionado.estado == 'Pendiente'):
if(fase_seleccionada.estado == 'Pendiente'):
#obtenemos el formulario
form = TipoItemEditable(request.form)
#Obtenemos todos los tipo de items de la fase seleccionada
tipoItems =TipoItem.query.filter(TipoItem.fase == fase_seleccionada)
# Obtenemos todos los atributos existentes en la base de datos
atributos =Atributo.query.all()
# Hacemos una tupla con el nombre y el id del atributo
lista_atributos=[]
for atributo in atributos:
lista_atributos.append((atributo.id, atributo.nombre))
# Asignamos la tupla de atributos a la lista que va a ser visualizada en el checkbox
form.atributos.choices = lista_atributos
#Se valida los datos ingresados en el formulario
if form.validate_on_submit():
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual
# a uno existente en la fase seleccionada
if tipoItems != None:
for tipoind in tipoItems:
if tipoItem_seleccionado.id != tipoind.id:
if form.nombre.data == tipoind.nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la modificacion
if contN != 0:
flash("El nombre del tipo de item ya existe, debe ingresar otro", 'error-message')
# Redirigimos a la pagina de modificar
return redirect(url_for('tipoItems.modificar_tipoItem', tipoItem = tipoItem_seleccionado.id))
# Si el nombre aun no existe
else:
# Obtenemos los atributos seleccionados por el usuario
lista_atributos = []
for id_atributo in form.atributos.data:
atributo = Atributo.query.filter_by(id=id_atributo).first()
lista_atributos.append(atributo)
# Realizamos los cambios
tipoItem_seleccionado.setNombre(form.nombre.data)
tipoItem_seleccionado.setAtributo(lista_atributos)
#Almacenamos el tipo de item modificado en la base de datos
db.session.add(tipoItem_seleccionado)
db.session.commit()
# Retornamos a la pagina de administracion de tipo de items
flash('El tipo de item ha sido actualizado con exito')
return redirect(url_for('tipoItems.administracion_tipoItem'))
# Mostramos en el formulario los datos actuales del tipo de item seleccionado
form.nombre.data = tipoItem_seleccionado.nombre
form.fase.data = fase_seleccionada.nombre
# Obtenemos los atributos que el tipo de item seleccionado tiene actualmente sin modificacion
atributos_seleccionados = []
for atributo_sec in tipoItem_seleccionado.atributo:
atributos_seleccionados.append(atributo_sec.id)
# Mostramos seleccionados en el checkbox los atributos
form.atributos.data = atributos_seleccionados
return render_template('tipoItem/modificar_tipoItem.html', form = form, tipoItem_seleccionado=tipoItem_seleccionado)
else:
flash('No se pueden modificar tipos de items para la fase seleccionada, la fase no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
else:
flash('No se pueden modificar tipos de items para el proyecto seleccionado, el proyecto no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
@mod.route('/consultar/<tipoItem>/', methods=['GET', 'POST'])
@permission('VER_TIPOITEM')
def consultar_tipoItem(tipoItem):
"""
Muestra en pantalla el formulario de consulta de tipos de items, muestra todos los datos del
tipo de item seleccionado
:param tipoItem:
id del tipo de item que se desea consultar
"""
#Obtenemos el tipo de item seleccionado
tipoItem_seleccionado = TipoItem.query.filter_by(id=tipoItem).first()
# Obtenemos el formulario
form = TipoItemNoEditable(request.form)
# Hacemos una tupla con el nombre y el id de los atributos del tipo de item
atributos_seleccionados = []
for atributo in tipoItem_seleccionado.atributo:
atributos_seleccionados.append((atributo.id, atributo.nombre))
# Mostramos en el formulario los datos actuales del tipo de item seleccionado
form.nombre.data = tipoItem_seleccionado.nombre
form.fase.data = tipoItem_seleccionado.fase.nombre
form.atributos.choices = atributos_seleccionados
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de tipo de items
return redirect(url_for('tipoItems.administracion_tipoItem'))
return render_template('tipoItem/consultar_tipoItem.html', form = form,
tipoItem_seleccionado=tipoItem_seleccionado)
@mod.route('/eliminar/<tipoItem>/', methods=['GET', 'POST'])
@permission('ELIMINAR_TIPOITEM')
def eliminar_tipoItem(tipoItem):
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#Obtenemos el tipo de item seleccionado
tipoItem_seleccionado = TipoItem.query.filter_by(id=tipoItem).first()
#obtenemos la fase del tipo de item seleccionado
fase_seleccionada = Fase.query.filter_by(id=tipoItem_seleccionado.fase.id).first()
#el proyecto seleccionado y la fase seleccionada deben estar con estado Pendiente
if(proyecto_seleccionado.estado == 'Pendiente'):
if(fase_seleccionada.estado == 'Pendiente'):
# Borramos de la base de datos el tipo de item seleccionado
db.session.delete(tipoItem_seleccionado)
db.session.commit()
# Redirigimos a la pagina de administracion de tipo de items
flash('El tipo de item ha sido eliminada con exito')
return redirect(url_for('tipoItems.administracion_tipoItem'))
else:
flash('No se pueden eliminar tipos de items para la fase seleccionada, la fase no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
else:
flash('No se pueden eliminar tipos de items para el proyecto seleccionado, el proyecto no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
@mod.route('/seleccionarfase/', methods=['GET', 'POST'])
@permission('CREAR_TIPOITEM')
def seleccionar_fase():
"""
Muestra en pantalla las fase que existen en el proyecto seleccionado.
"""
# Obtenemos el formulario para listar las fases
form = SeleccionarFase(request.form)
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos todas las fases del proyecto seleccionado
fases =Fase.query.filter(Fase.proyecto == proyecto_seleccionado)
# Hacemos una tupla con el nombre de la fase y su id
lista_fases=[]
for fase in fases:
lista_fases.append((fase.id, fase.nombre))
# Asignamos esa tupla de fases a la lista que va a ser visualizada
form.fases.choices = lista_fases
if form.validate_on_submit():
# Obtenemos la fase seleccionada por el usuario
session['fase_id'] = form.fases.data
return redirect(url_for('tipoItems.seleccionar_tipoItem'))
return render_template('tipoItem/seleccionar_fase.html', form = form)
@mod.route('/seleccionar/', methods=['GET', 'POST'])
def seleccionar_tipoItem():
"""
Muestra en pantalla los tipos de items que existen en el proyecto seleccionado.
"""
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#obtenemos la fase a donde importaremos el tipo de item seleccionado
fase = session['fase_id']
fase_seleccionada = Fase.query.filter_by(id=fase[0]).first()
#el proyecto seleccionado y la fase seleccionada deben estar con estado Pendiente
if(proyecto_seleccionado.estado == 'Pendiente'):
if(fase_seleccionada.estado == 'Pendiente'):
# Obtenemos el formulario para listar los tipo de items
form = SeleccionarTipoItem(request.form)
# Obtenemos todos los tipo de items existentes en la base de datos
tipoItems =TipoItem.query.all()
# Hacemos una tupla con el id y nombre del tipo de item, el proyecto y la fase donde fue creado
lista_tipoItems=[]
for tipoItem in tipoItems:
lista_tipoItems.append((tipoItem.id, tipoItem.nombre +" "+ tipoItem.fase.nombre +" "+ tipoItem.proyecto.nombre))
# Asignamos esa tupla de tipo de items a la lista que va a ser visualizada
form.tipoItems.choices = lista_tipoItems
form.fase.data = fase_seleccionada.nombre
if form.validate_on_submit():
session['tipoitem_id'] = form.tipoItems.data
return redirect(url_for('tipoItems.importar_tipoItem'))
return render_template('tipoItem/seleccionar_tipoItem.html', form = form)
else:
flash('No se pueden importar tipos de items para la fase seleccionada, la fase no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
else:
flash('No se pueden importar tipos de items para el proyecto seleccionado, el proyecto no se encuentra con estado PENDIENTE')
return redirect(url_for('tipoItems.administracion_tipoItem'))
@mod.route('/importar/', methods=['GET', 'POST'])
def importar_tipoItem():
"""
Muestra en pantalla el formulario de importar tipos de items
"""
# Obtenemos el formulario
form = ImportarTipoItem(request.form)
# Obtenemos el tipo de item seleccionado
tipoitem = session['tipoitem_id']
tipoItem_seleccionado = TipoItem.query.filter_by(id=tipoitem[0]).first()
# Hacemos una tupla con el nombre y el id de los atributos del tipo de item
lista_atributos = []
atributos_seleccionados = []
for atributo in tipoItem_seleccionado.atributo:
atributos_seleccionados.append((atributo.id, atributo.nombre))
lista_atributos.append(atributo)
# Se aceptan los datos del tipo de item
if form.validate_on_submit():
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#obtenemos la fase a donde se importara el tipo de item seleccionado
fase = session['fase_id']
fase_seleccionada = Fase.query.filter_by(id=fase[0]).first()
#obtenemos todos los tipos de items de la fase seleccionada
tipoItems = TipoItem.query.filter(TipoItem.fase==fase_seleccionada)
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual
# a uno existente en la fase seleccionada
if tipoItems != None:
for tipoind in tipoItems:
if form.nombre.data == tipoind.nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre del tipo de item ya existe, debe ingresar otro", 'error-message')
# Redirigimos a la pagina de importacion
return redirect(url_for('tipoItems.importar_tipoItem', tipoItem = tipoItem_seleccionado.id))
# Si el nombre aun no existe
else:
nombre = form.nombre.data
# Creamos el tipo de item
tipoItem_carga = TipoItem(nombre, lista_atributos, proyecto_seleccionado, fase_seleccionada)
db.session.add(tipoItem_carga)
db.session.commit()
flash('El tipo de item ha sido registrado con exito')
# Una vez creado el nuevo tipo de item, se redirecciona a la pagina de administracion
return redirect(url_for('tipoItems.administracion_tipoItem'))
# Mostramos en el formulario los datos actuales del tipo de item seleccionado
form.nombre.data = tipoItem_seleccionado.nombre
form.atributos.choices = atributos_seleccionados
return render_template('tipoItem/importar_tipoItem.html', form = form)
| Python |
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from flask import session
from app import db
from app.security import g
from app.wtforms.fase_forms import FaseBuscar
from app.wtforms.fase_forms import FaseCrear
from app.wtforms.fase_forms import FaseModificar
from app.wtforms.fase_forms import FaseConsultar
from app.wtforms.fase_forms import FaseSeleccionar
from app.wtforms.fase_forms import FaseImportar
from app.models.item import Item
from app.models.fase import Fase
from app.models.tipoItem import TipoItem
from app.models.atributo import Atributo
from app.models.entidad import Entidad
from app.models.permiso import Permiso
from app.security import permission
mod = Blueprint('fases', __name__, url_prefix='/fases')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_FASES')
def administracion_fase():
"""
Muestra en pantalla las fases que existen en el proyecto seleccionado.
Si no recibe algun filtro como parametro, lista todas las fases.
Si recibe algun filtro, muestra las fases que cumplen con el filtro indicado
"""
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
if(proyecto_seleccionado != None):
# Obtenemos el formulario
form = FaseBuscar(request.form)
# Obtenemos el filtro
nombreFilter = form.nombre.data
estadoFilter = form.estado.data
if(nombreFilter == None):
nombreFilter = ''
if(estadoFilter == None):
estadoFilter = ''
# Recuperamor de la base de datos las fases que coinciden con el filtro
fases = Fase.query.filter(Fase.nombre.like( '%'+nombreFilter+'%' ), Fase.estado.like( '%'+estadoFilter+'%' ), Fase.proyecto_id == proyecto_seleccionado.id)
fases = fases.all()
return render_template('fase/administracion_fase.html', form = form, fases = fases)
else:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
@mod.route('/crear/', methods=['GET', 'POST'])
#@permission('CREAR_FASE')
def crear_fase():
"""
Muestra en pantalla el formulario de creacion de fases, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre y la posicion de la nueva fase no existan en el
sistema para el proyecto seleccionado y se hayan ingresado los datos obligatorios.
Luego almacena en base de datos.
"""
if(verificar_autorizacion(g.user, g.proyecto, 'MODIFICAR')):
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#si el proyecto seleccionado no se encuentra con estado pendiente, no pueden crear fases
if(proyecto_seleccionado.estado != 'Pendiente'):
flash('No se pueden crear fases para el proyecto seleccionado. El proyecto no se encuentra con estado PENDIENTE')
return redirect(url_for('fases.administracion_fase'))
else:
# Obtenemos el formulario
form = FaseCrear(request.form)
#obtenemos todas las fases del proyecto seleccionado
fases=[]
fases = Fase.query.filter(Fase.proyecto == proyecto_seleccionado)
fases = fases.all()
# Se valida los datos ingresados en el formulario
if form.validate_on_submit():
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if fases != []:
for faseind in fases:
if form.nombre.data == faseind.nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre de la fase ya existe dentro del proyecto seleccionado, elija otro", 'error-message')
# Redirigimos a la pagina de administracion
return redirect(url_for('fases.crear_fase'))
# Si el nombre aun no existe
else:
nombre = form.nombre.data
estado = 'Pendiente'
if form.fechainicio.data != None and form.fechainicio.data != '':
if form.fechafin.data != None and form.fechafin.data != '':
fechainicio = form.fechainicio.data
fechafin = form.fechafin.data
#verificamos la fecha
if fechainicio > fechafin:
flash("La fecha inicial debe ser menor a la fecha final", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('fases.crear_fase'))
else:
fechafin = None
else:
if form.fechafin.data != None and form.fechafin.data != '':
flash("No se puede cargar una fecha final sin fecha inicial", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('fases.crear_fase'))
else:
fechainicio = None
fechafin = None
ultimo = 0
for fase in fases:
if(fase.posicion > ultimo):
ultimo = fase.posicion
posicion = ultimo + 1
nombreProy = proyecto_seleccionado.nombre
entidad = Entidad(nombre+" "+nombreProy)
# Creamos la fase
fase_carga = Fase(nombre, posicion, estado, fechainicio, fechafin, proyecto_seleccionado, entidad)
db.session.add(fase_carga)
db.session.commit()
flash('La fase ha sido registrada con exito')
# Una vez creado la nueva fase, se redirecciona a la pagina de administracion
return redirect(url_for('fases.administracion_fase'))
return render_template('fase/crear_fase.html', form = form)
else:
flash('NO TIENE PERMISOS PARA CREAR FASES')
return redirect(url_for('fases.administracion_fase'))
@mod.route('/modificar/<fase>/', methods=['GET', 'POST'])
#@permission('MODIFICAR_FASE')
def modificar_fase(fase):
"""
Muestra en pantalla el formulario de modificacion de fases, valida los datos ingresados por
el usuario, hace las validaciones del nombre y la posicion de la nueva fase, que no existan en el
sistema para el proyecto seleccionado y se hayan ingresado los datos obligatorios.
Luego almacena en base de datos los cambios.
:param fase:
id de la fase que se desea modificar
"""
#Obtenemos la fase seleccionada
fase_seleccionada = Fase.query.filter_by(id=fase).first()
anterior = fase_seleccionada.nombre
if(verificar_autorizacion_fase(g.user, fase_seleccionada, 'MODIFICAR')):
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#si el proyecto seleccionado no se encuentra con estado pendiente, no se puede modificar fases
if(proyecto_seleccionado.estado == 'Finalizado' and proyecto_seleccionado.estado == 'Cancelado'):
flash('No se pueden modificar la fase para el proyecto seleccionado. El proyecto no se encuentra con estado Finalizado o Cancelado')
return redirect(url_for('fases.administracion_fase'))
else:
form = FaseModificar(request.form)
#obtenemos todas las fases del proyecto seleccionado
fases = []
fases = Fase.query.filter(Fase.proyecto == proyecto_seleccionado)
fases = fases.all()
# verificamos que la/las fase/s anterior este/n finalizada/s
contNF=0
for fase in fases:
if fase.id != fase_seleccionada.id:
if fase.posicion < fase_seleccionada.posicion:
if fase.estado != 'Finalizada':
contNF=contNF+1
if fase_seleccionada.estado == 'Pendiente':
choicesEstados = (('1','Pendiente'), ('2', 'Eliminada'))
form.estado.choices = choicesEstados
estFase = 0
elif fase_seleccionada.estado == 'Finalizada':
choicesEstados = (('1','Finalizada'),('2','Finalizada'))
form.estado.choices = choicesEstados
estFase = 0
elif fase_seleccionada.estado == 'Eliminada':
choicesEstados = (('1','Eliminada'), ('2', 'Eliminada'))
form.estado.choices = choicesEstados
estFase = 1
else:
if fase_seleccionada.estado == 'Activa' and contNF == 0:
choicesEstados = (('1','Activa'), ('2','Finalizada'))
form.estado.choices = choicesEstados
estFase = 0
else:
choicesEstados = (('1','Activa'), ('2','Activa'))
form.estado.choices = choicesEstados
estFase = 0
# Se valida los datos ingresados en el formulario
if form.validate_on_submit():
posicionEstado = int(form.estado.data)
fase_seleccionada.estado = choicesEstados[posicionEstado-1][1]
items = []
items =Item.query.filter(Item.fase == fase_seleccionada)
items = items.all()
if fase_seleccionada.estado == 'Finalizada':
if items ==[]:
flash("La Fase no puede ser finalizada, no existen items dentro de la misma", 'error-message')
# Redirigimos a la pagina de modificacion
return redirect(url_for('fases.modificar_fase', fase = fase_seleccionada.id))
else:
# obtenemos los items de la fase a importar
contI=0
for item in items:
if item.estado != 'Bloqueado':
contI= contI + 1
# verificamos que todos los items de la fase seleccionada esten en estado bloqueado
if contI != 0:
flash("La Fase no puede ser finalizada, existen items que no se encuentran en estado bloqueado", 'error-message')
# Redirigimos a la pagina de modificacion
return redirect(url_for('fases.modificar_fase', fase = fase_seleccionada.id))
# verificamos que la/las fase/s anterior este/n finalizada/s
contNF=0
for fase in fases:
if fase.id != fase_seleccionada.id:
if fase.posicion < fase_seleccionada.posicion:
if fase.estado != 'Finalizada':
contNF=contNF+1
if contI != 0:
flash("La Fase no puede ser finalizada, existen fases de posiciones anteriores no finalizadas", 'error-message')
# Redirigimos a la pagina de modificacion
return redirect(url_for('fases.modificar_fase', fase = fase_seleccionada.id))
if (anterior != form.nombre.data and estFase == 1):
flash("El nombre de la fase no puede ser modificada, la fase se encuentra con estado Eliminada", 'error-message')
# Redirigimos a la pagina de modificacion
return redirect(url_for('fases.modificar_fase', fase = fase_seleccionada.id))
else:
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if fases != []:
for faseind in fases:
if fase_seleccionada.id != faseind.id:
if form.nombre.data == faseind.nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre de la fase ya existe dentro del proyecto seleccionado, elija otro", 'error-message')
# Redirigimos a la pagina de modificacion
return redirect(url_for('fases.modificar_fase', fase = fase_seleccionada.id))
if form.fechainicio.data != None and form.fechainicio.data != '':
if form.fechafin.data != None and form.fechafin.data != '':
fechainicio = form.fechainicio.data
fechafin = form.fechafin.data
#verificamos la fecha
if fechainicio > fechafin:
flash("La fecha inicial debe ser menor a la fecha final", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('fases.modificar_fase', fase = fase_seleccionada.id))
else:
if form.fechafin.data != None and form.fechafin.data != '':
flash("No se puede cargar una fecha final sin fecha inicial", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('fases.modificar_fase', fase = fase_seleccionada.id))
# Realizamos los cambios en los atributos de la fase
fase_seleccionada.setNombre(form.nombre.data)
fase_seleccionada.setEstado(fase_seleccionada.estado)
#fase_seleccionada.setPosicion(int(form.posicion.data))
if form.fechainicio.data != None and form.fechainicio.data != '':
fase_seleccionada.fechainicio = form.fechainicio.data
else:
fase_seleccionada.fechainicio = None
if form.fechafin.data != None and form.fechafin.data != '':
fase_seleccionada.fechafin = form.fechafin.data
else:
fase_seleccionada.fechafin = None
# Almacenamos la fase modificada en la base de datos
db.session.add(fase_seleccionada)
db.session.commit()
# Retornamos a la pagina de administracion de fases
flash('La fase ha sido actualizada con exito')
return redirect(url_for('fases.administracion_fase'))
# Mostramos en el formulario los datos actuales de la fase seleccionada
form.nombre.data = fase_seleccionada.nombre
form.fechainicio.data = fase_seleccionada.fechainicio
form.fechafin.data = fase_seleccionada.fechafin
return render_template('fase/modificar_fase.html', form = form, fase_seleccionada=fase_seleccionada)
else:
flash('NO TIENE PERMISOS PARA MODIFICAR LA FASE SELECCIONADA')
return redirect(url_for('fases.administracion_fase'))
@mod.route('/consultar/<fase>/', methods=['GET', 'POST'])
#@permission('VER_FASE')
def consultar_fase(fase):
"""
Muestra en pantalla el formulario de consulta de fases, muestra todos los datos de la
fase seleccionada
:param fase:
id de la fase que se desea consultar
"""
# Obtenemos la fase seleccionada
fase_seleccionada = Fase.query.filter_by(id=fase).first()
if(verificar_autorizacion_fase(g.user, fase_seleccionada, 'VER')):
#Obtenemos el formulario
form = FaseConsultar(request.form)
# Obtenemos los tipos de items si existen de la fase seleccionada
tipoItems =TipoItem.query.filter(TipoItem.fase == fase_seleccionada)
# Hacemos una tupla con el nombre del tipoItem y su id
lista_tipoItems=[]
for tipoItem in tipoItems:
lista_tipoItems.append((tipoItem.id, tipoItem.nombre))
# Obtenemos los items si existen de la fase seleccionada
items =Item.query.filter(Item.fase == fase_seleccionada)
# Hacemos una tupla con el nombre del tipoItem y su id
lista_items=[]
for item in items:
lista_items.append((item.id, item.nombre))
# Mostramos en el formulario los datos actuales de la fase seleccionada
form.nombre.data = fase_seleccionada.nombre
form.estado.data = fase_seleccionada.estado
form.posicion.data = str(fase_seleccionada.posicion)
form.fechainicio.data = fase_seleccionada.fechainicio
form.fechafin.data = fase_seleccionada.fechafin
form.tipoItems.choices = lista_tipoItems
form.items.choices = lista_items
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de fases
return redirect(url_for('fases.administracion_fase'))
return render_template('fase/consultar_fase.html', form = form,
fase_seleccionada=fase_seleccionada)
else:
flash('NO TIENE PERMISOS PARA VISUALIZAR LA FASE SELECCIONADA')
return redirect(url_for('fases.administracion_fase'))
@mod.route('/eliminar/<fase>/', methods=['GET', 'POST'])
#@permission('ELIMINAR_FASE')
def eliminar_fase(fase):
# Obtenemos la fase seleccionada
fase_seleccionada = Fase.query.filter_by(id=fase).first()
if(verificar_autorizacion_fase(g.user, fase_seleccionada, 'ELIMINAR')):
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#si el proyecto seleccionado no se encuentra con estado pendiente, no puede eliminar fases
if(proyecto_seleccionado.estado != 'Pendiente'):
flash('No se pueden eliminar fases para el proyecto seleccionado. El proyecto no se encuentra con estado PENDIENTE')
return redirect(url_for('fases.administracion_fase'))
else:
#obtenemos la posicion de la fase a eliminar
posicion = fase_seleccionada.posicion
#cambiamos el estado de la fase a elminada
if(fase_seleccionada.estado != 'Eliminada'):
fase_seleccionada.estado = 'Eliminada'
#actualizamos los datos de la fase eliminada
fase_seleccionada.posicion=0
db.session.add(fase_seleccionada)
db.session.commit()
#obtenemos todas las fases del proyecto
fases = Fase.query.filter(Fase.proyecto == proyecto_seleccionado)
#cambiamos las posiciones de las fases
for fase in fases:
if fase.id != fase_seleccionada.id:
if posicion < fase.posicion:
fase_sec = Fase.query.filter_by(id=fase.id).first()
fase_sec.posicion = fase.posicion - 1
db.session.add(fase_sec)
db.session.commit()
# Redirigimos a la pagina de administracion de fases
flash('La fase ha sido eliminada con exito')
return redirect(url_for('fases.administracion_fase'))
else:
flash('NO TIENE PERMISOS PARA ELIMINAR LA FASE SELECCIONADA')
return redirect(url_for('fases.administracion_fase'))
@mod.route('/seleccionar/', methods=['GET', 'POST'])
def seleccionar_fase():
if(verificar_autorizacion(g.user, g.proyecto, 'MODIFICAR')):
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
#si el proyecto seleccionado no se encuentra con estado pendiente, no se puede importar fases
if(proyecto_seleccionado.estado != 'Pendiente'):
flash('No se pueden importar fases para el proyecto seleccionado. El proyecto no se encuentra con estado PENDIENTE')
return redirect(url_for('fases.administracion_fase'))
else:
# Obtenemos el formulario para importar fases
form = FaseSeleccionar(request.form)
# Obtenemos todos las fases existentes en la base de datos
fases =Fase.query.all()
# Hacemos una tupla con el nombre de la fase y su id
lista_fases=[]
for fase in fases:
lista_fases.append((fase.id, fase.nombre +" "+ fase.proyecto.nombre))
# Asignamos esa tupla de fases a la lista que va a ser visualizada
form.fases.choices = lista_fases
if form.validate_on_submit():
# Obtenemos la fase seleccionada por el usuario
session['fase_id'] = form.fases.data
return redirect(url_for('fases.importar_fase'))
return render_template('fase/seleccionar_fase.html', form = form)
else:
flash('NO TIENE PERMISOS PARA IMPORTAR FASES')
return redirect(url_for('fases.administracion_fase'))
@mod.route('/importar/', methods=['GET', 'POST'])
def importar_fase():
"""
Muestra en pantalla el formulario de importar fases
"""
if(verificar_autorizacion(g.user, g.proyecto, 'MODIFICAR')):
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos el formulario
form = FaseImportar(request.form)
# Obtenemos la fase seleccionada
fase = session['fase_id']
fase_seleccionada = Fase.query.filter_by(id=fase[0]).first()
#obtenemos todas las fases del proyecto seleccionado
fases=[]
fases = Fase.query.filter(Fase.proyecto == proyecto_seleccionado)
fases = fases.all()
# obtenemos los tipo de items de la fase a importar
tipoItems =TipoItem.query.filter(TipoItem.fase == fase_seleccionada)
lista_tipoItems=[]
for tipoItem in tipoItems:
lista_tipoItems.append((tipoItem.id, tipoItem.nombre))
# obtenemos los items de la fase a importar
items =Item.query.filter(Item.fase == fase_seleccionada)
items= items.all()
lista_items=[]
for item in items:
lista_items.append((item.id, item.nombre))
# Se aceptan los datos de la fase
if form.validate_on_submit():
contN = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if fases != []:
for faseind in fases:
if form.nombre.data == faseind.nombre:
contN = contN + 1
# Si ya existe el nombre, no permitimos la creacion
if contN != 0:
flash("El nombre de la fase ya existe dentro del proyecto seleccionado, elija otro", 'error-message')
# Redirigimos a la pagina de administracion
return redirect(url_for('fases.importar_fase', fase = fase_seleccionada.id))
# Si el nombre aun no existe
else:
nombre = form.nombre.data
estado = 'Pendiente'
if form.fechainicio.data != None and form.fechainicio.data != '':
if form.fechafin.data != None and form.fechafin.data != '':
fechainicio = form.fechainicio.data
fechafin = form.fechafin.data
#verificamos la fecha
if fechainicio > fechafin:
flash("La fecha inicial debe ser menor a la fecha final", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('fases.crear_fase'))
else:
fechafin = None
else:
if form.fechafin.data != None and form.fechafin.data != '':
flash("No se puede cargar una fecha final sin fecha inicial", 'error-message')
# Redirigimos a la pagina de creacion
return redirect(url_for('fases.crear_fase'))
else:
fechainicio = None
fechafin = None
ultimo = 0
for fase in fases:
if(fase.posicion > ultimo):
ultimo = fase.posicion
posicion = ultimo + 1
nombreProy = proyecto_seleccionado.nombre
entidad = Entidad(nombre+" "+nombreProy)
# Creamos la fase
fase_carga = Fase(nombre, posicion, estado, fechainicio, fechafin, proyecto_seleccionado, entidad)
db.session.add(fase_carga)
db.session.commit()
#creamos el tipo de item para la fase importada si existe
lista_atributos=[]
for tipo in tipoItems:
if tipo != None:
# Obtenemos los atributos del tipo de item
for id_atributo in tipo.atributo:
atributo = Atributo.query.filter_by(id=id_atributo.id).first()
lista_atributos.append(atributo)
tipoItem_carga = TipoItem(tipo.nombre,lista_atributos,proyecto_seleccionado, fase_carga)
db.session.add(tipoItem_carga)
db.session.commit()
flash('La fase ha sido registrada con exito')
# Una vez creado la nueva fase, se redirecciona a la pagina de administracion
return redirect(url_for('fases.administracion_fase'))
# Mostramos en el formulario los datos actuales de la fase a importar
form.nombre.data = fase_seleccionada.nombre
form.tipoItems.choices = lista_tipoItems
form.items.choices = lista_items
return render_template('fase/importar_fase.html', form = form)
else:
flash('NO TIENE PERMISOS PARA IMPORTAR FASES')
return redirect(url_for('fases.administracion_fase'))
def verificar_autorizacion(usuario = None, proyecto = None, permisoRequerido = None):
autorizado = False
permiso = db.session.query(Permiso).filter_by(nombre = permisoRequerido, entidad_id = proyecto.entidad_id).first()
if(permiso != None):
for rol in usuario.roles:
if permiso in rol.permiso:
autorizado = True
return autorizado
def verificar_autorizacion_fase(usuario = None, fase = None, permisoRequerido = None):
autorizado = False
permiso = db.session.query(Permiso).filter_by(nombre = permisoRequerido, entidad_id = fase.entidad_id).first()
if(permiso != None):
for rol in usuario.roles:
if permiso in rol.permiso:
autorizado = True
return autorizado
| Python |
'''
Created on 03/04/2013
@author: belentwi
'''
from flask import Blueprint
from flask import request
from flask import render_template
from app.wtforms.entidad_forms import EntidadBuscar
from app.models.entidad import Entidad
mod = Blueprint('entidades', __name__, url_prefix='/entidad')
@mod.route('/administracion/', methods=['GET', 'POST'])
def administracion_entidad():
"""
Muestra en pantalla las entidades que existen en la base de datos.
@param filtros: los filtros segun los cuales se mostraran las entidades
@return: listado de las entidades segun los filtros indicados
"""
form = EntidadBuscar(request.form)
nombreFilter = form.nombre.data
if(nombreFilter == None):
nombreFilter = ''
entidades = Entidad.query.filter(Entidad.nombre.like( '%'+nombreFilter+'%' ) )
return render_template('entidad/administracion_entidad.html', form = form, entidades = entidades)
| Python |
'''
Created on 09/05/2013
@author: mirta
'''
from datetime import date
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from app import db
from app.security import g
from app.security import permission
from app.models.linea_base import LineaBase
from app.models.historial_lb import HistorialLineaBase
from app.models.fase import Fase
from app.models.item import Item
from app.models.permiso import Permiso
from app.wtforms.linea_base_forms import LbBuscar
from app.wtforms.linea_base_forms import LbFases
from app.wtforms.linea_base_forms import LbEditable
mod = Blueprint('lineas_base', __name__, url_prefix='/lineabase')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_LINEAS_BASE')
def administracion_lb():
"""
Muestra en pantalla las lineas base que existen en la base de datos.
Si no recibe algun filtro como parametro, lista todas las lineas base.
Si recibe algun filtro, muestra las lineas base que cumplen con el filtro indicado
"""
# Si el usuario no tiene asociado ningun proyecto no se le permite ver la pagina
if g.proyecto==None:
flash('No tiene permiso para ver esta pagina.')
return redirect(url_for('acceso.home'))
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos el formulario
form = LbBuscar(request.form)
# Obtenemos los filtros
nombreFilter = form.nombre.data
estadoFilter = form.estado.data
faseFilter = form.fase.data
if(nombreFilter == None):
nombreFilter = ''
if(estadoFilter == None):
estadoFilter = ''
if(faseFilter == None):
faseFilter = ''
# Recuperamos de la base de datos las lineas base que coinciden con los filtros
lbs = LineaBase.query.filter(LineaBase.nombre.like( '%'+nombreFilter+'%' ), LineaBase.estado.like( '%'+estadoFilter+'%' ) ).join(Fase).filter(Fase.nombre.like('%' + faseFilter + '%'), Fase.proyecto_id == proyecto_seleccionado.id)
lbs = lbs.all()
return render_template('linea_base/administracion_lb.html', form = form, lbs = lbs)
@mod.route('/seleccionar/', methods=['GET', 'POST'])
def seleccionar_fase():
"""
Lista las fases con estado activa en las que se pueden crear lineas base
"""
#Obtenemos el proyecto seleccionado
proyecto_seleccionado = g.proyecto
# Obtenemos el formulario para listar las fases con estado Activa del proyecto
form = LbFases(request.form)
# Buscamos las fases del proyecto seleccionado que tengan estado Activa
fases = Fase.query.filter_by(estado='Activa', proyecto_id=proyecto_seleccionado.id)
fases = fases.all()
# Si no existen fases con estado Activa entonces mandamos al usuario a la pagina de
# administracion
if fases == None:
flash('No existen fases con estado Activa en el proyecto', 'error-message')
return redirect(url_for('lineas_base.administracion_lb', fase=fase_seleccionada))
# Creamos una lista de esas fases para mostrarlos en la vista
lista_fases = []
for fase in fases:
# Verificamos si el usuario tiene permisos para modificar esas fases
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
# Si tiene permisos lo agregamos a la lista de fases
lista_fases.append((fase.id, fase.nombre))
# Mostramos estas fases en la interfaz
form.fases.choices = lista_fases
# Validamos los datos ingresados en el el formulario por el usuario
if form.validate_on_submit():
# Obtenemos la fase seleccionada y lo pasamos a la pagina de creacion de lineas base
fase_seleccionada = form.fases.data[0]
return redirect(url_for('lineas_base.crear_lb', fase=fase_seleccionada))
return render_template('linea_base/seleccionar_fase.html', form = form)
@mod.route('/crear/<fase>/', methods=['GET', 'POST'])
def crear_lb(fase):
"""
Permite la creacion de lineas base, muestra todos los items que pueden ser incluidos en la
nueva linea base
@param fase: id de la fase en la cual se creara la nueva linea base
"""
# Obtenemos la fase
fase_seleccionada = Fase.query.filter_by(id=fase).first()
# Verificamos si el usuario tiene permisos para modificar la fase
if(verificar_autorizacion_fase(usuario=g.user, fase=fase_seleccionada, permisoRequerido='MODIFICAR')):
# Obtenemos el usuario que se ha logueado
usuario_logueado = g.user
# Obtenemos todos los items de la fase que tengan estado aprobado y no esten en ninguna linea base
items = Item.query.filter_by(fase_id=fase, estado='Aprobado', linea_base_id=None)
items = items.all()
# Si no existen mas items disponibles para las lineas base, se informa al usuario
if items == []:
flash('Todos los items Aprobados de la fase se encuentran en un linea base', 'error-message')
return redirect(url_for('lineas_base.seleccionar_fase'))
else:
# Si existen items para una nueva linea base
# Obtenemos el formulario para la creacion de la linea base
form = LbEditable(request.form)
# Realizamos una lista para mostrar los items en la interfaz
lista_items = []
for item in items:
lista_items.append((item.id, item.nombre))
# Mostramos la lista de items a los usuarios
form.items.choices = lista_items
# Validamos los datos ingresados en el formulario por los usuarios
if form.validate_on_submit():
# Obtenemos todas las lineas base de la fase
lbs = LineaBase.query.filter_by(fase_id=fase)
lbs = lbs.all()
cont = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if lbs != None:
for lb in lbs:
if form.nombre.data == lb.nombre:
cont = cont + 1
# Si ya existe el nombre, no permitimos la creacion
if cont != 0:
flash("El nombre de la linea base ya existe en la fase, elija otro", 'error-message')
return redirect(url_for('lineas_base.crear_lb', fase=fase))
else:
# Si el nombre nuevo es unico en el sistema
# Generamos una linea base indicando nombre, estado y fase
lb_nueva = LineaBase(nombre=form.nombre.data, estado='Abierta')
lb_nueva.fecha_creacion = date.today()
lb_nueva.fase = fase_seleccionada
# Guardamos la nueva linea base en la base de datos
db.session.add(lb_nueva)
db.session.commit()
# Guardamos el en historial la operacion realizada
historial_lb = HistorialLineaBase(id_lb=lb_nueva.id, operacion='Creacion',
usuario=usuario_logueado.nombre, fecha=date.today())
db.session.add(historial_lb)
db.session.commit()
# Obtenemos los items seleccionados por el usuario
items_seleccionados = form.items.data
# A cada item de la lista le agregamos su linea base correspondiente y cambiamos su estado
for item_id in items_seleccionados:
item = Item.query.filter_by(id=item_id).first()
item.linea_base = lb_nueva
item.estado = 'Bloqueado'
# Guardamos los cambios hechos al item en base de datos
db.session.add(item)
db.session.commit()
# Desplegamos el mensaje de exito de la operacion
flash('La linea base ha sido registrada con exito')
return redirect(url_for('lineas_base.administracion_lb'))
return render_template('linea_base/crear_lb.html', form = form, fase=fase)
else:
# Si el usuario no tiene permiso para modificar la fase entonces lo redirigimos a la
# pagina de administracion de lineas bases y desplegamos un mensaje
flash('NO TIENE PERMISOS PARA MODIFICAR LA FASE SELECCIONADA')
return redirect(url_for('lineas_base.administracion_lb'))
@mod.route('/informe/<lb>/', methods=['GET', 'POST'])
def informe_lb(lb):
"""
Realiza un informe acerca del estado de la linea base seleccionada por el usuario, dando datos
sobre las operaciones que se realizaron sobre la linea base y algunos datos de los items
componentes de dicha linea base
@param lb: id de la linea base seleccionada por el usuario
"""
# Obtenemos la linea base seleccionada
lb_seleccionada = LineaBase.query.filter_by(id=lb).first()
# Obtenemos la fase a la cual pertenece la linea base
fase = Fase.query.filter_by(id=lb_seleccionada.fase_id).first()
# Verificamos si el usuario tiene permisos para ver datos de la fase
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='VER')):
# Obtenemos los datos historicos de la linea base seleccionada
lb_historial = HistorialLineaBase.query.filter_by(id_lb=lb)
lb_historial = lb_historial.all()
# Obtenemos los items que forman parte de la linea base seleccionada
items = Item.query.filter_by(linea_base_id=lb)
items = items.all()
# Mostramos los datos de la linea base e items a los usuarios
return render_template('linea_base/informe_lb.html', lb=lb,
historiales=lb_historial, items=items)
else:
# Si no se tiene permiso para ver los datos de la fase (informe de la linea base)
# Redirigimos al usuario a la pagina de administracion de linea base y desplegamos un mensaje
# informativo
flash('NO TIENE PERMISOS PARA MODIFICAR LA FASE SELECCIONADA')
return redirect(url_for('lineas_base.administracion_lb'))
@mod.route('/eliminar/<lb>/', methods=['GET', 'POST'])
def eliminar_lb(lb):
"""
Permite la eliminacion de lineas base que existen en el sistema
@param lb: id de la linea base que se va a eliminar
"""
# Obtenemos el usuario que se ha logueado
usuario_logueado = g.user
# Obtenemos la linea base seleccionada por el usuario
lb_seleccionada = LineaBase.query.filter_by(id=lb).first()
#flash(lb_seleccionada)
#return redirect(url_for('lineas_base.administracion_lb'))
# Obtenemos la fase a la cual pertenece la linea base seleccionada
fase = Fase.query.filter_by(id=lb_seleccionada.fase_id).first()
# Verificamos si el usuario tiene permisos para modificar lla fase
if(verificar_autorizacion_fase(usuario=g.user, fase=fase, permisoRequerido='MODIFICAR')):
# Si la fase de la linea base tiene estado Activa se podra realizar la eliminacion
if lb_seleccionada.fase.estado == 'Activa':
# Si la linea base seleccionada esta con estado Eliminada
if lb_seleccionada.estado == 'Eliminada':
# Entonces se redirige al usuario a la pagina de administracion de linea base
# y se despliega un mensaje indicando el hecho
flash('La linea base ya se encuentra con estado Eliminada')
return redirect(url_for('lineas_base.administracion_lb'))
# Establecemos el estado de la linea base como eliminada
lb_seleccionada.estado = 'Eliminada'
db.session.add(lb_seleccionada)
db.session.commit()
# Guardamos el en historial la operacion realizada
historial_lb = HistorialLineaBase(id_lb=lb_seleccionada.id, operacion='Eliminacion',
usuario=usuario_logueado.nombre, fecha=date.today())
db.session.add(historial_lb)
db.session.commit()
# Obtenemos todos los items que se encuentran en la linea base eliminada
items = Item.query.filter_by(linea_base_id=lb)
items = items.all()
# Por cada item
for item in items:
# Establecemos su estado a Aprobado
item.estado = 'Aprobado'
item.linea_base_id = None
item.linea_base = None
db.session.add(item)
db.session.commit()
# Obtenemos todos los items cuyos padres se encuentren en la linea base eliminada
items_hijos = Item.query.filter_by(padre_id=item.id)
items_hijos = items_hijos.all()
# Si existen hijos
if items_hijos!=None:
# Por cada uno de esos hijos
for hijo in items_hijos:
# Cambiamos su estado a revision
hijo.estado = 'Revision'
db.session.add(hijo)
db.session.commit()
# Si ese hijo esta en una linea base y ella no tienen estado de Revision
if hijo.linea_base.id!=None and hijo.linea_base.estado!='Revision':
# Pasamos la linea base para que sea procesada
cambiar_estado(hijo.linea_base.id)
# Obtenemos todos los items cuyos antecesores se encuentren en la linea base eliminada
items_sucesores = Item.query.filter_by(antecesor_id=item.id)
items_sucesores = items_sucesores.all()
# Si existen sucesores
if items_sucesores!=None:
# Por cada uno de esos sucesores
for sucesor in items_sucesores:
# Cambiamos su estado a revision
sucesor.estado = 'Revision'
db.session.add(sucesor)
db.session.commit()
# Si ese sucesor esta en una linea base y ella no esta en estado de revision
if sucesor.linea_base.id!=None and sucesor.linea_base.estado!='Revision':
# Pasamos esa linea base para que sea procesada
cambiar_estado(sucesor.linea_base.id)
# Indicamos que la eliminacion fue realizada correctamente y redirigimos al usuario
# a la pagina de administracion de lineas base
flash('La linea base ha sido eliminada con exito')
return redirect(url_for('lineas_base.administracion_lb'))
else:
# Si la fase de la linea base seleccionada no esta con estado Activo
# desplegamos un mensaje informando al usuario que no se puede realizar la eliminacion
# debido a esa situacion y lo redirigimos a la pagina de administacion de lineas base
flash('La fase de la linea base seleccionada no esta Activa')
return redirect(url_for('lineas_base.administracion_lb'))
else:
# Si no se tiene permiso para modificar la fase de la linea base, desplegamos un mensaje
# indicando al usuario y lo redirigimos a la pagina de administracion de lineas base
flash('NO TIENE PERMISOS PARA MODIFICAR LA FASE SELECCIONADA')
return redirect(url_for('lineas_base.administracion_lb'))
def cambiar_estado(lb):
"""
Cambia el estado de las lineas base e items de la misma relacionados a la linea base eliminada
al estado de Revision
@param lb: id de la linea base que se va a poner en revision
"""
# Obtenemos el usuario que se ha logueado
usuario_logueado = g.user
# Obtenemos la linea base que sera procesada
linea_base = LineaBase.query.filter_by(id=lb).first()
# Cambiamos su estado a revision
linea_base.estado = 'Revision'
db.session.add(linea_base)
db.session.commit()
# Guardamos el en historial la operacion realizada
historial_lb = HistorialLineaBase(id_lb=linea_base.id, operacion='Pasa a revision por eliminacion de la linea base: '+linea_base.nombre,
usuario=usuario_logueado.nombre, fecha=date.today())
db.session.add(historial_lb)
db.session.commit()
# Obtenemos los items que se encuentran en esa linea base
items = Item.query.filter_by(linea_base_id=lb)
items = items.all()
# Si existen items
if items!=None:
# Por cada uno de esos items
for item in items:
# Cambiamos su estado a revision
item.estado = 'Revision'
db.session.add(item)
db.session.commit()
# Obtenemos todo los items que tengan padres en la linea base
items_hijos = Item.query.filter_by(padre_id=item.id)
items_hijos = items_hijos.all()
# Si existen hijos
if items_hijos!=None:
# Por cada uno de esos hijos
for hijo in items_hijos:
# Cambiamos su estado a revision
hijo.estado = 'Revision'
db.session.add(hijo)
db.session.commit()
# Si un hijo esta en una linea base y esta no tiene estado de revision
if hijo.linea_base.id!=None and hijo.linea_base.estado!='Revision':
# Pasamos la linea base para que la procesen
cambiar_estado(hijo.linea_base.id)
# Obtenemos todos los items que tengan antecesores en la linea base
items_sucesores = Item.query.filter_by(antecesor_id=item.id)
items_sucesores = items_sucesores.all()
# Si existen sucesores
if items_sucesores!=None:
# Por cada uno de esos sucesores
for sucesor in items_sucesores:
# Cambiamos su estado a revision
sucesor.estado = 'Revision'
db.session.add(sucesor)
db.session.commit()
# Si un sucesor esta en una linea base y esta no tiene estado de revision
if sucesor.linea_base.id!=None and sucesor.linea_base.estado!='Revision':
# Pasamos la linea base para que la procesen
cambiar_estado(sucesor.linea_base.id)
def verificar_autorizacion_fase(usuario = None, fase = None, permisoRequerido = None):
"""
Verifica que el usuario posea pemisos para realizar una operacion determinada sobre una
fase
@param usuario: usuario que se logueo
@param fase: fase sobre la cual se desea realizar una operacion
@param permisoRequerido: permiso que debe poseer el usuario sobre la fase para que pueda
realizar la acccion
"""
# Establecemos por defecto que el usuario logueado no esta autorizado para realizar la operacion
autorizado = False
#============================================================================
# rolAdministrador = db.session.query(Rol).filter_by(nombre = 'Administrador de Sistema').first()
#
# if rolAdministrador in usuario.roles:
# autorizado = True
#
# else:
#============================================================================
# Obtenemos el permisos con los elementos requeridos
permiso = db.session.query(Permiso).filter_by(nombre = permisoRequerido, entidad_id = fase.entidad_id).first()
# flash(permiso)
# Si existe dicho permiso
if(permiso != None):
# Por cada rol que posea el usuario logueado
for rol in usuario.roles:
# Si tiene ese permiso
if permiso in rol.permiso:
# Establecemos que esta autorizado para realizar la operacion
autorizado = True
return autorizado
| Python |
'''
Created on 10/04/2013
@author: mirta
'''
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from app import db
from app.wtforms.rol_forms import RolBuscar
from app.wtforms.rol_forms import RolEditable
from app.wtforms.rol_forms import RolNoEditable
from app.models.rol import Rol
from app.models.permiso import Permiso
from app.models.usuario import Usuario
from app.security import permission
mod = Blueprint('roles', __name__, url_prefix='/rol')
#Lista de los nombre de los roles por defecto del sistema
roles_por_defecto = ['Administrador de Sistema', 'Lider de Proyecto']
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_ROLES')
def administracion_rol():
"""
Muestra en pantalla los roles que existen en la base de datos.
Si no recibe algun filtro como parametro, lista todos los roles.
Si recibe algun filtro, muestra los roles que cumplen con el filtro indicado
"""
# Obtenemos el formulario
form = RolBuscar(request.form)
# Obtenemos el filtro
nombreFilter = form.nombre.data
if(nombreFilter == None):
nombreFilter = ''
# Recuperamor de la base de datos lo roles que coinciden con el filtro
roles = Rol.query.filter(Rol.nombre.like( '%'+nombreFilter+'%' ))
roles = roles.all()
return render_template('rol/administracion_rol.html', form = form, roles = roles)
@mod.route('/crear/', methods=['GET', 'POST'])
@permission('CREAR_ROL')
def crear_rol():
"""
Muestra en pantalla el formulario de creacion de roles, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre del usuario nuevo no exista ya en el
sistema y se hayan ingresado los datos obligatorios. Luego almacena en base de datos
"""
# Obtenemos el formulario
form = RolEditable(request.form)
# Obtenemos todos los permisos existentes en la base de datos
permisos =Permiso.query.all()
# Hacemos una tupla con el nombre del permisos y su id
lista_permisos=[]
for permiso in permisos:
if permiso.entidad == None:
aux = ""
else:
aux= permiso.entidad.nombre
lista_permisos.append((permiso.id, permiso.nombre+" "+aux))
# Asignamos esa tupla de permisos a la lista que va a ser visualizada en el checkbox
form.permisos.choices = lista_permisos
# Se valida los datos ingresados en el formulario
if form.validate_on_submit():
# Obtenemos todos los roles de la base de datos
roles = Rol.query.all()
cont = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if roles != None:
for rolind in roles:
if form.nombre.data == rolind.nombre:
cont = cont + 1
# Si ya existe el nombre, no permitimos la creacion
if cont != 0:
flash("El nombre de rol ya existe, elija otro", 'error-message')
return redirect(url_for('roles.crear_rol'))
# Si el nombre aun no existe
else:
# Obtenemos los permisos seleccionados por el usuario
lista_permisos = []
for id_permiso in form.permisos.data:
permiso = Permiso.query.filter_by(id=id_permiso).first()
lista_permisos.append(permiso)
# Creamos el rol
rol = Rol(form.nombre.data, form.descripcion.data, lista_permisos)
db.session.add(rol)
db.session.commit()
# Una vez creado el nuevo rol, se redirecciona a la pagina de administracion
flash('El rol ha sido registrado con exito')
return redirect(url_for('roles.administracion_rol'))
return render_template('rol/crear_rol.html', form = form)
@mod.route('/modificar/<rol>/', methods=['GET', 'POST'])
@permission('MODIFICAR_ROL')
def modificar_rol(rol):
"""
Muestra en pantalla el formulario de modificacion de roles, valida los datos ingresados por
el usuario, hace las validaciones de el nombre de usuario nuevo no exista ya en el
sistema y se hayan ingresado los datos obligatorios. Luego almacena en base de datos los
cambios
@param rol: id del rol que se desea modificar
"""
# Obtenemos el rol seleccionado a ser modificado
rol_seleccionado = Rol.query.filter_by(id=rol).first()
if rol_seleccionado.nombre in roles_por_defecto:
# Si el rol seleccionado es un rol por defecto no permitimos la modificacion
flash('No se puede modificar el rol por defecto %s' % rol_seleccionado.nombre,
'error-message')
return redirect(url_for('roles.administracion_rol'))
else:
# Obtenemos el formulario
form = RolEditable(request.form)
# Obtenemos todos los permisos que existen en la base de datos
permisos =Permiso.query.all()
# Hacemos una tupla con el nombre del permisos y su id
lista_permisos=[]
for permiso in permisos:
if permiso.entidad == None:
aux = ""
else:
aux= permiso.entidad.nombre
lista_permisos.append((permiso.id, permiso.nombre+" "+aux))
# Listamos los permisos que existen en el checkbox
form.permisos.choices = lista_permisos
# Validamos los datos ingresados al formulario
if form.validate_on_submit():
# Obtenemos todos los roles de la base de datos
roles = Rol.query.all()
cont = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if roles != None:
for rolind in roles:
if form.nombre.data == rolind.nombre:
cont = cont + 1
# Si el nombre existe en el sistema y no es igual al nombre viejo del rol o
# es una nombre de un rol por defecto. No permitimos la modificacion
if (cont != 0 and form.nombre.data != rol_seleccionado.nombre) or (form.nombre.data
in roles_por_defecto):
flash("El nombre de rol ya existe, elija otro", 'error-message')
# Redirigimos a la pagina de modificacion
return redirect(url_for('roles.modificar_rol', rol = rol_seleccionado.id))
else:
# Si se puede realizar la modificacion
# Obtenemos los permisos seleccionados por el usuario
permisos_seleccionados = []
for id_permiso in form.permisos.data:
permiso = Permiso.query.filter_by(id=id_permiso).first()
permisos_seleccionados.append(permiso)
# Realizamos los cambios en los atributos del rol
rol_seleccionado.setNombre(form.nombre.data)
rol_seleccionado.setDescripcion(form.descripcion.data)
rol_seleccionado.setPermisos(permisos_seleccionados)
# Almacenamos el rol modificado en la base de datos
db.session.add(rol_seleccionado)
db.session.commit()
# Retornamos a la pagina de administracion de roles
flash('El rol ha sido registrado con exito')
return redirect(url_for('roles.administracion_rol'))
# Mostramos en el formulario la descripcion y el nombre actual del rol que se quiere
# modificar
form.descripcion.data = rol_seleccionado.descripcion
form.nombre.data = rol_seleccionado.nombre
# Obtenemos los permisos que el rol seleccionado tiene antes de la modificacion
permisos_seleccionados = []
for permiso_sec in rol_seleccionado.permiso:
permisos_seleccionados.append(permiso_sec.id)
# Mostramos seleccionados esos permisos en el checkbox
form.permisos.data = permisos_seleccionados
return render_template('rol/modificar_rol.html', form = form,
rol_seleccionado=rol_seleccionado)
@mod.route('/consultar/<rol>/', methods=['GET', 'POST'])
@permission('VER_ROL')
def consultar_rol(rol):
"""
Muestra en pantalla el formulario de consulta de roles, muestra todos los datos del
rol seleccionado
@param rol: id del rol que se desea consultar
"""
# Obtenemos el formulario
form = RolNoEditable(request.form)
# Obtenemos el rol seleccionado
rol_seleccionado = Rol.query.filter_by(id=rol).first()
# Hacemos una tupla con el nombre y el id de los permisos del rol
permisos_seleccionados = []
for permiso in rol_seleccionado.permiso:
if permiso.entidad == None:
aux = ""
else:
aux= permiso.entidad.nombre
permisos_seleccionados.append((permiso.id, permiso.nombre+" "+aux))
# Mostramos los permisos que posee el rol
form.permisos.choices = permisos_seleccionados
# Mostramos el nombre del rol
form.nombre.data = rol_seleccionado.nombre
#Mostramos la descripcion del sol
form.descripcion.data = rol_seleccionado.descripcion
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de roles
return redirect(url_for('roles.administracion_rol'))
return render_template('rol/consultar_rol.html', form = form,
rol_seleccionado=rol_seleccionado)
@mod.route('/eliminar/<rol>/', methods=['GET', 'POST'])
@permission('ELIMINAR_ROL')
def eliminar_rol(rol):
"""
Muestra en pantalla el formulario de eliminacion de roles, muestra todos los datos del
rol seleccionado
@param rol: id del rol que se desea eliminar
"""
# Obtenemos el rol seleccionado
rol_seleccionado = Rol.query.filter_by(id=rol).first()
usuarios = Usuario.query.all()
cont = 0
for usuario in usuarios:
if rol_seleccionado in usuario.roles:
cont = cont +1
if rol_seleccionado.nombre in roles_por_defecto:
# Si el rol seleccionado es un rol por defecto no permitimos la modificacion
flash('No se puede eliminar el rol por defecto %s' % rol_seleccionado.nombre,
'error-message')
return redirect(url_for('roles.administracion_rol'))
elif cont!=0:
flash('No se puede eliminar el rol %s , se encuentra asociado con un usuario' % rol_seleccionado.nombre,'error-message')
return redirect(url_for('roles.administracion_rol'))
else:
# Obtenemos el formulario
#form = RolNoEditable(request.form)
# Hacemos una tupla con el nombre y el id de los permisos del rol
#permisos_seleccionados = []
#for permiso in rol_seleccionado.permiso:
# if permiso.entidad == None:
# aux = ""
# else:
# aux= permiso.entidad.nombre
# permisos_seleccionados.append((permiso.id, permiso.nombre+" "+aux))
#Mostramos la lista de permisos que posee el rol
#form.permisos.choices = permisos_seleccionados
# Mostramos el nombre del rol
#form.nombre.data = rol_seleccionado.nombre
# Mostramos la descripcion del rol
#form.descripcion.data = rol_seleccionado.descripcion
# Cuando le da click en el boton aceptar
#if form.validate_on_submit():
# Borramos de la base de datos el rol
db.session.delete(rol_seleccionado)
db.session.commit()
# Redirigimos a la pagina de administracion de roles
flash('El rol ha sido eliminado con exito')
return redirect(url_for('roles.administracion_rol'))
#return render_template('rol/eliminar_rol.html', form = form,
# rol_seleccionado=rol_seleccionado)
| Python |
'''
Created on 18/05/2013
@author: belentwi
'''
from app import db
from flask import Blueprint
from flask import request
from flask import render_template
from flask import redirect
from flask import url_for
from flask import flash
from app.models.solicitud_cambio import SolicitudCambio
from app.models.fase import Fase
from app.models.item import Item
from app.models.voto import Voto
from app.wtforms.solicitud_cambio_forms import SolicitudBuscar
from app.wtforms.solicitud_cambio_forms import ConsultarSolicitud
from app.wtforms.solicitud_cambio_forms import CrearSolicitud
from app.wtforms.solicitud_cambio_forms import VotacionSolicitud
from app.security import permission
from app.security import g
from app.controllers.linea_base_controller import eliminar_lb
from app.models.linea_base import LineaBase
from app.models.solicitud_cambio_reporte import SolicitudCambioReporte
from app.controllers.calculo_impacto_controller import calculo_impacto_grup
from app.controllers.calculo_impacto_controller import calculo_costo
from app.reportes.solicitud_reporte import SolicitudReport
from geraldo.generators import PDFGenerator
import os
mod = Blueprint('solicitudes', __name__, url_prefix='/solicitud')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_SOLICITUDES')
def administracion_solicitud():
"""
Muestra en pantalla las solicitudes que existen en la base de datos.
Si no recibe algun filtro como parametro, lista todas solicitudes.
Si recibe algun filtro, muestra las solicitudes que cumplen con el filtro indicado
"""
# Obtenemos el formulario
form = SolicitudBuscar(request.form)
# Obtenemos el filtro
impactoFilter = form.impacto_total.data
estadoFilter = form.estado.data
observacionFilter = form.observacion.data
if(impactoFilter == None):
impactoFilter = ''
if(estadoFilter == None):
estadoFilter = ''
if(observacionFilter == None):
observacionFilter = ''
solicitudes = SolicitudCambio.query.filter(SolicitudCambio.creador_id == g.user.id, SolicitudCambio.estado.like('%'+estadoFilter+'%'), SolicitudCambio.impacto_total.like('%'+impactoFilter+'%'), SolicitudCambio.observacion.like('%'+observacionFilter+'%'))
solicitudes = solicitudes.all()
return render_template('solicitud_cambio/administracion_solicitud.html', form = form, solicitudes = solicitudes)
@mod.route('/crear/', methods=['GET', 'POST'])
#@permission('CREAR_ATRIBUTO')
def crear_solicitud():
"""
Muestra en pantalla el formulario de creacion de una solicitud de cambio, valida los datos ingresados por
el usuario y se hayan ingresado los datos obligatorios. Luego almacena en base de datos
"""
choicesItems = []
idList = []
proyecto = g.proyecto
permisos = g.permisos
fases = proyecto.fases
for fase in fases:
for permiso in permisos:
if(permiso.nombre == 'MODIFICAR' and permiso.entidad_id == fase.entidad_id):
idList.append(fase.id)
items = Item.query.filter_by(estado = 'Bloqueado').join(Fase).filter(Fase.id.in_(idList) ).all()
for item in items:
if(len(item.solicitud) == 0):
choicesItems.append((str(item.id), item.nombre))
form = CrearSolicitud(request.form)
form.items.choices = choicesItems
items = []
if form.validate_on_submit():
for id_item in form.items.data:
item = Item.query.filter_by(id = int(id_item)).first()
items.append(item)
costo_total = calculo_costo(items)
impacto_total = calculo_impacto_grup(items)
observacion = form.observacion.data
estado = 'Activa'
creador = g.user
proyecto = g.proyecto
solicitud = SolicitudCambio(impacto_total, costo_total, estado, observacion, items, creador, proyecto)
db.session.add(solicitud)
db.session.commit()
flash('La solicitud ha sido registrada con exito')
return redirect(url_for('solicitudes.administracion_solicitud'))
return render_template("solicitud_cambio/crear_solicitud.html", form = form)
@mod.route('/consultar/<solicitud>/', methods=['GET', 'POST'])
#@permission('VER_ROL')
def consultar_solicitud(solicitud):
"""
Muestra en pantalla el formulario de consulta de solicitudes, muestra todos los datos a la
solicitud relacionada
@param solicitud: id de la solicitud que se desea consultar
"""
# Obtenemos el formulario
form = ConsultarSolicitud(request.form)
solicitud = SolicitudCambio.query.filter_by(id = solicitud).first()
itemChoices = []
for item in solicitud.items:
itemChoices.append( (str(item.id), 'Item: ' +item.nombre + ' Costo: ' + str(item.costo)) )
form.costo_total.data = solicitud.costo_total
form.impacto_total.data = solicitud.impacto_total
form.creador.data = solicitud.creador.nombre
form.observacion.data = solicitud.observacion
form.estado.data = solicitud.estado
form.items.choices = itemChoices
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de roles
return redirect(url_for('solicitudes.administracion_solicitud'))
return render_template('solicitud_cambio/consultar_solicitud.html', form = form)
@mod.route('/modificar/<solicitud>/', methods=['GET', 'POST'])
#@permission('MODIFICAR_ROL')
def modificar_solicitud(solicitud):
"""
Muestra en pantalla el formulario de modificacion de una solicitud de cambio, valida los datos ingresados por
el usuario y se hayan ingresado los datos obligatorios. Luego almacena en base de datos
@param solicitud: id de la solicitud que se desea modificar
"""
# Obtenemos el formulario
form = CrearSolicitud(request.form)
idList = []
proyecto = g.proyecto
fases = proyecto.fases
for fase in fases:
idList.append(fase.id)
solicitud = SolicitudCambio.query.filter_by(id = solicitud).first()
if(solicitud.estado == 'Activa'):
choicesItems = []
items = Item.query.filter_by(estado = 'Bloqueado').join(Fase).filter(Fase.id.in_(idList) ).all()
for item in items:
choicesItems.append((str(item.id), item.nombre))
form.items.choices = choicesItems
if form.validate_on_submit():
solicitud.observacion = form.observacion.data
items = []
for id_item in form.items.data:
item = Item.query.filter_by(id = int(id_item)).first()
items.append(item)
solicitud.items = items
solicitud.costo_total= calculo_costo(items)
solicitud.impacto_total= calculo_impacto_grup(items)
db.session.add(solicitud)
db.session.commit()
# Retornamos a la pagina de administracion de roles
flash('La solicitud ha sido actualizada con exito')
return redirect(url_for('solicitudes.administracion_solicitud'))
form.observacion.data = solicitud.observacion
choicesData = []
for item in solicitud.items:
choicesData.append(str(item.id))
form.items.data = choicesData
return render_template('solicitud_cambio/modificar_solicitud.html', form = form)
else:
flash('La solicitud no puede ser modificada')
return redirect(url_for('solicitudes.administracion_solicitud'))
@mod.route('/eliminar/<solicitud>/', methods=['GET', 'POST'])
#@permission('ELIMINAR_ATRIBUTO')
def eliminar_solicitud(solicitud):
"""
Muestra en pantalla el formulario de eliminacion de solicitudes, se pide la confimacion del usuario
y se elimina la solicitud.
@param solicitud: id de la solicitud que se desea eliminar.
"""
solicitud_seleccionada = SolicitudCambio.query.filter_by(id=solicitud).first()
db.session.delete(solicitud_seleccionada)
db.session.commit()
flash('Se ha eliminado la solicitud exitosamente')
return redirect(url_for('solicitudes.administracion_solicitud'))
@mod.route('/enviar/<solicitud>/', methods=['GET', 'POST'])
def enviar_solicitud(solicitud):
"""
Muestra en pantalla el formulario de envio de solicitudes.
@param solicitud: id de la solicitud que se desea enviar.
"""
solicitud_seleccionada = SolicitudCambio.query.filter_by(id=solicitud).first()
if(solicitud_seleccionada.estado == 'Activa'):
solicitud_seleccionada.estado = 'Votacion'
db.session.add(solicitud_seleccionada)
db.session.commit()
else:
flash('La solicitud no puede ser enviada')
return redirect(url_for('solicitudes.administracion_solicitud'))
@mod.route('/ver_solicitudes/', methods=['GET', 'POST'])
def ver_solicitudes_comite():
"""
Muestra en pantalla las solicitudes que existen en la base de datos que corresponden al comite del proyecto.
"""
# Obtenemos el formulario
proyecto_login = g.proyecto
comite_miembros = proyecto_login.comite.miembros
usuario = g.user
if(usuario in comite_miembros ):
solicitudes = SolicitudCambio.query.filter_by(proyecto_id = proyecto_login.id)
solicitudes = solicitudes.all()
return render_template('solicitud_cambio/ver_solicitudes_comite.html', solicitudes = solicitudes)
else:
flash('Usted no pertenece al comite de cambio de este proyecto')
return redirect(url_for('solicitudes.administracion_solicitud'))
@mod.route('/votar/<solicitud>/', methods=['GET', 'POST'])
def votar(solicitud):
"""
Muestra en pantalla el formulario de votacion.
@param solicitud: id de la solicitud que se desea votar.
"""
usuario = g.user
proyecto_login = g.proyecto
solicitud_seleccionada = SolicitudCambio.query.filter_by(id=solicitud).first()
opciones = ((str(1), 'Aprobar'), (str(2), 'No Aprobar'))
if(solicitud_seleccionada.estado == 'Votacion'):
voto_verificado = Voto.query.filter_by(id_solicitud = solicitud, id_usuario = usuario.id).first()
if(voto_verificado == None):
form = VotacionSolicitud(request.form)
form.opciones.choices = opciones
if form.validate_on_submit():
if(form.opciones.data == '1'):
valor_voto = 1
else:
valor_voto = 0
voto = Voto(solicitud_seleccionada.id, usuario.id, valor_voto)
db.session.add(voto)
db.session.commit()
cantidad_miembros = proyecto_login.comite.cantidad_miembros
cantidad_votos = solicitud_seleccionada.cantidad_votos + 1
solicitud_seleccionada.cantidad_votos = cantidad_votos
db.session.add(solicitud_seleccionada)
db.session.commit()
if(solicitud_seleccionada.cantidad_votos == cantidad_miembros):
votos = Voto.query.filter_by(id_solicitud = solicitud_seleccionada.id )
resultado = 0
for votito in votos:
resultado = resultado + votito.voto
minimo = (cantidad_miembros/2)+1
if(resultado >= minimo):
solicitud_seleccionada.estado = 'Aprobada'
items = solicitud_seleccionada.items
for item in items:
#===================================================
# id_lb = item.linea_base.id
# linea_base = LineaBase.query.filter_by(id= id_lb)
#===================================================
eliminar_lb(item.linea_base.id)
item.estado = 'Activo'
db.session.add(item)
db.session.add(solicitud_seleccionada)
db.session.commit()
return redirect(url_for('solicitudes.administracion_solicitud'))
else:
solicitud_seleccionada.estado = 'Rechazada'
db.session.add(solicitud_seleccionada)
db.session.commit()
return redirect(url_for('solicitudes.administracion_solicitud'))
else:
return redirect(url_for('solicitudes.administracion_solicitud'))
return render_template("solicitud_cambio/votacion_solicitud.html", form = form, opciones = opciones)
else:
flash('Usted ya ha votado')
return redirect(url_for('solicitudes.administracion_solicitud'))
else:
flash('La solicitud no puede ser votada')
return redirect(url_for('solicitudes.administracion_solicitud'))
@mod.route('/reporte_solicitud/', methods=['GET', 'POST'])
def reporte_solicitud():
"""
Muestra en pantalla las solicitudes que existen en la base de datos que corresponden al comite del proyecto.
"""
# Obtenemos el formulario
proyecto_login = g.proyecto
if(proyecto_login.lider_id == g.user.id):
solicitudes = SolicitudCambio.query.filter_by(proyecto_id = proyecto_login.id)
solicitudes = solicitudes.all()
for solicitud in solicitudes:
items = solicitud.items
lista_nombres = []
for item in items:
if(item.linea_base.nombre not in lista_nombres):
lista_nombres.append(item.linea_base.nombre)
lider_id = proyecto_login.lider_id
voto_verificado = Voto.query.filter_by(id_solicitud = solicitud.id, id_usuario = lider_id).first()
if(voto_verificado == None):
voto = 'Votado'
else:
voto = 'No Votado'
solicitudes_reporte = []
for nombre in lista_nombres:
solicitud_reporte = SolicitudCambioReporte()
solicitud_reporte.setId(solicitud.id)
solicitud_reporte.setObservacion(solicitud.observacion)
solicitud_reporte.setLineBase(nombre)
solicitud_reporte.setCreador(solicitud.creador.nombre)
solicitud_reporte.setVoto(voto)
solicitud_reporte.setEstado(solicitud.estado)
solicitudes_reporte.append(solicitud_reporte)
report = SolicitudReport(solicitudes_reporte)
cur_dir = os.path.dirname(os.path.abspath(__file__))
reporte_dir = cur_dir + '/pdf'
nombre = 'reporte_solicitud.pdf'
#-------------------------------- if reporte_dir.isfile('reporte_item.pdf'):
#----------------------------------------- nombre = 'reporte_item_2.pdf'
report.generate_by(PDFGenerator, filename=os.path.join(reporte_dir , nombre))
ruta = '/usr/bin/gnome-open ' + reporte_dir + '/' + nombre
os.system(ruta)
return redirect(url_for('solicitudes.administracion_solicitud'))
else:
flash('No tiene permisos para ver el reporte')
return redirect(url_for('solicitudes.administracion_solicitud'))
| Python |
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import session
from flask import redirect
from flask import url_for
from werkzeug import check_password_hash
from werkzeug import generate_password_hash
from app import db
from app.security import permission
from app.security import g
from app.models.usuario import Usuario
from app.models.proyecto import Proyecto
from app.wtforms.acceso_forms import LoginForm
from app.wtforms.acceso_forms import IngresarUsuarioForm
from app.wtforms.acceso_forms import CambiarContrasenhaForm
from app.wtforms.acceso_forms import ElegirProyectoForm
mod = Blueprint('acceso', __name__ , url_prefix='/acceso')
@mod.route('/sap/')
@permission
def home():
"""
Manda al usuario que ongreso a la pagina principal del sistema
"""
return render_template("/base.html", g=g)
@mod.route('/proyecto/<usuario>/<aux>/', methods=['GET', 'POST'])
def elegir_proyecto(usuario, aux):
"""
Crea el formulario para la eleccion de proyectos y redirige a la pagina, recibe las
peticiones get y post, valida el datto seleccionado para mandarlo a la pagina principal
@param usuario: nombre del usuario que se logueo
@param aux: id que identifica que template se debe utilizar para mostrar los datos, esta
funcion es llamada por login y por cambiar_proyecto
"""
# Obtenermos el usuario que se logueo
user = Usuario.query.filter_by(nombre=usuario).first()
session['usuario_id'] = user.id
# Obtenemos todos los proyectos de la base de datos
proyectos = Proyecto.query.all()
# Hacemos una lista de todos los proyectos en donde el usuario sea miembro
Lista_proyectos = []
for proyecto in proyectos:
if user in proyecto.miembros:
Lista_proyectos.append((proyecto.id, proyecto.nombre))
Lista_roles = []
for rol in user.roles:
Lista_roles.append(rol.nombre)
if 'Administrador de Sistema' in Lista_roles:
#flash('No puede ingresar al sistema, no es miembro de ningun proyecto')
# Redirigimos a la pagina principal
return redirect(url_for('acceso.home'))
elif Lista_proyectos == []:
return redirect(url_for('acceso.login'))
else:
# Crea el formulario para la eleccion del proyecto entre los que el usuario es miembro
form = ElegirProyectoForm(request.form)
# Mostramos en pantalla esos proyectos
form.proyectos.choices = Lista_proyectos
# Validamos los datos ingresados en el formulario
if form.validate_on_submit():
# Creamos la session con el usuario y el proyecto seleccionado como atributos
session['proyecto_id'] = form.proyectos.data
p = session['proyecto_id']
for proy in Lista_proyectos:
if p[0] in proy:
nombre = proy[1]
session['proyecto_nombre'] = nombre
# Redirigimos a la pagina principal
return redirect(url_for('acceso.home'))
if aux=='0':
return render_template("acceso/elegir_proyecto.html", form=form)
elif aux=='1':
return render_template("acceso/cambiar_proyecto.html", form=form)
@mod.route('/login/', methods=['GET', 'POST'])
def login():
"""
Crea el formulario login y redirige a la pagina, recibe las peticiones get y post,
valida el nombre de usuario y contrasenha para mandarlo a la pagina principal de login
"""
form = LoginForm(request.form)
# Realizamos la validacion de los datos ingresados al formulario
if form.validate_on_submit():
user = Usuario.query.filter_by(nombre=form.nombre.data).first()
if user != None:
if user.estado == 'DESACTIVO':
flash('El usuario se encuentra con estado Desactivado', 'error-message')
return redirect(url_for('acceso.login'))
else:
# Utilizamos werzeug para realizar la validacion de usuario con su contrasenha
if user and check_password_hash(user.contrasenha, form.contrasenha.data):
#Redirigimos al usuario a la pagina de eleccion de proyectos
return redirect(url_for('acceso.elegir_proyecto', usuario =user.nombre, aux=0))
flash('Nombre de usuario o contrasenha incorrecta', 'error-message')
else:
flash('El usuario no existe en el sistema', 'error-message')
return render_template("acceso/login.html", form=form)
@mod.route('/usuario/', methods=['GET', 'POST'])
def ingresar_usuario():
"""
Crea el formulario para ingresar el usuario al cual se le quiere
establecer una nueva contrasenha y redirige a la pagina, recibe las peticiones get y post,
valida los datos ingresados para mandarlo a la pagina principal de ingreso de usuario
"""
form = IngresarUsuarioForm(request.form)
# Realizamos la validacion de los datos ingresados al formulario
if form.validate_on_submit():
# Obtenemos el usuario con el nombre de usuario que se paso en el formulario
user = Usuario.query.filter_by(nombre=form.nombre.data).first()
if user != None :
if user.estado == 'DESACTIVO':
flash('El usuario se encuentra con estado Desactivado', 'error-message')
return redirect(url_for('acceso.ingresar_usuario'))
else:
# Desplegamos un mensaje de bienvenida en pantalla
# Desplegamos un mensaje de bienvenida en pantalla
flash('Usuario %s , por favor responda la pregunta de seguridad e ingrese la nueva clave'
% user.nombre)
# Cuando se apriete el boton Aceptar de la pagina, se redirige al metodo
# cambiar_contrasenha
return redirect(url_for('acceso.cambiar_contrasenha', nombre=user.nombre))
else:
flash('El nombre de usuario no existe', 'error-message')
return render_template("acceso/ingresar_usuario.html", form=form)
@mod.route('/contrasenha/<nombre>/', methods=['GET', 'POST'])
def cambiar_contrasenha(nombre):
"""
Crea el formulario para responder la pregunta de seguridad del usuario
e ingresar la nueva contrasenha, recibe las peticiones get y post,valida los datos ingresados
para mandarlo a la pagina principal de ingreso de usuario
@param nombre: nombre del usuario a quien se debe cambiar la contrasenha
"""
# Obtenemos el usuario cuyo nombre de usuario fue proporcionado
user = Usuario.query.filter_by(nombre=nombre).first()
if user.estado == 'DESACTIVO':
flash('El usuario se encuentra con estado Desactivado', 'error-message')
return redirect(url_for('acceso.ingresar_usuario'))
else:
form = CambiarContrasenhaForm(request.form)
# Realizamos la validacion de los datos ingresados al formulario
if request.method == 'POST' and form.is_submitted() and form.validate():
# Verificamos que la respuesta dada en el formulario sea la misma que el usuario tiene
# almacenada en base de datos
if user.respuesta == form.respuesta.data:
# Establecemos la nueva contrasenha
user.setContrasenha(generate_password_hash(form.contrasenha.data))
# Add y comiteamos los cambios hechos al usuario
db.session.add(user)
db.session.commit()
# Redirigimos al metodo login
return redirect(url_for('acceso.login'))
flash('Respuesta incorrecta', 'error-message')
return render_template("acceso/cambiar_contrasenha.html", form=form, user=user)
@mod.route('/logout/')
def logout():
session.pop('usuario_id', None)
session.pop('proyecto_id', None)
session.pop('proyecto_nombre', None)
#flash('You were logged out')
return redirect(url_for('acceso.login'))
@mod.route('/cambiar/', methods=['GET', 'POST'])
def cambiar_proyecto():
"""
Metodo auxiliar que llama a elegir_proyecto, cuando el usuario desea ingresar a otro proyecto
en el cual es miembro sin necesidad de cerrar sesion
"""
return redirect(url_for('acceso.elegir_proyecto', usuario=g.user.nombre, aux=1)) | Python |
from flask import Blueprint
from flask import request
from flask import render_template
from flask import flash
from flask import redirect
from flask import url_for
from app import db
from werkzeug import generate_password_hash
from app.wtforms.usuario_forms import UsuarioBuscar
from app.wtforms.usuario_forms import UsuarioEditable
from app.wtforms.usuario_forms import UsuarioNoEditable
from app.wtforms.usuario_forms import UsuarioModificacion
from app.wtforms.usuario_forms import UsuarioClave
from app.models.rol import Rol
from app.models.usuario import Usuario
from app.security import permission
mod = Blueprint('usuarios', __name__, url_prefix='/usuario')
@mod.route('/administracion/', methods=['GET', 'POST'])
@permission('ADMINISTRACION_USUARIOS')
def administracion_usuario():
"""
Muestra en pantalla los usuarios que existen en la base de datos.
Si no recibe algun filtro como parametro, lista todos los usuarios.
Si recibe algun filtro, muestra los usuarios que cumplen con el filtro indicado
"""
form = UsuarioBuscar(request.form)
nombreFilter = form.nombre.data
mailFilter = form.email.data
estadoFilter = form.estado.data
if(nombreFilter == None):
nombreFilter = ''
if(mailFilter == None):
mailFilter = ''
if(estadoFilter == None):
estadoFilter = ''
usuarios = Usuario.query.filter(Usuario.nombre.like( '%'+nombreFilter+'%' ) , Usuario.email.like( '%'+mailFilter+'%' ), Usuario.estado.like('%'+estadoFilter+'%'))
return render_template('usuarios/administracion_usuario.html', form = form, usuarios = usuarios)
@mod.route('/crear/', methods=['GET', 'POST'])
@permission('CREAR_USUARIO')
def crear_usuario():
"""
Muestra en pantalla el formulario de creacion de usuario, valida los datos ingresados por
el usuario, hace las validaciones de que el nombre del usuario nuevo no exista ya en el
sistema y se hayan ingresado los datos obligatorios. Luego almacena en base de datos
"""
# Obtenemos el formulario
form = UsuarioEditable(request.form)
# Obtenemos todos los roles existentes en la base de datos
roles = Rol.query.all()
# Hacemos una tupla con el nombre y id de los roles
lista_roles=[]
for rol in roles:
lista_roles.append((rol.id, rol.nombre))
# Asignamos esa tupla de roles a la lista que va a ser visualizada en el checkbox
form.roles.choices = lista_roles
# Se valida los datos ingresados en el formulario
if form.validate_on_submit():
# Obtenemos todos los usuarios de la base de datos
usuarios = Usuario.query.all()
cont = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if usuarios != None:
for usu in usuarios:
if form.nombre.data == usu.nombre:
cont = cont + 1
# Si ya existe el nombre, no permitimos la creacion
if cont != 0:
flash("El nombre de usuario ya existe, elija otro")
return redirect(url_for('usuarios.crear_usuario'))
# Si el nombre aun no existe
else:
# Obtenemos los roles seleccionados por el usuario
lista_roles = []
for id_rol in form.roles.data:
rol = Rol.query.filter_by(id=id_rol).first()
lista_roles.append(rol)
# Creamos el usuario
usuario = Usuario(form.nombre.data, form.email.data, generate_password_hash(form.contrasenha.data),
form.pregunta.data, form.respuesta.data, 'ACTIVO', lista_roles)
db.session.add(usuario)
db.session.commit()
# Una vez creado el nuevo usuario, se redirecciona a la pagina de administracion
flash('El usuario ha sido registrado con exito')
return redirect(url_for('usuarios.administracion_usuario'))
return render_template('usuarios/crear_usuario.html', form = form)
@mod.route('/modificar/<usuario>/', methods=['GET', 'POST'])
@permission('MODIFICAR_USUARIO')
def modificar_usuario(usuario):
"""
Clase para modificar los atributos de un usuario existente en el sistema, muestra en pantalla todos
los datos del usuario almacenado en base de datos para su modificacion
@param usuario: id del usuario cuyos datos se quiere modificar
"""
# Obtenemos el formulario
form = UsuarioModificacion(request.form)
# Obtenemos el usuario seleccionado
usuario_seleccionado = Usuario.query.filter_by(id=usuario).first()
# Obtenemos todos los roles existentes en la base de datos
roles = Rol.query.all()
# Hacemos una tupla con el nombre y id de los roles
lista_roles=[]
for rol in roles:
lista_roles.append((rol.id, rol.nombre))
# Asignamos esa tupla de roles a la lista que va a ser visualizada en el checkbox
form.roles.choices = lista_roles
# Se valida los datos ingresados en el formulario
if form.validate_on_submit():
# Obtenemos todos los usuarios de la base de datos
usuarios = Usuario.query.all()
cont = 0
# Comparamos que el nombre ingresado por el usuario no sea igual a uno existente
if usuarios != None:
for usu in usuarios:
if form.nombre.data == usu.nombre:
cont = cont + 1
# Si ya existe el nombre, no permitimos la creacion
if cont != 0 and form.nombre.data != usuario_seleccionado.nombre:
flash("El nombre de usuario ya existe, elija otro")
return redirect(url_for('usuarios.crear_usuario'))
# Si el nombre aun no existe
else:
# Obtenemos los roles seleccionados por el usuario
lista_roles = []
for id_rol in form.roles.data:
rol = Rol.query.filter_by(id=id_rol).first()
lista_roles.append(rol)
# Guardamos los cambios del usuario
usuario_seleccionado.setNombre(form.nombre.data)
usuario_seleccionado.setEmail(form.email.data)
usuario_seleccionado.setPregunta(form.pregunta.data)
usuario_seleccionado.setRespuesta(form.respuesta.data)
usuario_seleccionado.setRoles(lista_roles)
db.session.add(usuario_seleccionado)
db.session.commit()
# Una vez creado el nuevo usuario, se redirecciona a la pagina de administracion
flash('El usuario ha sido registrado con exito')
return redirect(url_for('usuarios.administracion_usuario'))
# Mostramos en el formulario la descripcion y el nombre actual del rol que se quiere
# modificar
form.nombre.data = usuario_seleccionado.nombre
form.email.data = usuario_seleccionado.email
form.pregunta.data = usuario_seleccionado.pregunta
form.respuesta.data = usuario_seleccionado.respuesta
# Obtenemos los permisos que el rol seleccionado tiene antes de la modificacion
roles_seleccionados = []
for rol_sec in usuario_seleccionado.roles:
roles_seleccionados.append(rol_sec.id)
# Mostramos seleccionados esos permisos en el checkbox
form.roles.data = roles_seleccionados
return render_template('usuarios/modificar_usuario.html', form = form, usuario=usuario)
@mod.route('/clave/<usuario>/', methods=['GET', 'POST'])
@permission('MODIFICAR_USUARIO')
def cambiar_clave(usuario):
"""
Clase utilizada para la modificacion de clave de un usuario
@param usuario: id del usuario cuya clave se quiere modificar
"""
form = UsuarioClave(request.form)
# Obtenemos el usuario seleccionado
usuario_seleccionado = Usuario.query.filter_by(id=usuario).first()
# Realizamos la validacion de los datos ingresados al formulario
if request.method == 'POST' and form.is_submitted() and form.validate():
usuario_seleccionado.setContrasenha(generate_password_hash(form.contrasenha.data))
# Add y comiteamos los cambios hechos al usuario
db.session.add(usuario_seleccionado)
db.session.commit()
# Redirigimos a pagina de modificacion de usuario
return redirect(url_for('usuarios.modificar_usuario', usuario=usuario))
return render_template('usuarios/ingreso_contrasenha_usuario.html', form = form,
usuario=usuario)
@mod.route('/consultar/<usuario>/', methods=['GET', 'POST'])
@permission('VER_USUARIO')
def consultar_usuario(usuario):
"""
Muestra en pantalla el formulario de consulta de usuarios, muestra todos los datos del
usuario seleccionado
@param usuario: id del usuario que se desea consultar
"""
# Obtenemos el formulario
form = UsuarioNoEditable(request.form)
# Obtenemos el usuario seleccionado
usuario_seleccionado = Usuario.query.filter_by(id=usuario).first()
# Hacemos una tupla con el nombre y el id de los roles del usuario
roles_seleccionados = []
for rol in usuario_seleccionado.roles:
roles_seleccionados.append((rol.id, rol.nombre))
# Mostramos los roles que posee el usuario
form.roles.choices = roles_seleccionados
# Mostramos el nombre del usuario
form.nombre.data = usuario_seleccionado.nombre
#Mostramos el mail del usuario
form.email.data = usuario_seleccionado.email
# Mostramos el estado del usuario
form.estado.data = usuario_seleccionado.estado
if form.validate_on_submit():
#Cuando el usuario presiona aceptar, redirigimos a la pagina de administracion de usuarios
return redirect(url_for('usuarios.administracion_usuario'))
return render_template('usuarios/consultar_usuario.html', form = form,
usuario_seleccionado=usuario_seleccionado)
@mod.route('/desactivar/<usuario>/', methods=['GET', 'POST'])
@permission('DESACTIVAR_USUARIO')
def desactivar_usuario(usuario):
"""
Realiza la desactivacion de usuarios con estado activo
@param usuario: id del usuario que se desea desactivar
"""
#Obtenemos el usuario seleccionado
usuario_seleccionado = Usuario.query.filter_by(id=usuario).first()
if usuario_seleccionado.estado == 'DESACTIVO':
# Si el usuario seleccionado ya se encuentra con el estado desactivo
# mostramos un mensaje indicando el hecho
flash('El usuario ya se encuentra con el estado DESACTIVO',
'error-message')
return redirect(url_for('usuarios.administracion_usuario'))
else:
# Si el usuario se encuentra con estado activo
# Cambiamos el estado del usuario por desactivado
usuario_seleccionado.setEstado('DESACTIVO')
db.session.add(usuario_seleccionado)
db.session.commit()
# Redirigimos a la pagina de administracion de usuarios
flash('El usuario ha sido desactivado con exito')
return redirect(url_for('usuarios.administracion_usuario'))
# Hacemos una tupla con el nombre y el id de los roles del usuario
#roles_seleccionados = []
#for rol in usuario_seleccionado.roles:
# roles_seleccionados.append((rol.id, rol.nombre))
#Mostramos la lista de roles que posee el usuario
#form.roles.choices = roles_seleccionados
# Mostramos el nombre del usuario
#form.nombre.data = usuario_seleccionado.nombre
# Mostramos el mail del usuario
#form.email.data = usuario_seleccionado.email
# Mostramos el estado del usuario
#form.estado.data = usuario_seleccionado.estado
#return render_template('usuarios/eliminar_usuario.html', form = form,
# usuario_seleccionado=usuario_seleccionado)
@mod.route('/activar/<usuario>/', methods=['GET', 'POST'])
@permission('ACTIVAR_USUARIO')
def activar_usuario(usuario):
"""
Realiza la activacion de usuarios con estado desactivo
@param usuario: id del usuario que se desea activar
"""
#Obtenemos el usuario seleccionado
usuario_seleccionado = Usuario.query.filter_by(id=usuario).first()
if usuario_seleccionado.estado == 'ACTIVO':
# Si el usuario seleccionado ya se encuentra con el estado desactivo
# mostramos un mensaje indicando el hecho
flash('El usuario ya se encuentra con el estado ACTIVO',
'error-message')
return redirect(url_for('usuarios.administracion_usuario'))
else:
# Si el usuario se encuentra con estado activo
# Cambiamos el estado del usuario por desactivado
usuario_seleccionado.setEstado('ACTIVO')
db.session.add(usuario_seleccionado)
db.session.commit()
# Redirigimos a la pagina de administracion de usuarios
flash('El usuario ha sido activado con exito')
return redirect(url_for('usuarios.administracion_usuario'))
| Python |
from flask import Flask
from flask import render_template
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config.from_object('config')
db = SQLAlchemy(app)
@app.errorhandler(404)
def not_found(error):
#print "Pagina no encontrada"
return render_template('404.html')
from app.controllers.acceso_controller import mod as accesoModule
from app.controllers.entidad_controller import mod as entidadesModule
from app.controllers.usuario_controller import mod as usuariosModule
from app.controllers.rol_controller import mod as rolesModule
from app.controllers.fase_controller import mod as fasesModule
from app.controllers.permiso_controller import mod as permisosModules
from app.controllers.comite_de_cambio_controller import mod as comitesModule
from app.controllers.proyecto_controller import mod as proyectosModule
from app.controllers.atributo_controller import mod as atributosModule
from app.controllers.item_controller import mod as itemsModule
from app.controllers.relacion_controller import mod as relacionesModule
from app.controllers.linea_base_controller import mod as lineasbaseModule
from app.controllers.tipoItem_controller import mod as tipoItemsModule
from app.controllers.atributo_item_controller import mod as atributoItemModule
from app.controllers.solicitud_cambio_controller import mod as solicitudCambioModule
from app.controllers.voto_controller import mod as votoModule
from app.controllers.calculo_impacto_controller import mod as impactoModule
from app.controllers.grafico_controller import mod as graficoModule
app.register_blueprint(accesoModule)
app.register_blueprint(entidadesModule)
app.register_blueprint(usuariosModule)
app.register_blueprint(rolesModule)
app.register_blueprint(fasesModule)
app.register_blueprint(permisosModules)
app.register_blueprint(comitesModule)
app.register_blueprint(proyectosModule)
app.register_blueprint(atributosModule)
app.register_blueprint(itemsModule)
app.register_blueprint(relacionesModule)
app.register_blueprint(lineasbaseModule)
app.register_blueprint(tipoItemsModule)
app.register_blueprint(atributoItemModule)
app.register_blueprint(solicitudCambioModule)
app.register_blueprint(votoModule)
app.register_blueprint(impactoModule)
app.register_blueprint(graficoModule)
| Python |
'''
Created on 15/04/2013
@author: mirta
'''
from functools import wraps
from flask import g
from flask import session
from flask import redirect
from flask import url_for
from flask import current_app
from flask import flash
from flask import request
from app.models.usuario import Usuario
from app.models.proyecto import Proyecto
from app import app
def permission(method_or_name):
"""
Esta funcion valida los permisos del usuario logueado sobre las acciones posibles
en el sistema
"""
def decorator(method):
#if callable(method_or_name):
# method.gw_method = method.__name__
#else:
# method.gw_method = method_or_name
@wraps(method)
def wrapper(*args, **kwargs):
#current_app.logger.info(g.user.nombre)
if callable(method_or_name):
if g.user is None:
flash(u'Necesita estar registrado para acceder a esta pagina')
return redirect(url_for('acceso.login', next=request.path))
return method(*args, **kwargs)
else:
permiso = method_or_name
permisos = g.permisos
current_app.logger.info(permiso)
current_app.logger.info(permisos)
for per in permisos :
if per.nombre == permiso:
return method(*args, **kwargs)
flash(u'No tiene permiso para ver esta pagina.')
current_app.logger.info('Permiso no encontrado')
return redirect(url_for('acceso.home'))
#current_app.logger.info(method_or_name)
return wrapper
if callable(method_or_name):
return decorator(method_or_name)
return decorator
@app.before_request
def before_request():
"""
Trae el perfil del usuario de la base de datos antes de cada peticion
"""
g.user = None
if 'usuario_id' in session:
g.user = Usuario.query.get(session['usuario_id']);
roles = g.user.roles
g.permisos = []
for rol in roles:
g.permisos = g.permisos + rol.permiso
if 'proyecto_id' in session:
g.proyecto = Proyecto.query.get(session['proyecto_id']);
else:
g.proyecto = None
| Python |
'''
Created on 29/04/2013
@author: belentwi
'''
from app import db
print "Eliminando tablas"
db.drop_all()
print "Tablas eliminadas" | Python |
from app import db
print "Creando tablas"
db.create_all()
print "Tablas creadas"
| Python |
'''
Created on 18/05/2013
@author: mirta
'''
from werkzeug import generate_password_hash
#from datetime import date
from app import db
from app.models.usuario import Usuario
#from app.models.entidad import Entidad
from app.models.permiso import Permiso
from app.models.rol import Rol
#from app.models.fase import Fase
#from app.models.tipoItem import TipoItem
#from app.models.proyecto import Proyecto
#from app.models.item import Item
#from app.models.atributo import Atributo
#from app.models.linea_base import LineaBase
#from app.models.historial_lb import HistorialLineaBase
print "Cargando datos"
######################################
## Creacion de permisos por defecto###
######################################
per_1 = Permiso('CREAR_USUARIO',None, None)
db.session.add(per_1)
db.session.commit()
per_2 = Permiso('MODIFICAR_USUARIO',None, None)
db.session.add(per_2)
db.session.commit()
per_3 = Permiso('DESACTIVAR_USUARIO',None, None)
db.session.add(per_3)
db.session.commit()
per_4 = Permiso('VER_USUARIO',None, None)
db.session.add(per_4)
db.session.commit()
per_5 = Permiso('CREAR_ROL',None, None)
db.session.add(per_5)
db.session.commit()
per_6 = Permiso('MODIFICAR_ROL',None, None)
db.session.add(per_6)
db.session.commit()
per_7 = Permiso('ELIMINAR_ROL',None, None)
db.session.add(per_7)
db.session.commit()
per_8 = Permiso('VER_ROL',None, None)
db.session.add(per_8)
db.session.commit()
per_9 = Permiso('CREAR_PERMISO',None, None)
db.session.add(per_9)
db.session.commit()
per_10 = Permiso('ELIMINAR_PERMISO',None, None)
db.session.add(per_10)
db.session.commit()
per_15 = Permiso('ACTIVAR_USUARIO',None, None)
db.session.add(per_15)
db.session.commit()
per_16 = Permiso('ADMINISTRACION_USUARIOS',None, None)
db.session.add(per_16)
db.session.commit()
per_17 = Permiso('ADMINISTRACION_ENTIDADES',None, None)
db.session.add(per_17)
db.session.commit()
per_18 = Permiso('ADMINISTRACION_ROLES',None, None)
db.session.add(per_18)
db.session.commit()
per_19 = Permiso('ADMINISTRACION_PROYECTOS',None, None)
db.session.add(per_19)
db.session.commit()
per_20 = Permiso('ADMINISTRACION_FASES',None, None)
db.session.add(per_20)
db.session.commit()
per_21 = Permiso('ADMINISTRACION_PERMISOS',None, None)
db.session.add(per_21)
db.session.commit()
per_22 = Permiso('CREAR_PROYECTO',None, None)
db.session.add(per_22)
db.session.commit()
per_41 = Permiso('ADMINISTRACION_RELACIONES', None, None)
db.session.add(per_41)
db.session.commit()
per_42 = Permiso('ADMINISTRACION_ATRIBUTOS',None, None)
db.session.add(per_42)
db.session.commit()
per_43 = Permiso('CREAR_ATRIBUTO',None, None)
db.session.add(per_43)
db.session.commit()
per_44 = Permiso('ELIMINAR_ATRIBUTO',None, None)
db.session.add(per_44)
db.session.commit()
per_45 = Permiso('ADMINISTRACION_ITEMS',None, None)
db.session.add(per_45)
db.session.commit()
per_46 = Permiso('ADMINISTRACION_TIPOITEMS', None, None)
db.session.add(per_46)
db.session.commit()
per_47 = Permiso('CREAR_TIPOITEM',None, None)
db.session.add(per_47)
db.session.commit()
per_48 = Permiso('MODIFICAR_TIPOITEM',None, None)
db.session.add(per_48)
db.session.commit()
per_49 = Permiso('ELIMINAR_TIPOITEM',None, None)
db.session.add(per_49)
db.session.commit()
per_50 = Permiso('VER_TIPOITEM',None, None)
db.session.add(per_50)
db.session.commit()
per_51 = Permiso('MODIFICAR_PERMISO',None, None)
db.session.add(per_51)
db.session.commit()
per_52 = Permiso('VER_PERMISO',None, None)
db.session.add(per_52)
db.session.commit()
per_53 = Permiso('ADMINISTRACION_LINEAS_BASE',None, None)
db.session.add(per_53)
db.session.commit()
per_69 = Permiso('MODIFICAR_ATRIBUTO',None, None)
db.session.add(per_69)
db.session.commit()
per_70 = Permiso('CONSULTAR_ATRIBUTO',None, None)
db.session.add(per_70)
db.session.commit()
per_71 = Permiso('ADMINISTRACION_SOLICITUDES',None, None)
db.session.add(per_71)
db.session.commit()
Lista3 = [per_1, per_2, per_3, per_4, per_5, per_6, per_7, per_8, per_9, per_10, per_15, per_16, per_17, per_18, per_19, per_21, per_22, per_42, per_43, per_44, per_51, per_52]
rol3 = Rol('Administrador de Sistema', 'Rol por defecto del sistema', Lista3)
db.session.add(rol3)
db.session.commit()
Lista4 = [per_19,per_20, per_46, per_47, per_48, per_49, per_50]
rol4 = Rol('Lider Proyecto', 'Rol por defecto del sistema', Lista4)
db.session.add(rol4)
db.session.commit()
ListaUnica = [rol3]
usu = Usuario('admin', 'admin@admin.com', generate_password_hash('admin'), 'color?', 'azul','ACTIVO', ListaUnica)
db.session.add(usu)
db.session.commit()
print "Datos cargados" | Python |
from werkzeug import generate_password_hash
from datetime import date
from app import db
from app.models.usuario import Usuario
from app.models.entidad import Entidad
from app.models.permiso import Permiso
from app.models.rol import Rol
from app.models.fase import Fase
from app.models.tipoItem import TipoItem
from app.models.proyecto import Proyecto
from app.models.item import Item
from app.models.atributo import Atributo
from app.models.linea_base import LineaBase
from app.models.historial_lb import HistorialLineaBase
from app.models.solicitud_cambio import SolicitudCambio
from app.models.atributo_item import AtributoItem
from app.models.comite_de_cambio import ComiteDeCambio
from app.models.historial import Historial
print "Cargando datos"
######################################
###### Creacion de entidades##########
######################################
ent1 = Entidad('Proyecto 1')
db.session.add(ent1)
db.session.commit()
ent2 = Entidad('Proyecto 2')
db.session.add(ent2)
db.session.commit()
ent3 = Entidad('Fase 1 Proyecto 1')
db.session.add(ent3)
db.session.commit()
ent4 = Entidad('Fase 1 Proyecto 2')
db.session.add(ent4)
db.session.commit()
ent5 = Entidad('Proyecto 3')
db.session.add(ent5)
db.session.commit()
ent6 = Entidad('Proyecto 6')
db.session.add(ent6)
db.session.commit()
ent7 = Entidad('Fase 2 Proyecto 2')
db.session.add(ent7)
db.session.commit()
ent8 = Entidad('Fase 3 Proyecto 2')
db.session.add(ent8)
db.session.commit()
################################
# Entidad para probar linea base#
################################
ent9 = Entidad('Proyecto 4')
db.session.add(ent9)
db.session.commit()
ent10 = Entidad('Fase 1 Proyecto 4')
db.session.add(ent10)
db.session.commit()
ent11 = Entidad('Fase 2 Proyecto 4')
db.session.add(ent11)
db.session.commit()
ent12 = Entidad('Fase 3 Proyecto 4')
db.session.add(ent12)
db.session.commit()
ent13 = Entidad('Fase 4 Proyecto 4')
db.session.add(ent13)
db.session.commit()
ent14 = Entidad('Fase 1 Proyecto 3')
db.session.add(ent14)
db.session.commit()
ent15 = Entidad('Fase 2 Proyecto 3')
db.session.add(ent15)
db.session.commit()
ent_py = Entidad('Proyecto pyunit')
db.session.add(ent_py)
db.session.commit()
ent_py2 = Entidad('Fase 1 Proyecto pyunit')
db.session.add(ent_py2)
db.session.commit()
ent_py3 = Entidad('Fase 2 Proyecto pyunit')
db.session.add(ent_py3)
db.session.commit()
######################################
## Creacion de permisos por defecto###
######################################
per_1 = Permiso('CREAR_USUARIO', None, None)
db.session.add(per_1)
db.session.commit()
per_2 = Permiso('MODIFICAR_USUARIO', None, None)
db.session.add(per_2)
db.session.commit()
per_3 = Permiso('DESACTIVAR_USUARIO', None, None)
db.session.add(per_3)
db.session.commit()
per_4 = Permiso('VER_USUARIO', None, None)
db.session.add(per_4)
db.session.commit()
per_5 = Permiso('CREAR_ROL', None, None)
db.session.add(per_5)
db.session.commit()
per_6 = Permiso('MODIFICAR_ROL', None, None)
db.session.add(per_6)
db.session.commit()
per_7 = Permiso('ELIMINAR_ROL', None, None)
db.session.add(per_7)
db.session.commit()
per_8 = Permiso('VER_ROL', None, None)
db.session.add(per_8)
db.session.commit()
per_9 = Permiso('CREAR_PERMISO', None, None)
db.session.add(per_9)
db.session.commit()
per_10 = Permiso('ELIMINAR_PERMISO', None, None)
db.session.add(per_10)
db.session.commit()
per_15 = Permiso('ACTIVAR_USUARIO', None, None)
db.session.add(per_15)
db.session.commit()
per_16 = Permiso('ADMINISTRACION_USUARIOS', None, None)
db.session.add(per_16)
db.session.commit()
per_17 = Permiso('ADMINISTRACION_ENTIDADES', None, None)
db.session.add(per_17)
db.session.commit()
per_18 = Permiso('ADMINISTRACION_ROLES', None, None)
db.session.add(per_18)
db.session.commit()
per_19 = Permiso('ADMINISTRACION_PROYECTOS', None, None)
db.session.add(per_19)
db.session.commit()
per_20 = Permiso('ADMINISTRACION_FASES', None, None)
db.session.add(per_20)
db.session.commit()
per_21 = Permiso('ADMINISTRACION_PERMISOS', None, None)
db.session.add(per_21)
db.session.commit()
per_22 = Permiso('CREAR_PROYECTO', None, None)
db.session.add(per_22)
db.session.commit()
per_23 = Permiso('MODIFICAR', None, ent1)
db.session.add(per_23)
db.session.commit()
per_24 = Permiso('ELIMINAR', None, ent1)
db.session.add(per_24)
db.session.commit()
per_25 = Permiso('VER', None, ent1)
db.session.add(per_25)
db.session.commit()
per_26 = Permiso('MODIFICAR', None, ent2)
db.session.add(per_26)
db.session.commit()
per_27 = Permiso('ELIMINAR', None, ent2)
db.session.add(per_27)
db.session.commit()
per_28 = Permiso('VER', None, ent2)
db.session.add(per_28)
db.session.commit()
per_29 = Permiso('VER', None, ent3)
db.session.add(per_29)
db.session.commit()
per_30 = Permiso('MODIFICAR', None, ent3)
db.session.add(per_30)
db.session.commit()
per_31 = Permiso('ELIMINAR', None, ent3)
db.session.add(per_31)
db.session.commit()
per_32 = Permiso('VER', None, ent4)
db.session.add(per_32)
db.session.commit()
per_33 = Permiso('MODIFICAR', None, ent4)
db.session.add(per_33)
db.session.commit()
per_34 = Permiso('ELIMINAR', None, ent4)
db.session.add(per_34)
db.session.commit()
per_35 = Permiso('VER', None, ent7)
db.session.add(per_35)
db.session.commit()
per_36 = Permiso('MODIFICAR', None, ent7)
db.session.add(per_36)
db.session.commit()
per_37 = Permiso('ELIMINAR', None, ent7)
db.session.add(per_37)
db.session.commit()
per_38 = Permiso('VER', None, ent8)
db.session.add(per_38)
db.session.commit()
per_39 = Permiso('MODIFICAR', None, ent8)
db.session.add(per_39)
db.session.commit()
per_40 = Permiso('ELIMINAR', None, ent8)
db.session.add(per_40)
db.session.commit()
per_41 = Permiso('ADMINISTRACION_RELACIONES', None, None)
db.session.add(per_41)
db.session.commit()
per_42 = Permiso('ADMINISTRACION_ATRIBUTOS', None, None)
db.session.add(per_42)
db.session.commit()
per_43 = Permiso('CREAR_ATRIBUTO', None, None)
db.session.add(per_43)
db.session.commit()
per_44 = Permiso('ELIMINAR_ATRIBUTO', None, None)
db.session.add(per_44)
db.session.commit()
per_45 = Permiso('ADMINISTRACION_ITEMS', None, None)
db.session.add(per_45)
db.session.commit()
per_46 = Permiso('ADMINISTRACION_TIPOITEMS', None, None)
db.session.add(per_46)
db.session.commit()
per_47 = Permiso('CREAR_TIPOITEM', None, None)
db.session.add(per_47)
db.session.commit()
per_48 = Permiso('MODIFICAR_TIPOITEM', None, None)
db.session.add(per_48)
db.session.commit()
per_49 = Permiso('ELIMINAR_TIPOITEM', None, None)
db.session.add(per_49)
db.session.commit()
per_50 = Permiso('VER_TIPOITEM', None, None)
db.session.add(per_50)
db.session.commit()
per_51 = Permiso('MODIFICAR_PERMISO', None, None)
db.session.add(per_51)
db.session.commit()
per_52 = Permiso('VER_PERMISO', None, None)
db.session.add(per_52)
db.session.commit()
##################################
# Permisos para probar linea base#
##################################
per_53 = Permiso('ADMINISTRACION_LINEAS_BASE', None, None)
db.session.add(per_53)
db.session.commit()
per_54 = Permiso('VER', None, ent9)
db.session.add(per_54)
db.session.commit()
per_55 = Permiso('MODIFICAR', None, ent9)
db.session.add(per_55)
db.session.commit()
per_56 = Permiso('ELIMINAR', None, ent9)
db.session.add(per_56)
db.session.commit()
per_57 = Permiso('VER', None, ent10)
db.session.add(per_57)
db.session.commit()
per_58 = Permiso('MODIFICAR', None, ent10)
db.session.add(per_58)
db.session.commit()
per_59 = Permiso('ELIMINAR', None, ent10)
db.session.add(per_59)
db.session.commit()
per_60 = Permiso('VER', None, ent11)
db.session.add(per_60)
db.session.commit()
per_61 = Permiso('MODIFICAR', None, ent11)
db.session.add(per_61)
db.session.commit()
per_62 = Permiso('ELIMINAR', None, ent11)
db.session.add(per_62)
db.session.commit()
per_63 = Permiso('VER', None, ent12)
db.session.add(per_63)
db.session.commit()
per_64 = Permiso('MODIFICAR', None, ent12)
db.session.add(per_64)
db.session.commit()
per_65 = Permiso('ELIMINAR', None, ent12)
db.session.add(per_65)
db.session.commit()
per_66 = Permiso('VER', None, ent13)
db.session.add(per_66)
db.session.commit()
per_67 = Permiso('MODIFICAR', None, ent13)
db.session.add(per_67)
db.session.commit()
per_68 = Permiso('ELIMINAR', None, ent13)
db.session.add(per_68)
db.session.commit()
per_69 = Permiso('MODIFICAR_ATRIBUTO', None, None)
db.session.add(per_69)
db.session.commit()
per_70 = Permiso('CONSULTAR_ATRIBUTO', None, None)
db.session.add(per_70)
db.session.commit()
per_71 = Permiso('ADMINISTRACION_SOLICITUDES', None, None)
db.session.add(per_71)
db.session.commit()
per_72 = Permiso('MODIFICAR', None, ent5)
db.session.add(per_72)
db.session.commit()
per_73 = Permiso('VER', None, ent14)
db.session.add(per_73)
db.session.commit()
per_74 = Permiso('MODIFICAR', None, ent14)
db.session.add(per_74)
db.session.commit()
per_75 = Permiso('ELIMINAR', None, ent14)
db.session.add(per_75)
db.session.commit()
per_76 = Permiso('VER', None, ent15)
db.session.add(per_73)
db.session.commit()
per_77 = Permiso('MODIFICAR', None, ent15)
db.session.add(per_74)
db.session.commit()
per_78 = Permiso('ELIMINAR', None, ent15)
db.session.add(per_75)
db.session.commit()
# Permisos para pruebas d epyunit
per_py = Permiso('VER', None, ent_py)
db.session.add(per_py)
db.session.commit()
per_py2 = Permiso('MODIFICAR', None, ent_py)
db.session.add(per_py2)
db.session.commit()
per_py3 = Permiso('ELIMINAR', None, ent_py)
db.session.add(per_py3)
db.session.commit()
per_py4 = Permiso('VER', None, ent_py2)
db.session.add(per_py4)
db.session.commit()
per_py5 = Permiso('MODIFICAR', None, ent_py2)
db.session.add(per_py5)
db.session.commit()
per_py6 = Permiso('ELIMINAR', None, ent_py2)
db.session.add(per_py6)
db.session.commit()
per_py7 = Permiso('VER', None, ent_py3)
db.session.add(per_py7)
db.session.commit()
per_py8 = Permiso('MODIFICAR', None, ent_py3)
db.session.add(per_py8)
db.session.commit()
per_py9 = Permiso('ELIMINAR', None, ent_py3)
db.session.add(per_py9)
db.session.commit()
#===============================================================================
# per_22 = Permiso('MODIFICAR', ent1)
# db.session.add(per_22)
# db.session.commit()
#===============================================================================
######################################
# Creacion de permisos sobre entidades#
######################################
#===============================================================================
# per_11 = Permiso('Permiso_1', ent1)
# db.session.add(per_11)
# db.session.commit()
#
# per_12 = Permiso('Permiso_2', ent2)
# db.session.add(per_12)
# db.session.commit()
#
# per_13 = Permiso('Permiso_3', ent3)
# db.session.add(per_13)
# db.session.commit()
#
# per_14 = Permiso('Permiso_4', ent4)
# db.session.add(per_14)
# db.session.commit()
#===============================================================================
######################################
########## Creacion de roles##########
######################################
#===============================================================================
# Lista1 =[per_14, per_11]
# rol1 = Rol('Rol1','Descripcion1', Lista1)
# db.session.add(rol1)
# db.session.commit()
#
# Lista2 = [per_13]
# rol2 = Rol('Rol2','Descripcion2', Lista2)
# db.session.add(rol2)
# db.session.commit()
#===============================================================================
Lista1 = [per_26, per_27, per_19, per_20, per_32, per_33, per_34, per_36, per_38, per_39, per_40, per_41 ]
rol1 = Rol('Rol de Proyecto 2', 'Descripcion2', Lista1)
db.session.add(rol1)
db.session.commit()
Lista2 = [per_23, per_19, per_20, per_29, per_30, per_31, per_45, per_71]
rol2 = Rol('Rol de Proyecto 1', 'Descripcion2', Lista2)
db.session.add(rol2)
db.session.commit()
# rol2 = Rol('Rol2','Descripcion2', Lista2)
# db.session.add(rol2)
# db.session.commit()
######################################
### Creacion de roles por defecto#####
######################################
Lista3 = [per_1, per_2, per_3, per_4, per_5, per_6, per_7, per_8, per_9, per_10, per_15, per_16, per_17, per_18, per_19, per_21, per_22, per_42, per_43, per_44, per_51, per_52, per_69, per_70]
rol3 = Rol('Administrador de Sistema', 'Rol por defecto del sistema', Lista3)
db.session.add(rol3)
db.session.commit()
Lista4 = [per_19, per_20, per_38, per_46, per_47, per_48, per_49, per_50, per_72, per_73, per_74, per_75, per_76, per_77, per_78]
rol4 = Rol('Lider Proyecto', 'Rol por defecto del sistema', Lista4)
db.session.add(rol4)
db.session.commit()
#############################
# Rol para probar linea base#
#############################
Lista5 = [per_53]
rol5 = Rol('Administrador de Linea Base', 'Creacion, eliminacion y consulta', Lista5)
db.session.add(rol5)
db.session.commit()
Lista6 = [per_54, per_55, per_56, per_57, per_58, per_59, per_60, per_61, per_62, per_63, per_64, per_65, per_66, per_67, per_68, per_45]
rol6 = Rol('Encargado del Proyecto 4', 'Adm. Proyecto 4 y sus fases', Lista6)
db.session.add(rol6)
db.session.commit()
############################
## Rol para pyunit##########
############################
lista_py = [per_19, per_20, per_py, per_py2, per_py3, per_py4, per_py5, per_py6, per_py7, per_py8, per_py9, per_45, per_46, per_71, per_41, per_53]
rol_py = Rol('Rol para prueba de pyunit', 'Adm Proyecto pyunit', lista_py)
db.session.add(rol_py)
db.session.commit()
#===============================================================================
#
# Lista4 = [per_22]
# rol4 = Rol('Prueba de Seguridad', 'Rol creado para probar permisos', Lista4)
# db.session.add(rol4)
# db.session.commit()
#===============================================================================
######################################
######## Creacion de usuarios ########
######################################
ListaUnica = [rol3]
usu = Usuario('admin', 'admin@admin.com', generate_password_hash('admin'), 'color?', 'azul', 'ACTIVO', ListaUnica)
db.session.add(usu)
db.session.commit()
Lista5 = [rol1, rol4, rol5, rol6]
usu1 = Usuario('usu_1', 'usu_1@usu_1.com', generate_password_hash('usu_1'), 'dia?', 'sabado', 'ACTIVO', Lista5)
db.session.add(usu1)
db.session.commit()
Lista5 = [rol2]
usu2 = Usuario('usu_2', 'usu_2@usu_2.com', generate_password_hash('usu_2'), 'dia?', 'lunes', 'ACTIVO', Lista5)
db.session.add(usu2)
db.session.commit()
Lista5 = [rol2, rol1, rol4]
usu3 = Usuario('usu_3', 'usu_3@usu_3.com', generate_password_hash('usu_3'), 'dia?', 'martes', 'ACTIVO', Lista5)
db.session.add(usu3)
db.session.commit()
Lista5 = [rol2, rol1]
usu4 = Usuario('usu_4', 'usu_4@usu_4.com', generate_password_hash('usu_4'), 'dia?', 'martes', 'ACTIVO', Lista5)
db.session.add(usu3)
db.session.commit()
#################################
# # usuario para prueba de pyunit#
#################################
Lista_py = [rol_py]
usu_py = Usuario('testpy', 'testpy@testpy.com', generate_password_hash('testpy'), 'dia?', 'martes', 'ACTIVO', Lista_py)
db.session.add(usu_py)
db.session.commit()
#################################
# comite de cambio para pyunit###
#################################
miembros = [usu_py]
comite_py = ComiteDeCambio(miembros=miembros, observacion = 'comite pyunit', cantidad_miembros='1')
db.session.add(comite_py)
db.session.commit()
#===============================================================================
# Lista6 = [rol2]
# usu2 = Usuario('prueba', 'prueba@prueba.com', generate_password_hash('prueba'), 'dia?','sabado', 'ACTIVO', Lista6)
# db.session.add(usu2)
# db.session.commit()
#
# Lista7 = [rol1, rol2]
# usu3 = Usuario('aux', 'aux@aux.com', generate_password_hash('aux'), 'estacion?', 'verano','ACTIVO', Lista7)
# db.session.add(usu3)
# db.session.commit()
#===============================================================================
######################################
######## Creacion de proyectos #######
######################################
Lista = [usu2, usu3]
proyecto1 = Proyecto(nombre='Proyecto 1', estado='Activo', lider=usu1, entidad=ent1, miembros=Lista)
db.session.add(proyecto1)
db.session.commit()
Lista = [usu1, usu3]
proyecto2 = Proyecto(nombre='Proyecto 2', estado='Activo', lider=usu1 , entidad=ent2, miembros=Lista)
db.session.add(proyecto2)
db.session.commit()
Lista = [usu1, usu2, usu3]
proyecto3 = Proyecto(nombre='Proyecto 3', estado='Pendiente', lider=usu3, entidad=ent5, miembros=Lista)
db.session.add(proyecto3)
db.session.commit()
#################################
# Proyecto para probar linea base#
#################################
Lista = [usu1, usu2, usu3, usu4]
proyecto4 = Proyecto(nombre='Proyecto 4', estado='Activo', lider=usu1, entidad=ent9, miembros=Lista)
db.session.add(proyecto4)
db.session.commit()
###########################
# Proyecto para pyunit#####
###########################
Lista = [usu_py]
proyecto_py = Proyecto(nombre='Proyecto pyunit', estado='Pendiente', lider=usu_py, entidad=ent_py, miembros=Lista)
db.session.add(proyecto_py)
db.session.commit()
# proyecto3 = Proyecto('Proyecto3', 'Pendiente', 54, 80,miembros=[])
# db.session.add(proyecto3)
# db.session.commit()
#######################################
# Creacion de atributos
#######################################
atributo_1 = Atributo(nombre='Otro', tipo='String')
db.session.add(atributo_1)
db.session.commit()
atributo_2 = Atributo(nombre='Prueba', tipo='Integer')
db.session.add(atributo_2)
db.session.commit()
#######################################
# Creacion de fases
#######################################
fase1 = Fase(nombre='Fase 1', estado='Activa', posicion='1', proyecto=proyecto1, entidad=ent3)
db.session.add(fase1)
db.session.commit()
fase2 = Fase(nombre='Fase 1', estado='Activa', posicion='1', proyecto=proyecto2, entidad=ent4)
db.session.add(fase2)
db.session.commit()
fase3 = Fase(nombre='Fase 2', estado='Activa', posicion='2', proyecto=proyecto2, entidad=ent7)
db.session.add(fase3)
db.session.commit()
fase4 = Fase(nombre='Fase 3', estado='Pendiente', posicion='3', proyecto=proyecto2, entidad=ent8)
db.session.add(fase4)
db.session.commit()
######################################
#####Creacion de tipo de items #######
######################################
Lista = [atributo_1, atributo_2]
tipoI_1 = TipoItem(nombre='TipoItem_1', atributos=Lista, proyecto=proyecto1, fase=fase1)
db.session.add(tipoI_1)
db.session.commit()
Lista = [atributo_1]
tipoI_2 = TipoItem(nombre='TipoItem_1', atributos=Lista, proyecto=proyecto2, fase=fase2)
db.session.add(tipoI_2)
db.session.commit()
Lista = [atributo_2]
tipoI_3 = TipoItem(nombre='TipoItem_2', atributos=Lista, proyecto=proyecto2, fase=fase2)
db.session.add(tipoI_3)
db.session.commit()
Lista = [atributo_2]
tipoI_4 = TipoItem(nombre='TipoItem_3', atributos=Lista, proyecto=proyecto2, fase=fase3)
db.session.add(tipoI_4)
db.session.commit()
###############################
# Fases para probar linea base#
###############################
fase5 = Fase(nombre='Fase 1', estado='Activa', posicion='1', proyecto=proyecto4, entidad=ent10)
db.session.add(fase5)
db.session.commit()
Lista = [atributo_2]
tipoI_5 = TipoItem(nombre='TipoItem_5', atributos=Lista, proyecto=proyecto4, fase=fase5)
db.session.add(tipoI_5)
db.session.commit()
fase6 = Fase(nombre='Fase 2', estado='Activa', posicion='2', proyecto=proyecto4, entidad=ent11)
db.session.add(fase6)
db.session.commit()
Lista = [atributo_2]
tipoI_6 = TipoItem(nombre='TipoItem_6', atributos=Lista, proyecto=proyecto4, fase=fase6)
db.session.add(tipoI_6)
db.session.commit()
fase7 = Fase(nombre='Fase 3', estado='Activa', posicion='3', proyecto=proyecto4, entidad=ent12)
db.session.add(fase7)
db.session.commit()
Lista = [atributo_2]
tipoI_7 = TipoItem(nombre='TipoItem_7', atributos=Lista, proyecto=proyecto4, fase=fase7)
db.session.add(tipoI_7)
db.session.commit()
fase8 = Fase(nombre='Fase 4', estado='Activa', posicion='4', proyecto=proyecto4, entidad=ent13)
db.session.add(fase8)
db.session.commit()
Lista = [atributo_2]
tipoI_8 = TipoItem(nombre='TipoItem_8', atributos=Lista, proyecto=proyecto4, fase=fase8)
db.session.add(tipoI_8)
db.session.commit()
fase9 = Fase(nombre='Fase 1', estado='Pendiente', posicion='1', proyecto=proyecto3, entidad=ent14)
db.session.add(fase9)
db.session.commit()
Lista = [atributo_1, atributo_2]
tipoI_9 = TipoItem(nombre='TipoItem_9', atributos=Lista, proyecto=proyecto3, fase=fase9)
db.session.add(tipoI_9)
db.session.commit()
fase10 = Fase(nombre='Fase 2', estado='Pendiente', posicion='2', proyecto=proyecto3, entidad=ent15)
db.session.add(fase10)
db.session.commit()
#####################
# Fase para pyunit###
#####################
fase_py = Fase(nombre='Fase 1', estado='Pendiente', posicion='1', proyecto=proyecto_py, entidad=ent_py2)
db.session.add(fase_py)
db.session.commit()
Lista = [atributo_1, atributo_2]
tipoI_py = TipoItem(nombre='TipoItem_py1', atributos=Lista, proyecto=proyecto_py, fase=fase_py)
db.session.add(tipoI_py)
db.session.commit()
fase_py2 = Fase(nombre='Fase 2', estado='Pendiente', posicion='1', proyecto=proyecto_py, entidad=ent_py3)
db.session.add(fase_py2)
db.session.commit()
Lista = [atributo_1]
tipoI_py2 = TipoItem(nombre='TipoItem_py2', atributos=Lista, proyecto=proyecto_py, fase=fase_py2)
db.session.add(tipoI_py2)
db.session.commit()
#######################################
# Creacion de lineas base
#######################################
lb1 = LineaBase(nombre='LineaBase1', fase=fase2, estado='Abierta')
db.session.add(lb1)
db.session.commit()
h1 = HistorialLineaBase(id_lb=lb1.id, operacion='Creacion', usuario='Por defecto', fecha=date.today())
db.session.add(h1)
db.session.commit()
lb2 = LineaBase(nombre='LineaBase1', fase=fase5, estado='Abierta')
db.session.add(lb2)
db.session.commit()
h2 = HistorialLineaBase(id_lb=lb2.id, operacion='Creacion', usuario='Por defecto', fecha=date.today())
db.session.add(h2)
db.session.commit()
lb3 = LineaBase(nombre='LineaBase2', fase=fase6, estado='Abierta')
db.session.add(lb3)
db.session.commit()
h3 = HistorialLineaBase(id_lb=lb3.id, operacion='Creacion', usuario='Por defecto', fecha=date.today())
db.session.add(h3)
db.session.commit()
lb4 = LineaBase(nombre='LineaBase3', fase=fase7, estado='Abierta')
db.session.add(lb4)
db.session.commit()
h4 = HistorialLineaBase(id_lb=lb4.id, operacion='Creacion', usuario='Por defecto', fecha=date.today())
db.session.add(h4)
db.session.commit()
#############################
# Linea base para pyunit#####
#############################
lb_py = LineaBase(nombre='LineaBase pyunit', fase=fase_py2, estado='Abierta')
db.session.add(lb_py)
db.session.commit()
h_py = HistorialLineaBase(id_lb=lb_py.id, operacion='Creacion', usuario='Por defecto', fecha=date.today())
db.session.add(h_py)
db.session.commit()
#######################################
# Creacion de items
#######################################
item1 = Item(nombre='Item 1', fase=fase1, estado='Activo', version='1', tipo=tipoI_1)
db.session.add(item1)
db.session.commit()
item2 = Item(nombre='Item 2', estado='Bloqueado', fase=fase2, linea_base=lb1, version='1')
db.session.add(item2)
db.session.commit()
item3 = Item(nombre='Item 3', fase=fase3, estado='Activo', version='1', tipo=tipoI_4)
db.session.add(item3)
db.session.commit()
item4 = Item(nombre='Item 4', fase=fase1, estado='Activo', version='1', tipo=tipoI_1)
db.session.add(item4)
db.session.commit()
item5 = Item(nombre='Item 5', estado='Bloqueado' , fase=fase2, linea_base=lb1, version='1')
db.session.add(item5)
db.session.commit()
item6 = Item(nombre='Item 6', fase=fase3, estado='Activo', version='1', tipo=tipoI_4)
db.session.add(item6)
db.session.commit()
item13 = Item(nombre='Item 13', fase=fase1, estado='Bloqueado', version='1', complejidad='mucha', duracion='7 anhos', prioridad='Baja', observacion='item de prueba', fecha_creacion=date.today(), tipo=tipoI_1 , costo=444, descripcion='descripcion del item')
db.session.add(item13)
db.session.commit()
item13 = Item(nombre='Item 14', fase=fase1, estado='Bloqueado', version='1', complejidad='mucha', duracion='7 anhos', prioridad='Baja', observacion='item de prueba', fecha_creacion=date.today(), tipo=tipoI_5 , costo=444, descripcion='descripcion del item 14')
db.session.add(item13)
db.session.commit()
item13 = Item(nombre='Item 15', fase=fase1, estado='Activo', version='1', complejidad='mucha', duracion='7 anhos', prioridad='Baja', observacion='item de prueba', fecha_creacion=date.today(), tipo=tipoI_1 , costo=444, descripcion='descripcion del item 14')
db.session.add(item13)
db.session.commit()
atributoItem_1 = AtributoItem(item13.id, atributo_1.id, version='1', valor='atributo prueba 1')
db.session.add(atributoItem_1)
db.session.commit()
atributoItem_2 = AtributoItem(item13.id, atributo_2.id, version='1', valor='atributo prueba 2')
db.session.add(atributoItem_2)
db.session.commit()
atributoItem_3 = AtributoItem(item1.id, atributo_1.id, version='1', valor='atributo prueba 1')
db.session.add(atributoItem_1)
db.session.commit()
atributoItem_4 = AtributoItem(item4.id, atributo_2.id, version='1', valor='atributo prueba 2')
db.session.add(atributoItem_2)
db.session.commit()
################################
# # items para probar linea base#
################################
item7 = Item(nombre='Item 7', fase=fase8, estado='Aprobado', version='1')
db.session.add(item7)
db.session.commit()
item8 = Item(nombre='Item 8', fase=fase8, estado='Aprobado', version='1')
db.session.add(item8)
db.session.commit()
item9 = Item(nombre='Item 9', fase=fase8, estado='Aprobado', version='1')
db.session.add(item9)
db.session.commit()
item10 = Item(nombre='Item 10', fase=fase5, estado='Bloqueado', linea_base=lb2, version='1')
db.session.add(item10)
db.session.commit()
item11 = Item(nombre='Item 11', fase=fase6, estado='Bloqueado', linea_base=lb3, version='1', antecesor_id=item10.id)
db.session.add(item11)
db.session.commit()
item12 = Item(nombre='Item 12', fase=fase7, estado='Bloqueado', linea_base=lb4, version='1', antecesor_id=item11.id)
db.session.add(item12)
db.session.commit()
solCam1 = SolicitudCambio('monton!', 555555, 'VOTACION', 'la primera solicitud de cambio', [], None)
db.session.add(solCam1)
db.session.commit()
solCam2 = SolicitudCambio('poco', 111, 'VOTACION', 'la segunda solicitud de cambio', [], None)
db.session.add(solCam2)
db.session.commit()
###########################
# Items para pyunit########
###########################
atributo_py = Atributo(nombre='Atributo py', tipo='String')
db.session.add(atributo_py)
db.session.commit()
atributos_lista = [atributo_py]
tipo_py = TipoItem(nombre='Tipo Item pyunit', atributos=atributos_lista, proyecto=proyecto_py, fase=fase_py2)
db.session.add(tipo_py)
db.session.commit()
item_py = Item(nombre='Item pyunit', fase=fase_py2, estado='Activo', version='1', complejidad='mucha', duracion='1 anho', prioridad='Baja', observacion='item de pyunit', fecha_creacion=date.today(), tipo=tipo_py , costo=1000 , descripcion='descripcion del item 101')
db.session.add(item_py)
db.session.commit()
atributoItem_py = AtributoItem(item_py.id, atributo_py.id, version='1', valor='atributo prueba 1')
db.session.add(atributoItem_py)
db.session.commit()
item_py2 = Item(nombre='Item pyunit 2', fase=fase_py2, estado='Bloqueado', version='1', complejidad='mucha', duracion='1 anho', prioridad='Baja', observacion='item de pyunit', fecha_creacion=date.today(), tipo=tipo_py , costo=1000 , descripcion='descripcion del item 101', linea_base=lb_py)
db.session.add(item_py2)
db.session.commit()
atributoItem_py = AtributoItem(item_py2.id, atributo_py.id, version='1', valor='atributo prueba 1')
db.session.add(atributoItem_py)
db.session.commit()
#===============================================================================
# seccion Ana
#===============================================================================
ent_p1 = Entidad('Proyecto Uno')
db.session.add(ent_p1)
db.session.commit()
ent_p1_f1 = Entidad('Fase Uno Proyecto Uno')
db.session.add(ent_p1_f1)
db.session.commit()
ent_p1_f2 = Entidad('Fase Dos Proyecto Uno')
db.session.add(ent_p1_f2)
db.session.commit()
ent_p1_f3 = Entidad('Fase Tres Proyecto Uno')
db.session.add(ent_p1_f3)
db.session.commit()
per_100 = Permiso('MODIFICAR', None, ent_p1)
db.session.add(per_100)
db.session.commit()
per_101 = Permiso('MODIFICAR', None, ent_p1_f1)
db.session.add(per_101)
db.session.commit()
per_102 = Permiso('MODIFICAR', None, ent_p1_f2)
db.session.add(per_102)
db.session.commit()
per_103 = Permiso('MODIFICAR', None, ent_p1_f3)
db.session.add(per_103)
db.session.commit()
per_104 = Permiso('VER', None, ent_p1_f1)
db.session.add(per_104)
db.session.commit()
per_105 = Permiso('VER', None, ent_p1_f2)
db.session.add(per_105)
db.session.commit()
per_106 = Permiso('VER', None, ent_p1_f3)
db.session.add(per_106)
db.session.commit()
lista_permisos = [ per_19, per_20,per_42, per_43, per_44, per_45, per_53, per_69, per_71, per_70, per_100, per_101, per_102, per_103, per_104, per_105, per_106]
rol_101 = Rol('Rol Proyecto Uno', 'Permisos basicos de todos los miembros', lista_permisos)
db.session.add(rol_101)
db.session.commit()
roles_lista = [rol_101, rol4]
usu101 = Usuario('Ana', 'ana@ana.com', generate_password_hash('ana'), 'dia?', 'lunes', 'ACTIVO', roles_lista)
db.session.add(usu101)
db.session.commit()
roles_lista = [rol_101]
usu102 = Usuario('Mirta', 'mita@mirta.com', generate_password_hash('mirta'), 'dia?', 'martes', 'ACTIVO', roles_lista)
db.session.add(usu102)
db.session.commit()
roles_lista = [rol_101]
usu103 = Usuario('Monse', 'monse@monse.com', generate_password_hash('monse'), 'dia?', 'miercoles', 'ACTIVO', roles_lista)
db.session.add(usu103)
db.session.commit()
roles_lista = [rol_101]
usu104 = Usuario('Creador', 'Creador@Creador.com', generate_password_hash('creador'), 'dia?', 'jueves', 'ACTIVO', roles_lista)
db.session.add(usu104)
db.session.commit()
miembros_lista = [usu101, usu102, usu103]
comite_100 = ComiteDeCambio(observacion='Comite 100', miembros=miembros_lista, cantidad_miembros=3)
db.session.add(comite_100)
db.session.commit()
miembros = [usu101, usu102, usu103, usu104]
proyecto_100 = Proyecto(nombre='Proyecto Uno', estado='Activo', lider=usu101, entidad=ent_p1, miembros=miembros, comite=comite_100)
db.session.add(proyecto_100)
db.session.commit()
fase_101 = Fase(nombre='Fase Uno', estado='Activa', posicion='1', proyecto=proyecto_100, entidad=ent_p1_f1)
db.session.add(fase_101)
db.session.commit()
fase_102 = Fase(nombre='Fase Dos', estado='Activa', posicion='2', proyecto=proyecto_100, entidad=ent_p1_f2)
db.session.add(fase_102)
db.session.commit()
fase_103 = Fase(nombre='Fase Tres', estado='Activa', posicion='3', proyecto=proyecto_100, entidad=ent_p1_f3)
db.session.add(fase_103)
db.session.commit()
atributo_101 = Atributo(nombre='Atributo 1', tipo='String')
db.session.add(atributo_101)
db.session.commit()
atributo_102 = Atributo(nombre='Atributo 2', tipo='Integer')
db.session.add(atributo_102)
db.session.commit()
atributo_103 = Atributo(nombre='Atributo 3', tipo='String')
db.session.add(atributo_103)
db.session.commit()
atributo_104 = Atributo(nombre='Atributo 4', tipo='String')
db.session.add(atributo_104)
db.session.commit()
atributos_lista = [atributo_101, atributo_102]
tipo_101 = TipoItem(nombre='Tipo Item 101', atributos=atributos_lista, proyecto=proyecto_100, fase=fase_101)
db.session.add(tipo_101)
db.session.commit()
atributos_lista = [atributo_102, atributo_103]
tipo_102 = TipoItem(nombre='Tipo Item 102', atributos=atributos_lista, proyecto=proyecto_100, fase=fase_102)
db.session.add(tipo_102)
db.session.commit()
atributos_lista = [atributo_103, atributo_104]
tipo_103 = TipoItem(nombre='Tipo Item 103', atributos=atributos_lista, proyecto=proyecto_100, fase=fase_103)
db.session.add(tipo_103)
db.session.commit()
atributos_lista = [atributo_101, atributo_104]
tipo_104 = TipoItem(nombre='Tipo Item 104', atributos=atributos_lista, proyecto=proyecto_100, fase=fase_101)
db.session.add(tipo_104)
db.session.commit()
atributos_lista = [atributo_102, atributo_104]
tipo_105 = TipoItem(nombre='Tipo Item 105', atributos=atributos_lista, proyecto=proyecto_100, fase=fase_102)
db.session.add(tipo_105)
db.session.commit()
atributos_lista = [atributo_101, atributo_103]
tipo_106 = TipoItem(nombre='Tipo Item 106', atributos=atributos_lista, proyecto=proyecto_100, fase=fase_103)
db.session.add(tipo_106)
db.session.commit()
lb_101 = LineaBase(nombre='Linea Base 1', fase=fase_101, estado='Abierta')
db.session.add(lb_101)
db.session.commit()
lb_102 = LineaBase(nombre='Linea Base 2', fase=fase_102, estado='Abierta')
db.session.add(lb_102)
db.session.commit()
lb_103 = LineaBase(nombre='Linea Base 3', fase=fase_103, estado='Abierta')
db.session.add(lb_103)
db.session.commit()
item_101 = Item(nombre='Item Uno', fase=fase_101, estado='Bloqueado', version='1', complejidad='mucha', duracion='1 anho', prioridad='Baja', observacion='item de prueba 1', fecha_creacion=date.today(), tipo=tipo_101 , costo=1000 , descripcion='descripcion del item 101', linea_base=lb_101)
db.session.add(item_101)
db.session.commit()
atributoItem_101 = AtributoItem(item_101.id, atributo_101.id, version='1', valor='atributo prueba 1')
db.session.add(atributoItem_101)
db.session.commit()
atributoItem_102 = AtributoItem(item_101.id, atributo_102.id, version='1', valor='atributo prueba 2')
db.session.add(atributoItem_102)
db.session.commit()
item_102 = Item(nombre='Item Dos', fase=fase_101, estado='Bloqueado', version='1', complejidad='mucha', duracion='1 anho', prioridad='Baja', observacion='item de prueba 1', fecha_creacion=date.today(), tipo=tipo_104 , costo=2000 , descripcion='descripcion del item 102', linea_base=lb_101)
db.session.add(item_102)
db.session.commit()
atributoItem_103 = AtributoItem(item_102.id, atributo_101.id, version='1', valor='atributo prueba 3')
db.session.add(atributoItem_103)
db.session.commit()
atributoItem_104 = AtributoItem(item_102.id, atributo_104.id, version='1', valor='atributo prueba 4')
db.session.add(atributoItem_104)
db.session.commit()
item_103 = Item(nombre='Item Tres', fase=fase_102, estado='Bloqueado', version='1', complejidad='mucha', duracion='1 anho', prioridad='Baja', observacion='item de prueba 1', fecha_creacion=date.today(), tipo=tipo_102 , costo=3000 , descripcion='descripcion del item 103', linea_base=lb_102, antecesor_id=item_102.id)
db.session.add(item_103)
db.session.commit()
atributoItem_105 = AtributoItem(item_103.id, atributo_102.id, version='1', valor='atributo prueba 5')
db.session.add(atributoItem_105)
db.session.commit()
atributoItem_106 = AtributoItem(item_103.id, atributo_103.id, version='1', valor='atributo prueba 6')
db.session.add(atributoItem_106)
db.session.commit()
item_104 = Item(nombre='Item Cuatro', fase=fase_103, estado='Bloqueado', version='1', complejidad='mucha', duracion='1 anho', prioridad='Baja', observacion='item de prueba 1', fecha_creacion=date.today(), tipo=tipo_103 , costo=4000 , descripcion='descripcion del item 104', linea_base=lb_103, antecesor_id=item_103.id)
db.session.add(item_104)
db.session.commit()
atributoItem_107 = AtributoItem(item_104.id, atributo_103.id, version='1', valor='atributo prueba 5')
db.session.add(atributoItem_107)
db.session.commit()
atributoItem_108 = AtributoItem(item_104.id, atributo_104.id, version='1', valor='atributo prueba 6')
db.session.add(atributoItem_108)
db.session.commit()
items_cambio = [item_101, item_104]
solCam_100 = SolicitudCambio(impacto_total='', costo_total=0, estado='Activa', observacion='Solicitud 100', items=items_cambio, creador=usu104, proyecto=proyecto_100)
db.session.add(solCam_100)
db.session.commit()
print "Datos cargados"
| Python |
from app import app
#from subprocess import call
#call(["killall", "python", "-o 2s"])
if __name__ == '__main__':
app.run(debug=True)
| Python |
import os
_basedir = os.path.abspath(os.path.dirname(__file__))
DEBUG = False
ADMINS = frozenset(['youremail@yourdomain.com'])
SECRET_KEY = 'SecretKeyForSessionSigning'
SQLALCHEMY_DATABASE_URI = 'postgresql://postgres:postgres@localhost:5432/sap_db'
#SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(_basedir, 'app.db')
DATABASE_CONNECT_OPTIONS = {}
THREADS_PER_PAGE = 8
CSRF_ENABLED=False
CSRF_SESSION_KEY="somethingimpossibletoguess"
RECAPTCHA_USE_SSL = False
RECAPTCHA_PUBLIC_KEY = 'blahblahblahblahblahblahblahblahblah'
RECAPTCHA_PRIVATE_KEY = 'blahblahblahblahblahblahprivate'
RECAPTCHA_OPTIONS = {'theme': 'white'}
| Python |
import sys
sys.path.insert(0, '/home/mirta/workspace/fpuna-is2-sap/')
activate_this = '/home/mirta/flask/venv/bin/activate_this.py'
execfile(activate_this, dict(__file__=activate_this))
from app import app as application
| Python |
#!/usr/bin/python2.6
#
# Copyright 2011 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Build the ScriptCover Extension."""
__author__ = 'ekamenskaya@google.com (Ekaterina Kamenskaya)'
import logging
import optparse
import os
import shutil
import subprocess
import urllib
import zipfile
CHECKOUT_CLOSURE_COMMAND = ('svn checkout http://closure-library.googlecode.com'
'/svn/trunk/ closure-library')
CLOSURE_COMPILER_URL = ('http://closure-compiler.googlecode.com/files/'
'compiler-latest.zip')
SOY_COMPILER_URL = ('http://closure-templates.googlecode.com/files/'
'closure-templates-for-javascript-latest.zip')
COMPILE_CLOSURE_COMMAND = ' '.join(['python',
os.path.join('closure-library', 'closure',
'bin', 'build',
'closurebuilder.py'),
'--root=src',
'--root=closure-library',
'--root=build_gen',
'--output_mode=compiled',
'--output_file=%s',
'--compiler_jar=compiler.jar'])
SOY_COMPILER_COMMAND = ('java -jar SoyToJsSrcCompiler.jar'
' --shouldProvideRequireSoyNamespaces'
' --outputPathFormat %(output)s'
' %(file)s')
class ClosureError(Exception):
pass
def BuildClosureScript(input_filenames, output_filename):
"""Build a compiled closure script based on the given input file.
Args:
input_filenames: A sequence of strings representing names of the input
scripts to compile.
output_filename: A string representing the name of the output script.
Raises:
ClosureError: If closure fails to compile the given input file.
"""
input_opts = ' '.join('--input=%s' % fname for fname in input_filenames)
# Appends --input parameter to COMPILE_CLOSURE_COMMAND.
cmd = COMPILE_CLOSURE_COMMAND % output_filename + ' ' + input_opts
result = ExecuteCommand(cmd)
if result or not os.path.exists(output_filename):
raise ClosureError('Failed while compiling to %s.' % output_filename)
def BuildSoyJs(input_file):
"""Builds a javascript file from a soy file.
Args:
input_file: A path to the soy file to compile into JavaScript. The js file
will be stored in build_gen/{FILENAME}.soy.js
Raises:
ClosureError: If the soy compiler fails to compile.
"""
output_name = os.path.join('build_gen', '%s.js' % input_file)
result = ExecuteCommand(
SOY_COMPILER_COMMAND % {
'file': input_file,
'output': output_name})
if result or not os.path.exists(os.path.join(output_name)):
raise ClosureError('Failed while compiling the soy file %s.' % input_file)
def Clean():
if os.path.exists(os.path.join('clean')):
shutil.rmtree(os.path.join('build'))
if os.path.exists(os.path.join('build_gen')):
shutil.rmtree(os.path.join('build_gen'))
def ExecuteCommand(command):
"""Execute the given command and return the output.
Args:
command: A string representing the command to execute.
Returns:
The return code of the process.
"""
print 'Running command: %s' % command
process = subprocess.Popen(command.split(' '),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
results = process.communicate()
if process.returncode:
logging.error(results[1])
return process.returncode
def SetupClosure():
"""Setup the closure library and compiler.
Checkout the closure library using svn if it doesn't exist. Also, download
the closure compiler.
Raises:
ClosureError: If the setup fails.
"""
# Set up the svn repo for closure if it doesn't exist.
if not os.path.exists(os.path.join('closure-library')):
ExecuteCommand(CHECKOUT_CLOSURE_COMMAND)
if not os.path.exists(os.path.join('closure-library')):
logging.error(('Could not check out the closure library from svn. '
'Please check out the closure library to the '
'"closure-library" directory.'))
raise ClosureError('Could not set up the closure library.')
# Download the compiler jar if it doesn't exist.
if not os.path.exists(os.path.join('compiler.jar')):
(compiler_zip, _) = urllib.urlretrieve(CLOSURE_COMPILER_URL)
compiler_zipfile = zipfile.ZipFile(compiler_zip)
compiler_zipfile.extract(os.path.join('compiler.jar'))
if not os.path.exists(os.path.join('compiler.jar')):
logging.error('Could not download the closure compiler jar.')
raise ClosureError('Could not find the closure compiler.')
# Download the soy compiler jar if it doesn't exist.
if (not os.path.exists('SoyToJsSrcCompiler.jar') or
not os.path.exists(os.path.join('build_gen', 'soyutils_usegoog.js'))):
(soy_compiler_zip, _) = urllib.urlretrieve(SOY_COMPILER_URL)
soy_compiler_zipfile = zipfile.ZipFile(soy_compiler_zip)
soy_compiler_zipfile.extract('SoyToJsSrcCompiler.jar')
soy_compiler_zipfile.extract('soyutils_usegoog.js', 'build_gen')
if (not os.path.exists('SoyToJsSrcCompiler.jar') or
not os.path.exists(os.path.join('build_gen', 'soyutils_usegoog.js'))):
logging.error('Could not download the soy compiler jar.')
raise ClosureError('Could not find the soy compiler.')
def main():
usage = 'usage: %prog [options]'
parser = optparse.OptionParser(usage)
parser.add_option('--clean', dest='build_clean',
action='store_true', default=False,
help='Clean the build directories.')
options = parser.parse_args()[0]
if options.build_clean:
Clean()
exit()
# Set up the directories that will be built into.
if not os.path.exists(os.path.join('build')):
os.mkdir(os.path.join('build'))
if not os.path.exists(os.path.join('build_gen')):
os.mkdir(os.path.join('build_gen'))
# Get external Closure resources.
SetupClosure()
# Compile the closure scripts.
soy_files = ['coverage_report.soy', 'popup.soy']
for soy_filename in soy_files:
BuildSoyJs(os.path.join('src', soy_filename))
js_targets = [('content_compiled.js',
['scriptLoader.js', 'instrumentation.js', 'startTool.js']),
('background_compiled.js',
['showCoverageHelper.js', 'background.js']),
('inject_compiled.js', ['backgroundInteraction.js']),
('popup_compiled.js', ['popup.js', 'background.js'])]
for dest, sources in js_targets:
BuildClosureScript((os.path.join('src', src) for src in sources),
os.path.join('build', dest))
# Copy over the static resources
if os.path.exists(os.path.join('build', 'styles')):
shutil.rmtree(os.path.join('build', 'styles'))
shutil.copytree(os.path.join('src', 'styles'),
os.path.join('build', 'styles'))
if os.path.exists(os.path.join('build', 'third_party')):
shutil.rmtree(os.path.join('build', 'third_party'))
shutil.copytree(os.path.join('src', 'third_party'),
os.path.join('build', 'third_party'))
static_files = [os.path.join('src', 'popup.html'),
os.path.join('src', 'manifest.json'),
os.path.join('src', 'brticon.png')]
for static_file in static_files:
shutil.copy(static_file, 'build')
if __name__ == '__main__':
main()
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: initdb.py 265 2012-01-25 21:10:40Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/tools/initdb.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Aug 15, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 265 $'
import logging
import os
from core import runlevel
from core.bot import Bot
from core.persistence import SqlAlchemyPersistence
# Load all table definitions
import objects
if __name__ == '__main__':
config_root = os.environ['FPTBOT_CONFIG']
bot = Bot(root=config_root, level=logging.INFO)
bot.init(runlevel.LOCAL_SERVICE)
persistence = bot.get_subsystem('local-persistence')
base = SqlAlchemyPersistence.Base
base.metadata.create_all(persistence.engine)
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: config.py 261 2012-01-25 00:11:47Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/tools/config.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Mar 16, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 261 $'
import logging
import argparse
import os
from core import runlevel
from core.bot import Bot
def parseargs():
parser = argparse.ArgumentParser(prog='config', description='manipulate the bot configuration')
subparser = parser.add_subparsers()
cmd_init = subparser.add_parser('init', help='init --help', description='initialize configuration with default values. when no id is given, all known configurations will be initialized.')
cmd_init.set_defaults(func=config_init)
cmd_init.add_argument('--id', dest='identifier', help='only initialize the specified configuration')
cmd_read = subparser.add_parser('read', help='read --help')
cmd_read.set_defaults(func=config_read)
cmd_read.add_argument(dest='identifier', help='the configuration identifier')
cmd_read.add_argument('--key', dest='key', help='the configuration key to change')
cmd_write = subparser.add_parser('write', help='write --help')
cmd_write.set_defaults(func=config_write)
cmd_write.add_argument(dest='identifier', help='the configuration identifier')
cmd_write.add_argument(dest='key', help='the configuration key to change')
cmd_write.add_argument(dest='type', help='the data type', choices=['int', 'bool', 'string', 'list'])
cmd_write.add_argument(dest='value', help='the new value', nargs='+')
args = parser.parse_args()
args.func(args)
def config_init(args):
config_root = os.environ['FPTBOT_CONFIG']
bot = Bot(root=config_root, level=logging.INFO)
bot.init(runlevel.LOCAL_FILESYSTEM)
logger = logging.getLogger('tools.config')
def _init(identifier, object):
logger.info('initializing configuration: %s', identifier)
object.init(object.default_values())
object.save()
if args.identifier is None:
for (identifier, object) in bot.get_configs().items():
_init(identifier, object)
else:
identifier = args.identifier
try:
object = bot.get_config(identifier)
_init(identifier, object)
except KeyError:
logger.critical('invalid identifier: %s', identifier)
bot.init(runlevel.HALT)
def config_read(args):
config_root = os.environ['FPTBOT_CONFIG']
bot = Bot(root=config_root, level=logging.INFO)
bot.init(runlevel.LOCAL_FILESYSTEM)
logger = logging.getLogger('tools.config')
identifier = args.identifier
def _read(identifier, key, value, padding=0):
print "{}.{} {}= '{}' ({})".format(identifier, key, ' ' * padding, value, type(value))
try:
object = bot.get_config(identifier)
except KeyError:
logger.critical('invalid identifier: %s', identifier)
return
if(args.key is None):
spacelist = [len(item) for item in object.get_all().keys()]
if spacelist:
space = max(spacelist)
else:
space = 0
for (key, value) in object.get_all().items():
_read(identifier, key, value, (space - len(key)))
else:
try:
key = args.key
value = object.get(key)
except KeyError:
logger.critical('invalid key: %s', key)
return
_read(identifier, key, value)
bot.init(runlevel.HALT)
def config_write(args):
config_root = os.environ['FPTBOT_CONFIG']
bot = Bot(root=config_root, level=logging.INFO)
bot.init(runlevel.LOCAL_FILESYSTEM)
logger = logging.getLogger('tools.config')
identifier = args.identifier
key = args.key
type = args.type
value = args.value
try:
object = bot.get_config(identifier)
except KeyError:
logger.critical('invalid identifier: %s', identifier)
if key not in object.valid_keys():
logger.critical('invalid key: %s', key)
return
value = ' '.join(value)
if type == 'int':
new_value = int(value)
elif type == 'bool':
new_value = bool(value)
elif type == 'list':
new_value = value.split(',')
else:
new_value = value
object.set(key, new_value)
object.save()
logger.info('%s.%s set to %s', identifier, key, new_value)
bot.init(runlevel.HALT)
if __name__ == '__main__':
parseargs()
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: events.py 286 2012-05-31 17:26:15Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/tools/dataloader/events.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Sep 29, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 286 $'
import datetime
from core import runlevel
from core.bot import Bot
from objects.calendar import Calendar, Event
from components.calendar import LocalUserAuthority
from tools import dataloader
if __name__ == '__main__':
bot = Bot()
bot.register_subsystem('sqlite-persistence', 'core.persistence.SqlitePersistence', sqlite_file=dataloader.Parameters.source)
bot.init(runlevel.NETWORK_SERVICE)
sqlite = bot.get_subsystem('sqlite-persistence')
cursor = sqlite.get_cursor()
calendar = bot.get_subsystem('calendar-component')
logger = bot.get_logger('tools.import.contacts')
calendar_references = {}
for category in dataloader.get_categories(cursor, dataloader.Parameters.event_categories):
newCalendar = Calendar()
newCalendar.title = category['Name']
newCalendar.color = category['Color'][1:]
newCalendar.location = dataloader.Parameters.default_location
newCalendar.authority = LocalUserAuthority.NAME
logger.info('adding item: %s', newCalendar)
calendar_references[category['CatID']] = newCalendar
calendar.insert_object(newCalendar)
one = True
for event in dataloader.get_events(cursor, dataloader.Parameters.event_categories):
newEvent = Event()
newEvent.calendar = calendar_references[event['CatID']]
newEvent.title = event['Name']
newEvent.start = datetime.datetime.strptime(event['Date_B'], '%Y-%m-%d')
newEvent.end = datetime.datetime.strptime(event['Date_B'], '%Y-%m-%d')
newEvent.allday = True
logger.info('adding item: %s in calendar %s', newEvent, newEvent.calendar)
calendar.insert_object(newEvent)
bot.init(runlevel.HALT)
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: contacts.py 286 2012-05-31 17:26:15Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/tools/dataloader/contacts.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Sep 29, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 286 $'
import datetime
from core import runlevel
from core.bot import Bot
from objects.calendar import Calendar, Contact
from tools import dataloader
from components.calendar import LocalBirthdayAuthority
if __name__ == '__main__':
bot = Bot()
bot.register_subsystem('sqlite-persistence', 'core.persistence.SqlitePersistence', sqlite_file=dataloader.Parameters.source)
bot.init(runlevel.LOCAL_SERVICE)
bot.start_subsystem('sqlite-persistence')
sqlite = bot.get_subsystem('sqlite-persistence')
calendar = bot.get_subsystem('calendar-component')
logger = bot.get_logger('tools.import.contacts')
contacts_to_insert = []
calendar_to_insert = []
for event in dataloader.get_events(sqlite.get_cursor(), [dataloader.Parameters.birthday_category]):
contact = Contact()
contact.nickname = event['Name']
contact.birthday = datetime.datetime.strptime(event['Date_B'], '%Y-%m-%d')
logger.info('adding item: %s', contact)
#calendar.insert_object(contact)
for category in dataloader.get_categories(sqlite.get_cursor(), [dataloader.Parameters.birthday_category]):
calendar = Calendar()
calendar.title = category['Name']
calendar.color = category['Color'][1:]
calendar.location = dataloader.Parameters.default_location
calendar.authority = LocalBirthdayAuthority.NAME
logger.info('added item: %s', calendar)
#calendar.insert_object(contact)
bot.init(runlevel.HALT)
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: __init__.py 286 2012-05-31 17:26:15Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/tools/dataloader/__init__.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Sep 29, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 286 $'
class Parameters(object):
birthday_category = 1
birthday_authority = '/local/birthday'
event_categories = [2, 13]
event_authority = '/local/user'
default_location = u'Düsseldorf, Germany'
source = '/Users/msteinhoff/Work/Eclipse/projects/foption/bot/data/sqlite/legacy.db'
def get_categories(cursor, category_ids):
query = 'SELECT CatID, UserId, Name, Color FROM CATEGORY WHERE CatID IN ({seq})'.format(seq=','.join(['?']*len(category_ids)))
cursor.execute(query, category_ids)
return cursor.fetchall()
def get_events(cursor, category_ids):
query = 'SELECT ID, UserID, CatID, Name, Date_B FROM CALENDAR WHERE CatID IN ({seq})'.format(seq=','.join(['?']*len(category_ids)))
cursor.execute(query, category_ids)
return cursor.fetchall()
| Python |
# -*- coding: UTF-8 -*-
"""
$Id$
$URL$
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 16, 2012
@author Mario Steinhoff
"""
__all__ = [
]
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: cleandb.py 268 2012-02-01 22:56:11Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/tools/cleandb.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Aug 15, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 268 $'
import logging
import os
from core import runlevel
from core.bot import Bot
from core.persistence import SqlAlchemyPersistence
# Load all table definitions
import objects
if __name__ == '__main__':
config_root = os.environ['FPTBOT_CONFIG']
bot = Bot(root=config_root, level=logging.INFO)
bot.init(runlevel.LOCAL_SERVICE)
persistence = bot.get_subsystem('local-persistence')
base = SqlAlchemyPersistence.Base
base.metadata.drop_all(persistence.engine)
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: calendar.py 264 2012-01-25 00:18:36Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/components/calendar.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Mar 12, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 264 $'
import logging
import datetime
import time
import json
import sqlalchemy.orm.exc
import atom.data
import gdata.calendar.data
import gdata.contacts.data
from core import runlevel
from core.config import Config
from core.component import Component, ComponentError
from objects.calendar import Calendar, Event, Contact, Backend,\
CalendarPeerIdentity, EventPeerIdentity, ContactPeerIdentity
# ------------------------------------------------------------------------------
# Exceptions
# ------------------------------------------------------------------------------
class CalendarComponentError(ComponentError): pass
class InvalidObjectId(CalendarComponentError): pass
# ------------------------------------------------------------------------------
# Business Logic
# ------------------------------------------------------------------------------
class CalendarComponent(Component):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.LOCAL_COMPONENT
)
def __init__(self, bot):
Component.__init__(self, bot)
self.bot.register_config(CalendarComponentConfig)
self.logger = logging.getLogger('components.calendar')
self.config = self.bot.get_config('components.calendar')
self.datastore = None
# --------------------------------------------------------------------------
# Lifecycle
# --------------------------------------------------------------------------
def _start(self):
"""
Startup the component and background services (DataStore, Backends).
Implementation of Subsystem.start()
"""
datastore = DataStore(DataStoreOneWaySync)
# Setup primary backend
sqlite = SqlAlchemyBackend(datastore, self.bot.get_subsystem('local-persistence'))
datastore.set_primary_backend(sqlite)
# Setup secondary backend
google = GoogleBackend(datastore, self.bot.get_subsystem('google-api-service'))
datastore.register_secondary_backend(google)
datastore.register_authority(SystemAllowAuthority(), default=True)
datastore.register_authority(SystemDenyAuthority())
datastore.register_authority(LocalUserAuthority())
datastore.register_authority(LocalBirthdayAuthority())
self.datastore = datastore
self._running()
def _stop(self):
"""
Shutdown the component and background services (DataStore, Backends).
Implementation of Subsystem.stop()
"""
self.datastore = None
self._halted()
# --------------------------------------------------------------------------
# Component methods: global
# --------------------------------------------------------------------------
def insert_object(self, object):
if object is None:
raise ValueError('object must be given')
if object.id is not None:
raise ValueError('object.id must be None')
result = self.datastore.insert_object(
self.__class__.__name__,
object
)
return result
def update_object(self, object):
if object is None:
raise ValueError('object must be given')
if object.id is None:
raise ValueError('object.id must be given')
self.datastore.update_object(
self.__class__.__name__,
object
)
def delete_object(self, object):
if object is None:
raise ValueError('object must be given')
if object.id is None:
raise ValueError('object.id must be given')
self.datastore.delete_object(
self.__class__.__name__,
object
)
# --------------------------------------------------------------------------
# Component methods: calendars
# --------------------------------------------------------------------------
def find_all_calendars(self):
query = self.datastore.get_query('all_calendars')
return self.datastore.find_objects(query)
def find_default_calendar(self):
default_id = self.config.get('defaultCalendarId')
calendar = self.find_calendar_by_id(default_id)
return calendar
def find_calendar_by_id(self, id):
if id is None:
return None
query = self.datastore.get_query('calendar_by_id')
query.id = id
return self.datastore.find_objects(query)
def find_calendars_by_string(self, string):
if string is None:
return None
query = self.datastore.get_query('calendars_by_string')
query.string = string
return self.datastore.find_objects(query)
# --------------------------------------------------------------------------
# Component methods: events
# --------------------------------------------------------------------------
def find_all_events(self):
query = self.datastore.get_query('all_events')
return self.datastore.find_objects(query)
def find_event_by_id(self, id):
if id is None:
return None
query = self.datastore.get_query('event_by_id')
query.id = id
return self.datastore.find_objects(query)
def find_events_by_string(self, string):
if string is None:
return None
query = self.datastore.get_query('events_by_string')
query.string = string
return self.datastore.find_objects(query)
def find_events_at_date(self, date):
if date is None:
return None
query = self.datastore.get_query('events_at_date')
query.date = date
return self.datastore.find_objects(query)
# --------------------------------------------------------------------------
# Component methods: contacts
# --------------------------------------------------------------------------
def find_all_contacts(self):
query = self.datastore.get_query('all_contacts')
return self.datastore.find_objects(query)
def find_contact_by_id(self, id):
if id is None:
return None
query = self.datastore.get_query('contacts_by_id')
query.id = id
return self.datastore.find_objects(query)
def find_contacts_by_string(self, string):
if string is None:
return None
query = self.datastore.get_query('contacts_by_string')
query.string = string
return self.datastore.find_objects(query)
class CalendarComponentConfig(Config):
identifier = 'components.calendar'
def valid_keys(self):
return [
'defaultCalendarId'
]
def default_values(self):
return {
'defaultCalendarId' : None
}
# ------------------------------------------------------------------------------
# Data management
# ------------------------------------------------------------------------------
class DataStoreError(CalendarComponentError): pass
class InvalidQueryName(DataStoreError): pass
class DataStore():
"""
The calendar data store.
The data store manages all backend systems and data synchronization
between the primary and secondary backends.
"""
def __init__(self, strategy):
"""
Initialize the datastore.
@param: Class pointer to the sync strategy implementation to use.
"""
self.primary_backend = None
self.authorities = {}
self.defaulf_authority = None
self.secondary_backends = []
self.strategy = strategy(self)
def set_primary_backend(self, backend):
"""
Set a backend object as the primary backend.
@param backend: The backend instance.
@return None
"""
self.primary_backend = backend
def register_secondary_backend(self, backend):
"""
Register a backend object as a secondary backend.
@param backend: The backend instance.
@return None
"""
self.secondary_backends.append(backend)
def register_authority(self, authority, default=False):
"""
Register a new object authority.
@param authority: The authority instance.
@param authority: If the instance should be the default authority.
@return None
"""
name = authority.NAME
self.authorities[name] = authority
if default:
self.defaulf_authority = name
def get_authority(self, name=None):
"""
Return a authority by name.
@param name: The name of the authority.
@return The authority instance.
"""
if not name:
name = self.defaulf_authority
return self.authorities[name]
def get_query(self, name):
""""
Return a new query object with the given name.
A query object is used to query the backends for specific objects.
@param name: The name of the query.
@return A new DataStoreQuery instance.
"""
query_object = DataStoreQuery(name)
return query_object
def find_objects(self, query):
"""
Find objects in the primary backend using a query object.
@param query: A DataStoreQuery instance with search criteria.
@return A list with matching objects. The List will be empty if
nothing was found.
"""
return self.primary_backend.find_objects(query)
def find_identities(self, object):
"""
Find a identity for a specific object in the primary query.
@param object: The object to use.
"""
return self.primary_backend.find_datastore_identities(object)
def insert_object(self, source, object):
"""
insert a new object into the datastore.
@param source: The source of this action.
@param object: The object to insert.
@return The given object with a populated id attribute.
"""
return self.strategy.insert(source, object)
def update_object(self, source, object):
"""
Update an existing object in the datastore.
@param source: The source of this action.
@param object: The object to update.
@return The updated object.
"""
self.strategy.update(source, object)
def delete_object(self, source, object):
"""
Delete an existing object from the datastore.
@param source: The source of this action.
@param object: The object to delete.
"""
self.strategy.delete(source, object)
class DataStoreSyncStrategy(object):
"""
Abstract implementation for backend all synchronization strategies.
"""
def __init__(self, datastore):
"""
Initialize the strategy.
"""
self.datastore = datastore
def insert(self, source, object):
"""
Handle insert algorithm.
@param source: Classname where the object comes from.
@param object: The object to be inserted.
"""
raise NotImplementedError
def update(self, source, object):
"""
Handle update algorithm.
@param source: Classname where the object comes from.
@param object: The object to be updated.
"""
raise NotImplementedError
def delete(self, source, object):
"""
Handle delete algorithm.
@param source: Classname where the object comes frome.
@param object: The object to be deleted.
"""
raise NotImplementedError
class DataStoreOneWaySync(DataStoreSyncStrategy):
"""
Implementation for a one-way synchronization mechanism.
Data is exclusively entered locally into the primary backend and
replicated to all secondary backends. The secondary entities are mapped
to the primary entites by id.
"""
def insert(self, source, object):
"""
Insert a new object.
@param source: The object source' classname.
@param source: The local object.
@return The local object with populated id and mappings.
"""
primary = self.datastore.primary_backend
secondaries = self.datastore.secondary_backends
try:
stored_object = primary.insert_object(object)
try:
authority = self.datastore.get_authority(object.get_authority_name())
except AttributeError:
authority = self.datastore.get_authority()
for secondary in secondaries:
if not authority.may_replicate(object, primary, secondary):
continue
datastore_identity = secondary.insert_object(object)
primary.create_backend_identity(
stored_object,
datastore_identity
)
primary.commit_transaction()
except:
primary.rollback_transaction()
raise
return stored_object
def update(self, source, object):
"""
Update an existing object.
@param source: The object source' classname.
@param source: The local object.
"""
primary = self.datastore.primary_backend
secondaries = self.datastore.secondary_backends
try:
primary.update_object(object)
datastore_ids = {}
for identity in object.identities:
datastore_id = DataStorePeerIdentity(
backend=identity.backend.typename,
type=identity.typename,
identity=identity.identity
)
datastore_ids[identity.backend.typename] = datastore_id
for secondary in secondaries:
secondary.update_object(
datastore_ids[secondary.__class__.__name__],
object
)
primary.commit_transaction()
except:
primary.rollback_transaction()
raise
def delete(self, source, object):
"""
Delete an existing object.
@param source: The object source' classname.
@param source: The local object.
"""
primary = self.datastore.primary_backend
secondaries = self.datastore.secondary_backends
try:
datastore_ids = {}
for identity in object.identities:
datastore_id = DataStorePeerIdentity(
backend=identity.backend.name,
type=identity.typename,
identity=identity.identity
)
datastore_ids[identity.backend.typename] = datastore_id
for secondary in secondaries:
secondary.delete_object(
datastore_ids[secondary.__class__.__name__]
)
primary.delete_object(object)
primary.commit_transaction()
except:
primary.rollback_transaction()
raise
class DataStoreTwoWaySync(DataStoreSyncStrategy):
"""
Implementation for a two-way synchronization mechanism.
Data can be copied/synchronized from the primary backend to all
secondary backends. Additionally, all secondary backends can
request a data update in the primary backend which if successful
will be populated to all other secondary backends. The data update
request must be initiated from outside of this class.
"""
def insert(self, source, object):
"""
Insert a new object.
@param source: The object source' classname.
@param source: The local object.
@return The local object with populated id and mappings.
"""
return object
def update(self, source, object):
"""
Update an existing object.
@param source: The object source' classname.
@param source: The local object.
"""
pass
def delete(self, source, object):
"""
Delete an existing object.
@param source: The object source' classname.
@param source: The local object.
"""
pass
class DataStoreQuery(object):
"""
An abstract data store query.
This object only contains the general name of the specific query.
Arbitrary query parameters can be added at runtime. When the query is run
against the backends, the name is used to identify the concrete query
objects provided by the backends.
"""
def __init__(self, name):
"""
Instantiate a new query object.
@param name: The query name.
"""
self.__query_name = name
def get_name(self):
"""
Return the query name.
@return The query name.
"""
return self.__query_name
def get_parameters(self):
"""
Return a dictionary with query parameters.
@return A dictionary with query parameters.
"""
# TODO filter private attributes
return self.__dict__
class DataStorePeerIdentity(object):
"""
A storage-idenpendent, backend-specific identity for a given entity.
"""
def __init__(self, backend=None, type=None, identity=None):
"""
@param backend: The classname of the backend.
@param type: The classname of the entity type.
@param identity: The entity identity.
"""
self.backend = backend
self.type = type
self.identity = identity
class DataStoreAuthority(object):
"""
An abstract data store object authority.
A object authority decides whether a specific object is allowed to be
replicated between two backends.
"""
def may_replicate(self, object, source, destination):
"""
Decide wether the given object may be replicated from src to dst.
@param object: The object to check.
@param source: The source backend.
@param destination: The destination backend.
"""
return NotImplementedError
class SystemAllowAuthority(DataStoreAuthority):
"""
A default authority.
All objects may replicate.
"""
NAME = '/system/allow'
def may_replicate(self, object, source, destination):
return True
class SystemDenyAuthority(DataStoreAuthority):
"""
A system authority.
No objects may replicate.
"""
NAME = '/system/deny'
def may_replicate(self, object, source, destination):
return False
class LocalUserAuthority(DataStoreAuthority):
"""
An authority for objects created by local users.
All objects may replicate.
"""
NAME = '/local/user'
def may_replicate(self, object, source, destination):
return True
class LocalBirthdayAuthority(DataStoreAuthority):
"""
An authority for objects created by local users.
Keep all authority-based objects local.
"""
NAME = '/local/birthday'
def may_replicate(self, object, source, destination):
return False
class DataStoreBackend(object):
"""
An abstract datastore backend implementation.
"""
class Query(object):
"""
An abstract Query implementation.
Queries are used for data retrieval.
"""
def execute(self, endpoint, query):
"""
Execute the requested query against the concrete service
endpoint.
The query is executed using a query handler, which can be
any class method.
@param endpoint: The service endpoint.
@param query: The DataStoreQuery instance.
@return The result of the query.
@raise InvalidQueryName if no query handler was found.
"""
name = query.get_name()
try:
handler = getattr(self, name)
result = handler(endpoint, query)
except AttributeError:
raise InvalidQueryName
return result
class Adapter(object):
"""
An abstract Adapter implementation.
Adapters are used for data manipulation.
"""
pass
class SqlAlchemyBackend(DataStoreBackend):
"""
Backend implementation using the SQLAlchemy ORM layer.
"""
class Query(DataStoreBackend.Query):
def __with_deleted(self, query):
"""
Return if the result should contain entries marked as deleted.
@param query: The DataStoreQuery to check.
@return True if deleted entries are requested, otherwise False.
"""
return (hasattr(query, 'with_deleted') and query.with_deleted)
def all_calendars(self, session, query):
"""
@return All calendar objects.
"""
result = session \
.query(Calendar) \
.filter(Calendar.isDeleted == self.__with_deleted(query)) \
.all()
return result
def calendar_by_id(self, session, query):
"""
@return A single calendar object with the id of query.id.
"""
try:
result = session \
.query(Calendar) \
.filter(Calendar.id == query.id) \
.filter(Calendar.isDeleted == self.__with_deleted(query)) \
.one()
except sqlalchemy.orm.exc.NoResultFound:
result = []
return result
def calendars_by_string(self, session, query):
"""
@return Calendar objects where the name contains the query.string.
"""
result = session \
.query(Calendar) \
.filter(Calendar.title.contains(query.string)) \
.filter(Event.isDeleted == self.__with_deleted(query)) \
.all()
return result
def all_events(self, session, query):
"""
@return All event objects.
"""
result = session \
.query(Event) \
.filter(Event.isDeleted == self.__with_deleted(query)) \
.all()
return result
def event_by_id(self, session, query):
"""
@return A single event object with the id of query.id
"""
try:
result = session \
.query(Event) \
.filter(Event.id == query.id) \
.filter(Event.isDeleted == self.__with_deleted(query)) \
.one()
except sqlalchemy.orm.exc.NoResultFound:
result = []
return result
def events_by_string(self, session, query):
"""
@return Event objects where the title, description or
location contain the query.string.
"""
result = session \
.query(Event) \
.filter(sqlalchemy.or_( \
Event.title.contains(query.string), \
Event.description.contains(query.string), \
Event.location.contains(query.string) \
)) \
.filter(Event.isDeleted == self.__with_deleted(query)) \
.all()
return result
def events_at_date(self, session, query):
"""
@return Event objects that lie between query.start and query.end.
"""
result = session \
.query(Event) \
.filter(sqlalchemy.func.strftime('%Y-%m-%d', Event.start) <= query.date) \
.filter(sqlalchemy.func.strftime('%Y-%m-%d', Event.end) >= query.date) \
.filter(Event.isDeleted == self.__with_deleted(query)) \
.all()
return result
def all_contacts(self, session, query):
"""
@return All contact objects.
"""
result = session.query(Contact).filter(Contact.isDeleted == self.__with_deleted(query)).all()
return result
def contact_by_id(self, session, query):
"""
@return A single contact object with the id of query.id.
"""
try:
result = session \
.query(Contact) \
.filter(Contact.id == query.id) \
.filter(Contact.isDeleted == self.__with_deleted(query)) \
.one()
except sqlalchemy.orm.exc.NoResultFound:
result = []
return result
def contacts_by_string(self, session, query):
"""
@return Contact objects where the firstname, lastname or
nickname contain the query.string.
"""
result = session \
.query(Contact) \
.filter(sqlalchemy.or_( \
Contact.firstname.contains(query.string), \
Contact.lastname.contains(query.string), \
Contact.nickname.contains(query.string) \
)) \
.filter(Event.isDeleted == self.__with_deleted(query)) \
.all()
return result
def __init__(self, datastore, persistence):
"""
Initialize the sqlalchemy backend.
@param datastore: The datastore.
@param persistence: The bot persistence.
"""
self.datastore = datastore
self.session = persistence.get_session()
self.query = self.Query()
def begin_transaction(self):
"""
Begin a new transaction.
"""
self.session.begin()
def commit_transaction(self):
"""
Commit the session's transaction.
"""
self.session.commit()
def rollback_transaction(self):
"""
Rollback the session's transaction.
"""
self.session.rollback()
def request_backend(self, typename):
"""
Request a backend object from the database.
When the object was not found, a new object will be created.
@param typename: The typename of the backend.
@return A Backend instance.
"""
try:
backend = self.session \
.query(Backend) \
.filter(Backend.typename == typename) \
.one()
except sqlalchemy.orm.exc.NoResultFound:
backend = Backend(typename=typename)
self.session.add(backend)
return backend
def create_backend_identity(self, object, datastore_identity):
"""
Create a mapping between a local object and an remote peer identity.
@param object: The local object.
@param identity: The DataStorePeerIdentity object.
"""
def calendar():
identity = CalendarPeerIdentity()
identity.calendar = object
return identity
def event():
identity = EventPeerIdentity()
identity.event = object
return identity
def contact():
identity = ContactPeerIdentity()
identity.contact = object
return identity
dispatcher = {
'Calendar': calendar,
'Event': event,
'Contact': contact
}
identity = dispatcher[datastore_identity.type]()
identity.backend = self.request_backend(datastore_identity.backend)
identity.identity = datastore_identity.identity
self.session.add(identity)
def find_datastore_identities(self, object):
"""
Returns a DataStorePeerIdentity for a given local object.
@param object: The local object.
@return A DataStorePeerIdentity instance.
"""
result = []
for identity in object.identities:
datastore_identity = DataStorePeerIdentity()
datastore_identity.backend = identity.backend.typename
datastore_identity.type = identity.typename
datastore_identity.identity = identity.identity
result.append(datastore_identity)
return result
def find_objects(self, query):
"""
Find objects in the primary backend using a query object.
See SqlAlchemyBackend.Query for supported queries.
@param query_object: The query_object with search criteria.
@return A list with matching objects. The List will be empty if
nothing was found.
"""
result = self.query.execute(self.session, query)
return result
def insert_object(self, object):
"""
insert a new data object.
@param object: The object to insert.
@return The given object with a populated id attribute.
"""
self.session.add(object)
return object
def update_object(self, object):
"""
Update an existing object.
This method actually does nothing as SqlAlchemy maintains
attribute state and marks objects as dirty as soon as attributes
change.
The actual database update will be executed when committing the
current transaction.
@param object: The object to update.
"""
# legacy code
#self.session.save(object)
pass
def delete_object(self, object):
"""
Delete an existing object.
@param object: The object to delete.
"""
object.isDeleted = True
class GoogleBackend(DataStoreBackend):
"""
Backend implementation using Google's GData API.
"""
LINK_EDIT = 'edit'
LINK_EVENTFEED = 'http://schemas.google.com/gCal/2005#eventFeed'
class Query(DataStoreBackend.Query):
def all_calendars_feed(self, service, query):
"""
@return An atom feed with all calendar objects.
"""
return service.calendar_client.GetOwnCalendarsFeed()
def calendar_by_id(self, service, query):
"""
@return A single calendar object with the id of query.id.
"""
return service.calendar_client.get_calendar_entry(uri=query.id)
def event_by_id(self, service, query):
"""
@return A single event object with the id of query.id.
"""
return service.calendar_client.get_event_entry(uri=query.id)
def contact_by_id(self, service, query):
"""
@return A single contact object with the id of query.id.
"""
return service.contacts_client.get_contact(uri=query.id)
class Adapter(DataStoreBackend.Adapter):
"""
Abstract implementation for manipulation of GData entries.
"""
date_format_time = '%Y-%m-%dT%H:%M:%S.000Z'
date_format_allday = '%Y-%m-%d'
def hastime(self, object):
"""
Check if the given datetime object contains time.
TODO: this implementation is not optimal as an intentional
TODO: date at 00:00:00 produces a false positive result.
@param object: The datetime object.
"""
if hasattr(object, 'hour') and hasattr(object, 'minute') and hasattr(object, 'second'):
return (object.hour != 0 or object.minute != 0 or object.second != 0)
return False
def new_identity(self):
"""
Create a new DataStorePeerIdentity object.
@return A DataStorePeerIdentity instance from the GoogleBackend.
"""
identity = DataStorePeerIdentity()
identity.backend = 'GoogleBackend'
return identity
def json_links(self, gdata_object):
"""
Convert data from a atom.Link list into a JSON string.
@param gdata_object: The GData object containing the links.
@return A link.rel=>link.href dict in JSON.
"""
list = {}
for link in gdata_object.link:
if link.rel is None or link.href is None:
continue
list[link.rel] = link.href
result = json.dumps(list)
return result
class CalendarEntryAdapter(Adapter):
"""
Manipulate GData CalendarEntry objects.
"""
def _local_to_gdata(self, local_object, gdata_object):
"""
Update a GData instance with data from a local instance.
@param local_object: An objects.Calendar instance.
@param gdata_object: An gdata.contacts.data.CalendarEntry instance.
@return The updated gdata_object.
"""
#-------------------------------------------------------------------
# Calendar: title
#-------------------------------------------------------------------
if local_object.title:
if gdata_object.title:
gdata_object.title.text = local_object.title
else:
gdata_object.title = atom.data.Title(text=local_object.title)
#-------------------------------------------------------------------
# Calendar: summary
#-------------------------------------------------------------------
if local_object.summary:
if gdata_object.summary:
gdata_object.summary.text = local_object.summary
else:
gdata_object.summary = atom.data.Summary(text=local_object.summary)
#-------------------------------------------------------------------
# Calendar: timezone
#-------------------------------------------------------------------
# TODO: default timezone configurable
if gdata_object.timezone is None:
gdata_object.timezone = gdata.calendar.data.TimeZoneProperty(value='Europe/Berlin')
#-------------------------------------------------------------------
# Calendar: where
#-------------------------------------------------------------------
# TODO: default location configurable
if local_object.location:
if len(gdata_object.where) > 0:
# TODO: bad implementation, unclear specification from google
# TODO: assume where always contains only one element with index 0
gdata_object.where[0].value = local_object.location
else:
where = gdata.calendar.data.CalendarWhere(
value=local_object.location
)
gdata_object.where.append(where)
else:
if len(gdata_object.where) == 0:
where = gdata.calendar.data.CalendarWhere(
value='Duesseldorf, Germany'
)
gdata_object.where.append(where)
#-------------------------------------------------------------------
# Calendar: color
#-------------------------------------------------------------------
if local_object.color:
color = '#{0}'.format(local_object.color)
if gdata_object.color:
gdata_object.color.value = color
else:
gdata_object.color = gdata.calendar.data.ColorProperty(value=color)
else:
# TODO: default color configurable
color = '#000000'
if gdata_object.color is None:
gdata_object.color = gdata.calendar.data.ColorProperty(value=color)
return gdata_object
def _gdata_to_local(self, local_object, gdata_object):
"""
Update a local instance with data from a GData instance.
@param local_object: An objects.Calendar instance.
@param gdata_object: An gdata.contacts.data.CalendarEntry instance.
@return The updated local_object.
"""
#-------------------------------------------------------------------
# Calendar: title
#-------------------------------------------------------------------
if gdata_object.title:
local_object.title = gdata_object.title.text
#-------------------------------------------------------------------
# Calendar: summary
#-------------------------------------------------------------------
if gdata_object.summary:
local_object.summary = gdata_object.summary.text
#-------------------------------------------------------------------
# Calendar: where
#-------------------------------------------------------------------
if gdata_object.location and len(gdata_object.where) > 0:
local_object.location = gdata_object.where[0].value
#-------------------------------------------------------------------
# Calendar: color
#-------------------------------------------------------------------
if gdata_object.color.value:
local_object.color = '#{0}'.format(gdata_object.color.value)
#-------------------------------------------------------------------
# Calendar: type (internal attribute)
#-------------------------------------------------------------------
if len(gdata_object.extended_property) > 0:
for property in gdata_object.extended_property:
if property.name == self.properties['type']:
local_object.type = property.value
return gdata_object
def insert(self, backend, local_object):
"""
Insert a local object into the Google Service.
@param backend: The Google Backend.
@param local_object: An objects.Calendar instance.
@return a DataStorePeerIdentity with information about the
new Google Entry.
"""
entry = gdata.calendar.data.CalendarEntry()
entry = self._local_to_gdata(local_object, entry)
new_entry = backend.service.calendar_client.InsertCalendar(entry)
identity = self.new_identity()
identity.type = 'Calendar'
identity.identity = self.json_links(new_entry)
return identity
def update(self, backend, gdata_object, local_object):
"""
Update an existing object in Google with data from a local object.
@param backend: The Google Backend.
@param gdata_object: The existing gdata.contacts.data.CalendarEntry.
@param local_object: An objects.Calendar instance.
"""
updated_entry = self._local_to_gdata(local_object, gdata_object)
backend.service.calendar_client.Update(updated_entry)
def delete(self, backend, gdata_object):
"""
Delete an existing object from the Google Services.
@param backend: The Google Backend.
@param gdata_object: The existing gdata.contacts.data.CalendarEntry.
"""
backend.calendar_client.Delete(gdata_object)
class CalendarEventEntryAdapter(Adapter):
def _local_to_gdata(self, local_object, gdata_object):
"""
Update a GData instance with data from a local instance.
@param local_object: An objects.Event instance.
@param gdata_object: An gdata.contacts.data.CalendarEventEntry instance.
@return The updated gdata_object.
"""
#-----------------------------------------------------------------------
# Event: title
#-----------------------------------------------------------------------
if local_object.title:
if gdata_object.title:
gdata_object.title.text = local_object.title
else:
gdata_object.title = atom.data.Title(text=local_object.title)
#-----------------------------------------------------------------------
# Event: title
#-----------------------------------------------------------------------
if local_object.description:
if gdata_object.content:
gdata_object.content.text = local_object.description
else:
gdata_object.content = atom.data.Content(text=local_object.description)
#-----------------------------------------------------------------------
# Event: where
#-----------------------------------------------------------------------
if len(gdata_object.where) > 0:
# TODO: bad implementation, unclear specification from google
# TODO: assume where always contains only one element with index 0
gdata_object.where[0].value = local_object.location
else:
where = gdata.calendar.data.CalendarWhere(
value=local_object.location
)
gdata_object.where.append(where)
#-----------------------------------------------------------------------
# Event: when
#-----------------------------------------------------------------------
if self.hastime(local_object.start) and self.hastime(local_object.end):
date_format = self.date_format_time
elif not self.hastime(local_object.start) and not self.hastime(local_object.end):
date_format = self.date_format_allday
else:
raise ValueError('start/end date: mixing of datetime and date is not allowed. start={0}, end={1}'.format(local_object.start, local_object.end))
start = local_object.start
# Google API workaround
# when creating an event with start = x and end = y,
# the created event ends at y-1
if local_object.start == local_object.end:
end = local_object.end
else:
delta = datetime.timedelta(1)
end = local_object.end + delta
start_time = start.strftime(date_format)
end_time = end.strftime(date_format)
if len(gdata_object.when) > 0:
# TODO: bad implementation, missing docs from google
# TODO: assume when always contains only one element with index 0
when = gdata_object.when[0]
when.start = start_time
when.end = end_time
else:
when = gdata.calendar.data.When(
start=start_time,
end=end_time
)
gdata_object.when.append(when)
return gdata_object
def _gdata_to_local(self, local_object, gdata_object):
"""
Update a local instance with data from a GData instance.
@param local_object: An objects.Contact instance.
@param gdata_object: An gdata.contacts.data.CalendarEventEntry instance.
@return The updated local_object.
"""
#-------------------------------------------------------------------
# Event: title
#-------------------------------------------------------------------
if gdata_object.title:
local_object.title = gdata_object.title.text
#-------------------------------------------------------------------
# Event: description
#-------------------------------------------------------------------
if gdata_object.content:
local_object.description = gdata_object.content.text
#-------------------------------------------------------------------
# Event: where
#-------------------------------------------------------------------
if len(gdata_object.where) > 0:
local_object.location = gdata_object.where[0].value
#-----------------------------------------------------------------------
# Event: when
#-----------------------------------------------------------------------
if len(gdata_object.when) > 0:
when = gdata_object.when[0]
try:
start = time.strptime(when.start, self.date_format_time)
end = time.strptime(when.end, self.date_format_time)
except ValueError:
try:
start = time.strptime(when.start, self.date_format_allday)
end = time.strptime(when.end, self.date_format_allday)
except ValueError:
start = None
end = None
if start and end:
if start != end:
delta = datetime.timedelta(-1)
end -= delta
local_object.start = start
local_object.end = end
return local_object
def insert(self, backend, local_object):
"""
Insert a local object into the Google Service.
@param backend: The Google Backend.
@param local_object: An objects.Event instance.
@return a DataStorePeerIdentity with information about the
new Google Entry.
"""
entry = gdata.calendar.data.CalendarEventEntry()
entry = self._local_to_gdata(local_object, entry)
if local_object.calendar:
calendar_identities = backend.datastore.find_identities(local_object.calendar)
try:
google_identity = [identity for identity in calendar_identities if identity.backend == 'GoogleBackend'][0]
links = json.loads(google_identity.identity)
calendar_uri = backend.find_eventfeed_link(links)
except KeyError:
calendar_uri = None
else:
calendar_uri = None
new_entry = backend.service.calendar_client.InsertEvent(entry, calendar_uri)
identity = self.new_identity()
identity.type = 'Event'
identity.identity = self.json_links(new_entry)
return identity
def update(self, backend, gdata_object, local_object):
"""
Update an existing object in Google with data from a local object.
@param service: The Google API service.
@param gdata_object: The existing gdata.contacts.data.CalendarEventEntry.
@param local_object: An objects.Contact instance.
"""
updated_entry = self._local_to_gdata(local_object, gdata_object)
backend.service.calendar_client.Update(updated_entry)
def delete(self, backend, gdata_object):
"""
Delete an existing object from the Google Services.
@param backend: The Google Backend.
@param gdata_object: The existing gdata.contacts.data.CalendarEventEntry.
"""
backend.service.calendar_client.Delete(gdata_object)
class ContactEntryAdapter(Adapter):
def _local_to_gdata(self, local_object, gdata_object):
"""
Update a GData instance with data from a local instance.
@param local_object: An objects.Contact instance.
@param gdata_object: An gdata.contacts.data.ContactEntry instance.
@return The updated gdata_object.
"""
if local_object.firstname:
local = local_object.firstname
remote = gdata_object.name
if remote:
remote.given_name = local
else:
remote = gdata.data.Name(
given_name=gdata.data.GivenName(text=local)
)
if local_object.lastname:
local = local_object.lastname
remote = gdata_object.name
if remote:
remote.family_name = local
else:
remote = gdata.data.Name(
family_name=gdata.data.FamilyName(text=local)
)
if local_object.nickname:
local = local_object.nickname
remote = gdata_object.nickname
if remote:
remote.text = local
else:
remote = gdata.contacts.data.NickName(text=local)
if local_object.birthday:
local = local_object.birthday.strftime(self.date_format_allday)
remote = gdata_object.birthday
if remote:
remote.when = local
else:
remote = gdata.contacts.data.Birthday(when=local)
return gdata_object
def _gdata_to_local(self, local_object, gdata_object):
"""
Update a local instance with data from a GData instance.
@param local_object: An objects.Contact instance.
@param gdata_object: An gdata.contacts.data.ContactEntry instance.
@return The updated local_object.
"""
if gdata_object.name and gdata_object.name.given_name:
local_object.firstname = gdata_object.name.given_name
if gdata_object.name and gdata_object.name.family_name:
local_object.lastname = gdata_object.name.family_name
if gdata_object.nickname:
local_object.nickname = gdata_object.nickname.text
if gdata_object.birthday:
local_object.birthday = time.strptime(
gdata_object.birthday.when,
self.date_format_allday
)
return gdata_object
def insert(self, backend, local_object):
"""
Insert a local object into the Google Service.
@param backend: The Google Backend.
@param local_object: An objects.Contact instance.
@return a DataStorePeerIdentity with information about the
new Google Entry.
"""
entry = gdata.contacts.data.ContactEntry()
entry = self._local_to_gdata(local_object, entry)
new_entry = backend.service.contacts_client.CreateContact(entry)
identity = self.new_identity()
identity.type = 'Contact'
identity.identity = self.json_links(new_entry)
return identity
def update(self, backend, gdata_object, local_object):
"""
Update an existing object in Google with data from a local object.
@param backend: The Google Backend.
@param gdata_object: The existing gdata.contacts.data.ContactEntry.
@param local_object: An objects.Contact instance.
"""
updated_entry = self._local_to_gdata(local_object, gdata_object)
backend.service.contacts_client.Update(updated_entry)
def delete(self, backend, gdata_object):
"""
Delete an existing object from the Google Services.
@param backend: The Google Backend.
@param gdata_object: The existing gdata.contacts.data.ContactEntry.
"""
backend.service.contacts_client.Delete(gdata_object)
def __init__(self, datastore, service):
"""
Initialize the backend implementation.
@param datastore: The datastore.
@param service: An Google API service object which handles authentication
"""
self.datastore = datastore
self.service = service
self.query = self.Query()
self.adapters = {
'Calendar' : self.CalendarEntryAdapter(),
'Event' : self.CalendarEventEntryAdapter(),
'Contact' : self.ContactEntryAdapter(),
}
def find_objects(self, query):
"""
Find objects in the google backend using a query object.
@param query_object: The query_object with search criteria.
@return A list with matching objects. The List will be empty if
nothing was found.
"""
result = self.query.execute(self.service, query)
return result
def find_edit_link(self, links):
"""
Returns the Google edit link from a CalendarEventEntry link list.
"""
return links[self.LINK_EDIT]
def find_eventfeed_link(self, links):
"""
Returns the Google eventFeed link from a CalendarEventEntry link list.
"""
return links[self.LINK_EVENTFEED]
def insert_object(self, object):
"""
insert a new data object.
@param object: The object to insert.
@return The identity of the remote object.
"""
adapter = self.adapters[object.__class__.__name__]
identity = adapter.insert(self, object)
return identity
def update_object(self, identity, object):
"""
Update an existing object.
@param identity: The object's peer identity.
@param object: The new object data.
"""
links = json.loads(identity.identity)
query = self.datastore.get_query('event_by_id')
query.id = self.find_edit_link(links)
current_entry = self.find_objects(query)
adapter = self.adapters[identity.type]
adapter.update(self, current_entry, object)
def delete_object(self, identity):
"""
Delete an existing object.
@param identity: The object's peer identity.
"""
links = json.loads(identity.identity)
query = self.datastore.get_query('event_by_id')
query.id = self.find_edit_link(links)
current_entry = self.find_objects(query)
adapter = self.adapters[identity.type]
adapter.delete(self, current_entry)
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: principal.py 260 2012-01-23 21:45:31Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/components/principal.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Mar 12, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 260 $'
import logging
from core import runlevel
from core.config import Config
from core.component import Component, ComponentError
# ------------------------------------------------------------------------------
# Exceptions
# ------------------------------------------------------------------------------
class PrincipalComponentError(ComponentError): pass
# ------------------------------------------------------------------------------
# Business Logic
# ------------------------------------------------------------------------------
class PrincipalComponent(Component):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.LOCAL_COMPONENT
)
def __init__(self, bot):
Component.__init__(self, bot)
self.bot.register_config(PrincipalComponentConfig)
self.config = self.bot.get_config('components.principal')
self.logger = logging.getLogger('components.principal')
# --------------------------------------------------------------------------
# Lifecycle
# --------------------------------------------------------------------------
def _start(self):
"""
Startup the component and background services.
Implementation of Subsystem.start()
"""
self._running()
def _stop(self):
"""
Shutdown the component and background services.
Implementation of Subsystem.stop()
"""
self._halted()
def find_principal_by_id(self, id):
pass
def insert_principal(self, principal):
pass
def update_principal(self, principal):
pass
def delete_principal(self, id):
pass
# ------------------------------------------------------------------------------
# Configuration
# ------------------------------------------------------------------------------
class PrincipalComponentConfig(Config):
identifier = 'components.principal'
def valid_keys(self):
return []
def default_values(self):
return {}
| Python |
# -*- coding: UTF-8 -*-
'''
Created on 30.01.2012
@author: rack
'''
import logging
from sqlalchemy import func,desc
from sqlalchemy.orm.exc import NoResultFound
from datetime import date
from core import runlevel
from core.component import Component, ComponentError
from core.config import Config
from objects.topic import TopicAddition, Topic
#-------------------------------------------------------------------------------
# Exceptions
#-------------------------------------------------------------------------------
class TopicComponentError(ComponentError): pass
class TopicNotFound(TopicComponentError): pass
class AdditionNotFound(TopicComponentError): pass
class NoAdditionAvailable(TopicComponentError): pass
class NoAffectedRows(TopicComponentError): pass
#-------------------------------------------------------------------------------
# Business Logic
#-------------------------------------------------------------------------------
class TopicComponent(Component):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.LOCAL_COMPONENT
)
def __init__(self, bot):
"""
Initialize all required variables.
"""
Component.__init__(self, bot)
self.bot = bot
self.logger = logging.getLogger('components.topic')
self.persistence = self.bot.get_subsystem('local-persistence')
def insert_addition(self, text, user):
"""
Insert a new addition to database.
@param text: the real addition text
@param user: the person who likes to add the addition
@return: None
"""
added_at = date.today()
addition = TopicAddition(date=added_at, text=text, user=user)
session = self.persistence.get_session()
session.add(addition)
session.commit()
def get_random_addition(self):
"""
Return a random selected addition.
@return: entity of addition
@raise NoAdditionAvailable if there is an empty database
"""
try:
session = self.persistence.get_session()
addition = session.query(TopicAddition).order_by(func.random()).limit(1).one()
return addition
except NoResultFound:
raise NoAdditionAvailable
def delete_addition_by_id(self,id):
"""
Delete a topic addition with the given id.
@param id: number of the addition which will be deleted
@return: None
@raise AdditionNotFound if there is no addition with the given id
@raise DeleteDidntWork if sqlalchemy couldn't perform the deleting
"""
session = self.persistence.get_session()
affected_rows = session.query(TopicAddition).filter(TopicAddition.id==id).delete()
session.commit()
if (affected_rows < 1):
raise NoAffectedRows
def insert_topic(self,text,addition,year,user):
"""
Insert a new topic.
@param text: the real topic text
@param addition: an entity of addition
@param year: a (randomly) generated year for the topic addition
@param user: the name of the user who likes to add the topic
@return: None
"""
topic = Topic(date=date.today(),text=text,year=year,user=user)
topic.addition = addition
session = self.persistence.get_session()
session.add(topic)
session.commit()
def get_last_topic(self):
"""
Return the current topic
@return: an entity of topic
@raise TopicNotFound if there isn't a topic in database
"""
try:
session = self.persistence.get_session()
topic = session.query(Topic).order_by(desc(Topic.id)).limit(1).one()
return topic
except NoResultFound:
raise TopicNotFound
#-------------------------------------------------------------------------------
# Config
#-------------------------------------------------------------------------------
class TopicComponentConfig(Config):
identifier = 'components.topic' | Python |
# -*- coding: UTF-8 -*-
"""
$Id: facts.py 260 2012-01-23 21:45:31Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/components/facts.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since May 6, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 260 $'
import logging
import urllib
import re
import datetime
import htmlentitydefs
from core import runlevel
from core import constants
from core.config import Config
from core.component import Component, ComponentError
from objects.facts import Fact
# ------------------------------------------------------------------------------
# Exceptions
# ------------------------------------------------------------------------------
class FactsComponentError(ComponentError): pass
# ------------------------------------------------------------------------------
# Business Logic
# ------------------------------------------------------------------------------
class FactsComponent(Component):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.LOCAL_COMPONENT
)
def __init__(self, bot):
Component.__init__(self, bot)
self.bot.register_config(FactsComponentConfig)
self.config = self.bot.get_config('components.facts')
self.logger = logging.getLogger('components.facts')
self.bot.register_timer(
'components.facts.update',
'daily',
self.config.get('retrievalInterval'),
self.update_data
)
# --------------------------------------------------------------------------
# Lifecycle
# --------------------------------------------------------------------------
def _start(self):
"""
Startup the component and background services (Timer).
Implementation of Subsystem.start()
"""
self.bot.get_timer('components.facts.update').start()
self._running()
def _stop(self):
"""
Shutdown the component and background services (Timer).
Implementation of Subsystem.stop()
"""
self.bot.get_timer('components.facts.update').stop()
self._halted()
# --------------------------------------------------------------------------
# Component methods
# --------------------------------------------------------------------------
def find_all_facts(self):
pass
def find_random_fact(self):
pass
def insert_fact(self, fact):
pass
def delete_fact(self, id):
pass
def update_data(self):
self.logger.info('updating data')
source = SchoelnastAtFactSource()
source.limit_date = self.config.get('lastRetrievalDate')
data = source.get_data()
for entity in data:
self.insert_fact(entity)
if data:
self.config.set('lastRetrievalDate', datetime.date.today())
self.config.save()
self.logger.info('added %d new records', len(data))
else:
self.logger.info('no new data available')
class SchoelnastAtFactSource(object):
"""
A data source for wissen.schoelnast.at.
"""
URL = 'http://wissen.schoelnast.at/alles.shtml'
LINE_PATTERN = r'<tr><td class="li"><a(.*)>(?P<date>\d{1,2}\.\d{1,2}\.\d{4})</a></td><td class="re2">(?P<fact>.*)<span class="blau">'
LINE_DATE_FORMAT = '%d.%m.%Y'
ENTITY_NAME_PATTERN = r'&({0});'.format('|'.join(htmlentitydefs.name2codepoint))
ENTITY_CP_PATTERN = r'&#(\d{1,4});'
def __init__(self):
self.line_matcher = re.compile(self.LINE_PATTERN)
self.entity_name_matcher = re.compile(self.ENTITY_NAME_PATTERN)
self.entity_cp_matcher = re.compile(self.ENTITY_CP_PATTERN)
def _entity2unichr(self, input):
"""
# TODO optimize
"""
def name_converter(entity_match):
return unichr(htmlentitydefs.name2codepoint[entity_match.group(1)])
def cp_converter(entity_match):
return unichr(int(entity_match.group(1)))
output = re.sub(self.entity_name_matcher, name_converter, input)
output = re.sub(self.entity_cp_matcher, cp_converter, output)
return output
def get_data(self):
stream = urllib.urlopen(self.URL)
raw_lines = stream.readlines()
stream.close()
limit_date = getattr(self, 'limit_date', datetime.date(2000, 1, 1))
new_data = []
for raw_line in raw_lines:
raw_line = raw_line.strip()
match = self.line_matcher.search(raw_line)
if not match:
continue
date = datetime.datetime.strptime(match.group('date'), self.LINE_DATE_FORMAT).date()
if date < limit_date:
continue
fact = Fact()
fact.date = date
fact.text = self._entity2unichr(match.group('fact')).strip()
new_data.append(fact)
return new_data
# ------------------------------------------------------------------------------
# Configuration
# ------------------------------------------------------------------------------
class FactsComponentConfig(Config):
identifier = 'components.facts'
def valid_keys(self):
return [
'lastRetrievalDate',
'retrievalInterval'
]
def default_values(self):
return {
'lastRetrievalDate' : datetime.date(2011,1,1),
'retrievalInterval' : constants.TIME_HOUR * 8
}
| Python |
# -*- coding: UTF-8 -*-
"""
$Id$
$URL$
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Mar 12, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev$'
__all__ = [
'calendar',
]
| Python |
'''
Created on 22.02.2012
@author: rack
'''
import logging
from sqlalchemy import func
from sqlalchemy.orm.exc import NoResultFound
from datetime import date
from core import runlevel
from core.component import Component, ComponentError
from objects.quote import Quote
#-------------------------------------------------------------------------------
# Exceptions
#-------------------------------------------------------------------------------
class QuoteComponentError(ComponentError): pass
class NoQuoteAvailable(QuoteComponentError): pass
class NoAffectedRows(QuoteComponentError): pass
#-------------------------------------------------------------------------------
# Business Logic
#-------------------------------------------------------------------------------
class QuoteComponent(Component):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.LOCAL_COMPONENT
)
def __init__(self, bot):
"""
Initialize all required variables.
"""
Component.__init__(self, bot)
self.bot = bot
self.logger = logging.getLogger('components.quote')
self.persistence = self.bot.get_subsystem('local-persistence')
def insert_quote(self,text,user):
"""
Insert a new quote to database
@param text: the quote text
@param user: the person who likes to add the quote
@return: None
"""
added_at = date.today()
quote = Quote(date=added_at, text=text, user=user)
session = self.persistence.get_session()
session.add(quote)
session.commit()
def delete_quote_by_id(self,id):
"""
Delete a quote with the given id
@param id: number of the quote which will be deleted
@return: None
@raise NoAffectedRows if sqlalchemy couldn't perform the deleting
"""
session = self.persistence.get_session()
affected_rows = session.query(Quote).filter(Quote.id==id).delete()
session.commit()
if (affected_rows < 1):
raise NoAffectedRows
def get_quote_by_id(self,id):
"""
Return a quote with the given id
@param id: identifier of the quote which will be deleted
@return None
@raise NoQuoteAvailable if there is no quote with the given id
"""
try:
session = self.persistence.get_session()
quote = session.query(Quote).filter(Quote.id==id).one()
return quote
except NoResultFound:
raise NoQuoteAvailable
def get_random_quote_by_string(self,string):
"""
Retrun a random selected quote which have the given string in it.
"""
try:
session = self.persistence.get_session()
quote = session.query(Quote).filter(Quote.text.like('%{0}%'.format(string))).order_by(func.random()).limit(1).one()
return quote
except NoResultFound:
raise NoQuoteAvailable
def get_ids_by_string(self,string):
"""
Returns all quote ids which have the given string.
@param string: The string you are looking for.
@return: array of IDs
"""
session = self.persistence.get_session()
quotes = session.query(Quote).filter(Quote.text.like('%{0}%'.format(string))).all()
ids = []
for x in quotes:
ids.append(x.id)
return ids
def get_random_quote(self):
"""
Return a random selected quote.
@return: entity of quote
@raise NoQuoteAvailable if there is an empty database
"""
try:
session = self.persistence.get_session()
quote = session.query(Quote).order_by(func.random()).limit(1).one()
return quote
except NoResultFound:
raise NoQuoteAvailable | Python |
# -*- coding: UTF-8 -*-
"""
$Id: persistence.py 260 2012-01-23 21:45:31Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/core/persistence.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 08, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 260 $'
import logging
import sqlite3
import gdata.calendar.client
import gdata.contacts.client
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from core import runlevel
from core import subsystem
from core.config import Config
# ------------------------------------------------------------------------------
# Exceptions
# ------------------------------------------------------------------------------
class DatabaseError(Exception): pass
# ------------------------------------------------------------------------------
# Business Logic
# ------------------------------------------------------------------------------
class SqlitePersistence(subsystem.Subsystem):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.LOCAL_FILESYSTEM
)
"""
Provide sqlite persistence to all sub-systems.
"""
class Mapping():
def get_type(self):
raise NotImplementedError
def get_typename(self):
raise NotImplementedError
def adapt(self, value):
raise NotImplementedError
def convert(self, value):
raise NotImplementedError
type_mapping = []
def __init__(self, bot, sqlite_file):
"""
Create a new persistence instance.
@param sqlite_file: The SQLite database.
"""
subsystem.Subsystem.__init__(self, bot)
self.sqlite_file = sqlite_file
for clazz in self.type_mapping:
object = clazz()
sqlite3.register_adapter(object.type, object.adapt)
sqlite3.register_converter(object.typename, callable)
def start(self):
"""
Open the sqlite connection.
Implementation of Subsystem.start()
"""
if not self.sqlite_file:
raise KeyError('missing sql file')
sqlite_file = self.bot.get_config_key(self.sqlite_file)
self.connection = sqlite3.connect(sqlite_file)
self.connection.row_factory = sqlite3.Row
self._running()
def stop(self):
"""
Close the sqlite connection.
Implementation of Subsystem.stop()
"""
self.connection.close()
self._halted()
def get_connection(self):
"""
Return the SQLite connection instance.
"""
return self.connection
def get_cursor(self):
"""
Return a new SQLite cursor.
"""
return self.connection.cursor()
class SqlAlchemyPersistence(subsystem.Subsystem):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.LOCAL_SERVICE
)
"""
Provide access to the SQLAlchemy ORM for all sub-systems.
"""
Base = declarative_base()
def __init__(self, bot, connect_string):
"""
Create a new persistence instance.
@param connect_string: The SQLAlchemy connect string.
"""
subsystem.Subsystem.__init__(self, bot)
self.connect_string = connect_string
logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)
def _start(self):
"""
Create a SqlAlchemy session.
Implementation of Subsystem.start()
"""
if not self.connect_string:
raise KeyError('missing connect string')
connect_string = self.bot.get_config_key(self.connect_string)
self.engine = create_engine(connect_string)
self.sessionobj = sessionmaker(bind=self.engine, autoflush=False, autocommit=False)
self.session = self.sessionobj()
self._running()
def _stop(self):
"""
Close the SqlAlchemy session.
Implementation of Subsystem.stop()
"""
if self.session:
self.session.close()
self._halted()
def get_session(self):
"""
Create a new session instance.
@return sqlalchemy.orm.session.Session
"""
return self.session
class GoogleApiService(subsystem.Subsystem):
RUNLEVEL = runlevel.Runlevel(
autoboot=True,
minimum_start=runlevel.NETWORK_SERVICE
)
"""
Initialize the Google client API and handle all authentication logic.
"""
# TODO: externalize
source = 'foption-bot-v1'
def __init__(self, bot):
subsystem.Subsystem.__init__(self, bot)
self.bot.register_config(GoogleApiServiceConfig)
self.calendar_client = None
self.contacts_client = None
def _start(self):
"""
Register a new session at the Google API endpoint.
Implementation of Subsystem.start()
"""
config = self.bot.get_config(GoogleApiServiceConfig.identifier)
self.calendar_client = gdata.calendar.client.CalendarClient(
source=self.source
)
self.calendar_client.ClientLogin(
config.get('gdata-username'),
config.get('gdata-password'),
self.calendar_client.source
)
self.contacts_client = gdata.contacts.client.ContactsClient(
source=self.source
)
self.contacts_client.ClientLogin(
config.get('gdata-username'),
config.get('gdata-password'),
self.contacts_client.source
)
self._running()
def _stop(self):
"""
Currently does nothing, as the Google client API does not require
to close, shutdown or release any resources.
Implementation of Subsystem.stop()
"""
self._halted()
def get_calendar_client(self):
return self.calendar_client
def get_contacts_client(self):
return self.contacts_client
# ------------------------------------------------------------------------------
# Configuration
# ------------------------------------------------------------------------------
class GoogleApiServiceConfig(Config):
identifier = 'services.google.api'
def valid_keys(self):
return [
'gdata-username',
'gdata-password',
'gdata-tokens',
'gdata-client-id',
'gdata-client-secret'
]
def default_values(self):
return {
'gdata-username' : '',
'gdata-password' : '',
'gdata-tokens' : {},
'gdata-client-id' : '',
'gdata-client-secret' : ''
}
| Python |
# -*- coding: UTF-8 -*-
"""
$Id$
$URL$
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 6, 2011
@author Mario Steinhoff
This file contains all messages with associated message numbers that are
used through the whole project. When defining new messages, please use
named parameters wherever possible.
Currently, the following number ranges are defined:
00000-09999: Core
00001-00999: Bot
01000-01999: Config
10000-19999: Modules
20000-29999: Interaction
20001-20200: IRC
"""
__version__ = '$Rev$'
__all__ = [
'message'
]
message = {}
message[01000] = 'configuration saved'
message[01001] = 'unable to save configuration'
message[01002] = 'configuration loaded'
message[01003] = 'unable to load configuration: config file was found'
message[20001] = ''
message[20002] = ''
message[20003] = ''
message[20005] = ''
message[20006] = ''
message[20007] = ''
message[20008] = ''
message[20009] = ''
message[20010] = ''
message[20011] = ''
message[20012] = ''
message[20013] = ''
message[20014] = ''
message[20015] = ''
message[20016] = ''
#reply.add('deine mutter hat gefailed.')
#return "OHFUCKOHFUCKOHFUCK Etwas lief schief! Datenbankfehler"
#return "Error 555!"
#reply.add('Deine Mutter hat die Datenbank gefressen')
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: constants.py 260 2012-01-23 21:45:31Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/core/constants.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 9, 2011
@author Mario Steinhoff
TODO: Make environment-specific data configurable.
"""
__version__ = '$Rev: 260 $'
__all__ = [
'TIME_MINUTE',
'TIME_HOUR'
]
# ------------------------------------------------------------------------------
# time intervals
# ------------------------------------------------------------------------------
TIME_SECOND = 1
TIME_MINUTE = TIME_SECOND * 60
TIME_HOUR = TIME_MINUTE * 60
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: config.py 260 2012-01-23 21:45:31Z steinhoff.mario@googlemail.com $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/core/config.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 06, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 260 $'
import logging
try:
import cPickle as pickle
except:
import pickle
import os
# ------------------------------------------------------------------------------
# BusinessLogic
# ------------------------------------------------------------------------------
class Config(object):
"""
Provide abstract system-wide configuration handling.
TODO: Implement dict-style access for key/value-pairs.
"""
def __init__(self, bot):
"""
Initialize the configuration.
@param bot: The bot instance.
"""
self.bot = bot
self.logger = logging.getLogger('core.config')
self.init(self.default_values())
self.load()
def filter_valid_keys(self, dict):
"""
Validate a configuration dictionary against the config structure.
Keys that do not match will be removed and returned in
a new dictionary.
@param dict: The dictionary to validate
@return A dictionary with all valid keys
"""
result = {}
for key in dict:
if key not in self.valid_keys():
continue
result[key] = dict[key]
return result
def valid_keys(self):
"""
Return a list representing valid configuration keys.
"""
raise ValueError('no valid keys defined')
def default_values(self):
"""
Return a dictionary with default values. This dictionary
is validated against the list returned by valid().
"""
raise ValueError('no default values defined')
def set(self, key, value):
"""
Set a configuration value.
@param key: the name of the entry
@param value: the value of the entry
"""
if key not in self.valid_keys():
raise ValueError('invalid key: %s'.format(key))
self._keys[key] = value
def get(self, name):
"""
Return a configuration value.
@param name: the name of the entry
"""
return self._keys[name]
def get_all(self):
"""
Return the complete configuration dictionary.
"""
return self._keys
def delete(self, name):
"""
Remove a configuration value.
@param name: the name of the entry
"""
del self._keys[name]
def init(self, data={}):
"""
Initialize configuration dictionary with default values.
Overwrite all current values.
"""
self._keys = self.filter_valid_keys(data)
def load(self):
"""
Load configuration data from persistence.
Existing keys are updated. If a key in the current instance
exists but was not found in the persistence, it remains untouched.
"""
filename = os.path.join(self.bot.root, self.identifier)
try:
rawdata = self.readobject(filename)
loaded = self.filter_valid_keys(rawdata)
self._keys.update(loaded)
except IOError as e:
self.logger.error('could not load %s configuration: %s', self.identifier, e)
def save(self):
"""
Save the current configuration data to persistence.
"""
filename = os.path.join(self.bot.root, self.identifier)
try:
self.writeobject(filename, self._keys)
except IOError as e:
self.logger.error('could not save %s configuration: %s', self.identifier, e)
def readobject(self, filename):
"""
Restore a python object from a file.
Read the serialized data of a python object's state and create
an object from it.
@param filename: The source filename.
@return the restored object
"""
with open(filename, 'r') as f:
object = pickle.load(f)
return object
def writeobject(self, filename, object):
"""
Persist a python object to a file.
Serialize a python object's state and write the data to the
filesystem.
@param filename: The destination filename.
@param object: The object to serialize.
"""
with open(filename, 'w') as f:
pickle.dump(object, f)
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: timer.py 233 2011-09-23 01:27:22Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/core/timer.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since May 6, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 233 $'
import datetime
import threading
class BaseTimer(object):
def __init__(self, interval=None, callback=None):
self.interval = interval
self.callback = callback
class SingleTimer(BaseTimer):
def start(self):
if hasattr(self, 'timer') and self.timer:
self.stop()
self.timer = threading.Timer(self.interval, self.callback)
self.timer.start()
def stop(self):
self.timer.cancel()
self.timer = None
class DailyTimer(BaseTimer):
def start(self):
if hasattr(self, 'timer') and self.timer:
self.stop()
self.timer = threading.Timer(self.interval, self._check, [datetime.date.today()])
self.timer.start()
def stop(self):
# TODO check if timer was started
self.timer.cancel()
self.timer = None
def _check(self, start):
today = datetime.date.today()
if today != start:
self.callback(today)
self.start()
timer_map = {
'single': SingleTimer,
'daily': DailyTimer
}
| Python |
# -*- coding: UTF-8 -*-
"""
$Id$
$URL$
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 6, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev$'
__all__ = [
'messages',
'constants',
'exceptions',
'bot',
'runlevel',
'subsystem',
'config',
'persistence',
'component'
]
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: subsystem.py 246 2011-09-25 05:12:07Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/core/subsystem.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Sep 22, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 246 $'
from core import runlevel
from core.bot import BotError
# ------------------------------------------------------------------------------
# Exceptions
# ------------------------------------------------------------------------------
class SubsystemError(BotError): pass
class SubsystemStateError(SubsystemError): pass
# ------------------------------------------------------------------------------
# Business Logic
# ------------------------------------------------------------------------------
class Subsystem(object):
"""
Define a management interface for arbitrary subsystems.
"""
def __init__(self, bot):
"""
Initialize the subsystem with a reference to the bot instance.
"""
self.__state = runlevel.STATE_HALTED
self.bot = bot
def start(self):
"""
Start the subsystem and any background services.
"""
if self.__state != runlevel.STATE_HALTED:
raise SubsystemStateError('can not start subsystem %s: subsystem is not halted.'.format(self.__class__.__name__))
self._start()
def stop(self):
"""
Stop the subsystem and any background services.
"""
if self.__state != runlevel.STATE_RUNNING:
raise SubsystemStateError('can not stop subsystem %s: subsystem is not running.'.format(self.__class__.__name__))
self._stop()
def _starting(self):
"""
Subsystem-internal method to indicate that the system is starting.
"""
self.__state = runlevel.STATE_STARTING
def _running(self):
"""
Subsystem-internal method to indicate that the system is running.
"""
self.__state = runlevel.STATE_RUNNING
def _stopping(self):
"""
Subsystem-internal method to indicate that the system is stopping.
"""
self.__state = runlevel.STATE_STOPPING
def _halted(self):
"""
Subsystem-internal method to indicate that the system is stopped.
"""
self.__state = runlevel.STATE_HALTED
def get_state(self):
"""
Returns the current running state of the subsystem.
@see: core.runlevel for details on available running states.
"""
return self.__state
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: component.py 231 2011-09-23 01:24:05Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/core/component.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Apr 18, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 231 $'
from core import subsystem
from core.bot import BotError
# ------------------------------------------------------------------------------
# Exceptions
# ------------------------------------------------------------------------------
class ComponentError(BotError): pass
# ------------------------------------------------------------------------------
# Business Logic
# ------------------------------------------------------------------------------
class Component(subsystem.Subsystem):
"""
Component interface.
"""
def __init__(self, bot):
subsystem.Subsystem.__init__(self, bot)
| Python |
# -*- coding: UTF-8 -*-
"""
$Id$
$URL$
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 06, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev$'
import logging
import collections
from core import runlevel
from core.timer import timer_map
from core.config import Config
# ------------------------------------------------------------------------------
# Exceptions
# ------------------------------------------------------------------------------
class BotError(Exception): pass
class ConfigRegisteredError(BotError): pass
class TimerRegisteredError(BotError): pass
class SubsystemRegisteredError(BotError): pass
# ------------------------------------------------------------------------------
# Business Logic
# ------------------------------------------------------------------------------
class Bot(object):
"""
Provide general functionality and start all subsystems.
"""
def __init__(self, root=None, level=logging.DEBUG):
"""
Initialize the bot.
"""
logging.basicConfig(level=level)
self.root = root
self.logger = logging.getLogger('core.bot')
self.__runlevel = runlevel.HALT
self.__runlevel_map = collections.defaultdict(list)
self._config = {}
self._timer = {}
self._subsystems = {}
self._processes = {}
self.register_config(BotConfig)
self.register_subsystem('local-persistence', 'core.persistence.SqlAlchemyPersistence', connect_string='config:core.bot.database-connectstring')
self.register_subsystem('google-api-service', 'core.persistence.GoogleApiService')
self.register_subsystem('principal-component', 'components.principal.PrincipalComponent')
self.register_subsystem('calendar-component', 'components.calendar.CalendarComponent')
self.register_subsystem('facts-component', 'components.facts.FactsComponent')
self.register_subsystem('topic-component', 'components.topic.TopicComponent')
self.register_subsystem('quote-component', 'components.quote.QuoteComponent')
self.register_subsystem('irc-client', 'interaction.irc.client.Client')
def get_object(self, name):
"""
Returns a reference to the given object.
The containing module is imported and a reference to the
given object is returned.
Taken from http://stackoverflow.com/questions/452969/does-python-have-
an-equivalent-to-java-class-forname
@param classname: The fully qualified classname to load
@return: A reference to the class object
"""
module_name, _, object_name = name.rpartition('.')
m = __import__(module_name, globals(), locals(), [object_name], -1)
obj = getattr(m, object_name)
return obj
#---------------------------------------------------------------------------
# configuration
#---------------------------------------------------------------------------
def register_config(self, clazz):
"""
Register a new configuration class.
@param clazz: A reference to the class.
"""
if clazz.identifier in self._config:
raise ConfigRegisteredError
self._config[clazz.identifier] = clazz(self)
def get_config(self, identifier):
"""
Returns a registered configuration object.
@param identifier: The identifier of the configuration class.
@return The configuration object.
"""
return self._config[identifier]
def get_config_key(self, string):
"""
Find a configuration value by string identifier.
Using this method, configuration keys can be referenced before
the actual configuration object is available.
Format: config:[identifier].[key]
@param string: The identifier.
@return The configuration value.
"""
if string.startswith('config:'):
config_fqdn = string.split(':')[1].split('.')
identifier = '.'.join(config_fqdn[:-1])
key = '.'.join(config_fqdn[-1:])
result = self.get_config(identifier).get(key)
else:
result = string
return result
def get_configs(self):
"""
@return All known configuration objects.
"""
return self._config
#---------------------------------------------------------------------------
# timer
#---------------------------------------------------------------------------
def register_timer(self, identifier, type, interval, callback):
"""
Register a new timer with the bot.
@param identifier: The identifier of the timer.
@param type: The requested type.
@param interval: The type-specific interval.
@param callback: The callback to execute when the timer is fired.
"""
if identifier in self._timer:
raise TimerRegisteredError(identifier)
self._timer[identifier] = timer_map[type](interval, callback)
def get_timer(self, identifier):
"""
Returns a registered timer object.
@param identifier: The identifier of the timer.
@Return The timer instance.
"""
return self._timer[identifier]
#---------------------------------------------------------------------------
# subsystems
#---------------------------------------------------------------------------
def register_subsystem(self, identifier, classname, **kwargs):
"""
Register a new subsystem.
@param identifier: The identifier for the instanciated subsystem.
@param classname: The fully qualified classname of the subsystem.
@param **kwargs: Any additional constructor arguments.
"""
if identifier in self._subsystems:
raise SubsystemRegisteredError
clazz = self.get_object(classname)
self._subsystems[identifier] = clazz(self, **kwargs)
# using defaultdict here
self.__runlevel_map[clazz.RUNLEVEL.level].append(identifier)
def get_subsystem(self, identifier):
"""
Return a registered subsystem instance.
@identifier: The identifier of the subsystem.
@return The subsystem instance.
"""
return self._subsystems[identifier]
#---------------------------------------------------------------------------
# bootstrapping
#---------------------------------------------------------------------------
def init(self, requested):
"""
Execute a runlevel switch.
TODO multithreaded or singlethreaded, event-based architecture
for name, object in self._interaction.items():
#self._processes[name] = multiprocessing.Process(target=Interaction.startInteraction, args=(self, object))
#self._processes[name].start()
self.logger.info('starting process %s', name)
self._processes[name] = object
self._processes[name].start()
@param requested: The requested runlevel.
"""
if self.__runlevel == requested:
return
direction = runlevel.calculate_direction(self.__runlevel, requested)
distance = runlevel.calculate_distance(self.__runlevel, requested)
self.logger.info('switching runlevel: %s to %s', self.__runlevel, requested)
for next in distance:#
self.__runlevel = next
if direction == runlevel.DIRECTION_UP:
self.logger.info('entering runlevel %s', next)
for identifier in self.__runlevel_map[next]:
self.start_subsystem(identifier)
if direction == runlevel.DIRECTION_DOWN:
self.logger.info('leaving runlevel %s', next)
for identifier in self.__runlevel_map[next]:
self.stop_subsystem(identifier)
self.__runlevel = requested
self.logger.info('runlevel switched: %s', self.__runlevel)
# temporary solution because the system currently uses only one thread.
#self.init(runlevel.HALT)
def get_runlevel(self):
"""
Return the current runlevel of the system.
"""
return self.__runlevel
def start_subsystem(self, identifier):
"""
Start a subsystem registered with the bot.
@param identifier: The identifier of the subsystem.
"""
if self._subsystems[identifier].get_state() != runlevel.STATE_HALTED:
self.logger.info('subsystem %s: skipped (not halted)', identifier)
return
try:
self.logger.info('subsystem %s: starting', identifier)
self._subsystems[identifier].start()
self.logger.info('subsystem %s: started', identifier)
except:
self.logger.exception('subsystem %s: start failed', identifier)
def stop_subsystem(self, identifier):
"""
Stop a subsystem registered with the bot.
@param identifier: The identifier of the subsystem.
"""
if self._subsystems[identifier].get_state() != runlevel.STATE_RUNNING:
self.logger.info('subsystem %s: skipped (not running)', identifier)
return
try:
self.logger.info('subsystem %s: stopping', identifier)
self._subsystems[identifier].stop()
self.logger.info('subsystem %s: stopped', identifier)
except:
self.logger.exception('subsystem %s: stop failed', identifier)
class BotConfig(Config):
identifier = 'core.bot'
def valid_keys(self):
return [
'logging-directory',
'database-file',
'database-connectstring',
]
def default_values(self):
return {
'logging-directory' : '',
'database-file' : '',
'database-connectstring' : ''
}
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: runlevel.py 256 2012-01-12 23:28:32Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/core/runlevel.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Sep 22, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 256 $'
HALT = 0
LOCAL_MEMORY = 1
LOCAL_FILESYSTEM = 2
LOCAL_SERVICE = 3
LOCAL_COMPONENT = 4
NETWORK_SERVICE = 5
NETWORK_MANAGEMENT = 6
NETWORK_INTERACTION = 7
LEVELS = [
HALT,
LOCAL_MEMORY, LOCAL_FILESYSTEM, LOCAL_SERVICE, LOCAL_COMPONENT,
NETWORK_SERVICE, NETWORK_MANAGEMENT, NETWORK_INTERACTION
]
LEVELS_START = [
LOCAL_MEMORY, LOCAL_FILESYSTEM, LOCAL_SERVICE,
NETWORK_SERVICE, NETWORK_MANAGEMENT, NETWORK_INTERACTION
]
LEVELS_STOP = [
HALT,
]
STATE_STARTING = 1
STATE_RUNNING = 2
STATE_STOPPING = 3
STATE_HALTED = 4
DIRECTION_UP = 1
DIRECTION_DOWN = 2
class Runlevel(object):
def __init__(self, autoboot=False, minimum_start=None):
self.level = minimum_start
def calculate_direction(current, requested):
"""
Calculate the rl change direction based on current and requested rl.
If the requested runlevel is greater than the current runlevel,
DIRECTION_UP is returned, otherwise DIRECTION_DOWN.
@param current: The current runlevel.
@param requested: The requested runlevel.
@return DIRECTION_UP or DIRECTION_DOWN
"""
direction = {True: DIRECTION_UP, False: DIRECTION_DOWN}
return direction[current < requested]
def calculate_distance(current, requested):
"""
Calculate the steps between the given current and requested runlevel.
The calculation is based on the following table:
current = 0, requested = 6 -> [1, 2, 3, 4, 5, 6]
current = 2, requested = 4 -> [3, 4]
current = 5, requested = 1 -> [4, 3, 2, 1]
current = 6, requested = 0 -> [5, 4, 3, 2, 1, 0]
@param current: The current runlevel.
@param requested: The requested runlevel.
"""
if current == requested:
distance = []
if current < requested:
distance = range(current+1, requested+1)
if current > requested:
distance = range(requested+1, current+1)
distance.reverse()
return distance
| Python |
# -*- coding: UTF-8 -*-
"""
$Id: message.py 269 2012-02-01 22:58:55Z steinhoff.mario $
$URL: http://fptbot.googlecode.com/svn/trunk/fptbot/src/python/interaction/irc/message.py $
Copyright (c) 2010 foption
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
@since Jan 12, 2011
@author Mario Steinhoff
"""
__version__ = '$Rev: 269 $'
import string
from objects.irc import ServerSource, ClientSource
SPACE = '\x20'
COLON = '\x3A'
SPACECOLON = '\x20\x3A'
EXMARK = '\x21'
AT = '\x40'
class Message(object):
"""
A IRC message in plaintext.
"""
MAXLENGTH = 510
def __init__(self, message):
"""
Create a new instance.
@param message: The raw IRC message.
"""
if len(message) == 0:
raise ValueError('empty message')
if len(message) > self.MAXLENGTH:
raise ValueError('message exceeds maximum length')
self.message = message
def __str__(self):
"""
Return The string representation of the message.
"""
return self.message
def create_event(self):
"""
Parse the class' message attribute and return a new Event instance.
TODO: cleaner implementation using regex
@return An Event instance.
"""
result = self.message
#-----------------------------------------------------------------------
# Extract the source if available
# ----------------------------------------------------------------------
if result.startswith(COLON):
source, result = string.split(result[1:], SPACE, 1)
# when source contains a EXMARK we assume that source is not a
# servername, because EXMARK are not allowed in ip addresses or
# dns names.
if EXMARK in source:
nick, ident_host = string.split(source, EXMARK)
ident, host = string.split(ident_host, AT)
source = ClientSource(nickname=nick, ident=ident, host=host)
else:
source = ServerSource(servername=source)
else:
source = None
#-----------------------------------------------------------------------
# Separate command and parameters
#-----------------------------------------------------------------------
try:
# First case: There is a parameter with spaces after SPACECOLON
msg_without_space, msg_with_space = string.split(result, SPACECOLON, 1)
msg_parts = string.split(msg_without_space, SPACE)
command = msg_parts[0]
parameter = msg_parts[1:]
parameter.append(msg_with_space)
except ValueError:
try:
# Second case: There are multiple parameters without space
msg = string.split(result, SPACE)
command = msg[0]
parameter = msg[1:]
except ValueError:
# Third case: There is only one command
command = msg
parameter = None
return Event(source, command, parameter)
class Event(object):
"""
An IRC message event.
"""
def __init__(self, source=None, command=None, parameter=None):
"""
Create a new instance.
@param source: a Source instance or None
@param command: the IRC command/reply
@param parameter: a list with all parameters or None
"""
self.source = source or ''
self.command = command or ''
self.parameter = parameter or []
def __str__(self):
"""
Return the string representation of the event.
"""
return self.compose(self)
def compose(self):
"""
Compose a IRC message from this Event.
@return A string with the IRC message.
@raise ValueError if any of the first n-1 parameters contain spaces.
"""
#-----------------------------------------------------------------------
# Handle the source if existent
#-----------------------------------------------------------------------
if self.source is None:
prefix = ''
else:
prefix = '{0}{1}{2}'.format(COLON, self.source, SPACE)
#-----------------------------------------------------------------------
# Handle the command
#-----------------------------------------------------------------------
command = self.command
#-----------------------------------------------------------------------
# Handle parameters
#-----------------------------------------------------------------------
if self.parameter is None:
paramlist = ''
elif len(self.parameter) == 0:
paramlist = ''
elif len(self.parameter) == 1:
paramlist = '{0}{1}'.format(SPACECOLON, self.parameter[0])
else:
rest = self.parameter[:-1]
last = self.parameter[-1:][0]
for param in rest:
if SPACE in param:
raise ValueError('only the last parameter may contain spaces')
if SPACE in last:
paramlist = '{0}{1}{2}{3}'.format(SPACE, SPACE.join(rest), SPACECOLON, last)
else:
paramlist = '{0}{1}'.format(SPACE, SPACE.join(self.parameter))
message = '{0}{1}{2}'.format(prefix, command, paramlist)
return message
def create_message(self):
"""
Create a new Message instance.
"""
return Message(self.compose())
| Python |
Subsets and Splits
SQL Console for ajibawa-2023/Python-Code-Large
Provides a useful breakdown of language distribution in the training data, showing which languages have the most samples and helping identify potential imbalances across different language groups.