def item(_id):
items = get_items_for_user_action([_id], 'items')
if not items:
return
item = items[0]
set_permissions(item, 'wire', False if flask.request.args.get('ignoreLatest') == 'false' else True)
display_char_count = get_resource_service('ui_config').getSectionConfig('wire').get('char_count', False)
if is_json_request(flask.request):
return flask.jsonify(item)
if not item.get('_access'):
return flask.render_template('wire_item_access_restricted.html', item=item)
previous_versions = get_previous_versions(item)
template = 'wire_item.html'
data = {'item': item}
if 'print' in flask.request.args:
if flask.request.args.get('monitoring_profile'):
data.update(flask.request.view_args)
template = 'monitoring_export.html'
else:
template = 'wire_item_print.html'
update_action_list([_id], 'prints', force_insert=True)
get_resource_service('history').create_history_record([item], 'print', get_user(),
request.args.get('type', 'wire'))
return flask.render_template(
template,
**data,
previous_versions=previous_versions,
display_char_count=display_char_count)
def download(_ids):
user = get_user(required=True)
_format = flask.request.args.get('format', 'text')
item_type = get_type()
items = [get_entity_or_404(_id, item_type) for _id in _ids.split(',')]
_file = io.BytesIO()
formatter = app.download_formatters[_format]['formatter']
mimetype = None
attachment_filename = '%s-newsroom.zip' % utcnow().strftime('%Y%m%d%H%M')
if len(items) == 1:
item = items[0]
parse_dates(item) # fix for old items
_file.write(formatter.format_item(item, item_type=item_type))
_file.seek(0)
mimetype = formatter.get_mimetype(item)
attachment_filename = secure_filename(formatter.format_filename(item))
else:
with zipfile.ZipFile(_file, mode='w') as zf:
for item in items:
parse_dates(item) # fix for old items
zf.writestr(secure_filename(formatter.format_filename(item)),
formatter.format_item(item, item_type=item_type))
_file.seek(0)
update_action_list(_ids.split(','), 'downloads', force_insert=True)
app.data.insert('history',
items,
action='download',
user=user,
section=request.args.get('type', 'wire'))
return flask.send_file(_file,
mimetype=mimetype,
attachment_filename=attachment_filename,
as_attachment=True)
def export(_ids):
user = get_user(required=True)
_format = flask.request.args.get('format')
if not _format:
return jsonify({'message': 'No format specified.'}), 400
layout_format = flask.request.args.get('secondary_format')
formatter = app.download_formatters[_format]['formatter']
monitoring_profile = get_entity_or_404(
flask.request.args.get('monitoring_profile'), 'monitoring')
monitoring_profile['format_type'] = _format
monitoring_profile['alert_type'] = layout_format
items = get_items_for_monitoring_report([_id for _id in _ids.split(',')],
monitoring_profile)
if len(items) > 0:
try:
_file = get_monitoring_file(monitoring_profile, items)
except Exception as e:
logger.exception(e)
return jsonify({'message': 'Error exporting items to file'}), 400
if _file:
update_action_list(_ids.split(','), 'export', force_insert=True)
get_resource_service('history').create_history_record(
items, 'export', user, 'monitoring')
return send_file(
_file,
mimetype=formatter.get_mimetype(None),
attachment_filename=formatter.format_filename(None),
as_attachment=True)
return jsonify({'message': 'No files to export.'}), 400
def bookmark():
data = get_json_or_400()
assert data.get('items')
update_action_list(data.get('items'), 'bookmarks', item_type='agenda')
push_user_notification(
'saved_items',
count=get_resource_service('agenda').get_saved_items_count())
return flask.jsonify(), 200
def copy(_id):
item_type = get_type()
item = get_entity_or_404(_id, item_type)
update_action_list([_id], 'copies', item_type=item_type)
get_resource_service('history').create_history_record([item], 'copy',
get_user(),
request.args.get(
'type', 'wire'))
return flask.jsonify(), 200
def download(_ids):
user = get_user(required=True)
_format = flask.request.args.get('format', 'text')
item_type = get_type()
items = get_items_for_user_action(_ids.split(','), item_type)
_file = io.BytesIO()
formatter = app.download_formatters[_format]['formatter']
mimetype = None
attachment_filename = '%s-newsroom.zip' % utcnow().strftime('%Y%m%d%H%M')
if formatter.get_mediatype() == 'picture':
if len(items) == 1:
try:
picture = formatter.format_item(items[0], item_type=item_type)
return flask.redirect(
url_for('upload.get_upload',
media_id=picture['media'],
filename='baseimage%s' %
picture['file_extension']))
except ValueError:
return flask.abort(404)
else:
with zipfile.ZipFile(_file, mode='w') as zf:
for item in items:
try:
picture = formatter.format_item(item,
item_type=item_type)
file = flask.current_app.media.get(
picture['media'], ASSETS_RESOURCE)
zf.writestr('baseimage%s' % picture['file_extension'],
file.read())
except ValueError:
pass
_file.seek(0)
elif len(items) == 1 or _format == 'monitoring':
item = items[0]
args_item = item if _format != 'monitoring' else items
parse_dates(item) # fix for old items
_file.write(formatter.format_item(args_item, item_type=item_type))
_file.seek(0)
mimetype = formatter.get_mimetype(item)
attachment_filename = secure_filename(formatter.format_filename(item))
else:
with zipfile.ZipFile(_file, mode='w') as zf:
for item in items:
parse_dates(item) # fix for old items
zf.writestr(secure_filename(formatter.format_filename(item)),
formatter.format_item(item, item_type=item_type))
_file.seek(0)
update_action_list(_ids.split(','), 'downloads', force_insert=True)
get_resource_service('history').create_history_record(
items, 'download', user, request.args.get('type', 'wire'))
return flask.send_file(_file,
mimetype=mimetype,
attachment_filename=attachment_filename,
as_attachment=True)
def bookmark():
"""Bookmark an item.
Stores user id into item.bookmarks array.
Uses mongodb to update the array and then pushes updated array to elastic.
"""
data = get_json_or_400()
assert data.get('items')
update_action_list(data.get('items'), 'bookmarks', item_type='items')
user_id = get_user_id()
push_user_notification('saved_items', count=get_bookmarks_count(user_id, 'wire'))
return flask.jsonify(), 200
def share():
current_user = get_user(required=True)
item_type = get_type()
data = get_json_or_400()
assert data.get('users')
assert data.get('items')
items = get_items_for_user_action(data.get('items'), item_type)
for user_id in data['users']:
user = superdesk.get_resource_service('users').find_one(req=None,
_id=user_id)
subject = items[0].get('headline')
# If it's an event, 'name' is the subject
if items[0].get('event'):
subject = items[0]['name']
if not user or not user.get('email'):
continue
template_kwargs = {
'recipient': user,
'sender': current_user,
'items': items,
'message': data.get('message'),
'section': request.args.get('type', 'wire')
}
if item_type == 'agenda':
template_kwargs['maps'] = data.get('maps')
template_kwargs['dateStrings'] = [
get_agenda_dates(item) for item in items
]
template_kwargs['locations'] = [
get_location_string(item) for item in items
]
template_kwargs['contactList'] = [
get_public_contacts(item) for item in items
]
template_kwargs['linkList'] = [get_links(item) for item in items]
template_kwargs['is_admin'] = is_admin_or_internal(user)
send_email(
[user['email']],
gettext('From %s: %s' % (app.config['SITE_NAME'], subject)),
text_body=flask.render_template('share_{}.txt'.format(item_type),
**template_kwargs),
html_body=flask.render_template('share_{}.html'.format(item_type),
**template_kwargs),
)
update_action_list(data.get('items'), 'shares', item_type=item_type)
get_resource_service('history').create_history_record(
items, 'share', current_user, request.args.get('type', 'wire'))
return flask.jsonify(), 201
def share():
data = get_json_or_400()
assert data.get('users')
assert data.get('items')
assert data.get('monitoring_profile')
current_user = get_user(required=True)
monitoring_profile = get_entity_or_404(data.get('monitoring_profile'),
'monitoring')
items = get_items_for_monitoring_report(data.get('items'),
monitoring_profile)
for user_id in data['users']:
user = get_resource_service('users').find_one(req=None, _id=user_id)
template_kwargs = {
'recipient': user,
'sender': current_user,
'message': data.get('message'),
'item_name': 'Monitoring Report',
}
formatter = app.download_formatters['monitoring_pdf']['formatter']
monitoring_profile['format_type'] = 'monitoring_pdf'
_file = get_monitoring_file(monitoring_profile, items)
attachment = base64.b64encode(_file.read())
send_email(
[user['email']],
gettext(
'From %s: %s' % (app.config['SITE_NAME'],
monitoring_profile.get(
'subject', monitoring_profile['name']))),
text_body=flask.render_template('share_items.txt',
**template_kwargs),
html_body=flask.render_template('share_items.html',
**template_kwargs),
attachments_info=[{
'file':
attachment,
'file_name':
formatter.format_filename(None),
'content_type':
'application/{}'.format(formatter.FILE_EXTENSION),
'file_desc':
'Monitoring Report'
}],
)
update_action_list(data.get('items'), 'shares')
get_resource_service('history').create_history_record(
items, 'share', current_user, 'monitoring')
return jsonify({'success': True}), 200
def item(_id):
item = get_entity_or_404(_id, 'agenda')
user = get_user()
company = get_user_company(user)
if not is_admin_or_internal(user):
item.get('event', {}).pop('files', None)
planning_items = item.get('planning_items', [])
[item.pop('internal_note', None) for item in planning_items]
coverages = item.get('coverages', [])
[c.get('planning', {}).pop('internal_note', None) for c in coverages]
item.get('event', {}).pop('internal_note', None)
if company and not is_admin(user) and company.get('events_only', False):
# if the company has permission events only permission then
# remove planning items and coverages.
if not item.get('event'):
# for adhoc planning items abort the request
flask.abort(403)
item.pop('planning_items', None)
item.pop('coverages', None)
if is_json_request(flask.request):
return flask.jsonify(item)
if 'print' in flask.request.args:
map = flask.request.args.get('map')
template = 'agenda_item_print.html'
update_action_list([_id], 'prints', force_insert=True)
return flask.render_template(
template,
item=item,
map=map,
dateString=get_agenda_dates(item),
location=get_location_string(item),
contacts=get_public_contacts(item),
links=get_links(item),
is_admin=is_admin_or_internal(user)
)
data = get_view_data()
data['item'] = item
return flask.render_template('agenda_index.html', data=data, title=item.get('name', item.get('headline')))
def item(_id):
item = get_entity_or_404(_id, 'items')
set_permissions(item, 'wire')
display_char_count = get_resource_service('ui_config').getSectionConfig(
'wire').get('char_count', False)
if is_json_request(flask.request):
return flask.jsonify(item)
if not item.get('_access'):
return flask.render_template('wire_item_access_restricted.html',
item=item)
previous_versions = get_previous_versions(item)
if 'print' in flask.request.args:
template = 'wire_item_print.html'
update_action_list([_id], 'prints', force_insert=True)
else:
template = 'wire_item.html'
return flask.render_template(template,
item=item,
previous_versions=previous_versions,
display_char_count=display_char_count)
def follow():
data = get_json_or_400()
assert data.get('items')
for item_id in data.get('items'):
user_id = get_user_id()
item = get_entity_or_404(item_id, 'agenda')
coverage_updates = {'coverages': item.get('coverages') or []}
for c in coverage_updates['coverages']:
if c.get('watches') and user_id in c['watches']:
c['watches'].remove(user_id)
if request.method == 'POST':
updates = {
'watches': list(set((item.get('watches') or []) + [user_id]))
}
if item.get('coverages'):
updates.update(coverage_updates)
get_resource_service('agenda').patch(item_id, updates)
else:
if request.args.get('bookmarks'):
user_item_watches = [
u for u in (item.get('watches') or [])
if str(u) == str(user_id)
]
if not user_item_watches:
# delete user watches of all coverages
get_resource_service('agenda').patch(
item_id, coverage_updates)
return flask.jsonify(), 200
update_action_list(data.get('items'),
'watches',
item_type='agenda')
push_user_notification(
'saved_items',
count=get_resource_service('agenda').get_saved_items_count())
return flask.jsonify(), 200
def copy(_id):
item_type = get_type()
get_entity_or_404(_id, item_type)
update_action_list([_id], 'copies', item_type=item_type)
return flask.jsonify(), 200
