def show_results(self):
# check if user is owner/has permission to view all the poodle data
# if stealth voting is disabled this will just return true
if not self.context.stealth_voting:
return True
return 'Owner' in user.get_roles(user=user.get_current(),
obj=self.context)
def get_taskids_for_user():
user_id = user_api.get_current().getId()
storage = get_task_storage()
tasks = list()
if user_id in storage.get('users', dict()):
for taskid in storage['users'][user_id]:
tasks.append(taskid)
return tasks
def get_current_user_roles(self, context=None):
current_user = user.get_current().getId()
params = {"username": current_user}
if context:
params['obj'] = context
roles = get_roles(**params)
return roles
def get_sorted_users(self):
if self.show_results():
normalizer = queryUtility(IIDNormalizer)
poodledata = self.context.getPoodleData()
userids = poodledata['users'].keys()
userids.sort(
key=lambda id_: normalizer.normalize(self.getUserFullname(id_)))
else:
userids = [user.get_current().id]
return userids
def _send(self, mfrom, mto, messageText, immediate=False):
""" Send the message """
# Send it immediately. We don't want to store mails that doesn't get
# sent, mail shoud be delivered directly, always.
MailHost._send(self, mfrom, mto, messageText, immediate=True)
# I'm not sure you always get list here, so I handle both:
if isinstance(mto, (str, unicode)):
recipients = mto
mto = mto.split(',')
else:
recipients = ','.join(mto)
message = message_from_string(messageText)
email = {
'from': mfrom,
'to': recipients,
'date': DateTime(), # DateTime beacause timezones.
'subject': getheader(message['subject']),
'message': message.get_payload()
}
try:
key = self._emails.maxKey() + 1
except ValueError:
key = 0
store = False
current_user = user.get_current()
current_email = current_user.getProperty('email')
# Don't store anonymous password resets, or emails from the admin
if current_user.getId(
) is None or current_email is None or current_email == self.email_from_address:
return
sender_id = current_user.getId()
if sender_id not in self._outboxes:
self._outboxes[sender_id] = IITreeSet()
self._outboxes[sender_id].add(key)
store = True
acl_users = getToolByName(self, 'acl_users')
recipients = []
for mail in mto:
recipients.extend(acl_users.searchUsers(email=mail.strip()))
for recipient in recipients:
recipient_id = recipient['userid']
if recipient_id not in self._inboxes:
self._inboxes[recipient_id] = IITreeSet()
self._inboxes[recipient_id].add(key)
store = True
if store:
self._emails[key] = email
def _send(self, mfrom, mto, messageText, immediate=False):
""" Send the message """
# Send it immediately. We don't want to store mails that doesn't get
# sent, mail shoud be delivered directly, always.
MailHost._send(self, mfrom, mto, messageText, immediate=True)
# I'm not sure you always get list here, so I handle both:
if isinstance(mto, (str, unicode)):
recipients = mto
mto = mto.split(',')
else:
recipients = ','.join(mto)
message = message_from_string(messageText)
email = {'from': mfrom,
'to': recipients,
'date': DateTime(), # DateTime beacause timezones.
'subject': getheader(message['subject']),
'message': message.get_payload()}
try:
key = self._emails.maxKey() + 1
except ValueError:
key = 0
store = False
current_user = user.get_current()
current_email = current_user.getProperty('email')
# Don't store anonymous password resets, or emails from the admin
if current_user.getId() is None or current_email is None or current_email == self.email_from_address:
return
sender_id = current_user.getId()
if sender_id not in self._outboxes:
self._outboxes[sender_id] = IITreeSet()
self._outboxes[sender_id].add(key)
store = True
acl_users = getToolByName(self, 'acl_users')
recipients = []
for mail in mto:
recipients.extend(acl_users.searchUsers(email=mail.strip()))
for recipient in recipients:
recipient_id = recipient['userid']
if recipient_id not in self._inboxes:
self._inboxes[recipient_id] = IITreeSet()
self._inboxes[recipient_id].add(key)
store = True
if store:
self._emails[key] = email
def my_mails(self):
"""Return a dictionary of emails"""
user_id = user.get_current().getId()
if user_id in self._inboxes:
inbox = reversed([self._emails[key] for key in self._inboxes[user_id]])
else:
inbox = []
if user_id in self._outboxes:
outbox = reversed([self._emails[key] for key in self._outboxes[user_id]])
else:
outbox = []
return {'inbox': inbox, 'outbox': outbox}
def my_mails(self):
"""Return a dictionary of emails"""
user_id = user.get_current().getId()
if user_id in self._inboxes:
inbox = reversed(
[self._emails[key] for key in self._inboxes[user_id]])
else:
inbox = []
if user_id in self._outboxes:
outbox = reversed(
[self._emails[key] for key in self._outboxes[user_id]])
else:
outbox = []
return {'inbox': inbox, 'outbox': outbox}
def register_task(**kwargs):
task_id = uuid.uuid4().hex
now = datetime.now()
user_id = user_api.get_current().getId()
record = PersistentMapping(kwargs)
record["status"] = constants.PROCESSING
record["task_id"] = task_id
record['timestamp'] = now
record['seen'] = False
record['user'] = user_id
storage = get_task_storage()
if 'users' not in storage:
storage['users'] = OOBTree()
if user_id not in storage['users']:
storage['users'][user_id] = PersistentList()
storage['users'][user_id].append(task_id)
storage[task_id] = record
return task_id
def handle_save(self, action):
# roles = get_roles(obj=self.context)
if self.read_only_access:
raise Unauthorized
context = self.context
if not hasattr(context, 'saved_assessment_data') or \
not isinstance(context.saved_assessment_data, PersistentList):
context.saved_assessment_data = AssessmentData()
last = self.context.saved_assessment_data.last().copy()
datetime_now = datetime.datetime.now().replace(microsecond=0)
data, errors = self.extractData()
# if not errors:
# TODO: check for errors
for question in self.questions:
# countries = self.get_available_countries()
elements = question.get_assessed_elements(self.descriptor_obj,
muids=[])
values = []
score = None
if question.use_criteria == 'none':
field_name = '{}_{}'.format(self.article, question.id)
values.append(data.get(field_name, None))
for element in elements:
field_name = '{}_{}_{}'.format(self.article, question.id,
element.id)
values.append(data.get(field_name, None))
# score is updated if ALL of the fields have been answered
if values and None not in values:
score = question.calculate_score(self.descriptor, values)
name = '{}_{}_Score'.format(self.article, question.id)
last_upd = '{}_{}_Last_update'.format(self.article, question.id)
logger.info("Set score: %s - %s", name, score)
data[name] = score
last_values = last.get(name, [])
last_values = getattr(last_values, 'values', '')
score_values = getattr(score, 'values', '')
if last_values != score_values:
data[last_upd] = datetime_now
# check if _Summary text is changed, and update _Last_update field
summary = '{}_{}_Summary'.format(self.article, question.id)
if last.get(summary, '') != data.get(summary, ''):
data[last_upd] = datetime_now
last_upd = "{}_assess_summary_last_upd".format(self.article)
name = "{}_assessment_summary".format(self.article)
if last.get(name, '') != data.get(name, ''):
data[last_upd] = datetime_now
overall_score = 0
for k, v in data.items():
if not k.endswith('_Score'):
continue
else:
overall_score += getattr(v, 'weighted_score', 0)
data['OverallScore'] = overall_score
try:
data['assessor'] = user.get_current().getId()
except:
data['assessor'] = 'system'
data['assess_date'] = datetime.date.today()
if last != data:
last.update(data)
self.context.saved_assessment_data.append(last)
url = self.context.absolute_url() + '/@@edit-assessment-data-2018'
self.request.response.setHeader('Content-Type', 'text/html')
return self.request.response.redirect(url)
