htsworkflow/frontend/experiments/views.py

   1 # Create your views here.
   2 from datetime import datetime
   3 import os
   4
   5 #from django.template import Context, loader
   6 #shortcut to the above modules
   7 from django.contrib.auth.decorators import user_passes_test
   8 from django.conf import settings
   9 from django.core.exceptions import ObjectDoesNotExist
  10 from django.core.mail import EmailMessage, mail_managers
  11 from django.http import HttpResponse
  12 from django.shortcuts import render_to_response, get_object_or_404
  13 from django.template import RequestContext
  14 from django.template.loader import get_template
  15
  16 from htsworkflow.frontend.experiments.models import \
  17      DataRun, \
  18      DataFile, \
  19      FlowCell, \
  20      Lane, \
  21      Sequencer
  22 from htsworkflow.frontend.experiments.experiments import \
  23      estimateFlowcellDuration, \
  24      estimateFlowcellTimeRemaining, \
  25      roundToDays, \
  26      getUsersForFlowcell, \
  27      makeEmailLaneMap
  28
  29 def index(request):
  30     all_runs = DataRun.objects.order_by('-run_start_time')
  31     return render_to_response('experiments/index.html',{'data_run_list': all_runs})
  32
  33 def detail(request, run_folder):
  34     html_str = '<h2>Exp Track Details Page</h2>'
  35     html_str += 'Run Folder: '+run_folder
  36     r = get_object_or_404(DataRun,run_folder=run_folder)
  37     return render_to_response('experiments/detail.html',{'run_f': r})
  38
  39 def makeFCSheet(request,fcid):
  40   # get Flowcell by input fcid
  41   # ...
  42   rec = None
  43   try:
  44     rec = FlowCell.objects.get(flowcell_id=fcid)
  45   except ObjectDoesNotExist:
  46     pass
  47   lanes = ['1','2','3','4','5','6','7','8']
  48   return render_to_response('experiments/flowcellSheet.html',{'fc': rec})
  49
  50
  51 @user_passes_test(lambda u: u.is_staff)
  52 def startedEmail(request, pk):
  53     """
  54     Create the we have started processing your samples email
  55     """
  56     fc = get_object_or_404(FlowCell, id=pk)
  57
  58     send = request.REQUEST.get('send',False)
  59     if send in ('1', 'on', 'True', 'true', True):
  60         send = True
  61     else:
  62         send = False
  63
  64     bcc_managers = request.REQUEST.get('bcc', False)
  65     if bcc_managers in ('on', '1', 'True', 'true'):
  66         bcc_managers = True
  67     else:
  68         bcc_managers = False
  69
  70     email_lane = makeEmailLaneMap(fc)
  71     flowcell_users = getUsersForFlowcell(fc)
  72     estimate = estimateFlowcellTimeRemaining(fc)
  73     estimate_low, estimate_high = roundToDays(estimate)
  74     email_verify = get_template('experiments/email_preview.html')
  75     email_template = get_template('experiments/started_email.txt')
  76     sender = settings.NOTIFICATION_SENDER
  77
  78     warnings = []
  79     emails = []
  80
  81     emailless_users = []
  82     for user in flowcell_users:
  83         # provide warning
  84         if user.email is None or len(user.email) == 0:
  85             warnings.append((user.admin_url(), user.username))
  86     user=None
  87
  88     for user_email in email_lane.keys():
  89         sending = ""
  90         # build body
  91         context = RequestContext(request,
  92                                  {u'flowcell': fc,
  93                                   u'lanes': email_lane[user_email],
  94                                   u'runfolder': 'blank',
  95                                   u'finish_low': estimate_low,
  96                                   u'finish_high': estimate_high,
  97                                   u'now': datetime.now(),
  98                                   })
  99
 100         # build view
 101         subject = "Flowcell %s" % ( fc.flowcell_id )
 102         body = email_template.render(context)
 103
 104         if send:
 105             email = EmailMessage(subject, body, sender, to=[user_email])
 106             notified = set()
 107             if bcc_managers:
 108                 for manager in settings.MANAGERS:
 109                     if len(manager) > 0:
 110                         notified.add(manager)
 111             for user in settings.NOTIFICATION_BCC:
 112                 if len(user) > 0:
 113                     notified.add(user)
 114             email.bcc = list(notified)
 115             email.send()
 116
 117         emails.append((user_email, subject, body, sending))
 118
 119     verify_context = RequestContext(
 120         request,
 121         { 'emails': emails,
 122           'flowcell': fc,
 123           'from': sender,
 124           'send': send,
 125           'site_managers': settings.MANAGERS,
 126           'title': fc.flowcell_id,
 127           'warnings': warnings,
 128         })
 129     return HttpResponse(email_verify.render(verify_context))
 130
 131 def finishedEmail(request, pk):
 132     """
 133     """
 134     return HttpResponse("I've got nothing.")
 135
 136
 137 def flowcell_detail(request, flowcell_id, lane_number=None):
 138     fc = get_object_or_404(FlowCell, flowcell_id__startswith=flowcell_id)
 139     fc.update_data_runs()
 140
 141
 142     if lane_number is not None:
 143         lanes = fc.lane_set.filter(lane_number=lane_number)
 144     else:
 145         lanes = fc.lane_set.all()
 146
 147     context = RequestContext(request,
 148                              {'flowcell': fc,
 149                               'lanes': lanes})
 150
 151     return render_to_response('experiments/flowcell_detail.html',
 152                               context)
 153
 154 def flowcell_lane_detail(request, lane_pk):
 155     lane = get_object_or_404(Lane, id=lane_pk)
 156     lane.flowcell.update_data_runs()
 157
 158     dataruns = []
 159     lane.flowcell.update_data_runs()
 160     for run in lane.flowcell.datarun_set.all():
 161         files = run.lane_files().get(lane.lane_number, None)
 162         dataruns.append((run,
 163                          lane.lane_number,
 164                          files))
 165
 166     context = RequestContext(request,
 167                              {'lib': lane.library,
 168                               'lane': lane,
 169                               'flowcell': lane.flowcell,
 170                               'filtered_dataruns': dataruns})
 171
 172     return render_to_response('experiments/flowcell_lane_detail.html',
 173                               context)
 174
 175 def read_result_file(self, key):
 176     """Return the contents of filename if everything is approved
 177     """
 178     data_file = get_object_or_404(DataFile, random_key = key)
 179
 180     mimetype = 'application/octet-stream'
 181     if data_file.file_type.mimetype is not None:
 182         mimetype = data_file.file_type.mimetype
 183
 184     if os.path.exists(data_file.pathname):
 185         return HttpResponse(open(data_file.pathname,'r'),
 186                             mimetype=mimetype)
 187
 188     raise Http404
 189
 190
 191 def sequencer(request, sequencer_id):
 192     sequencer = get_object_or_404(Sequencer, id=sequencer_id)
 193     context = RequestContext(request,
 194                              {'sequencer': sequencer})
 195     return render_to_response('experiments/sequencer.html', context)