def export(self, **kw): try: current = dt.now() dateStr = current.strftime("%Y%m%d") fileDir = os.path.join(config.get("public_dir"), "report", 'ci', dateStr) if not os.path.exists(fileDir): os.makedirs(fileDir) templatePath = os.path.join(config.get("public_dir"), 'TEMPLATE', "CI_TEMPLATE.xlsx") tempFileName = os.path.join(fileDir, "tmp_%s.xlsx" % current.strftime("%Y%m%d%H%M%S")) realFileName = os.path.join(fileDir, "inventory_report_%s.xlsx" % current.strftime("%Y%m%d%H%M%S")) shutil.copy(templatePath, tempFileName) report_xls = InventoryExcel(templatePath=tempFileName, destinationPath=realFileName) data = [] if kw: data = self._query_ci_result(kw) report_xls.inputData(data=data) report_xls.outputData() try: os.remove(tempFileName) except: pass return serveFile(unicode(realFileName)) except: traceback.print_exc() flash("Export Fail.") redirect("/cireport/index")
def login(self, came_from=url('/')): """Start the user login.""" login_counter = request.environ['repoze.who.logins'] if login_counter > 0: flash(_('Wrong credentials'), 'warning') return dict(page='login', login_counter=str(login_counter), came_from=came_from)
def post_logout(self, came_from=lurl('/')): """ Redirect the user to the initially requested page on logout and say goodbye as well. """ flash(_('Successfully logged out. We hope to see you soon!')) redirect(came_from)
def list(self, id_fase): identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\ filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all() if(len(rol_lider)==0): listar = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\ filter(Permiso.permission_name=="ver_linea_base").\ filter(Usperfa.id_permiso==Permiso.id_permiso).\ filter(RolUsuario.id_usuario==idi).all() if (len(listar)==0): flash("No posee los permisos para ver las lineas bases",'error') redirect("/configuracion/linea_base/error") else: self.id_fase = id_fase fase = DBSession.query(Fase).get(id_fase) tmpl_context.widget = list_lineabase value = list_lineabase_filler.get_value(id_fase=id_fase) else: self.id_fase = id_fase fase = DBSession.query(Fase).get(id_fase) tmpl_context.widget = list_lineabase value = list_lineabase_filler.get_value(id_fase=id_fase) return dict(fase=fase, value=value)
def delete(self, id, **kw): ''' Delete department from DB ''' log.info('delete ' + kw['_id']) DBSession.delete(DBSession.query(Department).get(kw['_id'])) flash(u'Service supprimé', 'notice') redirect('/departments/')
def post_delete(self, languageid): """Delete a Language""" language = DBSession.query(Language).get(languageid.decode()) DBSession.delete(language) flash('%s %s' % (_('Deleted Language:'), language.id), 'ok') return dict(redirect_to=url('/admin/language/'))
def assign_license(self, **kwargs): user_name = request.identity['repoze.who.userid'] user_id = DBSession.query(model.User.user_id).filter(model.User.user_name==user_name).first().user_id #Report if computer or license don't belong to user who is logged in and available > 0 if DBSession.query(model.Computer).filter(model.Computer.id==kwargs['computer'], model.Computer.user_id==user_id).count() < 1 or DBSession.query(model.License).filter(model.License.id==kwargs['license'], model.License.user_id==user_id).count() < 1 or DBSession.query(model.License.available).filter(model.License.id==kwargs['license'], model.License.user_id==user_id).first().available < 1: flash(('This incident has been reported'), 'error') redirect('/manage') a = model.Assignment() a.user_id = user_id a.license_id = kwargs['license'] a.computer_id = kwargs['computer'] a.count = 1 a.locked = False model.DBSession.add(a) license = DBSession.query(model.License).filter(model.License.id==a.license_id).first() license.available = license.available - a.count model.DBSession.flush() flash("Assignment added.") redirect('/manage')
def delete(self, id_fase ,id, show=True, **kw): """ @type id_fase : Integer @param id_fase : Identificador del Rol @type id : Integer @param id : Identificador del usuario a desvincular. @type show : Boolean @param show : Indica si se despelgara el mensaje al culminar la operacion. @type kw : Hash @param kw : Keywords """ fase = fase_util.get_current() list = DBSession.query(UsuarioPermisoFase).\ filter(UsuarioPermisoFase.usuario_id == id).\ filter(UsuarioPermisoFase.fase_id == id_fase) for element in list : DBSession.delete(element) """ Si es false no muestra el mensaje de sobre la operacion, esto es debido que este metodo es reutilizado a la hora de eliminar a un usuario del proyecto """ if show : flash("El usuario '"+ str(id) +"' ha sido desvinculado de la fase.") redirect("/miproyecto/fase/get_all/"+ str(id_fase))
def delete(self, proyecto_id ,id, **kw): """ @type proyecto_id : Integer @param proyecto_id : Identificador del proyecto @type id : Integer @param id : Identificador del usuario a desvincular. @type kw : Hash @param kw : Keywords """ #se obtienen las relaciones del usuario sobre las fases del proyecto list = DBSession.query(UsuarioPermisoFase).\ filter(UsuarioPermisoFase.usuario_id == id).\ filter(Fase.proyecto == proyecto_id).\ filter(UsuarioPermisoFase.fase_id == Fase.id_fase) #Se eliminan las relaciones del usuario con las fases for element in list : DBSession.delete(element) #Se obtienen los roles del usuario en el proyecto list = DBSession.query(RolUsuario).\ filter(RolUsuario.usuario_id == id).\ filter(RolUsuario.rol_id == RolPermisoProyecto.rol_id).\ filter(RolPermisoProyecto.proyecto_id == proyecto_id) #Se eliminan los roles del usuario sobre el proyecto for element in list : DBSession.delete(element) flash("El usuario '"+ str(id) +"' ha sido desvinculado del proyecto.") redirect("/miproyecto/ver/"+str(proyecto_id))
def set_options(self, show_discussion=False, allow_email_posting=False): self.app.config.options[ 'show_discussion'] = show_discussion and True or False self.app.config.options[ 'AllowEmailPosting'] = allow_email_posting and True or False flash('Blog options updated') redirect(request.referer)
def set_exfeed(self, new_exfeed=None, **kw): exfeed_val = kw.get('exfeed', []) if type(exfeed_val) == unicode: tmp_exfeed_list = [] tmp_exfeed_list.append(exfeed_val) else: tmp_exfeed_list = exfeed_val if new_exfeed is not None and new_exfeed != '': tmp_exfeed_list.append(new_exfeed) exfeed_list = [] invalid_list = [] v = validators.URL() for link in tmp_exfeed_list: try: v.to_python(link) exfeed_list.append(link) except formencode.api.Invalid: invalid_list.append(link) self.app.external_feeds_list = exfeed_list flash('External feeds updated') if len(invalid_list) > 0: flash('Invalid link(s): %s' % ','.join(link for link in invalid_list), 'error') redirect(request.referer)
def post_tipo_item(self, nombre_tipo_item, codigo_tipo_item, descripcion, campo, valor): tipo_item = Tipo_Item( nombre_tipo_item=nombre_tipo_item, codigo_tipo_item=codigo_tipo_item, descripcion=descripcion ) DBSession.add(tipo_item) if campo is not None: if not isinstance(campo, list): campo = [campo] if valor is not None: if not isinstance(valor, list): valor = [valor] indice = 0 id_tipo = Tipo_Item.get_ultimo_id() for c in campo: if len(c) > 0: camp = Tipo_Campos(id_tipo_item=id_tipo, nombre_campo=c, valor_campo=valor[indice]) DBSession.add(camp) indice += 1 flash("Tipo Item Agregado!") redirect("/tipo_item/tipo_item")
def refresh(self, **kw): allura.tasks.repo_tasks.refresh.post() if request.referer: flash('Repository is being refreshed') redirect(request.referer or '/') else: return '%r refresh queued.\n' % c.app.repo
def post(self, args={}, **kw): """ Evento invocado luego de un evento post en el form de crear ecargado de persistir las nuevas instancias. @type args : Hash @param args : Argumentos de template @type kw : Hash @param kw : Keywords """ del kw['sprox_id'] rol = Rol() rol.codigo = kw['codigo'] rol.nombre = kw['nombre'] rol.descripcion = kw['descripcion'] for permiso in kw['permisos'] : rol.permisos.append(DBSession.query(Permiso).get(permiso)) DBSession.add(rol) flash("El rol ha sido creado correctamente.") redirect("/administracion/rol/get_all")
def put(self, id_tipo_item, nombre_tipo_item, codigo_tipo_item, descripcion, campo, valor, **kw): if id_tipo_item is not None: id_tipo_item = int(id_tipo_item) tipo_item = Tipo_Item.get_tipo_item_by_id(id_tipo_item) campos2 = Tipo_Campos.get_campos_by_tipo_item(tipo_item.id_tipo_item) for cam in campos2: Tipo_Campos.borrar_by_id(cam.id_tipo_campos) DBSession.flush() tipo_item.nombre_tipo_item = nombre_tipo_item tipo_item.descripcion = descripcion tipo_item.codigo_tipo_item = codigo_tipo_item if campo is not None: if not isinstance(campo, list): campo = [campo] if valor is not None: if not isinstance(valor, list): valor = [valor] indice = 0 for c in campo: if len(c) > 0: camp = Tipo_Campos(id_tipo_item=id_tipo_item, nombre_campo=c, valor_campo=valor[indice]) DBSession.add(camp) indice += 1 DBSession.flush() flash("Tipo de Item modificada!") redirect("/tipo_item/tipo_item")
def update(self, card=None, **kw): permissions = self._index_permissions() old_permissions = dict(permissions) for args in card: perm = args['id'] new_group_ids = args.get('new', []) group_ids = args.get('value', []) if isinstance(new_group_ids, basestring): new_group_ids = [ new_group_ids ] if isinstance(group_ids, basestring): group_ids = [ group_ids ] # make sure the admin group has the admin permission if perm == 'admin': if c.project.is_root: pid = c.project._id else: pid = c.project.parent_id admin_group_id = str(M.ProjectRole.query.get(project_id=pid, name='Admin')._id) if admin_group_id not in group_ids + new_group_ids: flash('You cannot remove the admin group from the admin permission.','warning') group_ids.append(admin_group_id) permissions[perm] = [] role_ids = map(ObjectId, group_ids + new_group_ids) permissions[perm] = role_ids c.project.acl = [] for perm, role_ids in permissions.iteritems(): role_names = lambda ids: ','.join(sorted( pr.name for pr in M.ProjectRole.query.find(dict(_id={'$in':ids})))) old_role_ids = old_permissions.get(perm, []) if old_role_ids != role_ids: M.AuditLog.log('updated "%s" permissions: "%s" => "%s"', perm,role_names(old_role_ids), role_names(role_ids)) c.project.acl += [M.ACE.allow(rid, perm) for rid in role_ids] g.post_event('project_updated') redirect('.')
def put(self, args={}, **kw): """ Evento invocado luego de un evento post en el form de editar ecargado de persistir las modificaciones de las instancias. @type args : Hash @param args : Argumentos de template @type kw : Hash @param kw : Keywords """ del kw['sprox_id'] rol = DBSession.query(Rol).get(int(kw['rol_id'])) rol.nombre = kw['nombre'] rol.codigo = kw['codigo'] rol.descripcion = kw['descripcion'] rol.is_template = kw['is_template'] rol.permisos = [] for permiso_id in kw['permisos'] : rol.permisos.append(DBSession.query(Permiso).get(permiso_id)) DBSession.merge(rol) flash("El rol '"+rol.nombre+"' ha sido modificado correctamente.") redirect("/administracion/rol/get_all")
def set_home(self, new_home): self.app.root_page_name = new_home self.app.upsert_root(new_home) flash('Home updated') mount_base = c.project.url()+self.app.config.options.mount_point+'/' url = h.really_unicode(mount_base).encode('utf-8') + h.really_unicode(new_home).encode('utf-8')+'/' redirect(url)
def check_access(): '''Check access rights / group: admin=full access, boss=users from same department, user. Returns SA Query object for selected CDRs ''' if in_any_group('admin', 'APPELS'): cdrs = DBSession.query(CDR) elif in_group('CDS'): # Find list of phones from the user's list of phones # user_phones -> departments -> phones phones = [] for p in request.identity['user'].phone: log.info('CDS phone %s -> department %s' % (p, p.department)) for d in [d.department for d in request.identity['user'].phone]: log.info('CDS department <%s>' % (d)) for p in d.phones: phones.append(p) src = [prefix_src + p.exten for p in phones] dst = [p.exten for p in phones] cdrs = DBSession.query(CDR).filter( (CDR.src.in_(src)) | (CDR.dst.in_(dst)) ) log.info('CDS phone <%s> -> source <%s>, destination <%s>' % ( request.identity['user'].phone, src, dst)) elif in_group('utilisateurs'): src = [prefix_src + p.exten for p in request.identity['user'].phone] dst = [p.exten for p in request.identity['user'].phone] cdrs = DBSession.query(CDR).filter( (CDR.src.in_(src)) | (CDR.dst.in_(dst)) ) else: flash(u'Accès interdit') redirect('/') return cdrs
def nuevo(self, id_fase, **kw): """Despliega el formulario para añadir una linea base a la fase""" fase=DBSession.query(Fase).get(id_fase) #Comprobación de si el estado de la fase se encuentra en Con Lineas Bases if fase.relacion_estado_fase.nombre_estado=='Con Lineas Bases': flash(_("Todos los items de esta fase ya se encuentran en una Linea Base Aprobada"), 'warning') redirect("/admin/linea_base/listado_linea_bases",id_proyecto=fase.id_proyecto, id_fase=id_fase) tipo_items=DBSession.query(TipoItem).filter_by(id_fase=id_fase) itemsDeFaseActual = [] for tipo_item in tipo_items: itemsTipoItem = DBSession.query(Item).filter_by(id_tipo_item=tipo_item.id_tipo_item).filter_by(vivo=True) for itemTipoItem in itemsTipoItem: itemsDeFaseActual.append(itemTipoItem) contador_items_en_fase_actual = 0 for item in itemsDeFaseActual: contador_items_en_fase_actual = contador_items_en_fase_actual + 1 #Comprobación de si existen items cargados para la fase actual if contador_items_en_fase_actual == 0: flash(_("Aun no existen items cargados para esta fase"), 'warning') redirect("/admin/linea_base/listado_linea_bases",id_proyecto=fase.id_proyecto, id_fase=id_fase) kw['id_estado']= 'Desarrollo' kw['id_fase']= id_fase kw['version']= '1' tmpl_context.form = crear_linea_base_form return dict(nombre_modelo='LineaBase', id_proyecto=fase.id_proyecto, id_fase=id_fase, page='nuevo', value=kw)
def listadoItemsParaAsignaraLineaBase(self, id_proyecto, id_fase, id_linea_base, page=1): """Metodo para listar todos los items a asignar a la linea base""" lineabase=DBSession.query(LineaBase).get(id_linea_base) if lineabase.estado=='Aprobado': flash(_("La Linea Base ya se encuentra aprobada"), 'warning') redirect("/admin/linea_base/listado_linea_bases",id_proyecto=id_proyecto, id_fase=id_fase) linea_bases=DBSession.query(LineaBase).filter_by(id_fase=id_fase) itemsenLineaBase = [] for linea_base in linea_bases: itemsLineaBase = linea_base.items for itemLineaBase in itemsLineaBase: itemsenLineaBase.append(itemLineaBase) #items Contiene todos los items que se encuentran en la fase actual tipo_items=DBSession.query(TipoItem).filter_by(id_fase=id_fase) itemsDeFaseActual = [] for tipo_item in tipo_items: itemsTipoItem = DBSession.query(Item).filter_by(id_tipo_item=tipo_item.id_tipo_item).filter_by(vivo=True).filter_by(estado='Aprobado').order_by(Item.id_item) for itemTipoItem in itemsTipoItem: itemsDeFaseActual.append(itemTipoItem) items=itemsDeFaseActual if itemsenLineaBase != None: for item in itemsenLineaBase: if items.count(item) >= 1: items.remove(item) currentPage = paginate.Page(items, page) return dict(items=currentPage.items, page='listadoItemsParaAsignaraLineaBase', id_proyecto=id_proyecto, id_fase=id_fase, id_linea_base=id_linea_base, currentPage=currentPage)
def put(self, **kw): ''' Update sound in DB ''' id = int(kw['id']) s = DBSession.query(Sound).get(id) if kw.has_key('owner_id'): s.owner_id = kw['owner_id'] s.comment = kw['comment'] wav = kw['file'] filetype = wav.type filedata = wav.file filename = '%s/%d_%s' % (dir_tmp, s.sound_id, wav.filename) # Temporarily save uploaded audio file out = open(filename, 'w') out.write(filedata.read()) out.close() ret = process_file(filename, filetype, s.sound_id, filetype, s.name, s.language) if ret: flash(ret,'error') DBSession.delete(s) redirect('/moh/') flash(u'Son modifié') redirect('/moh/%d/edit' % id)
def saveUpdate(self, **kw): obj=getOr404(JCPItemInfo, kw["id"], "/%s/index"%self.url) combo_mapping_obj = JCPComboMappingInfo.get_by_main_code(obj.packaging_code) params = {"lastModifyBy": request.identity["user"], "lastModifyTime": dt.now() } combo_mapping_params = {"lastModifyBy": request.identity["user"], "lastModifyTime": dt.now() } combo_mapping_fields = ["hangtang_pkg_code", "label_pkg_code", ] combo_mapping_flag = False for f in self.formFields: if f in kw.keys() and f not in combo_mapping_fields: params[f]=kw[f] if f in kw.keys() and len(kw[f]) > 0 and f in combo_mapping_fields: combo_mapping_params[f] = kw[f] combo_mapping_flag = True if params['combo_item'] == 'False': params.pop('combo_packaging_code') for k in params: setattr(obj, k, params[k]) if combo_mapping_flag == True: for key in combo_mapping_params: setattr(combo_mapping_obj[0], key, combo_mapping_params[key]) # obj.set(**params) flash("Update the master successfully!") redirect("/%s/index"%self.url)
def delete(self, **kw): obj=getOr404(self.dbObj, kw["id"], "/%s/index"%self.url) obj.lastModifyBy=request.identity["user"] obj.lastModifyTime=dt.now() obj.status=1 flash("Delete the master successfully!") redirect("/%s/index"%self.url)
def post_delete(self, id): """Elimina una fase de la bd si el proyecto no está iniciado""" fase = Fase.por_id(id) proy = Proyecto.por_id(fase.id_proyecto) proy.eliminar_fase(id) flash("Fase eliminada") redirect("../")
def put_seleccionar_tipo(self, id_fase, nombre_fase, id_tipo_fase, tipos_items, descripcion, asmSelect0, nombre_tipo_fase,**kw): if id_fase is not None: id_fase=int(id_fase) if id_tipo_fase is not None: id_tipo_fase=int(id_tipo_fase) fase = Fase.get_fase_by_id(id_fase) if not isinstance(tipos_items, list): tipos_items = [tipos_items] tipos_items = [DBSession.query(Tipo_Item).get(tipo_item) for tipo_item in tipos_items] fase.nombre_fase = nombre_fase fase.id_tipo_fase=id_tipo_fase fase.estado = fase.estado fase.linea_base = fase.linea_base fase.descripcion = descripcion fase.tipos_items=tipos_items DBSession.flush() flash("Tipos Item agregados!") redirect('/proyecto/proyecto')
def post_miembro(self, idusuario, idrol, asmSelect0, fases): if idusuario is not None: idusuario = int(idusuario) if idrol is not None: idrol = int(idrol) if fases is not None: if not isinstance(fases, list): fases = [fases] fases = [DBSession.query(Fase).get(fase) for fase in fases] valor=int( Variables.get_valor_by_nombre("proyecto_actual")) equipo = Equipo_Desarrollo(proyecto=valor, idusuario=idusuario, idrol=idrol, fases=fases) # usuario = Usuario.get_user_by_id(idusuario) # rol = Rol.get_rol_by_id(idrol) # usuario.roles=[] # usuario.roles.append(rol) DBSession.add(equipo) DBSession.flush() flash("Miembro Agregado Agregado!") redirect('/equipo/equipo')
def export(self, **kw): result_data=[] current=dt.now() dateStr=current.today().strftime("%Y%m%d") fileDir=os.path.join(os.path.abspath(os.path.curdir), "report_download", "%s"%dateStr) if not os.path.exists(fileDir): os.makedirs(fileDir) timeStr=current.time().strftime("%H%M%S") rn=random.randint(0, 10000) username=request.identity['repoze.who.userid'] filename=os.path.join(fileDir, "%s_%s_%d.xls"%(username, timeStr, rn)) templatePath=os.path.join(os.path.abspath(os.path.curdir), "report_download/TEMPLATE/JCP_SPECIAL_VALUE_TEMPLATE.xls") pe=JCPExcel(templatePath=templatePath, destinationPath=filename) try: results=self.searchMaster(kw) if results: for result in results: result_data.append(self._format_value(result)) pe.inputData(additionInfo=[], data=result_data) pe.outputData() return serveFile(unicode(filename)) except: traceback.print_exc() if pe: pe.clearData() flash("Error occur in the Excel Exporting !") raise redirect("report")
def new(self, id_fase, method='', **kw): identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\ filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all() if(len(rol_lider)==0): crear = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\ filter(Permiso.permission_name=="crear_linea_base").\ filter(Usperfa.id_permiso==Permiso.id_permiso).\ filter(RolUsuario.id_usuario==idi).all() if len(crear)==0: flash("No posee los permisos para crear linea base",'error') redirect("/configuracion/linea_base/error") else: ItemsFieldSelect.id_fase = id_fase new_lineabase_form = NewLineaBaseForm(DBSession)#new_lineabase_form tmpl_context.widget = new_lineabase_form else: ItemsFieldSelect.id_fase = id_fase new_lineabase_form = NewLineaBaseForm(DBSession)#new_lineabase_form tmpl_context.widget = new_lineabase_form return dict(value=kw)
def download(self, id, **kw): ''' Download sound ''' s = DBSession.query(Sound).get(id) dir = (dir_moh if s.type==0 else dir_sounds) % s.language fn = '%s/%s.' % (dir, re.sub(r'\W', '_', s.name)) import os for form in ( 'wav', 'sln16', 'sln' ): try: st = os.stat(fn + form) f = open(fn + form) fn += form break except: log.debug(u'Sound file not found %s' % (fn+form)) pass else: flash(u'Fichier sonore introuvable: %s' % fn, 'error') redirect('/moh/') rh = response.headers rh['Pragma'] = 'public' # for IE rh['Expires'] = '0' rh['Cache-Control'] = 'must-revalidate, post-check=0, pre-check=0' #for IE rh['Cache-Control'] = 'max-age=0' #for IE rh['Content-Type'] = 'audio/wav' rh['Content-Disposition'] = str( (u'attachment; filename="%s.%s"; size=%d;' % ( s.name, form, st.st_size)).encode('utf-8') ) rh['Content-Transfer-Encoding'] = 'binary' return f.read()
def aprobar(self, id, **kw): """Metodo invocado para aprobar un item especificado""" identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\ filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all() if(len(rol_lider)==0): aprob = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\ filter(Permiso.permission_name=="aprobar_item").\ filter(Usperfa.id_permiso==Permiso.id_permiso).\ filter(RolUsuario.id_usuario==idi).all() if len(aprob)==0: flash("No posee permiso para aprobar item",'error') redirect("/desarrollo/item/error") else: item = DBSession.query(Item).get(id) item.estado = "aprobado" identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario ahora = time.localtime() anho = str(ahora.tm_year) mes = str(ahora.tm_mon) dia = str(ahora.tm_mday) hora = str(ahora.tm_hour) min = str(ahora.tm_min) seg = str(ahora.tm_sec) historial = Historial() historial.cod_recurso = item.cod_item historial.tipo_recurso = "Item" historial.nombre_recurso = item.nombre_item historial.operacion = "Aprobacion" historial.fecha_operacion = anho+'-'+mes+'-'+dia historial.hora = hora+':'+min+':'+seg historial.nombre_usuario = user.user_name DBSession.add(historial) flash("Item aprobado") redirect('/desarrollo/item/list/'+str(self.id_fase)) #~ else: #~ item = DBSession.query(Item).get(id) #~ item.estado = "aprobado" else:#*******************************************************************************************desde aca item = DBSession.query(Item).get(id) item.estado = "aprobado" iditem = item.id_item if (item.id_lb!=None): """Si todos los items de la linea base, que fueron modificados, se aprueban, la linea base se cierra automaticamente""" lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==iditem).one() print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %s") % (lb) list_items = [] apro = 0 list_items = DBSession.query(Item).filter(Item.id_lb==lb).all() for k in list_items: if (k.estado == "aprobado"): apro = apro + 1 if(len(list_items)==apro): li_b = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all() for m in li_b: m.estado = "cerrado" DBSession.merge(m) #**************************************************************************************hasta aca identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario ahora = time.localtime() anho = str(ahora.tm_year) mes = str(ahora.tm_mon) dia = str(ahora.tm_mday) hora = str(ahora.tm_hour) min = str(ahora.tm_min) seg = str(ahora.tm_sec) historial = Historial() historial.cod_recurso = item.cod_item historial.tipo_recurso = "Item" historial.nombre_recurso = item.nombre_item historial.operacion = "Aprobacion" historial.fecha_operacion = anho+'-'+mes+'-'+dia historial.hora = hora+':'+min+':'+seg historial.nombre_usuario = user.user_name DBSession.add(historial) flash("Item aprobado") redirect('/desarrollo/item/list/'+str(self.id_fase))
class PreferencesController(BaseController): @with_trailing_slash @expose('jinja:allura:templates/user_preferences.html') def index(self, **kw): require_authenticated() c.form = F.subscription_form c.revoke_access = F.oauth_revocation_form subscriptions = [] mailboxes = M.Mailbox.query.find(dict(user_id=c.user._id, is_flash=False)) mailboxes = list(mailboxes.ming_cursor) project_collection = M.Project.query.mapper.collection app_collection = M.AppConfig.query.mapper.collection projects = dict( (p._id, p) for p in project_collection.m.find(dict( _id={'$in': [mb.project_id for mb in mailboxes ]}))) app_index = dict( (ac._id, ac) for ac in app_collection.m.find(dict( _id={'$in': [mb.app_config_id for mb in mailboxes]}))) for mb in mailboxes: project = projects.get(mb.project_id, None) app_config = app_index.get(mb.app_config_id, None) if project is None: mb.m.delete() continue if app_config is None: continue title = mb.artifact_title if mb.artifact_url: title = '<a href="%s">%s</a>' % (mb.artifact_url,title) subscriptions.append(dict( _id=mb._id, project_name=project.name, mount_point=app_config.options['mount_point'], artifact_title=title, topic=mb.topic, type=mb.type, frequency=mb.frequency.unit, artifact=mb.artifact_index_id)) api_token = M.ApiToken.query.get(user_id=c.user._id) provider = plugin.AuthenticationProvider.get(request) menu = provider.account_navigation() return dict( subscriptions=subscriptions, api_token=api_token, authorized_applications=M.OAuthAccessToken.for_user(c.user), menu=menu) @h.vardec @expose() @require_post() def update(self, display_name=None, addr=None, new_addr=None, primary_addr=None, oid=None, new_oid=None, preferences=None, **kw): require_authenticated() if config.get('auth.method', 'local') == 'local': if display_name is None: flash("Display Name cannot be empty.",'error') redirect('.') c.user.set_pref('display_name', display_name) for i, (old_a, data) in enumerate(zip(c.user.email_addresses, addr or [])): obj = c.user.address_object(old_a) if data.get('delete') or not obj: del c.user.email_addresses[i] if obj: obj.delete() c.user.set_pref('email_address', primary_addr) if new_addr.get('claim'): if M.EmailAddress.query.get(_id=new_addr['addr'], confirmed=True): flash('Email address already claimed', 'error') else: c.user.email_addresses.append(new_addr['addr']) em = M.EmailAddress.upsert(new_addr['addr']) em.claimed_by_user_id=c.user._id em.send_verification_link() for i, (old_oid, data) in enumerate(zip(c.user.open_ids, oid or [])): obj = c.user.openid_object(old_oid) if data.get('delete') or not obj: del c.user.open_ids[i] if obj: obj.delete() for k,v in preferences.iteritems(): if k == 'results_per_page': v = int(v) c.user.set_pref(k, v) if 'email_format' in preferences: c.user.set_pref('email_format', preferences['email_format']) redirect('.') @h.vardec @expose() @require_post() @validate(F.subscription_form, error_handler=index) def update_subscriptions(self, subscriptions=None, **kw): for s in subscriptions: if s['unsubscribe']: s['_id'].delete() redirect(request.referer) @expose() @require_post() def gen_api_token(self): tok = M.ApiToken.query.get(user_id=c.user._id) if tok is None: tok = M.ApiToken(user_id=c.user._id) else: tok.secret_key = h.cryptographic_nonce() redirect(request.referer) @expose() @require_post() def del_api_token(self): tok = M.ApiToken.query.get(user_id=c.user._id) if tok is None: return tok.delete() redirect(request.referer) @expose() @require_post() def revoke_oauth(self, _id=None): tok = M.OAuthAccessToken.query.get(_id=bson.ObjectId(_id)) if tok is None: flash('Invalid app ID', 'error') redirect('.') if tok.user_id != c.user._id: flash('Invalid app ID', 'error') redirect('.') tok.delete() flash('Application access revoked') redirect('.') @expose() @require_post() @validate(V.NullValidator(), error_handler=index) def change_password(self, **kw): kw = g.theme.password_change_form.to_python(kw, None) ap = plugin.AuthenticationProvider.get(request) try: ap.set_password(c.user, kw['oldpw'], kw['pw']) except wexc.HTTPUnauthorized: flash('Incorrect password', 'error') redirect('.') flash('Password changed') redirect('.') @expose() @require_post() def upload_sshkey(self, key=None): ap = plugin.AuthenticationProvider.get(request) try: ap.upload_sshkey(c.user.username, key) except AssertionError, ae: flash('Error uploading key: %s' % ae, 'error') flash('Key uploaded') redirect('.')
def claim_process_oid(self, **kw): oid_obj = process_oid(failure_redirect='claim_oid') if c.user: c.user.claim_openid(oid_obj._id) flash('Claimed %s' % oid_obj._id) redirect('/auth/prefs/')
def get_all(self, *args, **kw): """Return all records. Pagination is done by offset/limit in the filler method. Returns an HTML page with the records if not json. """ if self.pagination: paginator = request.paginators['value_list'] paginator.paginate_items_per_page = self.pagination[ 'items_per_page'] else: paginator = request.paginators['value_list'] paginator.paginate_items_per_page = -1 paginator.paginate_page = 0 if tg.request.response_type == 'application/json': adapt_params_for_pagination(kw, self.pagination_enabled) try: count, values = self.table_filler._do_get_provider_count_and_objs( **kw) except Exception as e: abort(400, detail=unicode_text(e)) values = self._dictify(values, length=count) if self.pagination_enabled: values = SmartPaginationCollection(values, count) return dict(value_list=values) if not getattr(self.table.__class__, '__retrieves_own_value__', False): kw.pop('substring_filters', None) if self.substring_filters is True: substring_filters = list( set(kw.keys()) - set(['limit', 'offset', 'order_by', 'desc'])) else: substring_filters = self.substring_filters adapt_params_for_pagination(kw, self.pagination_enabled) try: values = self.table_filler.get_value( substring_filters=substring_filters, **kw) except Exception as e: flash( 'Invalid search query "%s": %s' % (request.query_string, e), 'warn') # Reset all variables to sane defaults kw = {} values = [] self.table_filler.__count__ = 0 if self.pagination_enabled: values = SmartPaginationCollection(values, self.table_filler.__count__) else: values = [] tmpl_context.widget = self.table search_fields = self._get_search_fields(kw) current_search = self._get_current_search(search_fields) return dict( model=self.model.__name__, value_list=values, mount_point=self._mount_point(), headers=search_fields, # Just for backwards compatibility search_fields=search_fields, current_search=current_search)
def remove(self, **kw): cat = M.TroveCategory.query.get(trove_cat_id=int(kw['categoryid'])) if cat.trove_parent_id: parent = M.TroveCategory.query.get( trove_cat_id=cat.trove_parent_id) redirecturl = '/categories/%s' % parent.trove_cat_id else: redirecturl = '/categories' if len(cat.subcategories) > 0: m = "This category contains at least one sub-category, " m = m + "therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.User.withskill(cat).count() > 0: m = "This category is used as a skill by at least a user, " m = m + "therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_root_database=cat._id): m = "This category is used as a database by at least a project, " m = m + "therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_developmentstatus=cat._id): m = "This category is used as development status by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_audience=cat._id): m = "This category is used as intended audience by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_license=cat._id): m = "This category is used as a license by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_os=cat._id): m = "This category is used as operating system by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_language=cat._id): m = "This category is used as programming language by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_topic=cat._id): m = "This category is used as a topic by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_natlanguage=cat._id): m = "This category is used as a natural language by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return if M.Project.query.get(trove_environment=cat._id): m = "This category is used as an environment by at least a " m = m + "project, therefore it can't be removed." flash(m, "error") redirect(redirecturl) return M.TroveCategory.delete(cat) flash('Category removed.') redirect(redirecturl)
def login(self, came_from=lurl('/')): """Start the user login.""" login_counter = request.environ['repoze.who.logins'] if login_counter > 0: flash(_('Wrong credentials.'), 'warning') return dict(page='login', login_counter=str(login_counter), came_from=came_from)
def post(self, id_fase, method='', **kw): """Metodo invocado para persistir los datos del item creado en la BD""" del kw['sprox_id'] funciones = Funciones() item = Item() item.id_tipoitem = kw['tipo_item'] tipoitem = DBSession.query(TipoItem).filter(TipoItem.id_tipoitem==item.id_tipoitem).first() cod_tipoitem = tipoitem.cod_tipoitem item.cod_item = str(cod_tipoitem)+str(funciones.generador_codigo_item(cod_tipoitem)) item.nombre_item = kw['nombre_item'] item.descripcion = kw['descripcion'] item.version = 1#kw['version'] item.estado = "en desarrollo" item.complejidad = kw['complejidad'] id_fa = id_fase item.id_tipoitem = kw['tipo_item'] DBSession.add(item) DBSession.flush() #VERSIONADO_ITEM cod_tipoitem_versionado = DBSession.query(TipoItem.cod_tipoitem).filter(TipoItem.id_tipoitem==item.id_tipoitem).first() versionadoitem = VersionadoItem() versionadoitem.cod_item = item.cod_item versionadoitem.cod_tipoitem= cod_tipoitem_versionado versionadoitem.nombre_item = item.nombre_item versionadoitem.descripcion = item.descripcion versionadoitem.version = item.version versionadoitem.complejidad = item.complejidad DBSession.add(versionadoitem) DBSession.flush() print ("0000000000000000000000000000000000000000000000000000000000000000 VERSIONADO %s") % (versionadoitem.id_versionado) #se crean los detalles del item en base a los detalles del tipo detalles = DBSession.query(DetalleTipoItem.id_detalletipoitem).filter(DetalleTipoItem.id_tipoitem==kw['tipo_item']).all() for i in detalles: detalle = DBSession.query(DetalleTipoItem).get(i) atributo = DetalleItem() atributo.id_item = item.id_item atributo.tipo_dato = DBSession.query(DetalleTipoItem.tipo_dato).filter(DetalleTipoItem.id_detalletipoitem==i).first() atributo.id_detalletipoitem = i atributo.cod_detalleitem = funciones.generador_codigo(detalle.nombre_atributo) atributo.cod_detalletipoitem = DBSession.query(DetalleTipoItem.cod_detalletipoitem).filter(DetalleTipoItem.id_detalletipoitem==i).first() atributo.nombre_atributo = detalle.nombre_atributo atributo.valor = None #atributo.archivo = None DBSession.add(atributo) #DETALLE_VERSIONADO_ITEM detalleversionadoitem = DetalleVersionadoItem() detalleversionadoitem.id_versionado = versionadoitem.id_versionado detalleversionadoitem.cod_item = item.cod_item detalleversionadoitem.cod_detalleitem = atributo.cod_detalleitem detalleversionadoitem.cod_detalletipoitem = atributo.cod_detalletipoitem detalleversionadoitem.nombre_atributo = detalle.nombre_atributo detalleversionadoitem.tipo_dato = atributo.tipo_dato detalleversionadoitem.valor = None #detalleversionadoitem.archivo = atributo.archivo DBSession.add(detalleversionadoitem) identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario ahora = time.localtime() anho = str(ahora.tm_year) mes = str(ahora.tm_mon) dia = str(ahora.tm_mday) hora = str(ahora.tm_hour) min = str(ahora.tm_min) seg = str(ahora.tm_sec) historial = Historial() historial.cod_recurso = item.cod_item historial.tipo_recurso = "Item" historial.nombre_recurso = item.nombre_item historial.operacion = "Creacion" historial.fecha_operacion = anho+'-'+mes+'-'+dia historial.hora = hora+':'+min+':'+seg historial.nombre_usuario = user.user_name DBSession.add(historial) flash('Item creado') redirect('/desarrollo/item/list/'+str(id_fa))
def put(self, id='', **kw): """Metodo invocado para persistir los datos modificados """ del kw['sprox_id'] item = DBSession.query(Item).get(id) id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).all() for i in id_fase: fase = DBSession.query(Fase).get(i) print ("0000000000000000000000000000000000000000000000000000000 version del item en put es: %d") % (item.version) item.nombre_item = kw['nombre_item'] item.descripcion = kw['descripcion'] item.estado = "revision" #item.id_tipoitem = kw['tipo_item'] item.version = item.version + 1 item.complejidad = kw['complejidad'] DBSession.merge(item) """ si el item se encuentra en una linea base, esta debe estar abierta... una vez abierta, debe pasar a estado comprometido """ #relaciones del item modificado list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all() print ("wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww linea base del item en put es: %s") % (list_relaciones) for i in list_relaciones: iditem = DBSession.query(Relacion.id_item2).filter(Relacion.id_relacion==i).one() lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==iditem).one() print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %d") % (lb) linea = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all() for j in linea: j.estado = "comprometida" DBSession.merge(j) lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).first() if lb is not None: print ("0000000000000000000000000000000000000000000000000000000 linea base del item en put es: %d") % (lb) linea = DBSession.query(LineaBase).filter(LineaBase.id_lb==lb).all() for i in linea: i.estado = "comprometida" DBSession.merge(i) #Aqui se Agrega el registro del item a la taba de versionado cod_tipoitem_versionado = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).first() versionadoitem = VersionadoItem() versionadoitem.cod_item = item.cod_item versionadoitem.cod_tipoitem= cod_tipoitem_versionado versionadoitem.nombre_item = item.nombre_item versionadoitem.descripcion = item.descripcion versionadoitem.version = item.version versionadoitem.complejidad = item.complejidad DBSession.add(versionadoitem) DBSession.flush() identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario ahora = time.localtime() anho = str(ahora.tm_year) mes = str(ahora.tm_mon) dia = str(ahora.tm_mday) hora = str(ahora.tm_hour) min = str(ahora.tm_min) seg = str(ahora.tm_sec) historial = Historial() historial.cod_recurso = item.cod_item historial.tipo_recurso = "Item" historial.nombre_recurso = item.nombre_item historial.operacion = "Modificacion" historial.fecha_operacion = anho+'-'+mes+'-'+dia historial.hora = hora+':'+min+':'+seg historial.nombre_usuario = user.user_name DBSession.add(historial) flash('Item modificado') redirect("/desarrollo/item/list/"+str(fase.id_fase))
def index(self): flash(_("Hello World!")) return dict(page='index', idproject=None)
def post_delete(self, id, **kw): """Metodo invocado para eliminar un item especificado""" identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\ filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all() if(len(rol_lider)==0): eliminar = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\ filter(Permiso.permission_name=="eliminar_item").\ filter(Usperfa.id_permiso==Permiso.id_permiso).\ filter(RolUsuario.id_usuario==idi).all() if len(list)==0: flash("No posee los permisos para eliminar los items de la fase",'error') redirect("/desarrollo/item/error") else: list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all() for i in list_relaciones: DBSession.delete(DBSession.query(Relacion).get(i)) item = DBSession.query(Item).get(int(id)) identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario ahora = time.localtime() anho = str(ahora.tm_year) mes = str(ahora.tm_mon) dia = str(ahora.tm_mday) hora = str(ahora.tm_hour) min = str(ahora.tm_min) seg = str(ahora.tm_sec) historial = Historial() historial.cod_recurso = item.cod_item historial.tipo_recurso = "Item" historial.nombre_recurso = item.nombre_item historial.operacion = "Eliminacion" historial.fecha_operacion = anho+'-'+mes+'-'+dia historial.hora = hora+':'+min+':'+seg historial.nombre_usuario = user.user_name DBSession.add(historial) DBSession.delete(DBSession.query(Item).get(id)) redirect('/desarrollo/item/list/'+str(self.id_fase)) else: list_relaciones = DBSession.query(Relacion.id_relacion).filter(Relacion.id_item1==id).all() for i in list_relaciones: DBSession.delete(DBSession.query(Relacion).get(i)) item = DBSession.query(Item).get(int(id)) identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario ahora = time.localtime() anho = str(ahora.tm_year) mes = str(ahora.tm_mon) dia = str(ahora.tm_mday) hora = str(ahora.tm_hour) min = str(ahora.tm_min) seg = str(ahora.tm_sec) historial = Historial() historial.cod_recurso = item.cod_item historial.tipo_recurso = "Item" historial.nombre_recurso = item.nombre_item historial.operacion = "Eliminacion" historial.fecha_operacion = anho+'-'+mes+'-'+dia historial.hora = hora+':'+min+':'+seg historial.nombre_usuario = user.user_name DBSession.add(historial) DBSession.delete(DBSession.query(Item).get(id)) redirect('/desarrollo/item/list/'+str(self.id_fase))
def post_logout(self, came_from=url('/')): """Redirect the user to the root page on logout and say goodbye as well.""" flash(_('We hope to see you soon!')) redirect('/')
def edit(self, id,**kw): """Metodo para editar un item""" identity = request.environ.get('repoze.who.identity') if identity is not None: user = identity.get('user') idi = user.id_usuario rol_lider = DBSession.query(RolUsuario).filter(RolUsuario.id_usuario==idi).\ filter(Rol.group_name=="lider").filter(Rol.id_rol == RolUsuario.id_rol).all() if(len(rol_lider)==0): id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() editar = DBSession.query(Usperfa).filter(Usperfa.id_fase==id_fase).\ filter(Permiso.permission_name=="editar_item").\ filter(Usperfa.id_permiso==Permiso.id_permiso).\ filter(RolUsuario.id_usuario==idi).all() if len(editar)==0: flash("No posee los permisos para editar los items de la fase",'error') redirect("/desarrollo/item/error") else:#********************************************************************************************desde aca item = DBSession.query(Item).get(id) ide_lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).first() print ("0000000000000000000000000000000000000000000000000000000 %d") % (ide_lb) if ide_lb is not None: estado_lb = DBSession.query(LineaBase.estado).filter(LineaBase.id_lb==ide_lb).one() if (estado_lb != "cerrado"): id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() #edit_item_form.tipo_item.id_fase = id_fase tmpl_context.widget = edit_item_form kw['id_item'] = item.id_item value = edit_item_filler.get_value(kw) else: if (estado_lb == "cerrado"): ide_lb = DBSession.query(Item.id_lb).filter(Item.id_item==id).one() id_fa = DBSession.query(LineaBase.id_fase).filter(LineaBase.id_lb==ide_lb).one() ###### flash("El item pertenece a una Linea Base cerrada",'error') redirect("/desarrollo/item/error") #~ redirect('/desarrollo/item/list/'+str(id_fa)) else: item = DBSession.query(Item).get(id) id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() #edit_item_form.tipo_item.id_fase = id_fase tmpl_context.widget = edit_item_form kw['id_item'] = item.id_item value = edit_item_filler.get_value(kw) else: item = DBSession.query(Item).get(id) # if para controlar... ide_lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).first() if ide_lb is not None: id_fase = DBSession.query(LineaBase.id_fase).filter(LineaBase.id_lb==ide_lb).one() estado_lb = DBSession.query(LineaBase.estado).filter(LineaBase.id_lb==ide_lb).one() if (estado_lb != "cerrado"): id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() #### id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() #### #edit_item_form.tipo_item.id_fase = id_fase tmpl_context.widget = edit_item_form kw['id_item'] = item.id_item value = edit_item_filler.get_value(kw) else: if (estado_lb == "cerrado"): item = DBSession.query(Item).get(id) ### ide_lb = DBSession.query(ItemLineaBase.id_lb).filter(ItemLineaBase.id_item==id).one() ### id_fa = DBSession.query(LineaBase.id_fase).filter(LineaBase.id_lb==ide_lb).one() ### flash("El item pertenece a una Linea Base cerrada",'error') redirect("/desarrollo/item/error") else: item = DBSession.query(Item).get(id) id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() #edit_item_form.tipo_item.id_fase = id_fase tmpl_context.widget = edit_item_form kw['id_item'] = item.id_item value = edit_item_filler.get_value(kw) #~ else: #~ item = DBSession.query(Item).get(id) #~ id_tipo = DBSession.query(Item.id_tipoitem).filter(Item.id_item==id).one() #~ id_fase = DBSession.query(TipoItem.id_fase).filter(TipoItem.id_tipoitem==id_tipo).one() #~ #edit_item_form.tipo_item.id_fase = id_fase #~ tmpl_context.widget = edit_item_form #~ kw['id_item'] = item.id_item #~ value = edit_item_filler.get_value(kw) return dict(id_fase=id_fase, value=value)
def flag_as_spam(self, **kw): require_access(self.thread, 'moderate') self.thread.spam() flash('Thread flagged as spam.') redirect(self.discussion.url())
def set_language(self, languageid, came_from=url('/')): """Set language cookie""" language = DBSession.query(Language).get(languageid.decode()) response.set_cookie('lang', language.id) flash('%s %s' % (_('Preferred language set to:'), language.name)) redirect(came_from)
def index(self): """Let the user know that's visiting a protected controller.""" flash(_("Secure Controller here")) return dict(page='index')
def unset_language(self, came_from=url('/')): """Delete language cookie""" response.delete_cookie('lang') flash(_('No preferred language')) redirect(came_from)
def post(self, label, parent_id=None, can_contain_folders=False, can_contain_threads=False, can_contain_files=False, can_contain_pages=False): # TODO - SECURE THIS workspace = tmpl_context.workspace api = ContentApi(tmpl_context.current_user) redirect_url_tmpl = '/workspaces/{}/folders/{}' redirect_url = '' try: parent = None if parent_id: parent = api.get_one(int(parent_id), ContentType.Folder, workspace) with DBSession.no_autoflush: folder = api.create(ContentType.Folder, workspace, parent, label) subcontent = dict( folder=True if can_contain_folders == 'on' else False, thread=True if can_contain_threads == 'on' else False, file=True if can_contain_files == 'on' else False, page=True if can_contain_pages == 'on' else False) api.set_allowed_content(folder, subcontent) if not self._path_validation.validate_new_content(folder): return render_invalid_integrity_chosen_path( folder.get_label(), ) api.save(folder) tg.flash(_('Folder created'), CST.STATUS_OK) redirect_url = redirect_url_tmpl.format(tmpl_context.workspace_id, folder.content_id) except Exception as e: logger.error( self, 'An unexpected exception has been catched. Look at the traceback below.' ) traceback.print_exc() tb = sys.exc_info()[2] tg.flash( _('Folder not created: {}').format(e.with_traceback(tb)), CST.STATUS_ERROR) if parent_id: redirect_url = redirect_url_tmpl.format( tmpl_context.workspace_id, parent_id) else: redirect_url = '/workspaces/{}'.format( tmpl_context.workspace_id) #### # # INFO - D.A. - 2014-10-22 - Do not put redirect in a # try/except block as redirect is using exceptions! # tg.redirect(tg.url(redirect_url))
def save(self, name, events_type): new_calendar = create_calendar(name=name, events_type=events_type) model.DBSession.flush() flash(_('Calendar successfully added')) return plug_redirect('calendarevents', '/calendar/%d' % new_calendar.uid)
def put(self, item_id, file_data=None, comment=None, label=None): # TODO - SECURE THIS workspace = tmpl_context.workspace try: api = ContentApi(tmpl_context.current_user) item = api.get_one(int(item_id), self._item_type, workspace) label_changed = False if label is not None and label != item.label: label_changed = True if label is None: label = '' # TODO - D.A. - 2015-03-19 # refactor this method in order to make code easier to understand with new_revision(item): if (comment and label) or (not comment and label_changed): updated_item = api.update_content( item, label if label else item.label, comment if comment else '') # Display error page to user if chosen label is in conflict if not self._path_validation.validate_new_content( updated_item, ): return render_invalid_integrity_chosen_path( updated_item.get_label_as_file(), ) api.save(updated_item, ActionDescription.EDITION) # This case is the default "file title and description update" # In this case the file itself is not revisionned else: # So, now we may have a comment and/or a file revision if comment and '' == label: comment_item = api.create_comment(workspace, item, comment, do_save=False) if not isinstance(file_data, FieldStorage): api.save(comment_item, ActionDescription.COMMENT) else: # The notification is only sent # if the file is NOT updated # # If the file is also updated, # then a 'file revision' notification will be sent. api.save(comment_item, ActionDescription.COMMENT, do_notify=False) if isinstance(file_data, FieldStorage): api.update_file_data(item, file_data.filename, file_data.type, file_data.file.read()) # Display error page to user if chosen label is in # conflict if not self._path_validation.validate_new_content( item, ): return render_invalid_integrity_chosen_path( item.get_label_as_file(), ) api.save(item, ActionDescription.REVISION) msg = _('{} updated').format(self._item_type_label) tg.flash(msg, CST.STATUS_OK) tg.redirect( self._std_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, item.content_id)) except ValueError as e: msg = _('{} not updated - error: {}').format( self._item_type_label, str(e)) tg.flash(msg, CST.STATUS_ERROR) tg.redirect( self._err_url.format(tmpl_context.workspace_id, tmpl_context.folder_id, item_id))
def reclone_repo(self, prefix=None, shortname=None, mount_point=None, **data): if request.method == 'POST': if c.form_errors: error_msg = 'Error: ' for msg in list(c.form_errors): names = { 'prefix': 'Neighborhood prefix', 'shortname': 'Project shortname', 'mount_point': 'Repository mount point' } error_msg += '%s: %s ' % (names[msg], c.form_errors[msg]) flash(error_msg, 'error') return dict(prefix=prefix, shortname=shortname, mount_point=mount_point) nbhd = M.Neighborhood.query.get(url_prefix='/%s/' % prefix) if not nbhd: flash('Neighborhood with prefix %s not found' % prefix, 'error') return dict(prefix=prefix, shortname=shortname, mount_point=mount_point) c.project = M.Project.query.get(shortname=shortname, neighborhood_id=nbhd._id) if not c.project: flash( 'Project with shortname %s not found in neighborhood %s' % (shortname, nbhd.name), 'error') return dict(prefix=prefix, shortname=shortname, mount_point=mount_point) c.app = c.project.app_instance(mount_point) if not c.app: flash( 'Mount point %s not found on project %s' % (mount_point, c.project.shortname), 'error') return dict(prefix=prefix, shortname=shortname, mount_point=mount_point) source_url = c.app.config.options.get('init_from_url') source_path = c.app.config.options.get('init_from_path') if not (source_url or source_path): flash('%s does not appear to be a cloned repo' % c.app, 'error') return dict(prefix=prefix, shortname=shortname, mount_point=mount_point) allura.tasks.repo_tasks.reclone_repo.post(prefix=prefix, shortname=shortname, mount_point=mount_point) flash('Repository is being recloned') else: prefix = 'p' shortname = '' mount_point = '' return dict(prefix=prefix, shortname=shortname, mount_point=mount_point)
def update(self, title=None, text=None, labels=None, viewable_by=None, new_viewable_by=None, **kw): activity_verb = 'created' if not title: flash('You must provide a title for the page.', 'error') redirect('edit') title = title.replace('/', '-') if not self.page: # the page doesn't exist yet, so create it self.page = WM.Page.upsert(self.title) self.page.viewable_by = ['all'] else: require_access(self.page, 'edit') activity_verb = 'modified' name_conflict = None if self.page.title != title: name_conflict = WM.Page.query.find( dict(app_config_id=c.app.config._id, title=title, deleted=False)).first() if name_conflict: flash('There is already a page named "%s".' % title, 'error') else: if self.page.title == c.app.root_page_name: WM.Globals.query.get( app_config_id=c.app.config._id).root = title self.page.title = title activity_verb = 'renamed' self.page.text = text if labels: self.page.labels = labels.split(',') else: self.page.labels = [] self.page.commit() g.spam_checker.check(text, artifact=self.page, user=c.user, content_type='wiki') g.director.create_activity(c.user, activity_verb, self.page, target=c.project) if new_viewable_by: if new_viewable_by == 'all': self.page.viewable_by.append('all') else: user = c.project.user_in_project(str(new_viewable_by)) if user: self.page.viewable_by.append(user.username) if viewable_by: for u in viewable_by: if u.get('delete'): if u['id'] == 'all': self.page.viewable_by.remove('all') else: user = M.User.by_username(str(u['id'])) if user: self.page.viewable_by.remove(user.username) redirect('../' + h.really_unicode(self.page.title).encode('utf-8') + ('/' if not name_conflict else '/edit'))
def put(self, item_id, folder_id='0'): """ :param item_id: :param folder_id: id of the folder, in a style like 'workspace_14__content_1586' :return: """ # TODO - SECURE THIS workspace = tmpl_context.workspace item_id = int(item_id) new_workspace, new_parent = convert_id_into_instances(folder_id) if new_workspace != workspace: # check that user is at least # - content manager in current workspace # - content manager in new workspace user = tmpl_context.current_user if user.get_role(workspace) < UserRoleInWorkspace.CONTENT_MANAGER: tg.flash(_('You are not allowed ' 'to move this folder'), CST.STATUS_ERROR) tg.redirect(self.parent_controller.url(item_id)) if user.get_role( new_workspace) < UserRoleInWorkspace.CONTENT_MANAGER: tg.flash( _('You are not allowed to move ' 'this folder to this workspace'), CST.STATUS_ERROR) tg.redirect(self.parent_controller.url(item_id)) api = ContentApi(tmpl_context.current_user) item = api.get_one(item_id, ContentType.Any, workspace) with new_revision(item): api.move_recursively(item, new_parent, new_workspace) next_url = tg.url('/workspaces/{}/folders/{}'.format( new_workspace.workspace_id, item_id)) if new_parent: tg.flash( _('Item moved to {} (workspace {})').format( new_parent.label, new_workspace.label), CST.STATUS_OK) else: tg.flash( _('Item moved to workspace {}').format( new_workspace.label)) tg.redirect(next_url) else: # Default move inside same workspace api = ContentApi(tmpl_context.current_user) item = api.get_one(item_id, ContentType.Any, workspace) with new_revision(item): api.move(item, new_parent) next_url = self.parent_controller.url(item_id) if new_parent: tg.flash( _('Item moved to {}').format(new_parent.label), CST.STATUS_OK) else: tg.flash(_('Item moved to workspace root')) tg.redirect(next_url)
def flash_unicode(self): tg.flash(u"Привет, мир!") tg.redirect("/flash_after_redirect")
def _default(self, *args, **kw): """Maneja las urls no encontradas""" flash(_('Recurso no encontrado'), 'warning') redirect('/') return dict(page='index')
def flash_redirect(self): tg.flash("Wow, flash!") tg.redirect("/flash_after_redirect")
def flash_no_redirect(self): tg.flash("Wow, flash!") return tg.get_flash()
def rate_limit(): if BM.BlogPost.is_limit_exceeded(c.app.config, user=c.user): msg = 'Create/edit rate limit exceeded. ' log.warn(msg + c.app.config.url()) flash(msg + 'Please try again later.', 'error') redirect(c.app.config.url())
def bigflash_redirect(self): tg.flash('x' * 5000) tg.redirect('/flash_after_redirect')
def post(self, name, languageid, description): """create a new Category""" category = Category(name, languageid, description) DBSession.add(category) flash('%s %s' % (_('Created Category:'), category.id), 'ok') return dict(redirect_to=url('/admin/category/'))
def put(self, new_profile): # FIXME - Allow only self password or operation for managers current_user = tmpl_context.current_user user = tmpl_context.user group_api = GroupApi(current_user) if current_user.user_id == user.user_id: tg.flash(_('You can\'t change your own profile'), CST.STATUS_ERROR) tg.redirect(self.parent_controller.url()) redirect_url = self.parent_controller.url(skip_id=True) if new_profile not in self.allowed_profiles: tg.flash(_('Unknown profile'), CST.STATUS_ERROR) tg.redirect(redirect_url) pod_user_group = group_api.get_one(Group.TIM_USER) pod_manager_group = group_api.get_one(Group.TIM_MANAGER) pod_admin_group = group_api.get_one(Group.TIM_ADMIN) flash_message = _( 'User updated.') # this is the default value ; should never appear if new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_USER: if pod_user_group not in user.groups: user.groups.append(pod_user_group) try: user.groups.remove(pod_manager_group) except: pass try: user.groups.remove(pod_admin_group) except: pass flash_message = _('User {} is now a basic user').format( user.get_display_name()) elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_MANAGER: if pod_user_group not in user.groups: user.groups.append(pod_user_group) if pod_manager_group not in user.groups: user.groups.append(pod_manager_group) try: user.groups.remove(pod_admin_group) except: pass flash_message = _('User {} can now workspaces').format( user.get_display_name()) elif new_profile == UserProfileAdminRestController._ALLOWED_PROFILE_ADMIN: if pod_user_group not in user.groups: user.groups.append(pod_user_group) if pod_manager_group not in user.groups: user.groups.append(pod_manager_group) if pod_admin_group not in user.groups: user.groups.append(pod_admin_group) flash_message = _('User {} is now an administrator').format( user.get_display_name()) else: logger.error( self, 'Trying to change user {} profile with unexpected profile {}'. format(user.user_id, new_profile)) tg.flash(_('Unknown profile'), CST.STATUS_ERROR) tg.redirect(redirect_url) DBSession.flush() tg.flash(flash_message, CST.STATUS_OK) tg.redirect(redirect_url)