class FilterForm(forms.Form):
fromDate = forms.DateTimeField(required=False)
toDate = forms.DateTimeField(required=False)
aUserId = forms.MultipleChoiceField(
widget=forms.CheckboxSelectMultiple,
required=False,
choices=[(user.id,' '.join([user.last_name,user.first_name]))
for user in TaskWidgetManager.getUsersThatUserHaveAccess(request.user, headerValues['CURRENT_PROJECT'])
])
def getResponsibleMenu(request):
headerValues = headers.initGlobals(request)
widget_manager = TaskWidgetManager()
draft_id = request.GET.get('draft_id', None)
if draft_id:
from PManager.services.task_drafts import get_draft_by_id
draft = get_draft_by_id(draft_id, request.user)
if draft:
users = draft.users.exclude(id=draft.author_id)
else:
users = dict()
else:
users = widget_manager.getResponsibleList(request.user, headerValues['CURRENT_PROJECT'])
c = RequestContext(request, {
'users': users
})
t = loader.get_template('helpers/responsible_menu.html')
return HttpResponse(t.render(c))
def widget(request, headerValues, widgetParams={}, qArgs=[], arPageParams={}):
date = datetime.datetime.now()
arWeekdays = {
'Sun': u'Вс',
'Mon': u'Пн',
'Tue': u'Вт',
'Wed': u'Ср',
'Thu': u'Чт',
'Fri': u'Пт',
'Sat': u'Сб'
}
arDates = {}
arDays = [{
'dateFormatted': date.date,
'date': date.strftime('%d.%m.%Y'),
'weekday': arWeekdays[date.strftime('%a')] + date.strftime(' %d.%m'),
'weekdayMark': date.strftime('%a')
}]
for i in range(1, 7):
arDates[i] = date + datetime.timedelta(days=i)
arDays.append({
'dateObject': arDates[i],
'dateFormatted': arDates[i].date,
'date': arDates[i].strftime('%d.%m.%Y'),
'weekday': arWeekdays[arDates[i].strftime('%a')] + arDates[i].strftime(' %d.%m'),
'weekdayMark': arDates[i].strftime('%a')
})
arProject = []
now = timezone.make_aware(datetime.datetime.now(), timezone.get_default_timezone())
projects = request.user.get_profile().getProjects()
for project in projects:
setattr(project, 'milestoneSet', project.milestones.all())
setattr(project, 'isManaged', request.user.get_profile().isManager(project))
for milestone in project.milestoneSet:
if milestone.date < now and not milestone.closed:
milestone.date = datetime.datetime.now()
milestone.save()
setattr(milestone, 'respSet', milestone.responsible.all())
setattr(milestone, 'critically', random.randrange(1, 4))
arProject.append(project)
return {
'title': u'Календарь ответственности',
'projects': arProject,
'arDays': arDays,
'users': TaskWidgetManager.getUsersThatUserHaveAccess(request.user, headerValues['CURRENT_PROJECT'])
}
def getMyTeam(request):
widgetManager = TaskWidgetManager()
resps = widgetManager.getResponsibleList(request.user, None)
if request.POST.get('q'):
q = request.POST.get('q')
resps = resps.filter(Q(Q(first_name__icontains=q) | Q(last_name__icontains=q)))
aResps = []
for resp in resps:
p = resp.get_profile()
respDict = {
'first_name': resp.first_name,
'last_name': resp.last_name,
'rel': p.avatar_rel,
'id': resp.id
}
histasksQty = resp.todo.filter(active=True, closed=False).count()
respDict['openTasksQty'] = histasksQty
aResps.append(respDict)
return HttpResponse(json.dumps(aResps))
def widget(request, headerValues, a, b):
bAllUsers = request.GET.get('show_all') == 'Y'
projects = PM_Project.objects.filter(tracker=TRACKER, closed=False, locked=False)
now = timezone.make_aware(datetime.datetime.now(), timezone.get_current_timezone())
users = TaskWidgetManager.getUsersThatUserHaveAccess(request.user, headerValues['CURRENT_PROJECT'])
if not bAllUsers:
users = users.filter(id__in=PM_Timer.objects.filter(
Q(Q(dateEnd=None) | Q(dateEnd__gt=datetime.datetime.now() - datetime.timedelta(days=1)))
).values('user__id'))
users = users.order_by('last_name')
# arFilter = {}
usersResult = []
maxTaskEffective = 0
maxEventsQty = 1
ratingUsers = deque()
for user in users:
userJoinTime = now - datetime.timedelta(days=30)
# userJoinTime = userJoinTime.days if userJoinTime.days > 0 else 1
# userJoinTime = 30
taskClosedQty = PM_Task.objects.filter(closed=True, resp=user, dateClose__gte=userJoinTime, active=True).count()
userRoles = user.userRoles.filter(project__in=projects)
setattr(user, 'roles_in_projects', userRoles)
profile = user.get_profile()
if profile.avatar:
profile.avatar = str(profile.avatar).replace('PManager', '')
eventsQty = PM_Task_Message.objects.filter(
dateCreate__gte=userJoinTime,
author=user
).count()
time = LogData.objects.raw(
'SELECT SUM(`value`) as summ, id, user_id from PManager_logdata WHERE `user_id`=' + str(int(user.id)) + '' +
' AND datetime > \'' + userJoinTime.strftime('%Y-%m-%d %H:%M:%S') + '\'' +
' AND code = \'DAILY_TIME\''
)
allTime = 0
for timer in time:
allTime += timer.summ if timer.summ else 0
setattr(user, 'profile', profile)
setattr(user, 'tasksQty', taskClosedQty)
setattr(user, 'eventsQty', eventsQty + round(allTime / 3600))
if user.eventsQty > maxEventsQty:
maxEventsQty = user.eventsQty
if taskClosedQty:
setattr(user, 'tasksEffective', round(taskClosedQty / 30, 4))
if user.tasksEffective > maxTaskEffective:
maxTaskEffective = user.tasksEffective
ratingUsers.append(user.id)
try:
if user.pk:
startedTimer = PM_Timer.objects.filter(user__id=user.pk).order_by('-dateEnd')
if startedTimer:
startedTimer = startedTimer[0]
bHaveAccessToStartedTask = request.user.get_profile().hasAccess(startedTimer.task, 'view')
if bHaveAccessToStartedTask:
setattr(user, 'startedTask', startedTimer.task)
setattr(user, 'startedTimer', startedTimer)
setattr(user, 'taskTime', startedTimer.task.getAllTime())
else:
continue
except PM_Timer.DoesNotExist:
pass
if not user.email and user.username.find('@'):
setattr(user, 'email', user.username)
usersResult.append(user)
for user in usersResult:
setattr(user, 'activity', int(round(float(user.eventsQty) / float(maxEventsQty), 2) * 100))
projects = request.user.get_profile().getProjects()
aProjects = []
arWeekDays = {
1: u'Пн',
2: u'Вт',
3: u'Ср',
4: u'Чт',
5: u'Пт',
6: u'Сб',
7: u'Вс',
}
for project in projects:
weekdays = range(1, 7)
now = datetime.datetime.combine(datetime.date.today(), datetime.time.max)
now = timezone.make_aware(now, timezone.get_current_timezone())
date1, date2 = None, None
events = []
for dayLost in weekdays:
if not date2:
date2 = now
date1 = now - datetime.timedelta(days=dayLost)
eventsQty = PM_Task_Message.objects.filter(
dateCreate__lt=date2,
dateCreate__gte=date1,
project=project
).count()
time = LogData.objects.raw(
'SELECT SUM(`value`) as summ, id, user_id from PManager_logdata WHERE `project_id`=' + str(
int(project.id)) + '' +
' AND DATE(datetime) = \'' + date2.date().isoformat() + '\'' +
' AND code = \'DAILY_TIME\''
)
allTime = 0
for timer in time:
allTime += timer.summ if timer.summ else 0
eventsQty += int(round(float(allTime) / float(3600)))
events.append({
'date': arWeekDays[date2.isoweekday()],
'qty': eventsQty
})
date2 = date1
events.reverse()
setattr(project, 'events', events)
aProjects.append(project)
return {
'title': u'Активность пользователей',
'users': usersResult,
'currentProject': int(request.GET.get('project', 0)),
'projects': aProjects,
'topUser': ratingUsers.pop() if len(ratingUsers) > 0 and bAllUsers else 0
}
def widget(request, headerValues, ar, qargs):
""" Edit task POST Method """
widgetManager = TaskWidgetManager()
post = request.POST
deadline = post.get('deadline', time.strftime('%d.%m.%Y'))
deadline = templateTools.dateTime.convertToDateTime(deadline)
name = post.get('name', False)
status = post.get('status', False)
if status:
status = PM_Task_Status.objects.get(code=status)
if request.GET.get('id', False):
task = PM_Task.objects.get(id=int(request.GET.get('id', False)))
else:
task = False
userTagSums = {}
if name:
planTime = post.get('planTime', 0)
if planTime:
planTime = planTime.replace(',', '.')
if task and task.milestone:
oldPlanTime = task.planTime or 0
change = PM_MilestoneChanges(milestone=task.milestone,
value=float(planTime) -
oldPlanTime)
change.save()
arSaveFields = {
'name':
name,
'text':
post.get('description', ''),
'repeatEvery':
post.get('repeatEvery', 0),
'deadline':
deadline,
'critically':
float(post.get('critically', 0))
if post.get('critically', 0) else 0.5,
'hardness':
float(post.get('hardness', 0)) if post.get('hardness', 0) else 0.5,
'project_knowledge':
float(post.get('project_knowledge', 0)) if post.get(
'project_knowledge', 0) else 0.5,
'reconcilement':
float(post.get('reconcilement', 0)) if post.get(
'reconcilement', 0) else 0.5,
'planTime':
float(planTime),
'status':
status if status else task.status
}
if task:
for k, val in arSaveFields.iteritems():
setattr(task, k, val)
else:
arSaveFields['author'] = request.user
task = PM_Task(**arSaveFields)
respId = post.get('resp', '')
if str(respId).find('@') > -1:
oUserProfile = PM_User.getOrCreateByEmail(respId, task.project,
'employee')
respId = oUserProfile.id
if respId:
task.resp = User.objects.get(pk=int(respId))
arSaveFields['resp'] = task.resp
task.save()
aObservers = post.getlist('observers')
for (counter, observer) in enumerate(aObservers):
if observer.find('@') > -1:
oUserProfile = PM_User.getOrCreateByEmail(
observer, task.project, 'employee')
aObservers[counter] = oUserProfile.id
task.observers.clear()
task.observers.add(*aObservers)
task.saveTaskTags()
if 'tags' not in arSaveFields:
arSaveFields['tags'] = task.tags.all()
arEmail = task.getUsersEmail([request.user.id])
task.sendTaskEmail('task_changed', arEmail, 'Task has been changed.')
backurl = request.GET.get('backurl', None)
if backurl:
return {'redirect': backurl}
elif request.GET.get('id', False):
from PManager.services.similar_tasks import tags_relations, similar_tasks
arSaveFields = task
if arSaveFields:
tagsRelations = tags_relations(arSaveFields)
aSimilarTasks = similar_tasks(arSaveFields.id,
tagsRelations=tagsRelations)
resp = arSaveFields.resp
tags = arSaveFields.tags.all()
observers = arSaveFields.observers.all()
aUsersHaveAccess = widgetManager.getResponsibleList(
request.user, None).values_list('id', flat=True)
currentRecommendedUser, userTagSums = get_user_tag_sums(
get_task_tag_rel_array(task), None, aUsersHaveAccess)
arSaveFields = arSaveFields.__dict__
arSaveFields.update({
'tags':
tags,
'resp':
resp,
'observers':
observers,
'critically':
arSaveFields.get('critically', 0.5),
'hardness':
arSaveFields.get('hardness', 0.5),
'project_knowledge':
arSaveFields.get('project_knowledge', 0.5),
'reconcilement':
arSaveFields.get('reconcilement', 0.5),
'similarTasks':
aSimilarTasks,
'tagsRelations':
tagsRelations,
'files':
task.files.all(),
'status':
status if status else task.status
})
else:
arSaveFields = {}
users = widgetManager.getResponsibleList(request.user,
headerValues['CURRENT_PROJECT'])
for field, val in arSaveFields.iteritems():
if isinstance(val, datetime.datetime):
arSaveFields[field] = val.strftime('%d.%m.%Y %H:%M')
return {
'id':
request.GET.get('id', False),
'post':
arSaveFields,
'project':
task.project
if task and task.project else headerValues['CURRENT_PROJECT'],
'users':
users,
'recommendedUsers': [i for i, c in userTagSums.iteritems()],
'title':
u'Изменение задачи',
'files':
taskExtensions.getFileList(task.files.all())
}
def widget(request, headerValues,a,b):
class FilterForm(forms.Form):
fromDate = forms.DateTimeField(required=False)
toDate = forms.DateTimeField(required=False)
aUserId = forms.MultipleChoiceField(
widget=forms.CheckboxSelectMultiple,
required=False,
choices=[(user.id,' '.join([user.last_name,user.first_name]))
for user in TaskWidgetManager.getUsersThatUserHaveAccess(request.user, headerValues['CURRENT_PROJECT'])
])
filterForm = FilterForm(
data=request.GET
)
cur_user_access_projects = [v['id'] for v in request.user.get_profile().getProjects().values('id')]
weeksDelta = 4
dateStart = datetime.datetime.now() - datetime.timedelta(weeks=weeksDelta)
dateEnd = None
users_id = filterForm['aUserId'].value()
if filterForm.is_valid() and users_id:
users_id_tmp = []
for uId in users_id:
users_id_tmp.append(int(uId))
users_id = users_id_tmp
del users_id_tmp
dateStart = templateTools.dateTime.convertToDateTime(filterForm['fromDate'].value()) if filterForm['fromDate'].value() else None
dateEnd = templateTools.dateTime.convertToDateTime(filterForm['toDate'].value()) if filterForm['toDate'].value() else None
if dateEnd:
dateEnd += datetime.timedelta(days=1) #include all day of end of range
if dateStart and not dateEnd:
dateEnd = datetime.datetime.now()
else:
users_id = []
allUsers = TaskWidgetManager.getUsersThatUserHaveAccess(request.user, headerValues['CURRENT_PROJECT'])
users = allUsers.filter(pk__in=users_id)
filterProject = int(request.GET.get('project', 0))
if filterProject:
cur_user_access_projects = [filterProject]
for user in users:
profile = user.get_profile()
if profile.avatar:
profile.avatar = str(profile.avatar).replace('PManager', '')
setattr(user,'profile',profile)
if not user.email and user.username.find('@'):
setattr(user, 'email', user.username)
# query = 'SELECT SUM(`seconds`) as summ, id, user_id, task_id, dateStart, dateEnd from PManager_pm_timer' + \
# ' WHERE `user_id`=' + str(int(user.id)) + \
# ' AND `dateStart` > \'' + str(dateStart) + '\'' + \
# ((' AND `dateStart` < \'' + str(dateEnd) + '\'') if dateEnd else '') + \
# ' GROUP BY `task_id` ORDER BY `dateStart` DESC'
# timers = PM_Timer.objects.raw(query)
timers = PM_Timer.objects.filter(dateEnd__gt=dateStart, user=user)
if dateEnd:
timers = timers.filter(dateEnd__lt=dateEnd)
arTaskTime = []
allUserTime = 0
allCommentsQty = 0
allFilesQty = 0
for timer in timers:
try:
task = timer.task
if task.project.id not in cur_user_access_projects:
continue
comments = PM_Task_Message.objects.filter(task=task, author=user)
if dateEnd:
comments = comments.filter(dateCreate__lt=dateEnd)
if dateStart:
comments = comments.filter(dateCreate__gt=dateStart)
if timer.seconds:
allUserTime += int(timer.seconds)
allCommentsQty += comments.count()
arTaskTime.append({
'comments_qty': comments.count(),
'task': task,
'timer': timer,
'date': timer.dateEnd
})
except PM_Task.DoesNotExist:
pass
setattr(user, 'taskTime', arTaskTime)
setattr(user, 'allTime', PM_Timer(seconds=allUserTime) if allUserTime else None)
setattr(user, 'all_comments_qty', allCommentsQty)
setattr(user, 'all_files_qty', allFilesQty)
closedTaskQty = PM_Task.objects.filter(resp=user, active=True)
commentsQty = PM_Task_Message.objects.filter(author=user)
if dateEnd:
closedTaskQty = closedTaskQty.filter(dateClose__lt=dateEnd)
commentsQty = commentsQty.filter(dateCreate__lt=dateEnd)
if dateStart:
closedTaskQty = closedTaskQty.filter(dateClose__gt=dateStart)
commentsQty = commentsQty.filter(dateCreate__gt=dateStart)
closedTaskQty = closedTaskQty.count()
commentsQty = commentsQty.count()
setattr(user, 'closedTaskQty', closedTaskQty)
setattr(user, 'commentsQty', commentsQty)
return {
'users': users,
'allUsers': allUsers,
'filterForm': filterForm,
'now': templateTools.dateTime.convertToSite(timezone.make_aware(datetime.datetime.now(), timezone.get_current_timezone())),
'week_ago': templateTools.dateTime.convertToSite(timezone.make_aware(datetime.datetime.now(), timezone.get_current_timezone()) - datetime.timedelta(days=7)),
'title': u'Статистика пользователей'
}
def widget(request,
headerValues,
widgetParams={},
qArgs=[],
arPageParams={},
addFields=[]):
widgetManager = TaskWidgetManager()
filter = {}
""" # TODO REDUNDANT filter=False ever
if filter:
lManager = listManager(PM_Task)
filter = lManager.parseFilter(filter)
"""
needTaskList = False
if 'filter' in widgetParams:
filter.update(widgetParams['filter'])
needTaskList = True
pst = lambda n: request.POST.get(n, 0) if hasattr(request, 'POST'
) else None
pSettings = {}
if 'CURRENT_PROJECT' in headerValues and \
headerValues['CURRENT_PROJECT'] and \
not 'allProjects' in filter:
project = widgetManager.getProject(headerValues['CURRENT_PROJECT'])
pSettings = project.getSettings()
if project.locked:
return {'redirect': 'payment'}
filter['project'] = project
else:
if 'allProjects' in filter:
del filter['allProjects']
project = None
""" # TODO: CHECK if milestone defined
if pst('add-to-milestone'):
tasksId = request.POST.getlist('task')
mId = int(pst('milestone')) if pst('milestone') else 0
mName = pst('milestone_name')
mDate = pst('milestone_date')
mDesc = pst('milestone_description')
milestone = None
if mId:
milestone = PM_Milestone.objects.get(pk=mId)
elif project:
if mName:
mName = mName.strip()
if mDate:
try:
mDate = templateTools.dateTime.convertToDateTime(mDate)
except (Exception):
mDate = None
if not mDate:
mDate = datetime.datetime.now()
milestone = PM_Milestone(name=mName, project=project, description=mDesc)
milestone.date = mDate
milestone.save()
for tId in tasksId:
if int(tId):
task = PM_Task.objects.get(pk=int(tId))
if task.milestone:
change = PM_MilestoneChanges(milestone=task.milestone, value=-(task.planTime or 0))
change.save()
task.milestone = milestone
task.save()
if milestone:
change = PM_MilestoneChanges(milestone=milestone, value=(task.planTime or 0))
change.save()
return {'redirect': ''}
elif pst('add-to-release'):
tasksId = request.POST.getlist('task')
mId = int(pst('release')) if pst('release') else 0
mName = pst('release_name')
mDate = pst('release_date')
milestone = None
if mId:
milestone = Release.objects.get(pk=mId)
elif project:
if mName:
mName = mName.strip()
if mDate:
try:
mDate = templateTools.dateTime.convertToDateTime(mDate)
except (Exception):
mDate = None
if not mDate:
mDate = datetime.datetime.now()
milestone = Release(name=mName, project=project)
milestone.date = mDate
milestone.save()
for tId in tasksId:
if int(tId):
task = PM_Task.objects.get(pk=int(tId))
task.release = milestone
task.save()
return {'redirect': ''}
#elif pst('add-observers'):
"""
if pst('add-observers'):
#todo: объединить с выше
tasksId = request.POST.getlist('task')
mId = int(pst('observer')) if pst('observer') else 0
if mId:
observer = User.objects.get(pk=mId)
else:
observer = None
if observer:
for tId in tasksId:
if int(tId):
task = PM_Task.objects.get(pk=int(tId))
task.observers.add(observer)
task.save()
return {'redirect': ''}
if isinstance(request, User):
#@var User request
cur_user = request
else:
#@var HttpRequest request
cur_user = request.user
cur_prof = None
aManagedProjectsId = dict()
if cur_user.is_authenticated():
cur_prof = cur_user.get_profile()
try:
aManagedProjectsId = cur_prof.managedProjects.values_list(
'id', flat=True)
except AttributeError:
aManagedProjectsId = dict()
if not 'pageCount' in arPageParams:
arPageParams['pageCount'] = 20
arPageParams['page'] = int(request.POST.get('page')) if request.POST.get(
'page', None) else 1
tasks, paginator = {}, {}
now = timezone.make_aware(datetime.datetime.now(),
timezone.get_default_timezone())
if needTaskList:
addTasks = {}
if not 'parentTask' in filter and \
not 'pk' in filter and \
not 'isParent' in filter and \
not 'all' in filter:
filter['parentTask_id__isnull'] = True
else:
if 'pageCount' in arPageParams:
del arPageParams[
'pageCount'] #выводим все подзадачи, а не только кусок, как для задач
if 'exclude' in widgetParams:
filter['exclude'] = widgetParams['exclude']
arTaskOrderParams = {'group': arPageParams.get('group', None)}
if arTaskOrderParams['group'] == 'milestones':
filter['closed'] = False
tasks = PM_Task.getForUser(cur_user, project, filter, qArgs,
arTaskOrderParams)
try:
tasks = tasks['tasks']
tasks = tasks.select_related('resp', 'project', 'milestone',
'parentTask__id', 'author', 'status',
'tag', 'tags__tag')
qty = tasks.count()
except AttributeError:
qty = 0
tasks = []
if 'page' not in arPageParams:
arPageParams['page'] = 1
paginator = {}
if 'pageCount' in arPageParams:
tasks = tasks[(arPageParams['page'] - 1) *
arPageParams['pageCount']:arPageParams['page'] *
arPageParams['pageCount']]
paginator = {
'all_qty':
qty,
'lastPage':
(qty <= arPageParams['page'] * arPageParams['pageCount'])
}
currentRecommendedUser = None
arBIsManager = {}
arBets = {}
arClientBets = {}
# aUsersHaveAccess = []
# if cur_user.is_authenticated():
# widgetManager.getResponsibleList(cur_user, None).values_list('id', flat=True)
for task in tasks:
if not task.id in arBIsManager:
arBIsManager[task.id] = task.project.id in aManagedProjectsId
# currentRecommendedUser, userTagSums = get_user_tag_sums(get_task_tag_rel_array(task), currentRecommendedUser,
# aUsersHaveAccess)
last_message_q = task.messages
if not arBIsManager[task.id]:
last_message_q = last_message_q.filter(
hidden=False,
hidden_from_clients=False,
hidden_from_employee=False,
isSystemLog=False)
last_message_q = last_message_q.order_by("-pk")
# Yegor comment PM_Timer Deprecated
# try:
# startedTimer = PM_Timer.objects.get(task=task, dateEnd__isnull=True)
# except PM_Timer.DoesNotExist:
# startedTimer = None
if 'parentTask' not in filter:
# subtasksQuery = PM_Task.objects.filter(parentTask=task, active=True)
filterQArgs = PM_Task.getQArgsFilterForUser(
cur_user, task.project)
filterQArgs = PM_Task.mergeFilterObjAndArray(
{
'parentTask': task,
'active': True
}, filterQArgs)
subtasksQuery = PM_Task.objects.filter(*filterQArgs).distinct()
subtasksQty = subtasksQuery.count()
subtasksActiveQuery = subtasksQuery.filter(
closed=False).distinct()
subtasksActiveQty = subtasksActiveQuery.count()
else:
subtasksQty = 0
subtasksActiveQty = 0
responsibleSequence = None
if subtasksQty:
subtaskPlanTime = 0
for t in subtasksQuery.annotate(summ=Sum('planTime')):
subtaskPlanTime += t.summ if t.summ else 0
if subtasksActiveQty:
responsibleSequence = []
idSequence = []
for stask in subtasksActiveQuery.filter(
resp__isnull=False):
if stask.resp:
respName = stask.resp.first_name + ' ' + stask.resp.last_name \
if stask.resp.first_name else stask.resp.username
if not stask.resp.id in idSequence:
idSequence.append(stask.resp.id)
responsibleSequence.append({
'id': stask.resp.id,
'name': respName
})
bCanBaneUser = False
if arBIsManager[task.id] and task.resp:
bCanBaneUser = True
last_mes = last_message_q[0] if last_message_q else None
users_messages = []
messages = task.messages.filter(author__id__isnull=False)
for message in messages:
d = {
'id': message.author.id,
'name': message.author.get_full_name(),
'avatar': message.author.profile.avatarSrc,
}
if not d in users_messages:
users_messages.append(d)
winner = task.getWinner()
winner_dict = {}
if winner:
winner_dict = {
'id': winner.id,
'avatar': winner.profile.avatarSrc
}
addTasks[task.id] = {
'url':
task.url,
'project': {
'name': task.project.name,
'id': task.project.id,
},
'author': {
'first_name': task.author.first_name,
'last_name': task.author.last_name
},
'donated':
task.donated,
'asked':
task.asked,
'canEdit':
task.canEdit(cur_user)
if cur_user.is_authenticated() else False,
'canRemove':
task.canPMUserRemove(cur_prof) if cur_prof else False,
'canSetOnPlanning':
arBIsManager[task.id] or cur_user.id == task.author.id,
'canObserve':
cur_user.is_authenticated(),
'canApprove':
arBIsManager[task.id] or cur_user.id == task.author.id,
#todo: разрешать платным пользователям только если денег хватает
'canClose':
(cur_user.is_superuser or cur_user.id == task.author.id)
if cur_user else False,
'canSetReady':
cur_prof.hasRole(task.project) and task.messages.filter(
author=cur_user).exists() if cur_prof else False,
'canSetCritically':
arBIsManager[task.id] or cur_user.id == task.author.id
if cur_user.is_authenticated() else False,
'canSetPlanTime':
task.canPMUserSetPlanTime(cur_prof) if cur_prof else False,
'canBaneUser':
bCanBaneUser,
# PM_TIMER deprecated
#'startedTimerExist': startedTimer != None,
#'startedTimerUserId': startedTimer.user.id if startedTimer else None,
'status':
task.status.code if task.status else '',
'todo': [{
'todo': t['todo'],
'bug': t['bug'],
'checked': t['checked']
} for t in task.messages.filter(Q(Q(todo=True) | Q(
bug=True))).order_by('id').values('checked', 'bug', 'todo')
],
'resp':
responsibleSequence if responsibleSequence else [{
'id':
task.resp.id,
'name':
task.resp.first_name + ' ' + task.resp.last_name
if task.resp.first_name else task.resp.username
} if task.resp else {}],
'last_message': {
'text':
TextFilters.escapeText(last_mes.text),
'date':
last_mes.dateCreate,
#todo: исправить говнокод на метод сообщения getLastTextObject
'author':
last_mes.author.first_name + ' ' +
last_mes.author.last_name if last_mes.author else '',
} if last_mes and last_mes.author else {
'text': task.text
},
# 'responsibleList': userTagSums,
'files':
taskExtensions.getFileList(task.files.all()),
'planTimes': [],
'viewed': (task.closed or task.isViewed(cur_user))
if cur_user.is_authenticated() else False,
'parent':
task.parentTask.id if task.parentTask
and hasattr(task.parentTask, 'id') else None,
'parentName':
task.parentTask.name if task.parentTask
and hasattr(task.parentTask, 'name') else '',
'subtasksQty':
subtasksQty,
'resultsQty':
task.messages.filter(code='RESULT').count(),
'subtasksActiveQty':
subtasksActiveQty,
'observer':
True if task.observers.filter(id=cur_user.id) else False,
'avatar':
task.resp.get_profile().avatar_rel if task.resp else {},
'milestoneId':
task.milestone.id if task.milestone else None,
'users':
users_messages,
'winner':
winner_dict,
'createdAt':
templateTools.dateTime.convertToSite(task.dateCreate,
'%d.%m.%Y %H:%M'),
'group': {
'name':
task.milestone.name,
'id':
task.milestone.id,
'description':
task.milestone.description,
'code':
'milestone',
'closed':
task.milestone.closed,
'date':
templateTools.dateTime.convertToSite(
task.milestone.date, '%d.%m.%Y')
}
if task.milestone and arPageParams.get('group') == 'milestones'
else {} #overrides by projects
}
if not project:
addTasks[task.id]['group'] = {
'name': task.project.name,
'id': task.project.id,
'code': 'project',
'url': task.project.taskListUrl
}
if subtasksQty:
addTasks[task.id]['planTime'] = subtaskPlanTime
addTasks[task.id]['needRespRecommendation'] = (
len(addTasks[task.id]['resp']) <= 0
or not addTasks[task.id]['resp'][0])
task_tags = task.tags.filter(tag__is_public=True)
list_tags = []
if task_tags.exists():
for tag in task_tags.values('tag__id', 'tag__tagText',
'tag__color'):
list_tags.append({
'tagText': tag['tag__tagText'],
'id': tag['tag__id'],
'color': tag["tag__color"]
})
addTasks[task.id]['tags'] = list_tags
if cur_user.is_authenticated():
reminder = PM_Reminder.objects.filter(
task=task,
user=cur_user).order_by('-date').values_list('date',
flat=True)
if reminder.exists():
addTasks[task.id]['reminder'] = reminder[0]
# if addTasks[task.id]['needRespRecommendation']:
# if currentRecommendedUser:
# recommendedUser = User.objects.get(pk=int(currentRecommendedUser))
# recommendedUserArray = {
# 'id': recommendedUser.id,
# 'name': recommendedUser.first_name + ' ' + recommendedUser.last_name
# }
# addTasks[task.id]['recommendedUser'] = {
# 'id': int(currentRecommendedUser),
# 'name': recommendedUserArray['name']
# }
# TODO: DISABLE PLANTIME ?
# planTimes = PM_User_PlanTime.objects.filter(task=task).distinct()
# for obj in planTimes:
# addTasks[task.id]['planTimes'].append({
# 'user_url': obj.user.get_profile().url,
# 'user_id': obj.user.id,
# 'user_name': obj.user.first_name + ' ' + obj.user.last_name,
# 'time': obj.time
# })
# if not task.planTime and obj.user.id == cur_user.id:
# addTasks[task.id]['planTime'] = obj.time
aUserLinks = dict()
resps = widgetManager.getResponsibleList(cur_user, project)
aResps = []
for resp in resps:
histasksQty = resp.todo.filter(active=True, closed=False).count()
setattr(resp, 'openTasksQty', histasksQty)
if resp.id not in aUserLinks:
try:
aUserLinks[resp.id] = {
'url': resp.get_profile().url,
'name': resp.last_name + ' ' + resp.first_name,
}
aResps.append(resp)
except PM_User.DoesNotExist:
pass
if needTaskList:
aTasksId = addTasks.keys()
if aTasksId:
#todo: all queries
aTimers = PM_Task.getAllTimeOfTasksWithSubtasks(aTasksId)
tasks = tasks_to_tuple(tasks, addFields)
tasks = task_list_prepare(tasks, addTasks, False)
for task in tasks:
task['time'] = 0
task['timers'] = []
if task['id'] in aTimers:
task['time'] = sum(aTimers[task['id']].values())
for uid in aTimers[task['id']]:
if uid in aUserLinks.keys():
task['timers'].append({
'time':
templateTools.dateTime.timeFromTimestamp(
aTimers[task['id']][uid]),
'user':
aUserLinks[uid]['name'],
'user_url':
aUserLinks[uid]['url']
})
task['full'] = True
today = timezone.make_aware(datetime.datetime.today(),
timezone.get_current_timezone())
yesterday = timezone.make_aware(
datetime.datetime.today() - datetime.timedelta(days=1),
timezone.get_current_timezone())
template = templateTools.get_task_template()
title = u'All challenges' if not project else project.name + ' / Challenges'
header = u'Active challenges' if not project else '<a href="/project/' + str(
project.id) + '/public/">' + project.name + '</a>' + ' / Challenges'
result = {
'title':
title,
'header':
header,
'tasks':
tasks,
'project':
project,
'users':
aResps,
'bounty':
widgetParams.get('bounty'),
'projectSettings':
pSettings,
'tab':
True,
'name':
u'Tasks',
'paginator':
paginator,
# TODO: milestones disabled
#'milestones': PM_Milestone.objects.filter(project=project, closed=False),
# TODO: releases disabled
#'releases': Release.objects.filter(project=project, status='new'),
'nextPage':
arPageParams.get('startPage', 0) +
1 if 'startPage' in arPageParams else None,
'filterDates': {
'today':
templateTools.dateTime.convertToSite(today, '%d.%m.%Y'),
'yesterday':
templateTools.dateTime.convertToSite(yesterday, '%d.%m.%Y'),
},
'canInvite':
cur_prof.isManager(project) if project and cur_prof else False,
'template':
template,
'tags':
list(Tags.objects.filter(is_public=True).values('id', 'tagText')),
}
if cur_user.is_authenticated():
result['qty'] = {
'ready':
PM_Task.getQtyForUser(cur_user, project, {
'status__code': 'ready',
'closed': False,
'active': True
}),
'started':
PM_Task.getQtyForUser(cur_user, project, {
'realDateStart__isnull': False,
'closed': False,
'active': True
}),
'not_approved':
PM_Task.getQtyForUser(cur_user, project, {
'status__code': 'not_approved',
'closed': False,
'active': True
}),
'deadline':
PM_Task.getQtyForUser(
cur_user, project, {
'deadline__lt': now,
'deadline__isnull': False,
'closed': False,
'active': True
})
}
return result
def widget(request, headerValues, arFilter, q):
widgetManager = TaskWidgetManager()
cur_user = request.user
prof = None
if cur_user.is_authenticated():
prof = request.user.get_profile()
task = None
if 'id' in request.GET or 'number' in request.GET:
try:
if 'id' in request.GET:
task = PM_Task.objects.filter(id=int(request.GET.get('id')), active=True).get()
elif 'number' in request.GET and 'project' in request.GET:
task = PM_Task.objects.filter(
number=int(request.GET.get('number')),
project=int(request.GET.get('project')),
parentTask__isnull=True,
active=True
)[0]
except (PM_Task.DoesNotExist, ValueError, IndexError):
task = None
if not task:
raise Http404(u'Задача удалена')
if not task.onPlanning and not cur_user.get_profile().hasAccess(task, 'view'):
raise Http404(u'Нет прав для просмотра задачи')
error = ''
cid = int(request.GET.get('confirm', 0))
if cid:
try:
message = PM_Task_Message.objects.get(pk=cid, task=task)
if message.code == 'SET_PLAN_TIME':
planTime = PM_User_PlanTime.objects.get(task=task, user=message.author)
authorProf = message.author.get_profile()
if not authorProf.hasRole(task.project, not_guest=True):
authorProf.setRole('employee', task.project)
if authorProf.is_outsource:
Agreement.objects.get_or_create(
payer=task.project.payer,
resp=authorProf.user
)
if not authorProf.isEmployee(task.project):
task.resp = prof.user
else:
task.resp = planTime.user
task.planTime = planTime.time
task.onPlanning = False
task.setStatus('revision')
task.save()
redisSendTaskUpdate({
'status': task.status.code,
'onPlanning': task.onPlanning,
'planTime': task.planTime,
'resp': [{
'id': task.resp.id,
'name': task.resp.first_name + ' ' + task.resp.last_name
}],
'viewedOnly': request.user.id,
})
task.systemMessage(
u'подтвердил(а) оценку в ' + str(task.planTime) +
u'ч. пользователя ' + planTime.user.first_name +
u' ' + planTime.user.last_name,
cur_user,
'CONFIRM_ESTIMATION'
)
task.sendTaskEmail('new_task', [planTime.user.email])
elif message.code == 'TIME_REQUEST':
if not message.requested_time_approved:
if prof and prof.user.id == message.project.payer.id or prof.isManager(message.project):
message.requested_time_approved = True
message.requested_time_approve_date = datetime.datetime.now()
message.requested_time_approved_by = request.user
message.save()
return {'redirect': task.url}
except PM_Task_Message.DoesNotExist:
pass
except PM_User_PlanTime.DoesNotExist:
pass
winner = task.getWinner()
setattr(task, 'text_formatted', TextFilters.getFormattedText(task.text) if task.text else '')
# setattr(task, 'responsibleList', task.responsible.all())
setattr(task, 'observersList', task.observers.all())
setattr(task, 'currentWinner', winner)
setattr(task, 'taskPlanTime', task.planTime)
if cur_user.is_authenticated():
setattr(task, 'canSetOnPlanning', task.onPlanning or task.canEdit(cur_user))
setattr(task, 'canSetPlanTime', task.canPMUserSetPlanTime(prof))
setattr(task, 'canObserve', cur_user.is_authenticated())
setattr(task, 'canSetCritically', task.canEdit(cur_user))
setattr(task, 'canSetReady', prof.hasRole(task.project))
setattr(task, 'canEdit', task.canEdit(cur_user))
setattr(task, 'canRemove', task.canPMUserRemove(prof))
setattr(task, 'canApprove', cur_user.id == task.author.id or prof.isManager(task.project) or cur_user.is_superuser)
setattr(task, 'canClose', task.canApprove)
setattr(task, 'canConfirm', cur_user.is_authenticated() and task.donations.filter(user=cur_user).count())
setattr(task, 'taskResp', [{'id': task.resp.id, 'name': task.resp.first_name + ' ' + task.resp.last_name if task.resp.first_name else task.resp.username} if task.resp else {}])
allTime = task.getAllTime()
files = taskExtensions.getFileList(task.files.all())
if task:
#set task readed
if cur_user.is_authenticated():
if not cur_user.id in [u.id for u in task.viewedUsers.all()]:
task.viewedUsers.add(cur_user)
hiddenSubTasksExist = False
arFilter = {
'parentTask': task
}
subtasks = []
# subtasks = taskList(request, headerValues, {'filter': arFilter}, [], {})
# subtasks = subtasks['tasks']
# for subtask in subtasks:
# if subtask['closed']:
# hiddenSubTasksExist = True
# break
# users = widgetManager.getResponsibleList(request.user, headerValues['CURRENT_PROJECT'])
users = User.objects.order_by('last_name').filter(
pk__in=PM_Task_Message.objects.filter(task=task).values('author__id')
)
candidates = User.objects.order_by('last_name').filter(
pk__in=PM_Task_Message.objects.filter(task=task, code='RESULT').values('author__id')
)
dict = task.__dict__
for field, val in dict.iteritems():
if isinstance(val, datetime.datetime):
setattr(task, field, val.strftime('%d.%m.%Y %H:%M'))
messages = task.messages.order_by('-dateCreate').exclude(code="WARNING")
if not cur_user.is_authenticated():
messages = messages.filter(isSystemLog=True)
else:
# userRoles = PM_ProjectRoles.objects.filter(user=request.user, role__code='manager')
if not request.user.is_superuser:
messages = messages.exclude(code="RESULT")
messages = messages.filter(Q(hidden=False) | Q(userTo=request.user.id) | Q(author=request.user.id))
if not prof.isManager(task.project):
if prof.isClient(task.project):
messages = messages.filter(hidden_from_clients=False)
if prof.isEmployee(task.project):
messages = messages.filter(hidden_from_employee=False)
lamp, iMesCount = 'no-asked', messages.count()
if iMesCount > 0 and messages[iMesCount - 1]:
if messages[iMesCount - 1].author and messages[iMesCount - 1].author.id == cur_user.id:
lamp = 'asked'
arTodo = []
arBugs = []
for mes in messages:
if mes.todo:
arTodo.append({
'id': mes.id,
'text': mes.text,
'checked': mes.checked
})
if mes.bug:
arBugs.append({
'id':mes.id,
'text': mes.text,
'checked': mes.checked
})
ob = {
'init': True
}
if cur_user.is_authenticated():
ob['canEdit'] = mes.canEdit(cur_user)
ob['canDelete'] = mes.canDelete(cur_user)
if mes.userTo and mes.userTo.id == cur_user.id:
mes.read = True
mes.save()
if cur_user.get_profile().isManager(task.project):
ob.update({
'hidden_from_clients': mes.hidden_from_clients,
'hidden_from_employee': mes.hidden_from_employee
})
setattr(mes, 'json', json.dumps(mes.getJson(ob, cur_user if cur_user.is_authenticated() else None)))
# try:
# startedTimer = PM_Timer.objects.get(task=task, dateEnd__isnull=True)
# except PM_Timer.DoesNotExist:
# startedTimer = None
startedTimer = None
setattr(task, 'todo', arTodo)
setattr(task, 'bug', arBugs)
templates = templateTools.getMessageTemplates()
taskTemplate = templateTools.get_task_template()
backers = User.objects.filter(
pk__in=PM_Project_Donation.objects.filter(task=task)
.values_list('user__id', flat=True)
)
aBackers = []
from tracker.settings import GIFT_USD_RATE
arDonateSum = 0
arDonateQty = 0
for backer in backers:
setattr(backer, 'donated', backer.get_profile().get_donation_sum(taskId=task.id) * GIFT_USD_RATE)
arDonateSum += backer.donated
arDonateQty += 1
aBackers.append(backer)
aBackers.sort(key=lambda x: -x.donated)
askers = []
maxRequested = 100
askedMin = 0
askedMax = 0
for m in task.messages.filter(requested_time_approved=True):
if maxRequested < m.requested_time:
maxRequested = m.requested_time
askers.append({
'user': m.author,
'ask': m.requested_time
})
if not askedMin or askedMin > m.requested_time:
askedMin = m.requested_time
if askedMax < m.requested_time:
askedMax = m.requested_time
askers.sort(key=lambda x: x['ask'])
results = []
if task.project.id != 1131 or request.user.is_superuser or (request.user.is_authenticated() and request.user.id == 2318):
for m in task.messages.filter(code='RESULT'):
if maxRequested < m.requested_time:
maxRequested = m.requested_time
results.append(m)
if maxRequested:
maxRequested += maxRequested * 0.1
for asker in askers:
asker['percent'] = asker['ask'] * 100 / maxRequested
team = []
userShares = {}
if task.project.blockchain_state:
try:
state = json.loads(task.project.blockchain_state)
userShares = state['Users']
teamWallets = userShares.keys()
except ValueError:
teamWallets = []
t = PM_User.objects.filter(blockchain_wallet__in=teamWallets)
for u in t:
setattr(u, 'percent', userShares[u.blockchain_wallet])
team.append(u)
# brain = TaskMind()
return {
'projectTeam': team,
'title': task.name,
'task': task,
'voted': PM_Task_Message.objects.filter(code='VOTE', author=request.user.id, task=task).exists(),
'donated': PM_Task_Message.objects.filter(code='DONATION', author=request.user.id, task=task).exists(),
'todo': task.messages.filter(todo=True),
'asked_min': askedMin,
'asked_max': askedMax,
'donatedPercent': task.donated * 100 / maxRequested,
'startedTimerExist': startedTimer != None,
'startedTimerUserId': startedTimer.user.id if startedTimer else None,
'project': task.project,
'is_employee': cur_user.get_profile().isEmployee(task.project) if cur_user.is_authenticated() else False,
'is_manager': cur_user.get_profile().isManager(task.project) if cur_user.is_authenticated() else False,
'user_roles': cur_user.get_profile().getRoles(task.project) if cur_user.is_authenticated() else False,
'files': files,
'time': allTime,
'avgDonate': (arDonateSum * 0.5 / (arDonateQty or 1)) if arDonateSum else 5,
'backers': aBackers,
'askers': askers,
'results': results,
'subtasks': subtasks,
'taskTemplate': taskTemplate,
'users': users,
'candidates': candidates,
'messages': messages,
# 'solutions': similar_solutions(task.id),
'lamp': lamp,
'hiddenSubTasksExist': hiddenSubTasksExist,
'templates': templates,
'error': error
# 'dataSet': len(arParams),
# 'similarSet': len(tasksSimilar),
# 'params': arParams
}
def widget(request, headerValues, a, b):
users = TaskWidgetManager.getUsersThatUserHaveAccess(request.user, headerValues['CURRENT_PROJECT'])
users = users.order_by('last_name')
projects = PM_Project.objects.filter(tracker=TRACKER, closed=False, locked=False)
now = timezone.make_aware(datetime.datetime.now(), timezone.get_current_timezone())
arFilter = {}
if 'auth' in request.GET:
if request.user.is_superuser:
uid = int(request.GET.get('auth', 0))
if uid:
try:
user = User.objects.get(pk=uid)
user.backend = 'django.contrib.auth.backends.ModelBackend'
auth.login(
request,
user
)
return HttpResponseRedirect("/")
except User.DoesNotExist:
pass
if headerValues['CURRENT_PROJECT']:
arFilter['userRoles__in'] = PM_ProjectRoles.objects.filter(project=headerValues['CURRENT_PROJECT'])
users = users.filter(**arFilter).distinct()
# users = union(users, [request.user,])
allUsersTaskQty = 0
for user in users:
userRoles = user.userRoles.filter(project__in=projects)
setattr(user, 'roles_in_projects', userRoles)
profile = user.get_profile()
if profile.avatar:
profile.avatar = str(profile.avatar).replace('PManager', '')
tasks_quantity_mixin(user)
if allUsersTaskQty < user.allTasksQty:
allUsersTaskQty = user.allTasksQty
setattr(user, 'profile', profile)
if request.user.is_superuser:
feeSum = 0
s = Fee.objects.raw('select sum(value) as s, id from pmanager_fee where user_id='+str(user.id))
for k in s:
feeSum += k.s or 0
setattr(user, 'feeSum', feeSum)
try:
if user.pk:
startedTimer = PM_Timer.objects.get(user__id=user.pk, dateEnd=None)
setattr(user, 'bHaveAccessToStartedTask', user.get_profile().isManager(startedTimer.task.project))
setattr(user, 'startedTask', startedTimer.task)
except PM_Timer.DoesNotExist:
pass
if not user.email and user.username.find('@'):
setattr(user, 'email', user.username)
return {
'users': users,
'allTasksQty': allUsersTaskQty or 1, #exclude division by zero in template
'currentProject': int(request.GET.get('project', 0)),
'title': u'Список пользователей'
}