def content_item_delete_tag(user, org, content_item_id, tag_id):
"""
Remove a tag from a content item.
"""
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise NotFoundError(
'An ContentItem with ID {} does not exist.'
.format(content_item_id))
tag = Tag.query\
.filter_by(id=tag_id, org_id=org.id)\
.first()
if not tag:
raise NotFoundError(
'Tag with ID {} does not exist.'
.format(tag_id))
for tag in c.tags:
if tag.id == tag_id:
c.tags.remove(tag)
db.session.add(c)
db.session.commit()
# return modified content item
return jsonify(c)
def event_add_tag(user, org, event_id, tag_id):
"""
Add a tag to an event.
"""
e = Event.query\
.filter_by(id=event_id, org_id=org.id)\
.first()
if not e:
raise NotFoundError(
'An Event with ID {} does not exist.'.format(event_id))
if not e.status == 'approved':
raise RequestError(
'You must first approve an Event before adding additional Tags.')
tag = Tag.query\
.filter_by(id=tag_id, org_id=org.id)\
.first()
if not tag:
raise NotFoundError('Tag with ID {} does not exist.'.format(tag_id))
if tag.type != 'impact':
raise RequestError('Events can only be assigned Impact Tags.')
if tag.id not in e.tag_ids:
e.tags.append(tag)
db.session.add(e)
db.session.commit()
# return modified event
return jsonify(e)
def merge_authors(user, org, from_author_id, to_author_id):
"""
Remove an author to a content item.
"""
from_a = Author.query\
.filter_by(id=from_author_id, org_id=org.id)\
.first()
if not from_a:
raise NotFoundError(
'Author with ID "{}" does not exist."'.format(from_author_id))
to_a = Author.query\
.filter_by(id=to_author_id, org_id=org.id)\
.first()
if not to_a:
raise NotFoundError(
'Author with ID "{}" does not exist."'.format(to_author_id))
# re associate content
stmt = update(content_items_authors)\
.where(content_items_authors.c.author_id == from_author_id)\
.values(author_id=to_author_id)
db.session.execute(stmt)
# remove from author id
db.session.delete(from_a)
db.session.commit()
return jsonify(to_a.to_dict(incl_content=True))
def content_item_add_tag(user, org, content_item_id, tag_id):
"""
Add a tag to an content_item.
"""
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise NotFoundError(
'An ContentItem with ID {} does not exist.'
.format(content_item_id))
tag = Tag.query\
.filter_by(id=tag_id, org_id=org.id)\
.first()
if not tag:
raise NotFoundError(
'Tag with ID {} does not exist.'
.format(tag_id))
if tag.type != 'subject':
raise RequestError(
'Content Items can only be assigned Subject Tags.')
if tag.id not in c.subject_tag_ids:
c.tags.append(tag)
db.session.add(c)
db.session.commit()
# return modified content item
return jsonify(c)
def update_setting(user, org, level, name_id):
if level not in ['me', 'orgs']:
raise NotFoundError(
'You cannot store settings for \'{}\''.format(level))
s = fetch_by_id_or_field(Setting,
'name',
name_id,
org_id=org.id,
user_id=user.id,
level=level)
if not s:
raise NotFoundError('Setting "{}" does not yet exist.'.format(
name_id, org.name))
# get the request data
req_data = request_data()
name = req_data.get('name')
value = req_data.get('value')
json_value = req_data.get('json_value')
# if it's a json_value check whether we can parse it as such
if json_value:
if isinstance(value, basestring):
try:
obj_to_json(value)
except:
raise RequestError(
"Setting '{}' with value '{}' was declared as a "
"'json_value' but could not be parsed as such.".format(
name_id, value))
# upsert / patch values.
if name:
s.name = name
if json_value:
if not isinstance(json_value, bool):
if str(json_value).lower() in TRUE_VALUES:
json_value = True
else:
json_value = False
s.json_value = json_value
s.value = obj_to_json(value)
else:
s.value = value
db.session.add(s)
db.session.commit()
return jsonify(s)
def event_delete_tag(user, org, event_id, tag_id):
"""
Remove a tag from an event.
"""
e = Event.query\
.filter_by(id=event_id, org_id=org.id)\
.first()
if not e:
raise NotFoundError(
'An Event with ID {} does not exist.'.format(event_id))
if tag_id not in e.tag_ids:
raise RequestError(
'An Event with ID {} does not currently have an association '
'with a Tag with ID {}.'.format(event_id, tag_id))
# remove tag from event
for tag in e.tags:
if tag.id == tag_id:
e.tags.remove(tag)
# update metrics associated with these content item ids
if len(e.content_item_ids):
rollup_metric.content_summary_from_events(org, e.content_item_ids)
db.session.add(e)
db.session.commit()
# return modified event
return jsonify(e)
def update_author(user, org, author_id):
"""
Update an author.
"""
a = Author.query\
.filter_by(id=author_id, org_id=org.id)\
.first()
if not a:
raise NotFoundError(
'Author with ID "{}" does not exist."'.format(author_id))
req_data = request_data()
cols = get_table_columns(Author)
for k in req_data.keys():
if k not in cols or k in ['id', 'org_id']:
req_data.pop(k, None)
for k, v in req_data.items():
setattr(a, k, v)
db.session.add(a)
db.session.commit()
return jsonify(a)
def author_add_content(user, org, author_id, content_item_id):
"""
Add an author to a content item.
"""
a = Author.query\
.filter_by(id=author_id, org_id=org.id)\
.first()
if not a:
raise NotFoundError(
'Author with ID "{}" does not exist."'.format(author_id))
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise RequestError(
'ContentItem with ID {} does not exist.'.format(content_item_id))
if a.id not in c.author_ids:
c.authors.append(a)
db.session.add(c)
db.session.commit()
# return modified event
return jsonify(a.to_dict(incl_content=True))
def author_remove_content(user, org, author_id, content_item_id):
"""
Remove an author to a content item.
"""
a = Author.query\
.filter_by(id=author_id, org_id=org.id)\
.first()
if not a:
raise NotFoundError(
'Author with ID "{}" does not exist."'.format(author_id))
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise RequestError(
'ContentItem with ID {} does not exist.'.format(content_item_id))
if a.id in c.author_ids:
a.content_items.remove(c)
db.session.add(a)
db.session.commit()
return delete_response()
def get_comparison_items(level, level_id, org_id):
"""
Get a comparison item for any level. We can add more functions to
this as our needs grow.
"""
fx = {
'content': ContentMetricSummary.query
.filter_by(org_id=org_id)\
.filter(ContentMetricSummary.content_item_id.in_(level_id)),
'orgs': OrgMetricSummary.query
.filter(OrgMetricSummary.org_id.in_(level_id)),
}
if not isinstance(level_id, list):
level_id = [level_id]
if len(level_id) == 1:
o = fx[level].first()
else:
o = fx[level].all()
if not len(o):
o = None
if not o:
raise NotFoundError("No {} could be found with ids:\n{}".format(
level, ",".join(level_id)))
if len(level_id) == 1:
yield o.to_dict()
else:
for oo in o:
yield oo.to_dict()
def parse_comparison_level(level):
"""
Validate comparison levels.
"""
if level not in ['content', 'orgs']:
raise NotFoundError('URL Not Found')
return level
def update_author(user, org, author_id):
"""
Update an author.
"""
a = fetch_by_id_or_field(Author,
'name',
author_id,
org_id=org.id,
transform='upper')
if not a:
raise NotFoundError(
'Author with ID/Name "{}" does not exist."'.format(author_id))
req_data = request_data()
cols = get_table_columns(Author)
for k in req_data.keys():
if k not in cols or k in ['id', 'org_id']:
req_data.pop(k, None)
for k, v in req_data.items():
if k == 'name':
if v:
v = v.upper()
setattr(a, k, v)
db.session.add(a)
db.session.commit()
return jsonify(a)
def event_add_thing(user, org, event_id, content_item_id):
"""
Add a thing to an event.
"""
e = Event.query.filter_by(id=event_id, org_id=org.id).first()
if not e:
raise NotFoundError(
'An Event with ID {} does not exist.'.format(event_id))
if not e.status == 'approved':
raise RequestError(
'You must first approve an Event before adding additional ContentItems.'
)
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise RequestError(
'A ContentItem with ID {} does not exist.'.format(content_item_id))
# add content item to event
if c.id not in e.content_item_ids:
e.content_items.append(c)
db.session.add(e)
db.session.commit()
# return modified event
return jsonify(e)
def org_add_user(user, org_id_slug, user_email):
if not user.admin:
raise AuthError('You must be an admin to add a user to an Org.')
# fetch org
org = fetch_by_id_or_field(Org, 'slug', org_id_slug)
if not org:
raise NotFoundError('This Org does not exist.')
# ensure the active user can edit this Org
if user.id not in org.user_ids:
raise ForbiddenError('You are not allowed to edit this Org.')
# localize
localize(org)
# get this new user by id / email
new_org_user = fetch_by_id_or_field(User, 'email', user_email)
if not new_org_user:
raise RequestError('User "{}" does not exist'.format(user_email))
# ensure that user is not already a part of this Org.
if new_org_user.id in org.user_ids:
raise RequestError('User "{}" is already a part of Org "{}"'.format(
new_org_user.email, org.name))
org.users.append(new_org_user)
db.session.commit()
return jsonify(new_org_user)
def delete_recipe(user, org, recipe_id):
r = fetch_by_id_or_field(Recipe, 'slug', recipe_id, org_id=org.id)
if not r:
raise NotFoundError(
'Recipe with id/slug {} does not exist.'.format(recipe_id))
force = arg_bool('force', default=False)
if force:
db.session.delete(r)
else:
# just delete recipes with no approved events.
event_cnt = r.events.filter_by(status='approved').count()
if event_cnt > 0:
r.status = 'inactive'
db.session.add(r)
else:
db.session.delete(r)
# set the status of associated pending events to 'deleted'
cmd = """
UPDATE events SET status='deleted' WHERE recipe_id = {} AND status='pending';
""".format(r.id)
db.session.execute(cmd)
db.session.commit()
return delete_response()
def org_user(user, org_id_slug, user_email):
# fetch org
org = fetch_by_id_or_field(Org, 'slug', org_id_slug)
if not org:
raise NotFoundError('This Org does not exist.')
# ensure the active user can edit this Org
if user.id not in org.user_ids:
raise ForbiddenError('You are not allowed to access this Org')
# localize
localize(org)
# get this new user by id / email
org_user = fetch_by_id_or_field(User, 'email', user_email)
if not org_user:
raise RequestError('This user does not yet exist')
# check whether this user can view this other user:
if not len(list(set(org_user.org_ids).intersection(set(user.org_ids)))):
raise ForbiddenError('You are not allowed to view this user.'.format(
user.email))
return jsonify(org_user)
def org_delete(user, org_id_slug):
if not user.admin:
raise AuthError('You must be an admin to delete an Org')
# fetch org
org = fetch_by_id_or_field(Org, 'slug', org_id_slug)
# if it still doesn't exist, raise an error.
if not org:
raise NotFoundError('This Org does not exist.')
# localize
localize(org)
# ensure the active user can edit this Org
if user.id not in org.user_ids:
raise ForbiddenError(
'User "{}" is not allowed to access Org "{}".'.format(
user.name, org.name))
db.session.delete(org)
db.session.commit()
return delete_response()
def event_delete_content_item(user, org, event_id, content_item_id):
"""
Remove a thing from an event.
"""
e = Event.query\
.filter_by(id=event_id, org_id=org.id)\
.first()
if not e:
raise NotFoundError(
'An Event with ID {} does not exist.'.format(event_id))
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise RequestError(
'A ContentItem with ID {} does not exist.'.format(content_item_id))
if content_item_id not in e.content_item_ids:
raise RequestError(
'An Event with ID {} does not currently have an association '
'with a ContentItem with ID {}'.format(event_id, content_item_id))
# remove the content item form the event.
e.content_items.remove(c)
db.session.add(e)
db.session.commit()
# return modified event
return jsonify(e)
def delete_content_item(user, org, content_item_id):
"""
Update an individual content-item.
"""
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise NotFoundError(
'An ContentItem with ID {} does not exist.'
.format(content_item_id))
# delete metrics
cmd = """
DELETE FROM content_metric_timeseries WHERE content_item_id = {0};
DELETE FROM content_metric_summary WHERE content_item_id = {0};
""".format(content_item_id)
# delete content item + metrics
db.session.execute(cmd)
db.session.delete(c)
db.session.commit()
return delete_response()
def list_settings(user, org, level):
if level not in ['me', 'orgs']:
raise NotFoundError(
'You cannot store settings for \'{}\''.format(level))
if level == 'orgs':
return jsonify(org.settings)
return jsonify(user.get_settings(org_id=org.id))
def create_content_item_timeseries(user, org, content_item_id):
"""
Upsert content timseries metrics.
"""
c = ContentItem.query\
.filter_by(id=content_item_id)\
.filter_by(org_id=org.id)\
.first()
if not c:
raise NotFoundError(
'A ContentItem with ID {} does not exist'.format(content_item_id))
# insert content item id
req_data = request_data()
if not isinstance(req_data, list):
req_data = [req_data]
data = []
for row in req_data:
row.update({'content_item_id': c.id})
data.append(row)
# load.
ret = load.content_timeseries(
data,
org_id=org.id,
metrics_lookup=org.content_timeseries_metrics,
content_item_ids=[content_item_id],
queue=False)
return jsonify(ret)
def event_delete_tag(user, org, event_id, tag_id):
"""
Remove a tag from an event.
"""
e = Event.query\
.filter_by(id=event_id, org_id=org.id)\
.first()
if not e:
raise NotFoundError(
'An Event with ID {} does not exist.'.format(event_id))
if tag_id not in e.tag_ids:
raise RequestError(
'An Event with ID {} does not currently have an association '
'with a Tag with ID {}.'.format(event_id, tag_id))
# remove tag from event
for tag in e.tags:
if tag.id == tag_id:
e.tags.remove(tag)
db.session.add(e)
db.session.commit()
# return modified event
return jsonify(e)
def get_content_timeseries(user, org, content_item_id):
"""
Query an individual content timeseries.
"""
c = ContentItem.query\
.filter_by(id=content_item_id)\
.filter_by(org_id=org.id)\
.first()
if not c:
raise NotFoundError(
'A ContentItem with ID {} does not exist'
.format(content_item_id))
# select / exclude
select, exclude = arg_list('select', typ=str, exclusions=True, default=['*'])
if '*' in select:
exclude = []
select = "*"
kw = dict(
unit=arg_str('unit', default='hour'),
sparse=arg_bool('sparse', default=True),
sig_digits=arg_int('sig_digits', default=2),
select=select,
exclude=exclude,
rm_nulls=arg_bool('rm_nulls', default=False),
time_since_start=arg_bool('time_since_start', default=False),
transform=arg_str('transform', default=None),
before=arg_date('before', default=None),
after=arg_date('after', default=None)
)
q = QueryContentMetricTimeseries(org, [content_item_id], **kw)
return jsonify(list(q.execute()))
def author_remove_content(user, org, author_id, content_item_id):
"""
Remove an author from a content item.
"""
a = fetch_by_id_or_field(Author,
'name',
author_id,
org_id=org.id,
transform='upper')
if not a:
raise NotFoundError(
'Author with ID/Name "{}" does not exist."'.format(author_id))
c = ContentItem.query\
.filter_by(id=content_item_id, org_id=org.id)\
.first()
if not c:
raise RequestError(
'ContentItem with ID {} does not exist.'.format(content_item_id))
if a.id in c.author_ids:
a.content_items.remove(c)
db.session.add(a)
db.session.commit()
return delete_response()