def batch_plate_do_upload(self, id=None):
batch_plate = self.__load_batch_plate(id)
if not batch_plate:
abort(404)
box2 = self.form_result['box2']
plate = self.form_result['plate']
plate_type = batch_plate.batch.plate_type
if plate_type.code == 'fvtitr' and len(plate.analyzed_wells) == 4:
# if four wells, it's really a MFGCC (FVTITR FAM+/VIC+ should have 2)
plate_type = Session.query(PlateType).filter_by(code='mfgcc').one()
plateobj = save_plate_from_upload_request(request.POST['plate'], plate, box2, plate_type_obj=plate_type)
# I want to put this in the form validator, but it's field dependent, so not right now
if plate_type.code in ('mfgcc', 'bcc'):
ok, message = validate_colorcomp_plate(plate)
if not ok:
response = self._batch_plate_upload_base(id)
Session.rollback()
return h.render_bootstrap_form(response, errors={'plate': message})
Session.add(plateobj)
if batch_plate.batch.plate_type.code == plate_type.code:
batch_plate.plate = plateobj
else:
batch_plate.secondary_plate = plateobj
batch_plate.qc_plate = self.form_result['qc_plate']
batch_plate.plate_notes = self.form_result['plate_notes']
Session.commit()
session['flash'] = 'Plate linked.'
session.save()
return redirect(url(controller='metrics', action='per_plate', id=plateobj.id))
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_filter(self):
criteria = self.form_result['plate_type']
consumable_methods = (ManufacturingPlateBatch.DG_METHOD_WEIDMANN_V5,
ManufacturingPlateBatch.DG_METHOD_THINXXS_V2A,
ManufacturingPlateBatch.DG_METHOD_THINXXS_V2B,
ManufacturingPlateBatch.DG_METHOD_THINXXS_V2C)
if criteria == 'CS' or criteria == 'CC':
query = query_plate_type_dg_method(plate_type_code='mfgcc')
elif criteria == 'CO':
query = query_plate_type_dg_method(plate_type_code='mfgco')
elif criteria == 'CSFV':
query = query_plate_type_dg_method(plate_type_code='fvtitr')
elif criteria == 'QP':
query = query_plate_type_dg_method(plate_type_code='scc')
else:
query = Session.query(ManufacturingPlateBatch)
query = query.order_by('creation_date desc, mfg_plate_batch.name')
c.paginator = paginate.Page(
query,
page=int(request.params.get('page', 1)),
items_per_page = 15
)
c.pager_kwargs = {'plate_type': self.form_result['plate_type']}
c.plate_type_field = dg_plate_type_field()
response = render('/product/batch/list.html')
# TODO: need to do from_python?
return h.render_bootstrap_form(response, defaults=self.form_result)
def multipick(self):
response = self._multipick_base()
defaults = {'left_padding': 500,
'right_padding': 500,
'allow_methylation': '',
'singles_as_doubles': '',
'scoring_function': 'multi_mean'}
return h.render_bootstrap_form(response, defaults=defaults)
def search(self, *args, **kwargs):
response = self._search_query_base()
defaults = dict(request.params)
if not request.params.get('group_by_plate'):
defaults['group_by_plate'] = c.default_group_by_plate
if not request.params.get('start_date'):
defaults['start_date'] = c.default_start_date.strftime('%m/%d/%Y')
return h.render_bootstrap_form(response, defaults=defaults)
def batch_plate_upload(self, id=None):
response = self._batch_plate_upload_base(id)
override_plate_type = request.params.get('plate_type_code', None)
plate_defaults = self.__load_batch_plate_into_formvars(c.plate)
if override_plate_type:
plate_type = Session.query(PlateType).filter_by(code=override_plate_type).first()
if plate_type:
# weird
plate_defaults['plate_type'] = PlateTypeConverter.from_python(plate_type.id)
return h.render_bootstrap_form(response, defaults=plate_defaults)
def upload_file(self, id=None):
self.__setup_box2_code_context(id)
source = QLStorageSource(config)
basename = upload_basename(self.form_result['file'].filename)
errors = {}
existing_path = self.__file_name_query(c.box2.id, basename)
if existing_path and not self.form_result['file_id'] == existing_path.id:
# todo, if existing update path
errors = dict(file='File with this name already exists for this reader. Use the Update page.')
path = "%s_%s" % (int(round(time.time())), basename)
thefile = self.form_result['file'].file
filerec = self.__file_id_query(c.box2.id, self.form_result['file_id'])
new_record = False
if not filerec:
filerec = Box2File(box2_id=c.box2.id)
new_record = True
filerec.name = basename
filerec.deleted = False
filerec.path = path
filerec.updated = datetime.datetime.now()
filerec.description = self.form_result['description']
filerec.mime_type = guess_type(basename)[0] or 'text/plain'
if errors:
response = self._upload_base(id)
return h.render_bootstrap_form(response, errors=errors, error_formatters=h.tw_bootstrap_error_formatters)
try:
attachment_dir = self.__upload_file_dir(c.box2)
if not os.path.exists(attachment_dir):
os.mkdir(attachment_dir)
permanent_path = self.__upload_file_path(c.box2, path)
permanent_file = open(permanent_path, 'wb')
shutil.copyfileobj(thefile, permanent_file)
thefile.close()
permanent_file.close()
filerec.size = os.stat(permanent_path).st_size
if new_record:
Session.add(filerec)
else:
Session.merge(filerec)
Session.commit()
session['flash'] = 'File uploaded.'
write_success = True
except Exception, e:
session['flash'] = 'Could not upload file: %s' % str(e)
session['flash_class'] = 'error'
write_success = False
def create(self):
setup, errors = self.__update_groove_record()
if errors:
response = self._new_base()
defaults = GrooveCreateSetupForm().from_python(self.form_result)
return h.render_bootstrap_form(
response, defaults=defaults, errors=errors, error_formatters=h.tw_bootstrap_error_formatters
)
session["flash"] = "Plate created."
session.save()
return redirect(url(controller="groove", action="plates", id=setup.id))
def edit(self, id=None):
if not id:
abort(404)
tag = Session.query(SequenceGroupTag).get(int(id))
c.tag = tag
if not tag:
abort(404)
response = self._edit_base()
return h.render_bootstrap_form(response, defaults=tag.__dict__)
def index(self):
assay_field = fl.sequence_group_field(blank=True, selected=request.params.get('assay', None))
# this will need to change based on the mode...
enzyme_field = fl.enzyme_select_field()
c.assays = assay_field
c.enzymes = enzyme_field
response = render('/cutter/index.html')
defaults = {'left_padding': 500, 'right_padding': 500}
return h.render_bootstrap_form(response, defaults=defaults)
def batch_create(self):
try:
self.__update_batch_record()
except IntegrityError:
response = self._batch_new_base()
defaults = PlateBatchForm().from_python(self.form_result)
return h.render_bootstrap_form(response,
defaults=defaults,
errors={'name': 'A batch already exists with this name.'},
error_formatters=h.tw_bootstrap_error_formatters)
session['flash'] = 'Batch created.'
session.save()
return redirect(url(controller='product', action='batch_list'))
def category(self, *args, **kwargs):
response = self._category_query_base()
defaults = dict(request.params)
if not request.params.get('start_date'):
defaults['start_date'] = c.default_start_date.strftime('%m/%d/%Y')
return h.render_bootstrap_form(response, defaults=defaults)
def logfile(self):
response = self._logfile_base()
return h.render_bootstrap_form(response)
def batch_plate_template(self, id=None):
return h.render_bootstrap_form(self._batch_plate_template_base(id), defaults=self.__load_batch_plate_into_formvars(c.plate))
def algorithms(self):
response = self._algorithms_base()
return h.render_bootstrap_form(response)
def login(self):
response = self._login_base()
defaults = {"came_from": request.params.get("came_from", url(controller="auth", action="logged_in"))}
return h.render_bootstrap_form(response, defaults=defaults)
def list(self):
response = self._list_base()
return h.render_bootstrap_form(response)
def new(self):
response = self._new_base()
return h.render_bootstrap_form(response)
def algcommand(self, *args, **kwargs):
response = self._algcommand_base()
return h.render_bootstrap_form(response)
def edit(self, id=None):
response = self._edit_base(id)
return h.render_bootstrap_form(response, defaults=self.__load_setup_into_formvars(c.setup))
def reader_qcc(self, *args, **kwargs):
query, objects_expected = build_reader_query(self.form_result)
c.back_url = url(controller='qc_chart', action='reader')
response = self._process_and_display_qcc(query, objects_expected)
return h.render_bootstrap_form(response, defaults=ReaderQueryForm.from_python(self.form_result))
def new(self):
response = self._new_base()
now = datetime.now()
return h.render_bootstrap_form(response, defaults={"creation_date": now.strftime("%Y%m%d")})
def robocopy(self):
self.__setup_robocopy_context()
response = render("/box2/robocopy.html")
return h.render_bootstrap_form(response)
def batch_editplate(self, id=None):
response = self._batch_editplate_base(id)
return h.render_bootstrap_form(response, defaults=self.__load_batch_plate_into_formvars(c.plate))
def search_trend(self, *args, **kwargs):
query, objects_expected = build_search_query(self.form_result)
c.back_url = url(controller='trend', action='search')
response = self._process_and_display_trends(query, objects_expected)
return h.render_bootstrap_form(response, defaults=SearchQueryForm.from_python(self.form_result))
def update(self, id=None):
file_id = self.form_result['file_id']
response = self._update_base(file_id, id)
thefile = self.__file_id_query(c.box2.id, file_id)
return h.render_bootstrap_form(response, defaults={'file_id': thefile.id, 'description': thefile.description})
def upload(self, id=None):
response = self._upload_base(code=id)
return h.render_bootstrap_form(response)
def register_lab(self):
response = self._register_lab_base()
return h.render_bootstrap_form(response)
def validation(self, *args, **kwargs):
response = self._validation_base()
plate_template_id = request.params.get('plate_template_id', '')
return h.render_bootstrap_form(response, defaults={'plate_template_id': plate_template_id})
