def tearDown(self):
     from qtools.model import Session
     Session.delete(self.testUser)
     Session.delete(self.testProject)
     Session.delete(self.readQLP)
     Session.delete(self.unreadQLP)
     Session.commit()

    def runs(self, id=None):
        c.dg = Session.query(DropletGenerator).get(int(id))
        if not c.dg:
            abort(404)
        
        reprocess_config_id = request.params.get('rp_id', None)
        if reprocess_config_id:
            reprocess_config_id = int(reprocess_config_id)
        
        runs = Session.query(DropletGeneratorRun).filter(
                    and_(DropletGeneratorRun.droplet_generator_id == c.dg.id,
                         DropletGeneratorRun.run_number != None)).all()
        
        run_dict = dict([(run.run_number, run) for run in runs])

        wells = Session.query(WellMetric,
                              QLBWell.id,
                              QLBWell.sample_name,
                              QLBWell.dg_run_number,
                              QLBWell.consumable_channel_num)\
                       .join(QLBWell)\
                       .join(PlateMetric)\
                       .filter(and_(QLBWell.droplet_generator_id == id,
                                    QLBWell.dg_run_number != None,
                                    PlateMetric.reprocess_config_id == reprocess_config_id))\
                       .order_by(QLBWell.dg_run_number, QLBWell.consumable_channel_num).all()
        
        sorted_runs = sorted(groupinto(wells, lambda tup: (tup[3])), key=operator.itemgetter(0))
        c.runs = [(run_id, run_dict[run_id], sorted(info, key=operator.itemgetter(4))) for run_id, info in sorted_runs if run_dict.get(run_id, None)]
        #raise Exception, c.runs
        return render('/product/dg/runs.html')

def apply_setup_to_plate(qlplate, dbplate):
    """
    Determine if a plate has an applicable template, either by
    explicit setting or by implicit naming.

    :param qlplate: The QLP file to read
    :param dbplate: The DB plate to update
    """
    if qlplate.plate_setup_id:
        setup = Session.query(PlateSetup).get(int(qlplate.plate_setup_id))
        if setup:
            inherit_setup_attributes(dbplate, setup)
            return True
    
    dirname = dbplate.qlbplate.file.dirname
    basename = dbplate.qlbplate.file.basename
    complete_name = basename[:-4] # -- .qlp

    setups = Session.query(PlateSetup).order_by('prefix desc').all()

    for setup in setups:
        if complete_name.startswith(setup.prefix):
            inherit_setup_attributes(dbplate, setup)
            return True
    
    return False

 def __vendor_enzymes(self, name):
     vendor = Session.query(Vendor).filter_by(name=unicode(name)).first()
     # this might be better off with a regular SQL statement
     all_enzymes = Session.query(VendorEnzyme, Enzyme.name, Enzyme.cutseq, Enzyme.methylation_sensitivity,\
                                 func.sum(VendorEnzyme.stock_units).label('total_stock_units')
                                ).join(Enzyme).filter(VendorEnzyme.vendor_id == vendor.id).group_by(VendorEnzyme.enzyme_id).all()
     return all_enzymes

def make_plate_name(plate, experiment_name=None):
    """
    Given a plate and assigned project, operator
    and experiment, generate a name that conforms
    to the QTools naming standard.

    Name will be project_operator_experiment.

    :param plate:
    :param experiment_name:
    :return:
    """
    # this is the hard way, before the relation is saved.
    if plate.project_id:
        project = Session.query(Project).get(plate.project_id)
        if project:
            if project.code:
                project_code = project.code
            else:
                project_code = project.name
        else:
            project_code = ''
    else:
        project_code = ''
    
    operator = Session.query(Person).get(plate.operator_id)
    if operator:
        user_code = operator.name_code
    else:
        user_code = ''
    
    
    fields = [project_code, user_code, experiment_name]
    return '_'.join([field for field in fields if field])

def apply_template_to_plate(qlplate, dbplate):
    """
    Determine if a plate has an applicable template, either by
    explicit setting or by implicit naming.

    :param qlplate: The QLP file to read
    :param dbplate: The DB plate to update
    """
    # new-style: if plate file has plate_template_id in it,
    # just bind
    if qlplate.plate_template_id:
        template = Session.query(PlateTemplate).get(int(qlplate.plate_template_id))
        if template:
            inherit_template_attributes(dbplate, template)
            return True
    
    # otherwise, check the name
    dirname = dbplate.qlbplate.file.dirname
    basename = dbplate.qlbplate.file.basename
    complete_name = basename[:-4] # -- .qlp

    # duplicate prefixes are possible; use most recent
    templates = Session.query(PlateTemplate).order_by('prefix desc, id desc').all()
    
    for template in templates:
        if complete_name.startswith(template.prefix):
            inherit_template_attributes(dbplate, template)
            return True
    
    return False

 def by_well_tag(self):
     well_tag_field = fl.well_tag_field(str(self.form_result['well_tag']))
     c.group_by_plate = self.form_result['group_by_plate']
     c.tag_id = self.form_result['well_tag']
     c.tag_name = Session.query(WellTag).get(c.tag_id).name
     c.form = h.LiteralFormSelectPatch(
         value = {'well_tag': well_tag_field['value'],
                  'group_by_plate': [u'1' if c.group_by_plate else u'0']},
         option = {'well_tag': [('--','--')]+well_tag_field['options'],
                   'group_by_plate': [(u'1', '')]}
     )
     
     well_tags = Session.query(WellTag).\
                         filter_by(id=c.tag_id).\
                         options(joinedload_all(WellTag.tag_wells, QLBWell.plate, QLBPlate.file, innerjoin=True),
                                 joinedload_all(WellTag.tag_wells, QLBWell.plate, QLBPlate.plate, innerjoin=True)).\
                         all()
     
     c.label_names = []
     
     if not len(well_tags):
         c.wells = []
         c.well_groups = []
     elif c.group_by_plate:
         wells = sorted(well_tags[0].wells, key=lambda well: (well.plate_id, well.well_name))
         well_groups = [(plate, list(wells)) for plate, wells in itertools.groupby(wells, lambda well: well.plate)]
         c.well_groups = sorted(well_groups, key=lambda tup: tup[0].host_datetime)
         c.well_groups.reverse()
     else:
         c.wells = sorted(well_tags[0].wells, key=lambda well: well.host_datetime)
         c.wells.reverse()
     
     return render('/box2/by_well_tag.html')

 def reader_history(self, id=None, admin=True):
     box2 = self.__setup_box2_context_by_code(id)
     c.admin = admin != 'False'
     logs = Session.query(Box2Log).filter_by(box2_id=box2.id)\
                                  .order_by('time_effective desc')\
                                  .options(joinedload_all(Box2Log.circuit))\
                                  .all()
     
     statuses = Session.query(DRStatusLog).filter_by(box2_id=box2.id)\
                                          .order_by('time_effective desc')\
                                          .options(joinedload_all(DRStatusLog.reporter))\
                                          .all()
     
     fixes = Session.query(DRFixLog).filter_by(box2_id=box2.id)\
                                    .order_by('time_effective desc')\
                                    .all()
     
     log_pairs = [(logs[i].time_effective, [logs[i],(logs[i+1] if i < len(logs)-1 else None)]) for i in range(len(logs))]
     for pair in log_pairs:
         pair[1].append((sorted(box2log_mv.labeleditems(pair[1][0]).items()),
                         sorted(box2log_mv.labeleditems(pair[1][1]).items())))
     status_pairs = [(status.time_effective, status) for status in statuses]
     fix_pairs = [(fix.time_effective, fix) for fix in fixes]
     changes = log_pairs + status_pairs + fix_pairs
     c.changes = sorted(changes, key=operator.itemgetter(0))
     c.changes.reverse()
     
     return render('/admin/reader_history.html')             

    def command(self):
        app = self.load_wsgi_app()
        min_id = 0
        if len(self.args) > 1:
            min_id = self.args[0]
        storage = QLStorageSource(app.config)

        qlbplates = Session.query(QLBPlate).filter(QLBPlate.id > min_id).order_by('id').all()
        for qlbplate in qlbplates:
            try:
                path = storage.qlbplate_path(qlbplate)
            except Exception:
                print "Could not find plate: %s (%s)" % (qlbplate.plate.name if qlbplate.plate else 'Name unknown', qlbplate.id)
                continue
            try:
                qlplate = get_plate(path)
            except Exception:
                print "Could not read plate: %s (%s)" % (qlbplate.plate.name if qlbplate.plate else 'Name Unknown', qlbplate.id)
                continue

            if qlplate.is_fam_vic:
                qlbplate.dyeset = QLBPlate.DYESET_FAM_VIC
            elif qlplate.is_fam_hex:
                qlbplate.dyeset = QLBPlate.DYESET_FAM_HEX
            elif qlplate.is_eva_green:
                qlbplate.dyeset = QLBPlate.DYESET_EVA
            else:
                qlbplate.dyeset = QLBPlate.DYESET_UNKNOWN

            print "Assigned dye %s - %s (%s)" % (qlbplate.dyeset, qlbplate.plate.name if qlbplate.plate else 'Name Unknown', qlbplate.id)
            Session.commit()

    def register_algorithm(self):
        storage = QSAlgorithmSource(config)
        existing_folders = [tup[0] for tup in Session.query(ReprocessConfig.original_folder).all()]

        errors = dict()
        src_dir = self.form_result['src_dir']
        if src_dir in existing_folders:
            errors['src_dir'] = 'This algorithm has already been registered.'

        elif not storage.source_path_exists(src_dir):
            errors['src_dir'] = 'This algorithm is not accessible in the file system.'

        if self.form_result['peak_detection_version'] == (0,0):
            # this is arbitrary
            peak_detection_version = (0, QUANTASOFT_DIR_VERSION_RE.search(src_dir).group(1).split('_')[-1])
        else:
            peak_detection_version = self.form_result['peak_detection_version']

        if self.form_result['peak_quantitation_version'] == (0,0):
            peak_quantitation_version = (0, QUANTASOFT_DIR_VERSION_RE.search(src_dir).group(1).split('_')[-1])
        else:
            peak_quantitation_version = self.form_result['peak_quantitation_version']

        if errors:
            resp = self._algorithms_base()
            defaults = AlgorithmRegisterForm.from_python(self.form_result)
            return h.render_bootstrap_form(resp,
                defaults=defaults,
                errors=errors,
                error_formatters=h.tw_bootstrap_error_formatters)

        try:
            rp = ReprocessConfig(name=src_dir.split(os.path.sep)[0],
                                 code=self.form_result['code'],
                                 peak_detection_major=peak_detection_version[0],
                                 peak_detection_minor=peak_detection_version[1],
                                 peak_quant_major=peak_quantitation_version[0],
                                 peak_quant_minor=peak_quantitation_version[1],
                                 trigger_fixed_width=100,
                                 active=True,
                                 cluster_mode=ReprocessConfig.CLUSTER_MODE_CLUSTER,
                                 original_folder=src_dir)

            storage.add_reprocessor(src_dir, self.form_result['code'])
            Session.add(rp)
            Session.commit()
            session['flash'] = 'New algorithm reprocessor created.'
            session.save()
            return redirect(url(controller='product', action='algorithms'))

        except shutil.Error:
            session['flash'] = 'Could not copy source algorithm to destination.'
            session['flash_class'] = 'error'
            session.save()
            return redirect(url(controller='product', action='algorithms'))
        except IOError:
            session['flash'] = "Could not access the algorithm's file system."
            session['flash_class'] = 'error'
            session.save()
            return redirect(url(controller='product', action='algorithms'))

    def batch_plate_template_download(self, id=None):
        plate = self.__load_batch_plate(id)
        box2 = Session.query(Box2).get(self.form_result['box2_id'])
        if not plate or not box2:
            abort(404)
            
        code = plate.batch.plate_type.code

        if self.form_result['qc_plate']:
            plate.qc_plate = self.form_result['qc_plate']
            Session.commit()

        # TODO FIXFIX or incorporate into model
        if plate.qc_plate:
            serial = 'QC'
        else:
            serial = box2.name.split(' ')[-1]
        # only mfgco supported right now
        if code == 'mfgco':
            qlt_file = "%s/carryover.qlt" % config['qlb.setup_template_store']
        elif code == 'fvtitr':
            qlt_file = "%s/fvbatch_QC.qlt" % config['qlb.setup_template_store']
        else:
            abort(404)
        
        response.headers['Content-Type'] = 'application/quantalife-template'
        h.set_download_response_header(request, response, "%s_%s.qlt" % (serial, plate.name))
        response.headers['Pragma'] = 'no-cache'
        response.headers['Cache-Control'] = 'no-cache'
        return forward(FileApp(qlt_file, response.headerlist))

 def batch_csfv_unhook(self):
     plate = self.__load_batch_plate(self.form_result['batch_plate_id'])
     plate.plate_id = None
     Session.commit()
     session['flash'] = 'CSFV QC plate discarded.'
     session.save()
     return redirect(url(controller='product', action='batch_plates', id=plate.mfg_batch_id))

 def __update_batch_plate_record(self, record):
     record.dg_method = self.form_result['dg_method']
     record.qc_plate = self.form_result['qc_plate'] and True or False
     record.plate_notes = self.form_result['plate_notes']
     record.thermal_cycler_id = self.form_result['thermal_cycler_id']
     Session.add(record)
     Session.commit()

def plate_query():

    # writing it this way because the .join seems to muck up
    # filter_by statements downstream
    box2s = [tup[0] for tup in Session.query(Box2.id).all()]

    query = Session.query(Plate).filter(Plate.box2_id.in_(box2s))
    return query

 def sensitivity(self):
     enz = Session.query(Enzyme).get(self.form_result['enzyme'])
     if not self.form_result['sensitivity']:
         enz.methylation_sensitivity = None
     else:
         enz.methylation_sensitivity = self.form_result['sensitivity']
     Session.commit()
     return "OK"

    def save(self):
        if self.form_result['plate_setup_id']:
            ps = Session.query(PlateSetup).get(self.form_result['plate_setup_id'])
            prefix = ps.prefix
        elif self.form_result['plate_template_id']:
            pt = Session.query(PlateTemplate).get(self.form_result['plate_template_id'])
            prefix = pt.prefix
        else:
            prefix = 'output'
        
        response.headers['Content-Type'] = 'application/quantalife-template'
        h.set_download_response_header(request, response, "%s.qlt" % prefix)
        response.headers['Pragma'] = 'no-cache'

        # build a plate
        # TODO: add default fields
        plate = ExperimentMetadataQLPlate(channel_names=['FAM','VIC'],
                        host_datetime=datetime.now(),
                        host_machine='QTools',
                        host_user='qtools',
                        plate_template_id=self.form_result['plate_template_id'],
                        plate_setup_id=self.form_result['plate_setup_id'])
        
        for cell in sorted(self.form_result['cells'], key=lambda c: c['cell_name']):
            well = ExperimentMetadataQLWell(name=cell['cell_name'],
                                            num_channels=2,
                                            sample=cell['sample'],
                                            experiment_comment=cell['experiment_comment'],
                                            experiment_name=cell['experiment_name'],
                                            experiment_type=cell['experiment_type'],
                                            temperature=cell['temperature'],
                                            enzyme=cell['enzyme'],
                                            enzyme_conc=cell['enzyme_conc'],
                                            additive=cell['additive'],
                                            additive_conc=cell['additive_conc'],
                                            expected_cpd=cell['expected_cpd'],
                                            expected_cpul=cell['expected_cpul'],
                                            target_copy_num=cell['target_copy_num'],
                                            ref_copy_num=cell['ref_copy_num'],
                                            dg_cartridge=cell['cartridge'],
                                            supermix=cell['supermix'])
            
            well.channels[0].target = cell['fam_target']
            well.channels[0].type = cell['fam_type']
            well.channels[1].target = cell['vic_target']
            well.channels[1].type = cell['vic_type']

            plate.wells[str(cell['cell_name'])] = well
        
        # generate QLT
        # TODO: rowcol order

        writer = QLTWriter(rowcol_order=self.form_result['rowcol_order'],
                           fgcolorfunc=self.__qlt_fgcolorfunc,
                           bgcolorfunc=self.__qlt_bgcolorfunc)
        qlt = writer.getbytes(plate)
        return qlt

 def instock(self):
     enz = Session.query(VendorEnzyme).get(self.form_result['vendor_enzyme_id'])
     if self.form_result['in_stock']:
         enz.stock_units = 1
     else:
         enz.stock_units = 0
     
     Session.commit()
     return 'OK'

    def _list_base(self):
        groove_test = Session.query(Project).filter_by(name="GrooveTest").first()
        query = Session.query(PlateSetup).filter_by(project_id=groove_test.id).order_by("time_updated desc, name")

        c.paginator = paginate.Page(query, page=int(request.params.get("page", 1)), items_per_page=20)

        c.pager_kwargs = {}
        c.plate_type_field = groove_plate_type_field()
        return render("/product/groove/list.html")

    def enzyme_conc_create(self):
        conc = EnzymeConcentration()

        for k, v in self.form_result.items():
            setattr(conc, k, v)

        Session.add(conc)
        Session.commit()

        redirect(url(controller="assay", action="view", id=self.form_result["assay_id"]))

 def save_reagents(self, id=None):
     self.__load_context()
     setup, struct = self.__load_setup(id)
     if not setup:
         abort(404)
     
     for k, v in self.form_result.items():
         setattr(setup, k, v)
     Session.commit()
     redirect(url(controller='setup', action='dg', id=id, beta=c.beta))