def create_issue(request):
message = "True"
try:
IssueService.create_issue(request)
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def create(self, request, *args, **kwargs):
print(kwargs)
print(request.data)
issue_id = kwargs.get('issue_id', 0)
operation_type = request.data.get('operation', 0)
reslove_result = request.data.get('ResloveResult', 1)
comments = request.data.get('Desc')
IssueService.update_issue_operation_result(issue_id, operation_type,
reslove_result, comments,
request.user.id)
return response.Response(status=status.HTTP_200_OK)
def add_comment(request, issue_id):
message = "True"
try:
comment = request.POST.get('comments')
issue = ProjectIssue.objects.get(int(issue_id))
IssueService.create_issue_activity(issue, 0, 0, 0, comment,
request.user.id, 1, 2)
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def update_issue(request, issue_id):
message = "True"
try:
field = request.POST.get('field')
value = request.POST.get('value')
new_text = request.POST.get('new_text')
IssueService.update_issue(issue_id, field, value, new_text,
request.user.id)
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def cache_issue_search_word(request, project_id):
message = True
try:
word_key = str(request.user.id) + "_issue_searchkeyword"
filter_key = str(request.user.id) + "_issue_filter"
value = request.POST.get("search_word")
IssueService.cache_issue_search_word(word_key, value)
IssueService.cache_issue_filter(filter_key,
"Project:" + str(project_id))
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def update_issue_operation_result(request, issue_id, operation_type):
''' index page'''
message = "True"
try:
solution = request.POST.get("solution")
comments = request.POST.get("comments")
IssueService.update_issue_operation_result(issue_id, operation_type,
solution, comments,
request.user.id)
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def filter_ui_config(request, filter_id):
result = ""
try:
result = IssueService.filter_ui_config(filter_id)
except Exception as ex:
SimpleLogger.exception(ex)
return HttpResponse(result)
def get_issue_sub_navbar(self, request, sub_nav_action):
issues = IssueService.my_issue(request.user.id, sub_nav_action)
return self.get_sub_nav_bar(request,
self.subpage_model,
HomeIssuePath.sub_nav_template_path,
sub_nav_action=sub_nav_action,
issues=issues)
def get_my_issue_item(self,user_id,user_role):
issue_list_controll=self.get_my_issue_more(user_id,0,user_role)
issue_count=len(IssueService.my_issue(user_id,user_role))
key=str(user_id)+"_issue_searchkeyword"
search_word=RedisService.get_value(key)
pagefileds={"issue_list_controll":issue_list_controll,"issue_count":issue_count,"search_word":search_word}
return self.get_webpart(pagefileds,ProjectIssuePath.issue_item_list)
def get_filter_field(self, key):
issue_filter_cache = IssueService.filter_value_dict(
str(self.request.user.id) + "_issue_filter")
result = 0
if issue_filter_cache.get(key):
result = issue_filter_cache[key]
return result
def issue_count_bystatus(project_id, version_id, status, daterange):
result = IssueService.project_all_issues(project_id)
if daterange is not None:
create_daterange = daterange.split(',')
result = result.filter(CreationTime__range=create_daterange)
if str(version_id) != "0":
result = result.filter(Version=int(version_id))
return result.filter(Status=int(status)).count()
def patch(self, request, *args, **kwargs):
issue_id = kwargs.get('issue_id')
attachment_key = request.data.get('uploadList', [])
file_ids = IssueService.store_cached_file(attachment_key)
issue = models.ProjectIssue.objects.get(int(issue_id))
if issue:
issue.Attachments = issue.Attachments + file_ids
issue.save()
return response.Response(status=status.HTTP_202_ACCEPTED)
def create(self, request, *args, **kwargs):
issue = IssueService.create_issue(request.data, request.user)
serializer = project_serializer.ProjectIssueSerializer(
instance=issue, data=request.data)
serializer.is_valid(raise_exception=False)
headers = self.get_success_headers(serializer.data)
return response.Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def get_my_issue_more(self,user_id,page_index,user_role):
start_issue_index=int(page_index*10)
end_issue_index=int((page_index+1)*10)
dm_issues=IssueService.my_issue(user_id,user_role)[start_issue_index:end_issue_index]
issue_items=list()
for dm_issue in dm_issues:
temp_vm_issue=VM_ProjectIssue(self.request.user.id,dm_issue)
issue_items.append(temp_vm_issue)
pagefileds={"issue_items":issue_items}
return self.get_webpart(pagefileds,ProjectIssuePath.issue_item_controll)
def export_issue_result(request, project_id):
response = HttpResponse(content_type='application/vnd.ms-excel')
response['Content-Disposition'] = 'attachment;filename=' + str(
project_id) + '.xls'
output = BytesIO()
wb = IssueService.issue_excel_file(project_id, request.user.id)
wb.save(output)
output.seek(0)
response.write(output.getvalue())
return response
def create_issue_filter(request, project_id, filter_id):
message = "0"
try:
filter_name = request.POST.get('filter_name')
message = IssueService.create_issue_filter(project_id, filter_id,
filter_name,
request.user.id)
except Exception as ex:
SimpleLogger.exception(ex)
return HttpResponse(message)
def get(self, request, *args, **kwargs):
project_id = self.kwargs.get('project_id', 0)
issue_list = self.get_queryset()
return_result = HttpResponse(content_type='application/vnd.ms-excel')
return_result['Content-Disposition'] = 'attachment;filename=' + str(
project_id) + '.xls'
output = BytesIO()
wb = IssueService.issue_excel_file(issue_list, self.request.user.id)
wb.save(output)
output.seek(0)
return_result.write(output.getvalue())
return return_result
def save_cache(request, issue_id):
message = "True"
try:
cache_key = request.POST.get("cache_key")
tmp_issue = ProjectIssue.objects.get(int(issue_id))
tmp_issue.Attachments = tmp_issue.Attachments + IssueService.store_cached_file(
cache_key)
tmp_issue.save()
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def post(self, request, *args, **kwargs):
'''
:param request: /api/project/issue/attachments
:param args:
:param kwargs:
:return:
'''
file = request.FILES['file']
message = IssueService.cache_issue_attachments(file, request.user)
if message['cache_key'] != "":
return response.Response({
'file_id':
message["cache_key"],
'url':
WEB_HOST + '/api/project/issue/download_file/' +
str(message['cache_key'])
})
else:
return response.Response(status=status.HTTP_417_EXPECTATION_FAILED)
def cache_issue_filter(request, project_id, filter_id):
message = True
try:
key = str(request.user.id) + "_issue_filter"
print(request.POST)
if str(filter_id) == "0":
values = request.POST.get("values")
IssueService.cache_issue_filter(key, "Project:" + str(project_id))
IssueService.cache_issue_filter(key, values)
else:
IssueService.update_issue_filter_cache(key, filter_id)
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def issue_count_bystatus(project_id, version_id, status):
result = IssueService.project_all_issues(project_id)
if str(version_id) != "0":
result = result.filter(Version=int(version_id))
return result.filter(Status=int(status)).count()
def delete(self, request, *args, **kwargs):
file_id = kwargs.get('file_id')
issue_id = kwargs.get('issue_id')
IssueService.delete_attachment(file_id, issue_id)
return response.Response(status=status.HTTP_204_NO_CONTENT)
