experiments/views.py

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