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)