# Create your views here.
-from htsworkflow.frontend.experiments.models import FlowCell
+import StringIO
+import logging
+import os
+import sys
+
+try:
+ import json
+except ImportError, e:
+ import simplejson as json
+
+from htsworkflow.frontend.auth import require_api_key
+from htsworkflow.frontend.experiments.models import FlowCell, Lane
from htsworkflow.frontend.samples.changelist import ChangeList
-from htsworkflow.frontend.samples.models import Library
+from htsworkflow.frontend.samples.models import Library, HTSUser
from htsworkflow.frontend.samples.results import get_flowcell_result_dict, parse_flowcell_id
from htsworkflow.frontend.bcmagic.forms import BarcodeMagicForm
from htsworkflow.pipelines.runfolder import load_pipeline_run_xml
from htsworkflow.pipelines import runfolder
from htsworkflow.pipelines.eland import ResultLane
from htsworkflow.frontend import settings
+from htsworkflow.util.conversion import unicode_or_none
from htsworkflow.util import makebed
from htsworkflow.util import opener
+
from django.core.exceptions import ObjectDoesNotExist
-from django.http import HttpResponse, HttpResponseRedirect
+from django.http import HttpResponse, HttpResponseRedirect, Http404
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.template.loader import get_template
from django.contrib.auth.decorators import login_required
-import StringIO
-import logging
-import os
-
LANE_LIST = [1,2,3,4,5,6,7,8]
SAMPLES_CONTEXT_DEFAULTS = {
'app_name': 'Flowcell/Library Tracker',
'bcmagic': BarcodeMagicForm()
}
+def count_lanes(lane_set):
+ single = 0
+ paired = 1
+ short_read = 0
+ medium_read = 1
+ long_read = 2
+ counts = [[0,0,0,],[0,0,0]]
+
+ for lane in lane_set.all():
+ if lane.flowcell.paired_end:
+ lane_type = paired
+ else:
+ lane_type = single
+ if lane.flowcell.read_length < 40:
+ read_type = short_read
+ elif lane.flowcell.read_length < 100:
+ read_type = medium_read
+ else:
+ read_type = long_read
+ counts[lane_type][read_type] += 1
+
+ return counts
+
def create_library_context(cl):
"""
Create a list of libraries that includes how many lanes were run
#for lib in library_items.object_list:
for lib in cl.result_list:
summary = {}
- summary['library_id'] = lib.library_id
+ summary['library_id'] = lib.id
summary['library_name'] = lib.library_name
summary['species_name' ] = lib.library_species.scientific_name
if lib.amplified_from_sample is not None:
- summary['amplified_from'] = lib.amplified_from_sample.library_id
+ summary['amplified_from'] = lib.amplified_from_sample.id
else:
summary['amplified_from'] = ''
- lanes_run = 0
- #for lane_id in LANE_LIST:
- # lane = getattr(lib, 'lane_%d_library' % (lane_id,))
- # lanes_run += len( lane.all() )
- lanes_run = lib.lane_set.count()
+ lanes_run = count_lanes(lib.lane_set)
+ # suppress zeros
+ for row in xrange(len(lanes_run)):
+ for col in xrange(len(lanes_run[row])):
+ if lanes_run[row][col] == 0:
+ lanes_run[row][col] = ''
summary['lanes_run'] = lanes_run
summary['is_archived'] = lib.is_archived()
records.append(summary)
# build changelist
fcl = ChangeList(request, Library,
list_filter=['affiliations', 'library_species'],
- search_fields=['library_id', 'library_name', 'amplified_from_sample__library_id'],
+ search_fields=['id', 'library_name', 'amplified_from_sample__id'],
list_per_page=200,
queryset=Library.objects.filter(hidden__exact=0)
)
"""
try:
- lib = Library.objects.get(library_id=lib_id)
+ lib = Library.objects.get(id=lib_id)
except:
return HttpResponse("Library %s does not exist" % (lib_id))
flowcell_list = []
- interesting_flowcells = {} # aka flowcells we're looking at
- #for lane in LANE_LIST:
+ flowcell_run_results = {} # aka flowcells we're looking at
for lane in lib.lane_set.all():
- #lane_library = getattr(lib, 'lane_%d_library' % (lane,))
- #for fc in lane_library.all():
fc = lane.flowcell
flowcell_id, id = parse_flowcell_id(fc.flowcell_id)
- if flowcell_id not in interesting_flowcells:
- interesting_flowcells[flowcell_id] = get_flowcell_result_dict(flowcell_id)
+ if flowcell_id not in flowcell_run_results:
+ flowcell_run_results[flowcell_id] = get_flowcell_result_dict(flowcell_id)
flowcell_list.append((fc.flowcell_id, lane.lane_number))
flowcell_list.sort()
-
lane_summary_list = []
eland_results = []
for fc, lane_number in flowcell_list:
lane_summary, err_list = _summary_stats(fc, lane_number)
- eland_results.extend(_make_eland_results(fc, lane_number, interesting_flowcells))
+ eland_results.extend(_make_eland_results(fc, lane_number, flowcell_run_results))
lane_summary_list.extend(lane_summary)
context = {
context,
context_instance = RequestContext(request))
+def lanes_for(request, username=None):
+ """
+ Generate a report of recent activity for a user
+ """
+ query = {}
+ if username is not None:
+ user = HTSUser.objects.get(username=username)
+ query.update({'library__affiliations__users__id':user.id})
+ fcl = ChangeList(request, Lane,
+ list_filter=[],
+ search_fields=['flowcell__flowcell_id', 'library__id', 'library__library_name'],
+ list_per_page=200,
+ queryset=Lane.objects.filter(**query)
+ )
+
+ context = { 'lanes': fcl, 'title': 'Lane Index'}
+
+ return render_to_response(
+ 'samples/lanes_for.html',
+ context,
+ context_instance = RequestContext(request)
+ )
+
+
def summaryhtm_fc_cnm(request, flowcell_id, cnm):
"""
returns a Summary.htm file if it exists.
eland_summary = ResultLane(lane_id=lane_id, end=end)
# add information to lane_summary
eland_summary.flowcell_id = flowcell_id
- eland_summary.clusters = gerald_summary[end][lane_id].cluster
+ if len(gerald_summary) > end and gerald_summary[end].has_key(lane_id):
+ eland_summary.clusters = gerald_summary[end][lane_id].cluster
+ else:
+ eland_summary.clusters = None
eland_summary.cycle_width = cycle_width
if hasattr(eland_summary, 'genome_map'):
eland_summary.summarized_reads = runfolder.summarize_mapped_reads(
# grab some more information out of the flowcell db
flowcell = FlowCell.objects.get(flowcell_id=flowcell_id)
- pm_field = 'lane_%d_pM' % (lane_id)
- eland_summary.successful_pm = getattr(flowcell, pm_field)
+ #pm_field = 'lane_%d_pM' % (lane_id)
+ lane_obj = flowcell.lane_set.get(lane_number=lane_id)
+ eland_summary.successful_pm = lane_obj.pM
summary_list.append(eland_summary)
summary_list.append("Summary report needs to be updated.")
logging.error("Exception: " + str(e))
- print "----------------------------------"
- print "-- DOES NOT SUPPORT PAIRED END ---"
- print "----------------------------------"
+ print >>sys.stderr, "----------------------------------"
+ print >>sys.stderr, "-- DOES NOT SUPPORT PAIRED END ---"
+ print >>sys.stderr, "----------------------------------"
lane_results = results.gerald.summary[0][lane]
lrs = lane_results
result_path = cur_fc[cycle]['eland_results'].get(lane, None)
result_link = make_result_link(fc_id, cycle, lane, result_path)
results.append({'flowcell_id': fc_id,
+ 'run_date': flowcell.run_date,
'cycle': cycle,
'lane': lane,
'summary_url': make_summary_url(flowcell_id, cycle),
return '(' + '|'.join(output) + ')'
def library_id_to_admin_url(request, lib_id):
- lib = Library.objects.get(library_id=lib_id)
+ lib = Library.objects.get(id=lib_id)
return HttpResponseRedirect('/admin/samples/library/%s' % (lib.id,))
+def library_dict(library_id):
+ """
+ Given a library id construct a dictionary containing important information
+ return None if nothing was found
+ """
+ try:
+ lib = Library.objects.get(id = library_id)
+ except Library.DoesNotExist, e:
+ return None
+
+ #lane_info = lane_information(lib.lane_set)
+ lane_info = []
+ for lane in lib.lane_set.all():
+ lane_info.append( {'flowcell':lane.flowcell.flowcell_id,
+ 'lane_number': lane.lane_number} )
+
+ info = {
+ # 'affiliations'?
+ # 'aligned_reads': lib.aligned_reads,
+ #'amplified_into_sample': lib.amplified_into_sample, # into is a colleciton...
+ #'amplified_from_sample_id': lib.amplified_from_sample,
+ #'antibody_name': lib.antibody_name(), # we have no antibodies.
+ 'antibody_id': lib.antibody_id,
+ 'avg_lib_size': lib.avg_lib_size,
+ 'cell_line_id': lib.cell_line_id,
+ 'cell_line': unicode_or_none(lib.cell_line),
+ 'experiment_type': lib.experiment_type.name,
+ 'experiment_type_id': lib.experiment_type_id,
+ 'hidden': lib.hidden,
+ 'id': lib.id,
+ 'lane_set': lane_info,
+ 'library_id': lib.id,
+ 'library_name': lib.library_name,
+ 'library_species': lib.library_species.scientific_name,
+ 'library_species_id': lib.library_species_id,
+ #'library_type': lib.library_type.name,
+ 'library_type_id': lib.library_type_id,
+ 'made_for': lib.made_for,
+ 'made_by': lib.made_by,
+ 'notes': lib.notes,
+ 'replicate': lib.replicate,
+ 'stopping_point': lib.stopping_point,
+ 'successful_pM': unicode_or_none(lib.successful_pM),
+ 'undiluted_concentration': unicode_or_none(lib.undiluted_concentration)
+ }
+ if lib.library_type_id is None:
+ info['library_type'] = None
+ else:
+ info['library_type'] = lib.library_type.name
+ return info
+
+def library_json(request, library_id):
+ """
+ Return a json formatted library dictionary
+ """
+ require_api_key(request)
+ # what validation should we do on library_id?
+
+ lib = library_dict(library_id)
+ if lib is None:
+ raise Http404
+
+ lib_json = json.dumps(lib)
+ return HttpResponse(lib_json, mimetype='application/json')
+
+def species_json(request, species_id):
+ """
+ Return information about a species.
+ """
+ raise Http404
+
@login_required
def user_profile(request):
"""
context.update(SAMPLES_CONTEXT_DEFAULTS)
return render_to_response('registration/profile.html', context,
context_instance=RequestContext(request))
+
projects / htsworkflow.git / blobdiff