def get_age(datetime_from, datetime_to=None):
"""Returns the elapsed time in years, months and days between the two
dates passed in."""
if not datetime_to:
datetime_to = DateTime()
if not bapi.is_date(datetime_from) or not bapi.is_date(datetime_to):
bapi.fail("Only DateTime and datetype types are supported")
dfrom = DT2dt(bapi.to_date(datetime_from)).replace(tzinfo=None)
dto = DT2dt(bapi.to_date(datetime_to)).replace(tzinfo=None)
diff = relativedelta(dto, dfrom)
return (diff.years, diff.months, diff.days)
def make_proxy(
obj, event, target, suffix=''):
"""
Create a proxy in a target for a given syndication action.
"""
portal_properties = getToolByName(obj, 'portal_properties')
encoding = portal_properties.site_properties.getProperty(
'default_charset', 'utf-8')
workflow = getToolByName(obj, 'portal_workflow')
unique_id = INameChooser(target)._findUniqueName(
obj.getId() + suffix, None)
proxy = sudo(target.invokeFactory,
type_name='resonate.proxy',
id=unique_id)
proxy = target[proxy]
proxy.title = obj.Title().decode(encoding)
proxy.description = obj.Description().decode(encoding)
proxy.source_type = obj.portal_type
# Submit for publication, so the item shows up in the review list
sudo(workflow.doActionFor, proxy, 'submit')
# Set proxy to pending syndication so reviewer can accept/reject;
# Use the workflow object's doActionFor so that IAfterTransitionEvent
# gets fired correctly
referenceable.IReferenceable(obj).addReference(
referenceable.IReferenceable(proxy),
relationship='current_syndication_targets')
if event_behaviors.IEventBasic.providedBy(obj):
for attr in ('start', 'end'):
prop = getattr(obj, attr)
if callable(prop):
prop = DT2dt(prop())
setattr(proxy, attr, prop)
sudo(workflow.doActionFor, proxy, event.transition.id)
def to_review_history_info(review_history):
""" return the transition information
"""
converted = DT2dt(review_history.get('time')).\
strftime("%Y-%m-%d %H:%M:%S")
review_history['time'] = converted
return review_history
def date_to_query_literal(date, date_format=_default_date_format):
""" Convert a date to a valid JSONAPI URL query string.
:param date: date to be converted in datetime, DateTime or string format
:param date_format: in case the date is string, format to parse it
:return string: literal date
"""
if not date:
return None
if isinstance(date, DateTime):
date = DT2dt(date)
if isinstance(date, basestring):
date = datetime.strptime(date, date_format)
days = (datetime.now() - date).days
if days < 1:
return "today"
if days < 2:
return "yesterday"
if days < 8:
return "this-week"
if days < 32:
return "this-month"
if days < 367:
return "this-year"
logger.warn(
"Interval is too long to be converted to string: {} days".format(days))
return ""
def to_date(obj, key, value, dfmt="%d.%m.%Y"):
"""to date
"""
if isinstance(value, DateTime):
return DT2dt(value).strftime(dfmt)
elif isinstance(value, datetime):
return value.strftime(dfmt)
return value
def folderitem(self, obj, item, index):
"""Applies new properties to the item (Client) that is currently being
rendered as a row in the list
:param obj: client to be rendered as a row in the list
:param item: dict representation of the client, suitable for the list
:param index: current position of the item within the list
:type obj: ATContentType/DexterityContentType
:type item: dict
:type index: int
:return: the dict representation of the item
:rtype: dict
"""
obj = api.get_object(obj)
# XXX Refactor expiration to a proper place
# ---------------------------- 8< -------------------------------------
if item.get("review_state", "current") == "current":
# Check expiry date
exdate = obj.getExpiryDate()
if exdate:
expirydate = DT2dt(exdate).replace(tzinfo=None)
if (datetime.today() > expirydate):
# Trigger expiration
self.workflow.doActionFor(obj, "expire")
item["review_state"] = "expired"
item["obj"] = obj
if self.contentFilter.get('review_state', '') \
and item.get('review_state', '') == 'expired':
# This item must be omitted from the list
return None
# ---------------------------- >8 -------------------------------------
url = api.get_url(obj)
id = api.get_id(obj)
item["ID"] = id
item["replace"]["ID"] = get_link(url, value=id)
item["DateSampled"] = self.ulocalized_time(
obj.getDateSampled(), long_format=True)
item["DateReceived"] = self.ulocalized_time(obj.getDateReceived())
item["DateOpened"] = self.ulocalized_time(obj.getDateOpened())
item["ExpiryDate"] = self.ulocalized_time(obj.getExpiryDate())
# Icons
after_icons = ''
if obj.getBlank():
after_icons += get_image(
"blank.png", title=t(_("Blank")))
if obj.getHazardous():
after_icons += get_image(
"hazardous.png", title=t(_("Hazardous")))
if after_icons:
item["after"]["ID"] = after_icons
return item
def __was_new(self, dates, created):
"""
checks if article was recent when download occured
"""
delta = int(self.request['days'])
# convert old Zope DateTime to python datetime
obj_date = DT2dt(created).replace(tzinfo=None)
d = datetime.timedelta(days=delta)
return len(filter(lambda date: gt(obj_date, sub(date, d)), dates))
def to_datetime(date_value, default=None, tzinfo=None):
if isinstance(date_value, datetime):
return date_value
# Get the DateTime
date_value = api.to_date(date_value, default=None)
if not date_value:
if default is None:
return None
return to_datetime(default, tzinfo=tzinfo)
# Convert to datetime and strip
return DT2dt(date_value).replace(tzinfo=tzinfo)
def getDueDate(self):
"""Used to populate getDueDate index and metadata.
This calculates the difference between the time the analysis processing
started and the maximum turnaround time. If the analysis has no
turnaround time set or is not yet ready for proces, returns None
"""
tat = self.getMaxTimeAllowed()
if not tat:
return None
start = self.getStartProcessDate()
if not start:
return None
return dt2DT(DT2dt(start) + timedelta(minutes=api.to_minutes(**tat)))
def getRespondentDetails(self, respondent):
"""Return details of a respondent"""
try:
self.respondents
except AttributeError:
self.reset()
try:
details = self.respondents[respondent]
except KeyError:
# TODO try/except should be removed at some point
# probably old survey, create respondent details
self.respondents[respondent] = PersistentMapping(start='',
ip_address='',
end='')
details_dict = {}
details = self.respondents[respondent]
for k in details.keys():
details_dict[k] = details[k]
if details['start'] and details['end']:
details_dict['time_taken'] = DT2dt(details['end']) - DT2dt(
details['start'])
else:
details_dict['time_taken'] = ''
return details_dict
def disposal_date(self):
""" Calculate the disposal date by returning the latest
disposal date in this sample's partitions """
parts = self.objectValues("SamplePartition")
dates = []
for part in parts:
date = part.getDisposalDate()
if date:
dates.append(date)
if dates:
dis_date = dt2DT(max([DT2dt(date) for date in dates]))
else:
dis_date = None
return dis_date
def getAgeSplitted(self):
if (self.getBirthDate()):
dob = DT2dt(self.getBirthDate()).replace(tzinfo=None)
now = datetime.today()
currentday = now.day
currentmonth = now.month
currentyear = now.year
birthday = dob.day
birthmonth = dob.month
birthyear = dob.year
ageday = currentday - birthday
agemonth = 0
ageyear = 0
months31days = [1, 3, 5, 7, 8, 10, 12]
if (ageday < 0):
currentmonth -= 1
if (currentmonth < 1):
currentyear -= 1
currentmonth = currentmonth + 12
dayspermonth = 30
if currentmonth in months31days:
dayspermonth = 31
elif currentmonth == 2:
dayspermonth = 28
if(currentyear % 4 == 0
and (currentyear % 100 > 0 or currentyear % 400 == 0)):
dayspermonth += 1
ageday = ageday + dayspermonth
agemonth = currentmonth - birthmonth
if (agemonth < 0):
currentyear -= 1
agemonth = agemonth + 12
ageyear = currentyear - birthyear
return [{'year': ageyear,
'month': agemonth,
'day': ageday}]
else:
return [{'year': '',
'month': '',
'day': ''}]
def folderitems(self):
items = super(ReferenceSamplesView, self).folderitems()
outitems = []
workflow = getToolByName(self.context, 'portal_workflow')
for x in range(len(items)):
if not items[x].has_key('obj'): continue
obj = items[x]['obj']
if workflow.getInfoFor(obj, 'review_state') == 'current':
# Check expiry date
from Products.ATContentTypes.utils import DT2dt
from datetime import datetime
exdate = obj.getExpiryDate()
if exdate:
expirydate = DT2dt(exdate).replace(tzinfo=None)
if (datetime.today() > expirydate):
workflow.doActionFor(obj, 'expire')
items[x]['review_state'] = 'expired'
items[x]['obj'] = obj
if 'review_state' in self.contentFilter \
and self.contentFilter['review_state'] == 'current':
continue
items[x]['ID'] = obj.id
items[x]['replace']['Supplier'] = "<a href='%s'>%s</a>" % \
(obj.aq_parent.absolute_url(), obj.aq_parent.Title())
if obj.getReferenceDefinition():
items[x]['replace']['Definition'] = "<a href='%s'>%s</a>" % \
(obj.getReferenceDefinition().absolute_url(), obj.getReferenceDefinition().Title())
else:
items[x]['Definition'] = ' '
items[x]['DateSampled'] = self.ulocalized_time(
obj.getDateSampled(), long_format=True)
items[x]['DateReceived'] = self.ulocalized_time(
obj.getDateReceived())
items[x]['ExpiryDate'] = self.ulocalized_time(obj.getExpiryDate())
after_icons = ''
if obj.getBlank():
after_icons += "<img src='++resource++bika.lims.images/blank.png' title='Blank'>"
if obj.getHazardous():
after_icons += "<img src='++resource++bika.lims.images/hazardous.png' title='Hazardous'>"
items[x]['replace']['ID'] = "<a href='%s'>%s</a> %s" % \
(items[x]['url'], items[x]['ID'], after_icons)
outitems.append(items[x])
return outitems
def get_member_list(context):
""" Get member list
"""
membership_tool = getToolByName(context, 'portal_membership')
memdata_tool = getToolByName(context, 'portal_memberdata')
# Get members and orphaned members
for member_id in memdata_tool._members:
member = membership_tool.getMemberById(member_id)
if member is None:
continue
member_history = IAnnotations(member).get('login_history', None)
date, ip = DT2dt(member.getProperty('login_time')), None
if member_history:
date = member_history[-1]['date']
ip = member_history[-1]['ip']
yield dict(member=member, date=date, ip=ip)
def addToJSON(self, analysis, service, item):
""" Adds an analysis item to the self.anjson dict that will be used
after the page is rendered to generate a QC Chart
"""
parent = analysis.aq_parent
qcid = parent.id
serviceref = "%s (%s)" % (item['Service'], item['Keyword'])
trows = self.anjson.get(serviceref, {})
anrows = trows.get(qcid, [])
anid = '%s.%s' % (item['getReferenceAnalysesGroupID'], item['id'])
rr = parent.getResultsRangeDict()
uid = service.UID()
if uid in rr:
specs = rr.get(uid, None)
smin = float(specs.get('min', 0))
smax = float(specs.get('max', 0))
error = float(specs.get('error', 0))
target = float(specs.get('result', 0))
result = float(item['Result'])
error_amount = ((target / 100) * error) if target > 0 else 0
upper = smax + error_amount
lower = smin - error_amount
# ALS # XXX This is still odd in master, when the date format is changed
# this must be the same as the format for the x axis in
# bika.lims.graphics.controlchart.js
format = "%Y-%m-%d %I:%M %p"
cd = DT2dt(analysis.getResultCaptureDate()).strftime(format)
anrow = {
'date': item['Captured'],
'min': smin,
'max': smax,
'target': target,
'error': error,
'erroramount': error_amount,
'upper': upper,
'lower': lower,
'result': result,
'unit': item['Unit'],
'id': item['uid']
}
anrows.append(anrow)
trows[qcid] = anrows
self.anjson[serviceref] = trows
def getDueDate(self):
"""Used to populate getDueDate index and metadata.
This calculates the difference between the time the analysis processing
started and the maximum turnaround time. If the analysis has no
turnaround time set or is not yet ready for proces, returns None
"""
tat = self.getMaxTimeAllowed()
if not tat:
return None
start = self.getStartProcessDate()
if not start:
return None
# delta time when the first analysis is considered as late
delta = timedelta(minutes=api.to_minutes(**tat))
# calculated due date
end = dt2DT(DT2dt(start) + delta)
# delta is within one day, return immediately
if delta.days == 0:
return end
# get the laboratory workdays
setup = api.get_setup()
workdays = setup.getWorkdays()
# every day is a workday, no need for calculation
if workdays == tuple(map(str, range(7))):
return end
# reset the due date to the received date, and add only for configured
# workdays another day
due_date = end - delta.days
days = 0
while days < delta.days:
# add one day to the new due date
due_date += 1
# skip if the weekday is a non working day
if str(due_date.asdatetime().weekday()) not in workdays:
continue
days += 1
return due_date
def dataset_pid(paper):
"""
necessary since Dataverse switched to DOI (2013-10-01)
"""
def format_doi(doi):
if not doi.lower().startswith('doi:'):
doi = 'doi:{}'.format(doi)
return doi.replace('DOI:', 'doi:')
def format_hdl(hdl):
return "hdl:1902.1/{}".format(hdl)
pid = paper.getDataset()
switch_date = datetime.datetime(2013, 9, 30)
paper_date = DT2dt(paper.created()).replace(tzinfo=None)
if switch_date > paper_date:
return format_hdl(pid)
return format_doi(pid)
def disposal_date(self):
"""Returns the date the retention period ends for this sample based on
the retention period from the Sample Type. If the sample hasn't been
collected yet, returns None
"""
date_sampled = self.getDateSampled()
if not date_sampled:
return None
# TODO Preservation - preservation's retention period has priority over
# sample type's preservation period
retention_period = self.getSampleType().getRetentionPeriod() or {}
retention_period_delta = timedelta(
days=int(retention_period.get("days", 0)),
hours=int(retention_period.get("hours", 0)),
minutes=int(retention_period.get("minutes", 0)))
return dt2DT(DT2dt(date_sampled) + retention_period_delta)
def folderitems(self):
items = BikaListingView.folderitems(self)
outitems = []
workflow = getToolByName(self.context, 'portal_workflow')
for x in range(len(items)):
if not items[x].has_key('obj'): continue
obj = items[x]['obj']
if workflow.getInfoFor(obj, 'review_state') == 'current':
# Check expiry date
from Products.ATContentTypes.utils import DT2dt
from datetime import datetime
expirydate = DT2dt(obj.getExpiryDate()).replace(tzinfo=None)
if (datetime.today() > expirydate):
workflow.doActionFor(obj, 'expire')
items[x]['review_state'] = 'expired'
items[x]['obj'] = obj
if 'review_state' in self.contentFilter \
and self.contentFilter['review_state'] == 'current':
continue
items[x]['ID'] = obj.id
items[x]['Manufacturer'] = obj.getManufacturer() and \
obj.getManufacturer().Title() or ''
items[x]['Definition'] = obj.getReferenceDefinition() and \
obj.getReferenceDefinition().Title() or ''
items[x]['DateSampled'] = self.ulocalized_time(
obj.getDateSampled(), long_format=True)
items[x]['DateReceived'] = self.ulocalized_time(
obj.getDateReceived())
items[x]['DateOpened'] = self.ulocalized_time(obj.getDateOpened())
items[x]['ExpiryDate'] = self.ulocalized_time(obj.getExpiryDate())
after_icons = ''
if obj.getBlank():
after_icons += "<img\
src='%s/++resource++bika.lims.images/blank.png' \
title='%s'>" % (self.portal_url, t(_('Blank')))
if obj.getHazardous():
after_icons += "<img\
src='%s/++resource++bika.lims.images/hazardous.png' \
title='%s'>" % (self.portal_url, t(_('Hazardous')))
items[x]['replace']['ID'] = "<a href='%s/base_view'>%s</a> %s" % \
(items[x]['url'], items[x]['ID'], after_icons)
outitems.append(items[x])
return outitems
def update_on_modify(obj, event):
""" We change the workflow. We check if the type is enabled and the state is published
"""
registry = getUtility(IRegistry)
settings = registry.forInterface(IHootsuiteRegistry)
if settings.portal_types and (obj.portal_type in settings.portal_types
) and (event.new_state.id == 'published'):
# Send the title to hootsuite
dataDT = obj.getEffectiveDate()
data = DT2dt(dataDT)
# We send now !
services = []
for socialId in settings.active_services:
services.append(int(socialId.split(" ")[-1]))
title = obj.Title() + " " + obj.absolute_url() + " " + settings.hashtag
if (datetime.datetime.now().replace(tzinfo=pytz.utc) >
data.replace(tzinfo=pytz.utc)):
tosend = {'message': title, 'socialNetworks': services}
else:
tosend = {
'message': title,
'socialNetworks': services,
'sendLater': 1,
'sendAlert': 1,
'timestamp': time.mktime(data.timetuple())
}
tosend = json.dumps(tosend)
#tosend = urllib.urlencode(tosend)
authorization_header = "Bearer %s" % settings.token
req = urllib2.Request(settings.urlapi + 'messages', tosend)
req.add_header("Authorization", authorization_header)
try:
response = urllib2.urlopen(req)
resultat_json = response.read()
resultat = json.loads(resultat_json)
logger.info("Added to HootSuite a event " + title + " " +
json.dumps(resultat))
except urllib2.HTTPError, error:
contents = error.read()
resultat = json.loads(contents)
logger.error("Error on added a Hootsuite event " + title + " " +
json.dumps(resultat))
def disposal_date(self):
""" return disposal date """
DateSampled = self.getDateSampled()
# fallback to sampletype retention period
st_retention = self.aq_parent.getSampleType().getRetentionPeriod()
# but prefer retention period from preservation
pres = self.getPreservation()
pres_retention = pres and pres.getRetentionPeriod() or None
rp = pres_retention and pres_retention or None
rp = rp or st_retention
td = timedelta(days='days' in rp and int(rp['days']) or 0,
hours='hours' in rp and int(rp['hours']) or 0,
minutes='minutes' in rp and int(rp['minutes']) or 0)
dis_date = DateSampled and dt2DT(DT2dt(DateSampled) + td) or None
return dis_date
def populate_with_object(self, obj):
super(BasicTile, self).populate_with_object(obj)
data = {'title': obj.Title(),
'description': obj.Description(),
'uuid': IUUID(obj, None),
'date': obj.effective_date and \
DT2dt(obj.effective_date) or None,
'subjects': obj.Subject(),
}
# XXX: Implements a better way to detect image fields.
try:
data['image'] = NamedImageFile(str(obj.getImage().data))
except AttributeError:
try:
data['image'] = NamedImageFile(str(obj.image.data))
except AttributeError:
pass
data_mgr = ITileDataManager(self)
data_mgr.set(data)
def getRaw(self, instance, **kwargs):
bb = ''
sample = instance.getSample() \
if instance.portal_type == 'AnalysisRequest' else instance
if not sample:
# portal_factory ARs have no sample.
return ''
sampletype = sample.getSampleType()
FromDate = sample.getDateSampled()
if not FromDate:
FromDate = sample.getSamplingDate()
months = sampletype.Schema().getField('ShelfLife').get(sampletype)
if FromDate and months:
FromDate = DT2dt(FromDate)
try:
months = int(months)
bb = add_months(FromDate, months)
bb = dt2DT(bb)
except ValueError:
bb = ''
else:
bb = ''
return bb
def folderitem(self, obj, item, index):
workflow = getToolByName(obj, 'portal_workflow')
if item.get('review_state', 'current') == 'current':
# Check expiry date
exdate = obj.getExpiryDate()
if exdate:
expirydate = DT2dt(exdate).replace(tzinfo=None)
if (datetime.today() > expirydate):
# Trigger expiration
workflow.doActionFor(obj, 'expire')
item['review_state'] = 'expired'
item['obj'] = obj
if self.contentFilter.get('review_state', '') \
and item.get('review_state', '') == 'expired':
# This item must be omitted from the list
return None
item['ID'] = obj.id
item['DateSampled'] = self.ulocalized_time(obj.getDateSampled(),
long_format=True)
item['DateReceived'] = self.ulocalized_time(obj.getDateReceived())
item['DateOpened'] = self.ulocalized_time(obj.getDateOpened())
item['ExpiryDate'] = self.ulocalized_time(obj.getExpiryDate())
after_icons = ''
if obj.getBlank():
after_icons += "<img\
src='%s/++resource++bika.lims.images/blank.png' \
title='%s'>" % (self.portal_url, t(_('Blank')))
if obj.getHazardous():
after_icons += "<img\
src='%s/++resource++bika.lims.images/hazardous.png' \
title='%s'>" % (self.portal_url, t(_('Hazardous')))
item['replace']['ID'] = "<a href='%s/base_view'>%s</a> %s" % \
(item['url'], item['ID'], after_icons)
return item
def _end_date(self):
value = self['startDate']
if value is None:
return self.start_date
return DT2dt(value)
def _start_date(self):
value = self['startDate']
if value is None:
value = self['creation_date']
return DT2dt(value)
def get_publish_year(self):
"""
returns year of creation date
"""
return DT2dt(self.__get_obj_date()).strftime("%Y")
def publish_date(self):
"""
returns date in format Month dayNumber, Year
"""
return DT2dt(self.__get_obj_date()).strftime("%B %d, %Y")
def generateUniqueId(context, parent=False):
""" Generate pretty content IDs.
"""
def getLastCounter(context, config):
if config.get('counter_type', '') == 'backreference':
return len(context.getBackReferences(
config['counter_reference'])) - 1
elif config.get('counter_type', '') == 'contained':
return len(context.objectItems(config['counter_reference'])) - 1
else:
raise RuntimeError('ID Server: missing values in configuration')
number_generator = getUtility(INumberGenerator)
# keys = number_generator.keys()
# values = number_generator.values()
# for i in range(len(keys)):
# print '%s : %s' % (keys[i], values[i])
def getConfigByPortalType(config_map, portal_type):
config = {}
for c in config_map:
if c['portal_type'] == portal_type:
config = c
break
return config
config_map = api.get_bika_setup().getIDFormatting()
config = getConfigByPortalType(config_map=config_map,
portal_type=context.portal_type)
if context.portal_type == "AnalysisRequest":
variables_map = {
'sampleId': context.getSample().getId(),
'sample': context.getSample(),
}
elif context.portal_type == "SamplePartition":
variables_map = {
'sampleId': context.aq_parent.getId(),
'sample': context.aq_parent,
}
elif context.portal_type == "Sample" and parent:
config = getConfigByPortalType(
config_map=config_map, portal_type='SamplePartition') # Override
variables_map = {
'sampleId': context.getId(),
'sample': context,
}
elif context.portal_type == "Sample":
sampleDate = None
if context.getSamplingDate():
sampleDate = DT2dt(context.getSamplingDate())
variables_map = {
'clientId': context.aq_parent.getClientID(),
'sampleDate': sampleDate,
'sampleType': context.getSampleType().getPrefix(),
'year': DateTime().strftime("%Y")[2:],
}
else:
if not config:
# Provide default if no format specified on bika_setup
config = {
'form': '%s-{seq}' % context.portal_type.lower(),
'sequence_type': 'generated',
'prefix': '%s' % context.portal_type.lower(),
}
variables_map = {}
# Actual id construction starts here
form = config['form']
if config['sequence_type'] == 'counter':
new_seq = getLastCounter(context=variables_map[config['context']],
config=config)
elif config['sequence_type'] == 'generated':
if config.get('split_length', None) == 0:
prefix_config = '-'.join(form.split('-')[:-1])
prefix = prefix_config.format(**variables_map)
elif config.get('split_length', None) > 0:
prefix_config = '-'.join(form.split('-')[:config['split_length']])
prefix = prefix_config.format(**variables_map)
else:
prefix = config['prefix']
new_seq = number_generator(key=prefix)
variables_map['seq'] = new_seq + 1
result = form.format(**variables_map)
return result
def get_variables(context, **kw):
"""Prepares a dictionary of key->value pairs usable for ID formatting
"""
# allow portal_type override
portal_type = get_type_id(context, **kw)
# The variables map hold the values that might get into the constructed id
variables = {
"context": context,
"id": api.get_id(context),
"portal_type": portal_type,
"year": get_current_year(),
"yymmdd": get_yymmdd(),
"parent": api.get_parent(context),
"seq": 0,
"alpha": Alphanumber(0),
}
# Augment the variables map depending on the portal type
if portal_type in AR_TYPES:
now = DateTime()
sampling_date = context.getSamplingDate()
sampling_date = sampling_date and DT2dt(sampling_date) or DT2dt(now)
date_sampled = context.getDateSampled()
date_sampled = date_sampled and DT2dt(date_sampled) or DT2dt(now)
test_count = 1
variables.update({
"clientId": context.getClientID(),
"dateSampled": date_sampled,
"samplingDate": sampling_date,
"sampleType": context.getSampleType().getPrefix(),
"test_count": test_count
})
# Partition
if portal_type == "AnalysisRequestPartition":
parent_ar = context.getParentAnalysisRequest()
parent_ar_id = api.get_id(parent_ar)
parent_base_id = strip_suffix(parent_ar_id)
partition_count = get_partition_count(context)
variables.update({
"parent_analysisrequest": parent_ar,
"parent_ar_id": parent_ar_id,
"parent_base_id": parent_base_id,
"partition_count": partition_count,
})
# Retest
elif portal_type == "AnalysisRequestRetest":
# Note: we use "parent" instead of "invalidated" for simplicity
parent_ar = context.getInvalidated()
parent_ar_id = api.get_id(parent_ar)
parent_base_id = strip_suffix(parent_ar_id)
# keep the full ID if the retracted AR is a partition
if context.isPartition():
parent_base_id = parent_ar_id
retest_count = get_retest_count(context)
test_count = test_count + retest_count
variables.update({
"parent_analysisrequest": parent_ar,
"parent_ar_id": parent_ar_id,
"parent_base_id": parent_base_id,
"retest_count": retest_count,
"test_count": test_count,
})
# Secondary
elif portal_type == "AnalysisRequestSecondary":
primary_ar = context.getPrimaryAnalysisRequest()
primary_ar_id = api.get_id(primary_ar)
parent_base_id = strip_suffix(primary_ar_id)
secondary_count = get_secondary_count(context)
variables.update({
"parent_analysisrequest": primary_ar,
"parent_ar_id": primary_ar_id,
"parent_base_id": parent_base_id,
"secondary_count": secondary_count,
})
elif portal_type == "ARReport":
variables.update({
"clientId": context.aq_parent.getClientID(),
})
# Look for a variables adapter
adapter = queryAdapter(context, IIdServerVariables)
if adapter:
vars = adapter.get_variables(**kw)
variables.update(vars)
return variables
