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() contactleave = self._get_model_parameter(ContactLeave) if strutil.is_empty(contactleave.key()): contactleave.creator_id = self._get_user_id() contactleave = ContactService.get_instance().create_contactleave(contactleave, self._get_user_id()) else: contactleave = ContactService.get_instance().update_contactleave(contactleave, self._get_user_id()) rtn.set_data(contactleave) return rtn.to_json()
def execute(self): rtn = self._new_rtn() groupversion = self._get_model_parameter(GroupVersion) if strutil.is_empty(groupversion.key()): groupversion.creator_id = self._get_user_id() groupversion = ContactService.get_instance().create_groupversion(groupversion, self._get_user_id()) else: groupversion = ContactService.get_instance().update_groupversion(groupversion, self._get_user_id()) rtn.set_data(groupversion) return rtn.to_json()
def execute(self): rtn = self._new_rtn() groupcomponent = self._get_model_parameter(GroupComponent) if strutil.is_empty(groupcomponent.key()): groupcomponent.creator_id = self._get_user_id() groupcomponent = ContactService.get_instance().create_groupcomponent(groupcomponent, self._get_user_id()) else: groupcomponent = ContactService.get_instance().update_groupcomponent(groupcomponent, self._get_user_id()) rtn.set_data(groupcomponent) return rtn.to_json()
def execute(self): rtn = self._new_rtn() contact = self._get_model_parameter(Contact) group_ids = self._get_str_parameter("groupKeys", default='') group_ids = map(int, group_ids.split(",")) if group_ids.strip() != '' else [] contact.group_ids = group_ids if strutil.is_empty(contact.key()): contact.creator_id = self._get_user_id() contact = ContactService.get_instance().create_contact(contact, self._get_user_id()) else: contact = ContactService.get_instance().update_contact(contact, self._get_user_id()) contact.contactLeaves = ContactService.get_instance().fetch_contactleaves(contact.key()) rtn.set_data(contact) return rtn.to_json()
def fetch_tasks(self, user_id, group_id, worksheet_ids, assignee_ids): if group_id is not None: my_group_ids = ContactService.get_instance().fetch_my_groups(user_id, onlyrtnids=True) if group_id not in my_group_ids: raise UnauthorizedError() worksheet_ids = self.fetch_worksheet_ids(group_id, worksheet_ids=worksheet_ids) assignee_ids = self.fetch_assignee_ids(group_id, assignee_ids=assignee_ids) else: my_worksheet_ids = TaskService.get_instance().fetch_my_worksheets(user_id, onlyrtnids=True) worksheet_ids = list(set(worksheet_ids).intersection(set(my_worksheet_ids))) query = Task.all("a") query.what("a.uid") query.what("a.t_subject") query.what("a.due_startdate") query.what("a.due_finishdate") query.what("a.actual_progress") query.what("a.actual_startdate") query.what("a.actual_finishdate") query.what("a.t_status_code") query.what("a.assignee_id") if worksheet_ids != None and len(worksheet_ids) > 0: query.filter("a.worksheet_id in", worksheet_ids, wrapper=False) if assignee_ids != None and len(assignee_ids) > 0: query.filter("a.assignee_id in", assignee_ids, wrapper=False) tasks = query.fetch() return tasks
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 execute(self): rtn = self._new_rtn() offset = self._get_int_parameter('offset', 1) limit = self._get_int_parameter('limit', 20) filters = self._get_str_parameter('filters') filters = jsonutil.to_dict(filters) pager = ContactService.get_instance().fetch_contacts(self._get_user_id(), filters=filters, limit=limit, offset=offset) rtn.set_data(pager) 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 to_dict(self): self.planProgress = self.get_plan_progress() self.creatorDisplayName = user.get_user_display_name(self.creator_id) from contact.contactservice import ContactService self.taskAssigneeName = ContactService.get_instance().get_contact_name(self.assignee_id) from task.taskservice import TaskService self.componentKeys = map(lambda x: x.component_id, TaskService.get_instance().fetch_taskcomponents(self.key())) self.affectedVersionKeys = map(lambda x: x.version_id, TaskService.get_instance().fetch_taskversions(self.key(), True)) self.fixedVersionKeys = map(lambda x: x.version_id, TaskService.get_instance().fetch_taskversions(self.key(), False)) tdt = Model.to_dict(self) tdt['storyPoints'] = "%0.1f" % self.story_points if self.story_points is not None else "" return tdt
def fetch_notebooks(self, user_id, sharetome=None, withnotecount=True): query = Notebook.all() if sharetome: group_ids = ContactService.get_instance().fetch_my_groups(user_id, onlyrtnids=True, include_self=False) if len(group_ids) > 0: query.filter("group_id in", group_ids) else: return [] else: query.filter("creator_id =", user_id) query.order("nb_order") def notebook_proc(notebook): if withnotecount: notebook.notecount = self.get_notecount(False, user_id, notebook_id=notebook.uid) notebooks = query.fetch(model_proc=notebook_proc) return notebooks
def fetch_worksheets(self, user_id, sharetome=None, withtaskcount=True): query = Worksheet.all(alias="a") if sharetome: group_ids = ContactService.get_instance().fetch_my_groups(user_id, onlyrtnids=True, include_self=False) if len(group_ids) > 0: query.filter("group_id in", group_ids) else: return [] else: query.filter("creator_id =", user_id) query.order("ws_order") def worksheet_proc(worksheet): if withtaskcount: worksheet.taskcount = self.get_taskcount(False, user_id, worksheet_id=worksheet.uid) worksheets = query.fetch(model_proc=worksheet_proc) return worksheets
def _loadAssignees(self): assignees = ContactService.get_instance().fetch_my_contacts(self._get_user_id()) return assignees
def task_proc(task): task.mclogs = mclog.fetch_mclogs(Task.get_modelname(), task.key(), worksheet_id=self.get_worksheet_name, assignee_id=ContactService.get_instance().get_contact_name) task.taskComments = self.fetch_taskcomments(task.key())
def to_dict(self): self.bind_user_account = user.get_user(user_id=self.bind_user_id).u_account if self.bind_user_id != None and self.bind_user_id != model.EMPTY_UID else "" self.creatorDisplayName = user.get_user_display_name(self.creator_id) from contact.contactservice import ContactService self.groupKeys = list(set(map(lambda x: x.group_id, ContactService.get_instance().fetch_contactgroups(contact_id=self.key())))) return Model.to_dict(self)
def execute(self): rtn = self._new_rtn() status = ContactService.get_instance().empty_trash(self._get_user_id(), self._get_user_id()) rtn.set_data(status) 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 to_dict(self): from contact.contactservice import ContactService self.contactName = ContactService.get_instance().get_contact_name(self.contact_id) return Model.to_dict(self)
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
def execute(self): rtn = self._new_rtn() contact_id = self._get_int_parameter("contactKey") status = ContactService.get_instance().recover_contact(contact_id, self._get_user_id()) rtn.set_data(status) return rtn.to_json()
def execute(self): rtn = self._new_rtn() task = self._get_model_parameter(Task) affectedVersionKeys = self._get_str_parameter("affectedVersionKeys", '') task.affected_version_ids = map(int, affectedVersionKeys.split(",")) if affectedVersionKeys.strip() != '' else [] fixedVersionKeys = self._get_str_parameter("fixedVersionKeys", '') task.fixed_version_ids = map(int, fixedVersionKeys.split(",")) if fixedVersionKeys.strip() != '' else [] componentKeys = self._get_str_parameter("componentKeys", '') task.component_ids = map(int, componentKeys.split(",")) if componentKeys.strip() != '' else [] if strutil.is_empty(task.key()): task.creator_id = self._get_user_id() task = TaskService.get_instance().create_task(task, self._get_user_id()) task.taskComments = [] task.mclogs = [] else: task = TaskService.get_instance().update_task(task, self._get_user_id()) task.taskComments = TaskService.get_instance().fetch_taskcomments(task.key()) task.mclogs = mclog.fetch_mclogs(Task.get_modelname(), task.key(), worksheet_id=TaskService.get_instance().get_worksheet_name, assignee_id=ContactService.get_instance().get_contact_name) rtn.set_data(task) return rtn.to_json()
def execute(self): rtn = self._new_rtn() resource_id = self._get_int_parameter("resourceKey") status = ContactService.get_instance().delete_contactgroup(resource_id, self._get_user_id()) rtn.set_data(status) return rtn.to_json()
def execute(self): rtn = self._new_rtn() exception_id = self._get_int_parameter("exceptionKey") status = ContactService.get_instance().delete_groupexception(exception_id, self._get_user_id()) rtn.set_data(status) return rtn.to_json()
def to_dict(self): self.creatorDisplayName = user.get_user_display_name(self.creator_id) from contact.contactservice import ContactService self.groupName = ContactService.get_instance().get_group_name(self.group_id) return Model.to_dict(self)
def execute(self): rtn = self._new_rtn() component_id = self._get_int_parameter("componentKey") status = ContactService.get_instance().delete_groupcomponent(component_id, self._get_user_id()) rtn.set_data(status) return rtn.to_json()
def _loadGroups(self): groups = ContactService.get_instance().fetch_my_groups(self._get_user_id()) return groups
def execute(self): rtn = self._new_rtn() group_id = self._get_int_parameter("groupKey") groupversions = ContactService.get_instance().fetch_groupexceptions(group_id) rtn.set_data(groupversions) return rtn.to_json()