def corpus(self):
""" Return a corpus based on environment.
It will try to return it from cache, otherwise load it from disk.
If corpus hasn't been extracted from the document, it will redirect to
a corpus creation tool.
"""
corpus = get_corpus(self.request)
if corpus is None:
raise exc.HTTPNotFound()
return corpus
def delete_courrier_affaire_view(request):
settings = request.registry.settings
filename = request.params['filename']
temporary_directory = settings["temporary_directory"]
file_path = os.path.join(temporary_directory, filename)
if os.path.exists(file_path):
os.remove(file_path)
response = True
return "ok"
else:
raise exc.HTTPNotFound("Le fichier est indisponible")
def get_uuid(shortid):
settings = get_current_registry().settings
with psycopg2.connect(settings[config.CONNECTION_STRING]) as db_connection:
with db_connection.cursor() as cursor:
cursor.execute(SQL['get-module-uuid'], {'id': shortid})
try:
return cursor.fetchone()[0]
except (
TypeError,
IndexError,
): # None returned
logger.debug("Short ID was supplied and could not discover "
"UUID.")
raise httpexceptions.HTTPNotFound()
def __call__(self):
try:
page_content_file = os.path.join(
os.path.dirname(__file__), '..', 'pagecontent',
self.request.matchdict['doc_name'] + '.html')
with file(page_content_file) as f:
page_content = f.read()
except IOError:
return httpexceptions.HTTPNotFound()
return {
'doc': self.request.matchdict['doc_name'],
'page_content': page_content
}
def update(self):
"""Update a single user entry"""
user_id = int(self.request.matchdict['id'])
if not self.logged_in or user_id != self.logged_in:
return exc.HTTPForbidden()
user = self.request.dbsession.query(User).get(user_id)
if user is not None:
args = self.request.json
for key, value in args.items():
if args[key] is not None:
setattr(user, key, value)
transaction.commit()
return {'user': user.to_json()}
raise exc.HTTPNotFound()
def _item_get(request):
fnd, fnm = request.env.file_upload.get_filename(request.matchdict['id'])
if not isfile(fnm):
raise exc.HTTPNotFound()
with open(fnm, 'rb') as fd:
meta = pickle.loads(fd.read())
# Don't return incomplete upload
if meta.get('incomplete', False):
raise UploadNotCompleted()
return Response(json.dumpb(meta), content_type='application/json')
def confirmUser(request):
if not Helper.HiddenPages.validate(request.path):
return exc.HTTPNotFound()
if not Helper.HiddenPages.validate(request.path):
return exc.HTTPNotFound()
try:
username = request.params["username"]
title = request.params["title"]
firstname = request.params["firstname"]
lastname = request.params["lastname"]
organisation = request.params["organisation"]
email = request.params["email"]
password = request.params["password"]
except:
raise exc.HTTPBadRequest("Invalid request")
# Check if username already exists
if len(db.execute("User_Info", [username])):
raise exc.HTTPBadRequest("Username Exists")
salt, hashedPassword = Helper.hashPassword(password)
db.execute("User_confirmTemp", [
username, email, salt, hashedPassword, title, firstname, lastname,
organisation, request.path[-10:]
])
questions = db.execute("collectQuestions", [])
api = ExpertModelAPI()
for rows in questions:
qid = rows["qid"]
model_id = api.create_model(model_type=DEFAULT_TECH)
db.execute("eModel_insertModel", [model_id, username, qid])
Helper.HiddenPages.remove(request.path)
def activate(self):
"""
Handle a request for a user activation link.
Checks if the activation code passed is valid, and (as a safety check)
that it is an activation for the passed user id. If all is well,
activate the user and redirect them to the stream.
"""
code = self.request.matchdict.get('code')
id_ = self.request.matchdict.get('id')
if code is None or id_ is None:
return httpexceptions.HTTPNotFound()
try:
id_ = int(id_)
except ValueError:
return httpexceptions.HTTPNotFound()
activation = Activation.get_by_code(code)
if activation is None:
return httpexceptions.HTTPNotFound()
user = User.get_by_activation(activation)
if user is None or user.id != id_:
return httpexceptions.HTTPNotFound()
# Activate the user (by deleting the activation)
self.request.db.delete(activation)
self.request.session.flash(
_("Your e-mail address has been verified. "
"Thank you!"), 'success')
self.request.registry.notify(ActivationEvent(self.request, user))
return httpexceptions.HTTPFound(
location=self.request.route_url('index'))
def login_view(request):
"""
Login
"""
response = None
login = None
password = None
if 'login' in request.params:
login = request.params['login']
if 'password' in request.params:
password = request.params['password']
# Check if user exists in DB
query = request.dbsession.query(Operateur)
log.info('Attempt to log with: {}'.format(login))
operateur = query.filter(
func.lower(Operateur.login) == func.lower(login)).first()
if not operateur:
return exc.HTTPNotFound('Username {} was not found'.format(login))
try:
resp_json = LDAPQuery.do_login(request, login, password)
except Exception as error:
log.error(str(error))
return {'error': 'true', 'code': 403, 'message': str(error)}
if resp_json and 'dn' in resp_json:
headers = remember(request, resp_json['dn'])
if operateur:
operateur_json = Utils.serialize_one(operateur)
"""
operateur_json['role_id'] = Utils.get_role_id_by_name(request, resp_json['role_name'])
operateur_json['role_name'] = resp_json['role_name']
operateur_json['fonctions'] = Utils.get_fonctions_roles_by_id(request, operateur_json['role_id'])
operateur_json['fonctions'] = [x["nom"] for x in operateur_json['fonctions']]"""
operateur_json = json.dumps(operateur_json) if operateur else ''
response = Response(operateur_json,
content_type='application/json; charset=UTF-8',
headers=headers)
return response
def _parse_feature_results(self, results):
for i in range(0, len(results)):
if 'error' in results[i]:
if results[i]['error'] != '':
raise exc.HTTPNotFound(results[i]['error']) # pragma: no cover
if results[i] is not None and 'matches' in results[i]:
# Add results to the list
for res in results[i]['matches']:
if 'feature_id' in res['attrs']:
res['attrs']['featureId'] = res['attrs']['feature_id']
if self.typeInfo == 'featuresearch' or not self.bbox or \
self._bbox_intersection(self.bbox, res['attrs']['geom_st_box2d']):
if res['attrs']['layer'] == 'ch.bfs.gebaeude_wohnungs_register':
res['attrs'] = self._parse_address(res['attrs'])
self.results['results'].append(res)
def _validate_request(request):
"""
Check that the passed request is appropriate for proceeding with account
claim. Asserts that:
- no-one is logged in
- the claim token is provided and authentic
- the user referred to in the token exists
- the user referred to in the token has not already claimed their account
and raises for redirect or 404 otherwise.
"""
# If signed in, redirect to stream
if request.authenticated_userid is not None:
_perform_logged_in_redirect(request)
payload = _validate_token(request)
if payload is None:
raise exc.HTTPNotFound()
try:
username = util.user.split_user(payload['userid'])['username']
except ValueError:
log.warn('got claim token with invalid userid=%r', payload['userid'])
raise exc.HTTPNotFound()
user = User.get_by_username(username)
if user is None:
log.warn('got claim token with invalid userid=%r', payload['userid'])
raise exc.HTTPNotFound()
# User already has a password? Claimed already.
if user.password:
_perform_already_claimed_redirect(request)
return user
def get_layer(query, model, layerId):
''' Returns exactly one layer or raises
an exception. This function can be used with
both a layer config model or a layer metadata
model. '''
query = query.filter(model.layerBodId == layerId)
try:
layer = query.one()
except NoResultFound:
raise exc.HTTPNotFound('No layer with id %s' % layerId)
except MultipleResultsFound: # pragma: no cover
raise exc.HTTPInternalServerError('Multiple layers found for the same id %s' % layerId)
return layer
def _get_feature_db(featureId, params, models, process=True):
feature = None
# One layer can have several models
for model in models:
# return a sqlalchemy.util._collections.result
feature = _get_feature_by_id(featureId, params, model)
if feature is not None:
vector_model = model
break
if feature is None:
raise exc.HTTPNotFound('No feature with id %s' % featureId)
if process:
feature = _process_feature(feature, params)
feature = {'feature': feature}
return feature, vector_model
def delete_pet(context, request):
"""
Remove a pet
request.matchdict:
* 'pet_id' Pet's Unique identifier `{"type": "string", "required": true, "pattern": "^[a-zA-Z0-9-]+$"}`
"""
pet_id = request.matchdict["pet_id"]
if pet_id in PETS:
logger.info('Deleting pet %s..', pet_id)
del PETS[pet_id]
raise httpexceptions.HTTPNoContent()
else:
raise httpexceptions.HTTPNotFound()
def _item_delete(request, tus):
fnd, fnm = request.env.file_upload.get_filename(request.matchdict['id'])
if not isfile(fnm):
raise exc.HTTPNotFound()
unlink(fnd)
unlink(fnm)
if tus:
return _tus_response(204)
else:
return Response(
json.dumpb(None),
content_type='application/json',
)
def run_query_view(request):
"""
Run a query
:param request:
:return:
"""
query_name = request.matchdict['name']
dashboard_id = request.matchdict['dashboard_id']
query = session.query(Query).filter(Query.name == query_name, Query.dashboard_id == dashboard_id).first()
if not query:
raise exc.HTTPNotFound(json_body={'message': 'Query %s not found' % query_name})
# format query with parameters and dashboard variables
# run http or database query
return format_run_query(request, query.query, request.json_body, dashboard_id, query.data_source)
def get_resource(request):
"""Acquisition of a resource item"""
hash = request.matchdict['hash']
resource = storage.get(hash=hash, type_=Resource)
if resource is None:
raise httpexceptions.HTTPNotFound()
if not request.has_permission('view', resource):
raise httpexceptions.HTTPForbidden()
resp = request.response
with resource.open() as data:
resp.body = data.read()
resp.content_type = resource.media_type
if 'html' in resp.content_type:
resp.content_type = 'application/octet-stream'
return resp
def read_file(self):
try:
if self.admin_id:
return {
'fileId': self.file_id
}
else:
data = self.s3_fileshandler.get_item(self.file_path)['Body'].read()
return Response(
data,
content_type=self.item['ContentType'],
content_encoding=self.item['ContentEncoding']
)
except Exception as e:
raise exc.HTTPNotFound('File %s not found %s' % (self.file_path, e))
def archive_edit_config(request):
archiveConfig = DBSession.query(ConfigArchive).get(request.matchdict['id'])
if not archiveConfig:
return exc.HTTPNotFound()
device = DBSession.query(OpenWrt).get(archiveConfig.router_uuid)
if not device:
return exc.HTTPNotFound()
conf = Uci()
conf.load_tree(archiveConfig.configuration);
if request.POST:
configsToBeUpdated=[]
newConfig = {}
for key, val in request.POST.dict_of_lists().items():
if key != "submitted":
val[0] = val[0].replace("'", '"') # for better json recognition
packagename, configname, optionname = key.split()
if not (packagename in newConfig.keys()):
newConfig[packagename] = {}
newConfig[packagename]['values'] = {}
if not (configname in newConfig[packagename]['values'].keys()):
newConfig[packagename]['values'][configname] = {}
try:
savevalue = json.loads(val[0])
except ValueError:
savevalue = val[0]
newConfig[packagename]['values'][configname][optionname] = savevalue
confToBeArchivedNew = ConfigArchive(datetime.now(),
json.dumps(newConfig),
archiveConfig.router_uuid,
id_generator())
DBSession.add(confToBeArchivedNew)
return HTTPFound(location=request.route_url('confarchive'))
return{ 'hiddenOptions' : ['.index','.type','.name','.anonymous'],
'config' : conf,
'routerName' : device.name,
'date' : archiveConfig.date}
def delete(request, model):
"""
Delete a script view
:param request: HTTP Request
:param model: SQLAlchemy model instance
:return:
"""
record_id = request.matchdict.get('id')
record = session.query(model).filter(model.id == record_id).first()
if not record:
raise exc.HTTPNotFound(json_body={'message': 'Record not found.'})
return session.query(model). \
filter(model.id == record_id). \
delete(synchronize_session='fetch')
def locate_area(request):
from geopy.geocoders import Nominatim
q = request.params['q']
print(q)
geolocator = Nominatim(format_string='%s, addis ababa',
timeout=10,
country_bias='Ethiopia')
location = geolocator.geocode(q)
if location == None:
raise exc.HTTPNotFound()
return {
'address': location.address,
'lat': location.latitude,
'lon': location.longitude
}
def structure_data(self, id=None):
id = self.request.matchdict["id"]
if id is None:
raise exc.HTTPNotFound()
data = model.meta.DBSession.query(tables.Structure)
rec = data.get(int(id))
if rec is None:
raise exc.HTTPNotFound()
records = model.meta.DBSession.query(tables.Structure)
records = records.filter_by(_protein_id=rec.protein.id)
if rec.ligand:
records = records.filter_by(_ligand_id=rec.ligand.id)
def page_url(page):
return h.current_route_path(self.request,
page=page,
_query=self.request.GET)
current_page = int(self.request.matchdict["page"])
self.request.tmpl_context.paginator = paginate.Page(records,
current_page,
url=page_url)
return {}
def _check_access_permissions(self):
if not self.request.has_permission(Permission.Group.READ,
context=self.context):
show_join_page = self.request.has_permission(
Permission.Group.JOIN, self.context)
if not self.request.user:
# Show a page which will prompt the user to login to join.
show_join_page = True
if show_join_page:
self.request.override_renderer = "h:templates/groups/join.html.jinja2"
return {"group": self.group}
raise httpexceptions.HTTPNotFound()
return None
def get_file(self):
# Get the requested tool
tool, tid = self._get_tool()
# Get the file information
file_label = self.request.matchdict['file']
if not file_label in tool.get_file_information():
return exc.HTTPNotFound(detail='Tool %s has no such component %s' %
(tool.name, file_label))
file_content = getattr(tool, file_label)
file_extension = tool.get_file_information()[file_label]['extension']
return Response(content_type='application/force-download',
content_disposition='attachment; filename=%s_%s.%s' %
(tool.name, file_label, file_extension),
body=file_content)
def get(self) -> dict:
"""
Retrieve and render a single message schema.
This API responses to the ``/message_schemas/v1/<topic>`` endpoint.
Returns:
The requested message schema.
"""
try:
return pkg_resources.load_entry_point(
'bodhi-messages', 'fedora.messages',
f"{self.request.matchdict['topic']}.v1").body_schema
except ImportError:
# The user has requested a topic that does not exist
raise httpexceptions.HTTPNotFound()
def get_user(request):
id = request.matchdict['user_id']
try:
user = DBSession.query(User).filter(User.id == id).first()
except DBAPIError:
raise httpexceptions.HTTPServiceUnavailable(
connection_error_message,
content_type='text/plain',
)
if user is None:
raise httpexceptions.HTTPNotFound()
permissible = security.has_permission('view', user, request)
if not permissible:
raise httpexceptions.HTTPForbidden()
return user
def _get_page_in_book(page_uuid,
page_version,
book_uuid,
book_version,
latest=False):
book_ident_hash = join_ident_hash(book_uuid, book_version)
coltree = _get_content_json(ident_hash=book_ident_hash)['tree']
if coltree is None:
raise httpexceptions.HTTPNotFound()
pages = list(flatten_tree_to_ident_hashes(coltree))
page_ident_hash = join_ident_hash(page_uuid, page_version)
if page_ident_hash in pages:
return book_uuid, '{}:{}'.format(
latest and book_uuid or book_ident_hash, page_uuid)
# book not in page
return page_uuid, page_ident_hash
def get_with_prefilled_code(self):
"""Render the reset password form with a prefilled code."""
code = self.request.matchdict["code"]
# If valid, we inject the supplied it into the form as a hidden field.
# Otherwise, we 404.
try:
user = ResetCode().deserialize(self.schema, code)
except colander.Invalid:
raise httpexceptions.HTTPNotFound()
else:
# N.B. the form field for the reset code is called 'user'. See the
# comment in `~h.schemas.forms.accounts.ResetPasswordSchema` for details.
self.form.set_appstruct({"user": user})
self.form.set_widgets({"user": deform.widget.HiddenWidget()})
return {"form": self.form.render(), "has_code": True}
def profile_media_(request):
name = request.matchdict['name']
link_type = request.matchdict['link_type']
userid = profile.resolve_by_username(name)
media_items = media.get_user_media(userid)
if not media_items.get(link_type):
raise httpexceptions.HTTPNotFound()
return Response(headerlist=[
(
'X-Accel-Redirect',
str(media_items[link_type][0]['file_url']),
),
(
'Cache-Control',
'max-age=0',
),
])
def itc_data(self, id=None):
id = self.request.matchdict["id"]
if id is None:
raise exc.HTTPNotFound()
records = model.meta.DBSession.query(
tables.ITC).filter_by(_instrument_id=id)
def page_url(page):
return h.current_route_path(self.request,
page=page,
_query=self.request.GET)
current_page = int(self.request.matchdict["page"])
self.request.tmpl_context.paginator = paginate.Page(records,
current_page,
url=page_url)
return {}
