views.py 22.2 KB
Newer Older
Floreal Cabanettes's avatar
Floreal Cabanettes committed
1
from dgenies import app, app_title, app_folder, config_reader, mailer, APP_DATA
2

Floreal Cabanettes's avatar
Floreal Cabanettes committed
3
import os
4
5
import time
import datetime
6
import shutil
7
import re
8
import threading
Floreal Cabanettes's avatar
Floreal Cabanettes committed
9
from flask import render_template, request, url_for, jsonify, Response, abort, send_file, Markup
10
from pathlib import Path
11
12
13
14
15
from dgenies.lib.paf import Paf
from dgenies.lib.job_manager import JobManager
from dgenies.lib.functions import Functions, ALLOWED_EXTENSIONS
from dgenies.lib.upload_file import UploadFile
from dgenies.lib.fasta import Fasta
Floreal Cabanettes's avatar
Floreal Cabanettes committed
16
from dgenies.database import Session, Gallery
17
from peewee import DoesNotExist
Floreal Cabanettes's avatar
Floreal Cabanettes committed
18
19
from markdown import Markdown
from markdown.extensions.toc import TocExtension
20

21

Floreal Cabanettes's avatar
Floreal Cabanettes committed
22
23
24
25
26
27
@app.context_processor
def get_launched_results():
    cookie = request.cookies.get("results")
    return {"results": cookie.split("|") if cookie is not None else set()}


28
29
30
# Main
@app.route("/", methods=['GET'])
def main():
Floreal Cabanettes's avatar
Floreal Cabanettes committed
31
32
33
34
35
36
    pict = Gallery.select().order_by("id")
    if len(pict) > 0:
        pict = pict[0].picture
    else:
        pict = None
    return render_template("index.html", title=app_title, menu="index", pict=pict)
Floreal Cabanettes's avatar
Floreal Cabanettes committed
37
38
39
40


@app.route("/run", methods=['GET'])
def run():
Floreal Cabanettes's avatar
Floreal Cabanettes committed
41
42
43
44
45
46
47
48
49
50
51
    with Session.connect():
        s_id = Session.new()
        id_job = Functions.random_string(5) + "_" + datetime.datetime.fromtimestamp(time.time()).strftime('%Y%m%d%H%M%S')
        if "id_job" in request.args:
            id_job = request.args["id_job"]
        email = ""
        if "email" in request.args:
            email = request.args["email"]
        return render_template("run.html", title=app_title, id_job=id_job, email=email,
                               menu="run", allowed_ext=ALLOWED_EXTENSIONS, s_id=s_id,
                               max_upload_file_size=config_reader.max_upload_file_size)
52
53


54
55
56
57
58
@app.route("/run-test", methods=['GET'])
def run_test():
    print(config_reader.allowed_ip_tests)
    if request.remote_addr not in config_reader.allowed_ip_tests:
        return abort(404)
Floreal Cabanettes's avatar
Floreal Cabanettes committed
59
60
    with Session.connect():
        return Session.new()
61
62


63
64
65
# Launch analysis
@app.route("/launch_analysis", methods=['POST'])
def launch_analysis():
66
    try:
Floreal Cabanettes's avatar
Floreal Cabanettes committed
67
68
        with Session.connect():
            session = Session.get(s_id=request.form["s_id"])
69
70
71
72
73
74
    except DoesNotExist:
        return jsonify({"success": False, "errors": ["Session has expired. Please refresh the page and try again"]})
    # Reset session upload:
    session.allow_upload = False
    session.position = -1
    session.save()
75
76
    id_job = request.form["id_job"]
    email = request.form["email"]
77
78
79
80
    file_query = request.form["query"]
    file_query_type = request.form["query_type"]
    file_target = request.form["target"]
    file_target_type = request.form["target_type"]
81
82
83

    # Check form:
    form_pass = True
84
    errors = []
85
    if id_job == "":
86
        errors.append("Id of job not given")
87
88
89
        form_pass = False

    if email == "":
90
        errors.append("Email not given")
91
        form_pass = False
92
93
    if file_target == "":
        errors.append("No target fasta selected")
94
95
96
97
        form_pass = False

    # Form pass
    if form_pass:
98
        # Get final job id:
99
        id_job = re.sub('[^A-Za-z0-9_\-]+', '', id_job.replace(" ", "_"))
100
        id_job_orig = id_job
101
        i = 2
102
        while os.path.exists(os.path.join(APP_DATA, id_job)):
103
104
            id_job = id_job_orig + ("_%d" % i)
            i += 1
105

106
        folder_files = os.path.join(APP_DATA, id_job)
107
108
109
        os.makedirs(folder_files)

        # Save files:
110
        query = None
111
        upload_folder = session.upload_folder
112
113
        if file_query != "":
            query_name = os.path.splitext(file_query.replace(".gz", ""))[0] if file_query_type == "local" else None
114
            query_path = os.path.join(app.config["UPLOAD_FOLDER"], upload_folder, file_query) \
115
116
117
                if file_query_type == "local" else file_query
            query = Fasta(name=query_name, path=query_path, type_f=file_query_type)
        target_name = os.path.splitext(file_target.replace(".gz", ""))[0] if file_target_type == "local" else None
118
        target_path = os.path.join(app.config["UPLOAD_FOLDER"], upload_folder, file_target) \
119
120
            if file_target_type == "local" else file_target
        target = Fasta(name=target_name, path=target_path, type_f=file_target_type)
121
122

        # Launch job:
Floreal Cabanettes's avatar
Floreal Cabanettes committed
123
        job = JobManager(id_job, email, query, target, mailer)
124
        job.launch()
125
126
127

        # Delete session:
        session.delete_instance()
128
        return jsonify({"success": True, "redirect": url_for(".status", id_job=id_job)})
129
    else:
130
        return jsonify({"success": False, "errors": errors})
131
132
133
134
135
136


# Status of a job
@app.route('/status/<id_job>', methods=['GET'])
def status(id_job):
    job = JobManager(id_job)
137
138
139
140
141
142
143
144
145
146
147
148
    j_status = job.status()
    mem_peak = j_status["mem_peak"] if "mem_peak" in j_status else None
    if mem_peak is not None:
        mem_peak = "%.1f G" % (mem_peak / 1024.0 / 1024.0)
    time_e = j_status["time_elapsed"] if "time_elapsed" in j_status else None
    if time_e is not None:
        if time_e < 60:
            time_e = "%d secs" % time_e
        else:
            minutes = time_e // 60
            seconds = time_e - minutes * 60
            time_e = "%d min %d secs" % (minutes, seconds)
149
150
151
152
153
154
155
156
157
    format = request.args.get("format")
    if format is not None and format == "json":
        return jsonify({
            "status": j_status["status"],
            "error": j_status["error"].replace("#ID#", ""),
            "id_job": id_job,
            "mem_peak": mem_peak,
            "time_elapsed": time_e
        })
158
159
160
    return render_template("status.html", title=app_title, status=j_status["status"],
                           error=j_status["error"].replace("#ID#", ""),
                           id_job=id_job, menu="results", mem_peak=mem_peak,
161
162
                           time_elapsed=time_e,
                           query_filtered=job.is_query_filtered(), target_filtered=job.is_target_filtered())
163
164


Floreal Cabanettes's avatar
Floreal Cabanettes committed
165
# Results path
166
@app.route("/result/<id_res>", methods=['GET'])
167
def result(id_res):
168
    my_render = render_template("result.html", title=app_title, id=id_res, menu="result", current_result=id_res)
Floreal Cabanettes's avatar
Floreal Cabanettes committed
169
170
171
172
173
174
175
    response = app.make_response(my_render)
    cookie = request.cookies.get("results")
    cookie = cookie.split("|") if cookie is not None else []
    if id_res not in cookie:
        cookie.insert(0, id_res)
    response.set_cookie(key="results", value="|".join(cookie), path="/")
    return response
176
177


178
179
@app.route("/gallery", methods=['GET'])
def gallery():
180
    return render_template("gallery.html", items=Functions.get_gallery_items(), menu="gallery", title=app_title)
181
182
183
184
185
186
187
188
189
190


@app.route("/gallery/<filename>", methods=['GET'])
def gallery_file(filename):
    try:
        return send_file(os.path.join(config_reader.app_data, "gallery", filename))
    except FileNotFoundError:
        abort(404)


191
def get_file(file, gzip=False):  # pragma: no cover
Floreal Cabanettes's avatar
Floreal Cabanettes committed
192
193
194
195
196
197
    try:
        # Figure out how flask returns static files
        # Tried:
        # - render_template
        # - send_file
        # This should not be so non-obvious
198
        return open(file, "rb" if gzip else "r").read()
199
200
    except FileNotFoundError:
        abort(404)
Floreal Cabanettes's avatar
Floreal Cabanettes committed
201
    except IOError as exc:
202
203
        print(exc)
        abort(500)
Floreal Cabanettes's avatar
Floreal Cabanettes committed
204
205


Floreal Cabanettes's avatar
Floreal Cabanettes committed
206
207
@app.route("/install", methods=['GET'])
def install():
208
    with open(os.path.join(app_folder, "INSTALL.md"), "r", encoding='utf-8') as install_instr:
Floreal Cabanettes's avatar
Floreal Cabanettes committed
209
210
211
212
213
214
215
        content = install_instr.read()
    md = Markdown(extensions=[TocExtension(baselevel=1)])
    content = Markup(md.convert(content))
    toc = Markup(md.toc)
    return render_template("install.html", menu="install", title=app_title, content=content, toc=toc)


Floreal Cabanettes's avatar
Floreal Cabanettes committed
216
217
218
219
220
221
222
223
224
225
226
@app.route("/paf/<id_res>", methods=['GET'])
def download_paf(id_res):
    map_file = os.path.join(APP_DATA, id_res, "map.paf.sorted")
    if not os.path.exists(map_file):
        map_file = os.path.join(APP_DATA, id_res, "map.paf")
    if not os.path.exists(map_file):
        abort(404)
    content = get_file(map_file)
    return Response(content, mimetype="text/plain")


Floreal Cabanettes's avatar
Floreal Cabanettes committed
227
# Get graph (ajax request)
228
229
230
@app.route('/get_graph', methods=['POST'])
def get_graph():
    id_f = request.form["id"]
231
232
233
    paf = os.path.join(APP_DATA, id_f, "map.paf")
    idx1 = os.path.join(APP_DATA, id_f, "query.idx")
    idx2 = os.path.join(APP_DATA, id_f, "target.idx")
234

235
    paf = Paf(paf, idx1, idx2)
236

237
238
    if paf.parsed:
        res = paf.get_d3js_data()
239
        res["success"] = True
240
241
242
243
244
245
        return jsonify(res)
    return jsonify({"success": False, "message": paf.error})


@app.route('/sort/<id_res>', methods=['POST'])
def sort_graph(id_res):
246
    if not os.path.exists(os.path.join(APP_DATA, id_res, ".all-vs-all")):
247
248
249
        paf_file = os.path.join(APP_DATA, id_res, "map.paf")
        idx1 = os.path.join(APP_DATA, id_res, "query.idx")
        idx2 = os.path.join(APP_DATA, id_res, "target.idx")
250
        paf = Paf(paf_file, idx1, idx2, False)
251
252
253
254
255
256
257
        paf.sort()
        if paf.parsed:
            res = paf.get_d3js_data()
            res["success"] = True
            return jsonify(res)
        return jsonify({"success": False, "message": paf.error})
    return jsonify({"success": False, "message": "Sort is not available for All-vs-All mode"})
Floreal Cabanettes's avatar
Floreal Cabanettes committed
258

Floréal Cabanettes's avatar
Floréal Cabanettes committed
259

260
261
262
263
@app.route('/reverse-contig/<id_res>', methods=['POST'])
def reverse_contig(id_res):
    contig_name = request.form["contig"]
    if not os.path.exists(os.path.join(APP_DATA, id_res, ".all-vs-all")):
264
265
266
        paf_file = os.path.join(APP_DATA, id_res, "map.paf")
        idx1 = os.path.join(APP_DATA, id_res, "query.idx")
        idx2 = os.path.join(APP_DATA, id_res, "target.idx")
267
268
269
270
271
272
273
274
275
276
        paf = Paf(paf_file, idx1, idx2, False)
        paf.reverse_contig(contig_name)
        if paf.parsed:
            res = paf.get_d3js_data()
            res["success"] = True
            return jsonify(res)
        return jsonify({"success": False, "message": paf.error})
    return jsonify({"success": False, "message": "Sort is not available for All-vs-All mode"})


277
278
@app.route('/freenoise/<id_res>', methods=['POST'])
def free_noise(id_res):
279
280
281
    paf_file = os.path.join(APP_DATA, id_res, "map.paf")
    idx1 = os.path.join(APP_DATA, id_res, "query.idx")
    idx2 = os.path.join(APP_DATA, id_res, "target.idx")
282
283
284
285
286
287
288
289
290
    paf = Paf(paf_file, idx1, idx2, False)
    paf.parse_paf(noise=request.form["noise"] == "1")
    if paf.parsed:
        res = paf.get_d3js_data()
        res["success"] = True
        return jsonify(res)
    return jsonify({"success": False, "message": paf.error})


291
292
@app.route('/get-fasta-query/<id_res>', methods=['POST'])
def build_fasta(id_res):
293
    res_dir = os.path.join(APP_DATA, id_res)
294
295
    lock_query = os.path.join(res_dir, ".query-fasta-build")
    is_sorted = os.path.exists(os.path.join(res_dir, ".sorted"))
296
    compressed = request.form["gzip"].lower() == "true"
297
298
299
300
301
    query_fasta = Functions.get_fasta_file(res_dir, "query", is_sorted)
    if query_fasta is not None:
        if is_sorted and not query_fasta.endswith(".sorted"):
            # Do the sort
            Path(lock_query).touch()
302
303
            if not compressed:  # If compressed, it will took a long time, so not wait
                Path(lock_query + ".pending").touch()
304
305
306
307
308
            thread = threading.Timer(1, Functions.sort_fasta, kwargs={
                "job_name": id_res,
                "fasta_file": query_fasta,
                "index_file": os.path.join(res_dir, "query.idx.sorted"),
                "lock_file": lock_query,
309
                "compress": compressed,
310
311
312
                "mailer": mailer
            })
            thread.start()
313
314
315
316
317
318
            if not compressed:
                i = 0
                time.sleep(5)
                while os.path.exists(lock_query) and i < 2:
                    i += 1
                    time.sleep(5)
Floreal Cabanettes's avatar
Floreal Cabanettes committed
319
                os.remove(lock_query + ".pending")
320
321
322
                if os.path.exists(lock_query):
                    return jsonify({"success": True, "status": 1, "status_message": "In progress"})
                return jsonify({"success": True, "status": 2, "status_message": "Done",
323
                                "gzip": False})
324
325
            else:
                return jsonify({"success": True, "status": 1, "status_message": "In progress"})
326
327
328
329
330
        elif is_sorted and os.path.exists(lock_query):
            # Sort is already in progress
            return jsonify({"success": True, "status": 1, "status_message": "In progress"})
        else:
            # No sort to do or sort done
331
332
333
334
335
336
337
            if compressed and not query_fasta.endswith(".gz.fasta"):
                # If compressed file is asked, we must compress it now if not done before...
                Path(lock_query).touch()
                thread = threading.Timer(1, Functions.compress_and_send_mail, kwargs={
                    "job_name": id_res,
                    "fasta_file": query_fasta,
                    "index_file": os.path.join(res_dir, "query.idx.sorted"),
338
                    "lock_file": lock_query,
339
340
341
342
343
                    "compressed": compressed,
                    "mailer": mailer
                })
                thread.start()
                return jsonify({"success": True, "status": 1, "status_message": "In progress"})
344
345
346
347
348
349
350
            return jsonify({"success": True, "status": 2, "status_message": "Done",
                            "gzip": query_fasta.endswith(".gz") or query_fasta.endswith(".gz.sorted")})
    else:
        return jsonify({"success": False,
                        "message": "Unable to get fasta file for query. Please contact us to report the bug"})


351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
@app.route('/build-query-as-reference/<id_res>', methods=['POST'])
def get_query_as_reference(id_res):
    paf_file = os.path.join(APP_DATA, id_res, "map.paf")
    idx1 = os.path.join(APP_DATA, id_res, "query.idx")
    idx2 = os.path.join(APP_DATA, id_res, "target.idx")
    paf = Paf(paf_file, idx1, idx2, False, mailer=mailer, id_job=id_res)
    paf.parse_paf(False, True)
    thread = threading.Timer(0, paf.build_query_chr_as_reference)
    thread.start()
    return jsonify({"success": True})


@app.route('/download/<id_res>/<filename>')
def download_file(id_res, filename):
    file_dl = os.path.join(APP_DATA, id_res, filename)
    if os.path.isfile(file_dl):
        return send_file(file_dl)
    return abort(404)


371
372
373
@app.route('/fasta-query/<id_res>', defaults={'filename': ""}, methods=['GET'])
@app.route('/fasta-query/<id_res>/<filename>', methods=['GET'])  # Use fake URL in mail to set download file name
def dl_fasta(id_res, filename):
374
    res_dir = os.path.join(APP_DATA, id_res)
375
376
377
378
379
380
381
382
383
384
385
386
387
    lock_query = os.path.join(res_dir, ".query-fasta-build")
    is_sorted = os.path.exists(os.path.join(res_dir, ".sorted"))
    if not os.path.exists(lock_query) or not is_sorted:
        query_fasta = Functions.get_fasta_file(res_dir, "query", is_sorted)
        if query_fasta is not None:
            if query_fasta.endswith(".gz") or query_fasta.endswith(".gz.sorted"):
                content = get_file(query_fasta, True)
                return Response(content, mimetype="application/gzip")
            content = get_file(query_fasta)
            return Response(content, mimetype="text/plain")
    abort(404)


388
389
@app.route('/qt-assoc/<id_res>', methods=['GET'])
def qt_assoc(id_res):
390
    res_dir = os.path.join(APP_DATA, id_res)
391
    if os.path.exists(res_dir) and os.path.isdir(res_dir):
392
393
394
        paf_file = os.path.join(APP_DATA, id_res, "map.paf")
        idx1 = os.path.join(APP_DATA, id_res, "query.idx")
        idx2 = os.path.join(APP_DATA, id_res, "target.idx")
395
396
397
398
399
400
401
402
403
404
405
406
        try:
            paf = Paf(paf_file, idx1, idx2, False)
            paf.parse_paf(False)
        except FileNotFoundError:
            print("Unable to load data!")
            abort(404)
            return False
        csv_content = paf.build_query_on_target_association_file()
        return Response(csv_content, mimetype="text/plain")
    abort(404)


407
408
409
410
411
412
@app.route('/no-assoc/<id_res>', methods=['POST'])
def no_assoc(id_res):
    """
    Get contigs that match with None target
    :param id_res: id of the result
    """
413
    res_dir = os.path.join(APP_DATA, id_res)
414
    if os.path.exists(res_dir) and os.path.isdir(res_dir):
415
416
417
        paf_file = os.path.join(APP_DATA, id_res, "map.paf")
        idx1 = os.path.join(APP_DATA, id_res, "query.idx")
        idx2 = os.path.join(APP_DATA, id_res, "target.idx")
418
419
420
421
422
423
        try:
            paf = Paf(paf_file, idx1, idx2, False)
        except FileNotFoundError:
            print("Unable to load data!")
            abort(404)
            return False
424
        file_content = paf.build_list_no_assoc(request.form["to"])
425
426
427
428
429
430
431
432
        empty = file_content == "\n"
        return jsonify({
            "file_content": file_content,
            "empty": empty
        })
    abort(404)


Floreal Cabanettes's avatar
Floreal Cabanettes committed
433
434
@app.route('/summary/<id_res>', methods=['POST'])
def summary(id_res):
435
436
437
438
439
440
441
442
443
444
    paf_file = os.path.join(APP_DATA, id_res, "map.paf")
    idx1 = os.path.join(APP_DATA, id_res, "query.idx")
    idx2 = os.path.join(APP_DATA, id_res, "target.idx")
    try:
        paf = Paf(paf_file, idx1, idx2, False)
    except FileNotFoundError:
        return jsonify({
            "success": False,
            "message": "Unable to load data!"
        })
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
    percents = None
    s_status = "waiting"  # Accepted values: waiting, done, fail
    status_file = os.path.join(APP_DATA, id_res, ".summarize")
    fail_file = status_file + ".fail"
    if not os.path.exists(status_file):  # The job is finished or not started
        if not os.path.exists(fail_file):  # The job has not started yet or has successfully ended
            percents = paf.get_summary_stats()
            if percents is None:  # The job has not started yet
                Path(status_file).touch()
                thread = threading.Timer(0, paf.build_summary_stats, kwargs={"status_file": status_file})
                thread.start()
            else:  # The job has successfully ended
                s_status = "done"
        else:  # The job has failed
            s_status = "fail"

    if s_status == "waiting":  # The job is running
        # Check if the job end in the next 30 seconds
        nb_iter = 0
        while os.path.exists(status_file) and not os.path.exists(fail_file) and nb_iter < 10:
            time.sleep(3)
            nb_iter += 1
        if not os.path.exists(status_file):  # The job has ended
            percents = paf.get_summary_stats()
            if percents is None:  # The job has failed
                s_status = "fail"
            else:  # The job has successfully ended
                s_status = "done"

    if s_status == "fail":
475
476
477
478
479
480
        return jsonify({
            "success": False,
            "message": "Build of summary failed. Please contact us to report the bug"
        })
    return jsonify({
        "success": True,
481
482
        "percents": percents,
        "status": s_status
483
    })
Floreal Cabanettes's avatar
Floreal Cabanettes committed
484
485


486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
def get_filter_out(id_res, type_f):
    filter_file = os.path.join(APP_DATA, id_res, ".filter-" + type_f)
    return Response(get_file(filter_file), mimetype="text/plain")


@app.route('/filter-out/<id_res>/query')
def get_filter_out_query(id_res):
    return get_filter_out(id_res=id_res, type_f="query")


@app.route('/filter-out/<id_res>/target')
def get_filter_out_target(id_res):
    return get_filter_out(id_res=id_res, type_f="target")


501
502
503
504
@app.route("/ask-upload", methods=['POST'])
def ask_upload():
    try:
        s_id = request.form['s_id']
Floreal Cabanettes's avatar
Floreal Cabanettes committed
505
506
507
        with Session.connect():
            session = Session.get(s_id=s_id)
            allowed = session.ask_for_upload(True)
508
509
        return jsonify({
            "success": True,
Floreal Cabanettes's avatar
Floreal Cabanettes committed
510
            "allowed": allowed
511
512
513
        })
    except DoesNotExist:
        return jsonify({"success": False, "message": "Session not initialized. Please refresh the page."})
514
515


516
517
518
@app.route("/ping-upload", methods=['POST'])
def ping_upload():
    s_id = request.form['s_id']
Floreal Cabanettes's avatar
Floreal Cabanettes committed
519
520
521
    with Session.connect():
        session = Session.get(s_id=s_id)
        session.ping()
522
    return "OK"
523
524


525
526
527
528
@app.route("/upload", methods=['POST'])
def upload():
    try:
        s_id = request.form['s_id']
Floreal Cabanettes's avatar
Floreal Cabanettes committed
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
        with Session.connect():
            session = Session.get(s_id=s_id)
            if session.ask_for_upload(False):
                folder = session.upload_folder
                files = request.files[list(request.files.keys())[0]]

                if files:
                    filename = files.filename
                    folder_files = os.path.join(app.config["UPLOAD_FOLDER"], folder)
                    if not os.path.exists(folder_files):
                        os.makedirs(folder_files)
                    filename = Functions.get_valid_uploaded_filename(filename, folder_files)
                    mime_type = files.content_type

                    if not Functions.allowed_file(files.filename):
                        result = UploadFile(name=filename, type_f=mime_type, size=0, not_allowed_msg="File type not allowed")
                        shutil.rmtree(folder_files)

                    else:
                        # save file to disk
                        uploaded_file_path = os.path.join(folder_files, filename)
                        files.save(uploaded_file_path)

                        # get file size after saving
                        size = os.path.getsize(uploaded_file_path)

                        # return json for js call back
                        result = UploadFile(name=filename, type_f=mime_type, size=size)

                    return jsonify({"files": [result.get_file()], "success": "OK"})

                return jsonify({"files": [], "success": "404", "message": "No file provided"})
            return jsonify({"files": [], "success": "ERR", "message": "Not allowed to upload!"})
562
563
564
565
566
    except DoesNotExist:
        return jsonify({"files": [], "success": "ERR", "message": "Session not initialized. Please refresh the page."})
    except:  # Except all possible exceptions to prevent crashes
        return jsonify({"files": [], "success": "ERR", "message": "An unexpected error has occurred on upload. "
                                                                  "Please contact the support."})
567
568


569
570
571
572
573
574
@app.route("/send-mail/<id_res>", methods=['POST'])
def send_mail(id_res):
    allowed = False
    key_file = None
    if "key" in request.form:
        key = request.form["key"]
575
        res_dir = os.path.join(APP_DATA, id_res)
576
577
578
579
580
581
582
583
584
585
586
587
        key_file = os.path.join(res_dir, ".key")
        if os.path.exists(key_file):
            with open(key_file) as k_f:
                true_key = k_f.readline().strip("\n")
                allowed = key == true_key
    if allowed:
        os.remove(key_file)
        job_mng = JobManager(id_job=id_res, mailer=mailer)
        job_mng.set_inputs_from_res_dir()
        job_mng.send_mail()
        return "OK"
    else:
588
        abort(403)