def test_push_coverages_with_linked_stories(client, app):
event = deepcopy(test_event)
event['guid'] = 'foo7'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
planning = deepcopy(test_planning)
planning['guid'] = 'bar7'
planning['event_item'] = 'foo7'
planning['coverages'][0]['deliveries'] = [{'item_id': 'item7'}]
planning['coverages'][0]['workflow_status'] = 'completed'
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
assert parsed['coverages'][0]['delivery_id'] == 'item7'
assert parsed['coverages'][0]['delivery_href'] == '/wire?item=item7'
planning['coverages'][0]['deliveries'] = []
planning['coverages'][0]['workflow_status'] = 'active'
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
assert parsed['coverages'][0]['delivery_id'] is None
assert parsed['coverages'][0]['delivery_href'] is None
def test_push_cancelled_planning_for_an_existing_event(client, app):
event = deepcopy(test_event)
event['guid'] = 'foo5'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
parsed = get_entity_or_404(event['guid'], 'agenda')
assert type(parsed['firstcreated']) == datetime
assert 1 == len(parsed['event']['event_contact_info'])
assert 1 == len(parsed['location'])
# first push
planning = deepcopy(test_planning)
planning['guid'] = 'bar2'
planning['event_item'] = 'foo5'
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo5', 'agenda')
assert len(parsed['coverages']) == 2
assert len(parsed['planning_items']) == 1
# update the planning for cancel
planning['pubstatus'] = 'cancelled'
planning['state'] = 'cancelled'
# second push
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo5', 'agenda')
assert len(parsed['coverages']) == 0
assert len(parsed['planning_items']) == 0
def test_push_cancelled_planning_cancels_adhoc_planning(client, app):
# pushing an event to create the index
event = deepcopy(test_event)
event['guid'] = 'foo6'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
# remove event link from planning item
planning = deepcopy(test_planning)
planning['guid'] = 'bar3'
planning['event_item'] = None
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('bar3', 'agenda')
assert parsed['state'] == 'scheduled'
# cancel planning item
planning['state'] = 'cancelled'
planning[
'ednote'] = '-------------------------\nPlanning cancelled\nReason: Test\n',
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('bar3', 'agenda')
assert parsed['state'] == 'cancelled'
assert 'Reason' in parsed['ednote'][0]
def edit(id):
get_entity_or_404(id, 'cards')
data = json.loads(flask.request.form['card'])
card_data = _get_card_data(data)
get_resource_service('cards').patch(id=ObjectId(id), updates=card_data)
return jsonify({'success': True}), 200
def edit(_id):
get_entity_or_404(_id, 'navigations')
data = json.loads(flask.request.form['navigation'])
nav_data = _get_navigation_data(data)
get_resource_service('navigations').patch(id=ObjectId(_id),
updates=nav_data)
return jsonify({'success': True}), 200
def test_push_coverages_with_correction_to_linked_stories(client, app):
event = deepcopy(test_event)
event['guid'] = 'foo7'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
planning = deepcopy(test_planning)
planning['guid'] = 'bar7'
planning['event_item'] = 'foo7'
planning['coverages'][0]['deliveries'] = [{
'item_id': 'item7',
'item_state': 'published',
}]
planning['coverages'][0]['workflow_status'] = 'completed'
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
assert parsed['coverages'][0]['delivery_id'] == 'item7'
assert parsed['coverages'][0]['delivery_href'] == '/wire/item7'
# Publish an update to the original story
planning['coverages'][0]['deliveries'].append({
'item_id': 'item8',
'item_state': 'published',
'sequence_no': 1,
})
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
# Coverage should point to the latest version
assert parsed['coverages'][0]['delivery_id'] == 'item8'
assert parsed['coverages'][0]['delivery_href'] == '/wire/item8'
# Publish a correction to the latest version
planning['coverages'][0]['deliveries'].append({
'item_id': 'item8',
'item_state': 'corrected',
'sequence_no': 1,
})
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
# Coverage should still point to the latest version
assert parsed['coverages'][0]['delivery_id'] == 'item8'
assert parsed['coverages'][0]['delivery_href'] == '/wire/item8'
def delete(_id):
""" Deletes the navigations by given id """
get_entity_or_404(_id, 'navigations')
# remove all references from products
db = app.data.get_mongo_collection('products')
products = get_products_by_navigation(_id)
for product in products:
db.update_one({'_id': product['_id']}, {'$pull': {'navigations': _id}})
get_resource_service('navigations').delete({'_id': ObjectId(_id)})
return jsonify({'success': True}), 200
def edit(_id):
if flask.request.args.get('context', '') == 'wire':
items = get_items_for_user_action([_id], 'items')
if not items:
return
item = items[0]
if is_json_request(flask.request):
return flask.jsonify(item)
if 'print' in flask.request.args:
assert flask.request.args.get('monitoring_profile')
monitoring_profile = get_entity_or_404(
flask.request.args.get('monitoring_profile'), 'monitoring')
items = get_items_for_monitoring_report([_id],
monitoring_profile,
full_text=True)
flask.request.view_args['date_items_dict'] = get_date_items_dict(items)
flask.request.view_args['monitoring_profile'] = monitoring_profile
flask.request.view_args['monitoring_report_name'] = app.config.get(
'MONITORING_REPORT_NAME', 'Newsroom')
flask.request.view_args['print'] = True
return wire_print(_id)
profile = find_one('monitoring', _id=ObjectId(_id))
if not profile:
return NotFound(gettext('monitoring Profile not found'))
if flask.request.method == 'POST':
form = MonitoringForm(monitoring=profile)
if form.validate_on_submit():
updates = form.data
request_updates = flask.request.get_json()
# If the updates have anything other than 'users', only admin or monitoring_admin can update
if len(request_updates.keys()
) == 1 and 'users' not in request_updates:
user = get_user()
if not is_admin(user):
return jsonify({'error': 'Bad request'}), 400
company = get_entity_or_404(profile['company'], 'companies')
if str(user['_id']) != str(
company.get('monitoring_administrator')):
return jsonify({'error': 'Bad request'}), 400
process_form_request(updates, request_updates, form)
set_version_creator(updates)
get_resource_service('monitoring').patch(ObjectId(_id),
updates=updates)
return jsonify({'success': True}), 200
return jsonify(form.errors), 400
return jsonify(profile), 200
def save_navigation_products(id):
get_entity_or_404(id, 'navigations')
data = get_json_or_400()
products = list(query_resource('products', max_results=200))
db = app.data.get_mongo_collection('products')
for product in products:
if str(product['_id']) in data.get('products', []):
db.update_one({'_id': product['_id']}, {'$addToSet': {'navigations': id}})
else:
db.update_one({'_id': product['_id']}, {'$pull': {'navigations': id}})
return jsonify(), 200
def test_push_coverages_with_updates_to_linked_stories(client, app):
event = deepcopy(test_event)
event['guid'] = 'foo7'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
planning = deepcopy(test_planning)
planning['guid'] = 'bar7'
planning['event_item'] = 'foo7'
planning['coverages'][0]['deliveries'] = [{
'item_id': 'item7',
'item_state': 'published',
}]
planning['coverages'][0]['workflow_status'] = 'completed'
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
assert parsed['coverages'][0]['delivery_id'] == 'item7'
assert parsed['coverages'][0]['delivery_href'] == '/wire/item7'
planning['coverages'][0]['deliveries'].append({
'item_id': 'item8',
'item_state': 'in_progress',
'sequence_no': 1,
})
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
assert parsed['coverages'][0]['delivery_id'] == 'item7'
assert parsed['coverages'][0]['delivery_href'] == '/wire/item7'
planning['coverages'][0]['deliveries'].append({
'item_id': 'item8',
'item_state': 'published',
'sequence_no': 2,
})
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
assert parsed['coverages'][0]['delivery_id'] == 'item8'
assert parsed['coverages'][0]['delivery_href'] == '/wire/item8'
def share():
current_user = get_user(required=True)
data = get_json_or_400()
assert data.get('users')
assert data.get('items')
topic = get_entity_or_404(data.get('items')['_id'], 'topics')
for user_id in data['users']:
user = get_resource_service('users').find_one(req=None, _id=user_id)
if not user or not user.get('email'):
continue
template_kwargs = {
'recipient': user,
'sender': current_user,
'topic': topic,
'url': get_topic_url(topic),
'message': data.get('message'),
'app_name': app.config['SITE_NAME'],
}
send_email(
[user['email']],
gettext('From %s: %s' % (app.config['SITE_NAME'], topic['label'])),
render_template('share_topic.txt', **template_kwargs),
)
return jsonify(), 201
def test_push_event_coverage_info(client, app):
client.post('/push',
data=json.dumps(item),
content_type='application/json')
parsed = get_entity_or_404(item['guid'], 'items')
assert parsed['event_id'] == 'urn:event/1'
assert parsed['coverage_id'] == 'urn:coverage/1'
def test_coverages_delivery_sequence_has_default(client, app):
event = deepcopy(test_event)
event['guid'] = 'foo7'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
planning = deepcopy(test_planning)
planning['guid'] = 'bar7'
planning['event_item'] = 'foo7'
planning['coverages'][0]['deliveries'] = [{
'item_id': 'item7',
'item_state': 'published',
'sequence_no': None
}]
planning['coverages'][0]['workflow_status'] = 'completed'
planning['coverages'][0]['coverage_type'] = 'text'
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo7', 'agenda')
assert 2 == len(parsed['coverages'])
assert parsed['coverages'][0]['delivery_id'] == 'item7'
assert parsed['coverages'][0]['delivery_href'] == '/wire/item7'
assert parsed['coverages'][0]['deliveries'][0]['sequence_no'] == 0
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 watch_coverage():
user_id = get_user_id()
data = get_json_or_400()
assert data.get('item_id')
assert data.get('coverage_id')
item = get_entity_or_404(data['item_id'], 'agenda')
if item.get('watches') and user_id in item['watches']:
return flask.jsonify({
'error':
gettext('Cannot edit coverage watch when watching a parent item.')
}), 403
try:
coverage_index = [
c['coverage_id'] for c in (item.get('coverages') or [])
].index(data['coverage_id'])
except ValueError:
return flask.jsonify({'error': gettext('Coverage not found.')}), 404
updates = {'coverages': item['coverages']}
if request.method == 'POST':
updates['coverages'][coverage_index]['watches'] = list(
set((updates['coverages'][coverage_index].get('watches') or []) +
[user_id]))
else:
try:
updates['coverages'][coverage_index]['watches'].remove(user_id)
except Exception:
return flask.jsonify({'error':
gettext('Error removing watch.')}), 404
get_resource_service('agenda').patch(data['item_id'], updates)
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_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 test_ical_formatter_item(client, app, mocker):
client.post('/push', data=json.dumps(event), content_type='application/json')
parsed = get_entity_or_404(event['guid'], 'agenda')
formatter = iCalFormatter()
assert formatter.format_filename(parsed).endswith('new-press-conference.ical')
mocker.patch('newsroom.agenda.formatters.ical_formatter.utcnow', return_value=datetime(2018, 7, 30, 11, 9, 0))
ical = formatter.format_item(parsed, item_type='agenda')
cal = icalendar.cal.Calendar.from_ical(ical)
assert cal['version'] == '2.0'
assert cal['prodid'] == 'Newshub'
assert 1 == len(cal.subcomponents)
vevent = cal.subcomponents[0]
assert vevent['uid'] == event['guid']
assert vevent['summary'] == event['name']
assert vevent['description'] == event['definition_long']
assert vevent['dtstart'].to_ical() == b'20180528T040000Z'
assert vevent['dtend'].to_ical() == b'20180528T050000Z'
assert vevent['dtstamp'].to_ical() == b'20180730T110900Z'
assert vevent['attach'] == 'http://*****:*****@foo.com'
assert vevent['rrule'].to_ical() == b'FREQ=DAILY;COUNT=3;INTERVAL=1'
def share():
current_user = get_user(required=True)
data = get_json_or_400()
assert data.get('users')
assert data.get('items')
topic = get_entity_or_404(data.get('items')[0]['_id'], 'topics')
with app.mail.connect() as connection:
for user_id in data['users']:
user = get_resource_service('users').find_one(req=None, _id=user_id)
if not user or not user.get('email'):
continue
template_kwargs = {
'recipient': user,
'sender': current_user,
'topic': topic,
'url': '{}/?q={}'.format(app.config['CLIENT_URL'], parse.quote(topic['query'])),
'message': data.get('message'),
'app_name': app.config['SITE_NAME'],
}
send_email(
[user['email']],
gettext('From %s: %s' % (app.config['SITE_NAME'], topic['label'])),
render_template('share_topic.txt', **template_kwargs),
sender=current_user['email'],
connection=connection
)
return jsonify(), 201
def test_item_planning_reference_set_on_fulfill(client, app):
planning = deepcopy(test_planning)
planning['guid'] = 'bar1'
planning['event_item'] = None
post_json(client, '/push', planning)
item = deepcopy(text_item)
post_json(client, '/push', item)
planning = deepcopy(test_planning)
planning['guid'] = 'bar1'
planning['event_item'] = None
planning['coverages'][0]['deliveries'] = [{
'item_id':
'urn:newsml:localhost:2020-08-06T15:59:39.183090:1f02e9bb-3007-48f3-bfad-ffa6107f87bd',
'item_state': 'published',
}]
planning['coverages'][0]['workflow_status'] = 'completed'
post_json(client, '/push', planning)
parsed = get_entity_or_404(
'urn:newsml:localhost:2020-08-06T15:59:39.183090:1f02e9bb-3007-48f3-bfad-ffa6107f87bd',
'content_api')
assert parsed['planning_id'] == 'bar1'
assert parsed['coverage_id'] == 'urn:newsml:localhost:5000:2018-05-28T20:55:' \
'00.496765:197d3430-9cd1-4b93-822f-c3c050b5b6ab'
def test_push_parsed_item(client, app):
client.post('/push',
data=json.dumps(item),
content_type='application/json')
parsed = get_entity_or_404(item['guid'], 'wire_search')
assert type(parsed['firstcreated']) == datetime
assert 2 == parsed['wordcount']
def share():
current_user = get_user(required=True)
data = get_json_or_400()
assert data.get('users')
assert data.get('items')
items = [get_entity_or_404(_id, 'items') for _id in data.get('items')]
with app.mail.connect() as connection:
for user_id in data['users']:
user = superdesk.get_resource_service('users').find_one(
req=None, _id=user_id)
if not user or not user.get('email'):
continue
template_kwargs = {
'recipient': user,
'sender': current_user,
'items': items,
'message': data.get('message'),
}
send_email(
[user['email']],
gettext('From %s: %s' %
(app.config['SITE_NAME'], items[0]['headline'])),
flask.render_template('share_item.txt', **template_kwargs),
sender=current_user['email'],
connection=connection)
update_action_list(data.get('items'), 'shares')
return flask.jsonify(), 201
def test_push_parsed_planning_for_an_existing_event(client, app):
event = deepcopy(test_event)
event['guid'] = 'foo4'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
parsed = get_entity_or_404(event['guid'], 'agenda')
assert type(parsed['firstcreated']) == datetime
assert 1 == len(parsed['event']['event_contact_info'])
assert 1 == len(parsed['location'])
planning = deepcopy(test_planning)
planning['guid'] = 'bar1'
planning['event_item'] = 'foo4'
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo4', 'agenda')
assert parsed['name'] == test_event['name']
assert parsed['definition_short'] == test_event['definition_short']
assert parsed['slugline'] == test_event['slugline']
assert parsed['definition_long'] == test_event['definition_long']
assert parsed['dates']['start'].isoformat(
) == test_event['dates']['start'].replace('0000', '00:00')
assert parsed['dates']['end'].isoformat(
) == test_event['dates']['end'].replace('0000', '00:00')
assert parsed['ednote'] == event['ednote']
assert 2 == len(parsed['coverages'])
assert 1 == len(parsed['service'])
assert 'a' == parsed['service'][0]['code']
assert 1 == len(parsed['subject'])
assert '06002002' == parsed['subject'][0]['code']
assert parsed['coverages'][0]['slugline'] == 'Vivid Text Explainer'
assert parsed['coverages'][1]['slugline'] == 'Vivid Photos'
parsed_planning = parsed['planning_items'][0]
assert 1 == len(parsed_planning['service'])
assert 'e' == parsed_planning['service'][0]['code']
assert 1 == len(parsed_planning['subject'])
assert '01009000' == parsed_planning['subject'][0]['code']
assert parsed_planning['description_text'] == planning['description_text']
assert parsed_planning['slugline'] == planning['slugline']
assert parsed_planning['headline'] == planning['headline']
assert parsed_planning['ednote'] == planning['ednote']
assert 2 == len(parsed_planning['coverages'])
def request_coverage():
user = get_user(required=True)
data = get_json_or_400()
assert data.get('item')
assert data.get('message')
item = get_entity_or_404(data.get('item'), 'agenda')
send_coverage_request_email(user, data.get('message'), item['_id'])
return flask.jsonify(), 201
def edit(id):
get_entity_or_404(id, 'products')
data = get_json_or_400()
updates = {
'name': data.get('name'),
'description': data.get('description'),
'sd_product_id': data.get('sd_product_id'),
'query': data.get('query'),
'is_enabled': data.get('is_enabled'),
}
validation = validate_product(updates)
if validation:
return validation
get_resource_service('products').patch(id=ObjectId(id), updates=updates)
return jsonify({'success': True}), 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 test_push_parsed_dates(client, app):
payload = item.copy()
payload['embargoed'] = '2019-01-31T00:01:00+00:00'
client.post('/push',
data=json.dumps(payload),
content_type='application/json')
parsed = get_entity_or_404(item['guid'], 'items')
assert type(parsed['firstcreated']) == datetime
assert type(parsed['versioncreated']) == datetime
assert type(parsed['embargoed']) == datetime
def test_push_coverages_with_different_dates_for_an_existing_event(
client, app):
event = deepcopy(test_event)
event['guid'] = 'foo4'
client.post('/push',
data=json.dumps(event),
content_type='application/json')
parsed = get_entity_or_404(event['guid'], 'agenda')
assert type(parsed['firstcreated']) == datetime
assert 1 == len(parsed['event']['event_contact_info'])
assert 1 == len(parsed['location'])
planning = deepcopy(test_planning)
planning['guid'] = 'bar1'
planning['event_item'] = 'foo4'
planning['coverages'][0]['planning'][
'scheduled'] = "2018-06-28T10:51:52+0000"
planning['coverages'][1]['planning'][
'scheduled'] = "2018-06-28T13:51:52+0000"
# planning['planning_date'] = "2018-05-28T10:51:52+0000"
client.post('/push',
data=json.dumps(planning),
content_type='application/json')
parsed = get_entity_or_404('foo4', 'agenda')
assert parsed['name'] == test_event['name']
assert parsed['definition_short'] == test_event['definition_short']
assert parsed['slugline'] == test_event['slugline']
parsed_planning = parsed['planning_items'][0]
assert parsed_planning['description_text'] == planning['description_text']
assert 2 == len(parsed['coverages'])
assert parsed['dates']['start'].isoformat(
) == event['dates']['start'].replace('0000', '00:00')
assert parsed['dates']['end'].isoformat() == event['dates']['end'].replace(
'0000', '00:00')
assert 2 == len(parsed['display_dates'])
assert parsed['display_dates'][0]['date'].isoformat() == \
planning['coverages'][0]['planning']['scheduled'].replace('0000', '00:00')
assert parsed['display_dates'][1]['date'].isoformat() == \
planning['coverages'][1]['planning']['scheduled'].replace('0000', '00:00')
def get_media_card_external(card_id):
cache_id = '{}_{}'.format(HOME_EXTERNAL_ITEMS_CACHE_KEY, card_id)
if app.cache.get(cache_id):
card_items = app.cache.get(cache_id)
else:
card = get_entity_or_404(card_id, 'cards')
card_items = app.get_media_cards_external(card)
app.cache.set(cache_id, card_items, timeout=300)
return flask.jsonify({'_items': card_items})
def edit(id):
get_entity_or_404(ObjectId(id), 'products')
data = get_json_or_400()
updates = {
'name': data.get('name'),
'description': data.get('description'),
'sd_product_id': data.get('sd_product_id'),
'query': data.get('query'),
'planning_item_query': data.get('planning_item_query'),
'is_enabled': data.get('is_enabled'),
'product_type': data.get('product_type', 'wire')
}
validation = validate_product(updates)
if validation:
return validation
set_version_creator(updates)
get_resource_service('products').patch(id=ObjectId(id), updates=updates)
return jsonify({'success': True}), 200
def test_push_event_from_planning(client, app):
plan = deepcopy(test_planning)
plan['guid'] = 'adhoc_plan'
plan['planning_date'] = '2018-05-29T00:00:00+0000'
plan.pop('event_item', None)
post_json(client, '/push', plan)
parsed = get_entity_or_404(plan['guid'], 'agenda')
assert parsed['slugline'] == test_planning['slugline']
assert parsed['headline'] == test_planning['headline']
assert parsed['definition_short'] == test_planning['description_text']
assert 1 == len(parsed['service'])
assert 'e' == parsed['service'][0]['code']
assert 1 == len(parsed['subject'])
assert '01009000' == parsed['subject'][0]['code']
assert parsed.get('event_id') is None
assert parsed['guid'] == plan['guid']
assert parsed['dates']['start'].isoformat(
) == plan['planning_date'].replace('0000', '00:00')
assert parsed['dates']['end'].isoformat() == plan['planning_date'].replace(
'0000', '00:00')
event = deepcopy(test_event)
event['guid'] = 'retrospective_event'
event['plans'] = ['adhoc_plan']
post_json(client, '/push', event)
parsed = get_entity_or_404(plan['guid'], 'agenda')
assert parsed['slugline'] == test_event['slugline']
assert parsed['definition_short'] == test_event['definition_short']
assert parsed['guid'] == event['guid']
assert 1 == len(parsed['service'])
assert 'a' == parsed['service'][0]['code']
assert 1 == len(parsed['subject'])
assert '06002002' == parsed['subject'][0]['code']
assert parsed['dates']['start'].isoformat(
) == event['dates']['start'].replace('0000', '00:00')
assert parsed['dates']['end'].isoformat() == event['dates']['end'].replace(
'0000', '00:00')
