def account(request): change_password_form = forms.ChangePasswordForm( csrf_context=request ) if request.method == 'POST': change_password_form.process(request.POST) if change_password_form.validate(): try: user = DBSession.query(User).filter( User.id == authenticated_userid(request) ).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() user.set_password(change_password_form.password.data) DBSession.add(user) request.session.flash( get_localizer(request).translate(_( "Your password has been successfuly changed." )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.users.account') ) else: request.session.flash( get_localizer(request).translate(_( "There were some problems with your request." " Please check the form for error messages." )), queue='error' ) return { 'change_password_form': change_password_form, }
def setUp(self): self.config = testing.setUp() from sqlalchemy import create_engine engine = create_engine('sqlite://') from .models import ModelBase DBSession.configure(bind=engine) ModelBase.metadata.create_all(engine)
def account(request): change_password_form = forms.ChangePasswordForm(csrf_context=request) if request.method == 'POST': change_password_form.process(request.POST) if change_password_form.validate(): try: user = DBSession.query(User).filter( User.id == authenticated_userid(request)).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() user.set_password(change_password_form.password.data) DBSession.add(user) request.session.flash(get_localizer(request).translate( _("Your password has been successfuly changed.")), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.users.account')) else: request.session.flash(get_localizer(request).translate( _("There were some problems with your request." " Please check the form for error messages.")), queue='error') return { 'change_password_form': change_password_form, }
def environment(request): environment_name = request.matchdict['environment_name'] try: environment = DBSession.query(Environment.id, Environment.name).filter( Environment.name == environment_name).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() problems = DBSession.query(Problem).distinct().join(Occurrence).filter( Occurrence.problem_id == Problem.id, Occurrence.environment_id == environment.id).order_by( Problem.last_occurrence) return { 'environment': { 'id': environment.id, 'name': environment.name, }, 'problems': [{ 'id': problem.id, 'description': problem.description, 'tags': problem.get_split_tags(), 'last_occurrence': pytz.utc.normalize(pytz.utc.localize(problem.last_occurrence)), 'occurrence_count': problem.occurrence_count, 'url': request.route_url('alpaca.problems.problem', problem_id=problem.id), } for problem in problems], }
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, "sqlalchemy.") DBSession.configure(bind=engine) ModelBase.metadata.create_all(engine) user = User(email="*****@*****.**", role_administrator=True) user.set_password("admin") DBSession.add(user) transaction.commit()
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) ModelBase.metadata.create_all(engine) user = User( email='*****@*****.**', role_administrator=True ) user.set_password('admin') DBSession.add(user) transaction.commit()
def add_environments(event): environment_set = DBSession.query( Environment.id, Environment.name).order_by(Environment.name) event['all_environments'] = [{ 'id': environment.id, 'name': environment.name } for environment in environment_set]
def sign_in(request): destination = request.GET.get( 'destination', request.route_url('alpaca.problems.dashboard') ) sign_in_form = forms.AuthenticationForm(csrf_context=request) if request.method == 'POST': sign_in_form.process(request.POST) if sign_in_form.validate(): try: user = DBSession.query(User).filter( User.email == sign_in_form.email.data ).one() except database_exceptions.NoResultFound: pass else: if user.valid_password(sign_in_form.password.data): return httpexceptions.HTTPFound( destination, headers=security.remember(request, user.id) ) request.session.flash( get_localizer(request).translate(_( "Invalid credentials." )), queue='error' ) return { 'sign_in_form': sign_in_form, }
def validate_name(self, field): count = DBSession.query(Environment).filter( Environment.name == field.data ).count() if count != 0: raise validators.ValidationError( _("There is already an environment having this name.") )
def validate_email(self, field): count = DBSession.query(User).filter( User.email == field.data ).count() if count != 0: raise validators.ValidationError( _("There is already an account registered with this e-mail" " address.") )
def set_tags(request): problem_id = request.matchdict['problem_id'] try: problem = DBSession.query( Problem, ).filter(Problem.id == problem_id).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() tags_cstruct = request.POST.getall('tags[]') try: tags = ProblemTagsSchema().deserialize(tags_cstruct) except colander.Invalid as error: raise httpexceptions.HTTPBadRequest('\r\n'.join( (_("Invalid tags."), '\r\n'.join( ('%s: %s' % (node_name, message) for node_name, message in error.asdict().iteritems()))))) problem.tags = ','.join(tags) DBSession.add(problem) return Response()
def environment(request): environment_name = request.matchdict['environment_name'] try: environment = DBSession.query( Environment.id, Environment.name ).filter( Environment.name == environment_name ).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() problems = DBSession.query( Problem ).distinct().join( Occurrence ).filter( Occurrence.problem_id == Problem.id, Occurrence.environment_id == environment.id ).order_by( Problem.last_occurrence ) return { 'environment': { 'id': environment.id, 'name': environment.name, }, 'problems': [ { 'id': problem.id, 'description': problem.description, 'tags': problem.get_split_tags(), 'last_occurrence': pytz.utc.normalize(pytz.utc.localize( problem.last_occurrence )), 'occurrence_count': problem.occurrence_count, 'url': request.route_url( 'alpaca.problems.problem', problem_id=problem.id ), } for problem in problems ], }
def add_environments(event): environment_set = DBSession.query( Environment.id, Environment.name ).order_by(Environment.name); event['all_environments'] = [ { 'id': environment.id, 'name': environment.name } for environment in environment_set ]
def set_tags(request): problem_id = request.matchdict['problem_id'] try: problem = DBSession.query( Problem, ).filter( Problem.id == problem_id ).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() tags_cstruct = request.POST.getall('tags[]') try: tags = ProblemTagsSchema().deserialize(tags_cstruct) except colander.Invalid as error: raise httpexceptions.HTTPBadRequest('\r\n'.join(( _("Invalid tags."), '\r\n'.join(( '%s: %s' % (node_name, message) for node_name, message in error.asdict().iteritems() )) ))) problem.tags = ','.join(tags) DBSession.add(problem) return Response()
def sign_in(request): destination = request.GET.get( 'destination', request.route_url('alpaca.problems.dashboard')) sign_in_form = forms.AuthenticationForm(csrf_context=request) if request.method == 'POST': sign_in_form.process(request.POST) if sign_in_form.validate(): try: user = DBSession.query(User).filter( User.email == sign_in_form.email.data).one() except database_exceptions.NoResultFound: pass else: if user.valid_password(sign_in_form.password.data): return httpexceptions.HTTPFound(destination, headers=security.remember( request, user.id)) request.session.flash(get_localizer(request).translate( _("Invalid credentials.")), queue='error') return { 'sign_in_form': sign_in_form, }
def report(request): if 'Alpaca-Environment' not in request.headers: raise httpexceptions.HTTPBadRequest( "Missing Alpaca-Environment header." ) try: environment = DBSession.query(Environment).filter( Environment.name == request.headers['Alpaca-Environment'] ).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPBadRequest( "Unknown environment." ) if 'Alpaca-Signature' not in request.headers: raise httpexceptions.HTTPBadRequest( "Missing Alpaca-Signature header." ) if request.content_type == 'application/x-pickle.python': try: report_cstruct = pickle.loads(request.body) except pickle.UnpicklingError as error: raise httpexceptions.HTTPBadRequest( "Cannot parse request body: %s" % str(error) ) elif request.content_type == 'application/json': try: report_cstruct = simplejson.loads(request.body) except simplejson.JSONDecodeError as error: raise httpexceptions.HTTPBadRequest( "Cannot parse request body: %s" % str(error) ) else: raise httpexceptions.HTTPBadRequest("Unsupported Content-Type.") try: report = ReportSchema().deserialize(report_cstruct) except colander.Invalid as error: raise httpexceptions.HTTPBadRequest('\r\n'.join(( "Invalid report.", '\r\n'.join(( '%s: %s' % (node_name, message) for node_name, message in error.asdict().iteritems() )) ))) if report['date'].tzinfo is None: report['date'] = pytz.utc.normalize(pytz.utc.localize( report['date'] )) else: report['date'] = report['date'].astimezone(pytz.utc) try: problem = DBSession.query( Problem, ).filter( Problem.hash == report['hash'] ).one() except database_exceptions.NoResultFound: problem = Problem() problem.hash = report['hash'] problem.occurrence_count = 1 problem.first_occurrence = report['date'].replace(tzinfo=None) else: problem.occurrence_count += 1 finally: problem.description = report['message'].split('\n')[0].strip() problem.last_occurrence = report['date'].replace(tzinfo=None) DBSession.add(problem) occurrence = Occurrence() occurrence.problem = problem occurrence.environment = environment occurrence.date = report['date'].replace(tzinfo=None) occurrence.message = report['message'] occurrence.stack_trace = report['stack_trace'] occurrence.environment_data = report['environment_data'] DBSession.add(occurrence) DBSession.query( Occurrence ).filter( Occurrence.id.in_( DBSession.query( Occurrence.id ).join( Problem ).filter( Occurrence.problem_id == Problem.id, Problem.hash == report['hash'] ).order_by( sql.desc(Occurrence.date) ).offset( 30 ).subquery() ) ).delete(synchronize_session=False) # Call `expire_all()` to avoid having inconsistent state after calling # `delete()` with `synchronize_session=False`. DBSession.expire_all() return Response()
def tearDown(self): DBSession.remove() testing.tearDown()
def configuration(request): environments = DBSession.query(Environment).order_by('name') users = DBSession.query(User).order_by('email') # Changing permissions if 'change-permissions-submit' in request.POST: post_keys = filter(lambda key: key.startswith('role_administrator-'), request.POST.iterkeys()) user_ids = [] for post_key in post_keys: try: user_ids.append(int(post_key.split('-')[-1])) except (KeyError, ValueError): continue DBSession.query(User).filter( User.id != authenticated_userid(request)).update({ 'role_administrator': False, }) DBSession.query(User).filter(User.id != authenticated_userid(request), User.id.in_(user_ids)).update( { 'role_administrator': True, }, synchronize_session=False) request.session.flash(get_localizer(request).translate( _("User permissions have been successfuly saved.")), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration')) # Adding user add_user_form = forms.AddUserForm(csrf_context=request) if 'add-user-submit' in request.POST: add_user_form.process(request.POST) if add_user_form.validate(): user = User() add_user_form.populate_obj(user) new_password = user.generate_random_password() DBSession.add(user) request.session.flash(get_localizer(request).translate( _( "New user <code>${email}</code> has been successfuly" " created. Its temporary password is:" " <code>${password}</code>", mapping={ 'email': user.email, 'password': new_password, })), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration')) else: request.session.flash(get_localizer(request).translate( _("There were some problems with your request." " Please check the form for error messages.")), queue='error') # Resetting user password if 'reset-user-password-submit' in request.POST: reset_user_password_form = forms.ResetUserPasswordForm( request.POST, csrf_context=request) if reset_user_password_form.validate(): try: user = DBSession.query(User).filter( User.id == reset_user_password_form.user_id.data).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() new_password = user.generate_random_password() DBSession.add(user) request.session.flash(get_localizer(request).translate( _( "New password for user <code>${email}</code> is:" " <code>${password}</code>", mapping={ 'email': user.email, 'password': new_password, })), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration')) # Deleting user if 'delete-user-submit' in request.POST: delete_user_form = forms.DeleteUserForm(request.POST, csrf_context=request) if delete_user_form.validate(): DBSession.query(User).filter( User.id == delete_user_form.user_id.data).delete() request.session.flash(get_localizer(request).translate( _("User has been successfuly deleted.")), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration')) else: request.session.flash(get_localizer(request).translate( _("There were some problems with your request." " Please check the form for error messages.")), queue='error') # Adding environment add_environment_form = forms.AddEnvironmentForm(csrf_context=request) if 'add-environment-submit' in request.POST: add_environment_form.process(request.POST) if add_environment_form.validate(): environment = Environment() add_environment_form.populate_obj(environment) environment.regenerate_api_key() DBSession.add(environment) request.session.flash(get_localizer(request).translate( _( "New environment <code>${name}</code> has been successfuly" " created. Its API key is: <code>${api_key}</code>", mapping={ 'name': environment.name, 'api_key': environment.api_key, })), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration')) else: request.session.flash(get_localizer(request).translate( _("There were some problems with your request." " Please check the form for error messages.")), queue='error') # Regenerating environment API key if 'regenerate-environment-api-key-submit' in request.POST: regenerate_api_key_form = forms.RegenerateEnvironmentApiKeyForm( request.POST, csrf_context=request) if regenerate_api_key_form.validate(): try: environment = DBSession.query(Environment).filter( (Environment.id == regenerate_api_key_form.environment_id.data)).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() environment.regenerate_api_key() DBSession.add(environment) request.session.flash(get_localizer(request).translate( _( "New API key for environment <code>${name}</code> is:" " <code>${api_key}</code>", mapping={ 'name': environment.name, 'api_key': environment.api_key, })), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration')) # Deleting environment if 'delete-environment-submit' in request.POST: delete_environment_form = forms.DeleteEnvironmentForm( request.POST, csrf_context=request) if delete_environment_form.validate(): DBSession.query(Environment).filter( Environment.id == delete_environment_form.environment_id.data).delete() request.session.flash(get_localizer(request).translate( _("Environment has been successfuly deleted.")), queue='success') return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration')) else: request.session.flash(get_localizer(request).translate( _("There were some problems with your request." " Please check the form for error messages.")), queue='error') return { 'environments': [{ 'id': environment.id, 'name': environment.name, 'url': request.route_url('alpaca.problems.environment', environment_name=environment.name), 'delete_form': forms.DeleteEnvironmentForm(environment_id=environment.id, csrf_context=request), 'regenerate_api_key_form': (forms.RegenerateEnvironmentApiKeyForm( environment_id=environment.id, csrf_context=request)), } for environment in environments], 'users': [{ 'id': user.id, 'email': user.email, 'role_administrator': user.role_administrator, 'delete_form': forms.DeleteUserForm(user_id=user.id, csrf_context=request), 'reset_password_form': forms.ResetUserPasswordForm(user_id=user.id, csrf_context=request), } for user in users], 'add_environment_form': add_environment_form, 'add_user_form': add_user_form, }
def validate_email(self, field): count = DBSession.query(User).filter(User.email == field.data).count() if count != 0: raise validators.ValidationError( _("There is already an account registered with this e-mail" " address."))
def validate_name(self, field): count = DBSession.query(Environment).filter( Environment.name == field.data).count() if count != 0: raise validators.ValidationError( _("There is already an environment having this name."))
def problem(request): problem_id = int(request.matchdict['problem_id']) try: problem = DBSession.query( Problem, ).filter(Problem.id == problem_id).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() try: occurrence_id = request.matchdict['occurrence_id'] except KeyError: occurrence = DBSession.query(Occurrence).filter( Occurrence.problem_id == problem.id).order_by( sql.desc(Occurrence.date)).first() else: try: occurrence = DBSession.query(Occurrence).filter( Occurrence.problem_id == problem.id, Occurrence.id == occurrence_id).one() except database_exceptions.NoResultFound: request.session.flash(get_localizer(request).translate( _("Details of the problem occurrence your URL pointed to were" " removed to limit history size. Please investigate the" " problem using latest occurrence data.")), queue='warning') raise httpexceptions.HTTPSeeOther('#'.join( (request.route_url('alpaca.problems.problem', problem_id=problem.id), 'top'))) affected_environments = DBSession.query( Environment.id, Environment.name).distinct().join(Occurrence).filter( Occurrence.problem_id == problem.id).order_by(Environment.name) problem_occurrences = DBSession.query( Occurrence.id).filter(Occurrence.problem_id == problem.id).order_by( sql.desc(Occurrence.date)) return { 'problem': { 'id': problem.id, 'hash': problem.hash, 'first_occurrence': pytz.utc.normalize(pytz.utc.localize(problem.first_occurrence)), 'last_occurrence': pytz.utc.normalize(pytz.utc.localize(problem.last_occurrence)), 'occurrence_count': problem.occurrence_count, 'tags': problem.get_split_tags(), 'occurrences': [{ 'id': problem_occurrence.id, 'url': request.route_url('alpaca.problems.problem_occurrence', problem_id=problem.id, occurrence_id=problem_occurrence.id), } for problem_occurrence in problem_occurrences], }, 'occurrence': { 'id': occurrence.id, 'date': pytz.utc.normalize(pytz.utc.localize(occurrence.date)), 'message': occurrence.message, 'stack_trace': occurrence.get_normalized_stack_trace(), 'environment_data': occurrence.get_normalized_environment_data(), 'environment': { 'id': occurrence.environment.id, 'name': occurrence.environment.name, 'url': request.route_url( 'alpaca.problems.environment', environment_name=occurrence.environment.name), } }, 'affected_environments': [{ 'id': environment.id, 'name': environment.name, 'url': request.route_url('alpaca.problems.environment', environment_name=environment.name), } for environment in affected_environments], }
def main(global_config, **settings): # Provide deployment-independent settings settings.update({ # Webassets 'webassets.base_dir': os.path.join( os.path.abspath(os.path.dirname(__file__)), 'static' ), 'webassets.base_url': settings.get('route.prefix', '') + '/static/', # Jinja2 'jinja2.i18n.domain': 'alpaca', }) # Configure database session. database_engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=database_engine) # Create configurator. config = Configurator(settings=settings) config.registry['settings'] = settings # Configure ACL. config.set_root_factory(RootFactory) # Configure security. authentication_policy = AuthTktAuthenticationPolicy( settings['session.secret'], callback=User.authentication_callback ) config.set_authentication_policy(authentication_policy) authorization_policy = ACLAuthorizationPolicy() config.set_authorization_policy(authorization_policy) # Configure session. session_factory = UnencryptedCookieSessionFactoryConfig( settings['session.secret'] ) config.set_session_factory(session_factory) # Add translation directories. config.add_translation_dirs(os.path.join( os.path.dirname(__file__), 'locale' )) # Include packages. config.include('pyramid_tm') config.include('pyramid_jinja2') config.include('pyramid_webassets') # Configure asset bundles. for name, bundle in ASSET_BUNDLES.iteritems(): config.add_webasset(name, bundle) # Add Jinja2 extensions. config.add_jinja2_extension('jinja2.ext.with_') config.get_jinja2_environment().filters['tojson'] = json.dumps config.registry['jinja2_environment'] = config.get_jinja2_environment() # Add webassets extension to Jinja2. config.add_jinja2_extension('webassets.ext.jinja2.AssetsExtension') webassets_environment = config.get_webassets_env() config.get_jinja2_environment().assets_environment = webassets_environment # Configure routes. for name, pattern in ROUTES.iteritems(): config.add_route(name, pattern) # Add static view. config.add_static_view('static', 'static', cache_max_age=3600) # Scan for view configuration. config.scan() return config.make_wsgi_app()
def configuration(request): environments = DBSession.query(Environment).order_by('name') users = DBSession.query(User).order_by('email') # Changing permissions if 'change-permissions-submit' in request.POST: post_keys = filter( lambda key: key.startswith('role_administrator-'), request.POST.iterkeys() ) user_ids = [] for post_key in post_keys: try: user_ids.append(int(post_key.split('-')[-1])) except (KeyError, ValueError): continue DBSession.query(User).filter( User.id != authenticated_userid(request) ).update({ 'role_administrator': False, }) DBSession.query(User).filter( User.id != authenticated_userid(request), User.id.in_(user_ids) ).update({ 'role_administrator': True, }, synchronize_session=False) request.session.flash( get_localizer(request).translate(_( "User permissions have been successfuly saved." )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration') ) # Adding user add_user_form = forms.AddUserForm(csrf_context=request) if 'add-user-submit' in request.POST: add_user_form.process(request.POST) if add_user_form.validate(): user = User() add_user_form.populate_obj(user) new_password = user.generate_random_password() DBSession.add(user) request.session.flash( get_localizer(request).translate(_( "New user <code>${email}</code> has been successfuly" " created. Its temporary password is:" " <code>${password}</code>", mapping={ 'email': user.email, 'password': new_password, } )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration') ) else: request.session.flash( get_localizer(request).translate(_( "There were some problems with your request." " Please check the form for error messages." )), queue='error' ) # Resetting user password if 'reset-user-password-submit' in request.POST: reset_user_password_form = forms.ResetUserPasswordForm( request.POST, csrf_context=request ) if reset_user_password_form.validate(): try: user = DBSession.query(User).filter( User.id == reset_user_password_form.user_id.data ).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() new_password = user.generate_random_password() DBSession.add(user) request.session.flash( get_localizer(request).translate(_( "New password for user <code>${email}</code> is:" " <code>${password}</code>", mapping={ 'email': user.email, 'password': new_password, } )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration') ) # Deleting user if 'delete-user-submit' in request.POST: delete_user_form = forms.DeleteUserForm( request.POST, csrf_context=request ) if delete_user_form.validate(): DBSession.query(User).filter( User.id == delete_user_form.user_id.data ).delete() request.session.flash( get_localizer(request).translate(_( "User has been successfuly deleted." )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration') ) else: request.session.flash( get_localizer(request).translate(_( "There were some problems with your request." " Please check the form for error messages." )), queue='error' ) # Adding environment add_environment_form = forms.AddEnvironmentForm(csrf_context=request) if 'add-environment-submit' in request.POST: add_environment_form.process(request.POST) if add_environment_form.validate(): environment = Environment() add_environment_form.populate_obj(environment) environment.regenerate_api_key() DBSession.add(environment) request.session.flash( get_localizer(request).translate(_( "New environment <code>${name}</code> has been successfuly" " created. Its API key is: <code>${api_key}</code>", mapping={ 'name': environment.name, 'api_key': environment.api_key, } )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration') ) else: request.session.flash( get_localizer(request).translate(_( "There were some problems with your request." " Please check the form for error messages." )), queue='error' ) # Regenerating environment API key if 'regenerate-environment-api-key-submit' in request.POST: regenerate_api_key_form = forms.RegenerateEnvironmentApiKeyForm( request.POST, csrf_context=request ) if regenerate_api_key_form.validate(): try: environment = DBSession.query(Environment).filter( (Environment.id == regenerate_api_key_form.environment_id.data) ).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() environment.regenerate_api_key() DBSession.add(environment) request.session.flash( get_localizer(request).translate(_( "New API key for environment <code>${name}</code> is:" " <code>${api_key}</code>", mapping={ 'name': environment.name, 'api_key': environment.api_key, } )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration') ) # Deleting environment if 'delete-environment-submit' in request.POST: delete_environment_form = forms.DeleteEnvironmentForm( request.POST, csrf_context=request ) if delete_environment_form.validate(): DBSession.query(Environment).filter( Environment.id == delete_environment_form.environment_id.data ).delete() request.session.flash( get_localizer(request).translate(_( "Environment has been successfuly deleted." )), queue='success' ) return httpexceptions.HTTPFound( request.route_url('alpaca.configuration.configuration') ) else: request.session.flash( get_localizer(request).translate(_( "There were some problems with your request." " Please check the form for error messages." )), queue='error' ) return { 'environments': [ { 'id': environment.id, 'name': environment.name, 'url': request.route_url( 'alpaca.problems.environment', environment_name=environment.name ), 'delete_form': forms.DeleteEnvironmentForm( environment_id=environment.id, csrf_context=request ), 'regenerate_api_key_form': ( forms.RegenerateEnvironmentApiKeyForm( environment_id=environment.id, csrf_context=request ) ), } for environment in environments ], 'users': [ { 'id': user.id, 'email': user.email, 'role_administrator': user.role_administrator, 'delete_form': forms.DeleteUserForm( user_id=user.id, csrf_context=request ), 'reset_password_form': forms.ResetUserPasswordForm( user_id=user.id, csrf_context=request ), } for user in users ], 'add_environment_form': add_environment_form, 'add_user_form': add_user_form, }
def problem(request): problem_id = int(request.matchdict['problem_id']) try: problem = DBSession.query( Problem, ).filter( Problem.id == problem_id ).one() except database_exceptions.NoResultFound: raise httpexceptions.HTTPNotFound() try: occurrence_id = request.matchdict['occurrence_id'] except KeyError: occurrence = DBSession.query( Occurrence ).filter( Occurrence.problem_id == problem.id ).order_by( sql.desc(Occurrence.date) ).first() else: try: occurrence = DBSession.query( Occurrence ).filter( Occurrence.problem_id == problem.id, Occurrence.id == occurrence_id ).one() except database_exceptions.NoResultFound: request.session.flash( get_localizer(request).translate(_( "Details of the problem occurrence your URL pointed to were" " removed to limit history size. Please investigate the" " problem using latest occurrence data." )), queue='warning' ) raise httpexceptions.HTTPSeeOther( '#'.join(( request.route_url( 'alpaca.problems.problem', problem_id=problem.id ), 'top' )) ) affected_environments = DBSession.query( Environment.id, Environment.name ).distinct().join( Occurrence ).filter( Occurrence.problem_id == problem.id ).order_by( Environment.name ) problem_occurrences = DBSession.query( Occurrence.id ).filter( Occurrence.problem_id == problem.id ).order_by( sql.desc(Occurrence.date) ) return { 'problem': { 'id': problem.id, 'hash': problem.hash, 'first_occurrence': pytz.utc.normalize(pytz.utc.localize( problem.first_occurrence )), 'last_occurrence': pytz.utc.normalize(pytz.utc.localize( problem.last_occurrence )), 'occurrence_count': problem.occurrence_count, 'tags': problem.get_split_tags(), 'occurrences': [ { 'id': problem_occurrence.id, 'url': request.route_url( 'alpaca.problems.problem_occurrence', problem_id=problem.id, occurrence_id=problem_occurrence.id ), } for problem_occurrence in problem_occurrences ], }, 'occurrence': { 'id': occurrence.id, 'date': pytz.utc.normalize(pytz.utc.localize(occurrence.date)), 'message': occurrence.message, 'stack_trace': occurrence.get_normalized_stack_trace(), 'environment_data': occurrence.get_normalized_environment_data(), 'environment': { 'id': occurrence.environment.id, 'name': occurrence.environment.name, 'url': request.route_url( 'alpaca.problems.environment', environment_name=occurrence.environment.name ), } }, 'affected_environments': [ { 'id': environment.id, 'name': environment.name, 'url': request.route_url( 'alpaca.problems.environment', environment_name=environment.name ), } for environment in affected_environments ], }