def test_dependent_job(self):
(job1, job2) = [Job.new_edit(self.guest, self.entry) for x in range(2)]
self.assertIsNone(job1.dependent_job)
self.assertEqual(job2.dependent_job, job1)
# When a job don't has target parameter, dependent_job is not set because
# there is no problem when these tasks are run simultaneouslly.
jobs = [Job.new_export(self.guest) for x in range(2)]
self.assertTrue(all([j.dependent_job is None for j in jobs]))
# overwrite timeout timeout value for testing
settings.AIRONE['JOB_TIMEOUT'] = -1
# Because jobs[1] is created after the expiry of jobs[0]
jobs = [Job.new_edit(self.guest, self.entry) for x in range(2)]
self.assertTrue(all([j.dependent_job is None for j in jobs]))
def do_edit(request, entry_id, recv_data):
entry, error = get_obj_with_check_perm(request.user, Entry, entry_id,
ACLType.Writable)
if error:
return error
# checks that a same name entry corresponding to the entity is existed.
query = Q(schema=entry.schema,
name=recv_data["entry_name"]) & ~Q(id=entry.id)
if Entry.objects.filter(query).exists():
return HttpResponse("Duplicate name entry is existed", status=400)
# validate contexts of each attributes
err = _validate_input(recv_data, entry)
if err:
return err
if entry.get_status(Entry.STATUS_CREATING):
return HttpResponse("Target entry is now under processing", status=400)
if custom_view.is_custom("do_edit_entry", entry.schema.name):
# resp is HttpReponse instance or its subclass (e.g. JsonResponse)
resp = custom_view.call_custom("do_edit_entry", entry.schema.name,
request, recv_data, request.user, entry)
if resp:
return resp
# update name of Entry object. If name would be updated, the elasticsearch data of entries that
# refers this entry also be updated by creating REGISTERED_REFERRALS task.
job_register_referrals = None
if entry.name != recv_data["entry_name"]:
job_register_referrals = Job.new_register_referrals(
request.user, entry)
entry.name = recv_data["entry_name"]
entry.save(update_fields=["name"])
# set flags that indicates target entry is under processing
entry.set_status(Entry.STATUS_EDITING)
# Create new jobs to edit entry and notify it to registered webhook endpoint if it's necessary
job_edit_entry = Job.new_edit(request.user, entry, params=recv_data)
job_edit_entry.run()
# running job of re-register referrals because of chaning entry's name
if job_register_referrals:
job_register_referrals.dependent_job = job_edit_entry
job_register_referrals.run()
return JsonResponse({
"entry_id": entry.id,
"entry_name": entry.name,
})
def do_edit(request, entry_id, recv_data):
user = User.objects.get(id=request.user.id)
entry = Entry.objects.get(id=entry_id)
tasks = []
# checks that a same name entry corresponding to the entity is existed.
query = Q(schema=entry.schema, name=recv_data['entry_name']) & ~Q(id=entry.id)
if Entry.objects.filter(query).exists():
return HttpResponse('Duplicate name entry is existed', status=400)
# validate contexts of each attributes
err = _validate_input(recv_data, entry)
if err:
return err
if entry.get_status(Entry.STATUS_CREATING):
return HttpResponse('Target entry is now under processing', status=400)
if custom_view.is_custom("do_edit_entry", entry.schema.name):
# resp is HttpReponse instance or its subclass (e.g. JsonResponse)
resp = custom_view.call_custom(
"do_edit_entry", entry.schema.name, request, recv_data, user, entry
)
if resp:
return resp
# update name of Entry object. If name would be updated, the elasticsearch data of entries that
# refers this entry also be updated by creating REGISTERED_REFERRALS task.
if entry.name != recv_data['entry_name']:
tasks.append(Job.new_register_referrals(user, entry))
entry.name = recv_data['entry_name']
# set flags that indicates target entry is under processing
entry.set_status(Entry.STATUS_EDITING)
entry.save()
# Create a new job to edit entry
tasks.append(Job.new_edit(user, entry, params=recv_data))
# Run all tasks which are created in this request
[t.run() for t in tasks]
return JsonResponse({
'entry_id': entry.id,
'entry_name': entry.name,
})
def do_edit(request, entry_id, recv_data):
user = User.objects.get(id=request.user.id)
entry = Entry.objects.get(id=entry_id)
# checks that a same name entry corresponding to the entity is existed.
query = Q(schema=entry.schema,
name=recv_data['entry_name']) & ~Q(id=entry.id)
if Entry.objects.filter(query).exists():
return HttpResponse('Duplicate name entry is existed', status=400)
# validate contexts of each attributes
err = _validate_input(recv_data, entry)
if err:
return err
if entry.get_status(Entry.STATUS_CREATING):
return HttpResponse('Target entry is now under processing', status=400)
if custom_view.is_custom("do_edit_entry", entry.schema.name):
(is_continue, code, msg) = custom_view.call_custom(*[
"do_edit_entry", entry.schema.name, request, recv_data, user, entry
])
if not is_continue:
return HttpResponse(msg, status=code)
# update name of Entry object
entry.name = recv_data['entry_name']
# set flags that indicates target entry is under processing
entry.set_status(Entry.STATUS_EDITING)
entry.save()
# Create a new job
job = Job.new_edit(user, entry, params=recv_data)
# register a task to edit entry attributes
edit_entry_attrs.delay(user.id, entry.id, job.id)
return JsonResponse({
'entry_id': entry.id,
'entry_name': entry.name,
})
def test_rerun_jobs(self):
user = self.guest_login()
entity = Entity.objects.create(name='entity', created_user=user)
attr = EntityAttr.objects.create(name='attr',
created_user=user,
type=AttrTypeValue['string'],
parent_entity=entity)
entity.attrs.add(attr)
# make a job to create an entry
entry = Entry.objects.create(name='entry', schema=entity, created_user=user)
job = Job.new_create(user, entry, params={
'attrs': [
{'id': str(attr.id), 'value': [{'data': 'hoge', 'index': 0}], 'referral_key': []}
]
})
# send request to run job
resp = self.client.post('/api/v1/job/run/%d' % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
job = Job.objects.get(id=job.id)
self.assertEqual(job.status, Job.STATUS['DONE'])
self.assertEqual(entry.attrs.count(), 1)
attrv = entry.attrs.first().get_latest_value()
self.assertEqual(attrv.value, 'hoge')
# send request to run job with finished job-id
resp = self.client.post('/api/v1/job/run/%d' % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Target job has already been done"')
# send request to run job with invalid job-id
resp = self.client.post('/api/v1/job/run/%d' % 9999)
self.assertEqual(resp.status_code, 400)
# make and send a job to update entry
job = Job.new_edit(user, entry, params={
'attrs': [
{'id': str(entry.attrs.first().id), 'value': [{'data': 'fuga', 'index': 0}],
'referral_key': []}
]
})
resp = self.client.post('/api/v1/job/run/%d' % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
self.assertEqual(Job.objects.get(id=job.id).status, Job.STATUS['DONE'])
self.assertEqual(entry.attrs.first().get_latest_value().value, 'fuga')
# make and send a job to copy entry
job = Job.new_copy(user, entry, params={'new_name': 'new_entry'})
resp = self.client.post('/api/v1/job/run/%d' % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
self.assertEqual(Job.objects.get(id=job.id).status, Job.STATUS['DONE'])
# checks it's success to clone entry
new_entry = Entry.objects.get(name='new_entry', schema=entity)
self.assertEqual(new_entry.attrs.first().get_latest_value().value, 'fuga')
# make and send a job to delete entry
job = Job.new_delete(user, entry)
resp = self.client.post('/api/v1/job/run/%d' % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
self.assertFalse(Entry.objects.get(id=entry.id).is_active)
def test_rerun_jobs(self):
user = self.guest_login()
entity = Entity.objects.create(name="entity", created_user=user)
attr = EntityAttr.objects.create(
name="attr",
created_user=user,
type=AttrTypeValue["string"],
parent_entity=entity,
)
entity.attrs.add(attr)
# make a job to create an entry
entry = Entry.objects.create(name="entry", schema=entity, created_user=user)
job = Job.new_create(
user,
entry,
params={
"attrs": [
{
"id": str(attr.id),
"value": [{"data": "hoge", "index": 0}],
"referral_key": [],
}
]
},
)
# send request to run job
resp = self.client.post("/api/v1/job/run/%d" % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
job = Job.objects.get(id=job.id)
self.assertEqual(job.status, Job.STATUS["DONE"])
self.assertEqual(entry.attrs.count(), 1)
attrv = entry.attrs.first().get_latest_value()
self.assertEqual(attrv.value, "hoge")
# send request to run job with finished job-id
resp = self.client.post("/api/v1/job/run/%d" % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Target job has already been done"')
# send request to run job with invalid job-id
resp = self.client.post("/api/v1/job/run/%d" % 9999)
self.assertEqual(resp.status_code, 400)
# make and send a job to update entry
job = Job.new_edit(
user,
entry,
params={
"attrs": [
{
"id": str(entry.attrs.first().id),
"value": [{"data": "fuga", "index": 0}],
"referral_key": [],
}
]
},
)
resp = self.client.post("/api/v1/job/run/%d" % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
self.assertEqual(Job.objects.get(id=job.id).status, Job.STATUS["DONE"])
self.assertEqual(entry.attrs.first().get_latest_value().value, "fuga")
# make and send a job to copy entry
job = Job.new_do_copy(user, entry, params={"new_name": "new_entry"})
resp = self.client.post("/api/v1/job/run/%d" % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
self.assertEqual(Job.objects.get(id=job.id).status, Job.STATUS["DONE"])
# checks it's success to clone entry
new_entry = Entry.objects.get(name="new_entry", schema=entity)
self.assertEqual(new_entry.attrs.first().get_latest_value().value, "fuga")
# make and send a job to delete entry
job = Job.new_delete(user, entry)
resp = self.client.post("/api/v1/job/run/%d" % job.id)
self.assertEqual(resp.status_code, 200)
self.assertEqual(resp.content, b'"Success to run command"')
self.assertFalse(Entry.objects.get(id=entry.id).is_active)
