def test_update_office_by_removing_contact(self): """ Test `update_offices` to update an office: remove email, phone and website. """ office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, new_email= "*****@*****.**", # Should be overriden by remove_email. new_website= "https://foo.pole-emploi.fr", # Should be overriden by remove_website. remove_email=True, remove_phone=True, remove_website=True, new_company_name="", new_office_name="", ) office_to_update.save() script.update_offices(OfficeAdminUpdate) office = Office.get(self.office1.siret) self.assertEqual(office.email, '') self.assertEqual(office.tel, '') self.assertEqual(office.website, '') # Names should still be the same. self.assertEqual(office.company_name, self.office1.company_name) self.assertEqual(office.office_name, self.office1.office_name) res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=office.siret) self.assertEqual(res['_source']['email'], '') self.assertEqual(res['_source']['phone'], '') self.assertEqual(res['_source']['website'], '')
def test_update_office_boost_specific_romes(self): """ Test `update_offices` to update an office: boost score for specific ROME codes. """ romes_for_office = [ rome.code for rome in mapping_util.romes_for_naf(self.office1.naf) ] # Ensure the following ROME codes are related to the office. self.assertIn("D1507", romes_for_office) self.assertIn("D1103", romes_for_office) office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, boost=True, romes_to_boost="D1507\nD1103", # Boost score only for those ROME. ) office_to_update.save() script.update_offices(OfficeAdminUpdate) office = Office.get(self.office1.siret) res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=office.siret) # Check boosted scores. self.assertEqual({ 'D1507': True, 'D1103': True, }, res['_source']['boosted_romes'])
def test_remove_contacts_multi_siret(self): sirets = [self.office1.siret, self.office2.siret] office_to_update = OfficeAdminUpdate( sirets='\n'.join(sirets), name="Supermarché", remove_email=True, remove_phone=True, remove_website=True, ) office_to_update.save() script.update_offices(OfficeAdminUpdate) for siret in sirets: office = Office.get(siret) self.assertEqual(office.email, '') self.assertEqual(office.tel, '') self.assertEqual(office.website, '') res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret) self.assertEqual(res['_source']['email'], '') self.assertEqual(res['_source']['phone'], '') self.assertEqual(res['_source']['website'], '')
def test_update_office_add_naf(self): romes_for_office = [ rome.code for rome in mapping_util.romes_for_naf(self.office1.naf) ] romes_for_office += [ rome.code for rome in mapping_util.romes_for_naf("4772A") ] office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, nafs_to_add="4772A", ) office_to_update.save() # Use a mock to temporarily adjust scoring_util.SCORE_FOR_ROME_MINIMUM # and avoid removing romes if their score is too low. with mock.patch.object(script.scoring_util, 'SCORE_FOR_ROME_MINIMUM', 0): script.update_offices() res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=self.office1.siret) self.assertEqual(len(set(romes_for_office)), len(res['_source']['scores_by_rome']))
def test_update_office_by_removing_contact(self): """ Test `update_offices` to update an office: remove email, phone and website. """ office_to_update = OfficeAdminUpdate( siret=self.office.siret, name=self.office.company_name, new_email= u"*****@*****.**", # Should be overriden by remove_email. new_website= u"https://foo.pole-emploi.fr", # Should be overriden by remove_website. remove_email=True, remove_phone=True, remove_website=True, ) office_to_update.save() script.update_offices(index=self.ES_TEST_INDEX) time.sleep(1) # Sleep required by ES to register new documents. office = Office.get(self.office.siret) self.assertEquals(office.email, u'') self.assertEquals(office.tel, u'') self.assertEquals(office.website, u'') res = self.es.get(index=self.ES_TEST_INDEX, doc_type=self.ES_OFFICE_TYPE, id=office.siret) self.assertEquals(res['_source']['email'], u'') self.assertEquals(res['_source']['phone'], u'') self.assertEquals(res['_source']['website'], u'') self.assertEquals(res['_source']['score'], self.office.score)
def test_new_contact_multi_siret(self): sirets = [self.office1.siret, self.office2.siret] office_to_update = OfficeAdminUpdate( sirets='\n'.join(sirets), name="Supermarchés", new_email="*****@*****.**", new_phone="0240656459", new_website="https://foo.pole-emploi.fr", remove_email=False, remove_phone=False, remove_website=False, ) office_to_update.save() script.update_offices(OfficeAdminUpdate) for siret in sirets: office = Office.get(siret) self.assertEqual(office.email, office_to_update.new_email) self.assertEqual(office.tel, office_to_update.new_phone) self.assertEqual(office.website, office_to_update.new_website) res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret) self.assertEqual(res['_source']['email'], office_to_update.new_email) self.assertEqual(res['_source']['phone'], office_to_update.new_phone) self.assertEqual(res['_source']['website'], office_to_update.new_website)
def test_romes_to_boost_multi_siret(self): sirets = [self.office1.siret, self.office2.siret] romes_for_office = [ rome.code for rome in mapping_util.romes_for_naf(self.office1.naf) ] # Ensure the following ROME codes are related to the office. self.assertIn("D1507", romes_for_office) self.assertIn("D1103", romes_for_office) office_to_update = OfficeAdminUpdate( sirets='\n'.join(sirets), name="Supermarchés", boost=True, romes_to_boost="D1507\nD1103", # Boost score only for those ROME. ) office_to_update.save() script.update_offices(OfficeAdminUpdate) for siret in sirets: res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret) # Check boosted scores. self.assertTrue(res['_source']['boosted_romes']['D1507']) self.assertTrue(res['_source']['boosted_romes']['D1103'])
def test_update_office_by_updating_contact(self): """ Test `update_offices` to update an office: update email and website, keep current phone. """ office_to_update = OfficeAdminUpdate( siret=self.office.siret, name=self.office.company_name, new_score=100, new_email=u"*****@*****.**", new_phone=u"", # Leave empty on purpose: it should not be modified. new_website=u"https://foo.pole-emploi.fr", remove_email=False, remove_phone=False, remove_website=False, ) office_to_update.save() script.update_offices(index=self.ES_TEST_INDEX) time.sleep(1) # Sleep required by ES to register new documents. office = Office.get(self.office.siret) self.assertEquals(office.email, office_to_update.new_email) self.assertEquals(office.score, office_to_update.new_score) self.assertEquals( office.tel, self.office.tel) # This value should not be modified. self.assertEquals(office.website, office_to_update.new_website) res = self.es.get(index=self.ES_TEST_INDEX, doc_type=self.ES_OFFICE_TYPE, id=office.siret) self.assertEquals(res['_source']['email'], office.email) self.assertEquals(res['_source']['phone'], office.tel) self.assertEquals(res['_source']['score'], office.score) self.assertEquals(res['_source']['website'], office.website)
def test_nafs_to_add_multi_siret(self): romes_for_office = [ rome.code for rome in mapping_util.romes_for_naf(self.office1.naf) ] romes_for_office += [ rome.code for rome in mapping_util.romes_for_naf("4772A") ] sirets = [self.office1.siret, self.office2.siret] office_to_update = OfficeAdminUpdate( sirets='\n'.join(sirets), name="Supermarchés", nafs_to_add="4772A", ) office_to_update.save() # Use a mock to temporarily adjust scoring_util.SCORE_FOR_ROME_MINIMUM # and avoid removing romes if their score is too low. with mock.patch.object(script.scoring_util, 'SCORE_FOR_ROME_MINIMUM', 0),\ mock.patch.object(script.scoring_util, 'MINIMUM_POSSIBLE_SCORE', 0): script.update_offices(OfficeAdminUpdate) for siret in sirets: res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret) self.assertEqual(len(set(romes_for_office)), len(res['_source']['scores_by_rome']))
def test_romes_to_remove_multi_siret(self): romes_for_office = [ rome.code for rome in mapping_util.romes_for_naf(self.office1.naf) ] sirets = [self.office1.siret, self.office2.siret] self.assertIn("D1101", romes_for_office) # Rome related to the office self.assertIn("D1507", romes_for_office) # Rome related to the office office_to_update = OfficeAdminUpdate( sirets='\n'.join(sirets), name="Supermarchés", boost=False, romes_to_boost='', romes_to_remove="D1507", # Remove score only for those ROME. ) office_to_update.save() script.update_offices(OfficeAdminUpdate) for siret in sirets: res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret) # Check romes self.assertIn('D1101', res['_source']['scores_by_rome']) self.assertNotIn('D1507', res['_source']['scores_by_rome'])
def test_update_office_boost_unrelated_romes(self): """ Test `update_offices` to update an office: boost score for specific ROME codes but with romes not associated to the office. """ romes_for_office = [rome.code for rome in mapping_util.romes_for_naf(self.office1.naf)] self.assertNotIn("D1506", romes_for_office) # Rome not related to the office self.assertIn("D1507", romes_for_office) # Rome related to the office office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, boost=True, romes_to_boost="D1506\nD1507", # Boost score only for those ROME. ) office_to_update.save() script.update_offices() office = Office.get(self.office1.siret) res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=office.siret) # Check boosted scores. self.assertTrue(res['_source']['boosted_romes']['D1506']) self.assertTrue(res['_source']['boosted_romes']['D1507']) # Other scores should not be boosted. for rome in romes_for_office: if rome != "D1507": self.assertNotIn(rome, res['_source']['boosted_romes'])
def test_update_office_boost_flag_all_romes_alternance(self): """ Test `update_offices` boosted flag is present when all romes are boosted """ office_to_update = OfficeAdminUpdate(sirets='00000000000009', name='Office 9', boost_alternance=True) office_to_update.save() script.update_offices() es.Elasticsearch().indices.flush() params = self.add_security_params({ 'commune_id': self.positions['nantes']['commune_id'], 'rome_codes': 'D1211', 'user': '******', 'contract': 'alternance' }) with self.test_request_context: rv = self.app.get(self.url_for("api.company_list", **params)) self.assertEqual(rv.status_code, 200, msg=rv.data) data_list = json.loads(rv.data.decode()) self.assertEqual(len(data_list['companies']), 2) # 00000000000009 is boosted and is the first result self.assertTrue(data_list['companies'][0]['boosted']) # 00000000000008 is not boosted and is the second result self.assertFalse(data_list['companies'][1]['boosted'])
def test_update_office_removed_romes(self): """ Test `update_offices` to update an office: remove specific ROME to an office """ romes_for_office = [ rome.code for rome in mapping_util.romes_for_naf(self.office1.naf) ] self.assertIn("D1101", romes_for_office) # Rome related to the office self.assertIn("D1507", romes_for_office) # Rome related to the office office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, boost=False, romes_to_boost='', romes_to_remove="D1507", # Remove score only for those ROME. ) office_to_update.save() script.update_offices(OfficeAdminUpdate) office = Office.get(self.office1.siret) res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=office.siret) # Check rome scores. self.assertIn('D1101', res['_source']['scores_by_rome']) self.assertNotIn('D1507', res['_source']['scores_by_rome']) # Other scores should not be boosted. for rome in romes_for_office: if rome != "D1507": self.assertNotIn(rome, res['_source']['boosted_romes'])
def test_update_office_remove_lbb_details(self): """ Test `update_offices` to hide it on lbb """ siret = '00000000000011' # Remove alternance for this company # Note : we use 00000000000011 because score>50 & score_alternance>50 office_to_update = OfficeAdminUpdate( sirets=siret, score=0, ) office_to_update.save(commit=True) script.update_offices() # Available for LBA but not for LBB params = self.add_security_params({'user': '******'}) rv = self.app.get('/api/v1/office/%s/details?%s' % (siret, urlencode(params))) self.assertEqual(rv.status_code, 404) params = self.add_security_params({ 'user': '******', 'contract': 'alternance' }) rv = self.app.get('/api/v1/office/%s/details?%s' % (siret, urlencode(params))) self.assertEqual(rv.status_code, 200)
def test_update_office_social_network(self): """ Test `update_offices` to update an office: boost alternance score for specific ROME codes. """ office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, social_network="https://www.facebook.com/poleemploi/", ) office_to_update.save() script.update_offices() office = Office.get(self.office1.siret) # Check contact mode self.assertEqual("https://www.facebook.com/poleemploi/", office.social_network)
def test_update_office_with_blank_new_name_companny_office(self): """ Test `update_offices` to update an office: update names, email and website, keep current phone. """ office = Office.get(self.office1.siret) old_company_name = office.company_name old_office_name = office.office_name office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.name, new_company_name="", new_office_name="", boost=True, new_email="*****@*****.**", new_phone="", # Leave empty on purpose: it should not be modified. new_website="https://foo.pole-emploi.fr", remove_email=False, remove_phone=False, remove_website=False, ) office_to_update.save() script.update_offices(OfficeAdminUpdate) office = Office.get(self.office1.siret) self.assertEqual(office.company_name, old_office_name) self.assertEqual(office.office_name, old_office_name) self.assertEqual(office.email, office_to_update.new_email) self.assertEqual(office.score, office.score) # This value should not be modified. self.assertEqual( office.tel, self.office1.tel) # This value should not be modified. self.assertEqual(office.website, office_to_update.new_website) res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=office.siret) self.assertEqual(res['_source']['email'], office.email) self.assertEqual(res['_source']['phone'], office.tel) self.assertEqual(res['_source']['website'], office.website) # Global score should always be the same. self.assertEqual(res['_source']['score'], office.score) # Check scores for ROME. # Since `romes_to_boost` is empty, all romes should be boosted. self.assertEqual(office_to_update.romes_to_boost, "") for rome in mapping_util.romes_for_naf(office.naf): self.assertTrue(res['_source']['boosted_romes'][rome.code])
def test_update_office_contact_mode(self): """ Test `update_offices` to update an office: boost alternance score for specific ROME codes. """ office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, contact_mode="Come with his driver license", ) office_to_update.save() script.update_offices(OfficeAdminUpdate) office = Office.get(self.office1.siret) # Check contact mode self.assertEqual("Come with his driver license", office.contact_mode)
def test_email_alternance_multi_siret(self): sirets = [self.office1.siret, self.office2.siret] office_to_update = OfficeAdminUpdate( sirets='\n'.join(sirets), name="Supermarché", email_alternance="*****@*****.**", phone_alternance="0699999999", website_alternance="http://example-alternance.com", ) office_to_update.save(commit=True) script.update_offices() for siret in sirets: office = Office.get(siret) self.assertEqual(office.email_alternance, "*****@*****.**") self.assertEqual(office.phone_alternance, "0699999999") self.assertEqual(office.website_alternance, "http://example-alternance.com")
def test_boost_multi_siret(self): sirets = [self.office1.siret, self.office2.siret] office_to_update = OfficeAdminUpdate( sirets='\n'.join(sirets), name="Supermarché", boost=True, ) office_to_update.save(commit=True) script.update_offices() for siret in sirets: office = Office.get(siret) res = self.es.get(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret) # Since `romes_to_boost` is empty, all `scores_by_rome` should be boosted. self.assertEqual(office_to_update.romes_to_boost, "") for rome in mapping_util.romes_for_naf(office.naf): self.assertTrue(res['_source']['boosted_romes'][rome.code])
def test_update_office_add_alternance_infos(self): """ Test `update_offices` to add an email for alternance """ office = Office.get(self.office1.siret) self.assertNotEqual(office.email_alternance, "*****@*****.**") office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, email_alternance="*****@*****.**", phone_alternance="0699999999", website_alternance="http://example-alternance.com", ) office_to_update.save(commit=True) script.update_offices() office = Office.get(self.office1.siret) self.assertEqual(office.email_alternance, "*****@*****.**") self.assertEqual(office.phone_alternance, "0699999999") self.assertEqual(office.website_alternance, "http://example-alternance.com")
def test_update_office_remove_on_lbb(self): """ Test `update_offices` to hide on lbb """ # Remove for this company office_to_update = OfficeAdminUpdate( sirets=self.office1.siret, name=self.office1.company_name, score=0, ) office = Office.get(self.office1.siret) self.assertNotEqual(office.score, 0) office_to_update.save(commit=True) script.update_offices(OfficeAdminUpdate) # Expected score_rome = 0 office = Office.get(self.office1.siret) self.assertEqual(office.score, 0)
def test_update_office_boost_flag_specific_romes_alternance(self): """ Test `update_offices` boosted flag is present """ office_to_update = OfficeAdminUpdate( sirets='00000000000008', name='Office 8', boost_alternance=True, romes_alternance_to_boost="D1211", # Boost score only for this ROME. ) office_to_update.save(commit=True) script.update_offices(OfficeAdminUpdate) es.Elasticsearch().indices.flush() params = self.add_security_params({ 'commune_id': self.positions['nantes']['commune_id'], 'rome_codes': 'D1211', 'user': '******', 'contract': 'alternance' }) with self.test_request_context(): rv = self.app.get(self.url_for("api.company_list", **params)) self.assertEqual(rv.status_code, 200) data_list = json.loads(rv.data.decode()) self.assertEqual(len(data_list['companies']), 2) # 00000000000008 should be boosted and be the first result self.assertEqual(data_list['companies'][0]['siret'], '00000000000008') self.assertTrue(data_list['companies'][0]['boosted']) # 00000000000009 should not be boosted and be the second result self.assertFalse(data_list['companies'][1]['boosted'])
def update_jobs_form(): """ Allow a recruiter to add or delete ROME codes related to his company. """ # Use POST params if available, GET params otherwise. form_data = request.form or request.args.copy() try: office = models.Office.query.filter(models.Office.siret == form_data['siret']).one() except NoResultFound: flash(unknown_siret_message(), 'error') return redirect(url_for('contact_form.change_info')) if request.method == 'GET': # Prepare form's initial data. romes_to_boost = office.romes_codes romes_alternance_to_boost = office.romes_codes extra_romes_to_add = set() extra_romes_alternance_to_add = set() office_update = OfficeAdminUpdate.query.filter(OfficeAdminUpdate.sirets == office.siret).first() if office_update: if office_update.romes_to_boost: romes_to_boost = set(OfficeAdminUpdate.as_list(office_update.romes_to_boost)) extra_romes_to_add = romes_to_boost - office.romes_codes if office_update.romes_alternance_to_boost: romes_alternance_to_boost = set(OfficeAdminUpdate.as_list(office_update.romes_alternance_to_boost)) extra_romes_alternance_to_add = romes_alternance_to_boost - office.romes_codes form_data['romes_to_keep'] = romes_to_boost form_data['romes_alternance_to_keep'] = romes_alternance_to_boost else: # Those form fields are defined outside of the form class, we use `request.form` to get them. extra_romes_to_add = set(request.form.getlist('extra_romes_to_add')) extra_romes_alternance_to_add = set(request.form.getlist('extra_romes_alternance_to_add')) form = forms.OfficeUpdateJobsForm(data=form_data, office=office) if form.validate_on_submit(): recruiter_message = models.UpdateJobsRecruiterMessage.create_from_form( form, is_certified_recruiter=peam_recruiter.is_certified_recruiter(), uid=peam_recruiter.get_recruiter_uid() ) mail_content = mail.generate_update_jobs_mail(form, recruiter_message) try: mail.send_mail(mail_content, get_subject()) except MailNoSendException as e: logger.exception(e) flash(generate_fail_flash_content(), 'error') params = request.args.to_dict() params.update({ 'custom_ga_pageview': '/recruteur/update_jobs/success', 'suggest_update_coordinates': '1', }) return redirect(url_for('contact_form.success', **params)) extra_added_jobs = [ { 'rome_code': rome_code, 'label': settings.ROME_DESCRIPTIONS[rome_code], 'lbb': rome_code in extra_romes_to_add, 'lba': rome_code in extra_romes_alternance_to_add, } for rome_code in extra_romes_to_add | extra_romes_alternance_to_add ] return render_template('contact_form/change_job_infos.html', title='Demande de modification des métiers', form=form, params=urlencode(get_office_identification_data()), use_lba_template=is_recruiter_from_lba(), extra_added_jobs=extra_added_jobs, custom_ga_pageview='/recruteur/update_jobs/update_jobs', )
def update_offices(): """ Update offices (overload the data provided by the importer). """ # Good engineering eliminates users being able to do the wrong thing as much as possible. # But since it is possible to store multiple SIRETs, there is no longer any constraint of uniqueness # on a SIRET. As a result, it shouldn't but there may be `n` entries in `OfficeAdminUpdate` # for the same SIRET. We order the query by creation date ASC so that the most recent changes take # priority over any older ones. for office_to_update in db_session.query(OfficeAdminUpdate).order_by( asc(OfficeAdminUpdate.date_created)).all(): for siret in OfficeAdminUpdate.as_list(office_to_update.sirets): office = Office.query.filter_by(siret=siret).first() if office: # Apply changes in DB. office.company_name = office_to_update.new_company_name or office.company_name office.office_name = office_to_update.new_office_name or office.office_name office.email = '' if office_to_update.remove_email else ( office_to_update.new_email or office.email) office.tel = '' if office_to_update.remove_phone else ( office_to_update.new_phone or office.tel) office.website = '' if office_to_update.remove_website else ( office_to_update.new_website or office.website) office.email_alternance = office_to_update.email_alternance office.phone_alternance = office_to_update.phone_alternance office.website_alternance = office_to_update.website_alternance # Note : we need to handle when score and score_alternance = 0 office.score = office_to_update.score if office_to_update.score is not None else office.score office.score_alternance = office_to_update.score_alternance if office_to_update.score_alternance is not None else office.score_alternance office.social_network = office_to_update.social_network office.contact_mode = office_to_update.contact_mode office.save() # Apply changes in ElasticSearch. body = { 'doc': { 'email': office.email, 'phone': office.tel, 'website': office.website, 'flag_alternance': 1 if office.flag_alternance else 0 } } scores_by_rome, scores_alternance_by_rome, boosted_romes, boosted_alternance_romes = get_scores_by_rome_and_boosted_romes( office, office_to_update) if scores_by_rome: body['doc']['scores_by_rome'] = scores_by_rome body['doc']['boosted_romes'] = boosted_romes if scores_alternance_by_rome: body['doc'][ 'scores_alternance_by_rome'] = scores_alternance_by_rome body['doc'][ 'boosted_alternance_romes'] = boosted_alternance_romes # The update API makes partial updates: existing `scalar` fields are overwritten, # but `objects` fields are merged together. # https://www.elastic.co/guide/en/elasticsearch/guide/1.x/partial-updates.html # However `scores_by_rome` and `boosted_romes` need to be overwritten because they # may change over time. # To do this, we perform 2 requests: the first one resets `scores_by_rome` and # `boosted_romes` and the second one populates them. delete_body = {'doc': {}} delete_body = { 'doc': { 'scores_by_rome': None, 'boosted_romes': None, 'scores_alternance_by_rome': None, 'boosted_alternance_romes': None } } # Unfortunately these cannot easily be bulked :-( # The reason is there is no way to tell bulk to ignore missing documents (404) # for a partial update. Tried it and failed it on Oct 2017 @vermeer. es.Elasticsearch().update(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret, body=delete_body, params={'ignore': 404}) es.Elasticsearch().update(index=settings.ES_INDEX, doc_type=es.OFFICE_TYPE, id=siret, body=body, params={'ignore': 404}) # Delete the current PDF thus it will be regenerated at the next download attempt. pdf_util.delete_file(office)