def getWarnings(self):
rtn = {}
from Availability import Availability
tasks = self.getTasks()
avail = Availability(self)
timestamp = tsToDate(self.start)
userAvails = dict((user, avail.getAllForward(timestamp, user)) for user in self.members)
# Users with 0 availability
zeroes = [user for (user, hours) in userAvails.iteritems() if hours == 0]
if zeroes != []:
rtn['no-availability'] = zeroes
# Users with >100% commitment
overcommitted = filter(lambda user: userAvails[user] < sum(task.effectiveHours() for task in tasks if user in task.assigned), self.members)
if overcommitted != []:
rtn['overcommitted'] = overcommitted
# Users with no tasks
noTasks = filter(lambda user: filter(lambda task: user in task.assigned, tasks) == [], self.members)
if noTasks != []:
rtn['users-no-tasks'] = noTasks
# No sprint goals, or too many tasks (at least 10 tasks and more than 20% of all tasks) without a goal
unaffiliated = filter(lambda task: not task.goal, tasks)
if filter(lambda goal: goal.name != '', self.getGoals()) == []:
rtn['no-sprint-goals'] = True
elif len(unaffiliated) >= 10 and len(unaffiliated) / len(tasks) > .20:
rtn['tasks-without-goals'] = unaffiliated
# Goals with no tasks
noTasks = filter(lambda goal: goal.name and filter(lambda task: task.goal == goal, tasks) == [], self.getGoals())
if noTasks != []:
rtn['goals-no-tasks'] = noTasks
# Open tasks with 0 hours
noHours = filter(lambda task: task.stillOpen() and task.hours == 0, tasks)
if noHours != []:
rtn['open-without-hours'] = noHours
# Closed tasks with >0 hours
haveHours = filter(lambda task: not task.stillOpen() and task.status != 'deferred' and task.hours > 0, tasks)
if haveHours != []:
rtn['closed-with-hours'] = haveHours
# Tasks with too many hours
tooManyHours = filter(lambda task: task.hours > 24, tasks)
if tooManyHours != []:
rtn['too-many-hours'] = tooManyHours
return rtn
def placeholder(self):
avail = Availability(self.sprint)
for user in sorted(self.sprint.members):
hours = sum(t.effectiveHours() for t in self.tasks if user in t.assigned)
total = avail.getAllForward(getNow().date(), user)
print ProgressBar("<a style=\"color: #000\" href=\"/sprints/%d?search=assigned:%s\">%s</a>" % (self.sprint.id, user.safe.username, user.safe.username), hours, total, zeroDivZero = True, style = {100.01: 'progress-current-red'})
def __init__(self, placeholder, sprint, allTasks, revisions, **_):
Chart.__init__(self, placeholder)
days = [day for day in sprint.getDays()]
now = Weekday.today()
futureStarts = minOr(filter(lambda day: day > now, days), None)
futureIndex = days.index(futureStarts) if futureStarts else None
self.chart.defaultSeriesType = 'line'
self.chart.zoomType = 'x'
self.title.text = ''
self.plotOptions.line.dataLabels.enabled = True
self.tooltip.shared = True
self.credits.enabled = False
with self.xAxis as xAxis:
xAxis.tickmarkPlacement = 'on'
xAxis.maxZoom = 1
xAxis.title.text = 'Day'
# Future bar
if futureIndex is not None:
xAxis.plotBands = [{
'color': '#DDD',
'from': futureIndex - 0.75,
'to': len(days) - 0.5
}]
self.yAxis.min = 0
self.yAxis.title.text = 'Hours'
self.series = seriesList = []
taskSeries = {
'id': 'taskSeries',
'name': 'Tasking',
'data': [],
'color': '#4572a7',
'zIndex': 2
}
seriesList.append(taskSeries)
availSeries = {
'name': 'Availability',
'data': [],
'color': '#aa4643',
'zIndex': 2
}
seriesList.append(availSeries)
flagSeries = {
'type': 'flags',
'data': [],
'color': '#4572a7',
'shape': 'flag',
'onSeries': 'taskSeries',
'showInLegend': False,
'y': 16
}
seriesList.append(flagSeries)
if futureIndex == 0:
futureIndex = 1
statusToday, hoursToday = None, None
for day in days[:futureIndex]:
tasksToday = [revisions[t.id, day] for t in allTasks]
statusYesterday, hoursYesterday = statusToday, hoursToday
statusToday = {t: t.status for t in tasksToday if t and not t.deleted}
hoursToday = {t: t.manHours() for t in tasksToday if t and not t.deleted}
taskSeries['data'].append(sum(hoursToday.values()))
if hoursYesterday:
hoursDiff = {t: hoursToday.get(t, 0) - hoursYesterday.get(t, 0) for t in hoursToday}
largeChanges = [t for t, h in hoursDiff.iteritems() if abs(h) >= 16]
if largeChanges:
texts = []
for t in largeChanges:
if t not in hoursYesterday:
texts.append("<span style=\"color: #f00\">(New +%d)</span> %s" % (t.effectiveHours(), t.name))
elif hoursDiff[t] > 0:
texts.append("<span style=\"color: #f00\">(+%d)</span> %s" % (hoursDiff[t], t.name))
else:
if t.status in ('in progress', 'not started'):
texts.append("<span style=\"color: #0a0\">(%d)</span> %s" % (hoursDiff[t], t.name))
elif t.status == 'complete':
texts.append("<span style=\"color: #0a0\">(Complete %d)</span> %s" % (hoursDiff[t], t.name))
else:
texts.append("<span style=\"color: #999\">(%s %d)</span> %s" % (statuses[t.status].getRevisionVerb(statusYesterday.get(t, 'not started')), hoursDiff[t], t.name))
flagSeries['data'].append({'x': days.index(day), 'title': alphabet[len(flagSeries['data']) % len(alphabet)], 'text': '<br>'.join(texts)})
avail = Availability(sprint)
for day in days:
availSeries['data'].append(avail.getAllForward(day))
setupTimeline(self, sprint, ['Projected tasking'])
# Add commitment percentage to the axis label
labels = self.xAxis.categories.get()
for i in range(len(labels)):
# For future percentages, use today's hours (i.e. don't use the projected hours)
needed = taskSeries['data'][min(i, futureIndex - 1) if futureIndex else i][1]
thisAvail = availSeries['data'][i][1]
pcnt = "%d" % (needed * 100 / thisAvail) if thisAvail > 0 else "inf"
labels[i] += "<br>%s%%" % pcnt
self.xAxis.categories = labels
self.xAxis.labels.formatter = "function() {return this.value.replace('inf', '\u221e');}"
# Trendline
data = self.series[0].data.get()
dailyAvail = dict((day, avail.getAll(day)) for day in days)
totalAvail = 0
for daysBack in range(1, (futureIndex or 0) + 1):
midPoint = [futureIndex - daysBack, data[futureIndex - daysBack][1]]
if dailyAvail[days[midPoint[0]]] > 0:
daysBack = min(daysBack + 2, futureIndex)
startPoint = [futureIndex - daysBack, data[futureIndex - daysBack][1]]
totalAvail = sum(dailyAvail[day] for day in days[startPoint[0] : midPoint[0]])
break
if totalAvail > 0 and startPoint[0] != midPoint[0]:
slope = (midPoint[1] - startPoint[1]) / (midPoint[0] - startPoint[0])
slopePerAvail = slope * (midPoint[0] - startPoint[0]) / totalAvail
points, total = [], midPoint[1]
total = taskSeries['data'][futureIndex - 1][1]
points.append([futureIndex - 1, total])
for i in range(futureIndex, len(days)):
total += slopePerAvail * dailyAvail[days[i]]
points.append([i, total])
seriesList.append({
'name': 'Projected tasking',
'data': points,
'color': '#666',
'dataLabels': {'formatter': "function() {return (this.point.x == %d) ? parseInt(this.y, 10) : null;}" % (len(days) - 1)},
'marker': {'symbol': 'circle'},
'zIndex': 1
})
def distributeUpdate(handler, p_sprint, p_targetUser=None, p_task=None):
def die(msg):
print toJS({"error": msg})
done()
handler.title("Distribute Tasks")
requirePriv(handler, "Write")
handler.wrappers = False
handler.contentType = "application/json"
sprintid = int(p_sprint)
sprint = Sprint.load(sprintid)
if not sprint or sprint.isHidden(handler.session["user"]):
die("No sprint with ID %d" % sprintid)
if not sprint.canEdit(handler.session["user"]):
die("Unable to edit sprint")
# Make changes
if p_targetUser != None and p_task != None:
task = Task.load(int(p_task))
if not task:
die("Invalid task ID")
if p_targetUser == "deferred":
task.status = "deferred"
task.hours = 0
if task.creator == handler.session["user"] and (dateToTs(getNow()) - task.timestamp) < 5 * 60:
task.save()
else:
task.saveRevision(handler.session["user"])
Event.taskUpdate(handler, task, "status", task.status)
else:
userid = to_int(p_targetUser, "targetUser", die)
user = User.load(userid)
if not user:
die("No user with ID %d" % userid)
task.assigned = {user}
if task.creator == handler.session["user"] and (dateToTs(getNow()) - task.timestamp) < 5 * 60:
task.save()
else:
task.saveRevision(handler.session["user"])
Event.taskUpdate(handler, task, "assigned", task.assigned)
def makeTaskMap(task):
return {
"id": task.id,
"groupid": task.group.id,
"hours": task.hours,
"name": task.name,
"important": task.hours > 8,
"team": len(task.assigned) > 1,
}
# Return current info
tasks = filter(lambda task: task.stillOpen(), sprint.getTasks())
avail = Availability(sprint)
deferredTasks = filter(lambda task: task.status == "deferred", sprint.getTasks())
m = {
"deferred": {
"username": "******",
"groups": [
{"id": group.id, "name": group.name}
for group in sorted(
(group for group in set(task.group for task in deferredTasks)), key=lambda group: group.seq
)
],
"tasks": [makeTaskMap(task) for task in deferredTasks],
}
}
for user in sprint.members:
userTasks = filter(lambda task: user in task.assigned, tasks)
m[user.id] = {
"username": user.username,
"hours": sum(task.hours for task in userTasks),
"availability": avail.getAllForward(getNow().date(), user),
"groups": [
{"id": group.id, "name": group.name}
for group in sorted(
(group for group in set(task.group for task in userTasks)), key=lambda group: group.seq
)
],
"tasks": [makeTaskMap(task) for task in userTasks],
}
print toJS(m)
def newTaskMany(handler, group, p_body, dryrun=False):
def die(msg):
print msg
done()
handler.wrappers = False
requirePriv(handler, "User")
id = int(group)
defaultGroup = Group.load(id)
if not defaultGroup or defaultGroup.sprint.isHidden(handler.session["user"]):
die("No group with ID <b>%d</b>" % id)
sprint = defaultGroup.sprint
if not (sprint.isActive() or sprint.isPlanning()):
die("Unable to modify inactive sprint")
elif not sprint.canEdit(handler.session["user"]):
die("You don't have permission to modify this sprint")
group = defaultGroup
groups = [group]
newGroups = []
tasks = {group: []}
sep = "|"
lines = map(lambda x: x.strip(" \r\n"), p_body.split("\n"))
errors = []
defaultAssigned = {handler.session["user"] if handler.session["user"] in sprint.members else sprint.owner}
for line in lines:
if line == "":
group = defaultGroup
elif line[0] == "#": # Comment
continue
elif len(line) == 1: # Separator
sep = line[0]
elif (
line[0] == "[" and line[-1] == "]" and set(line[1:-1].split(" ")) <= set(u.username for u in sprint.members)
): # Default assigned
defaultAssigned = {User.load(username=username) for username in line[1:-1].split(" ")}
elif line[-1] == ":": # Group
line = line[:-1]
group = Group.load(sprintid=sprint.id, name=line)
if not group: # Check if new group already defined
for newGroup in newGroups:
if newGroup.name == line:
group = newGroup
break
if not group: # Make new group
group = Group(sprint.id, line)
newGroups.append(group)
group.id = -len(newGroups)
if not group in groups: # First time this group has been used in the script
groups.append(group)
tasks[group] = []
else:
parts = line.split(sep)
name, assigned, status, hours = None, None, None, None
if not 2 <= len(parts) <= 4:
errors.append("Unable to parse (field count mismatch): %s" % stripTags(line))
continue
for part in parts:
part = part.strip()
if part == "":
errors.append("Unable to parse (empty field): %s" % stripTags(line))
continue
# Hours
if hours is None:
try:
hours = int(part)
continue
except ValueError:
pass
# Status
if status is None and part.lower() in statuses:
status = part.lower()
continue
# Assigned
if assigned is None and set(part.split(" ")) <= set(u.username for u in sprint.members):
assigned = set(User.load(username=username) for username in part.split(" "))
continue
# Name
if name is None:
name = part
continue
errors.append("Unable to parse (no field match on '%s'): %s" % (stripTags(part), stripTags(line)))
if assigned is None:
assigned = defaultAssigned
if status is None:
status = "not started"
if name is None or hours is None:
errors.append("Unable to parse (missing required fields): %s" % stripTags(line))
if not any(v is None for v in (name, assigned, status, hours)):
tasks[group].append((name, assigned, status, hours))
if dryrun:
handler.log = False
numTasks = sum(len(taskSet) for taskSet in tasks.values())
taskHours = sum(
hours for taskSet in tasks.values() for name, assigned, status, hours in taskSet if status != "deferred"
)
ownTaskHours = sum(
hours
for taskSet in tasks.values()
for name, assigned, status, hours in taskSet
if status != "deferred" and handler.session["user"] in assigned
)
avail = Availability(sprint)
availHours = avail.getAllForward(getNow().date(), handler.session["user"])
usedHours = sum(task.effectiveHours() for task in sprint.getTasks() if handler.session["user"] in task.assigned)
availHours -= usedHours
if errors:
print ErrorBox("<br>".join(errors))
if numTasks:
box = InfoBox
stats = "Adding %s " % pluralize(numTasks, "task", "tasks")
if newGroups:
stats += "and %s " % pluralize(len(newGroups), "group", "groups")
stats += "for a total of %s" % pluralize(taskHours, "hour", "hours")
if ownTaskHours != taskHours:
stats += ", %s yours" % pluralize(ownTaskHours, "hour", "hours")
if ownTaskHours:
if availHours == 0:
stats += ". You have no future availability for these tasks"
box = WarningBox
elif availHours < 0:
stats += ". You are already overcommitted by %s" % pluralize(-availHours, "hour", "hours")
box = WarningBox
else:
stats += ", %d%% of your future availability" % (100 * ownTaskHours / availHours)
box = WarningBox if ownTaskHours > availHours else InfoBox
print box(stats)
elif not errors:
print InfoBox('Waiting for tasks. Click "Help" above if needed')
groupedTasks = OrderedDict(
(
group,
[
Task(
group.id,
sprint.id,
handler.session["user"].id,
0,
name,
status,
hours,
{user.id for user in assigned},
1,
id=0,
)
for name, assigned, status, hours in tasks[group]
],
)
for group in groups
)
print TaskTable(sprint, False, tasks=groupedTasks, status=True, name=True, assigned=True, hours=True)
elif errors:
die("There are unparseable lines in the task script. See the preview for more information")
else:
# There's some weirdness in the way groups auto-sequence that breaks when multiple groups are made without saving
seq = maxOr(group.seq for group in sprint.getGroups()) + 1
for group in newGroups:
group.seq = seq
seq += 1
for group in groups:
# Changing a group's ID will change its hash, so this pulls from tasks before saving the group in case it's new
groupTasks = tasks[group]
if group in newGroups:
group.id = 0
group.save()
for name, assigned, status, hours in groupTasks:
task = Task(group.id, group.sprint.id, handler.session["user"].id, 0, name, status, hours)
task.assigned |= assigned
task.save()
Event.newTask(handler, task)
numGroups = len(newGroups)
numTasks = sum(map(lambda g: len(g), tasks.values()))
if numGroups > 0 and numGroups > 0:
delay(
handler,
SuccessBox(
"Added %d %s, %d %s"
% (
numGroups,
"group" if numGroups == 1 else "groups",
numTasks,
"task" if numTasks == 1 else "tasks",
),
close=3,
fixed=True,
),
)
elif numGroups > 0:
delay(
handler,
SuccessBox("Added %d %s" % (numGroups, "group" if numGroups == 1 else "groups"), close=3, fixed=True),
)
elif numTasks > 0:
delay(
handler,
SuccessBox("Added %d %s" % (numTasks, "task" if numTasks == 1 else "tasks"), close=3, fixed=True),
)
else:
delay(handler, WarningBox("No changes", close=3, fixed=True))
handler.responseCode = 299
