def get_votes(self, meeting_item, factor):
item_evaluations = Evaluation.get_evaluations_by_meeting(self.meeting) \
.filter(meeting_item=meeting_item, factor=factor) \
.exclude(measure_value=None)
max_evaluations = item_evaluations.count()
rankings = list()
for measure_value in self.measure_values:
rankings.append({
'measure_value__id': measure_value.pk,
'measure_value__order': measure_value.order,
'votes': 0
})
votes_by_measure_value = item_evaluations \
.values('measure_value__id', 'measure_value__order') \
.annotate(votes=Count('measure_value')) \
.order_by('measure_value__order')
for measure_value_votes in votes_by_measure_value:
for index, ranking in enumerate(rankings):
if ranking['measure_value__id'] == measure_value_votes[
'measure_value__id']:
rankings[index]['votes'] = measure_value_votes['votes']
break
for index, ranking in enumerate(rankings):
votes = int(ranking['votes'])
percentage = get_votes_percentage(max_evaluations,
votes,
round_value=False)
rankings[index]['percentage'] = round(percentage, 2)
return rankings
def matrix_by_factors(self):
meeting_factors_count = self.meeting.factors.count()
''' Calculate the level of agreement between the stakeholders '''
factors_indexes = range(0, meeting_factors_count)
max_agreement = self.meeting_items.count() * meeting_factors_count
factors_agreement = list()
for ms_1 in self.meeting_stakeholders:
factors_agreement_row = (ms_1, list())
for ms_2 in self.meeting_stakeholders:
agreement_sum = 0
for mi in self.meeting_items:
for i in factors_indexes:
if self.dataset[ms_1.stakeholder.pk][
mi.pk][1][i][0] == self.dataset[
ms_2.stakeholder.pk][mi.pk][1][i][0]:
agreement_sum += 1
# Translate the raw result into percentages
percentage_agreement_sum = get_votes_percentage(
max_agreement, agreement_sum)
factors_agreement_row[1].append((
ms_2,
percentage_agreement_sum,
))
factors_agreement.append(factors_agreement_row)
return factors_agreement
def matrix_by_items(self):
''' Calculate the level of agreement between the stakeholders based on the overall decision items value '''
max_agreement = self.meeting_items.count()
items_agreement = list()
for ms_1 in self.meeting_stakeholders:
items_agreement_row = (ms_1, list())
for ms_2 in self.meeting_stakeholders:
agreement_sum = 0
for mi in self.meeting_items:
# The `self.dataset[ms_1.stakeholder.pk][mi.pk][0]` returns the most used measure value for a
# given item a given stakeholder evaluated
if self.dataset[ms_1.stakeholder.pk][mi.pk][
0] == self.dataset[ms_2.stakeholder.pk][mi.pk][0]:
agreement_sum += 1
# Translate the raw result into percentages
percentage_agreement_sum = get_votes_percentage(
max_agreement, agreement_sum)
items_agreement_row[1].append((
ms_2,
percentage_agreement_sum,
))
items_agreement.append(items_agreement_row)
return items_agreement
def update_meeting_input(self):
evaluations_count = Evaluation.get_evaluations_by_meeting(
self.meeting).filter(user=self.stakeholder).count()
factors_count = self.meeting.factors.count()
meeting_items_count = self.meeting.meetingitem_set.count()
max_input = factors_count * meeting_items_count
self.meeting_input = get_votes_percentage(max_input, evaluations_count)
self.save()
return self.meeting_input
def get_stakeholders_opinion(self):
measure_values_lookup = self._get_measure_values_lookup()
stakeholders_opinion = list()
for mi in self.meeting_items:
meeting_item_row = (mi, list())
for ms in self.meeting_stakeholders:
winner = self.dataset[ms.stakeholder.pk][mi.pk][0]
votes = self.dataset[ms.stakeholder.pk][mi.pk][1]
winner_count = len(filter(lambda x: x[0] == winner, votes))
winner_percentage = get_votes_percentage(
len(votes), winner_count)
meeting_item_row[1].append({
'color':
measure_values_lookup[winner]['color'],
'description':
measure_values_lookup[winner]['description'],
'percentage':
winner_percentage
})
mi_dataset = list()
for stakeholder_id, stakeholder_meeting_items in self.dataset.iteritems(
):
mi_dataset += stakeholder_meeting_items[mi.pk][1]
overall_winner = self._get_most_common_item_ordered(mi_dataset)
overall_winner_count = len(
filter(lambda x: x[0] == overall_winner, mi_dataset))
overall_winner_percentage = get_votes_percentage(
len(mi_dataset), overall_winner_count)
meeting_item_row[1].append({
'color':
measure_values_lookup[overall_winner]['color'],
'description':
measure_values_lookup[overall_winner]['description'],
'percentage':
overall_winner_percentage
})
stakeholders_opinion.append(meeting_item_row)
return stakeholders_opinion
def calculate_ranking(self):
meeting_items_count = self.meeting_items.count()
stakeholders_count = self.meeting.meetingstakeholder_set.count()
factors_count = self.meeting.factors.count()
max_evaluations = stakeholders_count * factors_count * meeting_items_count
with transaction.atomic():
value_ranking_sum = self.meeting_items.aggregate(
total=Sum('value_ranking'))
meeting_items_ranking = value_ranking_sum['total']
if meeting_items_count > 0:
self.value_ranking = meeting_items_ranking / float(
meeting_items_count)
else:
self.value_ranking = 0.0
self.save()
self.evaluation_summary.all().delete()
aggregated_measure_values = dict()
# Initialize the aggregated_measure_values dict to make sure
# it's gonna have all possible Measure Value, even if no meeting item
# has received a vote for that Measure Value.
for measure_value in self.meeting.measure.measurevalue_set.all():
aggregated_measure_values[measure_value.pk] = 0
for meeting_item in self.meeting_items.all():
for ranking in meeting_item.evaluation_summary.all():
if ranking.measure_value.pk not in aggregated_measure_values.keys(
):
aggregated_measure_values[measure_value.pk] = 0
aggregated_measure_values[
ranking.measure_value.pk] += ranking.raw_votes
for measure_value_id, raw_votes in aggregated_measure_values.iteritems(
):
percentage_votes = get_votes_percentage(max_evaluations,
raw_votes,
round_value=False)
measure_value = MeasureValue.objects.get(pk=measure_value_id)
Ranking.objects.create(content_object=self,
meeting=self.meeting,
measure_value=measure_value,
raw_votes=raw_votes,
percentage_votes=percentage_votes)
def calculate_ranking(self):
item_evaluations = Evaluation.get_evaluations_by_meeting(self.meeting) \
.filter(meeting_item=self)
measure = self.meeting.measure
stakeholders_count = self.meeting.meetingstakeholder_set.count()
factors_count = self.meeting.factors.count()
max_evaluations = stakeholders_count * factors_count
rankings = item_evaluations.values('measure_value__id').annotate(
votes=Count('measure_value'))
with transaction.atomic():
self.evaluation_summary.all().delete()
meeting_item_content_type = ContentType.objects.get_for_model(
MeetingItem)
for measure_value in measure.measurevalue_set.all():
Ranking.objects.get_or_create(
meeting=self.meeting,
content_type=meeting_item_content_type,
object_id=self.pk,
measure_value=measure_value)
for ranking in rankings:
votes = int(ranking['votes'])
percentage = get_votes_percentage(max_evaluations,
votes,
round_value=False)
Ranking.objects.filter(
meeting=self.meeting,
content_type=meeting_item_content_type,
object_id=self.pk,
measure_value__id=ranking['measure_value__id']).update(
raw_votes=votes, percentage_votes=percentage)
rankings = Ranking.objects.filter(
meeting=self.meeting,
content_type=meeting_item_content_type,
object_id=self.pk).order_by('measure_value__order')
if measure.measurevalue_set.count() <= 3:
highest = rankings.first()
lowest = rankings.last()
self.value_ranking = highest.percentage_votes - lowest.percentage_votes
else:
grouped_measure_values = measure.get_grouped_measure_values()
highest_group = grouped_measure_values[0]
highest_ids = map(lambda measure_value: measure_value.pk,
highest_group)
highest_sum = rankings.filter(
measure_value__in=highest_ids).aggregate(
Sum('percentage_votes'))
lowest_group = grouped_measure_values[-1]
lowest_ids = map(lambda measure_value: measure_value.pk,
lowest_group)
lowest_sum = rankings.filter(
measure_value__in=lowest_ids).aggregate(
Sum('percentage_votes'))
self.value_ranking = highest_sum[
'percentage_votes__sum'] - lowest_sum[
'percentage_votes__sum']
self.save()
def _calc_value_ranking(meeting, meeting_items, measure_values_count,
factors_count, stakeholders_ids, measure_values,
grouped_measure_values):
stakeholders_count = len(stakeholders_ids)
max_evaluations = stakeholders_count * factors_count
value_rankings = list()
for meeting_item in meeting_items:
item_evaluations = Evaluation.get_evaluations_by_meeting(meeting) \
.filter(meeting_item=meeting_item, user__in=stakeholders_ids)
rankings = list()
for measure_value in measure_values:
rankings.append({
'measure_value__id': measure_value.pk,
'measure_value__order': measure_value.order,
'votes': 0
})
votes_by_measure_value = item_evaluations \
.values('measure_value__id', 'measure_value__order') \
.annotate(votes=Count('measure_value')) \
.order_by('measure_value__order')
for measure_value_votes in votes_by_measure_value:
for index, ranking in enumerate(rankings):
if ranking['measure_value__id'] == measure_value_votes[
'measure_value__id']:
rankings[index]['votes'] = measure_value_votes['votes']
break
for index, ranking in enumerate(rankings):
votes = int(ranking['votes'])
percentage = get_votes_percentage(max_evaluations,
votes,
round_value=False)
rankings[index]['percentage'] = round(percentage, 2)
if measure_values_count <= 3:
highest = rankings[0]
lowest = rankings[-1]
value_ranking = highest['percentage'] - lowest['percentage']
else:
highest_group = grouped_measure_values[0]
highest_ids = map(lambda measure_value: measure_value.pk,
highest_group)
highest_sum = sum([
r['percentage'] for r in rankings
if r['measure_value__id'] in highest_ids
])
lowest_group = grouped_measure_values[-1]
lowest_ids = map(lambda measure_value: measure_value.pk,
lowest_group)
lowest_sum = sum([
r['percentage'] for r in rankings
if r['measure_value__id'] in lowest_ids
])
value_ranking = highest_sum - lowest_sum
value_rankings.append({
'meeting_item': meeting_item,
'value_ranking': value_ranking
})
value_rankings = sorted(value_rankings,
key=lambda v: v['value_ranking'],
reverse=True)
next_ranking = 1
for index, entry in enumerate(value_rankings):
if index > 0 and value_rankings[
index -
1]['value_ranking'] != value_rankings[index]['value_ranking']:
next_ranking += 1
value_rankings[index]['ranking'] = next_ranking
return value_rankings