def test_queue_transmission_wrong_article_type_fails(self):
self._is_publish_queue_empty()
doc = copy(self.articles[0])
doc['item_id'] = doc['_id']
doc[ITEM_TYPE] = CONTENT_TYPE.PICTURE
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.DIGITAL)
no_formatters, queued = get_enqueue_service(
'publish').queue_transmission(doc, subscribers, subscriber_codes)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(1, queue_items.count())
self.assertEqual(0, len(no_formatters))
self.assertTrue(queued)
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.WIRE)
no_formatters, queued = get_enqueue_service(
'publish').queue_transmission(doc, subscribers)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(2, queue_items.count())
self.assertEqual(0, len(no_formatters))
self.assertTrue(queued)
def resend_association_items(self, doc):
"""This method is used to resend assciation items.
:param dict doc: document
"""
associated_items = doc.get(ASSOCIATIONS)
if associated_items:
for association in self.get_unique_associations(associated_items):
# resend only media association
if association.get(
"type") not in MEDIA_TYPES or association.get(
"is_queued"):
continue
archive_article = get_resource_service("archive").find_one(
req=None, _id=association.get("_id"))
if not archive_article:
continue
associated_article = get_resource_service(
"published").find_one(
req=None,
item_id=archive_article["_id"],
_current_version=archive_article["_current_version"])
if associated_article and associated_article.get(
"state") not in ["unpublished", "killed"]:
from apps.publish.enqueue import get_enqueue_service
get_enqueue_service(associated_article.get(
"operation")).publish(associated_article)
def test_conform_target_subscribers(self):
doc = {'headline': 'test'}
subscriber = {'_id': 1}
self.assertTupleEqual(
(True, False),
get_enqueue_service('publish').conforms_subscriber_targets(
subscriber, doc))
doc = {'headline': 'test', 'target_subscribers': []}
self.assertTupleEqual(
(True, False),
get_enqueue_service('publish').conforms_subscriber_targets(
subscriber, doc))
doc = {'headline': 'test', 'target_subscribers': [{'_id': 2}]}
self.assertTupleEqual(
(False, False),
get_enqueue_service('publish').conforms_subscriber_targets(
subscriber, doc))
doc = {'headline': 'test', 'target_subscribers': [{'_id': 1}]}
self.assertTupleEqual(
(True, True),
get_enqueue_service('publish').conforms_subscriber_targets(
subscriber, doc))
doc = {
'headline': 'test',
'target_subscribers': [{
'_id': 2
}],
'target_regions': [{
'name': 'Victoria'
}]
}
self.assertTupleEqual(
(True, False),
get_enqueue_service('publish').conforms_subscriber_targets(
subscriber, doc))
def create(self, docs, **kwargs):
doc = docs[0] if len(docs) > 0 else {}
article_id = request.view_args['original_id']
article_version = doc.get('version')
article = self._validate_article(article_id, article_version)
subscribers = self._validate_subscribers(doc.get('subscribers'), article)
get_enqueue_service(article.get(ITEM_OPERATION)).resend(article, subscribers)
app.on_archive_item_updated({'subscribers': doc.get('subscribers')}, article, ITEM_RESEND)
return [article_id]
def create(self, docs, **kwargs):
doc = docs[0] if len(docs) > 0 else {}
article_id = request.view_args["original_id"]
article_version = doc.get("version")
article = self._validate_article(article_id, article_version)
subscribers = self._validate_subscribers(doc.get("subscribers"), article)
get_enqueue_service(article.get(ITEM_OPERATION)).resend(article, subscribers)
app.on_archive_item_updated({"subscribers": doc.get("subscribers")}, article, ITEM_RESEND)
return [article_id]
def publish_event(self, event):
event.setdefault(config.VERSION, 1)
event.setdefault('item_id', event['_id'])
get_enqueue_service('publish').enqueue_item(event, 'event')
updates = {
'state': self._get_publish_state(event),
'pubstatus': event['pubstatus']
}
get_resource_service('events').update(event['_id'], updates, event)
get_resource_service('events_history')._save_history(
event, updates, 'publish')
def enqueue_planning_item(id):
"""
Get the version of the item to be published from the planning versions collection and enqueue it.
:param id:
:return:
"""
planning_version = get_resource_service('published_planning').find_one(req=None, _id=id)
if planning_version:
try:
get_enqueue_service('publish').enqueue_item(planning_version.get('published_item'), 'event')
except Exception:
logger.exception('Failed to queue {} item {}'.format(planning_version.get('type'), id))
else:
logger.error('Failed to retrieve planning item from planning versions with id: {}'.format(id))
def test_get_changed_items_no_item_found(self):
# dummy publishing so that elastic mappings are created.
doc = self.articles[3].copy()
get_resource_service(ARCHIVE_PUBLISH).patch(id=doc['_id'], updates={ITEM_STATE: CONTENT_STATE.PUBLISHED})
removed_items, added_items = get_enqueue_service('publish')._get_changed_items({}, {'item_id': 'test'})
self.assertEqual(len(removed_items), 0)
self.assertEqual(len(added_items), 0)
def test_products(self, article, lookup=None):
req = ParsedRequest()
results = []
products = list(get_resource_service('products').get(req=req, lookup=lookup))
service = get_enqueue_service(article.get(ITEM_OPERATION, 'publish'))
for product in products:
result = {'product_id': product['_id'], 'matched': True, 'name': product.get('name', '')}
reason = ''
if not service.conforms_product_targets(product, article):
# Here it fails to match due to geo restriction
# story has target_region and product has geo restriction
result['matched'] = False
if BasePublishService().is_targeted(article, 'target_regions'):
reason = 'Story has target_region'
if product.get('geo_restrictions'):
reason = '{} {}'.format(reason, 'Product has target_region')
if not service.conforms_content_filter(product, article):
# Here it fails to match due to content filter
content_filter = product.get('content_filter')
filter = service.filters.get('content_filters', {}).get(content_filter['filter_id'], {}).get('cf')
result['matched'] = False
reason = 'Story does not match the filter: {}'.format(filter.get('name'))
result['reason'] = reason
results.append(result)
return results
def _format_associations(self, content, item):
"""When association is already published we need to resend it again
with link to text item.
"""
photos = []
for assoc in item['associations'].values():
if assoc:
published = superdesk.get_resource_service(
'published').get_last_published_version(assoc['_id'])
if published and published[
'pubstatus'] == 'usable' and False: # disable for the time being
published.setdefault('extra',
{})['container'] = item['guid']
publish_service = get_enqueue_service('publish')
subscribers = [
subs for subs in publish_service.get_subscribers(
published, None)[0] if any([
dest['format'] == 'jimi'
for dest in subs.get('destinations', [])
])
]
publish_service.resend(published, subscribers)
if assoc.get('type') == 'picture':
photos.append(assoc)
etree.SubElement(content, 'PhotoType').text = get_count_label(
len(photos), item['language'])
if photos:
etree.SubElement(content, 'PhotoReference').text = ','.join(
filter(None, [guid(photo.get('guid')) for photo in photos]))
def test_conform_target_subscribers(self):
doc = {'headline': 'test'}
subscriber = {'_id': 1}
self.assertTupleEqual((True, False),
get_enqueue_service('publish').conforms_subscriber_targets(subscriber, doc))
doc = {'headline': 'test', 'target_subscribers': []}
self.assertTupleEqual((True, False),
get_enqueue_service('publish').conforms_subscriber_targets(subscriber, doc))
doc = {'headline': 'test', 'target_subscribers': [{'_id': 2}]}
self.assertTupleEqual((False, False),
get_enqueue_service('publish').conforms_subscriber_targets(subscriber, doc))
doc = {'headline': 'test', 'target_subscribers': [{'_id': 1}]}
self.assertTupleEqual((True, True),
get_enqueue_service('publish').conforms_subscriber_targets(subscriber, doc))
doc = {'headline': 'test', 'target_subscribers': [{'_id': 2}], 'target_regions': [{'name': 'Victoria'}]}
self.assertTupleEqual((True, False),
get_enqueue_service('publish').conforms_subscriber_targets(subscriber, doc))
def test_get_changed_items_no_item_found(self):
# dummy publishing so that elastic mappings are created.
doc = self.articles[3].copy()
get_resource_service(ARCHIVE_PUBLISH).patch(
id=doc['_id'], updates={ITEM_STATE: CONTENT_STATE.PUBLISHED})
removed_items, added_items = get_enqueue_service(
'publish')._get_changed_items({}, {'item_id': 'test'})
self.assertEqual(len(removed_items), 0)
self.assertEqual(len(added_items), 0)
def test_reload_filters_if_updated(self):
self.app.data.insert('vocabularies', [
{
'_id': 'categories',
'items': []
},
{
'_id': 'urgency',
'items': []
},
{
'_id': 'priority',
'items': []
},
{
'_id': 'type',
'items': []
},
{
'_id': 'genre',
'items': []
},
{
'_id': 'place',
'items': []
},
])
product = self.products[0]
product['content_filter'] = {'filter_id': 1, 'filter_type': 'blocking'}
self.app.data.insert('filter_conditions',
[{
'_id': '1',
'field': 'headline',
'operator': 'like',
'value': 'tor',
'name': 'test-1',
'_updated': utcnow() - timedelta(days=10)
}])
get_enqueue_service('publish')
get_resource_service('filter_conditions').patch(
'1', updates={'name': 'test-1 updated'})
service2 = get_enqueue_service('publish')
self.assertGreater(service2.filters['latest_filter_conditions'],
utcnow() - timedelta(seconds=10))
def test_can_publish_article(self):
product = self.products[0]
self._add_content_filters(product, is_global=False)
service = get_enqueue_service('publish')
can_it = service.conforms_content_filter(product, self.articles[4])
self.assertFalse(can_it)
product['content_filter']['filter_type'] = 'permitting'
can_it = service.conforms_content_filter(product, self.articles[4])
self.assertTrue(can_it)
product.pop('content_filter')
def test_can_publish_article(self):
product = self.products[0]
self._add_content_filters(product, is_global=False)
service = get_enqueue_service('publish')
can_it = service.conforms_content_filter(product, self.articles[4])
self.assertFalse(can_it)
product['content_filter']['filter_type'] = 'permitting'
can_it = service.conforms_content_filter(product, self.articles[4])
self.assertTrue(can_it)
product.pop('content_filter')
def test_reload_filters_if_updated(self):
self.app.data.insert('vocabularies',
[{'_id': 'categories', 'items': []},
{'_id': 'urgency', 'items': []},
{'_id': 'priority', 'items': []},
{'_id': 'type', 'items': []},
{'_id': 'genre', 'items': []},
{'_id': 'place', 'items': []},
])
product = self.products[0]
product['content_filter'] = {'filter_id': 1, 'filter_type': 'blocking'}
self.app.data.insert('filter_conditions',
[{'_id': '1',
'field': 'headline',
'operator': 'like',
'value': 'tor',
'name': 'test-1',
'_updated': utcnow() - timedelta(days=10)}])
get_enqueue_service('publish')
get_resource_service('filter_conditions').patch('1', updates={'name': 'test-1 updated'})
service2 = get_enqueue_service('publish')
self.assertGreater(service2.filters['latest_filter_conditions'], utcnow() - timedelta(seconds=10))
def test_queue_transmission_wrong_article_type_fails(self):
self._is_publish_queue_empty()
doc = copy(self.articles[0])
doc['item_id'] = doc['_id']
doc[ITEM_TYPE] = CONTENT_TYPE.PICTURE
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.DIGITAL)
no_formatters, queued = get_enqueue_service('publish').queue_transmission(doc, subscribers, subscriber_codes)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(1, queue_items.count())
self.assertEqual(0, len(no_formatters))
self.assertTrue(queued)
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.WIRE)
no_formatters, queued = get_enqueue_service('publish').queue_transmission(doc, subscribers)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(2, queue_items.count())
self.assertEqual(0, len(no_formatters))
self.assertTrue(queued)
def test_conform_target_regions(self):
doc = {'headline': 'test'}
product = {'geo_restrictions': 'QLD'}
self.assertFalse(
get_enqueue_service('publish').conforms_product_targets(
product, doc))
doc = {'headline': 'test', 'target_regions': []}
self.assertFalse(
get_enqueue_service('publish').conforms_product_targets(
product, doc))
doc = {
'headline': 'test',
'target_regions': [{
'qcode': 'VIC',
'name': 'Victoria',
'allow': True
}]
}
self.assertFalse(
get_enqueue_service('publish').conforms_product_targets(
product, doc))
doc = {
'headline':
'test',
'target_regions': [{
'qcode': 'VIC',
'name': 'Victoria',
'allow': False
}]
}
self.assertTrue(
get_enqueue_service('publish').conforms_product_targets(
product, doc))
doc = {
'headline':
'test',
'target_regions': [{
'qcode': 'QLD',
'name': 'Queensland',
'allow': True
}]
}
self.assertTrue(
get_enqueue_service('publish').conforms_product_targets(
product, doc))
doc = {
'headline':
'test',
'target_regions': [{
'qcode': 'QLD',
'name': 'Queensland',
'allow': False
}]
}
self.assertFalse(
get_enqueue_service('publish').conforms_product_targets(
product, doc))
def test_queue_transmission_for_digital_channels(self):
self._is_publish_queue_empty()
doc = copy(self.articles[1])
doc['item_id'] = doc['_id']
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.DIGITAL)
service.queue_transmission(doc, subscribers, subscriber_codes)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(1, queue_items.count())
expected_subscribers = ['5']
for item in queue_items:
self.assertIn(item["subscriber_id"], expected_subscribers, 'item {}'.format(item))
def test_queue_transmission_for_digital_channels(self):
self._is_publish_queue_empty()
doc = copy(self.articles[1])
doc['item_id'] = doc['_id']
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.DIGITAL)
service.queue_transmission(doc, subscribers, subscriber_codes)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(1, queue_items.count())
expected_subscribers = ['5']
for item in queue_items:
self.assertIn(item["subscriber_id"], expected_subscribers,
'item {}'.format(item))
def test_get_subscribers_without_product(self):
doc = copy(self.articles[1])
doc['item_id'] = doc['_id']
subscriber_service = get_resource_service('subscribers')
for sub in self.subscribers:
sub.pop('products', None)
subscriber_service.delete({'_id': sub['_id']})
subscriber_service.post(self.subscribers)
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.WIRE)
self.assertEqual(0, len(subscribers))
self.assertDictEqual({}, subscriber_codes)
def test_get_subscribers_without_product(self):
doc = copy(self.articles[1])
doc['item_id'] = doc['_id']
subscriber_service = get_resource_service('subscribers')
for sub in self.subscribers:
sub.pop('products', None)
subscriber_service.delete({'_id': sub['_id']})
subscriber_service.post(self.subscribers)
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.WIRE)
self.assertEqual(0, len(subscribers))
self.assertDictEqual({}, subscriber_codes)
def test_can_publish_article_with_global_filters(self):
subscriber = self.subscribers[0]
product = self.products[0]
self._add_content_filters(product, is_global=True)
service = get_resource_service('content_filters')
req = ParsedRequest()
req.args = {'is_global': True}
global_filters = list(service.get(req=req, lookup=None))
enqueue_service = get_enqueue_service('publish')
enqueue_service.conforms_global_filter(global_filters, self.articles[4])
can_it = enqueue_service.conforms_subscriber_global_filter(subscriber, global_filters)
self.assertFalse(can_it)
subscriber['global_filters'] = {'1': False}
can_it = enqueue_service.conforms_subscriber_global_filter(subscriber, global_filters)
self.assertTrue(can_it)
product.pop('content_filter')
def test_conform_target_regions(self):
doc = {'headline': 'test'}
product = {'geo_restrictions': 'QLD'}
self.assertFalse(get_enqueue_service('publish').conforms_product_targets(product, doc))
doc = {'headline': 'test', 'target_regions': []}
self.assertFalse(get_enqueue_service('publish').conforms_product_targets(product, doc))
doc = {'headline': 'test', 'target_regions': [{'qcode': 'VIC', 'name': 'Victoria', 'allow': True}]}
self.assertFalse(get_enqueue_service('publish').conforms_product_targets(product, doc))
doc = {'headline': 'test', 'target_regions': [{'qcode': 'VIC', 'name': 'Victoria', 'allow': False}]}
self.assertTrue(get_enqueue_service('publish').conforms_product_targets(product, doc))
doc = {'headline': 'test', 'target_regions': [{'qcode': 'QLD', 'name': 'Queensland', 'allow': True}]}
self.assertTrue(get_enqueue_service('publish').conforms_product_targets(product, doc))
doc = {'headline': 'test', 'target_regions': [{'qcode': 'QLD', 'name': 'Queensland', 'allow': False}]}
self.assertFalse(get_enqueue_service('publish').conforms_product_targets(product, doc))
def _format_associations(self, content, item):
"""When association is already published we need to resend it again
with link to text item.
"""
guids = set()
photos = []
for assoc in item["associations"].values():
if assoc:
published = superdesk.get_resource_service(
"published"
).get_last_published_version(assoc["_id"])
if (
published and published["pubstatus"] == "usable" and False
): # disable for the time being
published.setdefault("extra", {})["container"] = item["guid"]
publish_service = get_enqueue_service("publish")
subscribers = [
subs
for subs in publish_service.get_subscribers(published, None)[0]
if any(
[
dest["format"] == "jimi"
for dest in subs.get(cp.DESTINATIONS, [])
]
)
]
publish_service.resend(published, subscribers)
if (
assoc.get("type") == "picture"
and assoc.get("guid")
and assoc["guid"] not in guids
):
guids.add(assoc["guid"])
photos.append(assoc)
etree.SubElement(content, "PhotoType").text = get_count_label(
len(photos), item["language"]
)
if photos:
etree.SubElement(content, "PhotoReference").text = ",".join(
filter(None, [media_ref(photo) for photo in photos])
)
def test_queue_transmission_for_wire_channels_with_codes(self):
self._is_publish_queue_empty()
doc = copy(self.articles[1])
doc['item_id'] = doc['_id']
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.WIRE)
service.queue_transmission(doc, subscribers, subscriber_codes)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(1, queue_items.count())
expected_subscribers = ['5']
for item in queue_items:
self.assertIn(item['subscriber_id'], expected_subscribers, 'item {}'.format(item))
if item['subscriber_id'] == '5':
self.assertEqual(4, len(item['codes']))
self.assertIn('def', item['codes'])
self.assertIn('abc', item['codes'])
self.assertIn('xyz', item['codes'])
self.assertIn('klm', item['codes'])
def test_can_publish_article_with_global_filters(self):
subscriber = self.subscribers[0]
product = self.products[0]
self._add_content_filters(product, is_global=True)
service = get_resource_service('content_filters')
req = ParsedRequest()
req.args = {'is_global': True}
global_filters = list(service.get(req=req, lookup=None))
enqueue_service = get_enqueue_service('publish')
enqueue_service.conforms_global_filter(global_filters,
self.articles[4])
can_it = enqueue_service.conforms_subscriber_global_filter(
subscriber, global_filters)
self.assertFalse(can_it)
subscriber['global_filters'] = {'1': False}
can_it = enqueue_service.conforms_subscriber_global_filter(
subscriber, global_filters)
self.assertTrue(can_it)
product.pop('content_filter')
def test_queue_transmission_for_wire_channels_with_codes(self):
self._is_publish_queue_empty()
doc = copy(self.articles[1])
doc['item_id'] = doc['_id']
service = get_enqueue_service(doc[ITEM_OPERATION])
subscribers, subscriber_codes, associations = \
service.get_subscribers(doc, SUBSCRIBER_TYPES.WIRE)
service.queue_transmission(doc, subscribers, subscriber_codes)
queue_items = self.app.data.find(PUBLISH_QUEUE, None, None)
self.assertEqual(1, queue_items.count())
expected_subscribers = ['5']
for item in queue_items:
self.assertIn(item['subscriber_id'], expected_subscribers,
'item {}'.format(item))
if item['subscriber_id'] == '5':
self.assertEqual(4, len(item['codes']))
self.assertIn('def', item['codes'])
self.assertIn('abc', item['codes'])
self.assertIn('xyz', item['codes'])
self.assertIn('klm', item['codes'])
def test_products(self, article, lookup=None):
req = ParsedRequest()
results = []
products = list(
get_resource_service("products").get(req=req, lookup=lookup))
service = get_enqueue_service(article.get(ITEM_OPERATION, "publish"))
for product in products:
result = {
"product_id": product["_id"],
"matched": True,
"name": product.get("name", "")
}
reason = ""
if not service.conforms_product_targets(product, article):
# Here it fails to match due to geo restriction
# story has target_region and product has geo restriction
result["matched"] = False
if BasePublishService().is_targeted(article, "target_regions"):
reason = "Story has target_region"
if product.get("geo_restrictions"):
reason = "{} {}".format(reason,
"Product has target_region")
if not service.conforms_content_filter(product, article):
# Here it fails to match due to content filter
content_filter = product.get("content_filter")
filter = service.filters.get("content_filters", {}).get(
content_filter["filter_id"], {}).get("cf")
result["matched"] = False
reason = "Story does not match the filter: {}".format(
filter.get("name"))
result["reason"] = reason
results.append(result)
return results
def update(self, id, updates, original):
"""Runs on update of archive item.
Overriding to handle with Kill/Takedown workflow in the Archived repo:
1. Check if Article has an associated Digital Story and if Digital Story has more Takes.
If both Digital Story and more Takes exists then all of them would be killed along with the one requested
2. If the item is flagged as archived only then it was never created by or published from the system so all
that needs to be done is to delete it and send an email to all subscribers
3. For each article being killed do the following:
i. Create an entry in archive, archive_versions and published collections.
ii. Query the Publish Queue in Legal Archive and find the subscribers who received the article
previously and create transmission entries in Publish Queue.
iii. Change the state of the article to Killed in Legal Archive.
iv. Delete all the published versions from Archived.
v. Send a broadcast email to all subscribers.
:param id: primary key of the item to be killed
:type id: str
:param updates: updates to be applied on the article before saving
:type updates: dict
:param original:
:type original: dict
"""
# Step 1
articles_to_kill = self.find_articles_to_kill({"_id": id})
logger.info("Fetched articles to kill for id: {}".format(id))
articles_to_kill.sort(
key=itemgetter(ITEM_TYPE),
reverse=True) # Needed because package has to be inserted last
kill_service = KillPublishService() if updates.get(
ITEM_OPERATION) == ITEM_KILL else TakeDownPublishService()
updated = original.copy()
for article in articles_to_kill:
updates_copy = deepcopy(updates)
kill_service.apply_kill_override(article, updates_copy)
updated.update(updates_copy)
# Step 2, If it is flagged as archived only it has no related items in the system so can be deleted.
# An email is sent to all subscribers
if original.get("flags", {}).get("marked_archived_only", False):
super().delete({"item_id": article["item_id"]})
logger.info("Delete for article: {}".format(
article[config.ID_FIELD]))
kill_service.broadcast_kill_email(article, updates_copy)
logger.info("Broadcast kill email for article: {}".format(
article[config.ID_FIELD]))
continue
# Step 3(i)
self._remove_and_set_kill_properties(article, articles_to_kill,
updated)
logger.info(
"Removing and setting properties for article: {}".format(
article[config.ID_FIELD]))
# Step 3(ii)
transmission_details = list(
get_resource_service(LEGAL_PUBLISH_QUEUE_NAME).get(
req=None, lookup={"item_id": article["item_id"]}))
if transmission_details:
get_enqueue_service(updates.get(
ITEM_OPERATION, ITEM_KILL)).enqueue_archived_kill_item(
article, transmission_details)
article[config.ID_FIELD] = article.pop("item_id",
article["item_id"])
# Step 3(iv)
super().delete({"item_id": article[config.ID_FIELD]})
logger.info("Delete for article: {}".format(
article[config.ID_FIELD]))
# Step 3(i) - Creating entries in published collection
docs = [article]
get_resource_service(ARCHIVE).post(docs)
insert_into_versions(doc=article)
published_doc = deepcopy(article)
published_doc[QUEUE_STATE] = PUBLISH_STATE.QUEUED
get_resource_service("published").post([published_doc])
logger.info(
"Insert into archive and published for article: {}".format(
article[config.ID_FIELD]))
# Step 3(iii)
import_into_legal_archive.apply_async(
countdown=3, kwargs={"item_id": article[config.ID_FIELD]})
logger.info("Legal Archive import for article: {}".format(
article[config.ID_FIELD]))
# Step 3(v)
kill_service.broadcast_kill_email(article, updates_copy)
logger.info("Broadcast kill email for article: {}".format(
article[config.ID_FIELD]))
def update(self, id, updates, original):
"""Runs on update of archive item.
Overriding to handle with Kill workflow in the Archived repo:
1. Check if Article has an associated Digital Story and if Digital Story has more Takes.
If both Digital Story and more Takes exists then all of them would be killed along with the one requested
2. If the item is flagged as archived only then it was never created by or published from the system so all
that needs to be done is to delete it and send an email to all subscribers
3. For each article being killed do the following:
i. Create an entry in archive, archive_versions and published collections.
ii. Query the Publish Queue in Legal Archive and find the subscribers who received the article
previously and create transmission entries in Publish Queue.
iii. Change the state of the article to Killed in Legal Archive.
iv. Delete all the published versions from Archived.
v. Send a broadcast email to all subscribers.
:param id: primary key of the item to be killed
:type id: str
:param updates: updates to be applied on the article before saving
:type updates: dict
:param original:
:type original: dict
"""
# Step 1
articles_to_kill = self.find_articles_to_kill({'_id': id})
logger.info('Fetched articles to kill for id: {}'.format(id))
articles_to_kill.sort(key=itemgetter(ITEM_TYPE), reverse=True) # Needed because package has to be inserted last
kill_service = KillPublishService()
updated = original.copy()
for article in articles_to_kill:
updates_copy = deepcopy(updates)
kill_service.apply_kill_override(article, updates_copy)
updated.update(updates_copy)
# Step 2, If it is flagged as archived only it has no related items in the system so can be deleted.
# An email is sent to all subscribers
if original.get('flags', {}).get('marked_archived_only', False):
super().delete({'item_id': article['item_id']})
logger.info('Delete for article: {}'.format(article[config.ID_FIELD]))
kill_service.broadcast_kill_email(article, updates_copy)
logger.info('Broadcast kill email for article: {}'.format(article[config.ID_FIELD]))
continue
# Step 3(i)
self._remove_and_set_kill_properties(article, articles_to_kill, updated)
logger.info('Removing and setting properties for article: {}'.format(article[config.ID_FIELD]))
# Step 3(ii)
transmission_details = list(
get_resource_service(LEGAL_PUBLISH_QUEUE_NAME).get(req=None,
lookup={'item_id': article['item_id']}))
if transmission_details:
get_enqueue_service(ITEM_KILL).enqueue_archived_kill_item(article, transmission_details)
article[config.ID_FIELD] = article.pop('item_id', article['item_id'])
# Step 3(iv)
super().delete({'item_id': article[config.ID_FIELD]})
logger.info('Delete for article: {}'.format(article[config.ID_FIELD]))
# Step 3(i) - Creating entries in published collection
docs = [article]
get_resource_service(ARCHIVE).post(docs)
insert_into_versions(doc=article)
published_doc = deepcopy(article)
published_doc[QUEUE_STATE] = PUBLISH_STATE.QUEUED
get_resource_service('published').post([published_doc])
logger.info('Insert into archive and published for article: {}'.format(article[config.ID_FIELD]))
# Step 3(iii)
import_into_legal_archive.apply_async(countdown=3, kwargs={'item_id': article[config.ID_FIELD]})
logger.info('Legal Archive import for article: {}'.format(article[config.ID_FIELD]))
# Step 3(v)
kill_service.broadcast_kill_email(article, updates)
logger.info('Broadcast kill email for article: {}'.format(article[config.ID_FIELD]))
