def get_period(self, dates, group_id, assignee_id=None):
rtn = stdModel(totalDays=0, periods=[])
if dates == None or len(dates) == 0:
return rtn
period = stdModel()
dates.sort()
date = dates[0]
period.startDate = date
def _append_period(peroid, end_date):
period.endDate = end_date
period.days = self.get_workdays(period.startDate, period.endDate, group_id, assignee_id=assignee_id)
rtn.totalDays += period.days
rtn.periods.append(period)
for i in range(1, len(dates)):
if date + datetime.timedelta(days=1) == dates[i]:
date = dates[i]
if i == len(dates) - 1:
_append_period(period, date)
else:
_append_period(period, date)
date = dates[i]
period = stdModel()
period.startDate = date
return rtn
def execute(self):
rtn = self._new_rtn()
notebooks = NoteService.get_instance().fetch_notebooks(self._get_user_id())
std = stdModel()
defaultnotebook = Notebook()
defaultnotebook.uid = model.EMPTY_UID
defaultnotebook.nb_name = i18n.get_i18n_message(conf.get_preferred_language(), "note_label_defaultnotebook")
defaultnotebook.notecount = NoteService.get_instance().get_notecount(False, self._get_user_id(), notebook_id=model.EMPTY_UID)
defaultnotebook.creator_id = self._get_user_id()
notebooks.insert(0, defaultnotebook);
trash = Notebook()
trash.uid = -100
trash.nb_name = i18n.get_i18n_message(conf.get_preferred_language(), "note_label_recyclebin")
trash.notecount = NoteService.get_instance().get_notecount(True, self._get_user_id())
trash.creator_id = self._get_user_id()
notebooks.append(trash)
std.notebooks = notebooks
std.notecount = NoteService.get_instance().get_notecount(False, self._get_user_id())
std.contactGroups = ContactService.get_instance().fetch_my_groups(self._get_user_id())
stmnotebooks = NoteService.get_instance().fetch_notebooks(self._get_user_id(), sharetome=True)
notebooks.extend(stmnotebooks)
rtn.set_data(std)
return rtn.to_json()
def testFilterWrapper(self):
query = stdModel().all()
query.model(self.TModel.get_modelname(), 'a')
query.model(self.TSubModel.get_modelname(), 'b')
query.filter("a.uid =", "b.t_id")
query.what("a.uid", "uid")
i = query.count()
self.assertEqual(i, 0)
query.filter("a.uid =", 'b.t_id', wrapper=False, replace=True)
query.clear()
i = query.count()
self.assertEqual(i, 21)
try:
query.filter("a.f_str =", 'abcd', wrapper=False)
query.clear()
query.fetch()
except Exception:
self.assertIn("Unknown column 'abcd", traceback.format_exc())
query = self.TModel.all("a")
query.filter("a.f_date =", properti.DateProperty.utctoday())
query.fetch(1)
self.assertTrue(True)
query.filter("a.f_datetime =", properti.DateTimeProperty.utcnow())
query.clear()
query.fetch(1)
self.assertTrue(True)
def get_burndown_data(self, user_id, group_id, start_date, end_date, worksheet_ids=None, assignee_ids=None):
if group_id is None:
raise RequiredError(label="cont_label_group")
if start_date is None:
raise RequiredError(label="rept_label_startdate")
if end_date is None:
raise RequiredError(label="rept_label_enddate")
today = dtutil.localtoday(conf.get_preferred_timezone())
daysBurndownLine = stdModel(guide=[], actual=[], forecast=[], teamEffort=[], requireRate=[])
workdates = self.get_workdates(start_date, end_date, group_id)
for date in workdates:
daysBurndownLine.guide[date] = [date, 0] # [date, days]
if date <= today:
daysBurndownLine.actual[date] = [date, 0] # [date, days]
else:
daysBurndownLine.forecast[date] = [date, 0] # [date, days]
daysBurndownLine.teamEffort = [date, 0] # [date, days]
daysBurndownLine.requireRate = [date, 0] # [date, rate]
tasks = self.fetch_tasks(user_id, group_id, worksheet_ids, assignee_ids)
duration = self.get_workdays(start_date, end_date, group_id)
for task in tasks:
if task.due_startdate >= start_date and task.due_finishdate <= end_date:
for date, guidearr in daysBurndownLine.guide.items():
task_workdays = self.get_workdays(task.due_startdate, task.due_finishdate, group_id)
if task.t_status_code != "task_code_cancel":
days = (duration - (date - start_date).days) / duration * task_workdays
guidearr[1] += days
if date <= today and task.actual:
""""""
def execute(self):
rtn = self._new_rtn()
std = stdModel()
select = self._get_bool_parameter("select", False)
if not select:
groups = ContactService.get_instance().fetch_groups(self._get_user_id())
std.groups = groups;
defaultgroup = Group()
defaultgroup.uid = model.EMPTY_UID
defaultgroup.group_name = i18n.get_i18n_message(conf.get_preferred_language(), "cont_label_defaultgroup")
defaultgroup.contactcount = ContactService.get_instance().get_contactcount(False, self._get_user_id(), group_id=model.EMPTY_UID)
defaultgroup.creator_id = self._get_user_id()
groups.insert(0, defaultgroup);
trash = Group()
trash.uid = -100
trash.group_name = i18n.get_i18n_message(conf.get_preferred_language(), "cont_label_recyclebin")
trash.contactcount = ContactService.get_instance().get_contactcount(True, self._get_user_id())
trash.creator_id = self._get_user_id()
groups.append(trash)
stmgroups = ContactService.get_instance().fetch_groups(self._get_user_id(), sharetome=True)
std.groups.extend(stmgroups)
else:
groups = ContactService.get_instance().fetch_groups(self._get_user_id(), withcontactcount=False)
std.groups = groups;
rtn.set_data(std)
return rtn.to_json()
def execute(self):
rtn = self._new_rtn()
group_id = self._get_int_parameter("groupKey")
groupresources = ContactService.get_instance().fetch_contactgroups(group_id=group_id)
std = stdModel()
std.groupResources = groupresources
std.contacts = ContactService.get_instance().fetch_contacts_created_by(self._get_user_id())
rtn.set_data(std)
return rtn.to_json()
def execute(self):
rtn = self._new_rtn()
std = stdModel()
if self._get_bool_parameter("ws", False):
std.worksheets = self._loadWorksheets()
if self._get_bool_parameter("gr", False):
std.groups = self._loadGroups()
if self._get_bool_parameter("as", False):
std.assignees = self._loadAssignees()
rtn.set_data(std)
return rtn.to_json()
def execute(self):
rtn = self._new_rtn()
worksheets = TaskService.get_instance().fetch_worksheets(self._get_user_id())
std = stdModel()
workbasket = Worksheet()
workbasket.uid = model.EMPTY_UID
workbasket.ws_name = i18n.get_i18n_message(conf.get_preferred_language(), "task_label_workbasket")
workbasket.taskcount = TaskService.get_instance().get_taskcount(False, self._get_user_id(), worksheet_id=model.EMPTY_UID)
workbasket.creator_id = self._get_user_id()
worksheets.insert(0, workbasket)
trash = Worksheet()
trash.uid = -100
trash.ws_name = i18n.get_i18n_message(conf.get_preferred_language(), "task_label_recyclebin")
trash.taskcount = TaskService.get_instance().get_taskcount(True, self._get_user_id())
trash.creator_id = self._get_user_id()
worksheets.append(trash)
std.worksheets = worksheets
std.contactGroups = ContactService.get_instance().fetch_my_groups(self._get_user_id())
stmworksheets = TaskService.get_instance().fetch_worksheets(self._get_user_id(), sharetome=True)
std.worksheets.extend(stmworksheets)
std.worksheetComponents = {}
std.worksheetVersions = {}
std.worksheetContacts = {}
for worksheet in std.worksheets:
if worksheet.group_id != None and worksheet.group_id != model.EMPTY_UID:
std.worksheetComponents[worksheet.key()] = ContactService.get_instance().fetch_groupcomponents(worksheet.group_id)
std.worksheetVersions[worksheet.key()] = ContactService.get_instance().fetch_groupversions(worksheet.group_id)
std.worksheetContacts[worksheet.key()] = ContactService.get_instance().fetch_contacts_by_group(worksheet.group_id)
else:
myself = ContactService.get_instance().get_myself(self._get_user_id())
if myself is not None:
std.worksheetContacts[worksheet.key()] = [myself]
rtn.set_data(std)
return rtn.to_json()
def get_progress_data(self, user_id, start_date, end_date, worksheet_ids, group_id=None, assignee_ids=None):
if worksheet_ids is None or len(worksheet_ids) == 0:
raise RequiredError("task_label_worksheet")
if start_date is None:
raise RequiredError(label="rept_label_startdate")
if end_date is None:
raise RequiredError(label="rept_label_enddate")
if end_date <= start_date:
raise CompareError(
label="rept_label_enddate", limitlabel="rept_label_startdate", limit=start_date, operator=">"
)
today = dtutil.localtoday(conf.get_preferred_timezone())
finishtaskcount = 0
progressLine = stdModel(plan={}, actual={}, forecast={})
progressBar = {}
for priority in i18n.get_i18n_messages(
conf.get_preferred_language(), "task_priority_code", rtn_dict=True
).keys():
statusTaskCount = [0, 0, 0] # planFinishCount, actualFinishCount, cancelCount
progressBar[priority] = statusTaskCount
rtn = stdModel(progressLine=progressLine, progressBar=progressBar, deviationTasks=[])
dates = self.get_workdates(start_date, end_date, group_id)
for date in dates:
progressLine.plan[date] = [date, 0] # [date, finish count]
if date <= today:
progressLine.actual[date] = [date, 0] # [date, finish count]
else:
progressLine.forecast[date] = [date, 0] # [date, finish count]
tasks = self.fetch_tasks(user_id, None, worksheet_ids, assignee_ids)
for task in tasks:
for date, planstd in progressLine.plan.items():
if date <= today and task.t_status_code == "task_code_closed" and task.actual_finishdate <= date:
progressLine.actual[date][1] += 1
if task.due_finishdate <= date and task.t_status_code != "task_code_cancel":
planstd[1] += 1
if task.t_status_code != "task_code_closed" and task.t_status_code != "task_code_cancel":
progress = task.get_plan_progress_int()
if progress > task.actual_progress:
task.deviationStatus = "rept_label_deviationdelay"
elif progress < task.actual_progress:
task.deviationStatus = "rept_label_deviationadvance"
if progress != task.actual_progress:
task.assigneeName = ContactService.get_instance().get_contact_name(task.assignee_id)
comments = TaskService.get_instance().fetch_taskcomments(task.key(), limit=1)
task.lastComment = comments[0].tc_content if len(comments) > 0 else ""
rtn.deviationTasks.append(task)
else:
if (
task.t_status_code == "task_code_closed"
and task.actual_startdate >= start_date
and task.actual_finishdate <= today
):
finishtaskcount += 1
statusTaskCount = progressBar[task.t_priority_code]
if task.due_finishdate <= end_date:
if task.t_status_code == "task_code_cancel":
statusTaskCount[2] += 1
else:
statusTaskCount[0] += 1
if task.t_status_code == "task_code_closed":
statusTaskCount[1] += 1
speed = finishtaskcount / float(self.get_workdays(start_date, today, None, None))
for date, forestd in progressLine.forecast.items():
forestd[1] = finishtaskcount + speed * ((date - today).days + 1)
if end_date > today:
progressLine.forecast[today] = [today, float(progressLine.actual[today][1])]
progressLine.plan = progressLine.plan.values()
progressLine.actual = progressLine.actual.values()
progressLine.forecast = progressLine.forecast.values()
return rtn
def get_allocation_data(self, user_id, group_id, start_date, end_date, worksheet_ids, assignee_ids):
if group_id is None:
raise RequiredError(label="cont_label_group")
if start_date is None:
raise RequiredError(label="rept_label_startdate")
if end_date is None:
raise RequiredError(label="rept_label_enddate")
if worksheet_ids is None or len(worksheet_ids) == 0:
raise RequiredError(label="task_label_worksheet")
if assignee_ids is None or len(assignee_ids) == 0:
raise RequiredError(label="rept_label_assignee")
assignee_linedata = {}
for assignee_id in assignee_ids:
std = stdModel()
std.assigneeName = ContactService.get_instance().get_contact_name(assignee_id)
std.totalTaskCount = 0
std.totalTaskDays = 0
std.statusTaskCounts = {}
for status in i18n.get_i18n_messages(
conf.get_preferred_language(), "task_status_code", rtn_dict=True
).keys():
std.statusTaskCounts[status] = 0
std.plan = {}
dates = self.get_workdates(start_date, end_date, group_id)
for date in dates:
std.plan[date] = [date, 0] # [date, finish count]
assignee_linedata[assignee_id] = std
tasks = self.fetch_tasks(user_id, group_id, worksheet_ids, assignee_ids)
for task in tasks:
assigneedata = assignee_linedata[task.assignee_id]
for date, plan in assigneedata.plan.items():
if task.due_startdate <= date and date <= task.due_finishdate:
plan[1] += 1
if task.due_finishdate <= end_date and task.due_startdate >= start_date:
assigneedata.totalTaskCount += 1
assigneedata.totalTaskDays += self.get_workdays(
task.due_startdate, task.due_finishdate, group_id, task.assignee_id
)
assigneedata.statusTaskCounts[task.t_status_code] += 1
sum1 = stdModel(totalTaskCount=0, totalTaskDays=0, totalWorkdays=0, totalIdleDays=0, totalBusyDays=0)
for assignee_id, ad in assignee_linedata.items():
ad.plan = ad.plan.values()
idleDates = []
busyDates = []
for p in ad.plan:
if p[1] == 0:
idleDates.append(p[0])
elif p[1] >= 2:
busyDates.append(p[0])
ad.idlePeriod = self.get_period(idleDates, group_id, assignee_id)
ad.busyPeriod = self.get_period(busyDates, group_id, assignee_id)
ad.totalWorkdays = self.get_workdays(start_date, end_date, group_id, assignee_id)
sum1.totalTaskCount += ad.totalTaskCount
sum1.totalTaskDays += ad.totalTaskDays
sum1.totalWorkdays += ad.totalWorkdays
sum1.totalIdleDays += ad.idlePeriod.totalDays
sum1.totalBusyDays += ad.busyPeriod.totalDays
std = stdModel()
std.details = assignee_linedata.values()
std.sum = sum1
return std
