def jsonByType(self, rooted, document_base_url, searchtext, page='1'):
""" Returns the actual listing """
catalog_results = []
results = {}
obj = self.obj
catalog = api.portal.get_tool('portal_catalog')
normalizer = getUtility(IIDNormalizer)
if 'filter_portal_types' in self.request.keys():
self.filter_portal_types = self.request['filter_portal_types']
else:
self.filter_portal_types = [i[0] for i in self._getCurrentValues()]
if INavigationRoot.providedBy(obj) or (rooted == 'True'
and document_base_url[:-1]
== obj.absolute_url()):
results['parent_url'] = ''
else:
results['parent_url'] = aq_parent(obj).absolute_url()
if rooted == 'True':
results['path'] = self.getBreadcrumbs(results['parent_url'])
else:
# get all items from siteroot to context (title and url)
results['path'] = self.getBreadcrumbs()
# get all portal types and get information from brains
path = '/'.join(obj.getPhysicalPath())
catalog_query = {'sort_on': 'getObjPositionInParent'}
catalog_query['portal_type'] = self.filter_portal_types
catalog_query['path'] = {'query': path, 'depth': 1}
if searchtext:
catalog_query['Title'] = '{0}*'.format(searchtext)
brains = catalog(**catalog_query)
page = int(page, 10)
start = (page - 1) * ITEMS_BY_REQUEST
brains = Batch(brains, size=ITEMS_BY_REQUEST, start=start, orphan=0)
results['has_next'] = brains.next is not None
results['nextpage'] = brains.pagenumber + 1
results['total_results'] = len(brains)
for brain in brains:
catalog_results.append({
'id':
brain.getId,
'uuid':
brain.UID or None, # Maybe Missing.Value
'url':
brain.getURL(),
'portal_type':
brain.portal_type,
'normalized_type':
normalizer.normalize(brain.portal_type),
'classicon':
'contenttype-{0}'.format(
normalizer.normalize(brain.portal_type)),
'r_state':
'state-{0}'.format(
normalizer.normalize(brain.review_state or '')),
'title':
brain.Title == '' and brain.id or brain.Title,
'icon':
self.getIcon(brain).url or '',
'is_folderish':
brain.is_folderish,
'description':
brain.Description or ''
})
# add catalog_ressults
results['items'] = catalog_results
# return results in JSON format
return json.dumps(results)
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 batch(self):
start = int(self.request.get('b_start') or 0)
return Batch(self.items, ITEMSPERPAGE, start, orphan=1)
def solrResults(self, query, batch=True, b_size=20, b_start=0):
"""
Do the search with solr.
Add to the query some solr parameters.
"""
solr_config = getUtility(ISolrConnectionConfig)
for field in solr_config.required:
query[field] = True
query['facet'] = 'true'
indexes_list = self.available_indexes.keys()
indexes_list.append('portal_type')
query['facet_field'] = indexes_list
if batch:
query['b_size'] = b_size
query['b_start'] = b_start
results = self.catalog(**query)
res_dict = {'tabs': ['all']}
if results.actual_result_count is None:
res_dict['tot_results_len'] = 0
return res_dict
res_dict['tot_results_len'] = results.actual_result_count
filtered_results = []
global_facet_counts = getattr(results, 'facet_counts', None)
if global_facet_counts:
if hasattr(global_facet_counts, 'facet_fields'):
# new c.solr with scorched lib
facets = dict(
(k, dict(v))
for k, v in global_facet_counts.facet_fields.items())
else:
# old c.solr
facets = global_facet_counts.get('facet_fields', {})
res_dict['tabs'] = self.solrAvailableTabs(facets)
active_tab = self.context.REQUEST.form.get('filter_tab')
if active_tab:
filtered_results = self.doFilteredSearch(active_tab, query)
else:
if self.tabs_order[0] != "all":
for tab_id in self.tabs_order:
filtered_results = self.doFilteredSearch(tab_id, query)
if filtered_results:
break
if filtered_results:
facet_counts = getattr(filtered_results, 'facet_counts', None)
results = IContentListing(filtered_results)
else:
facet_counts = getattr(results, 'facet_counts', None)
results = IContentListing(results)
if batch:
results = Batch(results, b_size, b_start)
res_dict['results'] = results
if facet_counts:
if hasattr(facet_counts, 'facet_fields'):
# new c.solr with scorched lib
facets = dict(
(k, dict(v)) for k, v in facet_counts.facet_fields.items())
else:
# old c.solr
facets = facet_counts.get('facet_fields', {})
res_dict['indexes_dict'] = self.solrFacetsFormatter(facets)
return res_dict
