def reconcile(slug):
"""
Reconciliation API, emulates Google Refine API. See:
http://code.google.com/p/google-refine/wiki/ReconciliationServiceApi
"""
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
# TODO: Add proper support for types and namespacing.
data = request.args.copy()
data.update(request.form.copy())
if 'query' in data:
# single
q = data.get('query')
if q.startswith('{'):
try:
q = json.loads(q)
except ValueError:
raise BadRequest()
else:
q = data
return jsonify(reconcile_op(project, q))
elif 'queries' in data:
# multiple requests in one query
qs = data.get('queries')
try:
qs = json.loads(qs)
except ValueError:
raise BadRequest()
queries = {}
for k, q in qs.items():
queries[k] = reconcile_op(project, q)
return jsonify(queries)
else:
return reconcile_index(project)
def search():
searcher = ESSearcher(request.args)
pager = Pager(searcher)
conv = lambda c: [x for x in c]
data = pager.to_dict(results_converter=conv)
data['facets'] = searcher.facets()
return jsonify(data)
def update(id):
relation = object_or_404(Relation.by_id(id))
authz.require(authz.project_edit(relation.project))
data = request_data({'author': request.account})
relation = relations.save(data, relation=relation)
db.session.commit()
return jsonify(relation)
def suggest():
if 'q' not in request.args or not len(request.args.get('q').strip()):
raise BadRequest("Missing the query ('q' parameter).")
q = db.session.query(Property)
q = q.join(Entity)
q = q.filter(Entity.project_id.in_(authz.permissions().get('reader')))
q = q.filter(Property.name == 'name')
q = q.filter(Property.active == True) # noqa
q = q.filter(Property.entity_id != None) # noqa
q = q.filter(Property.value_string.ilike(request.args.get('q') + '%'))
if 'project' in request.args:
q = q.join(Project)
q = q.filter(Project.slug == request.args.get('project'))
if 'exclude' in request.args:
ents = request.args.getlist('exclude')
q = q.filter(not_(Property.entity_id.in_(ents)))
q = q.distinct()
pager = Pager(q)
data = []
def convert(props):
for prop in props:
data.append({
'properties': {
'name': prop.to_dict_index(),
},
'id': prop.entity_id,
'api_url': url_for('entities_api.view', id=prop.entity_id)
})
return data
validate_cache(keys='#'.join([d['name'] for d in data]))
return jsonify(pager.to_dict(results_converter=convert))
def update(id):
account = object_or_404(Account.by_id(id))
authz.require(account.id == request.account.id)
data = request_data()
account = accounts.save(data, account=account)
db.session.commit()
return jsonify(account)
def update(id):
entity = object_or_404(Entity.by_id(id))
authz.require(authz.project_edit(entity.project))
data = request_data({'author': request.account})
entity = entities.save(data, entity=entity)
db.session.commit()
return jsonify(entities.to_rest(entity))
def suggest():
if not 'q' in request.args or not len(request.args.get('q').strip()):
raise BadRequest("Missing the query ('q' parameter).")
q = db.session.query(EntityProperty)
q = q.join(Entity)
q = q.join(Project)
q = q.outerjoin(Permission)
q = q.filter(or_(Project.private==False,
and_(Permission.reader==True, Permission.account==request.account)))
q = q.filter(EntityProperty.name=='name')
q = q.filter(EntityProperty.active==True)
q = q.filter(EntityProperty.entity_id!=None)
q = q.filter(EntityProperty.value_string.ilike(request.args.get('q') + '%'))
if 'project' in request.args:
q = q.filter(Project.slug==request.args.get('project'))
pager = Pager(q)
data = []
def convert(props):
for prop in props:
data.append({
'name': prop.value,
'api_url': url_for('entities_api.view', id=prop.entity_id)
})
return data
validate_cache(keys='#'.join([d['name'] for d in data]))
return jsonify(pager.to_dict(results_converter=convert))
def suggest():
if not 'q' in request.args or not len(request.args.get('q').strip()):
raise BadRequest("Missing the query ('q' parameter).")
q = db.session.query(EntityProperty)
q = q.filter(EntityProperty.name=='name')
q = q.filter(EntityProperty.active==True)
q = q.filter(EntityProperty.entity_id!=None)
q = q.filter(EntityProperty.value.ilike(request.args.get('q') + '%'))
if 'project' in request.args:
q = q.join(Entity)
q = q.join(Project)
q = q.filter(Project.slug==request.args.get('project'))
pager = Pager(q)
data = []
def convert(props):
for prop in props:
data.append({
'name': prop.value,
'api_url': url_for('entities_api.view', id=prop.entity_id)
})
return data
validate_cache(keys='#'.join([d['name'] for d in data]))
return jsonify(pager.to_dict(results_converter=convert))
def update(id):
entity = object_or_404(Entity.by_id(id))
authz.require(authz.entity_edit(entity))
data = request_data({'author': request.account})
entity = entities.save(data, files=request.files, entity=entity)
db.session.commit()
return jsonify(entity)
def status():
permissions = {}
if authz.logged_in():
for permission in request.account.permissions:
permissions[permission.project.slug] = {
'reader': permission.reader,
'editor': permission.editor,
'admin': permission.admin
}
keys = {
'p': repr(permissions),
'i': request.account.id if authz.logged_in() else None
}
validate_cache(keys=keys)
oauth_providers = {}
for name, provider in PROVIDERS.items():
if not isinstance(provider, Stub):
oauth_providers[name] = url_for('.login', provider=name)
return jsonify({
'logged_in': authz.logged_in(),
'api_key': request.account.api_key if authz.logged_in() else None,
'account': request.account if request.account else None,
'permissions': permissions,
'oauth': oauth_providers
})
def create(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
data = request_data({'project': project})
permission = permissions.save(data)
db.session.commit()
return jsonify(permission, status=201)
def suggest_property(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
prefix = '%%%s%%' % request.args.get('prefix', '')
q = db.session.query(Attribute)
q = q.join(Schema)
q = q.filter(Schema.obj=='entity')
q = q.filter(Schema.project==project)
q = q.filter(or_(Attribute.label.ilike(prefix), Attribute.name.ilike(prefix)))
q = q.limit(get_limit(default=5))
matches = []
for attribute in q:
matches.append({
'name': attribute.label,
'n:type': {
'id': '/properties/property',
'name': 'Property'
},
'id': attribute.name
})
return jsonify({
"code" : "/api/status/ok",
"status" : "200 OK",
"prefix" : request.args.get('prefix', ''),
"result" : matches
})
def update(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
data = request_data({'author': request.account})
project = projects.save(data, project=project)
db.session.commit()
return jsonify(project)
def status():
permissions = {}
if authz.logged_in():
for permission in request.account.permissions:
permissions[permission.project.slug] = {
'reader': permission.reader,
'editor': permission.editor,
'admin': permission.admin
}
keys = {
'p': repr(permissions),
'i': request.account.id if authz.logged_in() else None
}
validate_cache(keys=keys)
oauth_providers = {}
for name, provider in PROVIDERS.items():
if not isinstance(provider, Stub):
oauth_providers[name] = url_for('.login', provider=name)
return jsonify({
'logged_in':
authz.logged_in(),
'api_key':
request.account.api_key if authz.logged_in() else None,
'account':
request.account if request.account else None,
'permissions':
permissions,
'oauth':
oauth_providers
})
def suggest_property(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
prefix = "%%%s%%" % request.args.get("prefix", "")
log.info("Suggesting property names in %s: %r", project.slug, prefix)
q = db.session.query(Attribute)
q = q.join(Schema)
q = q.filter(Schema.obj == "entity")
q = q.filter(Schema.project == project)
q = q.filter(or_(Attribute.label.ilike(prefix), Attribute.name.ilike(prefix)))
q = q.limit(get_limit(default=5))
matches = []
for attribute in q:
matches.append(
{
"name": attribute.label,
"n:type": {"id": "/properties/property", "name": "Property"},
"id": attribute.name,
}
)
return jsonify(
{"code": "/api/status/ok", "status": "200 OK", "prefix": request.args.get("prefix", ""), "result": matches}
)
def update(id):
account = object_or_404(Account.by_id(id))
authz.require(account.id==request.account.id)
data = request_data()
entity = accounts.save(data, account=account)
db.session.commit()
return jsonify(accounts.to_rest(account))
def create(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
data = request_data({'project': project})
permission = permissions.save(data)
db.session.commit()
return jsonify(permission, status=201)
def create(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
data = request_data({"project": project})
schema = schemata.save(data)
db.session.commit()
return jsonify(schema, status=201)
def view(slug, name):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
if not project.private:
validate_cache(last_modified=project.updated_at)
schema = object_or_404(Schema.by_name(project, name))
return jsonify(schema)
def update(id):
relation = object_or_404(Relation.by_id(id))
authz.require(authz.project_edit(relation.project))
data = request_data({'author': request.account})
relation = relations.save(data, relation=relation)
db.session.commit()
return jsonify(relations.to_rest(relation))
def view(slug, name):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
if not project.private:
validate_cache(last_modified=project.updated_at)
schema = object_or_404(Schema.by_name(project, name))
return jsonify(schema)
def suggest_property(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
prefix = '%%%s%%' % request.args.get('prefix', '')
log.info("Suggesting property names in %s: %r", project.slug, prefix)
q = db.session.query(Attribute)
q = q.join(Schema)
q = q.filter(Schema.obj == 'entity')
q = q.filter(Schema.project == project)
q = q.filter(or_(Attribute.label.ilike(prefix),
Attribute.name.ilike(prefix)))
q = q.limit(get_limit(default=5))
matches = []
for attribute in q:
matches.append({
'name': attribute.label,
'n:type': {
'id': '/properties/property',
'name': 'Property'
},
'id': attribute.name
})
return jsonify({
"code": "/api/status/ok",
"status": "200 OK",
"prefix": request.args.get('prefix', ''),
"result": matches
})
def suggest_type(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
prefix = '%%%s%%' % request.args.get('prefix', '')
log.info("Suggesting types in %s: %r", project.slug, prefix)
q = db.session.query(Schema)
q = q.filter(Schema.obj == 'entity')
q = q.filter(Schema.hidden == False) # noqa
q = q.filter(Schema.project == project)
q = q.filter(or_(Schema.label.ilike(prefix), Schema.name.ilike(prefix)))
q = q.limit(get_limit(default=5))
matches = []
for schema in q:
matches.append({
'name': schema.label,
'id': '/%s/%s' % (slug, schema.name)
})
return jsonify({
"code": "/api/status/ok",
"status": "200 OK",
"prefix": request.args.get('prefix', ''),
"result": matches
})
def graph(slug):
project = object_or_404(Project.by_slug(slug))
extractor = GraphExtractor(project_id=project.id)
validate_cache(keys=extractor.to_hash())
if extractor.format == 'gexf':
return Response(extractor.to_gexf(), mimetype='text/xml')
return jsonify(extractor.to_dict())
def create(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
data = request_data({'project': project})
schema = schemata.save(data)
db.session.commit()
return jsonify(schemata.to_rest(schema), status=201)
def update(slug, id):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
permission = object_or_404(Permission.by_project_and_id(project, id))
data = request_data({'project': project})
permission = permissions.save(data, permission=permission)
db.session.commit()
return jsonify(permission)
def authorize(self, **kwargs):
return jsonify(
{
'status': 501,
'name': 'Provider not configured: %s' % self.name,
'message': 'There are no credentials given for %s' % self.name,
},
status=501)
def create():
data = request_data({'author': request.account})
project = ProjectRef().get(data.get('project'))
data['project'] = project
authz.require(authz.project_edit(project))
relation = relations.save(data)
db.session.commit()
return jsonify(relations.to_rest(relation))
def handle_invalid(exc):
body = {
'status': 400,
'name': 'Invalid Data',
'message': unicode(exc),
'errors': exc.asdict()
}
return jsonify(body, status=400)
def index(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
query = Permission.all()
query = query.filter_by(project=project)
pager = Pager(query)
conv = lambda es: [permissions.to_rest_index(e) for e in es]
return jsonify(pager.to_dict(conv))
def create():
data = request_data({'author': request.account})
project = ProjectRef().get(data.get('project'))
data['project'] = project
authz.require(authz.project_edit(project))
file_ = files.save(data, request.files.get('file'))
db.session.commit()
return jsonify(file_)
def index():
q = Project.all()
q = q.outerjoin(Permission)
q = q.filter(or_(Project.private==False,
and_(Permission.reader==True, Permission.account==request.account)))
pager = Pager(q)
conv = lambda es: [projects.to_rest_index_stats(e) for e in es]
return jsonify(pager.to_dict(conv))
def create():
data = request_data({'author': request.account})
project = ProjectRef().get(data.get('project'))
data['project'] = project
authz.require(authz.project_edit(project))
file_ = files.save(data, request.files.get('file'))
db.session.commit()
return jsonify(file_)
def index(slug):
project = object_or_404(Project.by_slug(slug))
validate_cache(last_modified=project.updated_at)
query = Schema.all()
query = query.filter_by(project=project)
pager = Pager(query)
conv = lambda es: [schemata.to_rest_index(e) for e in es]
return jsonify(pager.to_dict(conv))
def index(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
query = Permission.all()
query = query.filter_by(project=project)
pager = Pager(query, slug=slug)
validate_cache(keys=pager.cache_keys())
return jsonify(pager, index=True)
def graph(id):
entity = object_or_404(Entity.by_id(id))
extractor = GraphExtractor(root_id=entity.id)
validate_cache(keys=extractor.to_hash())
if extractor.format == 'gexf':
return Response(extractor.to_gexf(),
mimetype='text/xml')
return jsonify(extractor.to_dict())
def index(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
validate_cache(last_modified=project.updated_at)
query = Schema.all()
query = query.filter_by(project=project)
pager = Pager(query, slug=slug)
return jsonify(pager, index=not arg_bool("full"))
def provider_not_enabled(name):
return jsonify(
{
'status': 501,
'name': 'Provider not configured: %s' % name,
'message': 'There are no OAuth credentials given for %s' % name,
},
status=501)
def update(slug, name):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
schema = object_or_404(Schema.by_name(project, name))
data = request_data({'project': project})
project = schemata.save(data, schema=schema)
db.session.commit()
return jsonify(schemata.to_rest(schema))
def index(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
validate_cache(last_modified=project.updated_at)
query = Schema.all()
query = query.filter_by(project=project)
pager = Pager(query, slug=slug)
return jsonify(pager, index=not arg_bool('full'))
def handle_invalid(exc):
body = {
'status': 400,
'name': 'Invalid Data',
'message': unicode(exc),
'errors': exc.asdict()
}
return jsonify(body, status=400)
def create():
data = request_data({'author': request.account})
project = ProjectRef().get(data.get('project'))
data['project'] = project
authz.require(authz.project_edit(project))
entity = entities.save(data)
db.session.commit()
return jsonify(entities.to_rest(entity))
def create():
data = request_data({'author': request.account})
project = ProjectRef().get(data.get('project'))
data['project'] = project
authz.require(authz.project_edit(project))
relation = relations.save(data)
db.session.commit()
return jsonify(relation)
def index(slug):
project = object_or_404(Project.by_slug(slug))
validate_cache(last_modified=project.updated_at)
query = Schema.all()
query = query.filter_by(project=project)
pager = Pager(query)
conv = lambda es: [schemata.to_rest_index(e) for e in es]
return jsonify(pager.to_dict(conv))
def update(slug, id):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
permission = object_or_404(Permission.by_project_and_id(project, id))
data = request_data({'project': project})
permission = permissions.save(data, permission=permission)
db.session.commit()
return jsonify(permission)
def index(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
query = Permission.all()
query = query.filter_by(project=project)
pager = Pager(query, slug=slug)
validate_cache(keys=pager.cache_keys())
return jsonify(pager, index=True)
def update(slug, name):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
schema = object_or_404(Schema.by_name(project, name))
data = request_data({'project': project})
schema = schemata.save(data, schema=schema)
db.session.commit()
return jsonify(schema)
def index():
q = Project.all()
q = q.outerjoin(Permission)
q = q.filter(or_(Project.private==False,
and_(Permission.reader==True, Permission.account==request.account)))
q = q.distinct()
pager = Pager(q)
validate_cache(keys=pager.cache_keys())
return jsonify(pager, index=True)
def graph(slug):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_read(project))
extractor = GraphExtractor(project_id=project.id)
if not project.private:
validate_cache(keys=extractor.to_hash())
if extractor.format == 'gexf':
return Response(extractor.to_gexf(), mimetype='text/xml')
return jsonify(extractor)
def status():
return jsonify({
'logged_in':
authz.logged_in(),
'api_key':
request.account.api_key if authz.logged_in() else None,
'account':
accounts.to_rest(request.account) if request.account else None
})
def index():
alias = aliased(Entity)
q = db.session.query(alias)
query = filters.for_entities(q, alias)
query = query.distinct()
pager = Pager(query)
validate_cache(keys=pager.cache_keys())
result = pager.to_dict()
result['facets'] = facets.for_entities()
return jsonify(result, index=True)
def delete(slug, name):
project = object_or_404(Project.by_slug(slug))
authz.require(authz.project_manage(project))
schema = object_or_404(Schema.by_name(project, name))
deleted = schemata.delete(schema)
db.session.commit()
if deleted:
raise Gone()
else:
return jsonify(schema)
def index():
alias = aliased(Relation)
q = db.session.query(alias)
query = filters.for_relations(q, alias)
query = query.distinct()
pager = Pager(query)
validate_cache(keys=pager.cache_keys())
result = pager.to_dict()
result['facets'] = facets.for_relations()
return jsonify(result, index=True)
def index():
alias = aliased(Entity)
query = db.session.query(alias)
query = filters.for_entities(query, alias)
query = sorters.for_entities(query, alias)
pager = Pager(query)
validate_cache(keys=pager.cache_keys())
result = pager.to_dict()
result['facets'] = facets.for_entities()
return jsonify(result, index=True)
def handle_exceptions(exc):
if isinstance(exc, HTTPException):
message = exc.get_description(request.environ)
message = message.replace("<p>", "").replace("</p>", "")
body = {"status": exc.code, "name": exc.name, "message": message}
headers = exc.get_headers(request.environ)
else:
body = {"status": 500, "name": exc.__class__.__name__, "message": unicode(exc)}
headers = {}
return jsonify(body, status=body.get("status"), headers=headers)
def index():
query = filter_query(Entity, Entity.all(), request.args)
for schema in request.args.getlist('schema'):
alias = aliased(Schema)
query = query.join(alias, Entity.schemata)
query = query.filter(alias.name.in_(schema.split(',')))
pager = Pager(query)
conv = lambda es: [entities.to_rest_index(e) for e in es]
return jsonify(pager.to_dict(conv))
