Also have a proper undelete analysis that restores from backup. Plus show analysis result files in home table, small fix of delete_analysis

Author: glormph

src/backend/analysis/tests.py

@@ -1312,3 +1312,61 @@ def test_delete_fail_backup(self):
         self.assertFalse(self.ana.deleted)
         self.assertFalse(jm.Job.objects.exclude(pk=job.pk).filter(funcname='create_pdc_archive',
             kwargs={'sfloc_id': self.anasfile_sfl.pk, 'isdir': False}).exists())
+
+
+class TestUndeleteAnalysis(BaseTest):
+    url = '/analysis/undelete/'
+
+    def test_fail_request(self):
+        resp = self.cl.get(self.url)
+        self.assertEqual(resp.status_code, 405)
+        # wrong dict keys
+        resp = self.cl.post(self.url, content_type='application/json', data={'hello': 'test'})
+        self.assertEqual(resp.status_code, 400)
+
+        # No analysis
+        resp = self.cl.post(self.url, content_type='application/json',
+                data={'item_id': self.ana.pk + 1000})
+        self.assertEqual(resp.status_code, 400)
+        self.assertIn('Analysis does not exist', resp.json()['error'])
+
+        # analysis not deleted
+        resp = self.cl.post(self.url, content_type='application/json', data={'item_id': self.ana.pk})
+        self.assertEqual(resp.status_code, 403)
+        self.assertIn('Analysis is not deleted', resp.json()['error'])
+        
+        # Not allowed wrong user
+        user = User.objects.create(username='wrong', email='wrong2')
+        self.user.is_staff = False
+        self.user.save()
+        self.ana.user = user
+        self.ana.deleted = True
+        self.ana.save()
+        resp = self.cl.post(self.url, content_type='application/json', data={'item_id': self.ana.pk})
+        self.assertEqual(resp.status_code, 403)
+        self.assertIn('User is not authorized to undelete', resp.json()['error'])
+        
+    def test_undelete_with_backup_ok(self):
+        self.ana.deleted = True
+        self.ana.save()
+        rm.PDCBackedupFile.objects.create(storedfile=self.anasfile, success=True)
+        self.anasfile.deleted = True
+        self.anasfile.save()
+        self.anasfile_sfl.active = False
+        self.anasfile_sfl.save()
+        resp = self.cl.post(self.url, content_type='application/json', data={'item_id': self.ana.pk})
+        self.assertEqual(resp.status_code, 200)
+        self.ana.refresh_from_db()
+        self.assertFalse(self.ana.deleted)
+        self.assertTrue(jm.Job.objects.filter(funcname='restore_from_pdc_archive',
+            kwargs={'sfloc_id': self.anasfile_sfl.pk}).exists())
+
+    def test_delete_without_backup(self):
+        self.ana.deleted = True
+        self.ana.save()
+        resp = self.cl.post(self.url, content_type='application/json', data={'item_id': self.ana.pk})
+        self.assertEqual(resp.status_code, 409)
+        self.assertTrue(self.ana.deleted)
+        self.ana.refresh_from_db()
+        self.assertTrue(self.ana.deleted)
+        self.assertFalse(jm.Job.objects.filter(funcname='restore_from_pdc_archive').exists())

src/backend/analysis/views.py

@@ -1305,26 +1305,51 @@ def undelete_analysis(request):
     req = json.loads(request.body.decode('utf-8'))
     try:
         analysis = am.Analysis.objects.get(pk=req['item_id'])
-    except am.Analysis.DoesNotExist:
-        return JsonResponse({'error': 'Analysis does not exist'}, status=403)
+    except (am.Analysis.DoesNotExist, KeyError):
+        return JsonResponse({'error': 'Analysis does not exist or wrongly specified'}, status=400)
     if not analysis.deleted:
         return JsonResponse({'error': 'Analysis is not deleted, cant undelete it'}, status=403)
-    if analysis.user == request.user or request.user.is_staff:
-        analysis.deleted = False
-        analysis.save()
-        am.AnalysisDeleted.objects.filter(analysis=analysis).delete()
-        return JsonResponse({})
-    else:
+    if not analysis.success_completed:
+        return JsonResponse({'error': 'Analysis was never completed, cant undelete it'}, status=403)
+    if analysis.user != request.user and not request.user.is_staff:
         return JsonResponse({'error': 'User is not authorized to undelete this analysis'}, status=403)
 
+    backedup_sfs = rm.StoredFile.objects.filter(analysisresultfile__analysis=analysis,
+            pdcbackedupfile__deleted=False)
+    if not backedup_sfs.count():
+        return JsonResponse({'error': 'There are no backed up result files, this analysis cannot be '
+            'restored'}, status=409)
+    nr_resfiles = analysis.analysisresultfile_set.count()
+    #if backedup_sfs.count() < nr_resfiles:
+    # TODO warn in case of fewer files than needed (need to impl warning in frontend, takes
+    # no messages now if not error
+
+    restore_sflpk = []
+    for sf in backedup_sfs.values('pk'):
+        if sfls := rm.StoredFileLoc.objects.filter(sfile_id=sf['pk'],
+                servershare__fileservershare__server__can_backup=True).values('pk'):
+            # Assume delivery area for user, otherwise first available
+            if not (sfl := sfls.filter(servershare__function=rm.ShareFunction.ANALYSIS_DELIVERY).first()):
+                sfl = sfls.first()
+            restore_sflpk.append(sfl['pk']) 
+            if joberr := check_job_error('restore_from_pdc_archive', sfloc_id=sfl['pk']):
+                return JsonResponse({'error': 'Error trying to restore backed up result files, '
+                    'cannot restore'}, status=409)
+    for r_sflpk in restore_sflpk:
+        create_job_without_check('restore_from_pdc_archive', sfloc_id=r_sflpk)
+    rm.StoredFileLoc.objects.filter(pk__in=restore_sflpk).update(active=True)
+    backedup_sfs.update(deleted=False)
+    analysis.deleted = False
+    analysis.purged = False
+    analysis.save()
+    am.AnalysisDeleted.objects.filter(analysis=analysis).delete()
+    return JsonResponse({})
+
 
 @login_required
 def delete_analysis(request):
-    # FIXME analysis can be properly deleted if its backed up
-    # right now this is only mark for deletion and it was for a previous
-    # setup where delete meant gone for ever
-    # There is a lot of old analyses that should be backed up or purged properly
-    # Maybe delete all those where no project is active anymore in delete_expired?
+    '''Sets deleted and queues delete jobs after checking if result files need
+    backing up'''
     if request.method != 'POST':
         return JsonResponse({'error': 'Must use POST'}, status=405)
     req = json.loads(request.body.decode('utf-8'))
@@ -1356,7 +1381,7 @@ def do_analysis_deletion(analysis):
         # Back up files if that for some reason (old analysis) hasnt happened earlier
         backup_jobs = []
         for sf in rm.StoredFile.objects.filter(analysisresultfile__analysis=analysis).exclude(
-                pdcbackedupfile__success=True).values('pk', 'filetype__is_folder'):
+                pdcbackedupfile__deleted=False).values('pk', 'filetype__is_folder'):
             sfl_pks = [x['pk'] for x in rm.StoredFileLoc.objects.filter(sfile_id=sf['pk']).values('pk')]
             do_backup = True
             for exist_job in jm.Job.objects.filter(funcname='create_pdc_archive',

src/backend/home/views.py

@@ -461,6 +461,8 @@ def populate_analysis(analyses, user):
             infns = afv.union(adsi).values('pk', 'rawfile_id')
             infn_ds = dsmodels.Dataset.objects.filter(datasetrawfile__rawfile__in=[x['rawfile_id']
                 for x in infns]).distinct('pk').values('pk')
+            outfns = filemodels.StoredFile.objects.filter(analysisresultfile__analysis_id=ana['pk']
+                    ).values('pk')
             nfs = {'name': anmodels.Analysis.get_fullname(ananame),
                     'jobstate': ana['nextflowsearch__job__state'],
                     'jobid': ana['nextflowsearch__job_id'],
@@ -492,6 +494,7 @@ def populate_analysis(analyses, user):
             'purged': ana['purged'],
             'dset_ids': [x['pk'] for x in infn_ds],
             'fn_ids':  [x['pk'] for x in infns],
+            'outfiles': [x['pk'] for x in outfns],
             'mstulosq': tulos_filt,
             'actions': get_ana_actions(ana, user),
             **nfs,

src/frontend/home/src/Analysis.svelte

@@ -18,6 +18,7 @@ const tablefields = [
   {id: 'name', name: 'Analysis name', type: 'str', multi: false},
   {id: 'files', name: '', help: 'Input files', type: 'icon', icon: 'database', multi: false, links: 'fn_ids', linkroute: '#/files'},
   {id: 'datasets', name: '', help: 'Datasets', type: 'icon', icon: 'clipboard-list', multi: false, links: 'dset_ids', linkroute: '#/datasets'},
+  {id: 'outfiles', name: '', help: 'Result files', type: 'icon', icon: 'file-export', multi: false, links: 'outfiles', linkroute: '#/files'},
   {id: 'mstulos', name: '', help: 'ResultsDB', type: 'icon', icon: 'chart-bar', multi: false, links: 'mstulosq', linkroute: '/mstulos/', qparam: 'q'},
   {id: 'wf', name: 'Workflow', type: 'str', multi: false, links: 'wflink', linkroute: false},
   {id: 'usr', name: 'Users', type: 'str', multi: false},