def increase_value(request): """increase a value for the user""" user_id = int(request.matchdict["user_id"]) try: value = float(request.POST["value"]) except: raise BadRequest("Invalid value provided") key = request.matchdict["key"] if request.matchdict.has_key("key") else "" variable_name = request.matchdict["variable_name"] user = User.get_user(user_id) if not user: raise NotFound("user not found") variable = Variable.get_variable_by_name(variable_name) if not variable: raise NotFound("variable not found") Value.increase_value(variable_name, user, value, key) output = get_progress(request, return_object=True) for aid in output["achievements"].keys(): if len(output["achievements"][aid]["new_levels"]) > 0: del output["achievements"][aid]["levels"] del output["achievements"][aid]["priority"] del output["achievements"][aid]["goals"] else: del output["achievements"][aid] return output
def submit_word(request): session = request.session params = request.params db = request.db rooms = db.rooms if not 'room_id' in session or not 'word' in params: return NotFound() room = rooms.find_one({'_id': session['room_id']}) currUser = room['currUsr'] if currUser == '': currUser = room['inRoom'][0] sentence = room['answer'] sentence += params['word'] + " " if len(room['inRoom']) < 2: return NotFound() nextUser = room['inRoom'][1] rooms.update({'_id': room['_id']}, { '$pop': { 'inRoom': -1 }, '$push': { 'inRoom': currUser }, '$set': { 'answer': sentence, 'lastUser': currUser, 'currUser': nextUser } }) return {}
def statistics_csv_view(request): statistics_folder = get_setting(request.context, 'statistics_folder') csv_file = request.matchdict.get('csv_file') if not csv_file.endswith('.csv'): raise NotFound() path = os.path.join(statistics_folder, csv_file) if not os.path.exists(path): raise NotFound() return request.get_response(FileApp(path).get)
def factory(request): if request.matchdict is not None and 'id' in request.matchdict: try: cid = int(request.matchdict['id']) except ValueError: raise NotFound() context = model.query.filter_by(id=cid).first() if context is None: raise NotFound() return context return Root()
def get(self, request): resource = self.get_resource(request) if not resource or not resource.exists: return NotFound('Template not found') request.response.content_type = 'text/plain' request.response.write(resource.read()) return request.response
def __call__(self): request = self.request with request.connmgr.get_connection() as conn: cursor = conn.execute( """EXEC sp_%s_Page_s_Slug ?, ?, ?""" % request.pageinfo.DbAreaS, request.dboptions.MemberID, request.matchdict["slug"], request.viewdata.dom.ViewType, ) page = cursor.fetchone() cursor.nextset() other_langs = cursor.fetchall() if not page and not other_langs: raise NotFound() title = page and page.Title or _("Page not found", request) return self._create_response_namespace( title, title, { "page": page, "other_langs": other_langs, }, no_index=True, )
def pull_repository_files(repo, commit_id): changed_files = {} for name in list_content_types(repo): changed_files[name] = [] try: old_commit = repo.commit(commit_id) diff = old_commit.diff(repo.head) sm = StorageManager(repo) for diff_added in diff.iter_change_type('A'): add_model_item_to_pull_dict(sm, diff_added.b_blob.path, changed_files) for diff_modified in diff.iter_change_type('M'): add_model_item_to_pull_dict(sm, diff_modified.b_blob.path, changed_files) json_diff = [] for diff_added in diff.iter_change_type('R'): json_diff.append(format_diff_R(diff_added)) for diff_removed in diff.iter_change_type('D'): json_diff.append(format_diff_D(diff_removed)) changed_files["other"] = json_diff changed_files["commit"] = repo.head.commit.hexsha return changed_files except (GitCommandError, BadName): raise NotFound("The git index does not exist")
def relationships_watch_commit(context, request): # XXX clean this crap up target_username = request.params.get('target_user', None) target_user = model.session.query(model.User) \ .filter_by(name=target_username).one() if not target_user: raise NotFound() watch_form = WatchForm(request.POST) if not watch_form.validate(): # XXX better redirect whatever request.session.flash(u"Yo form is jacked", level=u'error') return HTTPBadRequest() watch = model.session.query(model.UserWatch) \ .filter_by(user=request.user, other_user=target_user) \ .first() if not watch: watch = model.UserWatch( user=request.user, other_user=target_user, ) watch.watch_upload = watch_form.watch_upload.data watch.watch_by = watch_form.watch_by.data watch.watch_for = watch_form.watch_for.data watch.watch_of = watch_form.watch_of.data model.session.add(watch) # XXX where should this redirect? request.session.flash(u"Saved watch settings for {0}.".format( target_user.name), level=u'success') return HTTPSeeOther(request.route_url('users.view', user=target_user))
def render(self, **kwargs): """render the form as html or json""" request = self.request if request.format != 'html': meth = getattr(self, 'render_%s_format' % request.format, None) if meth is not None: return meth(**kwargs) else: raise NotFound() if request.model_class: request.model_class = model_class = I18NModel( request.model_class, request) request.model_label = model_label = model_class.label request.model_plural = model_plural = model_class.plural else: model_class = request.model_class model_label = model_plural = '' self.update_resources() kwargs.update(main=get_renderer( 'pyramid_formalchemy:templates/admin/master.pt').implementation(), model_class=model_class, model_name=request.model_name, model_label=model_label, model_plural=model_plural, breadcrumb=self.breadcrumb(**kwargs), actions=request.actions, F_=get_translator()), return kwargs
def proposal_redirect_to_agenda_item(context, request): ai = find_interface(context, IAgendaItem) if ai: query = request.GET url = request.resource_url(ai, query=query, anchor=context.uid) return HTTPFound(location=url) raise NotFound("Couldn't locate Agenda Item from this context.")
class Model(Base): """Context used for model instances""" def fa_url(self, *args, **kwargs): return self._fa_url(*args[2:], **kwargs) def __init__(self, request, name): Base.__init__(self, request, name) query = request.session_factory.query(request.model_class) try: request.model_instance = request.query_factory(request, query, id=name) except sqlalchemy_exceptions.SQLAlchemyError, exc: if name != 'new': log.exception(exc) request.session_factory().rollback() raise NotFound(request.path) if request.model_instance is None: raise NotFound(request.path) request.model_id = name if request.model_instance and hasattr(request.model_instance, '__acl__'): self.__acl__ = request.model_instance.__acl__
def render_page(self, section, redirpath, values=None): if self.endpath is None: return HTTPFound(location=route_url('subsections', self.request, action=section, endpath='/'.join(redirpath))) self.c.active_footer_nav = '-'.join( [self.request.matchdict.get('action')] + list(self.endpath)) for ext in ('.mako', '.rst'): tmpl_path = ('templates/pages/%s/%s%s' % (section, '/'.join(self.endpath), ext)) values = values or {} if pkg_resources.resource_exists('pylonshq', tmpl_path): if ext == '.mako': return render_to_response('pylonshq:%s' % tmpl_path, values, self.request) else: self.c.pagename = ' : '.join([ item.replace('-', ' ').title() for item in self.endpath ]) content = pkg_resources.resource_string( 'pylonshq', tmpl_path) body = publish_parts(content, writer_name='html')['html_body'] values = {'body': body} return render_to_response('pylonshq:templates/rst.mako', values, self.request) raise NotFound()
def preview_wikipage_view(context, request, WikiPage=WikiPage, tz=None): version_num = int(request.params['version_num']) repo = find_repo(context) for version in repo.history(context.docid): if version.version_num == version_num: break else: raise NotFound("No such version: %d" % version_num) page = WikiPage() page.__parent__ = context.__parent__ page.revert(version) is_front_page = (context.__name__ == 'front_page') if is_front_page: community = find_interface(context, ICommunity) page_title = '%s Community Wiki Page' % community.title else: page_title = page.title profiles = find_profiles(context) author = profiles[version.user] # Extra paranoia, probably not strictly necessary. I just want to make # extra special sure that the temp WikiPage object we create above # doesn't accidentally get attached to the persistent object graph. transaction.doom() return { 'date': format_local_date(version.archive_time, tz), 'author': author.title, 'title': page_title, 'body': page.cook(request), }
def activities(self): """ Get activities for current user. By default activities are getted only for current day. Different date range can be queried using `from` and `to` arguments in the request. Returns a List of Activity. """ if not self.is_valid_object: raise NotFound() try: (from_date, to_date) = self.get_filter_from_to() except (TypeError, ValueError): return error_response(_('Invalid date format')) # When no dates are given use current date as default if not from_date and not to_date: from_date = datetime.date.today() to_date = from_date + datetime.timedelta(days=1) query = Activity.query() query = query.filter(Activity.user_id == self.pk_value) if from_date: query = query.filter(Activity.start >= from_date) if to_date: query = query.filter(Activity.start < to_date) return query.all()
def discussion_redirect_to_agenda_item(context, request): root = find_root(context) ai = find_interface(context, IAgendaItem) if ai: path = resource_path(ai) query = dict( path=path, content_type='DiscussionPost', sort_index='created', reverse=True, limit=5, #FIXME: this should be globaly configurable? ) docids = root.catalog.search(**query)[1] # set to True if requested post is after the display limit after_limit = False get_metadata = root.catalog.document_map.get_metadata for docid in docids: brain = get_metadata(docid) if brain['uid'] == context.uid: after_limit = True break # post was not found among the displayed posts query = request.GET if not after_limit: query['discussions'] = 'all' url = request.resource_url(ai, query=query, anchor=context.uid) else: url = request.resource_url(ai, query=query, anchor=context.uid) return HTTPFound(location=url) raise NotFound("Couldn't locate Agenda Item from this context.")
def edit_article(self): article = db_session.query(Article).filter_by(id=self.request.matchdict['id']) user_id = self.request.POST.get('user_id') if user_id is None or user_id <= 0: NotFound() article.update({**self.request.POST}) db_session.commit() return {'id': self.request.matchdict['id']}
def _get_related_name(self): related_name = super(ModelResource, self)._get_related_name() # Check that related name is in fact a relationship if related_name: if related_name not in self.relationships: raise NotFound() return related_name
def get_model_definition(request): """Retrieves a model definition. """ modelname = request.matchdict['modelname'] results = db_model_definition(request.db)[modelname] for result in results: return result.value raise NotFound("Unknown model %s" % modelname)
def uid_factory(request): if request.matchdict is not None and 'uid' in request.matchdict: context = models.TalkPreference.query.filter_by( uid=request.matchdict['uid']).first() if context is None: raise NotFound() return context return object()
def add_article(self): article = Article(**self.request.POST) user_id = self.request.POST.get('user_id') if user_id is None or user_id <= 0: NotFound() db_session.add(article) db_session.commit() return {'id': article.id, 'id_user': user_id}
def get(request): """Retrieves.""" key = request.matchdict['key'] if key not in todos.keys(): raise NotFound("Unknown key '%s'." % (key)) return {key: todos[key]}
def GetOrder(request): print "serving request context:", request.context.__name__ order = DBSession.query(Order).filter_by( id=request.context.__name__).first() if (order is None): return NotFound("No matching order found!") else: return {'order': order, 'logged_in': request.authenticated_userid}
def download_datafile(request): name = request.matchdict['equip'] date = request.matchdict['date'] time = request.matchdict['time'] dbsession = DBSession() try: dbsession.query(EquipmentModel).filter_by(name=name).one() except NoResultFound: return NotFound("Unknown equipment name") filename = '{0}_{1}_{2}.h5'.format(name, date, time) file_path = os.path.join(data_path, name, filename) if not os.path.exists(file_path): return NotFound("No file for this equipment on the given date") return _make_response(file_path)
def test_traverser_raises_notfound_instance(self): from pyramid.exceptions import NotFound environ = self._makeEnviron() context = DummyContext() self._registerTraverserFactory(context, raise_error=NotFound('foo')) router = self._makeOne() start_response = DummyStartResponse() why = exc_raised(NotFound, router, environ, start_response) self.failUnless('foo' in why[0], why)
def __init__(self, request, name): Base.__init__(self, request, name) query = request.session_factory.query(request.model_class) try: request.model_instance = request.query_factory(request, query, id=name) except sqlalchemy_exceptions.SQLAlchemyError, exc: log.exception(exc) request.session_factory().rollback() raise NotFound(request.path)
def factory(request): # This yields the "context", which should be the row object try: return contextualize( model.session.query(sqla_column.parententity).filter( sqla_column == request.matchdict[match_key]).one()) except NoResultFound: # 404! raise NotFound()
def get_progress(request): """get all relevant data concerning the user's progress""" user_id = int(request.matchdict["user_id"]) user = User.get_user(user_id) if not user: raise NotFound("user not found") return _get_progress(user, force_generation=False)[0]
def hashed_uid_factory(request): if request.matchdict is not None and 'hash' in request.matchdict: context = models.TalkPreference.query.filter( func.encode( func.digest(func.text(models.TalkPreference.uid), 'sha256'), 'hex') == request.matchdict['hash']).first() if context is None: raise NotFound() return context return object()
def view_easteregg(request): pwd_hash = request.matchdict['hash'] try: log.debug('got %s', pwd_hash) path = os.path.join(egg_dir, eastereggs[pwd_hash]) return FileResponse(path, content_type='text/html') except (KeyError, FileNotFoundError): raise NotFound()
def layouts_redirect_view(people, request): """ Redirects requests for tabs in old people directory to tabs in the new people directory. Tabs in old people directory were referred to as "layouts". """ tab = request.subpath[0] if tab not in people: raise NotFound() section = people[tab] return HTTPFound(location=resource_url(section, request))