def job_table_view(self):
user_jobs = meta.Session.query(model.job).all()
c.jobs = paginate.Page(user_jobs, items_per_page=10)
total_pages = len(user_jobs)/10 + 1
#jobs = meta.Session.query(model.job)
#if (len(user_jobs)!=0):
# print "\njobs------\n",jobs.first().jobinfo[1].key, jobs.first().jobinfo[1].value
# to check if user visiting this page for the first time and
#assign the latest jobs page,page_num tell which page to show
page_num = total_pages
if ('page' in request.params) and request.params['page']. isdigit() and (int(request.params['page']) <= total_pages):
page_num =int(request.params['page'])
if 'm' in request.params:
c.display_message = "Job successfully submitted and your Job ID is " \
+ str(request.params['id'])
c.jobs = paginate.Page(user_jobs, page=page_num, items_per_page=10)
c.pagenums=c.jobs.pager()
c.pagenumber = page_num
return render("/job_table_view.mako")
def atributosDef(self, id, **named):
identity = request.environ.get('repoze.who.identity')
user = identity['user']
tipoItem = DBSession.query(TipoItemUsuario).filter_by(id=id).one()
fase = DBSession.query(Fase).filter_by(id=tipoItem.fase_id).one()
atributos = DBSession.query(TipoItemUsuarioAtributos).filter_by(
tipo_item_id=id).order_by(TipoItemUsuarioAtributos.id)
from webhelpers import paginate
count = atributos.count()
page = int(named.get('page', '1'))
currentPage = paginate.Page(
atributos,
page,
item_count=count,
items_per_page=3,
)
atributos = currentPage.items
return dict(page='tipoItemUsuario',
user=user,
fase=fase,
atributos=atributos,
tipoItem=tipoItem,
subtitulo='ABM-TipoItemUsuario',
currentPage=currentPage)
def agregarRolUsuario(self, id_usuario, id_proyecto, page=1):
"""Metodo que permite listar los roles que se pueden agregar al usuario seleccionado"""
try:
usuario = DBSession.query(Usuario).get(id_usuario)
rolesUsuario = usuario.roles
rolesDB = DBSession.query(Rol).filter_by(tipo="Proyecto").all()
roles = []
for rol in rolesDB:
if rolesUsuario.count(rol) == 0:
roles.append(rol)
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Agregar Roles! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/agregarRolUsuario",
id_usuario=id_usuario,
id_proyecto=id_proyecto)
except (AttributeError, NameError, ValueError):
flash(
_("No se pudo acceder a Agregar Roles! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/agregarRolUsuario",
id_usuario=id_usuario,
id_proyecto=id_proyecto)
return dict(roles=currentPage.items,
page='agregar_roles',
currentPage=currentPage,
id_usuario=id_usuario,
usuario=usuario,
id_proyecto=id_proyecto)
def listaProyectos_a_iniciar(self, page=1):
"""Metodo para listar todos los Proyectos a iniciar de la base de datos"""
try:
proy = DBSession.query(Proyecto).filter_by(
iniciado=False).order_by(Proyecto.id_proyecto)
usuario = DBSession.query(Usuario).filter_by(
nombre_usuario=request.identity['repoze.who.userid']).first()
proyectos = []
for p in proy:
if usuario.proyectos.count(p) == 1:
proyectos.append(p)
currentPage = paginate.Page(proyectos, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Proyectos! SQLAlchemyError..."),
'error')
redirect("/admin")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Proyectos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin")
return dict(proyectos=currentPage.items,
page='listaProyectos_a_iniciar',
currentPage=currentPage)
def rolProyecto(self, id_proyecto, page=1):
"""Metodo que permite listar los roles que se pueden agregar al proyecto seleccionado"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
id_proyecto = proyecto.id_proyecto
rolesProyecto = proyecto.roles
roles = DBSession.query(Rol).filter_by(tipo="Proyecto").order_by(
Rol.id_rol).all()
for rol in rolesProyecto:
if roles.count(rol) >= 1:
roles.remove(rol)
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Agregar Roles al Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Agregar Roles al Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/roles", id_proyecto=id_proyecto)
return dict(roles=currentPage.items,
page='agregar_roles',
currentPage=currentPage,
id_proyecto=id_proyecto,
proyecto=proyecto)
def evaluate(self, id=None):
if not h.auth.is_logged_in():
abort(401)
c.idea = h.fetch_obj(Idea, id, new_id=True)
node_q = Session.query(Node).filter_by(concept_id=id)
c.node = node_q.first()
if request.environ.get('REMOTE_USER', False):
user = h.get_user(request.environ['REMOTE_USER'])
sq = Session.query(IdeaEvaluation.cons_id)
sq = sq.filter(IdeaEvaluation.ante == c.idea)
sq = sq.filter(IdeaEvaluation.uid == user.ID)
sq = sq.subquery()
to_evaluate = c.idea.related.outerjoin(
(sq, Idea.ID == sq.c.cons_id))
to_evaluate = to_evaluate.filter(sq.c.cons_id == None)
else:
to_evaluate = c.idea.related
c.paginator = paginate.Page(to_evaluate,
page=int(request.params.get('page', 1)),
items_per_page=10,
controller='idea',
action='edit',
id=id)
response.headers['Access-Control-Allow-Origin'] = '*'
return render('idea/idea-edit.html')
def mentor_courseware_course_add(request):
page = int(request.params.get('page', 1))
conn = DBSession()
userid = request.user.id
courseid = request.params.get('courseid')
course = None
items = []
if courseid:
course = conn.query(Course).filter(Course.id == courseid).first()
#items=conn.query(Courseware)
wares = conn.query(
Ware_Course.wareid).filter(Ware_Course.courseid == courseid)
#if wares :
items=conn.query(Courseware).filter(Courseware.mentorid.in_(conn.query(Mentor.id)\
.filter(Mentor.userid==userid)),Courseware.id.notin_(wares))
#else :
# items=conn.query(Courseware)
#"""
page_url = paginate.PageURL_WebOb(request)
items = paginate.Page(
items,
page=int(page),
items_per_page=10,
url=page_url,
)
return dict(code=0, course=course, items=items)
def recent_tasks_panel(context, request):
"""
Panel returning the company's tasklist
Parameters to be supplied as a cookie or in request.POST
pseudo params: tasks_per_page, see _get_tasks_per_page()
tasks_page_nb: -only in POST- the page we display
"""
if not request.is_xhr:
# javascript engine for the panel
resources.task_list_js.need()
query = _company_tasks_query(context)
page_nb = utils.get_page_number(request, "tasks_page_nb")
items_per_page = utils.get_items_per_page(request, 'tasks_per_page')
paginated_tasks = paginate.Page(
query,
page_nb,
items_per_page=items_per_page,
url=utils.make_get_list_url('tasklist'),
)
result_data = {'tasks': paginated_tasks}
return result_data
def home_view(request):
if 'q' not in request.params:
# Home page
return {'home': True, 'query': ''}
else:
# Search page
query = request.params['q']
current_page = int(request.params.get('p', 1))
num_found, results = search(query, page=current_page)
results = highlight(results, query)
# Generate pager
root_url = request.registry.settings.get('root', '/')
page = paginate.Page(range(num_found),
page=current_page,
items_per_page=RESULTS_PER_PAGE,
url=lambda page: '%s?q=%s&p=%s' %
(root_url, query, page))
pager_html = page.pager(
format='$link_first $link_previous ~3~ $link_next $link_last')
return {
'home': False,
'num_found': num_found,
'results': results,
'query': query,
'pager': pager_html
}
def list(self):
ds = u"请输入主机名或IP或负责人"
dv = model.DeviceBase
if 'ds' in request.params:
ds = request.params['ds']
log.info("________________")
log.info(type(ds))
log.info(ds)
'''
if ds == u'请输入主机名或IP或负责人':
log.info("++++++++++++++++++++++")
log.info(ds)
ds = ''
'''
if ds and ds!=u"请输入主机名或IP或负责人":
devices = model.meta.Session.query(dv).filter(dv.hidden==0).filter(dv.for_search.like('%'+ds+'%')).order_by(dv.hostname.asc()).all()
else:
devices = model.meta.Session.query(dv).filter(dv.hidden==0).order_by(dv.hostname.asc()).all()
c.pagename = "devices"
c.heading = "主机列表"
for x,t in enumerate(devices):
t.cpuinfo = self.cinfo_conv(t.cpuinfo, t.cpucore);
t.memsize = self.num_scale(t.memsize, 1000)
t.diskspace = self.num_scale(t.diskspace,1000)
t.hardware = self.hinfo_conv(t.hardware)
c.ds = ds
c.rows = paginate.Page(
devices,
ds = ds,
page=int(request.params.get('page', 1)),
items_per_page = 20,
)
return render('/derived/devices/list.html')
def listadoTipoItemPorFase(self, id_proyecto, id_fase, page=1):
"""Metodo para listar los Tipos de Items de una Fase """
try:
tipoItemPorFase = DBSession.query(TipoItem).join(
TipoItem.relacion_fase).filter(
TipoItem.id_fase == id_fase).options(
contains_eager(TipoItem.relacion_fase)).order_by(
TipoItem.id_tipo_item)
nombreFase = DBSession.query(
Fase.nombre).filter_by(id_fase=id_fase).first()
idProyectoFase = DBSession.query(
Fase.id_proyecto).filter_by(id_fase=id_fase).first()
currentPage = paginate.Page(tipoItemPorFase,
page,
items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Tipo de Items de Fase! SQLAlchemyError..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Tipo de Items de Fase! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/fase/listadoFasesPorProyecto",
id_proyecto=id_proyecto)
return dict(tipoItemPorFase=currentPage.items,
page='listado',
nombre_fase=nombreFase,
id_proyecto=id_proyecto,
id_fase=id_fase,
currentPage=currentPage)
def listcourse(request):
page = int(request.params.get('page', 1))
conn = DBSession()
if request.method == "POST":
semesterid = request.params.get('semesterid')
items = conn.query(Course).filter(
Course.semesterid == semesterid).order_by(Course.id)
else:
items = conn.query(Course).order_by(Course.id)
semesters = conn.query(Semester).order_by(Semester.id)
lis = []
for semester in semesters:
t = List_semester()
t.id = semester.id
t.time = date.fromtimestamp(semester.start)
t.weeks = semester.weeks
time = t.time
name = str(time.year)
mon = time.month
if mon > 7:
name += u"年秋季"
else:
name += u"年春季"
t.name = name
lis.append(t)
page_url = paginate.PageURL_WebOb(request)
items = paginate.Page(
items,
page=int(page),
items_per_page=10,
url=page_url,
)
return dict(items=items, lis=lis)
def listadoFasesPorProyecto(self, id_proyecto, page=1):
"""Metodo para listar las Fases de un proyecto """
try:
fasesPorProyecto = DBSession.query(Fase).join(
Fase.relacion_estado_fase).filter(
Fase.id_proyecto == id_proyecto).options(
contains_eager(Fase.relacion_estado_fase)).order_by(
Fase.numero_fase)
# fasesPorProyecto = DBSession.query(Fase).filter_by(id_proyecto=id_proyecto).order_by(Fase.numero_fase)
nombreProyecto = DBSession.query(
Proyecto.nombre).filter_by(id_proyecto=id_proyecto).first()
currentPage = paginate.Page(fasesPorProyecto,
page,
items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Fases del Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/listado")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Fases del Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/listado")
return dict(fasesPorProyecto=currentPage.items,
page='listado_fases',
nombre_proyecto=nombreProyecto,
id_proyecto=id_proyecto,
currentPage=currentPage)
def mentor_lesson_listbycourse(request):
page = int(request.params.get('page', 1))
courseid = request.params.get('courseid')
conn = DBSession()
course=conn.query(Course).filter(Course.id==courseid,Course.mentorid.in_(\
conn.query(Mentor.id).filter(Mentor.userid==request.user.id))).first()
if course:
course_classes = conn.query(Course_Class).filter(
Course_Class.courseid == course.id).all()
course.course_classes = course_classes
items = conn.query(Lesson).filter(Lesson.courseid == course.id,
Lesson.state != -1).all()
for item in items:
lesson_locations = conn.query(Lesson_Location).filter(
Lesson_Location.lessonid == item.id).all()
item.lesson_locations = lesson_locations
page_url = paginate.PageURL_WebOb(request)
items = paginate.Page(
items,
page=int(page),
items_per_page=10,
url=page_url,
)
return dict(items=items, course=course)
return dict(code=0, error=u"课程不存在")
def list(self):
c.pagename = "contacts"
c.heading = "Contacts::List"
c.qw = ""
log.info(config['app_conf']['my_contacts'])
my_contacts = config['app_conf']['my_contacts']
if len(my_contacts) > 2:
c.my_contacts = my_contacts.split(',')
else:
c.my_contacts = []
if "qw" in request.params:
qw = request.params['qw']
else:
qw = "nothing"
c.qw = qw
con = model.Contacts
contacts = model.meta.Session.query(model.Contacts).filter(
con.forsearch.like('%' + qw + '%')).order_by(con.id.asc())
c.contacts = paginate.Page(
contacts,
page=int(request.params.get('page', 1)),
items_per_page=20,
)
return render('/derived/contacts/list.html')
def user_list_view(request):
""" Render the user list page.
Return a paged user list from the database. The paged list can be
ordered by username, first name or last name. Add an error flash message
if the list is empty. Return also basic users statistics.
:param request: a ``pyramid.request`` object
"""
_ = request.translate
stats = get_user_stats()
sortable_columns = ['username', 'first_name', 'last_name']
column = request.params.get('sort')
search = request.params.get('search')
# construct the query
users = DBSession.query(AuthUser)
if column and column in sortable_columns:
users = users.order_by(column)
else:
users = users.order_by(AuthUser.username)
if search:
users = users.filter(AuthUser.username.like('%' + search + '%'))
# add a flash message for empty results
if users.count() == 0:
request.session.flash(_(u"There is no results!"), 'error')
# paginate results
page_url = paginate.PageURL_WebOb(request)
users = paginate.Page(users,
page=int(request.params.get("page", 1)),
items_per_page=20,
url=page_url)
return dict(users=users, stats=stats)
def index(self):
c.topic = "Templates"
c.rows = paginate.Page(model.meta.Session.query(
model.Categories).order_by(model.Categories.typeid.desc()),
page=int(request.params.get('page', 1)),
items_per_page=20)
return render('/derived/categories/list.html')
def student_assignment_list(request):
conn = DBSession()
page = int(request.params.get('page', 1))
s_courseid = request.params.get('s_courseid')
userid = request.user.id
student = conn.query(Student).filter(Student.userid == userid).first()
courses=conn.query(Course).filter(Course.id.in_(\
conn.query(Course_Class.courseid).filter(Course_Class.clazzid\
==student.clazzid))).all()
if s_courseid:
items=conn.query(Assignment,Lesson).filter(Assignment.id.in_(conn.query(Lesson.assignmentid).filter(\
Lesson.courseid==s_courseid,Lesson.courseid.in_(conn.query(Course_Class.courseid).\
filter(Course_Class.clazzid==student.clazzid)))),Assignment.id==Lesson.assignmentid).all()
else:
items=conn.query(Assignment,Lesson).filter(Assignment.id.in_(conn.query(Lesson.assignmentid).filter(\
Lesson.courseid.in_(conn.query(Course_Class.courseid).\
filter(Course_Class.clazzid==student.clazzid)))),Assignment.id==Lesson.assignmentid).all()
page_url = paginate.PageURL_WebOb(request)
items = paginate.Page(
items,
page=int(page),
items_per_page=10,
url=page_url,
)
return dict(items=items, courses=courses)
def listadoAtributosPorTipoItem(self,
id_proyecto,
id_fase,
id_tipo_item,
page=1):
"""Metodo para listar todos los atributos de la base de datos"""
try:
atributos = DBSession.query(Atributo).filter_by(
id_tipo_item=id_tipo_item).order_by(Atributo.id_atributo)
currentPage = paginate.Page(atributos, page, items_per_page=10)
tipo_item = DBSession.query(TipoItem).get(id_tipo_item)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Atributos de Tipo de Item! SQLAlchemyError..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Atributos de Tipo de Item! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/tipo_item/listadoTipoItemPorFase",
id_proyecto=id_proyecto,
id_fase=id_fase)
return dict(atributos=currentPage.items,
page='listado_atributos',
nombre_tipo_item=tipo_item.nombre,
id_proyecto=id_proyecto,
id_fase=id_fase,
id_tipo_item=id_tipo_item,
currentPage=currentPage)
def showsimitems(self, adate, sort):
t = model.Categories
categories = model.meta.Session.query(t).filter_by(
graphtype="realtime").filter_by(d_report=1).order_by(
t.r_weight.desc()).order_by(t.alertlevel.desc()).order_by(
t.rankcode.asc())
if sort == '2':
categories = model.meta.Session.query(t).filter_by(
graphtype="realtime").filter_by(d_report=1).order_by(
t.typeid.desc()).order_by(t.alertlevel.desc()).order_by(
t.rankcode.asc())
elif sort == '1':
categories = model.meta.Session.query(t).filter_by(
graphtype="realtime").filter_by(d_report=1).order_by(
t.typeid.asc()).order_by(t.alertlevel.desc()).order_by(
t.rankcode.asc())
else:
pass
rows = paginate.Page(
categories,
page=int(request.params.get('page', 1)),
#items_per_page = page_rows,
items_per_page=1000,
)
return rows
def viewforum(self, id):
forum_q = model.Session.query(model.Forum).filter_by(id=id)
if len(forum_q.all()) == 0:
abort(404)
c.forum = forum_q.first()
thread_q = model.Session.query(model.Page).filter_by(forumid=id)
#search
c.search_text = request.params.get('search', '')
if not c.search_text == '':
thread_q = thread_q.filter(
model.page_table.c.title.like(u'%' + c.search_text + u'%'))
thread_q = thread_q.order_by(model.page_table.c.posted.desc())
c.paginator = paginate.Page(
thread_q.all(),
page=int(request.params.get('page', 1)),
items_per_page=10,
)
c.empty = False
if len(thread_q.all()) == 0:
c.empty = True
c.active = request.params.get('viewtype', 'new')
return render("forums/viewforum.html")
def archive(self, page=1, direction='dsc',
order_by='timestamp', format=None):
"messages archive"
filters = session.get('filter_by', None)
num_items = session.get('msgs_num_items', 50)
if direction == 'dsc':
sort = desc(order_by)
else:
sort = order_by
messages = self._get_archived().order_by(sort)
msgcount = self._get_msg_count(True)
query = UserFilter(Session, c.user, messages, True)
countquery = UserFilter(Session, c.user, msgcount, True)
messages = query.filter()
msgcount = countquery.filter()
if filters:
dynq = DynaQuery(Archive, messages, filters)
dynmsgq = DynaQuery(Archive, msgcount, filters)
messages = dynq.generate()
msgcount = dynmsgq.generate()
c.order_by = order_by
c.direction = direction
msgcount = msgcount.count()
pages = paginate.Page(messages, page=int(page),
items_per_page=num_items,
item_count=msgcount)
if format == 'json':
response.headers['Content-Type'] = 'application/json'
data = convert_to_json(pages,
direction=direction,
order_by=order_by,
section=None)
return data
c.page = pages
return render('/messages/archive.html')
def _paginate(self, query, appstruct):
"""
wraps the current SQLA query with pagination
"""
if self.use_paginate:
# Url builder for page links
from functools import partial
page_url = partial(get_page_url, request=self.request)
current_page = self._get_current_page(appstruct)
items_per_page = convert_to_int(
appstruct.get('items_per_page', 30), 30
)
self.logger.debug(
" + Page : %s, items per page : %s" % (
current_page, items_per_page
)
)
self.logger.debug(query)
page = paginate.Page(
query,
current_page,
url=page_url,
items_per_page=items_per_page
)
self.logger.debug(page)
return page
else:
return query
def report_list(request):
current_status = status_filters[request.matched_route.name]
current_page = int(request.GET.get("page", 1))
reports = Session.query(PromptReport).order_by(
PromptReport.created.desc(),
).filter(PromptReport.status == current_status).options(
joinedload(PromptReport.reporting_user),
joinedload(PromptReport.reported_user),
).limit(25).offset((current_page-1)*25).all()
# 404 on empty pages.
if current_page!=1 and len(reports)==0:
raise HTTPNotFound
report_count = Session.query(func.count('*')).select_from(PromptReport).filter(PromptReport.status == current_status).scalar()
paginator = paginate.Page(
[],
page=current_page,
items_per_page=25,
item_count=report_count,
url=paginate.PageURL(
request.route_path("admin_report_list"),
{ "page": current_page }
),
)
return {
"PromptReport": PromptReport,
"reports": reports,
"paginator": paginator,
"prompt_categories": prompt_categories,
"prompt_levels": prompt_levels,
}
def usuarioProyecto(self, id_proyecto, page=1):
"""Metodo que permite listar los usuarios que se pueden agregar al proyecto seleccionado"""
try:
proyecto = DBSession.query(Proyecto).get(id_proyecto)
id_proyecto = proyecto.id_proyecto
usuariosProyecto = proyecto.usuarios
usuarios = DBSession.query(Usuario).order_by(
Usuario.id_usuario).all()
for usuario in usuariosProyecto:
if usuarios.count(usuario) >= 1:
usuarios.remove(usuario)
currentPage = paginate.Page(usuarios, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Agregar Usuarios al Proyecto! SQLAlchemyError..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Agregar Usuarios al Proyecto! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
return dict(usuarios=currentPage.items,
page='agregar_usuarios',
currentPage=currentPage,
id_proyecto=id_proyecto,
proyecto=proyecto)
def test_sqlalchemy_orm(self):
session = self.sessionmaker()
q = session.query(self.Note).order_by(self.Note.id)
page = paginate.Page(q)
records = list(page)
eq_(records[0].id, 1)
eq_(records[-1].id, 20)
def rolesProyectoUsuario(self, id_proyecto, id_usuario, page=1):
"""Metodo para listar todos los roles que tiene el usuario seleccionado"""
try:
usuario = DBSession.query(Usuario).get(id_usuario)
rolesProyecto = DBSession.query(Rol).filter_by(
tipo="Proyecto").all()
roles = []
for rol in rolesProyecto:
if usuario.roles.count(rol) == 1:
roles.append(rol)
currentPage = paginate.Page(roles, page, items_per_page=10)
except SQLAlchemyError:
flash(
_("No se pudo acceder a Roles de Usuario! SQLAlchemyError..."),
'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
except (AttributeError, NameError, ValueError):
flash(
_("No se pudo acceder a Roles de Usuario! Hay Problemas con el servidor..."
), 'error')
redirect("/admin/proyecto/usuarios", id_proyecto=id_proyecto)
return dict(roles=currentPage.items,
page='rolesProyectoUsuario',
currentPage=currentPage,
usuario=usuario,
id_proyecto=id_proyecto)
def users(self, page=1, *args, **kw):
"""
Users Managment.
"""
users = DBSession.query(User)
page_url = paginate.PageURL_WebOb(request)
tmpl = ''
dsc = True
order = 'user_id'
if kw:
if 'desc' in kw and kw['desc'] != u'':
if kw['desc'] != u'1':
dsc = False
if 'order_by' in kw and kw['order_by'] != u'':
order = kw['order_by']
if dsc:
users = users.order_by(desc(order).nullslast())
else:
users = users.order_by((order))
currentPage = paginate.Page(users,
page,
url=page_url,
items_per_page=30)
return dict(page='index',
currentPage=currentPage,
tmpl=tmpl,
pname=None)
def listado(self, page=1):
"""Metodo para listar todos los Proyectos existentes de la base de datos"""
try:
proyectos = []
if predicates.has_permission('administracion'):
proyectos = DBSession.query(Proyecto).order_by(
Proyecto.id_proyecto)
elif predicates.has_permission('lider_proyecto'):
usuario = DBSession.query(Usuario).filter_by(
nombre_usuario=request.identity['repoze.who.userid']
).first()
proyectos = usuario.proyectos
currentPage = paginate.Page(proyectos, page, items_per_page=10)
except SQLAlchemyError:
flash(_("No se pudo acceder a Proyectos! SQLAlchemyError..."),
'error')
redirect("/admin")
except (AttributeError, NameError):
flash(
_("No se pudo acceder a Proyectos! Hay Problemas con el servidor..."
), 'error')
redirect("/admin")
return dict(proyectos=currentPage.items,
page='listado_proyecto',
currentPage=currentPage)
def listado(self, page=1):
"""Metodo para listar todos los linea_bases de la base de datos"""
linea_bases = DBSession.query(LineaBase)
currentPage = paginate.Page(linea_bases, page, items_per_page=5)
return dict(linea_bases=currentPage.items,
page='listado',
currentPage=currentPage)