def test_create_travel_request_from_record(self):
"""
"""
now = DateTime()
record = self.portal.record_module.newContent(
portal_type = "Travel Request Record",
start_date = now.Date(),
stop_date = now.Date(),
source_reference = "%s" % now,
source='person_module/hr_user',
title = "Test Leave Record %s" % now
)
self.tic()
self.portal.portal_alarms.alarm_process_draft_record_list.activeSense()
self.tic()
self.assertTrue(record.getSimulationState(), "delivered")
ticket = record.getFollowUpValue()
new_record = self.portal.portal_catalog.getResultValue(
portal_type="Travel Request Record",
strict_follow_up_uid=record.getFollowUpUid(),
simulation_state="stopped"
)
self.assertIsNotNone(new_record)
self.assertEqual(record.getSource(), ticket.getDestinationDecision())
self.assertEqual(record.getStartDate(), ticket.getStartDate())
self.assertEqual(record.getStopDate(), ticket.getStopDate())
def test_change_travel_request_create_record(self):
"""
"""
now = DateTime()
record = self.portal.record_module.newContent(
portal_type = "Travel Request Record",
start_date = now.Date(),
stop_date = now.Date(),
source_reference = "%s" % now,
source='person_module/hr_user',
title = "Test Travel Request Record %s" % now
)
self.tic()
self.portal.portal_alarms.alarm_process_draft_record_list.activeSense()
self.tic()
ticket = record.getFollowUpValue()
ticket.accept()
self.tic()
self.portal.portal_alarms.create_representative_record_for_travel_request.activeSense()
self.tic()
record_list = ticket.getFollowUpRelatedValueList(portal_type='Travel Request Record')
self.assertEqual(len(record_list), 3)
self.assertEqual(1, len(self.portal.portal_catalog(
portal_type="Travel Request Record",
strict_follow_up_uid=ticket.getUid(),
simulation_state="stopped"
)))
self.assertEqual(2, len(self.portal.portal_catalog(
portal_type="Travel Request Record",
strict_follow_up_uid=ticket.getUid(),
simulation_state="delivered"
)))
def geojsonCase(filepath):
try:
ds = open(filepath)
jsonDict = json.load(ds)
isoTimeSeq = []
if jsonDict["type"] == "FeatureCollection":
prop = ""
if "time" in jsonDict["features"][0]["properties"]:
prop = "time"
elif "date" in jsonDict["features"][0]["properties"]:
prop = "date"
elif "dateTime" in jsonDict["features"][0]["properties"]:
prop = "dateTime"
else:
return (None, "no time data available")
timeext = []
for feature in jsonDict["features"]:
timeext.append(feature["properties"][prop])
isoTimeSeq = list(map(DateTime, timeext))
isoTimeSeq.sort()
avgInt = 0
if len(isoTimeSeq) > 1:
interval = []
for i in range(len(isoTimeSeq) - 1):
interval.append(isoTimeSeq[i + 1] - isoTimeSeq[i])
avgInt = functools.reduce(lambda x, y: x + y,
interval) / float(len(interval))
return ([isoTimeSeq[0].Date(), isoTimeSeq[-1].Date(),
avgInt], None)
else:
prop = ""
if "time" in jsonDict:
prop = "time"
elif "date" in jsonDict:
prop = "date"
elif "dateTime" in jsonDict:
prop = "dateTime"
else:
return (None, "no time data available")
timeext = jsonDict["properties"][prop]
timeext = DateTime(timeext)
return ([timeext.Date(), timeext.Date(), 0], None)
except:
return (None, "File Error!")
finally:
ds.close()
def openCounterDate(self,
date=None,
site=None,
id='counter_date_1',
open=True,
force_check=0):
"""
Redefine openCounterDate here, taking code from TestERP5Banking.
This is because "force_check", when false, skips entierly workflow
scripts. As a workflow is responsible for setting the reference, it
would make this test unable to open counter dates on a day other than
current one.
"""
if date is None:
date = DateTime().Date()
if not isinstance(date, str):
date = date.Date()
if site is None:
site = self.testsite
date_object = self.getCounterDateModule().newContent(
id=id,
portal_type='Counter Date',
site_value=site,
start_date=date)
if open:
self.workflow_tool.doActionFor(date_object,
'open_action',
wf_id='counter_date_workflow',
check_date_is_today=force_check)
setattr(self, id, date_object)
date_object.assignRoleToSecurityGroup()
def examine(self):
now = DateTime()
try:
if self.axial_images_location == '[]' or self.coronal_images_location == '[]' or self.sagittal_images_location == '[]':
QMessageBox.warning(self, "Error!", "can\'t load images!")
return
except AttributeError:
QMessageBox.warning(self, "Error!", "can\'t load images!")
return
if not self.check_text_constrains(self.get_name()):
QMessageBox.warning(self, "Error!",
"name field can't contain (' , \)")
return
if not self.check_text_constrains(self.get_note()):
QMessageBox.warning(self, "Error!",
"note field can't contain (' , \)")
return
self.btn_examine.setEnabled(False)
self.lbl_state.setText('in progress...')
self.th = threads.ExamineThread(self.get_thread_data,
self.axial_images_location,
self.coronal_images_location,
self.sagittal_images_location,
self.get_name(), self.get_age(),
self.get_blood(), self.get_note(),
now.Date() + ' ' + now.AMPM())
self.th.signals.finished.connect(self.on_thread_finished)
self.threadpool.start(self.th)
def __call__(self):
portal = api.portal.get()
catalog = portal.portal_catalog
tool = portal.portal_plonemeeting
logger.info('Sending mails linked to annexes on PV added today.')
now = DateTime()
start = DateTime(now.Date())
date_query = {'query': start, 'range': 'min'}
# This is made to return links with correct URL as cron4plone tasks breaks the absolute_url machinery
request = aq_acquire(self, 'REQUEST')
request['SERVER_URL'] = tool.getPublicUrl()
annexCpt = 0
brains = catalog.searchResults(meta_type='MeetingFile',
Date=date_query)
for brain in brains:
annex = brain.getObject()
if annex.findRelatedTo() == "item_pv":
annexCpt += 1
annexType = annex.getMeetingFileType(
theRealObject=True).getName()
sendMailToCopyGroupsIfRelevant(annex.getParent(),
'event_add_pv_annex',
mapping={
'itemType': annexType,
})
logger.info('mails sent about ' + str(annexCpt) + ' new annexes on PV')
def CoerceType(x, t):
"""CoerceType.
:param x:
:param t:
"""
if x is Missing.Value:
return x
elif t == IntValued:
if isinstance(x, float):
return int(x)
if not isinstance(x, int):
if not isinstance(x, str):
x = str(x)
try:
x = int(x)
except ValueError:
x = 0
return x
elif t == LongValued:
if not isinstance(x, int):
if not isinstance(x, str):
x = str(x)
try:
x = long(x)
except ValueError:
x = 0
return x
elif t == FloatValued:
if not isinstance(x, float):
if not isinstance(x, str):
x = str(x)
try:
x = float(x)
except ValueError:
x = 0.0
return x
elif t == DateTimeValued:
if not (isinstance(x, object) and x.__class__ == DateTime):
try:
x = DateTime(x)
except Exception as err:
logger.error('DateTime error! %s', str(err))
x = Missing.Value
return x
elif t == DateValued:
if not (isinstance(x, object) and x.__class__ == DateTime):
try:
# force date-only
x = DateTime(x)
except Exception as err:
logger.error('DateTime error! %s', str(err))
x = Missing.Value
return DateTime(x.Date())
else:
return str(x)
def default_end(self):
now = DateTime()
date = now.Date()
time = self.round_minutes(now.TimeMinutes())
parts = time.split(":")
parts[0] = str((int(parts[0]) + 1) % 24)
result = DateTime(date + " " + parts[0] + ":" + parts[1])
return result
class message(Folder):
"""
The chat message, stores a chat line
@param date_time: date and time posted
@param user: the user id who sent this message
@param msg: the submitted text message
"""
id = ''
title = ''
date_time = None
user = ''
msg = ''
#Class metadata
#Zope
meta_type = CHATTER_MESSAGE_META_TYPE
security = ClassSecurityInfo()
all_meta_types = {}
def __init__(self, id, title, user, msg):
self.id = id
self.title = title
self.date_time = DateTime()
self.user = user
self.msg = msg
security.declareProtected(CHATTER_VIEW_ROOM_PERMISSION, 'get_posting_user')
def get_posting_user(self):
""" Returns the posting user id """
return self.user
security.declareProtected(CHATTER_VIEW_ROOM_PERMISSION, 'get_posting_time')
def get_posting_time(self):
""" Returns the time at whitch the message was posted """
return self.date_time
security.declareProtected(CHATTER_VIEW_ROOM_PERMISSION, 'get_msg')
def get_msg(self):
""" Returns the posted message"""
msg = ut.utXmlEncode(self.msg)
msg = self.linkifyURLS(msg)
return msg
security.declareProtected(CHATTER_VIEW_ROOM_PERMISSION, 'get_date')
def get_date(self):
""" """
return self.date_time.Date()
security.declareProtected(CHATTER_VIEW_ROOM_PERMISSION, 'get_time')
def get_time(self):
""" """
return self.date_time.Time()
def getClosestDate(date=None,
target_date=None,
precision='month',
before=1,
strict=1):
"""
Return the closest date from target_date, at the given precision.
If date is set, the search is made by making steps of 'precision' duration.
If target_date is None, it is replaced by current time.
Precision can be year, month or day
If before is set to 1, return the closest date before target_date,
unless the closest date after target_date
Example :
date=None, target_date=DateTime('2004/03/12'), precision='month', before=1
-> return DateTime('2004/03/01')
date=DateTime('2002/12/14'), target_date=DateTime('2004/03/12'), precision='month', before=1
-> return DateTime('2004/02/14')
"""
if target_date is None:
target_date = DateTime()
if date is None:
date = DateTime('2000/01/01')
date._tz = target_date._tz
earlier_target_date = target_date - millis
to_check = {
'day': {
'year': 1,
'month': 1,
'day': 1
},
'month': {
'year': 1,
'month': 1
},
'year': {
'year': 1
}
}
diff_value = {}
diff_value = getIntervalBetweenDates(from_date=date,
to_date=target_date,
keys=to_check[precision])
return_date = addToDate(date=date, to_add=diff_value)
while (strict and return_date - target_date < 0) or \
(not strict and \
getIntervalBetweenDates(from_date=return_date, to_date=target_date, keys={'day':1})['day'] > 0):
return_date = addToDate(date=return_date, to_add={precision: 1})
if before and DateTime(return_date.Date()) != DateTime(target_date.Date()):
return_date = addToDate(date=return_date, to_add={precision: -1})
return return_date
def closeArchives(self):
""" Close expired automatic archives """
today = DateTime()
archives = self.getOpenArchives()
for arch in archives:
if arch.automatic and arch.get_creation_date().Date(
) != today.Date():
arch.closing_date = today
return self.getOpenArchives()
def process(self, device, results, log):
# data format expected in results
# DisplayName=Software1;InstallDate=19700101;Vendor=Microsoft Corporation|
# DisplayName=Software2;InstallDate=19700102;Vendor=Microsoft Corporation|
log.info("Modeler %s processing data for device %s", self.name(),
device.id)
rm = self.relMap()
software_results = results.get('software')
if not software_results:
return rm
software_results = ''.join(software_results.stdout).split('|')
# Registry Software formatting
for sw in software_results:
softwareDict = {}
for keyvalues in sw.split(';'):
try:
key, value = keyvalues.split('=')
except ValueError:
continue
try:
if key == "Vendor":
checkValidId(None, value, allow_dup=False)
except BadRequest:
value = str()
softwareDict[key] = value
keys = ['DisplayName', 'Vendor', 'InstallDate']
# malformed data line
if set(keys).difference(set(softwareDict.keys())):
continue
# skip over empty entries
if softwareDict['DisplayName'] == '':
continue
om = self.objectMap()
om.id = self.eliminate_underscores(
self.prepId(softwareDict['DisplayName'])).strip()
vendor = softwareDict['Vendor'].strip(
) if softwareDict['Vendor'].strip() != '' else 'Unknown'
om.setProductKey = MultiArgs(om.id, vendor)
try:
installDate = DateTime(softwareDict['InstallDate'])
om.setInstallDate = '{0} 00:00:00'.format(installDate.Date())
except (SyntaxError, TimeError):
# Date is unreadable or empty, ok to leave blank
pass
rm.append(om)
return rm
def test_create_expense_request_from_record(self):
"""
"""
now = DateTime()
date = "%s" % now.Date().replace('/','-')
quantity = 3.14
resource = "currency_module/CNY"
resource_title = "Money"
comment="New Work is Comming %s" % now
latitude = 121012012
longitude = 121012012.30
record = self.portal.expense_record_module.newContent(
date=date,
quantity=quantity,
resource=resource,
resource_title=resource_title,
comment=comment,
source_reference = '%s' % now,
source='person_module/hr_user',
latitude=latitude,
longitude=longitude,
)
record.setTitle("Test Expense Record %s" % now)
self.tic()
self.portal.portal_alarms.alarm_process_draft_record_list.activeSense()
self.tic()
self.assertTrue(record.getSimulationState(), "delivered")
ticket = record.getFollowUpValue()
new_record = self.portal.portal_catalog.getResultValue(
portal_type="Expense Record",
strict_follow_up_uid=record.getFollowUpUid(),
simulation_state="stopped"
)
self.assertIsNotNone(new_record)
self.assertEqual(
record.getDestinationReference(),
ticket.getReference()
)
self.assertEqual(quantity,ticket.getPrice())
self.assertEqual(DateTime(date),ticket.getStartDate())
self.assertEqual(resource,ticket.getPriceCurrency())
self.assertEqual(comment,ticket.getDescription())
self.assertEqual(longitude,ticket.getLongitude())
self.assertEqual(latitude,ticket.getLatitude())
self.assertEqual(
record.getDestinationReference(),
new_record.getDestinationReference()
)
def _format_time(self, time):
# We have to transform Python datetime into Zope DateTime
# before we can call toLocalizedTime.
if hasattr(time, 'isoformat'):
zope_time = DateTime(time.isoformat())
else:
# already a Zope DateTime
zope_time = time
util = getToolByName(getSite(), 'translation_service')
if DateTime().Date() == zope_time.Date():
return util.toLocalizedTime(zope_time,
long_format=True,
time_only=True)
else:
# time_only=False still returns time only
return util.toLocalizedTime(zope_time, long_format=True)
def date(self):
''' The date of our context object
'''
# We have to transform Python datetime into Zope DateTime
# before we can call toLocalizedTime.
time = self.context.raw_date
if hasattr(time, 'isoformat'):
time = DateTime(self.context.raw_date.isoformat())
if DateTime().Date() == time.Date():
time_only = True
else:
# time_only=False still returns time only
time_only = None
return self.toLocalizedTime(time,
long_format=True,
time_only=time_only)
def test_change_expense_record_create_new_record(self):
"""
"""
now = DateTime()
date = "%s" % now.Date().replace('/','-')
quantity = 3.14
resource = "currency_module/CNY"
resource_title = "Money"
comment="New Work is Comming %s" % now
latitude = 121012012
longitude = 121012012.30
record = self.portal.expense_record_module.newContent(
date=date,
quantity=quantity,
resource=resource,
resource_title=resource_title,
comment=comment,
source_reference = '%s' % now,
source='person_module/hr_user',
latitude=latitude,
longitude=longitude,
)
record.setTitle("Test Expense Record %s" % now)
self.tic()
self.portal.portal_alarms.alarm_process_draft_record_list.activeSense()
self.tic()
ticket = record.getFollowUpValue()
ticket.accept()
self.portal.portal_alarms.create_representative_record_for_expense_validation_request()
self.tic()
expense_record_list = ticket.getFollowUpRelatedValueList(portal_type='Expense Record')
self.assertEqual(len(expense_record_list), 3)
self.assertEqual(1, len(self.portal.portal_catalog(
portal_type="Expense Record",
strict_follow_up_uid=ticket.getUid(),
simulation_state="stopped"
)))
self.assertEqual(2, len(self.portal.portal_catalog(
portal_type="Expense Record",
strict_follow_up_uid=ticket.getUid(),
simulation_state="delivered"
)))
def test_accept_expense_record_create_purchase_invoice_transaction(self):
"""
"""
now = DateTime()
date = "%s" % now.Date().replace('/','-')
quantity = 3.14
resource = "currency_module/CNY"
resource_title = "Money"
comment="New Work is Comming %s" % now
latitude = 121012012
longitude = 121012012.30
record = self.portal.expense_record_module.newContent(
date=date,
quantity=quantity,
resource=resource,
resource_title=resource_title,
source_reference = '%s' % now,
source='person_module/hr_user',
comment=comment,
latitude=latitude,
longitude=longitude,
)
record.setTitle("Test Expense Record %s" % now)
self.tic()
self.portal.portal_alarms.alarm_process_draft_record_list.activeSense()
self.tic()
ticket = record.getFollowUpValue()
ticket.accept()
self.tic()
purchase_invoice_transaction = self.portal.portal_catalog.getResultValue(
portal_type="Purchase Invoice Transaction",
strict_causality_uid=ticket.getUid(),
)
self.assertIsNotNone(purchase_invoice_transaction)
self.assertEqual(ticket.getDestinationDecision(), purchase_invoice_transaction.getSourceSection())
self.assertEqual(ticket.getSourceProject(),purchase_invoice_transaction.getSourceProject())
self.assertEqual(ticket.getSourceSection(),purchase_invoice_transaction.getDestinationSection(),)
self.assertEqual(ticket.getPriceCurrency(),purchase_invoice_transaction.getResource())
self.assertEqual(ticket.getStartDate(),purchase_invoice_transaction.getStartDate())
self.assertEqual("confirmed",purchase_invoice_transaction.getSimulationState())
line_list = purchase_invoice_transaction.objectValues(portal_type="Purchase Invoice Transaction Line")
self.assertEqual(2, len(line_list))
def data_postprocessing(obj, event):
"""When setting the startDate and endDate, the value of the timezone field
isn't known, so we have to convert those timezone-naive dates into
timezone-aware ones afterwards.
For whole day events, set start time to 0:00:00 and end time to 23:59:59.
For open end events, set end time to 23:59:59.
"""
if not IEvent.providedBy(obj):
# don't run me, if i'm not installed
return
timezone = obj.getField('timezone').get(obj)
start_field = obj.getField('startDate')
end_field = obj.getField('endDate')
# The previous_timezone is set, when the timezone has changed to another
# value. In this case we need to convert the UTC dt values to the
# previous_timezone, so that we get the datetime values, as the user
# entered them. However, this value might be always set, even when creating
# an event, since ObjectModifiedEvent is called several times when editing.
prev_tz = getattr(obj, 'previous_timezone', None)
if prev_tz:
delattr(obj, 'previous_timezone')
def _fix_zone(dt, tz):
if not dt.timezoneNaive():
# The object is edited and the value alreadty stored in UTC on the
# object. In this case we want the value converted to the given
# timezone, in which the user entered the data.
dt = dt.toZone(tz)
return dt
start = _fix_zone(start_field.get(obj), prev_tz and prev_tz or timezone)
end = _fix_zone(end_field.get(obj), prev_tz and prev_tz or timezone)
def make_DT(value, timezone):
return DateTime(
value.year(),
value.month(),
value.day(),
value.hour(),
value.minute(),
int(value.second()), # No microseconds
timezone)
start = make_DT(start, timezone)
end = make_DT(end, timezone)
whole_day = obj.getWholeDay()
open_end = obj.getOpenEnd()
if whole_day:
start = DateTime('%s 0:00:00 %s' % (start.Date(), timezone))
if open_end:
end = start # Open end events end on same day
if open_end or whole_day:
end = DateTime('%s 23:59:59 %s' % (end.Date(), timezone))
start_field.set(obj, start.toZone('UTC'))
end_field.set(obj, end.toZone('UTC'))
if not obj.getEventUid():
# sync_uid has to be set for icalendar data exchange.
uid = IUUID(obj)
# We don't want to fail when getRequest() returns None, e.g when
# creating an event during test layer setup time.
request = getRequest() or {}
domain = request.get('HTTP_HOST')
obj.setEventUid('%s%s' % (uid, domain and '@%s' % domain or ''))
obj.reindexObject()
def default_start(self):
now = DateTime()
date = now.Date()
time = self.round_minutes(now.TimeMinutes())
result = DateTime(date + " " + time)
return result
def listMetaTags(self, context):
# Lists meta tags helper.
# Creates a mapping of meta tags -> values for the listMetaTags script.
result = {}
mt = getToolByName(self, 'portal_membership')
registry = getUtility(IRegistry)
site_settings = registry.forInterface(ISiteSchema,
prefix="plone",
check=False)
use_all = site_settings.exposeDCMetaTags
try:
use_all = site_settings.exposeDCMetaTags
except AttributeError:
use_all = False
security_settings = registry.forInterface(ISecuritySchema,
prefix='plone')
view_about = security_settings.allow_anon_views_about \
or not mt.isAnonymousUser()
if not use_all:
metadata_names = {'Description': METADATA_DCNAME['Description']}
else:
metadata_names = METADATA_DCNAME
for accessor, key in metadata_names.items():
# check non-public properties
if not view_about and accessor in METADATA_DC_AUTHORFIELDS:
continue
# short circuit non-special cases
if not use_all and accessor not in ('Description', 'Subject'):
continue
method = getattr(aq_inner(context).aq_explicit, accessor, None)
if not callable(method):
continue
# Catch AttributeErrors raised by some AT applications
try:
value = method()
except AttributeError:
value = None
if not value:
# No data
continue
if accessor == 'Publisher' and value == 'No publisher':
# No publisher is hardcoded (TODO: still?)
continue
# Check for fullnames
if view_about and accessor in METADATA_DC_AUTHORFIELDS:
if not isinstance(value, (list, tuple)):
value = [value]
tmp = []
for userid in value:
member = mt.getMemberInfo(userid)
name = userid
if member:
name = member['fullname'] or userid
tmp.append(name)
value = tmp
if isinstance(value, (list, tuple)):
# convert a list to a string
value = ', '.join(value)
# Special cases
if accessor == 'Description':
result['description'] = value
elif accessor == 'Subject':
result['keywords'] = value
if use_all:
result[key] = value
if use_all:
created = context.CreationDate()
try:
effective = context.EffectiveDate()
if effective == 'None':
effective = None
if effective:
effective = DateTime(effective)
except AttributeError:
effective = None
try:
expires = context.ExpirationDate()
if expires == 'None':
expires = None
if expires:
expires = DateTime(expires)
except AttributeError:
expires = None
# Filter out DWIMish artifacts on effective / expiration dates
if effective is not None and \
effective > FLOOR_DATE and \
effective != created:
eff_str = effective.Date()
else:
eff_str = ''
if expires is not None and expires < CEILING_DATE:
exp_str = expires.Date()
else:
exp_str = ''
if eff_str or exp_str:
result['DC.date.valid_range'] = '%s - %s' % (eff_str, exp_str)
return result
def generateMovementListForStockOptimisation(self, **kw):
# XXX: unused
from Products.ERP5Type.Document import newTempMovement
movement_list = []
for attribute, method in [('node_uid', 'getDestinationUid'),
('section_uid', 'getDestinationSectionUid')]:
if getattr(self, method)() not in ("", None):
kw[attribute] = getattr(self, method)()
# We have to check the inventory for each stock movement date.
# Inventory can be negative in some date, and positive in futur !!
# This must be done by subclassing OrderBuilder with a new inventory
# algorithm.
sql_list = self.portal_simulation.getFutureInventoryList(
group_by_variation=1,
group_by_resource=1,
group_by_node=1,
group_by_section=0,
**kw)
id_count = 0
for inventory_item in sql_list:
# XXX FIXME SQL return None inventory...
# It may be better to return always good values
if (inventory_item.inventory is not None):
dumb_movement = inventory_item.getObject()
# Create temporary movement
movement = newTempMovement(self.getPortalObject(),
str(id_count))
id_count += 1
movement.edit(resource=inventory_item.resource_relative_url,
variation_category_list=dumb_movement.
getVariationCategoryList(),
destination_value=self.getDestinationValue(),
destination_section_value=self.
getDestinationSectionValue())
# We can do other test on inventory here
# XXX It is better if it can be sql parameters
resource_portal_type = self.getResourcePortalType()
resource = movement.getResourceValue()
# FIXME: XXX Those properties are defined on a supply line !!
# min_flow, max_delay
min_flow = resource.getMinFlow(0)
if (resource.getPortalType() == resource_portal_type) and\
(round(inventory_item.inventory, 5) < min_flow):
# FIXME XXX getNextNegativeInventoryDate must work
stop_date = DateTime() + 10
# stop_date = resource.getNextNegativeInventoryDate(
# variation_text=movement.getVariationText(),
# from_date=DateTime(),
# # node_category=node_category,
# # section_category=section_category)
# node_uid=self.getDestinationUid(),
# section_uid=self.getDestinationSectionUid())
max_delay = resource.getMaxDelay(0)
movement.edit(
start_date=DateTime(((stop_date - max_delay).Date())),
stop_date=DateTime(stop_date.Date()),
quantity=min_flow - inventory_item.inventory,
quantity_unit=resource.getQuantityUnit()
# XXX FIXME define on a supply line
# quantity_unit
)
movement_list.append(movement)
return movement_list
obj = state_change['object']
from DateTime import DateTime
# we set h/m/s on min date and max date
date = obj.getStopDateRangeMax()
if date is not None:
date = DateTime("%8s 23:59:59" % (date.Date(), ))
obj.setStopDateRangeMax(date)
date = obj.getStopDateRangeMin()
if date is not None:
date = DateTime("%8s 23:59:59" % (date.Date(), ))
obj.setStopDateRangeMin(date)
# Raise ValidationFailed if the accounting date is not opened for the given date and the given site
from Products.DCWorkflow.DCWorkflow import ValidationFailed
from Products.ERP5Type.Message import Message
from DateTime import DateTime
if date is None:
# get current date
date = DateTime()
# Make sure we have a date with no hours
try:
date = date.Date()
except AttributeError:
# Assume that non-date parameter contains the bare date.
pass
if site is None:
# get site from user assignment
site_list = context.Baobab_getUserAssignedSiteList()
if len(site_list) == 0:
context.log('Baobab_checkAccountingDateOpen', 'No site found for the user')
return 0
else:
site = site_list[0]
# get only the office, not need of vault
#context.log('Baobab_checkAccountingDateOpen', 'get site for vault %s' %(site))
site = context.Baobab_getVaultSite(site)
accounting_date_list = context.portal_catalog(portal_type='Accounting Date', site_id=site.getId(), simulation_state="opened", sort_on=[("start_date", "DESC")], limit=1)
if len(accounting_date_list) == 0:
class TestBug(ERP5TypeTestCase):
"""
ERP5 unit tests for Bug module (part of erp5_forge business template).
"""
# pseudo constants
RUN_ALL_TEST = 1
QUIET = 1
person_portal_type = "Person"
assignment_portal_type = "Assignment"
project_portal_type = "Project"
bug_portal_type = "Bug"
organisation_portal_type = "Organisation"
def getTitle(self):
"""
Return the title of the current test set.
"""
return "Bug"
def getBusinessTemplateList(self):
"""
Return the list of required business templates.
"""
return ('erp5_base', 'erp5_crm', 'erp5_forge', 'erp5_pdm',
'erp5_simulation', 'erp5_trade', 'erp5_project')
def afterSetUp(self, quiet=QUIET, run=RUN_ALL_TEST):
"""
Initialize the ERP5 site.
"""
self.login()
self.setDefaultSitePreference()
self.datetime = DateTime()
self.workflow_tool = self.portal.portal_workflow
# Use a dummy mailhost to not send mail notification to the guy how run unit test
if 'MailHost' in self.portal.objectIds():
self.portal.manage_delObjects(['MailHost'])
self.portal._setObject('MailHost', DummyMailHost('MailHost'))
def setDefaultSitePreference(self):
default_preference = self.portal.portal_preferences.default_site_preference
default_preference.setPreferredTextFormat('text/plain')
default_preference.getPreferredTextEditor('text_area')
if self.portal.portal_workflow.isTransitionPossible(
default_preference, 'enable'):
default_preference.enable()
return default_preference
##################################
## Usefull methods
##################################
# def login(self, quiet=QUIET, run=RUN_ALL_TEST):
# """
# Create a new manager user and login.
# """
# user_name = 'kevin'
# user_folder = self.getPortal().acl_users
# user_folder._doAddUser(user_name, '', ['Manager', 'Owner', 'Assignor'], [])
# user = user_folder.getUserById(user_name).__of__(user_folder)
# newSecurityManager(None, user)
#
##################################
## Basic steps
##################################
def stepLoginUsualUser(self, **kw):
portal = self.getPortal()
uf = portal.acl_users
uf._doAddUser('mame', '', ['Assignor', 'Assignee'], [])
if not uf.getUser('dummy'):
uf._doAddUser('manager', '', ['Manager'], [])
self.loginByUserName('manager')
person_module = portal.getDefaultModule(self.person_portal_type)
person = person_module.newContent(id='dummy',
title='dummy',
reference='dummy')
portal.portal_categories.group.newContent(id='dummy',
codification='DUMMY')
person.setEmailText('loggedperson@localhost')
assignment = person.newContent(title='dummy',
group='dummy',
portal_type='Assignment',
start_date='1980-01-01',
stop_date='2099-12-31')
assignment.open()
person.newContent(portal_type='ERP5 Login',
reference='dummy').validate()
self.tic()
portal_type_list = []
for portal_type in (
self.project_portal_type,
self.bug_portal_type,
self.person_portal_type,
self.assignment_portal_type,
self.organisation_portal_type,
):
portal_type_list.append(portal_type)
module = portal.getDefaultModule(portal_type, None)
if module is not None:
portal_type_list.append(module.getPortalType())
for portal_type in portal_type_list:
ti = portal.portal_types[portal_type]
ti.newContent(portal_type='Role Information',
role_name_list=('Auditor', 'Author', 'Assignee',
'Assignor'),
title='Dummy',
role_base_category_script_id=
'ERP5Type_getSecurityCategoryFromAssignment',
role_category='group/dummy')
ti.updateRoleMapping()
self.tic()
portal.portal_caches.clearAllCache()
self.loginByUserName('dummy')
def stepCreateProject(self,sequence=None, sequence_list=None, \
**kw):
"""
Create a project
"""
project_portal_type = "Project"
portal = self.getPortal()
module = portal.getDefaultModule(project_portal_type)
project = module.newContent(portal_type=project_portal_type,
title='Project')
sequence.edit(project=project)
def createPerson(self):
"""
Create a person.
"""
portal_type = 'Person'
person_module = self.portal.getDefaultModule(portal_type)
person = person_module.newContent(portal_type=portal_type)
return person
def stepCreatePerson1(self, sequence=None, sequence_list=None, **kw):
"""
Create one Person
"""
person = self.createPerson()
project = sequence.get("project")
self.createPersonAssignment(person=person, project=project)
person.setDefaultEmailText("person1@localhost")
sequence.edit(person1=person)
def stepCreatePerson2(self, sequence=None, sequence_list=None, **kw):
"""
Create Person 2
"""
person = self.createPerson()
project = sequence.get("project")
person.setDefaultEmailText("person2@localhost")
sequence.edit(person2=person)
def createPersonAssignment(self, person=None, project=None):
"""
Create a person Assigment and Assign to a Project.
"""
# Create Assignment
assignment = person.newContent(portal_type='Assignment')
assignment.setDestinationProjectValue(project)
assignment.setStartDate(DateTime() - 365)
assignment.setStopDate(DateTime() + 365)
self.portal.portal_workflow.doActionFor(assignment, 'open_action')
def stepCheckBugNotification(self,
sequence=None,
sequence_list=None,
**kw):
"""
Check that notification works
"""
bug = sequence.get('bug')
last_message = self.portal.MailHost._last_message
self.assertNotEquals((), last_message)
mfrom, mto, messageText = last_message
self.assertEqual('dummy <loggedperson@localhost>', mfrom)
self.assertEqual(['person1@localhost'], mto)
message = message_from_string(messageText)
self.assertTrue(
decode_header(message['Subject'])[0][0].endswith(bug.getTitle()))
def stepCheckBugMessageNotification(self,
sequence=None,
sequence_list=None,
**kw):
"""
Check that notification works
"""
bug = sequence.get('bug')
last_message = self.portal.MailHost._last_message
self.assertNotEquals((), last_message)
mfrom, mto, messageText = last_message
self.assertEqual('person2@localhost', mfrom)
self.assertEqual(['person1@localhost'], mto)
message = message_from_string(messageText)
self.assertTrue(
decode_header(message['Subject'])[0][0].endswith(bug.getTitle()))
def stepSetSourceProject(self, sequence=None, sequence_list=None, **kw):
"""
Set Source Project to a Bug
"""
bug = sequence.get('bug')
project = sequence.get('project')
bug.setSourceProjectValue(project)
def stepSetRequester(self, sequence=None, sequence_list=None, **kw):
"""
Set Source Project to a Bug
"""
bug = sequence.get('bug')
person2 = sequence.get('person2')
bug.setDestinationValue(person2)
def stepCreateBug(self, sequence=None, sequence_list=None, **kw):
"""
Create a dummy bug
"""
portal_type = 'Bug'
bug_module = self.portal.getDefaultModule(portal_type)
bug = bug_module.newContent(portal_type=portal_type,
title='Bug Title',
description='Bug Description',
start_date=self.datetime,
stop_date=self.datetime)
sequence.edit(bug=bug)
def stepCreateBugMessage(self, sequence=None, sequence_list=None, **kw):
"""
Create a dummy Bug Message
"""
portal_type = 'Bug Line'
bug = sequence.get('bug')
person2 = sequence.get('person2')
bug_message = bug.newContent(portal_type=portal_type,
title='Bug Message',
text_content='Bug Description')
# usually the person who is creates the message is setted as source
# by BugLine_init
bug_message.setSourceValue(person2)
sequence.edit(bug_message=bug_message)
def stepPostBugMessage(self, sequence=None, sequence_list=None, **kw):
"""
Post the bug message.
"""
bug_message = sequence.get('bug_message')
self.workflow_tool.doActionFor(bug_message, 'start_action')
def stepCheckBugMessageIsDelivered(self, sequence=None, \
sequence_list=None, **kw):
"""
check if the message is delivered the bug.
"""
bug_message = sequence.get('bug_message')
self.assertEqual(bug_message.getSimulationState(), 'delivered')
def stepCheckBugMessage(self, sequence=None, sequence_list=None, **kw):
"""
Check a dummy bug message
"""
bug_message = sequence.get('bug_message')
person = sequence.get('person1')
self.assertEqual([person], bug_message.getDestinationValueList())
self.assertTrue(bug_message.getStartDate() is not None)
#self.assertEqual(bug_message.getSourceValue().getTitle(), 'dummy')
def stepCheckBugMessageNotificationReAssign(self,
sequence=None,
sequence_list=None,
**kw):
"""
Check the bug message when re-assign
"""
last_message = self.portal.MailHost._last_message
self.assertNotEquals((), last_message)
mfrom, mto, messageText = last_message
from email.parser import Parser
p = Parser()
m = p.parsestr(messageText)
self.assertTrue('Re-assign!' in m.get_payload()[0].get_payload(
decode=True))
def stepCheckBugInit(self, sequence=None, sequence_list=None, **kw):
"""
Create a dummy bug
"""
bug = sequence.get('bug')
self.assertEqual("#%s" % bug.getId(), bug.getReference())
#self.assertEqual(bug_message.getSourceTradeValue().getTitle(), 'dummy')
def stepCloneAndCheckBug(self, sequence=None, sequence_list=None, **kw):
"""
Create a dummy bug
"""
bug_to_clone = sequence.get('bug')
self.assertNotEquals(len(bug_to_clone.contentValues()), 0)
bug = bug_to_clone.Base_createCloneDocument(batch_mode=1)
self.assertEqual("#%s" % bug.getId(), bug.getReference())
self.assertEqual(len(bug.contentValues()), 0)
def stepOpenBug(self, sequence=None, sequence_list=None, **kw):
"""
Open the bug.
"""
bug = sequence.get('bug')
self.workflow_tool.doActionFor(bug, 'confirm_action', send_event=1)
self.assertEqual(bug.getSimulationState(), 'confirmed')
def stepAssignBug(self, sequence=None, sequence_list=None, **kw):
"""
Close the bug.
"""
bug = sequence.get('bug')
self.workflow_tool.doActionFor(bug, 'set_ready_action', send_event=1)
self.assertEqual(bug.getSimulationState(), 'ready')
def stepResolveBug(self, sequence=None, sequence_list=None, **kw):
"""
Close the bug.
"""
bug = sequence.get('bug')
self.workflow_tool.doActionFor(bug, 'stop_action', send_event=1)
self.assertEqual(bug.getSimulationState(), 'stopped')
def stepReAssignBug(self, sequence=None, sequence_list=None, **kw):
"""
Re Assign the bug.
"""
bug = sequence.get('bug')
self.workflow_tool.doActionFor(bug,
're_assign_action',
send_event=1,
comment='Re-assign!')
self.assertEqual(bug.getSimulationState(), 'ready')
def stepCloseBug(self, sequence=None, sequence_list=None, **kw):
"""
Close the bug.
"""
bug = sequence.get('bug')
self.workflow_tool.doActionFor(bug, 'deliver_action', send_event=1)
self.assertEqual(bug.getSimulationState(), 'delivered')
def stepCancelBug(self, sequence=None, sequence_list=None, **kw):
"""
Cancel the bug.
"""
bug = sequence.get('bug')
self.workflow_tool.doActionFor(bug, 'cancel_action', send_event=1)
self.assertEqual(bug.getSimulationState(), 'cancelled')
def stepSetTestedBug(self, sequence=None, sequence_list=None, **kw):
"""
Set the bug as unit tested.
"""
bug = sequence.get('bug')
bug.setTested(True)
self.assertEqual(bug.getTested(), True)
def stepSetOldClosedDate(self, sequence=None, sequence_list=None, **kw):
"""
Change Closed Date to a funky old value.
"""
bug = sequence.get('bug')
bug.setStopDate(self.datetime - 10)
self.assertEqual(bug.getStopDate().Date(),
(self.datetime -
10).Date()) # Check that datetime is fixed
def stepCheckClosedDate(self, sequence=None, sequence_list=None, **kw):
"""
Check that the closed date is set as today.
"""
bug = sequence.get('bug')
self.assertEqual(bug.getStopDate().Date(), self.datetime.Date())
##################################
## Tests
##################################
def test_01_StopDateUpdatedOnClose(self, quiet=QUIET, run=RUN_ALL_TEST):
"""
Test that a closed bug has its stop date property updated.
"""
if not run: return
sequence_list = SequenceList()
step_list = [
'stepCreateBug', 'stepCheckBugInit', 'stepOpenBug', 'stepTic',
'stepSetOldClosedDate', 'stepAssignBug', 'stepTic',
'stepResolveBug', 'stepTic', 'stepReAssignBug', 'stepTic',
'stepResolveBug', 'stepTic', 'stepCloseBug', 'stepTic',
'stepCheckClosedDate'
]
sequence_string = ' '.join(step_list)
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_02_setCheckBugNotification(self, quiet=QUIET, run=RUN_ALL_TEST):
"""
Test that a closed bug has its stop date property updated.
"""
if not run: return
sequence_list = SequenceList()
step_list = [
'stepLoginUsualUser', 'stepCreateBug', 'stepCreateProject',
'stepCreatePerson1', 'stepCreatePerson2', 'stepSetSourceProject',
'stepSetRequester', 'stepTic', 'stepOpenBug', 'stepTic',
'stepCheckBugNotification', 'stepAssignBug', 'stepTic',
'stepCheckBugNotification', 'stepResolveBug', 'stepTic',
'stepCheckBugNotification', 'stepReAssignBug', 'stepTic',
'stepCheckBugNotification',
'stepCheckBugMessageNotificationReAssign', 'stepResolveBug',
'stepTic', 'stepCheckBugNotification', 'stepCloseBug', 'stepTic',
'stepCheckBugNotification'
]
sequence_string = ' '.join(step_list)
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_03_setCheckBugNotification(self, quiet=QUIET, run=RUN_ALL_TEST):
"""
Test that a closed bug has its stop date property updated.
"""
if not run: return
sequence_list = SequenceList()
step_list = [
'stepLoginUsualUser', 'stepCreateBug', 'stepCreateProject',
'stepCreatePerson1', 'stepCreatePerson2', 'stepSetSourceProject',
'stepSetRequester', 'stepTic', 'stepOpenBug', 'stepTic',
'stepCheckBugNotification', 'stepCreateBugMessage',
'stepCheckBugMessage', 'stepTic', 'stepPostBugMessage', 'stepTic',
'stepCheckBugMessageIsDelivered', 'stepCheckBugMessageNotification'
]
sequence_string = ' '.join(step_list)
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_04_StopDateUpdatedOnCancelWithUsualUser(self,
quiet=QUIET,
run=RUN_ALL_TEST):
"""
Test that cancelBug with usual user.
"""
if not run: return
sequence_list = SequenceList()
step_list = [
'stepLoginUsualUser', 'stepCreateBug', 'stepOpenBug', 'stepTic',
'stepSetOldClosedDate', 'stepCancelBug', 'stepTic'
]
sequence_string = ' '.join(step_list)
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_05_setCheckBugClone(self, quiet=QUIET, run=RUN_ALL_TEST):
"""
Test that a closed bug has its stop date property updated.
"""
if not run: return
sequence_list = SequenceList()
step_list = [
'stepCreateBug', 'stepCheckBugInit', 'stepOpenBug',
'stepCloneAndCheckBug'
]
sequence_string = ' '.join(step_list)
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_06_BugLineClone(self):
bug_portal_type = 'Bug'
bug_line_portal_type = 'Bug Line'
module = self.portal.getDefaultModule(portal_type=bug_portal_type)
bug = module.newContent(portal_type=bug_portal_type)
bug_line = bug.newContent(portal_type='Bug Line')
cloned_bug_line = bug_line.Base_createCloneDocument(batch_mode=1)
self.assertTrue(
cloned_bug_line.getStartDate() > bug_line.getStartDate())
def test_07_Bug_BugLineSendFastInput(self):
bug_portal_type = 'Bug'
bug_line_portal_type = 'Bug Line'
module = self.portal.getDefaultModule(portal_type=bug_portal_type)
bug = module.newContent(portal_type=bug_portal_type)
text_content = 'text content'
title = 'title'
bug_line = bug.Bug_doBugLineSendFastInputAction(
batch_mode=1, title=title, text_content=text_content)
self.assertEqual(text_content, bug_line.getTextContent())
self.assertEqual(title, bug_line.getTitle())
self.assertEqual('delivered', bug_line.getSimulationState())
def test_08_openResolvedBug(self, quiet=QUIET, run=RUN_ALL_TEST):
"""
Test that a bug is resolved, we can still reopen it
"""
if not run: return
sequence_list = SequenceList()
step_list = [
'stepCreateBug', 'stepCheckBugInit', 'stepOpenBug', 'stepTic',
'stepAssignBug', 'stepTic', 'stepResolveBug', 'stepTic',
'stepOpenBug', 'stepTic'
]
sequence_string = ' '.join(step_list)
sequence_list.addSequenceString(sequence_string)
sequence_list.play(self, quiet=quiet)
def test_09_ResolveBugWithDeletedBugLine(self):
"""
verify that we can still resolve a bug with a
deleted bug line
"""
self.loginByUserName('mame')
bug_portal_type = 'Bug'
bug_line_portal_type = 'Bug Line'
module = self.portal.getDefaultModule(portal_type=bug_portal_type)
bug = module.newContent(portal_type=bug_portal_type)
bug_line = bug.newContent(portal_type='Bug Line')
cloned_bug_line = bug_line.Base_createCloneDocument(batch_mode=1)
self.workflow_tool.doActionFor(bug, 'confirm_action', send_event=1)
self.assertEqual(bug.getSimulationState(), 'confirmed')
self.tic()
bug.deleteContent(id='2')
self.tic()
self.workflow_tool.doActionFor(bug, 'stop_action', send_event=1)
self.assertEqual(bug.getSimulationState(), 'stopped')
def test_posting_bug_line_updates_bug_modification_date(self):
bug = self.portal.bug_module.newContent(portal_type='Bug')
bug_modification_date = bug.getModificationDate()
bug_line = bug.newContent(portal_type='Bug Line')
self.assertEqual(bug.getModificationDate(), bug_modification_date)
bug_line.start()
self.commit()
self.assertGreater(bug.getModificationDate(), bug_modification_date)
def getDateStr(date):
"""Expects date-object, returns a string like: '2016/12/24 21:39:12'."""
return str(DateTime.Date(date)) + ' ' + str(DateTime.Time(date))
from DateTime import DateTime
group_calendar_assignment = state_change["object"]
stop_date = group_calendar_assignment.getStopDate()
if stop_date:
stop_date = DateTime(stop_date.Date() + " 23:59:59")
group_calendar_assignment.setStopDate(stop_date)
# Check it is a working day
if len(getattr(context.getPortalObject(), 'not_working_days', "")) == 0:
pass
else:
not_working_day_list = getattr(context.getPortalObject(),
'not_working_days').split(" ")
if start_date.Day().lower() in not_working_day_list:
msg = Message(
domain='ui',
message="Sorry, you cannot open the date on not working days")
raise ValidationFailed(msg, )
# Check it is today
check_date_is_today = state_change.kwargs.get('check_date_is_today', 1)
if check_date_is_today and now.Date() != start_date.Date():
msg = Message(domain='ui', message="Sorry, the date is not today")
raise ValidationFailed(msg, )
if listbox is not None:
for line in listbox:
if line["choice"] == "open":
counter = context.restrictedTraverse("%s" %
(line['listbox_key'], ))
counter.open()
# Set a reference
first_day_of_year = DateTime(start_date.year(), 1, 1)
counter_date_list = [
x.getObject()
for x in context.portal_catalog(portal_type='Counter Date',
# retrieve a date from object and return the new id
if obj is None:
obj = context
# don't change custom (non-int) ids
old_id = obj.getId()
if not old_id.isdigit():
return old_id
date = obj.getCreationDate()
if date is None:
from DateTime import DateTime
date = DateTime()
date = date.Date().replace('/', '')
return "%s-%s" %(date, old_id)
def dict_from_item(item):
if hasPloneAppEvent and (IEvent.providedBy(item)
or IOccurrence.providedBy(item)):
# plone.app.event DX or AT Event
is_occurrence = IOccurrence.providedBy(item)
acc = IEventAccessor(item)
return {
"status":
"ok",
"id":
"UID_%s" % (acc.uid),
"title":
acc.title,
"description":
acc.description,
"start":
acc.start.isoformat(),
"end":
acc.end.isoformat(),
"url":
acc.url,
"editable":
editable,
"allDay":
acc.whole_day,
"className":
"contextualContentMenuEnabled %s %s %s %s" %
(state and "state-%s" % str(state)
or "", editable and "editable" or "", css and css
or "", is_occurrence and "occurrence" or ""),
"color":
color
}
elif IATEvent.providedBy(item):
# Products.ATContentTypes ATEvent
allday = (item.end() - item.start()) > 1.0
adapted = interfaces.ISFBaseEventFields(item, None)
if adapted:
allday = adapted.allDay
return {
"status":
"ok",
"id":
"UID_%s" % (item.UID()),
"title":
item.Title(),
"description":
item.Description(),
"start":
item.start().ISO8601(),
"end":
item.end().ISO8601(),
"url":
item.absolute_url(),
"editable":
editable,
"allDay":
allday,
"className":
"contextualContentMenuEnabled %s %s %s" %
(state and "state-%s" % str(state)
or "", editable and "editable" or "", css and css or ""),
"color":
color
}
elif ICatalogBrain.providedBy(item):
# Event catalog brain
if type(item.end) != DateTime:
brainend = DateTime(item.end)
brainstart = DateTime(item.start)
else:
brainend = item.end
brainstart = item.start
allday = (brainend - brainstart) > 1.0
if getattr(item, 'SFAllDay', None) in [False, True]:
allday = item.SFAllDay
# Set Mexico City Time
brainstart = DateTime(' '.join(
(brainstart.Date(), brainstart.Time(), 'America/Mexico_City')))
brainend = DateTime(' '.join(
(brainend.Date(), brainend.Time(), 'America/Mexico_City')))
return {
"status":
"ok",
"id":
"UID_%s" % (item.UID),
"title":
item.Title,
"description":
item.Description,
"start":
brainstart.ISO8601(),
"end":
brainend.ISO8601(),
"url":
item.getURL(),
"editable":
editable,
"allDay":
allday,
"className":
"contextualContentMenuEnabled %s %s %s" %
(state and "state-%s" % str(state)
or "", editable and "editable" or "", css and css or ""),
"color":
color
}
else:
raise ValueError('item type not supported for: %s' % repr(item))
def listMetaTags(self):
"""Calculate list metatags"""
result = SortedDict()
pps = queryMultiAdapter((self.context, self.request),
name="plone_portal_state")
seo_global = queryAdapter(pps.portal(), ISEOConfigletSchema)
seo_context = queryMultiAdapter((self.context, self.request),
name='seo_context')
use_all = seo_global.exposeDCMetaTags
adapter = IMappingMetaTags(self.context, None)
mapping_metadata = adapter and adapter.getMappingMetaTags() \
or SortedDict()
if not use_all:
metadata_names = 'DC.description' in mapping_metadata and \
{'DC.description': mapping_metadata['DC.description']} \
or SortedDict()
if 'description' in mapping_metadata:
metadata_names['description'] = mapping_metadata['description']
else:
metadata_names = mapping_metadata
for key, accessor in metadata_names.items():
if accessor == 'meta_keywords':
# Render all the existing keywords for the current content type
adapter = IMetaKeywords(self.context, None)
if adapter is not None:
keywords = adapter.getMetaKeywords()
if keywords:
result['keywords'] = keywords
continue
if accessor in seo_context._seotags:
value = seo_context._seotags.get(accessor, None)
else:
method = getattr(seo_context, accessor, None)
if method is None:
method = getattr(
aq_inner(self.context).aq_explicit, accessor, None)
if not callable(method):
continue
# Catch AttributeErrors raised by some AT applications
try:
value = method()
except AttributeError:
value = None
if not value:
# No data
continue
if accessor == 'Publisher' and value == 'No publisher':
# No publisher is hardcoded (TODO: still?)
continue
if isinstance(value, (list, tuple)):
# convert a list to a string
value = ', '.join(value)
# Special cases
if accessor == 'Description' and \
not 'description' in metadata_names:
result['description'] = escape(value)
elif accessor == 'Subject' and \
not 'keywords' in metadata_names:
result['keywords'] = escape(value)
if accessor not in ('Description', 'Subject'):
result[key] = escape(str(value))
if use_all:
created = self.context.CreationDate()
try:
effective = self.context.EffectiveDate()
if effective == 'None':
effective = None
if effective:
effective = DateTime(effective)
except AttributeError:
effective = None
try:
expires = self.context.ExpirationDate()
if expires == 'None':
expires = None
if expires:
expires = DateTime(expires)
except AttributeError:
expires = None
# Filter out DWIMish artifacts on effective / expiration dates
if effective is not None and \
effective > FLOOR_DATE and \
effective != created:
eff_str = effective.Date()
else:
eff_str = ''
if expires is not None and expires < CEILING_DATE:
exp_str = expires.Date()
else:
exp_str = ''
if exp_str or exp_str:
result['DC.date.valid_range'] = '%s - %s' % (eff_str, exp_str)
# add custom meta tags (added from qseo tab by user)
# for given context and default from configlet
custom_meta_tags = seo_context and \
seo_context['seo_customMetaTags'] or []
for tag in custom_meta_tags:
if tag['meta_content']:
result[tag['meta_name']] = escape(tag['meta_content'])
return result
