def add_filter_by_date(self, query, out_params): """Applies the filter by Requested date to the search query """ date_query = formatDateQuery(self.context, 'Requested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'Requested') out_params.append({'title': _('Requested'), 'value': requested, 'type': 'text'})
def add_filter_by_date_range(self, query, out_params): date_query = formatDateQuery(self.context, "tats_DateReceived") if not date_query: return query["getDateReceived"] = date_query out_params.append({ "title": _("Received"), "value": formatDateParms(self.context, "Tats_DateReceived"), "type": "text" })
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Attachments") headings['subheader'] = _( "The attachments linked to analysis requests and analyses") count_all = 0 query = {'portal_type': 'Attachment'} if 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = 'All' parms.append({ 'title': _('Client'), 'value': client_title, 'type': 'text' }) date_query = formatDateQuery(self.context, 'Loaded') if date_query: query['getDateLoaded'] = date_query loaded = formatDateParms(self.context, 'Loaded') parms.append({ 'title': _('Loaded'), 'value': loaded, 'type': 'text' }) # and now lets do the actual report lines formats = { 'columns': 6, 'col_heads': [ _('Request'), _('File'), _('Attachment type'), _('Content type'), _('Size'), _('Loaded'), ], 'class': '', } datalines = [] attachments = pc(query) for a_proxy in attachments: attachment = a_proxy.getObject() attachment_file = attachment.getAttachmentFile() icon = attachment_file.icon filename = attachment_file.filename filesize = attachment_file.get_size() filesize = filesize / 1024 sizeunit = "Kb" if filesize > 1024: filesize = filesize / 1024 sizeunit = "Mb" dateloaded = attachment.getDateLoaded() dataline = [] dataitem = {'value': attachment.Title()} dataline.append(dataitem) dataitem = {'value': filename, 'img_before': icon} dataline.append(dataitem) dataitem = { 'value': attachment.getAttachmentType().Title() if attachment.getAttachmentType() else '' } dataline.append(dataitem) dataitem = { 'value': self.context.lookupMime(attachment_file.getContentType()) } dataline.append(dataitem) dataitem = {'value': '%s%s' % (filesize, sizeunit)} dataline.append(dataitem) dataitem = {'value': self.ulocalized_time(dateloaded)} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'colspan': 5, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ _('Request'), _('File'), _('Attachment type'), _('Content type'), _('Size'), _('Loaded'), ] output = StringIO.StringIO() dw = csv.DictWriter(output, fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow(row) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader( "Content-Disposition", "attachment;filename=\"analysesattachments_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return { 'report_title': t(headings['header']), 'report_data': self.template() }
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analyses per analysis service") headings['subheader'] = _( "Number of analyses requested per analysis service") query = {'portal_type': 'Analysis'} if self.request.form.has_key('ClientUID'): client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = _('All') parms.append({ 'title': _('Client'), 'value': client_title, 'type': 'text' }) date_query = formatDateQuery(self.context, 'Requested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'Requested') parms.append({ 'title': _('Requested'), 'value': requested, 'type': 'text' }) date_query = formatDateQuery(self.context, 'Published') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'Published') parms.append({ 'title': _('Published'), 'value': published, 'type': 'text' }) workflow = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('bika_analysis_workflow'): query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = workflow.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') parms.append({ 'title': _('Status'), 'value': review_state, 'type': 'text' }) if self.request.form.has_key('bika_cancellation_workflow'): query['cancellation_state'] = self.request.form[ 'bika_cancellation_workflow'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') parms.append({ 'title': _('Active'), 'value': cancellation_state, 'type': 'text' }) if self.request.form.has_key('bika_worksheetanalysis_workflow'): query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) # and now lets do the actual report lines formats = { 'columns': 2, 'col_heads': [_('Analysis service'), _('Number of analyses')], 'class': '', } datalines = [] count_all = 0 for cat in sc(portal_type="AnalysisCategory", sort_on='sortable_title'): dataline = [ { 'value': cat.Title, 'class': 'category_heading', 'colspan': 2 }, ] datalines.append(dataline) for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on='sortable_title'): query['getServiceUID'] = service.UID analyses = bc(query) count_analyses = len(analyses) dataline = [] dataitem = {'value': service.Title} dataline.append(dataitem) dataitem = {'value': count_analyses} dataline.append(dataitem) datalines.append(dataline) count_all += count_analyses # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } title = self.context.translate(headings['header']) return {'report_title': title, 'report_data': self.template()}
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') bc = getToolByName(self.context, 'bika_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} count_all_ars = 0 count_all_analyses = 0 query = {} this_client = logged_in_client(self.context) if not this_client and self.request.form.has_key('ClientUID'): client_uid = self.request.form['ClientUID'] this_client = rc.lookupObject(client_uid) parms.append( { 'title': _('Client'), 'value': this_client.Title(), 'type': 'text'}) if this_client: headings['header'] = _("Analysis requests and analyses") headings['subheader'] = _("Number of Analysis requests and analyses") else: headings['header'] = _("Analysis requests and analyses per client") headings['subheader'] = _("Number of Analysis requests and analyses per client") date_query = formatDateQuery(self.context, 'Requested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'Requested') else: requested = 'Undefined' parms.append( { 'title': _('Requested'), 'value': requested, 'type': 'text'}) workflow = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('bika_analysis_workflow'): query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = workflow.getTitleForStateOnType(self.request.form['bika_analysis_workflow'], 'Analysis') parms.append({'title': _('Status'), 'value': review_state, 'type': 'text'}) if self.request.form.has_key('bika_cancellation_workflow'): query['cancellation_state'] = self.request.form['bika_cancellation_workflow'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') parms.append({'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if self.request.form.has_key('bika_worksheetanalysis_workflow'): query['worksheetanalysis_review_state'] = self.request.form['bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) if self.request.form.has_key('bika_worksheetanalysis_workflow'): query['worksheetanalysis_review_state'] = self.request.form['bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 3, 'col_heads': [ _('Client'), _('Number of requests'), _('Number of analyses')], 'class': ''} datalines = [] if this_client: c_proxies = pc(portal_type="Client", UID=this_client.UID()) else: c_proxies = pc(portal_type="Client", sort_on='sortable_title') for client in c_proxies: query['getClientUID'] = client.UID dataline = [{'value': client.Title },] query['portal_type'] = 'AnalysisRequest' ars = bc(query) count_ars = len(ars) dataitem = {'value': count_ars} dataline.append(dataitem) query['portal_type'] = 'Analysis' analyses = bac(query) count_analyses = len(analyses) dataitem = {'value': count_analyses } dataline.append(dataitem) datalines.append(dataline) count_all_analyses += count_analyses count_all_ars += count_ars # footer data footlines = [] if not this_client: footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all_ars} footline.append(footitem) footitem = {'value': count_all_analyses} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return {'report_title': self.context.translate(headings['header']), 'report_data': self.template()}
def __call__(self): bsc = getToolByName(self.context, 'bika_setup_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analyses out of range") headings['subheader'] = _("Analyses results out of specified range") count_all = 0 query = {"portal_type": "Analysis", "sort_order": "reverse"} spec_uid = self.request.form.get("spec", False) spec_obj = None spec_title = "" if spec_uid: brains = bsc(UID=spec_uid) if brains: spec_obj = brains[0].getObject() spec_title = spec_obj.Title() parms.append({ "title": _("Range spec"), "value": spec_title, "type": "text" }) date_query = formatDateQuery(self.context, 'Received') if date_query: query['getDateReceived'] = date_query received = formatDateParms(self.context, 'Received') else: received = 'Undefined' parms.append({ 'title': _('Received'), 'value': received, 'type': 'text' }) wf_tool = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('bika_analysis_workflow'): query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = wf_tool.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') else: review_state = 'Undefined' parms.append({ 'title': _('Status'), 'value': review_state, 'type': 'text' }) if self.request.form.has_key('bika_cancellation_workflow'): query['cancellation_state'] = self.request.form[ 'bika_cancellation_workflow'] cancellation_state = wf_tool.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') else: cancellation_state = 'Undefined' parms.append({ 'title': _('Active'), 'value': cancellation_state, 'type': 'text' }) if self.request.form.has_key('bika_worksheetanalysis_workflow'): query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = wf_tool.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') else: ws_review_state = 'Undefined' parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) # and now lets do the actual report lines col_heads = [ _('Client'), _('Request'), _('Sample type'), _('Sample point'), _('Category'), _('Analysis'), _('Result'), _('Min'), _('Max'), _('Status'), ] if isAttributeHidden('Sample', 'SamplePoint'): col_heads.remove(_('Sample point')) formats = { 'columns': 10, 'col_heads': col_heads, 'class': '', } datalines = [] for a_proxy in bac(query): analysis = a_proxy.getObject() if analysis.getResult(): try: result = float(analysis.getResult()) except: continue else: continue keyword = analysis.getKeyword() # determine which specs to use for this particular analysis # 1) if a spec is given in the query form, use it. # 2) if a spec is entered directly on the analysis, use it. # otherwise just continue to the next object. spec_dict = False if spec_obj: rr = spec_obj.getResultsRangeDict() if keyword in rr: spec_dict = rr[keyword] else: ar = analysis.aq_parent ar_spec_obj = ar.getSpecification() if ar_spec_obj: rr = ar_spec_obj.getResultsRangeDict() if keyword in rr: spec_dict = rr[keyword] else: if hasattr(analysis, "specification") \ and analysis.specification: spec_dict = analysis.specification else: continue if not spec_dict: continue try: spec_min = float(spec_dict['min']) spec_max = float(spec_dict['max']) except ValueError: continue if spec_min <= result <= spec_max: continue # check if in shoulder: out of range, but in acceptable # error percentage shoulder = False error = 0 try: error = float(spec_dict.get('error', '0')) except: error = 0 pass error_amount = (result / 100) * error error_min = result - error_amount error_max = result + error_amount if ((result < spec_min) and (error_max >= spec_min)) or \ ((result > spec_max) and (error_min <= spec_max)): shoulder = True dataline = [] dataitem = {'value': analysis.getClientTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getRequestID()} dataline.append(dataitem) dataitem = {'value': analysis.aq_parent.getSampleTypeTitle()} dataline.append(dataitem) if isAttributeHidden('Sample', 'SamplePoint'): dataitem = {'value': analysis.aq_parent.getSamplePointTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getCategoryTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getServiceTitle()} dataline.append(dataitem) if shoulder: dataitem = { 'value': analysis.getResult(), 'img_after': '++resource++bika.lims.images/exclamation.png' } else: dataitem = {'value': analysis.getResult()} dataline.append(dataitem) dataitem = {'value': spec_dict['min']} dataline.append(dataitem) dataitem = {'value': spec_dict['max']} dataline.append(dataitem) state = wf_tool.getInfoFor(analysis, 'review_state', '') review_state = wf_tool.getTitleForStateOnType(state, 'Analysis') dataitem = {'value': review_state} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = { 'value': _('Number of analyses out of range for period'), 'colspan': 9, 'class': 'total_label' } footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) # report footer data footnotes = [] footline = [] footitem = { 'value': _('Analysis result within error range'), 'img_before': '++resource++bika.lims.images/exclamation.png' } footline.append(footitem) footnotes.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines, 'footnotes': footnotes } title = t(headings['header']) return {'report_title': title, 'report_data': self.template()}
def __call__(self): bsc = getToolByName(self.context, "bika_setup_catalog") bac = getToolByName(self.context, "bika_analysis_catalog") self.report_content = {} parms = [] headings = {} headings["header"] = _("Analyses out of range") headings["subheader"] = _("Analyses results out of specified range") count_all = 0 query = {"portal_type": "Analysis", "sort_order": "reverse"} if self.request.form.get("spec", ""): spec_uid = self.request.form["spec"] spec_obj = bsc(UID=spec_uid).getObject() spec_title = spec_obj.Title() else: spec_uid = "" spec_obj = None spec_title = "" parms.append({"title": _("Range spec"), "value": spec_title, "type": "text"}) date_query = formatDateQuery(self.context, "Received") if date_query: query["getDateReceived"] = date_query received = formatDateParms(self.context, "Received") else: received = "Undefined" parms.append({"title": _("Received"), "value": received, "type": "text"}) wf_tool = getToolByName(self.context, "portal_workflow") if self.request.form.has_key("bika_analysis_workflow"): query["review_state"] = self.request.form["bika_analysis_workflow"] review_state = wf_tool.getTitleForStateOnType(self.request.form["bika_analysis_workflow"], "Analysis") else: review_state = "Undefined" parms.append({"title": _("Status"), "value": review_state, "type": "text"}) if self.request.form.has_key("bika_cancellation_workflow"): query["cancellation_state"] = self.request.form["bika_cancellation_workflow"] cancellation_state = wf_tool.getTitleForStateOnType( self.request.form["bika_cancellation_workflow"], "Analysis" ) else: cancellation_state = "Undefined" parms.append({"title": _("Active"), "value": cancellation_state, "type": "text"}) if self.request.form.has_key("bika_worksheetanalysis_workflow"): query["worksheetanalysis_review_state"] = self.request.form["bika_worksheetanalysis_workflow"] ws_review_state = wf_tool.getTitleForStateOnType( self.request.form["bika_worksheetanalysis_workflow"], "Analysis" ) else: ws_review_state = "Undefined" parms.append({"title": _("Assigned to worksheet"), "value": ws_review_state, "type": "text"}) # and now lets do the actual report lines formats = { "columns": 10, "col_heads": [ _("Client"), _("Request"), _("Sample type"), _("Sample point"), _("Category"), _("Analysis"), _("Result"), _("Min"), _("Max"), _("Status"), ], "class": "", } datalines = [] for a_proxy in bac(query): analysis = a_proxy.getObject() if analysis.getResult(): try: result = float(analysis.getResult()) except: continue else: continue keyword = analysis.getKeyword() # determine which specs to use for this particular analysis # 1) if a spec is given in the query form, use it. # 2) if a spec is entered directly on the analysis, use it. # otherwise just continue to the next object. if spec_obj: rr = spec_obj.getResultsRangeDict() if keyword in rr: spec_dict = rr[keyword] else: ar = analysis.aq_parent ar_spec_obj = ar.getSpecification() if ar_spec_obj: rr = ar_spec_obj.getResultsRangeDict() if keyword in rr: spec_dict = rr[keyword] else: if hasattr(analysis, "specification") and analysis.specification: spec_dict = analysis.specification else: continue spec_min = float(spec_dict["min"]) spec_max = float(spec_dict["max"]) if spec_min <= result <= spec_max: continue # check if in shoulder: out of range, but in acceptable # error percentage shoulder = False error = 0 try: error = float(spec_dict.get("error", "0")) except: error = 0 pass error_amount = (result / 100) * error error_min = result - error_amount error_max = result + error_amount if ((result < spec_min) and (error_max >= spec_min)) or ((result > spec_max) and (error_min <= spec_max)): shoulder = True dataline = [] dataitem = {"value": analysis.getClientTitle()} dataline.append(dataitem) dataitem = {"value": analysis.getRequestID()} dataline.append(dataitem) dataitem = {"value": analysis.aq_parent.getSampleTypeTitle()} dataline.append(dataitem) dataitem = {"value": analysis.aq_parent.getSamplePointTitle()} dataline.append(dataitem) dataitem = {"value": analysis.getCategoryTitle()} dataline.append(dataitem) dataitem = {"value": analysis.getServiceTitle()} dataline.append(dataitem) if shoulder: dataitem = {"value": analysis.getResult(), "img_after": "++resource++bika.lims.images/exclamation.png"} else: dataitem = {"value": analysis.getResult()} dataline.append(dataitem) dataitem = {"value": spec_dict["min"]} dataline.append(dataitem) dataitem = {"value": spec_dict["max"]} dataline.append(dataitem) state = wf_tool.getInfoFor(analysis, "review_state", "") review_state = wf_tool.getTitleForStateOnType(state, "Analysis") dataitem = {"value": review_state} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = {"value": _("Number of analyses out of range for period"), "colspan": 9, "class": "total_label"} footline.append(footitem) footitem = {"value": count_all} footline.append(footitem) footlines.append(footline) # report footer data footnotes = [] footline = [] footitem = { "value": _("Analysis result within error range"), "img_before": "++resource++bika.lims.images/exclamation.png", } footline.append(footitem) footnotes.append(footline) self.report_content = { "headings": headings, "parms": parms, "formats": formats, "datalines": datalines, "footings": footlines, "footnotes": footnotes, } title = self.context.translate(headings["header"]) return {"report_title": title, "report_data": self.template()}
def __call__(self): # get all the data into datalines bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times over time") headings['subheader'] = \ _("The turnaround time of analyses plotted over time") query = {'portal_type': 'Analysis'} if 'ServiceUID' in self.request.form: service_uid = self.request.form['ServiceUID'] query['ServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() parms.append( {'title': _('Analysis Service'), 'value': service_title, 'type': 'text'}) if 'Analyst' in self.request.form: analyst = self.request.form['Analyst'] query['getAnalyst'] = analyst analyst_title = self.user_fullname(analyst) parms.append( {'title': _('Analyst'), 'value': analyst_title, 'type': 'text'}) if 'getInstrumentUID' in self.request.form: instrument_uid = self.request.form['getInstrumentUID'] query['getInstrument'] = instrument_uid instrument = rc.lookupObject(instrument_uid) instrument_title = instrument.Title() parms.append( {'title': _('Instrument'), 'value': instrument_title, 'type': 'text'}) if 'Period' in self.request.form: period = self.request.form['Period'] else: period = 'Day' date_query = formatDateQuery(self.context, 'tats_DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'tats_DateReceived') parms.append( {'title': _('Received'), 'value': received, 'type': 'text'}) query['review_state'] = 'published' # query all the analyses and increment the counts periods = {} total_count = 0 total_duration = 0 analyses = bc(query) for a in analyses: analysis = a.getObject() received = analysis.created() if period == 'Day': datekey = received.strftime('%d %b %Y') elif period == 'Week': # key period on Monday dayofweek = received.strftime('%w') # Sunday = 0 if dayofweek == 0: firstday = received - 6 else: firstday = received - (int(dayofweek) - 1) datekey = firstday.strftime(self.date_format_short) elif period == 'Month': datekey = received.strftime('%m-%d') if datekey not in periods: periods[datekey] = {'count': 0, 'duration': 0, } count = periods[datekey]['count'] duration = periods[datekey]['duration'] count += 1 duration += analysis.getDuration() periods[datekey]['duration'] = duration periods[datekey]['count'] = count total_count += 1 total_duration += duration # calculate averages for datekey in periods.keys(): count = periods[datekey]['count'] duration = periods[datekey]['duration'] ave_duration = (duration) / count periods[datekey]['duration'] = \ formatDuration(self.context, ave_duration) # and now lets do the actual report lines formats = {'columns': 2, 'col_heads': [_('Date'), _('Turnaround time (h)'), ], 'class': '', } datalines = [] period_keys = periods.keys() for period in period_keys: dataline = [{'value': period, 'class': ''}, ] dataline.append({'value': periods[period]['duration'], 'class': 'number'}) datalines.append(dataline) if total_count > 0: ave_total_duration = total_duration / total_count else: ave_total_duration = 0 ave_total_duration = formatDuration(self.context, ave_total_duration) # footer data footlines = [] footline = [] footline = [{'value': _('Total data points'), 'class': 'total'}, ] footline.append({'value': total_count, 'class': 'total number'}) footlines.append(footline) footline = [{'value': _('Average TAT'), 'class': 'total'}, ] footline.append({'value': ave_total_duration, 'class': 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Date', 'Turnaround time (h)', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow({ 'Date': row[0]['value'], 'Turnaround time (h)': row[1]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader("Content-Disposition", "attachment;filename=\"analysesperservice_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return {'report_title': self.context.translate(headings['header']), 'report_data': self.template()}
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analyses per analysis service") headings['subheader'] = _( "Number of analyses requested per analysis service") query = {'portal_type': 'Analysis'} client_title = None if 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() if client_title: parms.append( {'title': _('Client'), 'value': client_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'Requested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'Requested') parms.append( {'title': _('Requested'), 'value': requested, 'type': 'text'}) date_query = formatDateQuery(self.context, 'Published') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'Published') parms.append( {'title': _('Published'), 'value': published, 'type': 'text'}) workflow = getToolByName(self.context, 'portal_workflow') if 'bika_analysis_workflow' in self.request.form: query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = workflow.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') parms.append( {'title': _('Status'), 'value': review_state, 'type': 'text'}) if 'bika_cancellation_workflow' in self.request.form: query['cancellation_state'] = self.request.form[ 'bika_cancellation_workflow'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') parms.append({'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append( {'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 2, 'col_heads': [_('Analysis service'), _('Number of analyses')], 'class': '', } datalines = [] count_all = 0 for cat in sc(portal_type="AnalysisCategory", sort_on='sortable_title'): dataline = [{'value': cat.Title, 'class': 'category_heading', 'colspan': 2}, ] datalines.append(dataline) for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on='sortable_title'): query['getServiceUID'] = service.UID analyses = bc(query) count_analyses = len(analyses) dataline = [] dataitem = {'value': service.Title} dataline.append(dataitem) dataitem = {'value': count_analyses} dataline.append(dataitem) datalines.append(dataline) count_all += count_analyses # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} title = t(headings['header']) if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Analysis Service', 'Analyses', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: if len(row) == 1: # category heading thingy continue dw.writerow({ 'Analysis Service': row[0]['value'], 'Analyses': row[1]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader("Content-Disposition", "attachment;filename=\"analysesperservice_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return {'report_title': title, 'report_data': self.template()}
def __call__(self): # get all the data into datalines bsc = getToolByName(self.context, 'bika_setup_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') localTimeFormat = self.context.portal_properties.site_properties.getProperty('localTimeFormat') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Results per sample point") headings['subheader'] = _("Analysis results per sample point and analysis service") count_all = 0 query = {'portal_type' : "Analysis", 'review_state': 'published', 'sort_on' : 'getDateAnalysisPublished'} if self.request.form.has_key('getSamplePointUID'): sp_uid = self.request.form['getSamplePointUID'] query['getSamplePointUID'] = sp_uid sp = rc.lookupObject(sp_uid) sp_title = sp.Title() else: sp_title = 'Undefined' parms.append( { 'title': _('Sample point'), 'value': sp_title, 'type': 'text'}) if self.request.form.has_key('getSampleTypeUID'): st_uid = self.request.form['getSampleTypeUID'] query['getSampleTypeUID'] = st_uid st = rc.lookupObject(st_uid) st_title = st.Title() else: st_title = 'Undefined' parms.append( { 'title': _('Sample type'), 'value': st_title, 'type': 'text'}) service_uids = [] if self.request.form.has_key('getServiceUID'): service_uid = self.request.form['getServiceUID'] query['getServiceUID'] = service_uid if type(service_uid) == str: # a single service was selected service_uids.append(service_uid) no_services = 1 else: # multiple services were selected service_uids = list(service_uid) no_services = len(service_uids) service_titles = [] service_values = {} service_counts = {} service_oor = {} # out of range service_joor = {} # just out of range service_keys = {} for service_uid in service_uids: service = rc.lookupObject(service_uid) service_titles.append('%s (%s)' \ %(service.Title(), service.getUnit())) service_values[service_uid] = [] service_counts[service_uid] = 0 service_oor[service_uid] = 0 service_joor[service_uid] = 0 service_keys[service_uid] = service.getKeyword() date_query = formatDateQuery(self.context, 'DateAnalysisPublished') if date_query: query['getDateAnalysisPublished'] = date_query published = formatDateParms(self.context, 'DateAnalysisPublished') else: published = 'Undefined' parms.append( { 'title': _('Published'), 'value': published, 'type': 'text'}) if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form['cancellation_state'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') else: cancellation_state = 'Undefined' parms.append( { 'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form['ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') else: ws_review_state = 'Undefined' parms.append( { 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # get the lab specs for these services specs = {} owner_uid = self.context.bika_setup.bika_analysisspecs.UID() proxies = bsc(portal_type = 'AnalysisSpec', getSampleTypeUID = st_uid, getClientUID = owner_uid) if len(proxies) > 0: spec_object = proxies[0].getObject() results_range = spec_object.getResultsRangeDict() for service_uid in service_uids: keyword = service_keys[service_uid] if results_range.has_key(keyword): specs[service_uid] = results_range[keyword] # and now lets do the actual report lines formats = {'columns': no_services + 1, 'col_heads': [' ',] + service_titles, 'class': '', } datalines = [] dataline = [] dataline = [{'value':'Specification minimum', 'class':'colhead'}, ] for service_uid in service_uids: dataline.append({'value': specs[service_uid]['min'], 'class':'colhead number'}) datalines.append(dataline) dataline = [{'value':'Specification maximum', 'class':'colhead'}, ] for service_uid in service_uids: dataline.append({'value': specs[service_uid]['max'], 'class':'colhead number'}) datalines.append(dataline) current = None first = True def loadlines(): more = True while more: thisline = [{'value': current},] more = False for service_uid in service_uids: if service_values[service_uid]: item = service_values[service_uid].pop(0) if service_values[service_uid]: more = True thisline.append(item) else: thisline.append({'value': '-'}) datalines.append(thisline) joor_img = '++resource++bika.lims.images/warning.png' oor_img = '++resource++bika.lims.images/exclamation.png' for a_proxy in bac(query): analysis = a_proxy.getObject() this_service = analysis.getServiceUID() pubdate = analysis.getDateAnalysisPublished() published = pubdate.strftime('%d %b %Y') if first: current = published first = False if published != current: # print the previous date loadlines() current = published if analysis.getResult(): try: result = float(analysis.getResult()) except: continue dataitem = {'value': analysis.getResult(), 'class': 'number'} # check if in range if specs.has_key(this_service): spec_min = float(specs[this_service]['min']) spec_max = float(specs[this_service]['max']) spec_error = float(specs[this_service]['error']) if spec_min < result < spec_max: pass else: # check if in shoulder: out of range, # but in acceptable error percentage error_amount = (result / 100) * spec_error error_min = result - error_amount error_max = result + error_amount if ((result < spec_min) and (error_max >= spec_min)) or \ ((result > spec_max) and (error_min <= spec_max)): dataitem['img_before'] = joor_img service_joor[this_service] += 1 else: dataitem['img_before'] = oor_img service_oor[this_service] += 1 service_values[this_service].append(dataitem) service_counts[this_service] += 1 # include the last one loadlines() # footer data footlines = [] footline = [] footitem = {'value': _('Total analyses out of range'), 'colspan': 1, 'class': 'total_label'} footline.append(footitem) for service_uid in service_uids: footitem = {'value': service_oor[service_uid], 'class': 'number'} footline.append(footitem) footlines.append(footline) footline = [] footitem = {'value': _('Total analyses within error range'), 'colspan': 1, 'class': 'total_label'} footline.append(footitem) for service_uid in service_uids: footitem = {'value': service_joor[service_uid], 'class': 'number'} footline.append(footitem) footlines.append(footline) footline = [] footitem = {'value': _('Total number of analyses'), 'colspan': 1, 'class': 'total_label'} footline.append(footitem) for service_uid in service_uids: footitem = {'value': service_counts[service_uid], 'class': 'number'} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return self.template()
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Attachments") headings['subheader'] = _("The attachments linked to analysis requests and analyses") count_all = 0 query = {'portal_type': 'Attachment'} if self.request.form.has_key('ClientUID'): client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = 'Undefined' parms.append( { 'title': _('Client'), 'value': client_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'Loaded') if date_query: query['getDateLoaded'] = date_query loaded = formatDateParms(self.context, 'Loaded') else: loaded = 'Undefined' parms.append( { 'title': _('Loaded'), 'value': loaded, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 6, 'col_heads': [ _('Request'), \ _('File'), \ _('Attachment type'), \ _('Content type'), \ _('Size'), \ _('Loaded'), \ ], 'class': '', } datalines = [] attachments = pc(query) for a_proxy in attachments: attachment = a_proxy.getObject() attachment_file = attachment.getAttachmentFile() icon = attachment_file.getBestIcon() filename = attachment_file.filename filesize = attachment_file.get_size() filesize = filesize / 1024 sizeunit = "Kb" if filesize > 1024: filesize = filesize / 1024 sizeunit = "Mb" dateloaded = attachment.getDateLoaded() dataline = [] dataitem = {'value': attachment.getTextTitle()} dataline.append(dataitem) dataitem = {'value': filename, 'img_before': icon} dataline.append(dataitem) dataitem = {'value': attachment.getAttachmentType().Title()} dataline.append(dataitem) dataitem = {'value': self.context.lookupMime(attachment_file.getContentType())} dataline.append(dataitem) dataitem = {'value': '%s%s' %(filesize, sizeunit)} dataline.append(dataitem) dataitem = {'value': self.ulocalized_time(dateloaded)} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'colspan': 5, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return {'report_title': self.context.translate(headings['header']), 'report_data': self.template()}
def __call__(self): # get all the data into datalines bc = getToolByName(self.context, "bika_analysis_catalog") rc = getToolByName(self.context, "reference_catalog") self.report_content = {} parms = [] headings = {} headings["header"] = _("Analysis turnaround times over time") headings["subheader"] = _("The turnaround time of analyses plotted over time") query = {"portal_type": "Analysis"} if "ServiceUID" in self.request.form: service_uid = self.request.form["ServiceUID"] query["ServiceUID"] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() parms.append({"title": _("Analysis Service"), "value": service_title, "type": "text"}) if "Analyst" in self.request.form: analyst = self.request.form["Analyst"] query["getAnalyst"] = analyst analyst_title = self.user_fullname(analyst) parms.append({"title": _("Analyst"), "value": analyst_title, "type": "text"}) if "getInstrumentUID" in self.request.form: instrument_uid = self.request.form["getInstrumentUID"] query["getInstrument"] = instrument_uid instrument = rc.lookupObject(instrument_uid) instrument_title = instrument.Title() parms.append({"title": _("Instrument"), "value": instrument_title, "type": "text"}) if "Period" in self.request.form: period = self.request.form["Period"] else: period = "Day" date_query = formatDateQuery(self.context, "tats_DateReceived") if date_query: query["created"] = date_query received = formatDateParms(self.context, "tats_DateReceived") parms.append({"title": _("Received"), "value": received, "type": "text"}) query["review_state"] = "published" # query all the analyses and increment the counts periods = {} total_count = 0 total_duration = 0 analyses = bc(query) for a in analyses: analysis = a.getObject() received = analysis.created() if period == "Day": datekey = received.strftime("%d %b %Y") elif period == "Week": # key period on Monday dayofweek = received.strftime("%w") # Sunday = 0 if dayofweek == 0: firstday = received - 6 else: firstday = received - (int(dayofweek) - 1) datekey = firstday.strftime(self.date_format_short) elif period == "Month": datekey = received.strftime("%m-%d") if datekey not in periods: periods[datekey] = {"count": 0, "duration": 0} count = periods[datekey]["count"] duration = periods[datekey]["duration"] count += 1 duration += analysis.getDuration() periods[datekey]["duration"] = duration periods[datekey]["count"] = count total_count += 1 total_duration += duration # calculate averages for datekey in periods.keys(): count = periods[datekey]["count"] duration = periods[datekey]["duration"] ave_duration = (duration) / count periods[datekey]["duration"] = formatDuration(self.context, ave_duration) # and now lets do the actual report lines formats = {"columns": 2, "col_heads": [_("Date"), _("Turnaround time (h)")], "class": ""} datalines = [] period_keys = periods.keys() for period in period_keys: dataline = [{"value": period, "class": ""}] dataline.append({"value": periods[period]["duration"], "class": "number"}) datalines.append(dataline) if total_count > 0: ave_total_duration = total_duration / total_count else: ave_total_duration = 0 ave_total_duration = formatDuration(self.context, ave_total_duration) # footer data footlines = [] footline = [] footline = [{"value": _("Total data points"), "class": "total"}] footline.append({"value": total_count, "class": "total number"}) footlines.append(footline) footline = [{"value": _("Average TAT"), "class": "total"}] footline.append({"value": ave_total_duration, "class": "total number"}) footlines.append(footline) self.report_content = { "headings": headings, "parms": parms, "formats": formats, "datalines": datalines, "footings": footlines, } if self.request.get("output_format", "") == "CSV": import csv import StringIO import datetime fieldnames = ["Date", "Turnaround time (h)"] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction="ignore", fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow({"Date": row[0]["value"], "Turnaround time (h)": row[1]["value"]}) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader("Content-Type", "text/csv") setheader("Content-Disposition", 'attachment;filename="analysesperservice_%s.csv"' % date) self.request.RESPONSE.write(report_data) else: return {"report_title": t(headings["header"]), "report_data": self.template()}
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, "bika_setup_catalog") bc = getToolByName(self.context, "bika_analysis_catalog") rc = getToolByName(self.context, "reference_catalog") self.report_content = {} parm_lines = {} parms = [] headings = {} headings["header"] = _("Analysis turnaround times") headings["subheader"] = _("The turnaround time of analyses") count_all = 0 query = {"portal_type": "Analysis"} if self.request.form.has_key("ClientUID"): client_uid = self.request.form["ClientUID"] query["getClientUID"] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query["getClientUID"] = client.UID() else: client_title = "Undefined" parms.append({"title": _("Client"), "value": client_title, "type": "text"}) date_query = formatDateQuery(self.context, "Received") if date_query: query["created"] = date_query received = formatDateParms(self.context, "Received") else: received = "Undefined" parms.append({"title": _("Received"), "value": received, "type": "text"}) query["review_state"] = "published" workflow = getToolByName(self.context, "portal_workflow") if self.request.form.has_key("bika_worksheetanalysis_workflow"): query["worksheetanalysis_review_state"] = self.request.form["bika_worksheetanalysis_workflow"] ws_review_state = workflow.getTitleForStateOnType( self.request.form["bika_worksheetanalysis_workflow"], "Analysis" ) parms.append({"title": _("Assigned to worksheet"), "value": ws_review_state, "type": "text"}) # query all the analyses and increment the counts count_early = 0 mins_early = 0 count_late = 0 mins_late = 0 count_undefined = 0 services = {} analyses = bc(query) for a in analyses: analysis = a.getObject() service_uid = analysis.getServiceUID() if not services.has_key(service_uid): services[service_uid] = { "count_early": 0, "count_late": 0, "mins_early": 0, "mins_late": 0, "count_undefined": 0, } earliness = analysis.getEarliness() if earliness < 0: count_late = services[service_uid]["count_late"] mins_late = services[service_uid]["mins_late"] count_late += 1 mins_late -= earliness services[service_uid]["count_late"] = count_late services[service_uid]["mins_late"] = mins_late if earliness > 0: count_early = services[service_uid]["count_early"] mins_early = services[service_uid]["mins_early"] count_early += 1 mins_early += earliness services[service_uid]["count_early"] = count_early services[service_uid]["mins_early"] = mins_early if earliness == 0: count_undefined = services[service_uid]["count_undefined"] count_undefined += 1 services[service_uid]["count_undefined"] = count_undefined # calculate averages for service_uid in services.keys(): count_early = services[service_uid]["count_early"] mins_early = services[service_uid]["mins_early"] if count_early == 0: services[service_uid]["ave_early"] = "" else: avemins = (mins_early) / count_early services[service_uid]["ave_early"] = formatDuration(self.context, avemins) count_late = services[service_uid]["count_late"] mins_late = services[service_uid]["mins_late"] if count_late == 0: services[service_uid]["ave_late"] = "" else: avemins = mins_late / count_late services[service_uid]["ave_late"] = formatDuration(self.context, avemins) # and now lets do the actual report lines formats = { "columns": 7, "col_heads": [ _("Analysis"), _("Count"), _("Undefined"), _("Late"), _("Average late"), _("Early"), _("Average early"), ], "class": "", } total_count_early = 0 total_count_late = 0 total_mins_early = 0 total_mins_late = 0 total_count_undefined = 0 datalines = [] for cat in sc(portal_type="AnalysisCategory", sort_on="sortable_title"): catline = [{"value": cat.Title, "class": "category_heading", "colspan": 7}] first_time = True cat_count_early = 0 cat_count_late = 0 cat_count_undefined = 0 cat_mins_early = 0 cat_mins_late = 0 for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on="sortable_title"): dataline = [{"value": service.Title, "class": "testgreen"}] if not services.has_key(service.UID): continue if first_time: datalines.append(catline) first_time = False # analyses found cat_count_early += services[service.UID]["count_early"] cat_count_late += services[service.UID]["count_late"] cat_count_undefined += services[service.UID]["count_undefined"] cat_mins_early += services[service.UID]["mins_early"] cat_mins_late += services[service.UID]["mins_late"] count = ( services[service.UID]["count_early"] + services[service.UID]["count_late"] + services[service.UID]["count_undefined"] ) dataline.append({"value": count, "class": "number"}) dataline.append({"value": services[service.UID]["count_undefined"], "class": "number"}) dataline.append({"value": services[service.UID]["count_late"], "class": "number"}) dataline.append({"value": services[service.UID]["ave_late"], "class": "number"}) dataline.append({"value": services[service.UID]["count_early"], "class": "number"}) dataline.append({"value": services[service.UID]["ave_early"], "class": "number"}) datalines.append(dataline) # category totals dataline = [{"value": "%s - total" % (cat.Title), "class": "subtotal_label"}] dataline.append( {"value": cat_count_early + cat_count_late + cat_count_undefined, "class": "subtotal_number"} ) dataline.append({"value": cat_count_undefined, "class": "subtotal_number"}) dataline.append({"value": cat_count_late, "class": "subtotal_number"}) if cat_count_late: dataitem = {"value": cat_mins_late / cat_count_late, "class": "subtotal_number"} else: dataitem = {"value": 0, "class": "subtotal_number"} dataline.append(dataitem) dataline.append({"value": cat_count_early, "class": "subtotal_number"}) if cat_count_early: dataitem = {"value": cat_mins_early / cat_count_early, "class": "subtotal_number"} else: dataitem = {"value": 0, "class": "subtotal_number"} dataline.append(dataitem) total_count_early += cat_count_early total_count_late += cat_count_late total_count_undefined += cat_count_undefined total_mins_early += cat_mins_early total_mins_late += cat_mins_late # footer data footlines = [] footline = [] footline = [{"value": _("Total"), "class": "total"}] footline.append( {"value": total_count_early + total_count_late + total_count_undefined, "class": "total number"} ) footline.append({"value": total_count_undefined, "class": "total number"}) footline.append({"value": total_count_late, "class": "total number"}) if total_count_late: ave_mins = total_mins_late / total_count_late footline.append({"value": formatDuration(self.context, ave_mins), "class": "total number"}) else: footline.append({"value": ""}) footline.append({"value": total_count_early, "class": "total number"}) if total_count_early: ave_mins = total_mins_early / total_count_early footline.append({"value": formatDuration(self.context, ave_mins), "class": "total number"}) else: footline.append({"value": "", "class": "total number"}) footlines.append(footline) self.report_content = { "headings": headings, "parms": parms, "formats": formats, "datalines": datalines, "footings": footlines, } title = self.context.translate(headings["header"]) return {"report_title": title, "report_data": self.template()}
def __call__(self): # get all the data into datalines bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times over time") headings['subheader'] = \ _("The turnaround time of analyses plotted over time") query = {'portal_type': 'Analysis'} if 'ServiceUID' in self.request.form: service_uid = self.request.form['ServiceUID'] query['getServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() parms.append({ 'title': _('Analysis Service'), 'value': service_title, 'type': 'text' }) if 'Analyst' in self.request.form: analyst = self.request.form['Analyst'] query['getAnalyst'] = analyst analyst_title = self.user_fullname(analyst) parms.append({ 'title': _('Analyst'), 'value': analyst_title, 'type': 'text' }) if 'getInstrumentUID' in self.request.form: instrument_uid = self.request.form['getInstrumentUID'] query['getInstrument'] = instrument_uid instrument = rc.lookupObject(instrument_uid) instrument_title = instrument.Title() parms.append({ 'title': _('Instrument'), 'value': instrument_title, 'type': 'text' }) if 'Period' in self.request.form: period = self.request.form['Period'] else: period = 'Day' date_query = formatDateQuery(self.context, 'tats_DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'tats_DateReceived') parms.append({ 'title': _('Received'), 'value': received, 'type': 'text' }) query['review_state'] = 'published' # query all the analyses and increment the counts analysis_list = [] analyses = bc(query) import datetime for a in analyses: analysis = a.getObject() analysis_list.append( {'analysis_id': analysis.id, 'duration': str(datetime.timedelta(seconds=analysis.getDuration())), 'overtime': self.formatOvertime(int(round((DT2dt(DateTime.DateTime(analysis.getDueDate())) - \ DT2dt(DateTime.DateTime(analysis.getDateAnalysisPublished()))) \ .total_seconds()))) } ) # and now lets do the actual report lines formats = { 'columns': 3, 'col_heads': [ _('Analysis'), _('Duration'), _('Overtime'), ], 'class': '' } datalines = [] for al in analysis_list: dataline = [{'value': al['analysis_id'], 'class': ''}] dataline.append({'value': al['duration'], 'class': 'number'}) dataline.append({'value': al['overtime'], 'class': 'number'}) datalines.append(dataline) # footer data footlines = [] footline = [] footline = [ { 'value': _('Total number of analysis'), 'class': 'total' }, ] footline.append({ 'value': len(analysis_list), 'colspan': 2, 'class': 'total number' }) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Analysis', 'Duration', 'Overtime', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow({ 'Analysis': row[0]['value'], 'Duration': row[1]['value'], 'Overtime': row[2]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader("Content-Disposition", "attachment;filename=\"analysestats_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return { 'report_title': t(headings['header']), 'report_data': self.template() }
def __call__(self): self.datalines = [] workflow = getToolByName(self, 'portal_workflow') # check for batch size if self.request.form.has_key('size'): batch_size = self.request.form['size'] else: batch_size = 6 # check for batch start if self.request.form.has_key('b_start'): batch_start = self.request.form['b_start'] else: batch_start = 0 sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.query_content = {} parm_lines = {} self.parms = [] self.headings = {} self.headings['header'] = _("Analysis Requests") self.headings['head_parms'] = _("Selected on the following criteria") self.headings['head_undefined'] = _("Parameters undefined") count_all = 0 query = {'portal_type': 'AnalysisRequest'} undefined = [] # Client client_title = None if self.request.form.has_key('ClientUID'): client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() if client_title: self.parms.append({ 'title': _('Client'), 'fieldid': 'ClientUID', 'value': client_title, 'type': 'text' }) else: undefined.append('Client') # Contact if self.request.form.has_key('ContactUID'): contact_uid = self.request.form['ContactUID'] query['getContactUID'] = contact_uid contact = rc.lookupObject(contact_uid) contact_name = contact.getFullname() self.parms.append({ 'title': _('Contact'), 'fieldid': 'ContactUID', 'value': contact_name, 'type': 'text' }) else: undefined.append('Contact') # Profile if self.request.form.has_key('ProfileUID'): profile_uid = self.request.form['ProfileUID'] query['getAnalysisProfileUID'] = profile_uid profile = rc.lookupObject(profile_uid) profile_title = profile.Title() self.parms.append({ 'title': _('Profile'), 'value': profile_title, 'type': 'text' }) else: undefined.append('Profile') # Request ID if self.request.form.has_key('RequestID'): request_id = self.request.form['RequestID'] query['getRequestID'] = request_id self.parms.append({ 'title': _('AR'), 'value': request_id, 'type': 'text' }) else: undefined.append('AR') # Client order number if self.request.form.has_key('ClientOrderNumber'): clientoid = self.request.form['ClientOrderNumber'] query['getClientOrderNumber'] = clientoid self.parms.append({ 'title': _('Client order number'), 'value': clientoid, 'type': 'text' }) else: undefined.append('Client order number') # Client reference if self.request.form.has_key('ClientReference'): clientref = self.request.form['ClientReference'] query['getClientReference'] = clientref self.parms.append({ 'title': _('Client reference'), 'value': clientref, 'type': 'text' }) else: undefined.append('Client reference') # Client sample ID if self.request.form.has_key('ClientSampleID'): clientsid = self.request.form['ClientSampleID'] query['getClientSampleID'] = clientsid self.parms.append({ 'title': _('Client sample ID'), 'value': clientsid, 'type': 'text' }) else: undefined.append('Client sample ID') # Sample type if self.request.form.has_key('SampleTypeUID'): st_uid = self.request.form['SampleTypeUID'] query['getSampleTypeUID'] = st_uid st = rc.lookupObject(st_uid) st_title = st.Title() self.parms.append({ 'title': _('Sample type'), 'value': st_title, 'type': 'text' }) else: undefined.append('Sample type') # Sample point if self.request.form.has_key('SamplePointUID'): sp_uid = self.request.form['SamplePointUID'] query['getSamplePointUID'] = sp_uid sp = rc.lookupObject(sp_uid) sp_title = sp.Title() self.parms.append({ 'title': _('Sample point'), 'value': sp_title, 'type': 'text' }) else: undefined.append('Sample point') # Date sampled date_query = formatDateQuery(self.context, 'DateSampled') if date_query: query['created'] = date_query sampled = formatDateParms(self.context, 'DateSampled') self.parms.append({ 'title': _('Sampled'), 'value': sampled, 'type': 'text' }) else: undefined.append('Sampled') # Date requested date_query = formatDateQuery(self.context, 'DateRequested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'DateRequested') self.parms.append({ 'title': _('Requested'), 'value': requested, 'type': 'text' }) else: undefined.append('Requested') # Date received date_query = formatDateQuery(self.context, 'DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'DateReceived') self.parms.append({ 'title': _('Received'), 'value': received, 'type': 'text' }) else: undefined.append('Received') # Date published date_query = formatDateQuery(self.context, 'DatePublished') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'DatePublished') self.parms.append({ 'title': _('Published'), 'value': published, 'type': 'text' }) else: undefined.append('Published') # Category if self.request.form.has_key('CategoryUID'): category_uid = self.request.form['CategoryUID'] query['getCategoryUID'] = category_uid category = rc.lookupObject(category_uid) category_title = category.Title() self.parms.append({ 'title': _('Category'), 'value': category_title, 'type': 'text' }) else: undefined.append('Category') # Analysis service if self.request.form.has_key('ServiceUID'): service_uid = self.request.form['ServiceUID'] query['getServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() self.parms.append({ 'title': _('Analysis service'), 'value': service_title, 'type': 'text' }) else: undefined.append('Analysis service') # Analyst if self.request.form.has_key('Analyst'): analyst = self.request.form['Analyst'] query['getAnalyst'] = analyst analyst_name = self.user_fullname(analyst) self.parms.append({ 'title': _('Analyst'), 'value': analyst_name, 'type': 'text' }) else: undefined.append('Analyst') # Status if self.request.form.has_key('review_state'): query['review_state'] = self.request.form['review_state'] review_state = workflow.getTitleForStateOnType( self.request.form['review_state'], 'Analysis') self.parms.append({ 'title': _('Status'), 'value': review_state, 'type': 'text' }) else: undefined.append('Status') # Cancellation state if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form[ 'cancellation_state'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') self.parms.append({ 'title': _('Active'), 'value': cancellation_state, 'type': 'text' }) else: undefined.append('Active') # Assigned to worksheet if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form[ 'ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') self.parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) else: undefined.append('Assigned to worksheet') # set up the undefined parameters in pretty format undefined_string = ', '.join(undefined) self.parms_undefined = [{ 'title': _('Parameters not defined'), 'value': undefined_string }] self.columns = batch_size + 1 # and now lets do the actual query lines self.formats = { 'columns': self.columns, 'col_heads': [], 'class': '', } labels = [ "Client order ID", "Client reference", "Client sample ID", "Client", "Contact", "Request ID", "Sample ID", "Profile", "Sample type", "Sample point", "Sampled", "Requested", "Received", "Published", "Status", "Submitted by", "Verified by" ] for label in labels: self.datalines.append([{ 'value': _(label), 'class': 'header', }]) details = [] for i in range(len(self.datalines)): details.append([]) ars = bc(query) self.url = self.request.URL self.show_all = False self.batch = Batch(ars, batch_size, batch_start) analyses = [] analysis_dict = {} service_dict = {} ar_ids = [] for arp in self.batch: ar = arp.getObject() ar_ids.append(ar.getRequestID()) details[0].append({'value': ar.getClientOrderNumber()}) details[1].append({'value': ar.getClientReference()}) details[2].append({'value': ar.getClientSampleID()}) details[3].append({'value': ar.aq_parent.Title()}) details[4].append({'value': ar.getContact().Title()}) details[5].append({'value': ar.getRequestID()}) details[6].append({'value': ar.getSample().getSampleID()}) details[7].append( {'value': ar.getProfile() and ar.getProfile().Title() or ' '}) details[8].append({'value': ar.getSampleTypeTitle()}) details[10].append({ 'value': self.ulocalized_time(ar.getSample().getDateSampled()) }) details[11].append({'value': self.ulocalized_time(ar.created())}) details[12].append( {'value': self.ulocalized_time(ar.getDateReceived())}) details[13].append( {'value': self.ulocalized_time(ar.getDatePublished())}) details[14].append( {'value': workflow.getInfoFor(ar, 'review_state')}) #details[15].append({'value': ar.getSubmittedBy().Title()}) details[15].append({'value': ' '}) #details[16].append({'value': ar.get_verifier().Title()}) details[16].append({'value': ' '}) #analyses for analysis in ar.getAnalyses(full_objects=True): service_uid = analysis.getServiceUID() if not analysis_dict.has_key(service_uid): service_dict[analysis.Title()] = service_uid analysis_dict[service_uid] = {} analysis_dict[service_uid][ ar.getRequestID()] = analysis.getResult() if len(details[0]) == batch_size: break # load the detail lines for i in range(len(self.datalines)): self.datalines[i].extend(details[i]) # load the analysis lines service_titles = service_dict.keys() service_titles.sort() for service_title in service_titles: service_uid = service_dict[service_title] analysis_line = [ { 'value': service_title }, ] for ar_id in ar_ids: if analysis_dict[service_uid].has_key(ar_id): analysis_line.append( {'value': analysis_dict[service_uid][ar_id]}) else: analysis_line.append({}) self.datalines.append(analysis_line) # footer data self.footlines = [] footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) self.footlines.append(footline) return self.template()
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') pc = getToolByName(self.context, 'portal_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analyses per analysis service") headings['subheader'] = _( "Number of analyses requested per analysis service") count_all = 0 query = {'portal_type': 'Analysis'} if self.request.form.has_key('getClientUID'): client_uid = self.request.form['getClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client_title = 'Undefined' parms.append({ 'title': _('Client'), 'value': client_title, 'type': 'text' }) date_query = formatDateQuery(self.context, 'DateRequested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'DateRequested') else: requested = 'Undefined' parms.append({ 'title': _('Requested'), 'value': requested, 'type': 'text' }) date_query = formatDateQuery(self.context, 'DatePublished') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'DatePublished') else: published = 'Undefined' parms.append({ 'title': _('Published'), 'value': published, 'type': 'text' }) workflow = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('review_state'): query['review_state'] = self.request.form['review_state'] review_state = workflow.getTitleForStateOnType( self.request.form['review_state'], 'Analysis') else: review_state = 'Undefined' parms.append({ 'title': _('Status'), 'value': review_state, 'type': 'text' }) if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form[ 'cancellation_state'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') else: cancellation_state = 'Undefined' parms.append({ 'title': _('Active'), 'value': cancellation_state, 'type': 'text' }) if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form[ 'ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') else: ws_review_state = 'Undefined' parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) datalines = [] for cat in sc(portal_type="AnalysisCategory", sort_on='sortable_title'): service_data = [] for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on='sortable_title'): query['getServiceUID'] = service.UID analyses = pc(query) count_analyses = len(analyses) service_data.append([service.Title, count_analyses]) count_all += count_analyses datalines.append([cat.Title, service_data]) self.report_content = { 'headings': headings, 'parms': parms, 'datalines': datalines, 'total': count_all } return self.template()
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times") headings['subheader'] = _("The turnaround time of analyses") query = {'portal_type': 'Analysis'} client_title = None if 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() if client_title: parms.append({ 'title': _('Client'), 'value': client_title, 'type': 'text' }) date_query = formatDateQuery(self.context, 'Received') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'Received') parms.append({ 'title': _('Received'), 'value': received, 'type': 'text' }) query['review_state'] = 'published' workflow = getToolByName(self.context, 'portal_workflow') if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) # query all the analyses and increment the counts count_early = 0 mins_early = 0 count_late = 0 mins_late = 0 count_undefined = 0 services = {} analyses = bc(query) for a in analyses: analysis = a.getObject() service_uid = analysis.getServiceUID() if service_uid not in services: services[service_uid] = { 'count_early': 0, 'count_late': 0, 'mins_early': 0, 'mins_late': 0, 'count_undefined': 0, } earliness = analysis.getEarliness() if earliness < 0: count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] count_late += 1 mins_late -= earliness services[service_uid]['count_late'] = count_late services[service_uid]['mins_late'] = mins_late if earliness > 0: count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] count_early += 1 mins_early += earliness services[service_uid]['count_early'] = count_early services[service_uid]['mins_early'] = mins_early if earliness == 0: count_undefined = services[service_uid]['count_undefined'] count_undefined += 1 services[service_uid]['count_undefined'] = count_undefined # calculate averages for service_uid in services.keys(): count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] if count_early == 0: services[service_uid]['ave_early'] = '' else: avemins = (mins_early) / count_early services[service_uid]['ave_early'] = formatDuration( self.context, avemins) count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] if count_late == 0: services[service_uid]['ave_late'] = '' else: avemins = mins_late / count_late services[service_uid]['ave_late'] = formatDuration( self.context, avemins) # and now lets do the actual report lines formats = { 'columns': 7, 'col_heads': [ _('Analysis'), _('Count'), _('Undefined'), _('Late'), _('Average late'), _('Early'), _('Average early'), ], 'class': '', } total_count_early = 0 total_count_late = 0 total_mins_early = 0 total_mins_late = 0 total_count_undefined = 0 datalines = [] for cat in sc(portal_type='AnalysisCategory', sort_on='sortable_title'): catline = [ { 'value': cat.Title, 'class': 'category_heading', 'colspan': 7 }, ] first_time = True cat_count_early = 0 cat_count_late = 0 cat_count_undefined = 0 cat_mins_early = 0 cat_mins_late = 0 for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on='sortable_title'): dataline = [ { 'value': service.Title, 'class': 'testgreen' }, ] if service.UID not in services: continue if first_time: datalines.append(catline) first_time = False # analyses found cat_count_early += services[service.UID]['count_early'] cat_count_late += services[service.UID]['count_late'] cat_count_undefined += services[service.UID]['count_undefined'] cat_mins_early += services[service.UID]['mins_early'] cat_mins_late += services[service.UID]['mins_late'] count = services[service.UID]['count_early'] + \ services[service.UID]['count_late'] + \ services[service.UID]['count_undefined'] dataline.append({'value': count, 'class': 'number'}) dataline.append({ 'value': services[service.UID]['count_undefined'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['count_late'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['ave_late'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['count_early'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['ave_early'], 'class': 'number' }) datalines.append(dataline) # category totals dataline = [ { 'value': '%s - total' % (cat.Title), 'class': 'subtotal_label' }, ] dataline.append({ 'value': cat_count_early + cat_count_late + cat_count_undefined, 'class': 'subtotal_number' }) dataline.append({ 'value': cat_count_undefined, 'class': 'subtotal_number' }) dataline.append({ 'value': cat_count_late, 'class': 'subtotal_number' }) if cat_count_late: dataitem = { 'value': cat_mins_late / cat_count_late, 'class': 'subtotal_number' } else: dataitem = {'value': 0, 'class': 'subtotal_number'} dataline.append(dataitem) dataline.append({ 'value': cat_count_early, 'class': 'subtotal_number' }) if cat_count_early: dataitem = { 'value': cat_mins_early / cat_count_early, 'class': 'subtotal_number' } else: dataitem = {'value': 0, 'class': 'subtotal_number'} dataline.append(dataitem) total_count_early += cat_count_early total_count_late += cat_count_late total_count_undefined += cat_count_undefined total_mins_early += cat_mins_early total_mins_late += cat_mins_late # footer data footlines = [] footline = [] footline = [ { 'value': _('Total'), 'class': 'total' }, ] footline.append({ 'value': total_count_early + total_count_late + total_count_undefined, 'class': 'total number' }) footline.append({ 'value': total_count_undefined, 'class': 'total number' }) footline.append({'value': total_count_late, 'class': 'total number'}) if total_count_late: ave_mins = total_mins_late / total_count_late footline.append({ 'value': formatDuration(self.context, ave_mins), 'class': 'total number' }) else: footline.append({'value': ''}) footline.append({'value': total_count_early, 'class': 'total number'}) if total_count_early: ave_mins = total_mins_early / total_count_early footline.append({ 'value': formatDuration(self.context, ave_mins), 'class': 'total number' }) else: footline.append({'value': '', 'class': 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Analysis', 'Count', 'Undefined', 'Late', 'Average late', 'Early', 'Average early', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: if len(row) == 1: # category heading thingy continue dw.writerow({ 'Analysis': row[0]['value'], 'Count': row[1]['value'], 'Undefined': row[2]['value'], 'Late': row[3]['value'], 'Average late': row[4]['value'], 'Early': row[5]['value'], 'Average early': row[6]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader("Content-Disposition", "attachment;filename=\"analysestats_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return { 'report_title': self.context.translate(headings['header']), 'report_data': self.template() }
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.query_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analysis Requests") headings['subheader'] = _("Selected on the following criteria") count_all = 0 query = {'portal_type': 'AnalysisRequest'} if self.request.form.has_key('getClientUID'): client_uid = self.request.form['getClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = 'Undefined' parms.append( { 'title': _('Client'), 'value': client_title, 'type': 'text'}) if self.request.form.has_key('getContactUID'): contact_uid = self.request.form['getContactUID'] query['getContactUID'] = contact_uid contact = rc.lookupObject(contact_uid) contact_name = contact.getFullname() else: contact_name = 'Undefined' parms.append( { 'title': _('Contact'), 'value': contact_name, 'type': 'text'}) if self.request.form.has_key('getARProfileUID'): profile_uid = self.request.form['getARProfileUID'] query['getARProfileUID'] = profile_uid profile = rc.lookupObject(profile_uid) profile_title = profile.Title() else: profile_title = 'Undefined' parms.append( { 'title': _('Profile'), 'value': profile_title, 'type': 'text'}) if self.request.form.has_key('RequestID'): request_id = self.request.form['RequestID'] query['getRequestID'] = request_id else: request_id = 'Undefined' parms.append( { 'title': _('AR'), 'value': request_id, 'type': 'text'}) if self.request.form.has_key('ClientOrderNumber'): clientordernumber = self.request.form['ClientOrderNumber'] query['getClientOrderNumber'] = clientordernumber else: clientordernumber = 'Undefined' parms.append( { 'title': _('Client order number'), 'value': clientordernumber, 'type': 'text'}) if self.request.form.has_key('ClientReference'): clientref = self.request.form['ClientReference'] query['getClientReference'] = clientref else: clientref = 'Undefined' parms.append( { 'title': _('Client reference'), 'value': clientref, 'type': 'text'}) if self.request.form.has_key('ClientSampleID'): clientsid = self.request.form['ClientSampleID'] query['getClientSampleID'] = clientsid else: clientsid = 'Undefined' parms.append( { 'title': _('Client sample ID'), 'value': clientsid, 'type': 'text'}) if self.request.form.has_key('SampleTypeUID'): st_uid = self.request.form['SampleTypeUID'] query['getSampleTypeUID'] = st_uid st = rc.lookupObject(st_uid) st_title = st.Title() else: st_title = 'Undefined' parms.append( { 'title': _('Sample type'), 'value': st_title, 'type': 'text'}) if self.request.form.has_key('SamplePointUID'): sp_uid = self.request.form['SamplePointUID'] query['getSamplePointUID'] = sp_uid sp = rc.lookupObject(sp_uid) sp_title = sp.Title() else: sp_title = 'Undefined' parms.append( { 'title': _('Sample point'), 'value': sp_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DateSampled') if date_query: query['created'] = date_query sampled = formatDateParms(self.context, 'DateSampled') else: sampled = 'Undefined' parms.append( { 'title': _('Sampled'), 'value': sampled, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DateRequested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'DateRequested') else: requested = 'Undefined' parms.append( { 'title': _('Requested'), 'value': requested, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'DateReceived') else: received = 'Undefined' parms.append( { 'title': _('Received'), 'value': received, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DatePublished') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'DatePublished') else: published = 'Undefined' parms.append( { 'title': _('Published'), 'value': published, 'type': 'text'}) if self.request.form.has_key('CategoryUID'): category_uid = self.request.form['CategoryUID'] query['getCategoryUID'] = category_uid category = rc.lookupObject(category_uid) category_title = category.Title() else: category_title = 'Undefined' parms.append( { 'title': _('Category'), 'value': category_title, 'type': 'text'}) if self.request.form.has_key('ServiceUID'): service_uid = self.request.form['ServiceUID'] query['getServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() else: service_title = 'Undefined' parms.append( { 'title': _('Analysis service'), 'value': service_title, 'type': 'text'}) if self.request.form.has_key('SubmittedByUID'): submittedby_uid = self.request.form['SubmittedByUID'] query['getSubmittedByUID'] = submittedby_uid submittedby = rc.lookupObject(submittedby_uid) submittedby_name = submittedby.prettyNameOrTitle() else: submittedby_name = 'Undefined' parms.append( { 'title': _('Submitted by'), 'value': submittedby_name, 'type': 'text'}) workflow = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('review_state'): query['review_state'] = self.request.form['review_state'] review_state = workflow.getTitleForStateOnType( self.request.form['review_state'], 'Analysis') else: review_state = 'Undefined' parms.append( { 'title': _('Status'), 'value': review_state, 'type': 'text'}) if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form['cancellation_state'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') else: cancellation_state = 'Undefined' parms.append( { 'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form['ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') else: ws_review_state = 'Undefined' parms.append( { 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual query lines formats = {'columns': 7, 'col_heads': [], 'class': '', } columns = 6 datalines = [] clientoid_label = [{'value': _("Client order ID"), 'class': 'header',}] clientref_label = [{'value': _("Client reference"), 'class': 'header',}] clientsid_label = [{'value': _("Client sample ID"), 'class': 'header',}] client_label = [{'value': _("Client"), 'class': 'header',}] contact_label = [{'value': _("Contact"), 'class': 'header',}] requestid_label = [{'value': _("Request ID"), 'class': 'header',}] sampleid_label = [{'value': _("Sample ID"), 'class': 'header',}] profile_label = [{'value': _("Profile"), 'class': 'header',}] sampletype_label = [{'value': _("Sample type"), 'class': 'header',}] samplepoint_label = [{'value': _("Sample point"), 'class': 'header',}] sampled_label = [{'value': _("Sampled"), 'class': 'header',}] requested_label = [{'value': _("Requested"), 'class': 'header',}] received_label = [{'value': _("Received"), 'class': 'header',}] published_label = [{'value': _("Published"), 'class': 'header',}] status_label = [{'value': _("Status"), 'class': 'header',}] submittedby_label = [{'value': _("Submitted by"), 'class': 'header',}] verifiedby_label = [{'value': _("Verified by"), 'class': 'header',}] i = 0 for arp in bc(query): ar = arp.getObject() clientoid.append({'value': ar.getClientOrderNumber()}) clientref.append({'value': ar.getClientReference()}) clientsid.append({'value': ar.getClientSampleID()}) client.append({'value': ar.aq_parent.Title()}) contact.append({'value': ar.getContact().Title()}) requestid.append({'value': ar.getRequestID()}) sampleid.append({'value': ar.getSample().getSampleID()}) profile.append({'value': ar.getProfile() and ar.getProfile().Title() or ' '}) sampletype.append({'value': ar.getSampleTypeTitle()}) samplepoint.append({'value': ar.getSamplePointTitle()}) sampled.append({'value': TimeOrDate(self.context, ar.getSample().getDateSampled())}) requested.append({'value': ' '}) #requested.append({'value': TimeOrDate(self.context, ar.created())}) received.append({'value': TimeOrDate(self.context, ar.getDateReceived())}) published.append({'value': TimeOrDate(self.context, ar.getDatePublished())}) status.append({'value': ' '}) #status.append({'value': ar.review_state()}) submittedby.append({'value': ' '}) #submittedby.append({'value': ar.getSubmittedBy().Title()}) verifiedby.append({'value': ' '}) #verifiedby.append({'value': ar.get_verifier().Title()}) if len(clientoid) > columns: datalines.append(clientoid) datalines.append(clientref) datalines.append(clientsid) datalines.append(client) datalines.append(contact) datalines.append(requestid) datalines.append(sampleid) datalines.append(profile) datalines.append(sampletype) datalines.append(samplepoint) datalines.append(sampled) datalines.append(requested) datalines.append(received) datalines.append(published) datalines.append(status) datalines.append(submittedby) datalines.append(verifiedby) # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.query_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return self.template()
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Attachments") headings['subheader'] = _("The attachments linked to analysis requests and analyses") count_all = 0 query = {'portal_type': 'Attachment'} if self.request.form.has_key('getClientUID'): client_uid = self.request.form['getClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = 'Undefined' parms.append( { 'title': _('Client'), 'value': client_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DateLoaded') if date_query: query['getDateLoaded'] = date_query loaded = formatDateParms(self.context, 'DateLoaded') else: loaded = 'Undefined' parms.append( { 'title': _('Loaded'), 'value': loaded, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 6, 'col_heads': [ _('Request'), \ _('File'), \ _('Attachment type'), \ _('Content type'), \ _('Size'), \ _('Loaded'), \ ], 'class': '', } datalines = [] attachments = pc(query) for a_proxy in attachments: attachment = a_proxy.getObject() attachment_file = attachment.getAttachmentFile() icon = attachment_file.getBestIcon() filename = attachment_file.filename filesize = attachment_file.get_size() filesize = filesize / 1024 sizeunit = "Kb" if filesize > 1024: filesize = filesize / 1024 sizeunit = "Mb" dateloaded = attachment.getDateLoaded() dataline = [] dataitem = {'value': attachment.getTextTitle()} dataline.append(dataitem) dataitem = {'value': filename, 'img_before': icon} dataline.append(dataitem) dataitem = {'value': attachment.getAttachmentType().Title()} dataline.append(dataitem) dataitem = {'value': self.context.lookupMime(attachment_file.getContentType())} dataline.append(dataitem) dataitem = {'value': '%s%s' %(filesize, sizeunit)} dataline.append(dataitem) dataitem = {'value': self.ulocalized_time(dateloaded)} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'colspan': 5, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return {'report_title': self.context.translate(headings['header']), 'report_data': self.template()}
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, "portal_catalog") sc = getToolByName(self.context, "bika_setup_catalog") bc = getToolByName(self.context, "bika_analysis_catalog") rc = getToolByName(self.context, "reference_catalog") self.report_content = {} parm_lines = {} parms = [] headings = {} headings["header"] = _("Attachments") headings["subheader"] = _("The attachments linked to analysis requests and analyses") count_all = 0 query = {"portal_type": "Attachment"} if self.request.form.has_key("ClientUID"): client_uid = self.request.form["ClientUID"] query["getClientUID"] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query["getClientUID"] = client.UID() else: client_title = "Undefined" parms.append({"title": _("Client"), "value": client_title, "type": "text"}) date_query = formatDateQuery(self.context, "Loaded") if date_query: query["getDateLoaded"] = date_query loaded = formatDateParms(self.context, "Loaded") else: loaded = "Undefined" parms.append({"title": _("Loaded"), "value": loaded, "type": "text"}) # and now lets do the actual report lines formats = { "columns": 6, "col_heads": [_("Request"), _("File"), _("Attachment type"), _("Content type"), _("Size"), _("Loaded")], "class": "", } datalines = [] attachments = pc(query) for a_proxy in attachments: attachment = a_proxy.getObject() attachment_file = attachment.getAttachmentFile() icon = attachment_file.getBestIcon() filename = attachment_file.filename filesize = attachment_file.get_size() filesize = filesize / 1024 sizeunit = "Kb" if filesize > 1024: filesize = filesize / 1024 sizeunit = "Mb" dateloaded = attachment.getDateLoaded() dataline = [] dataitem = {"value": attachment.getTextTitle()} dataline.append(dataitem) dataitem = {"value": filename, "img_before": icon} dataline.append(dataitem) dataitem = {"value": attachment.getAttachmentType().Title()} dataline.append(dataitem) dataitem = {"value": self.context.lookupMime(attachment_file.getContentType())} dataline.append(dataitem) dataitem = {"value": "%s%s" % (filesize, sizeunit)} dataline.append(dataitem) dataitem = {"value": self.ulocalized_time(dateloaded)} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # footer data footlines = [] footline = [] footitem = {"value": _("Total"), "colspan": 5, "class": "total_label"} footline.append(footitem) footitem = {"value": count_all} footline.append(footitem) footlines.append(footline) self.report_content = { "headings": headings, "parms": parms, "formats": formats, "datalines": datalines, "footings": footlines, } return {"report_title": self.context.translate(headings["header"]), "report_data": self.template()}
def __call__(self): bsc = getToolByName(self.context, 'bika_setup_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analyses out of range") headings['subheader'] = _("Analyses results out of client or lab specified range") count_all = 0 query = {'portal_type': 'Analysis', 'sort_order': 'reverse'} if self.request.form.has_key('spec'): spec = self.request.form['spec'] else: spec = 'lab' if spec == 'lab': lab_spec = True else: lab_spec = False parms.append( { 'title': _('Range spec'), 'value': spec, 'type': 'text'}) date_query = formatDateQuery(self.context, 'c_DateReceived') if date_query: query['getDateReceived'] = date_query received = formatDateParms(self.context, 'c_DateReceived') else: received = 'Undefined' parms.append( { 'title': _('Received'), 'value': received, 'type': 'text'}) wf_tool = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('review_state'): query['review_state'] = self.request.form['review_state'] review_state = wf_tool.getTitleForStateOnType( self.request.form['review_state'], 'Analysis') else: review_state = 'Undefined' parms.append( { 'title': _('Status'), 'value': review_state, 'type': 'text'}) if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form['cancellation_state'] cancellation_state = wf_tool.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') else: cancellation_state = 'Undefined' parms.append( { 'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form['ws_review_state'] ws_review_state = wf_tool.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') else: ws_review_state = 'Undefined' parms.append( { 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 10, 'col_heads': [ _('Client'), \ _('Request'), \ _('Sample type'), \ _('Sample point'), \ _('Category'), \ _('Analysis'), \ _('Result'), \ _('Min'), \ _('Max'), \ _('Status'), \ ], 'class': '', } datalines = [] clients = {} sampletypes = {} samplepoints = {} categories = {} services = {} specs = {} if lab_spec: owner_uid = self.context.bika_setup.bika_analysisspecs.UID() for a_proxy in bac(query): analysis = a_proxy.getObject() if analysis.getResult(): try: result = float(analysis.getResult()) except: continue else: continue sampletypeuid = analysis.getSampleTypeUID() # determine which specs to use, and load if not yet found if not lab_spec: owner_uid = analysis.getClientUID() if not specs.has_key(owner_uid): specs[owner_uid] = {} if not specs[owner_uid].has_key(sampletypeuid): proxies = bsc(portal_type = 'AnalysisSpec', getSampleTypeUID = sampletypeuid, getClientUID = owner_uid) if len(proxies) == 0: continue spec_object = proxies[0].getObject() specs[owner_uid][sampletypeuid] = spec_object.getResultsRangeDict() spec = specs[owner_uid][sampletypeuid] keyword = analysis.getKeyword() if spec.has_key(keyword): spec_min = float(spec[keyword]['min']) spec_max = float(spec[keyword]['max']) if spec_min <= result <= spec_max: continue else: continue # check if in shoulder: out of range, but in acceptable # error percentage shoulder = False error_amount = (result / 100) * float(spec[keyword]['error']) error_min = result - error_amount error_max = result + error_amount if ((result < spec_min) and (error_max >= spec_min)) or \ ((result > spec_max) and (error_min <= spec_max)): shoulder = True dataline = [] dataitem = {'value': analysis.getClientTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getRequestID()} dataline.append(dataitem) dataitem = {'value': analysis.aq_parent.getSampleTypeTitle()} dataline.append(dataitem) dataitem = {'value': analysis.aq_parent.getSamplePointTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getCategoryTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getServiceTitle()} dataline.append(dataitem) if shoulder: dataitem = {'value': analysis.getResult(), 'img_after': '++resource++bika.lims.images/exclamation.png'} else: dataitem = {'value': analysis.getResult()} dataline.append(dataitem) dataitem = {'value': spec[keyword]['min']} dataline.append(dataitem) dataitem = {'value': spec[keyword]['max']} dataline.append(dataitem) state = wf_tool.getInfoFor(analysis, 'review_state', '') review_state = wf_tool.getTitleForStateOnType( state, 'Analysis') dataitem = {'value': review_state} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = {'value': _('Number of analyses out of range for period'), 'colspan': 9, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) # report footer data footnotes = [] footline = [] footitem = {'value': _('Analysis result within error range'), 'img_before': '++resource++bika.lims.images/exclamation.png' } footline.append(footitem) footnotes.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines, 'footnotes': footnotes} title = self.context.translate(headings['header']) return {'report_title': title, 'report_data': self.template()}
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') bc = getToolByName(self.context, 'bika_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} this_client = logged_in_client(self.context) if this_client: headings['header'] = _("Analysis requests and analyses") headings['subheader'] = _( "Number of Analysis requests and analyses") else: headings['header'] = _("Analysis requests and analyses per client") headings['subheader'] = _( "Number of Analysis requests and analyses per client") count_all_ars = 0 count_all_analyses = 0 query = {} date_query = formatDateQuery(self.context, 'c_DateRequested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'c_DateRequested') else: requested = 'Undefined' parms.append({ 'title': _('Requested'), 'value': requested, 'type': 'text' }) workflow = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('review_state'): query['review_state'] = self.request.form['review_state'] review_state = workflow.getTitleForStateOnType( self.request.form['review_state'], 'Analysis') else: review_state = 'Undefined' parms.append({ 'title': _('Status'), 'value': review_state, 'type': 'text' }) if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form[ 'cancellation_state'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') else: cancellation_state = 'Undefined' parms.append({ 'title': _('Active'), 'value': cancellation_state, 'type': 'text' }) if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form[ 'ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') else: ws_review_state = 'Undefined' parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) # and now lets do the actual report lines formats = {'columns': 3, 'col_heads': [ _('Client'), \ _('Number of requests'), \ _('Number of analyses')], 'class': '', } datalines = [] if this_client: c_proxies = pc(portal_type="Client", UID=this_client.UID()) else: c_proxies = pc(portal_type="Client", sort_on='sortable_title') for client in c_proxies: query['getClientUID'] = client.UID dataline = [ { 'value': client.Title }, ] query['portal_type'] = 'AnalysisRequest' ars = bc(query) count_ars = len(ars) dataitem = {'value': count_ars} dataline.append(dataitem) query['portal_type'] = 'Analysis' analyses = bac(query) count_analyses = len(analyses) dataitem = {'value': count_analyses} dataline.append(dataitem) datalines.append(dataline) count_all_analyses += count_analyses count_all_ars += count_ars # footer data footlines = [] if not this_client: footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all_ars} footline.append(footitem) footitem = {'value': count_all_analyses} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } return { 'report_title': self.context.translate(headings['header']), 'report_data': self.template() }
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, "bika_setup_catalog") bc = getToolByName(self.context, "bika_analysis_catalog") rc = getToolByName(self.context, "reference_catalog") self.report_content = {} parm_lines = {} parms = [] headings = {} headings["header"] = _("Analyses per analysis service") headings["subheader"] = _("Number of analyses requested per analysis service") query = {"portal_type": "Analysis"} if self.request.form.has_key("ClientUID"): client_uid = self.request.form["ClientUID"] query["getClientUID"] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query["getClientUID"] = client.UID() else: client_title = _("All") parms.append({"title": _("Client"), "value": client_title, "type": "text"}) date_query = formatDateQuery(self.context, "Requested") if date_query: query["created"] = date_query requested = formatDateParms(self.context, "Requested") parms.append({"title": _("Requested"), "value": requested, "type": "text"}) date_query = formatDateQuery(self.context, "Published") if date_query: query["getDatePublished"] = date_query published = formatDateParms(self.context, "Published") parms.append({"title": _("Published"), "value": published, "type": "text"}) workflow = getToolByName(self.context, "portal_workflow") if self.request.form.has_key("bika_analysis_workflow"): query["review_state"] = self.request.form["bika_analysis_workflow"] review_state = workflow.getTitleForStateOnType(self.request.form["bika_analysis_workflow"], "Analysis") parms.append({"title": _("Status"), "value": review_state, "type": "text"}) if self.request.form.has_key("bika_cancellation_workflow"): query["cancellation_state"] = self.request.form["bika_cancellation_workflow"] cancellation_state = workflow.getTitleForStateOnType( self.request.form["bika_cancellation_workflow"], "Analysis" ) parms.append({"title": _("Active"), "value": cancellation_state, "type": "text"}) if self.request.form.has_key("bika_worksheetanalysis_workflow"): query["worksheetanalysis_review_state"] = self.request.form["bika_worksheetanalysis_workflow"] ws_review_state = workflow.getTitleForStateOnType( self.request.form["bika_worksheetanalysis_workflow"], "Analysis" ) parms.append({"title": _("Assigned to worksheet"), "value": ws_review_state, "type": "text"}) # and now lets do the actual report lines formats = {"columns": 2, "col_heads": [_("Analysis service"), _("Number of analyses")], "class": ""} datalines = [] count_all = 0 for cat in sc(portal_type="AnalysisCategory", sort_on="sortable_title"): dataline = [{"value": cat.Title, "class": "category_heading", "colspan": 2}] datalines.append(dataline) for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on="sortable_title"): query["getServiceUID"] = service.UID analyses = bc(query) count_analyses = len(analyses) dataline = [] dataitem = {"value": service.Title} dataline.append(dataitem) dataitem = {"value": count_analyses} dataline.append(dataitem) datalines.append(dataline) count_all += count_analyses # footer data footlines = [] footline = [] footitem = {"value": _("Total"), "class": "total_label"} footline.append(footitem) footitem = {"value": count_all} footline.append(footitem) footlines.append(footline) self.report_content = { "headings": headings, "parms": parms, "formats": formats, "datalines": datalines, "footings": footlines, } title = self.context.translate(headings["header"]) return {"report_title": title, "report_data": self.template()}
def __call__(self): bc = getToolByName(self.context, "bika_catalog") self.report_content = {} parm_lines = {} parms = [] headings = {} headings["header"] = _("Analysis requests not invoiced") headings["subheader"] = _("Published Analysis Requests which have not been invoiced") count_all = 0 query = { "portal_type": "AnalysisRequest", "getInvoiced": False, "review_state": "published", "sort_order": "reverse", } date_query = formatDateQuery(self.context, "c_DatePublished") if date_query: query["getDatePublished"] = date_query pubished = formatDateParms(self.context, "c_DatePublished") else: pubished = "Undefined" parms.append({"title": _("Published"), "value": pubished, "type": "text"}) if self.request.form.has_key("cancellation_state"): query["cancellation_state"] = self.request.form["cancellation_state"] cancellation_state = wf_tool.getTitleForStateOnType( self.request.form["cancellation_state"], "AnalysisRequest" ) else: cancellation_state = "Undefined" parms.append({"title": _("Active"), "value": cancellation_state, "type": "text"}) # and now lets do the actual report lines formats = { "columns": 6, "col_heads": [_("Client"), _("Request"), _("Sample type"), _("Sample point"), _("Published"), _("Amount")], "class": "", } datalines = [] clients = {} sampletypes = {} samplepoints = {} categories = {} services = {} for ar_proxy in bc(query): ar = ar_proxy.getObject() dataline = [] dataitem = {"value": ar.aq_parent.Title()} dataline.append(dataitem) dataitem = {"value": ar.getRequestID()} dataline.append(dataitem) dataitem = {"value": ar.getSampleTypeTitle()} dataline.append(dataitem) dataitem = {"value": ar.getSamplePointTitle()} dataline.append(dataitem) dataitem = {"value": self.ulocalized_time(getTransitionDate(ar, "publish"), long_format=True)} dataline.append(dataitem) dataitem = {"value": ar.getTotalPrice()} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = {"value": _("Number of analyses retested for period"), "colspan": 5, "class": "total_label"} footline.append(footitem) footitem = {"value": count_all} footline.append(footitem) footlines.append(footline) self.report_content = { "headings": headings, "parms": parms, "formats": formats, "datalines": datalines, "footings": footlines, } return {"report_title": t(headings["header"]), "report_data": self.template()}
def __call__(self): bac = getToolByName(self.context, 'bika_analysis_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analyses retested") headings['subheader'] = _("Analyses which have been retested") count_all = 0 query = {'portal_type': 'Analysis', 'getRetested': True, 'sort_order': 'reverse'} date_query = formatDateQuery(self.context, 'Received') if date_query: query['getDateReceived'] = date_query received = formatDateParms(self.context, 'Received') else: received = 'Undefined' parms.append( { 'title': _('Received'), 'value': received, 'type': 'text'}) wf_tool = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('bika_analysis_workflow'): query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = wf_tool.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') else: review_state = 'Undefined' parms.append( { 'title': _('Status'), 'value': review_state, 'type': 'text'}) if self.request.form.has_key('bika_cancellation_workflow'): query['cancellation_state'] = self.request.form['bika_cancellation_workflow'] cancellation_state = wf_tool.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') else: cancellation_state = 'Undefined' parms.append( { 'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if self.request.form.has_key('bika_worksheetanalysis_workflow'): query['worksheetanalysis_review_state'] = self.request.form['bika_worksheetanalysis_workflow'] ws_review_state = wf_tool.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') else: ws_review_state = 'Undefined' parms.append( { 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 8, 'col_heads': [ _('Client'), _('Request'), _('Sample type'), _('Sample point'), _('Category'), _('Analysis'), _('Received'), _('Status'), ], 'class': '', } datalines = [] clients = {} sampletypes = {} samplepoints = {} categories = {} services = {} for a_proxy in bac(query): analysis = a_proxy.getObject() dataline = [] dataitem = {'value': analysis.getClientTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getRequestID()} dataline.append(dataitem) dataitem = {'value': analysis.aq_parent.getSampleTypeTitle()} dataline.append(dataitem) dataitem = {'value': analysis.aq_parent.getSamplePointTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getCategoryTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getServiceTitle()} dataline.append(dataitem) dataitem = {'value': self.ulocalized_time(analysis.getDateReceived())} dataline.append(dataitem) state = wf_tool.getInfoFor(analysis, 'review_state', '') review_state = wf_tool.getTitleForStateOnType( state, 'Analysis') dataitem = {'value': review_state} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = {'value': _('Number of analyses retested for period'), 'colspan': 7, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} title = self.context.translate(headings['header']) return {'report_title': title, 'report_data': self.template()}
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Attachments") headings['subheader'] = _("The attachments linked to analysis requests and analyses") count_all = 0 query = {'portal_type': 'Attachment'} if 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = 'All' parms.append( {'title': _('Client'), 'value': client_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'Loaded') if date_query: query['getDateLoaded'] = date_query loaded = formatDateParms(self.context, 'Loaded') parms.append( {'title': _('Loaded'), 'value': loaded, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 6, 'col_heads': [_('Request'), _('File'), _('Attachment type'), _('Content type'), _('Size'), _('Loaded'), ], 'class': '', } datalines = [] attachments = pc(query) for a_proxy in attachments: attachment = a_proxy.getObject() attachment_file = attachment.getAttachmentFile() icon = attachment_file.getBestIcon() filename = attachment_file.filename filesize = attachment_file.get_size() filesize = filesize / 1024 sizeunit = "Kb" if filesize > 1024: filesize = filesize / 1024 sizeunit = "Mb" dateloaded = attachment.getDateLoaded() dataline = [] dataitem = {'value': attachment.getTextTitle()} dataline.append(dataitem) dataitem = {'value': filename, 'img_before': icon} dataline.append(dataitem) dataitem = {'value': attachment.getAttachmentType().Title() if attachment.getAttachmentType() else ''} dataline.append(dataitem) dataitem = {'value': self.context.lookupMime(attachment_file.getContentType())} dataline.append(dataitem) dataitem = {'value': '%s%s' % (filesize, sizeunit)} dataline.append(dataitem) dataitem = {'value': self.ulocalized_time(dateloaded)} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'colspan': 5, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ _('Request'), _('File'), _('Attachment type'), _('Content type'), _('Size'), _('Loaded'), ] output = StringIO.StringIO() dw = csv.DictWriter(output, fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow(row) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader("Content-Disposition", "attachment;filename=\"analysesattachments_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return {'report_title': self.context.translate(headings['header']), 'report_data': self.template()}
def __call__(self): bc = getToolByName(self.context, 'bika_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Samples not invoiced") headings['subheader'] = _( "Published Samples which have not been invoiced") count_all = 0 query = {'portal_type': 'AnalysisRequest', 'getInvoiced': False, 'review_state': 'published', 'sort_order': 'reverse'} date_query = formatDateQuery(self.context, 'c_DatePublished') if date_query: query['getDatePublished'] = date_query pubished = formatDateParms(self.context, 'c_DatePublished') else: pubished = 'Undefined' parms.append( {'title': _('Published'), 'value': pubished, 'type': 'text'}) parms.append( {'title': _('Active'), 'value': 'Undefined', 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 6, 'col_heads': [_('Client'), \ _('Request'), \ _('Sample type'), \ _('Sample point'), \ _('Published'), \ _('Amount'), \ ], 'class': '', } datalines = [] clients = {} sampletypes = {} samplepoints = {} categories = {} services = {} for ar_proxy in bc(query): ar = ar_proxy.getObject() dataline = [] dataitem = {'value': ar.aq_parent.Title()} dataline.append(dataitem) dataitem = {'value': ar.getId()} dataline.append(dataitem) dataitem = {'value': ar.getSampleTypeTitle()} dataline.append(dataitem) dataitem = {'value': ar.getSamplePointTitle()} dataline.append(dataitem) dataitem = {'value': self.ulocalized_time(getTransitionDate(ar, 'publish'), long_format=True)} dataline.append(dataitem) dataitem = {'value': ar.getTotalPrice()} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = {'value': _('Number of analyses retested for period'), 'colspan': 5, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return {'report_title': t(headings['header']), 'report_data': self.template()}
def __call__(self): # get all the data into datalines bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times over time") headings['subheader'] = \ _("The turnaround time of analyses plotted over time") query = {'portal_type': 'Analysis'} if 'ServiceUID' in self.request.form: service_uid = self.request.form['ServiceUID'] query['ServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() parms.append({ 'title': _('Analysis Service'), 'value': service_title, 'type': 'text' }) if 'Analyst' in self.request.form: analyst = self.request.form['Analyst'] query['getAnalyst'] = analyst analyst_title = self.user_fullname(analyst) parms.append({ 'title': _('Analyst'), 'value': analyst_title, 'type': 'text' }) if 'getInstrumentUID' in self.request.form: instrument_uid = self.request.form['getInstrumentUID'] query['getInstrument'] = instrument_uid instrument = rc.lookupObject(instrument_uid) instrument_title = instrument.Title() parms.append({ 'title': _('Instrument'), 'value': instrument_title, 'type': 'text' }) if 'Period' in self.request.form: period = self.request.form['Period'] else: period = 'Day' date_query = formatDateQuery(self.context, 'tats_DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'tats_DateReceived') parms.append({ 'title': _('Received'), 'value': received, 'type': 'text' }) query['review_state'] = 'published' # query all the analyses and increment the counts periods = {} total_count = 0 total_duration = 0 analyses = bc(query) for a in analyses: analysis = a.getObject() received = analysis.created() if period == 'Day': datekey = received.strftime('%d %b %Y') elif period == 'Week': # key period on Monday dayofweek = received.strftime('%w') # Sunday = 0 if dayofweek == 0: firstday = received - 6 else: firstday = received - (int(dayofweek) - 1) datekey = firstday.strftime(self.date_format_short) elif period == 'Month': datekey = received.strftime('%m-%d') if datekey not in periods: periods[datekey] = { 'count': 0, 'duration': 0, } count = periods[datekey]['count'] duration = periods[datekey]['duration'] count += 1 duration += analysis.getDuration() periods[datekey]['duration'] = duration periods[datekey]['count'] = count total_count += 1 total_duration += duration # calculate averages for datekey in periods.keys(): count = periods[datekey]['count'] duration = periods[datekey]['duration'] ave_duration = (duration) / count periods[datekey]['duration'] = \ formatDuration(self.context, ave_duration) # and now lets do the actual report lines formats = { 'columns': 2, 'col_heads': [ _('Date'), _('Turnaround time (h)'), ], 'class': '', } datalines = [] period_keys = periods.keys() for period in period_keys: dataline = [ { 'value': period, 'class': '' }, ] dataline.append({ 'value': periods[period]['duration'], 'class': 'number' }) datalines.append(dataline) if total_count > 0: ave_total_duration = total_duration / total_count else: ave_total_duration = 0 ave_total_duration = formatDuration(self.context, ave_total_duration) # footer data footlines = [] footline = [] footline = [ { 'value': _('Total data points'), 'class': 'total' }, ] footline.append({'value': total_count, 'class': 'total number'}) footlines.append(footline) footline = [ { 'value': _('Average TAT'), 'class': 'total' }, ] footline.append({'value': ave_total_duration, 'class': 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Date', 'Turnaround time (h)', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow({ 'Date': row[0]['value'], 'Turnaround time (h)': row[1]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader( "Content-Disposition", "attachment;filename=\"analysesperservice_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return { 'report_title': t(headings['header']), 'report_data': self.template() }
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') bc = getToolByName(self.context, 'bika_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} count_all_ars = 0 count_all_analyses = 0 query = {} this_client = logged_in_client(self.context) if not this_client and 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] this_client = rc.lookupObject(client_uid) parms.append({ 'title': _('Client'), 'value': this_client.Title(), 'type': 'text' }) if this_client: headings['header'] = _("Analysis requests and analyses") headings['subheader'] = _( "Number of Analysis requests and analyses") else: headings['header'] = _("Analysis requests and analyses per client") headings['subheader'] = _( "Number of Analysis requests and analyses per client") date_query = formatDateQuery(self.context, 'Requested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'Requested') parms.append({ 'title': _('Requested'), 'value': requested, 'type': 'text' }) workflow = getToolByName(self.context, 'portal_workflow') if 'bika_analysis_workflow' in self.request.form: query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = workflow.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') parms.append({ 'title': _('Status'), 'value': review_state, 'type': 'text' }) if 'bika_cancellation_workflow' in self.request.form: query['cancellation_state'] = self.request.form[ 'bika_cancellation_workflow'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') parms.append({ 'title': _('Active'), 'value': cancellation_state, 'type': 'text' }) if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) # and now lets do the actual report lines formats = { 'columns': 3, 'col_heads': [_('Client'), _('Number of requests'), _('Number of analyses')], 'class': '' } datalines = [] if this_client: c_proxies = pc(portal_type="Client", UID=this_client.UID()) else: c_proxies = pc(portal_type="Client", sort_on='sortable_title') for client in c_proxies: query['getClientUID'] = client.UID dataline = [ { 'value': client.Title }, ] query['portal_type'] = 'AnalysisRequest' ars = bc(query) count_ars = len(ars) dataitem = {'value': count_ars} dataline.append(dataitem) query['portal_type'] = 'Analysis' analyses = bac(query) count_analyses = len(analyses) dataitem = {'value': count_analyses} dataline.append(dataitem) datalines.append(dataline) count_all_analyses += count_analyses count_all_ars += count_ars # footer data footlines = [] if not this_client: footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all_ars} footline.append(footitem) footitem = {'value': count_all_analyses} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Client', 'Analysis Requests', 'Analyses', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow({ 'Client': row[0]['value'], 'Analysis Requests': row[1]['value'], 'Analyses': row[2]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader( "Content-Disposition", "attachment;filename=\"analysesperclient_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return { 'report_title': t(headings['header']), 'report_data': self.template() }
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times over time") headings['subheader'] = \ _("The turnaround time of analyses plotted over time") count_all = 0 query = {'portal_type': 'Analysis'} if self.request.form.has_key('getServiceUID'): service_uid = self.request.form['getServiceUID'] query['getServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() else: service_title = 'Undefined' parms.append( { 'title': _('Analysis Service'), 'value': service_title, 'type': 'text'}) if self.request.form.has_key('Analyst'): analyst = self.request.form['Analyst'] query['getAnalyst'] = analyst analyst_title = pretty_user_name_or_id(self.context, analyst) else: analyst_title = 'Undefined' parms.append( { 'title': _('Analyst'), 'value': analyst_title, 'type': 'text'}) if self.request.form.has_key('getInstrumentUID'): instrument_uid = self.request.form['getInstrumentUID'] query['getInstrument'] = instrument_uid instrument = rc.lookupObject(instrument_uid) instrument_title = instrument.Title() else: instrument_title = 'Undefined' parms.append( { 'title': _('Instrument'), 'value': instrument_title, 'type': 'text'}) if self.request.form.has_key('Period'): period = self.request.form['Period'] else: period = 'Day' date_query = formatDateQuery(self.context, 'tats_DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'tats_DateReceived') else: received = 'Undefined' parms.append( { 'title': _('Received'), 'value': received, 'type': 'text'}) query['review_state'] = 'published' # query all the analyses and increment the counts periods = {} total_count = 0 total_duration = 0 analyses = bc(query) for a in analyses: analysis = a.getObject() received = analysis.created() if period == 'Day': datekey = received.strftime('%d %b %Y') elif period == 'Week': # key period on Monday dayofweek = received.strftime('%w') # Sunday = 0 if dayofweek == 0: firstday = received - 6 else: firstday = received - (int(dayofweek) - 1) datekey = firstday.strftime('%d %b %Y') elif period == 'Month': datekey = received.strftime('%b %Y') if not periods.has_key(datekey): periods[datekey] = {'count': 0, 'duration': 0, } count = periods[datekey]['count'] duration = periods[datekey]['duration'] count += 1 duration += analysis.getDuration() periods[datekey]['duration'] = duration periods[datekey]['count'] = count total_count += 1 total_duration += duration # calculate averages for datekey in periods.keys(): count = periods[datekey]['count'] duration = periods[datekey]['duration'] ave_duration = (duration) / count periods[datekey]['duration'] = \ formatDuration(self.context, ave_duration) # and now lets do the actual report lines formats = {'columns': 2, 'col_heads': [ _('Date'), \ _('Turnaround time (h)'), \ ], 'class': '', } datalines = [] period_keys = periods.keys() for period in period_keys: dataline = [{'value': period, 'class' : ''},] dataline.append({'value': periods[period]['duration'], 'class' : 'number'}) datalines.append(dataline) ave_total_duration = total_duration / total_count ave_total_duration = formatDuration(self.context, ave_total_duration) # footer data footlines = [] footline = [] footline = [{'value': _('Total data points'), 'class': 'total'}, ] footline.append({'value' : total_count, 'class' : 'total number'}) footlines.append(footline) footline = [{'value': _('Average TAT'), 'class': 'total'}, ] footline.append({'value' : ave_total_duration, 'class' : 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return self.template()
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analyses per analysis service") headings['subheader'] = _("Number of analyses requested per analysis service") count_all = 0 query = {'portal_type': 'Analysis'} if self.request.form.has_key('getClientUID'): client_uid = self.request.form['getClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = _('All') parms.append( { 'title': _('Client'), 'value': client_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DateRequested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'DateRequested') parms.append( { 'title': _('Requested'), 'value': requested, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DatePublished') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'DatePublished') else: published = 'Undefined' parms.append( { 'title': _('Published'), 'value': published, 'type': 'text'}) workflow = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('review_state'): query['review_state'] = self.request.form['review_state'] review_state = workflow.getTitleForStateOnType( self.request.form['review_state'], 'Analysis') else: review_state = 'Undefined' parms.append( { 'title': _('Status'), 'value': review_state, 'type': 'text'}) if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form['cancellation_state'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') else: cancellation_state = 'Undefined' parms.append( { 'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form['ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') else: ws_review_state = 'Undefined' parms.append( { 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 2, 'col_heads': [ _('Analysis service'), _('Number of analyses')], 'class': '', } datalines = [] for cat in sc(portal_type="AnalysisCategory", sort_on='sortable_title'): dataline = [{'value': cat.Title, 'class': 'category_heading', 'colspan': 2},] datalines.append(dataline) for service in sc(portal_type="AnalysisService", getCategoryUID = cat.UID, sort_on='sortable_title'): query['getServiceUID'] = service.UID analyses = bc(query) count_analyses = len(analyses) dataline = [] dataitem = {'value': service.Title} dataline.append(dataitem) dataitem = {'value': count_analyses } dataline.append(dataitem) datalines.append(dataline) count_all += count_analyses # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} title = self.context.translate(headings['header']) return {'report_title': title, 'report_data': self.template()}
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times over time") headings['subheader'] = \ _("The turnaround time of analyses plotted over time") count_all = 0 query = {'portal_type': 'Analysis'} if self.request.form.has_key('getServiceUID'): service_uid = self.request.form['getServiceUID'] query['getServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() else: service_title = 'Undefined' parms.append({ 'title': _('Analysis Service'), 'value': service_title, 'type': 'text' }) if self.request.form.has_key('Analyst'): analyst = self.request.form['Analyst'] query['getAnalyst'] = analyst analyst_title = self.user_fullname(analyst) else: analyst_title = 'Undefined' parms.append({ 'title': _('Analyst'), 'value': analyst_title, 'type': 'text' }) if self.request.form.has_key('getInstrumentUID'): instrument_uid = self.request.form['getInstrumentUID'] query['getInstrument'] = instrument_uid instrument = rc.lookupObject(instrument_uid) instrument_title = instrument.Title() else: instrument_title = 'Undefined' parms.append({ 'title': _('Instrument'), 'value': instrument_title, 'type': 'text' }) if self.request.form.has_key('Period'): period = self.request.form['Period'] else: period = 'Day' date_query = formatDateQuery(self.context, 'tats_DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'tats_DateReceived') else: received = 'Undefined' parms.append({ 'title': _('Received'), 'value': received, 'type': 'text' }) query['review_state'] = 'published' # query all the analyses and increment the counts periods = {} total_count = 0 total_duration = 0 analyses = bc(query) for a in analyses: analysis = a.getObject() received = analysis.created() if period == 'Day': datekey = received.strftime('%d %b %Y') elif period == 'Week': # key period on Monday dayofweek = received.strftime('%w') # Sunday = 0 if dayofweek == 0: firstday = received - 6 else: firstday = received - (int(dayofweek) - 1) datekey = firstday.strftime(self.date_format_short) elif period == 'Month': datekey = received.strftime('%m-%d') if not periods.has_key(datekey): periods[datekey] = { 'count': 0, 'duration': 0, } count = periods[datekey]['count'] duration = periods[datekey]['duration'] count += 1 duration += analysis.getDuration() periods[datekey]['duration'] = duration periods[datekey]['count'] = count total_count += 1 total_duration += duration # calculate averages for datekey in periods.keys(): count = periods[datekey]['count'] duration = periods[datekey]['duration'] ave_duration = (duration) / count periods[datekey]['duration'] = \ formatDuration(self.context, ave_duration) # and now lets do the actual report lines formats = { 'columns': 2, 'col_heads': [ _('Date'), _('Turnaround time (h)'), ], 'class': '', } datalines = [] period_keys = periods.keys() for period in period_keys: dataline = [ { 'value': period, 'class': '' }, ] dataline.append({ 'value': periods[period]['duration'], 'class': 'number' }) datalines.append(dataline) if total_count > 0: ave_total_duration = total_duration / total_count else: ave_total_duration = 0 ave_total_duration = formatDuration(self.context, ave_total_duration) # footer data footlines = [] footline = [] footline = [ { 'value': _('Total data points'), 'class': 'total' }, ] footline.append({'value': total_count, 'class': 'total number'}) footlines.append(footline) footline = [ { 'value': _('Average TAT'), 'class': 'total' }, ] footline.append({'value': ave_total_duration, 'class': 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } title = self.context.translate(headings['header']) return {'report_title': title, 'report_data': self.template()}
def __call__(self): # get all the data into datalines pc = getToolByName(self.context, 'portal_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') bc = getToolByName(self.context, 'bika_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} count_all_ars = 0 count_all_analyses = 0 query = {} this_client = logged_in_client(self.context) if not this_client and 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] this_client = rc.lookupObject(client_uid) parms.append( {'title': _('Client'), 'value': this_client.Title(), 'type': 'text'}) if this_client: headings['header'] = _("Analysis requests and analyses") headings['subheader'] = _("Number of Analysis requests and analyses") else: headings['header'] = _("Analysis requests and analyses per client") headings['subheader'] = _( "Number of Analysis requests and analyses per client") date_query = formatDateQuery(self.context, 'Requested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'Requested') parms.append( {'title': _('Requested'), 'value': requested, 'type': 'text'}) workflow = getToolByName(self.context, 'portal_workflow') if 'bika_analysis_workflow' in self.request.form: query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = workflow.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') parms.append( {'title': _('Status'), 'value': review_state, 'type': 'text'}) if 'bika_cancellation_workflow' in self.request.form: query['cancellation_state'] = self.request.form[ 'bika_cancellation_workflow'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') parms.append({'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append( {'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append( {'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 3, 'col_heads': [_('Client'), _('Number of requests'), _('Number of analyses')], 'class': ''} datalines = [] if this_client: c_proxies = pc(portal_type="Client", UID=this_client.UID()) else: c_proxies = pc(portal_type="Client", sort_on='sortable_title') for client in c_proxies: query['getClientUID'] = client.UID dataline = [{'value': client.Title}, ] query['portal_type'] = 'AnalysisRequest' ars = bc(query) count_ars = len(ars) dataitem = {'value': count_ars} dataline.append(dataitem) query['portal_type'] = 'Analysis' analyses = bac(query) count_analyses = len(analyses) dataitem = {'value': count_analyses} dataline.append(dataitem) datalines.append(dataline) count_all_analyses += count_analyses count_all_ars += count_ars # footer data footlines = [] if not this_client: footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all_ars} footline.append(footitem) footitem = {'value': count_all_analyses} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Client', 'Analysis Requests', 'Analyses', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: dw.writerow({ 'Client': row[0]['value'], 'Analysis Requests': row[1]['value'], 'Analyses': row[2]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader("Content-Disposition", "attachment;filename=\"analysesperclient_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return {'report_title': t(headings['header']), 'report_data': self.template()}
def __call__(self): bsc = getToolByName(self.context, 'bika_setup_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analyses out of range") headings['subheader'] = _("Analyses results out of specified range") count_all = 0 query = {"portal_type": "Analysis", "sort_order": "reverse"} spec_uid = self.request.form.get("spec", False) spec_obj = None spec_title = "" if spec_uid: brains = bsc(UID=spec_uid) if brains: spec_obj = brains[0].getObject() spec_title = spec_obj.Title() parms.append( {"title": _("Range spec"), "value": spec_title, "type": "text"}) date_query = formatDateQuery(self.context, 'Received') if date_query: query['getDateReceived'] = date_query received = formatDateParms(self.context, 'Received') else: received = 'Undefined' parms.append( {'title': _('Received'), 'value': received, 'type': 'text'}) wf_tool = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('bika_analysis_workflow'): query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = wf_tool.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') else: review_state = 'Undefined' parms.append( {'title': _('Status'), 'value': review_state, 'type': 'text'}) if self.request.form.has_key('bika_cancellation_workflow'): query['cancellation_state'] = self.request.form[ 'bika_cancellation_workflow'] cancellation_state = wf_tool.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') else: cancellation_state = 'Undefined' parms.append( {'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) if self.request.form.has_key('bika_worksheetanalysis_workflow'): query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = wf_tool.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') else: ws_review_state = 'Undefined' parms.append( {'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # and now lets do the actual report lines col_heads = [_('Client'), _('Request'), _('Sample type'), _('Sample point'), _('Category'), _('Analysis'), _('Result'), _('Min'), _('Max'), _('Status'), ] if isAttributeHidden('Sample', 'SamplePoint'): col_heads.remove(_('Sample point')) formats = {'columns': 10, 'col_heads': col_heads, 'class': '', } datalines = [] for a_proxy in bac(query): analysis = a_proxy.getObject() if analysis.getResult(): try: result = float(analysis.getResult()) except: continue else: continue keyword = analysis.getKeyword() # determine which specs to use for this particular analysis # 1) if a spec is given in the query form, use it. # 2) if a spec is entered directly on the analysis, use it. # otherwise just continue to the next object. spec_dict = False if spec_obj: rr = spec_obj.getResultsRangeDict() if keyword in rr: spec_dict = rr[keyword] else: ar = analysis.aq_parent ar_spec_obj = ar.getSpecification() if ar_spec_obj: rr = ar_spec_obj.getResultsRangeDict() if keyword in rr: spec_dict = rr[keyword] else: if hasattr(analysis, "specification") \ and analysis.specification: spec_dict = analysis.specification else: continue if not spec_dict: continue try: spec_min = float(spec_dict['min']) spec_max = float(spec_dict['max']) except ValueError: continue if spec_min <= result <= spec_max: continue # check if in shoulder: out of range, but in acceptable # error percentage shoulder = False error = 0 try: error = float(spec_dict.get('error', '0')) except: error = 0 pass error_amount = (result / 100) * error error_min = result - error_amount error_max = result + error_amount if ((result < spec_min) and (error_max >= spec_min)) or \ ((result > spec_max) and (error_min <= spec_max)): shoulder = True dataline = [] dataitem = {'value': analysis.getClientTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getRequestID()} dataline.append(dataitem) dataitem = {'value': analysis.aq_parent.getSampleTypeTitle()} dataline.append(dataitem) if isAttributeHidden('Sample', 'SamplePoint'): dataitem = {'value': analysis.aq_parent.getSamplePointTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getCategoryTitle()} dataline.append(dataitem) dataitem = {'value': analysis.getServiceTitle()} dataline.append(dataitem) if shoulder: dataitem = {'value': analysis.getResult(), 'img_after': '++resource++bika.lims.images/exclamation.png'} else: dataitem = {'value': analysis.getResult()} dataline.append(dataitem) dataitem = {'value': spec_dict['min']} dataline.append(dataitem) dataitem = {'value': spec_dict['max']} dataline.append(dataitem) state = wf_tool.getInfoFor(analysis, 'review_state', '') review_state = wf_tool.getTitleForStateOnType( state, 'Analysis') dataitem = {'value': review_state} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = {'value': _('Number of analyses out of range for period'), 'colspan': 9, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) # report footer data footnotes = [] footline = [] footitem = {'value': _('Analysis result within error range'), 'img_before': '++resource++bika.lims.images/exclamation.png' } footline.append(footitem) footnotes.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines, 'footnotes': footnotes} title = t(headings['header']) return {'report_title': title, 'report_data': self.template()}
def __call__(self): self.datalines = [] workflow = getToolByName(self, 'portal_workflow') # check for batch size if self.request.form.has_key('size'): batch_size = self.request.form['size'] else: batch_size = 6 # check for batch start if self.request.form.has_key('b_start'): batch_start = self.request.form['b_start'] else: batch_start = 0 sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_catalog') bac = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.query_content = {} parm_lines = {} self.parms = [] self.headings = {} self.headings['header'] = _("Analysis Requests") self.headings['head_parms'] = _("Selected on the following criteria") self.headings['head_undefined'] = _("Parameters undefined") count_all = 0 query = {'portal_type': 'AnalysisRequest'} undefined = [] # Client client_title = None if self.request.form.has_key('ClientUID'): client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() if client_title: self.parms.append( { 'title': _('Client'), 'fieldid': 'ClientUID', 'value': client_title, 'type': 'text'}) else: undefined.append('Client') # Contact if self.request.form.has_key('ContactUID'): contact_uid = self.request.form['ContactUID'] query['getContactUID'] = contact_uid contact = rc.lookupObject(contact_uid) contact_name = contact.getFullname() self.parms.append( { 'title': _('Contact'), 'fieldid': 'ContactUID', 'value': contact_name, 'type': 'text'}) else: undefined.append('Contact') # Profile if self.request.form.has_key('ProfileUID'): profile_uid = self.request.form['ProfileUID'] query['getAnalysisProfileUID'] = profile_uid profile = rc.lookupObject(profile_uid) profile_title = profile.Title() self.parms.append( { 'title': _('Profile'), 'value': profile_title, 'type': 'text'}) else: undefined.append('Profile') # Request ID if self.request.form.has_key('RequestID'): request_id = self.request.form['RequestID'] query['getRequestID'] = request_id self.parms.append( { 'title': _('AR'), 'value': request_id, 'type': 'text'}) else: undefined.append('AR') # Client order number if self.request.form.has_key('ClientOrderNumber'): clientoid = self.request.form['ClientOrderNumber'] query['getClientOrderNumber'] = clientoid self.parms.append( { 'title': _('Client order number'), 'value': clientoid, 'type': 'text'}) else: undefined.append('Client order number') # Client reference if self.request.form.has_key('ClientReference'): clientref = self.request.form['ClientReference'] query['getClientReference'] = clientref self.parms.append( { 'title': _('Client reference'), 'value': clientref, 'type': 'text'}) else: undefined.append('Client reference') # Client sample ID if self.request.form.has_key('ClientSampleID'): clientsid = self.request.form['ClientSampleID'] query['getClientSampleID'] = clientsid self.parms.append( { 'title': _('Client sample ID'), 'value': clientsid, 'type': 'text'}) else: undefined.append('Client sample ID') # Sample type if self.request.form.has_key('SampleTypeUID'): st_uid = self.request.form['SampleTypeUID'] query['getSampleTypeUID'] = st_uid st = rc.lookupObject(st_uid) st_title = st.Title() self.parms.append( { 'title': _('Sample type'), 'value': st_title, 'type': 'text'}) else: undefined.append('Sample type') # Sample point if self.request.form.has_key('SamplePointUID'): sp_uid = self.request.form['SamplePointUID'] query['getSamplePointUID'] = sp_uid sp = rc.lookupObject(sp_uid) sp_title = sp.Title() self.parms.append( { 'title': _('Sample point'), 'value': sp_title, 'type': 'text'}) else: undefined.append('Sample point') # Date sampled date_query = formatDateQuery(self.context, 'DateSampled') if date_query: query['created'] = date_query sampled = formatDateParms(self.context, 'DateSampled') self.parms.append( { 'title': _('Sampled'), 'value': sampled, 'type': 'text'}) else: undefined.append('Sampled') # Date requested date_query = formatDateQuery(self.context, 'DateRequested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'DateRequested') self.parms.append( { 'title': _('Requested'), 'value': requested, 'type': 'text'}) else: undefined.append('Requested') # Date received date_query = formatDateQuery(self.context, 'DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'DateReceived') self.parms.append( { 'title': _('Received'), 'value': received, 'type': 'text'}) else: undefined.append('Received') # Date published date_query = formatDateQuery(self.context, 'DatePublished') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'DatePublished') self.parms.append( { 'title': _('Published'), 'value': published, 'type': 'text'}) else: undefined.append('Published') # Category if self.request.form.has_key('CategoryUID'): category_uid = self.request.form['CategoryUID'] query['getCategoryUID'] = category_uid category = rc.lookupObject(category_uid) category_title = category.Title() self.parms.append( { 'title': _('Category'), 'value': category_title, 'type': 'text'}) else: undefined.append('Category') # Analysis service if self.request.form.has_key('ServiceUID'): service_uid = self.request.form['ServiceUID'] query['getServiceUID'] = service_uid service = rc.lookupObject(service_uid) service_title = service.Title() self.parms.append( {'title': _('Analysis service'), 'value': service_title, 'type': 'text'}) else: undefined.append('Analysis service') # Analyst if self.request.form.has_key('Analyst'): analyst = self.request.form['Analyst'] query['getAnalyst'] = analyst analyst_name = self.user_fullname(analyst) self.parms.append( {'title': _('Analyst'), 'value': analyst_name, 'type': 'text'}) else: undefined.append('Analyst') # Status if self.request.form.has_key('review_state'): query['review_state'] = self.request.form['review_state'] review_state = workflow.getTitleForStateOnType( self.request.form['review_state'], 'Analysis') self.parms.append( {'title': _('Status'), 'value': review_state, 'type': 'text'}) else: undefined.append('Status') # Cancellation state if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form['cancellation_state'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['cancellation_state'], 'Analysis') self.parms.append( {'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) else: undefined.append('Active') # Assigned to worksheet if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form['ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') self.parms.append( {'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) else: undefined.append('Assigned to worksheet') # set up the undefined parameters in pretty format undefined_string = ', '.join(undefined) self.parms_undefined = [{'title': _('Parameters not defined'), 'value': undefined_string}] self.columns = batch_size + 1 # and now lets do the actual query lines self.formats = {'columns': self.columns, 'col_heads': [], 'class': '', } labels = ["Client order ID", "Client reference", "Client sample ID", "Client", "Contact", "Request ID", "Sample ID", "Profile", "Sample type", "Sample point", "Sampled", "Requested", "Received", "Published", "Status", "Submitted by", "Verified by"] for label in labels: self.datalines.append([{'value': _(label), 'class': 'header',}]) details = [] for i in range(len(self.datalines)): details.append([]) ars = bc(query) self.url = self.request.URL self.show_all = False self.batch = Batch(ars, batch_size, batch_start) analyses = [] analysis_dict = {} service_dict = {} ar_ids = [] for arp in self.batch: ar = arp.getObject() ar_ids.append(ar.getRequestID()) details[0].append({'value': ar.getClientOrderNumber()}) details[1].append({'value': ar.getClientReference()}) details[2].append({'value': ar.getClientSampleID()}) details[3].append({'value': ar.aq_parent.Title()}) details[4].append({'value': ar.getContact().Title()}) details[5].append({'value': ar.getRequestID()}) details[6].append({'value': ar.getSample().getSampleID()}) details[7].append({'value': ar.getProfile() and ar.getProfile().Title() or ' '}) details[8].append({'value': ar.getSampleTypeTitle()}) details[10].append({'value': self.ulocalized_time(ar.getSample().getDateSampled())}) details[11].append({'value': self.ulocalized_time(ar.created())}) details[12].append({'value': self.ulocalized_time(ar.getDateReceived())}) details[13].append({'value': self.ulocalized_time(ar.getDatePublished())}) details[14].append({'value': workflow.getInfoFor(ar, 'review_state')}) #details[15].append({'value': ar.getSubmittedBy().Title()}) details[15].append({'value': ' '}) #details[16].append({'value': ar.get_verifier().Title()}) details[16].append({'value': ' '}) #analyses for analysis in ar.getAnalyses(full_objects=True): service_uid = analysis.getServiceUID() if not analysis_dict.has_key(service_uid): service_dict[analysis.Title()] = service_uid analysis_dict[service_uid] = {} analysis_dict[service_uid][ar.getRequestID()] = analysis.getResult() if len(details[0]) == batch_size: break # load the detail lines for i in range(len(self.datalines)): self.datalines[i].extend(details[i]) # load the analysis lines service_titles = service_dict.keys() service_titles.sort() for service_title in service_titles: service_uid = service_dict[service_title] analysis_line = [{'value': service_title},] for ar_id in ar_ids: if analysis_dict[service_uid].has_key(ar_id): analysis_line.append({'value': analysis_dict[service_uid][ar_id]}) else: analysis_line.append({}) self.datalines.append(analysis_line) # footer data self.footlines = [] footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) self.footlines.append(footline) return self.template()
def __call__(self): bc = getToolByName(self.context, 'bika_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analysis requests not invoiced") headings['subheader'] = _( "Published Analysis Requests which have not been invoiced") count_all = 0 query = {'portal_type': 'AnalysisRequest', 'getInvoiced': False, 'review_state': 'published', 'sort_order': 'reverse'} date_query = formatDateQuery(self.context, 'c_DatePublished') if date_query: query['getDatePublished'] = date_query pubished = formatDateParms(self.context, 'c_DatePublished') else: pubished = 'Undefined' parms.append( {'title': _('Published'), 'value': pubished, 'type': 'text'}) if self.request.form.has_key('cancellation_state'): query['cancellation_state'] = self.request.form['cancellation_state'] cancellation_state = wf_tool.getTitleForStateOnType( self.request.form['cancellation_state'], 'AnalysisRequest') else: cancellation_state = 'Undefined' parms.append( {'title': _('Active'), 'value': cancellation_state, 'type': 'text'}) # and now lets do the actual report lines formats = {'columns': 6, 'col_heads': [_('Client'), \ _('Request'), \ _('Sample type'), \ _('Sample point'), \ _('Published'), \ _('Amount'), \ ], 'class': '', } datalines = [] clients = {} sampletypes = {} samplepoints = {} categories = {} services = {} for ar_proxy in bc(query): ar = ar_proxy.getObject() dataline = [] dataitem = {'value': ar.aq_parent.Title()} dataline.append(dataitem) dataitem = {'value': ar.getRequestID()} dataline.append(dataitem) dataitem = {'value': ar.getSampleTypeTitle()} dataline.append(dataitem) dataitem = {'value': ar.getSamplePointTitle()} dataline.append(dataitem) dataitem = {'value': self.ulocalized_time(ar.getDatePublished())} dataline.append(dataitem) dataitem = {'value': ar.getTotalPrice()} dataline.append(dataitem) datalines.append(dataline) count_all += 1 # table footer data footlines = [] footline = [] footitem = {'value': _('Number of analyses retested for period'), 'colspan': 5, 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return {'report_title': t(headings['header']), 'report_data': self.template()}
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analyses per analysis service") headings['subheader'] = _( "Number of analyses requested per analysis service") query = {'portal_type': 'Analysis'} client_title = None if 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() if client_title: parms.append({ 'title': _('Client'), 'value': client_title, 'type': 'text' }) date_query = formatDateQuery(self.context, 'Requested') if date_query: query['created'] = date_query requested = formatDateParms(self.context, 'Requested') parms.append({ 'title': _('Requested'), 'value': requested, 'type': 'text' }) date_query = formatDateQuery(self.context, 'Published') if date_query: query['getDatePublished'] = date_query published = formatDateParms(self.context, 'Published') parms.append({ 'title': _('Published'), 'value': published, 'type': 'text' }) workflow = getToolByName(self.context, 'portal_workflow') if 'bika_analysis_workflow' in self.request.form: query['review_state'] = self.request.form['bika_analysis_workflow'] review_state = workflow.getTitleForStateOnType( self.request.form['bika_analysis_workflow'], 'Analysis') parms.append({ 'title': _('Status'), 'value': review_state, 'type': 'text' }) if 'bika_cancellation_workflow' in self.request.form: query['cancellation_state'] = self.request.form[ 'bika_cancellation_workflow'] cancellation_state = workflow.getTitleForStateOnType( self.request.form['bika_cancellation_workflow'], 'Analysis') parms.append({ 'title': _('Active'), 'value': cancellation_state, 'type': 'text' }) if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) # and now lets do the actual report lines formats = { 'columns': 2, 'col_heads': [_('Analysis service'), _('Number of analyses')], 'class': '', } datalines = [] count_all = 0 for cat in sc(portal_type="AnalysisCategory", sort_on='sortable_title'): dataline = [ { 'value': cat.Title, 'class': 'category_heading', 'colspan': 2 }, ] datalines.append(dataline) for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on='sortable_title'): query['getServiceUID'] = service.UID analyses = bc(query) count_analyses = len(analyses) dataline = [] dataitem = {'value': service.Title} dataline.append(dataitem) dataitem = {'value': count_analyses} dataline.append(dataitem) datalines.append(dataline) count_all += count_analyses # footer data footlines = [] footline = [] footitem = {'value': _('Total'), 'class': 'total_label'} footline.append(footitem) footitem = {'value': count_all} footline.append(footitem) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } title = t(headings['header']) if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Analysis Service', 'Analyses', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: if len(row) == 1: # category heading thingy continue dw.writerow({ 'Analysis Service': row[0]['value'], 'Analyses': row[1]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader( "Content-Disposition", "attachment;filename=\"analysesperservice_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return {'report_title': title, 'report_data': self.template()}
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times") headings['subheader'] = _("The turnaround time of analyses") count_all = 0 query = {'portal_type': 'Analysis'} if self.request.form.has_key('getClientUID'): client_uid = self.request.form['getClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = 'Undefined' parms.append( { 'title': _('Client'), 'value': client_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'DateReceived') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'DateReceived') else: received = 'Undefined' parms.append( { 'title': _('Received'), 'value': received, 'type': 'text'}) query['review_state'] = 'published' if self.request.form.has_key('ws_review_state'): query['worksheetanalysis_review_state'] = self.request.form['ws_review_state'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['ws_review_state'], 'Analysis') else: ws_review_state = 'Undefined' parms.append( { 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # query all the analyses and increment the counts count_early = 0 mins_early = 0 count_late = 0 mins_late = 0 count_undefined = 0 services = {} analyses = bc(query) for a in analyses: analysis = a.getObject() service_uid = analysis.getServiceUID() if not services.has_key(service_uid): services[service_uid] = {'count_early': 0, 'count_late': 0, 'mins_early': 0, 'mins_late': 0, 'count_undefined': 0, } earliness = analysis.getEarliness() if earliness < 0: count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] count_late += 1 mins_late -= earliness services[service_uid]['count_late'] = count_late services[service_uid]['mins_late'] = mins_late if earliness > 0: count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] count_early += 1 mins_early += earliness services[service_uid]['count_early'] = count_early services[service_uid]['mins_early'] = mins_early if earliness == 0: count_undefined = services[service_uid]['count_undefined'] count_undefined += 1 services[service_uid]['count_undefined'] = count_undefined # calculate averages for service_uid in services.keys(): count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] if count_early == 0: services[service_uid]['ave_early'] = '' else: avemins = (mins_early) / count_early services[service_uid]['ave_early'] = formatDuration(self.context, avemins) count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] if count_late == 0: services[service_uid]['ave_late'] = '' else: avemins = mins_late / count_late services[service_uid]['ave_late'] = formatDuration(self.context, avemins) # and now lets do the actual report lines formats = {'columns': 7, 'col_heads': [ _('Analysis'), \ _('Count'), \ _('Undefined'), \ _('Late'), \ _('Average late'), \ _('Early'), \ _('Average early'), \ ], 'class': '', } total_count_early = 0 total_count_late = 0 total_mins_early = 0 total_mins_late = 0 total_count_undefined = 0 datalines = [] for cat in sc(portal_type='AnalysisCategory', sort_on='sortable_title'): catline = [{'value': cat.Title, 'class': 'category', 'colspan': 7},] first_time = True cat_count_early = 0 cat_count_late = 0 cat_count_undefined = 0 cat_mins_early = 0 cat_mins_late = 0 for service in sc(portal_type="AnalysisService", getCategoryUID = cat.UID, sort_on='sortable_title'): dataline = [{'value': service.Title, 'class': 'testgreen'},] if not services.has_key(service.UID): continue if first_time: datalines.append(catline) first_time = False # analyses found cat_count_early += services[service.UID]['count_early'] cat_count_late += services[service.UID]['count_late'] cat_count_undefined += services[service.UID]['count_undefined'] cat_mins_early += services[service.UID]['mins_early'] cat_mins_late += services[service.UID]['mins_late'] count = services[service.UID]['count_early'] + \ services[service.UID]['count_late'] + \ services[service.UID]['count_undefined'] dataline.append({'value': count, 'class' : 'number'}) dataline.append({'value': services[service.UID]['count_undefined'], 'class' : 'number'}) dataline.append({'value': services[service.UID]['count_late'], 'class' : 'number'}) dataline.append({'value': services[service.UID]['ave_late'], 'class' : 'number'}) dataline.append({'value': services[service.UID]['count_early'], 'class' : 'number'}) dataline.append({'value': services[service.UID]['ave_early'], 'class' : 'number'}) datalines.append(dataline) # category totals dataline = [{'value': '%s - total' %(cat.Title), 'class': 'subtotal_label'}, ] dataline.append({'value' : cat_count_early + \ cat_count_late + \ cat_count_undefined, 'class' : 'subtotal_number'}) dataline.append({'value' : cat_count_undefined, 'class' : 'subtotal_number'}) dataline.append({'value' : cat_count_late, 'class' : 'subtotal_number'}) if cat_count_late: dataitem = {'value' : cat_mins_late / cat_count_late, 'class' : 'subtotal_number'} else: dataitem = {'value' : 0, 'class' : 'subtotal_number'} dataline.append(dataitem) dataline.append({'value' : cat_count_early, 'class' : 'subtotal_number'}) if cat_count_early: dataitem = {'value' : cat_mins_early / cat_count_early, 'class' : 'subtotal_number'} else: dataitem = {'value' : 0, 'class' : 'subtotal_number'} dataline.append(dataitem) total_count_early += cat_count_early total_count_late += cat_count_late total_count_undefined += cat_count_undefined total_mins_early += cat_mins_early total_mins_late += cat_mins_late # footer data footlines = [] footline = [] footline = [{'value': _('Total'), 'class': 'total'}, ] footline.append({'value' : total_count_early + \ total_count_late + \ total_count_undefined, 'class' : 'total number'}) footline.append({'value' : total_count_undefined, 'class' : 'total number'}) footline.append({'value' : total_count_late, 'class' : 'total number'}) if total_count_late: ave_mins = total_mins_late / total_count_late footline.append({'value' : formatDuration(self.context, ave_mins), 'class' : 'total number'}) else: footline.append({'value' : ''}) footline.append({'value' : total_count_early, 'class' : 'total number'}) if total_count_early: ave_mins = total_mins_early / total_count_early footline.append({'value' : formatDuration(self.context, ave_mins), 'class' : 'total number'}) else: footline.append({'value' : '', 'class' : 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} return self.template()
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times") headings['subheader'] = _("The turnaround time of analyses") query = {'portal_type': 'Analysis'} client_title = None if 'ClientUID' in self.request.form: client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() if client_title: parms.append( {'title': _('Client'), 'value': client_title, 'type': 'text'}) date_query = formatDateQuery(self.context, 'Received') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'Received') parms.append( {'title': _('Received'), 'value': received, 'type': 'text'}) query['review_state'] = 'published' workflow = getToolByName(self.context, 'portal_workflow') if 'bika_worksheetanalysis_workflow' in self.request.form: query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append( {'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text'}) # query all the analyses and increment the counts count_early = 0 mins_early = 0 count_late = 0 mins_late = 0 count_undefined = 0 services = {} analyses = bc(query) for a in analyses: analysis = a.getObject() service_uid = analysis.getServiceUID() if service_uid not in services: services[service_uid] = {'count_early': 0, 'count_late': 0, 'mins_early': 0, 'mins_late': 0, 'count_undefined': 0, } earliness = analysis.getEarliness() if earliness < 0: count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] count_late += 1 mins_late -= earliness services[service_uid]['count_late'] = count_late services[service_uid]['mins_late'] = mins_late if earliness > 0: count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] count_early += 1 mins_early += earliness services[service_uid]['count_early'] = count_early services[service_uid]['mins_early'] = mins_early if earliness == 0: count_undefined = services[service_uid]['count_undefined'] count_undefined += 1 services[service_uid]['count_undefined'] = count_undefined # calculate averages for service_uid in services.keys(): count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] if count_early == 0: services[service_uid]['ave_early'] = '' else: avemins = (mins_early) / count_early services[service_uid]['ave_early'] = formatDuration(self.context, avemins) count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] if count_late == 0: services[service_uid]['ave_late'] = '' else: avemins = mins_late / count_late services[service_uid]['ave_late'] = formatDuration(self.context, avemins) # and now lets do the actual report lines formats = {'columns': 7, 'col_heads': [_('Analysis'), _('Count'), _('Undefined'), _('Late'), _('Average late'), _('Early'), _('Average early'), ], 'class': '', } total_count_early = 0 total_count_late = 0 total_mins_early = 0 total_mins_late = 0 total_count_undefined = 0 datalines = [] for cat in sc(portal_type='AnalysisCategory', sort_on='sortable_title'): catline = [{'value': cat.Title, 'class': 'category_heading', 'colspan': 7}, ] first_time = True cat_count_early = 0 cat_count_late = 0 cat_count_undefined = 0 cat_mins_early = 0 cat_mins_late = 0 for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on='sortable_title'): dataline = [{'value': service.Title, 'class': 'testgreen'}, ] if service.UID not in services: continue if first_time: datalines.append(catline) first_time = False # analyses found cat_count_early += services[service.UID]['count_early'] cat_count_late += services[service.UID]['count_late'] cat_count_undefined += services[service.UID]['count_undefined'] cat_mins_early += services[service.UID]['mins_early'] cat_mins_late += services[service.UID]['mins_late'] count = services[service.UID]['count_early'] + \ services[service.UID]['count_late'] + \ services[service.UID]['count_undefined'] dataline.append({'value': count, 'class': 'number'}) dataline.append( {'value': services[service.UID]['count_undefined'], 'class': 'number'}) dataline.append({'value': services[service.UID]['count_late'], 'class': 'number'}) dataline.append({'value': services[service.UID]['ave_late'], 'class': 'number'}) dataline.append({'value': services[service.UID]['count_early'], 'class': 'number'}) dataline.append({'value': services[service.UID]['ave_early'], 'class': 'number'}) datalines.append(dataline) # category totals dataline = [{'value': '%s - total' % (cat.Title), 'class': 'subtotal_label'}, ] dataline.append({'value': cat_count_early + cat_count_late + cat_count_undefined, 'class': 'subtotal_number'}) dataline.append({'value': cat_count_undefined, 'class': 'subtotal_number'}) dataline.append({'value': cat_count_late, 'class': 'subtotal_number'}) if cat_count_late: dataitem = {'value': cat_mins_late / cat_count_late, 'class': 'subtotal_number'} else: dataitem = {'value': 0, 'class': 'subtotal_number'} dataline.append(dataitem) dataline.append({'value': cat_count_early, 'class': 'subtotal_number'}) if cat_count_early: dataitem = {'value': cat_mins_early / cat_count_early, 'class': 'subtotal_number'} else: dataitem = {'value': 0, 'class': 'subtotal_number'} dataline.append(dataitem) total_count_early += cat_count_early total_count_late += cat_count_late total_count_undefined += cat_count_undefined total_mins_early += cat_mins_early total_mins_late += cat_mins_late # footer data footlines = [] footline = [] footline = [{'value': _('Total'), 'class': 'total'}, ] footline.append({'value': total_count_early + total_count_late + total_count_undefined, 'class': 'total number'}) footline.append({'value': total_count_undefined, 'class': 'total number'}) footline.append({'value': total_count_late, 'class': 'total number'}) if total_count_late: ave_mins = total_mins_late / total_count_late footline.append({'value': formatDuration(self.context, ave_mins), 'class': 'total number'}) else: footline.append({'value': ''}) footline.append({'value': total_count_early, 'class': 'total number'}) if total_count_early: ave_mins = total_mins_early / total_count_early footline.append({'value': formatDuration(self.context, ave_mins), 'class': 'total number'}) else: footline.append({'value': '', 'class': 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines} if self.request.get('output_format', '') == 'CSV': import csv import StringIO import datetime fieldnames = [ 'Analysis', 'Count', 'Undefined', 'Late', 'Average late', 'Early', 'Average early', ] output = StringIO.StringIO() dw = csv.DictWriter(output, extrasaction='ignore', fieldnames=fieldnames) dw.writerow(dict((fn, fn) for fn in fieldnames)) for row in datalines: if len(row) == 1: # category heading thingy continue dw.writerow({ 'Analysis': row[0]['value'], 'Count': row[1]['value'], 'Undefined': row[2]['value'], 'Late': row[3]['value'], 'Average late': row[4]['value'], 'Early': row[5]['value'], 'Average early': row[6]['value'], }) report_data = output.getvalue() output.close() date = datetime.datetime.now().strftime("%Y%m%d%H%M") setheader = self.request.RESPONSE.setHeader setheader('Content-Type', 'text/csv') setheader("Content-Disposition", "attachment;filename=\"analysestats_%s.csv\"" % date) self.request.RESPONSE.write(report_data) else: return {'report_title': t(headings['header']), 'report_data': self.template()}
def __call__(self): # get all the data into datalines sc = getToolByName(self.context, 'bika_setup_catalog') bc = getToolByName(self.context, 'bika_analysis_catalog') rc = getToolByName(self.context, 'reference_catalog') self.report_content = {} parm_lines = {} parms = [] headings = {} headings['header'] = _("Analysis turnaround times") headings['subheader'] = _("The turnaround time of analyses") count_all = 0 query = {'portal_type': 'Analysis'} if self.request.form.has_key('ClientUID'): client_uid = self.request.form['ClientUID'] query['getClientUID'] = client_uid client = rc.lookupObject(client_uid) client_title = client.Title() else: client = logged_in_client(self.context) if client: client_title = client.Title() query['getClientUID'] = client.UID() else: client_title = 'Undefined' parms.append({ 'title': _('Client'), 'value': client_title, 'type': 'text' }) date_query = formatDateQuery(self.context, 'Received') if date_query: query['created'] = date_query received = formatDateParms(self.context, 'Received') else: received = 'Undefined' parms.append({ 'title': _('Received'), 'value': received, 'type': 'text' }) query['review_state'] = 'published' workflow = getToolByName(self.context, 'portal_workflow') if self.request.form.has_key('bika_worksheetanalysis_workflow'): query['worksheetanalysis_review_state'] = self.request.form[ 'bika_worksheetanalysis_workflow'] ws_review_state = workflow.getTitleForStateOnType( self.request.form['bika_worksheetanalysis_workflow'], 'Analysis') parms.append({ 'title': _('Assigned to worksheet'), 'value': ws_review_state, 'type': 'text' }) # query all the analyses and increment the counts count_early = 0 mins_early = 0 count_late = 0 mins_late = 0 count_undefined = 0 services = {} analyses = bc(query) for a in analyses: analysis = a.getObject() service_uid = analysis.getServiceUID() if not services.has_key(service_uid): services[service_uid] = { 'count_early': 0, 'count_late': 0, 'mins_early': 0, 'mins_late': 0, 'count_undefined': 0, } earliness = analysis.getEarliness() if earliness < 0: count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] count_late += 1 mins_late -= earliness services[service_uid]['count_late'] = count_late services[service_uid]['mins_late'] = mins_late if earliness > 0: count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] count_early += 1 mins_early += earliness services[service_uid]['count_early'] = count_early services[service_uid]['mins_early'] = mins_early if earliness == 0: count_undefined = services[service_uid]['count_undefined'] count_undefined += 1 services[service_uid]['count_undefined'] = count_undefined # calculate averages for service_uid in services.keys(): count_early = services[service_uid]['count_early'] mins_early = services[service_uid]['mins_early'] if count_early == 0: services[service_uid]['ave_early'] = '' else: avemins = (mins_early) / count_early services[service_uid]['ave_early'] = formatDuration( self.context, avemins) count_late = services[service_uid]['count_late'] mins_late = services[service_uid]['mins_late'] if count_late == 0: services[service_uid]['ave_late'] = '' else: avemins = mins_late / count_late services[service_uid]['ave_late'] = formatDuration( self.context, avemins) # and now lets do the actual report lines formats = {'columns': 7, 'col_heads': [ _('Analysis'), \ _('Count'), \ _('Undefined'), \ _('Late'), \ _('Average late'), \ _('Early'), \ _('Average early'), \ ], 'class': '', } total_count_early = 0 total_count_late = 0 total_mins_early = 0 total_mins_late = 0 total_count_undefined = 0 datalines = [] for cat in sc(portal_type='AnalysisCategory', sort_on='sortable_title'): catline = [ { 'value': cat.Title, 'class': 'category_heading', 'colspan': 7 }, ] first_time = True cat_count_early = 0 cat_count_late = 0 cat_count_undefined = 0 cat_mins_early = 0 cat_mins_late = 0 for service in sc(portal_type="AnalysisService", getCategoryUID=cat.UID, sort_on='sortable_title'): dataline = [ { 'value': service.Title, 'class': 'testgreen' }, ] if not services.has_key(service.UID): continue if first_time: datalines.append(catline) first_time = False # analyses found cat_count_early += services[service.UID]['count_early'] cat_count_late += services[service.UID]['count_late'] cat_count_undefined += services[service.UID]['count_undefined'] cat_mins_early += services[service.UID]['mins_early'] cat_mins_late += services[service.UID]['mins_late'] count = services[service.UID]['count_early'] + \ services[service.UID]['count_late'] + \ services[service.UID]['count_undefined'] dataline.append({'value': count, 'class': 'number'}) dataline.append({ 'value': services[service.UID]['count_undefined'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['count_late'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['ave_late'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['count_early'], 'class': 'number' }) dataline.append({ 'value': services[service.UID]['ave_early'], 'class': 'number' }) datalines.append(dataline) # category totals dataline = [ { 'value': '%s - total' % (cat.Title), 'class': 'subtotal_label' }, ] dataline.append({'value' : cat_count_early + \ cat_count_late + \ cat_count_undefined, 'class' : 'subtotal_number'}) dataline.append({ 'value': cat_count_undefined, 'class': 'subtotal_number' }) dataline.append({ 'value': cat_count_late, 'class': 'subtotal_number' }) if cat_count_late: dataitem = { 'value': cat_mins_late / cat_count_late, 'class': 'subtotal_number' } else: dataitem = {'value': 0, 'class': 'subtotal_number'} dataline.append(dataitem) dataline.append({ 'value': cat_count_early, 'class': 'subtotal_number' }) if cat_count_early: dataitem = { 'value': cat_mins_early / cat_count_early, 'class': 'subtotal_number' } else: dataitem = {'value': 0, 'class': 'subtotal_number'} dataline.append(dataitem) total_count_early += cat_count_early total_count_late += cat_count_late total_count_undefined += cat_count_undefined total_mins_early += cat_mins_early total_mins_late += cat_mins_late # footer data footlines = [] footline = [] footline = [ { 'value': _('Total'), 'class': 'total' }, ] footline.append({'value' : total_count_early + \ total_count_late + \ total_count_undefined, 'class' : 'total number'}) footline.append({ 'value': total_count_undefined, 'class': 'total number' }) footline.append({'value': total_count_late, 'class': 'total number'}) if total_count_late: ave_mins = total_mins_late / total_count_late footline.append({ 'value': formatDuration(self.context, ave_mins), 'class': 'total number' }) else: footline.append({'value': ''}) footline.append({'value': total_count_early, 'class': 'total number'}) if total_count_early: ave_mins = total_mins_early / total_count_early footline.append({ 'value': formatDuration(self.context, ave_mins), 'class': 'total number' }) else: footline.append({'value': '', 'class': 'total number'}) footlines.append(footline) self.report_content = { 'headings': headings, 'parms': parms, 'formats': formats, 'datalines': datalines, 'footings': footlines } title = self.context.translate(headings['header']) return {'report_title': title, 'report_data': self.template()}