def init_task(task_data, task, user_id):
tmp_task = task
for field in tmp_task.__dict__.keys():
if field in task_data.keys():
if field == 'id':
continue
if field == 'DeadLine':
dead_line = task_data.get('DeadLine')
if dead_line == "":
tmp_task.DeadLine = DateTimeHelper.add_day(
DateTimeHelper.get_now_date(), 1)
else:
tmp_task.DeadLine = DateTimeHelper.get_date_StringFormat(
dead_line[0:10], '%Y-%m-%d')
continue
if field == 'Owner':
owner = task_data.get('Owner')
if owner == "":
owner = str(user_id)
tmp_task.Owner = str(owner) + ','
continue
if field == 'ProjectID':
project = task_data.get('ProjectID')[0]
version = task_data.get('ProjectID')[1]
print(project)
print(version)
tmp_task.ProjectID = project
tmp_task.Version = version
continue
tmp_task.__setattr__(field, task_data.get(field))
tmp_task.Progress = 0
tmp_task.StartDate = None
return tmp_task
def init_task(task_data, task, user_id):
tmp_task = task
for field in tmp_task.__dict__.keys():
if field in task_data.keys():
if field == 'id':
continue
if field == 'DeadLine':
dead_line = task_data.get('DeadLine')
if "000Z" in dead_line:
temp_date = datetime.datetime.strptime(
dead_line, "%Y-%m-%dT%H:%M:%S.000Z")
ts = int(temp_date.timestamp())
temp_date = datetime.datetime.fromtimestamp(
ts, pytz.timezone(TIME_ZONE))
offset = temp_date.tzinfo.utcoffset(temp_date)
temp_date = temp_date + datetime.timedelta(
seconds=offset.seconds)
else:
temp_date = dead_line
if dead_line == "":
tmp_task.DeadLine = DateTimeHelper.add_day(
DateTimeHelper.get_now_date(), 1)
else:
tmp_task.DeadLine = temp_date
continue
if field == 'Owner':
continue
if field == 'ProjectVersions':
continue
if field == 'Progress':
tmp_task.Progress = float(task_data.get(field))
tmp_task.__setattr__(field, task_data.get(field))
return tmp_task
def get_query_info(submitionid):
query_info = list()
testjobs = DAL_TestJob.getjobsbysubmitionid(submitionid)
today = str(datetime.date.today())
if len(testjobs):
testjob = testjobs[0]
query_info.append(testjob.TJStartTime)
if testjob.TJFinishedTime:
tempDate = str(
DateTimeHelper.add_day(str(testjob.TJFinishedTime),
1))[0:10]
query_info.append(tempDate)
elif int(testjob.TJProgress) == 100:
tempDate = str(
DateTimeHelper.add_day(str(testjob.TJEndTime), 1))[0:10]
query_info.append(tempDate)
else:
query_info.append(str(datetime.date.today()))
query_info[1] = str(DateTimeHelper.add_day(query_info[1],
1))[0:10]
else:
query_info.append(str(datetime.date.today()))
query_info.append(str(DateTimeHelper.add_day(today, 1))[0:10])
testsubmition = DAL_TestSubmition.gettestsubmition(submitionid)
bugfree_mapping_item = DAL_BugReport.get_bugfree_module(
testsubmition.TPSProductName, testsubmition.TPSPlatform)
query_info.append(bugfree_mapping_item.BugfreeProjectID)
return query_info
def update_issue_operation_result(issue_id, operation_type, solution,
comments, user_id):
result = False
try:
issue = ProjectIssue.objects.get(int(issue_id))
if str(operation_type) == "1": # 解决问题
field = "Solution"
old_value = str(issue.__dict__[field])
issue.__dict__[field] = int(solution)
issue.Status = 4
issue.ResolvedTime = DateTimeHelper.getcnow()
issue.UpdateTime = DateTimeHelper.getcnow()
issue.Solver = user_id
issue.Processor = issue.Creator
issue.save()
IssueService.send_notification_email(issue, "修复了问题",
EMAIL_TEMPLATES['Issue'])
IssueService.create_issue_activity(issue, field, "", "",
"解决了问题", user_id, 2, 1)
if str(operation_type) == "2": # 关闭问题
field = "Status"
old_value = str(issue.__dict__[field])
value = 3
issue.Status = 3
issue.Processor = issue.Creator
issue.ClosedTime = DateTimeHelper.getcnow()
issue.UpdateTime = DateTimeHelper.getcnow()
issue.save()
IssueService.create_issue_activity(issue, field, "", "",
"关闭了问题", user_id, 2, 1)
if str(operation_type) == "3": # 重新打开问题
field = "Status"
old_value = str(issue.__dict__[field])
value = 5
if issue.Solver:
issue.Processor = issue.Solver
else:
issue.Processor = user_id
issue.Solution = 1
issue.ReopenCounts = issue.ReopenCounts + 1
issue.UpdateTime = DateTimeHelper.getcnow()
issue.Status = 5
issue.save()
IssueService.send_notification_email(issue, "重新打开了问题",
EMAIL_TEMPLATES['Issue'])
IssueService.create_issue_activity(issue, field, "", "",
"重新打开了问题", user_id, 2, 1)
if comments != "":
IssueService.create_issue_activity(issue, 0, '', '',
"备注" + comments, user_id, 1,
1)
result = True
except Exception as ex:
SimpleLogger.error(ex)
return result
def get_ReleaseDate(self, obj):
result = ""
if obj.TestingDeadLineDate:
result = str(
DateTimeHelper.add_day(str(obj.TestingDeadLineDate)[:10],
1))[0:10]
return result
def fortesting_commit(login_user, fortesting, status):
message = "已经将项目提测信息，通知到项目成员。！"
build_summary = "已经提测了！"
result = [False, '']
try:
print(fortesting.EmailNotificationStatus)
notification_status = (eval(
fortesting.EmailNotificationStatus)[int(status) - 1] == 0)
print(notification_status)
if notification_status:
result[0] = True
result[1] = message
fortesting.CommitTime = DateTimeHelper.getcnow()
fortesting.Commitor = login_user.id
email_notification_status = ForTestingService.get_email_notification_status(
fortesting.EmailNotificationStatus, status)
fortesting.EmailNotificationStatus = email_notification_status
fortesting.save()
email_template = EMAIL_TEMPLATES['ForTesting']
ForTestingService.send_notification_email(
fortesting.id, build_summary, email_template)
ForTestingService.log_commit_activity(login_user, fortesting)
except Exception as ex:
message = str(ex)
SimpleLogger.exception(ex)
return result
def start_ci_task(request, task_id, parameter_group_id, project_version):
ci_task = CITask.objects.get(int(task_id))
queuetask = TaskQueue()
queuetask.EnqueueTime = DateTimeHelper.get_local_now()
queuetask.TaskType = ci_task.TaskType
queuetask.Command = TaskQueueCommandTypeEnum.TaskQueueCommandType_Start
queuetask.Priority = 2
queuetask.Status = TaskQueueStatusEnum.QueueTaskStatus_New
queuetask.TaskID = int(task_id)
queuetask.TaskUUID = uuid.uuid1()
if parameter_group_id:
queuetask.BuildParameterID = parameter_group_id
else:
queuetask.BuildParameterID = CITaskParameterService.default_parameter_group(
int(task_id))
queuetask.save()
ci_task.BuildVersion = ci_task.BuildVersion + 1
if str(project_version) == '0':
project_version = VersionService.get_latest_version(
ci_task.Project)
if project_version:
project_version = project_version.id
else:
project_version = 0
ci_task.LastHistory = CITaskService.save_ci_taskhistory(
request, queuetask, ci_task, project_version)
ci_task.save(update_fields=['BuildVersion', 'LastHistory'])
message = "任务ID为:" + str(task_id) + "的执行指令已经下发，请耐心等待。"
user_id = 0
if request.user.id:
user_id = request.user.id
CITaskService.log_build_activity(user_id, ci_task)
CITaskService.send_task_enqueue_message()
return [queuetask.id, message, queuetask.TaskUUID]
def testing_start_date(self):
result = "--"
if self.fortesting.TestingStartDate:
result = self.fortesting.TestingStartDate
else:
result = DateTimeHelper.get_now_date()
return result
def create_intesting_message(fortesting, summary_info,
email_template_path):
email_templates = open(email_template_path, 'rb').read().decode()
project = Project.objects.get(fortesting.ProjectID)
submitior = UserService.get_user(fortesting.Commitor)
version = ForTestingService.get_fortesting_version(fortesting)
vm_fortesting = VM_ProjectForTesting(fortesting)
tester_name = "--"
if len(vm_fortesting.fortesting_testers()) > 0:
tester_name = vm_fortesting.fortesting_testers()[0].member_name()
title = "项目：【" + project.PBTitle + version + "】" + summary_info
email_templates = email_templates.replace("${SUBMITIONINFO}", title)
email_templates = email_templates.replace(
"${SUBMITTIME}", str(DateTimeHelper.getcnow()))
email_templates = email_templates.replace("${TPID}",
str(fortesting.id))
email_templates = email_templates.replace("${PROJECTNAME}",
project.PBTitle)
email_templates = email_templates.replace(
"${STARTTIME}", str(vm_fortesting.testing_start_date()))
email_templates = email_templates.replace(
"${ENDTIME}", str(vm_fortesting.testing_deadline()))
email_templates = email_templates.replace(
"${SUBMITIOR}", str(submitior.last_name + submitior.first_name))
email_templates = email_templates.replace("${TESTER}", tester_name)
email_templates = email_templates.replace("${VERSION}", version)
return email_templates
def create_commit_message(fortesting, summary_info, email_template_path):
email_templates = open(email_template_path, 'rb').read().decode()
project = Project.objects.get(fortesting.ProjectID)
projectname = project.PBTitle
module = ProjectModule.objects.get(fortesting.ProjectModuleID)
module_name = "--"
code_addr = ProjectCodeUrl.objects.get(fortesting.ProjectCode)
if module:
module_name = module.Name
platform = SystemConfigService.get_platform_name(project.PBPlatform)
submitior = UserService.get_user(fortesting.Commitor)
title = "项目：【" + platform + projectname + ForTestingService.get_fortesting_version(
fortesting) + "】" + summary_info
email_templates = email_templates.replace("${SUBMITIONINFO}", title)
email_templates = email_templates.replace("${SUBMITTIME}", str(DateTimeHelper.getcnow()))
email_templates = email_templates.replace("${SUBMITID}", str(fortesting.id))
email_templates = email_templates.replace("${PROJECTNAME}", projectname)
email_templates = email_templates.replace("${PROJECTMODULENAME}", module_name)
email_templates = email_templates.replace("${SUBMITIOR}", str(submitior.last_name + submitior.first_name))
email_templates = email_templates.replace("${PLATFORM}", str(platform))
email_templates = email_templates.replace("${VERSION}", ForTestingService.get_fortesting_version(fortesting))
if code_addr:
email_templates = email_templates.replace("${CODEURI}", code_addr.CodeRepertory)
email_templates = email_templates.replace("${BRANCH}", code_addr.Branch)
else:
email_templates = email_templates.replace("${CODEURI}", "")
email_templates = email_templates.replace("${BRANCH}", "")
email_templates = email_templates.replace("${FUNCTIONCHANGE}", str(fortesting.TestingFeature))
email_templates = email_templates.replace("${SUGGESTION}", str(fortesting.TestingAdvice))
return email_templates
def update_date(self):
result = "--"
if self.issue.ResolvedTime:
result = DateTimeHelper.how_long_ago(
(datetime.datetime.now().replace(
tzinfo=pytz.timezone('Asia/Shanghai')) -
self.issue.ResolvedTime).seconds)
return result
def get_chartdata(queryset, startdate, enddate):
result = dict()
datelist = DateTimeHelper.generate_datelist(startdate, enddate)
for date in datelist:
result[str(date)] = 0
for item in queryset:
result[str(item[0])] = item[1]
return result
def get_update_date(self, issue):
result = "--"
if issue.UpdateTime:
result = DateTimeHelper.how_long_ago(
(datetime.datetime.now().replace(
tzinfo=pytz.timezone(TIME_ZONE)) -
issue.UpdateTime).seconds)
return result
def start_taskflow(request, flow_id):
taskflow = CITaskFlow.objects.get(int(flow_id))
queuetask = TaskQueue()
queuetask.EnqueueTime = DateTimeHelper.get_local_now()
queuetask.TaskType = 6
queuetask.Command = TaskQueueCommandTypeEnum.TaskQueueCommandType_Start
queuetask.Priority = 2
queuetask.Status = TaskQueueStatusEnum.QueueTaskStatus_New
queuetask.TaskID = int(flow_id)
queuetask.TaskUUID = uuid.uuid1()
queuetask.FromName = request.user.id
queuetask.save()
# taskflow.LastHistory = CITaskFlowService.save_taskflow_history(request,taskflow,queuetask.TaskUUID)
taskflow.LastRunTime = DateTimeHelper.get_local_now()
taskflow.save(update_fields=['LastRunTime'])
message = "任务流 [" + taskflow.FlowName + "] 的执行指令已经下发，请耐心等待。"
return message
def get_ActionTimeStr(self, obj):
now = datetime.datetime.strptime(
datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
"%Y-%m-%d %H:%M:%S")
action_time = datetime.datetime.strptime(
obj.ActionTime.strftime("%Y-%m-%d %H:%M:%S"), "%Y-%m-%d %H:%M:%S")
action_time = action_time + datetime.timedelta(hours=8)
time_internal = (now - action_time).total_seconds()
return DateTimeHelper.how_long_ago(time_internal)
def return_device(request):
device_id=request.POST.get("device_id",0)
device=Device.objects.get(device_id)
device.DeviceStatus=1
device.DeviceReturnTime=DateTimeHelper.getcnow()
DeviceService.add_device_history(device)
DeviceService.log_return_activity(request.user,device)
device.DeviceBorrower=0
device.save()
def start_flowsection(request, section_id):
flow_section = CITaskFlowSection.objects.get(int(section_id))
message = "任务阶段 [" + flow_section.SectionName + "] 的执行指令已经下发，请耐心等待。"
queuetask = TaskQueue()
queuetask.EnqueueTime = DateTimeHelper.get_local_now()
queuetask.TaskType = 7
queuetask.Command = TaskQueueCommandTypeEnum.TaskQueueCommandType_Start
queuetask.Priority = 2
queuetask.Status = TaskQueueStatusEnum.QueueTaskStatus_New
queuetask.TaskID = int(section_id)
queuetask.TaskUUID = uuid.uuid1()
queuetask.FromName=request.user.id
queuetask.save()
task_flow = CITaskFlow.objects.get(flow_section.TaskFlow)
# flow_history = CITaskFlowSectionService.save_taskflow_history(request, task_flow,queuetask.TaskUUID)
# CITaskFlowSectionService.save_section_history(request, flow_section, flow_history)
# task_flow.LastHistory = flow_history.id
task_flow.LastRunTime = DateTimeHelper.get_local_now()
task_flow.save(update_fields=['LastRunTime'])
return message
def is_ordered(device):
result=False
if device.DeviceStatus==3:
if DateTimeHelper.get_time_to_now(str(device.DeviceBorrorwTime),"%Y-%m-%d %H:%M:%S+00:00")<=1800+28800:
result=True
else:
result=False
device.DeviceBorrorwTime=None
device.DeviceStatus=1
device.DeviceBorrower=0
device.save()
return result
def expect_commit_date(self):
result = "明天"
if self.fortesting.Status == 1:
expect_date = self.fortesting.CreationTime
if self.fortesting.Status == 2:
expect_date = self.fortesting.CommitTime
if self.fortesting.Status == 3:
expect_date = self.fortesting.TestingDeadLineDate
if self.fortesting.Status == 4:
expect_date = self.fortesting.TestingFinishedDate
if self.fortesting.Status == 5:
expect_date = self.fortesting.TestingFinishedDate
if expect_date != None:
expect_date = expect_date + datetime.timedelta(hours=8)
action_time = datetime.datetime.strptime(
expect_date.strftime("%Y-%m-%d %H:%M:%S"), "%Y-%m-%d %H:%M:%S")
data_interval = DateTimeHelper.get_time_to_now(
str(action_time), "%Y-%m-%d %H:%M:%S")
result = DateTimeHelper.how_long_tonow(data_interval)
return result
def createemailmessage(testsubmition, summaryinfo, buildstatus, buildno,
emailtemplatepath):
emailtemplates = open(emailtemplatepath, 'rb').read()
projectname = DAL_TestProject.get_testproject(
testsubmition.TPSProductName).TPName
platform = TestSubmitionService.getdicvaluebyid(
testsubmition.TPSPlatform)
submitior = UserService.getuser(testsubmition.TPSSubmiter)
emailtemplates = emailtemplates.replace(
"${SUBMITIONINFO}", "项目：【" + platform + projectname +
TestSubmitionService.get_project_version(testsubmition) + "】" +
summaryinfo)
emailtemplates = emailtemplates.replace("${SUBMITTIME}",
str(DateTimeHelper.getcnow()))
emailtemplates = emailtemplates.replace("${SUBMITID}",
str(testsubmition.id))
emailtemplates = emailtemplates.replace("${PROJECTNAME}", projectname)
emailtemplates = emailtemplates.replace(
"${SUBMITIOR}", str(submitior.last_name + submitior.first_name))
emailtemplates = emailtemplates.replace("${PLATFORM}", str(platform))
emailtemplates = emailtemplates.replace(
"${VERSION}",
TestSubmitionService.get_project_version(testsubmition))
emailtemplates = emailtemplates.replace(
"${SVNVERSION}", str(testsubmition.TPSCodeVersion))
emailtemplates = emailtemplates.replace("${SVNADDRESS}",
str(testsubmition.TPSCodeUrl))
emailtemplates = emailtemplates.replace(
"${FUNCTIONCHANGE}", str(testsubmition.TPSFunctionChange))
emailtemplates = emailtemplates.replace("${BUGFIX}",
str(testsubmition.TPSBugFix))
emailtemplates = emailtemplates.replace(
"${SUGGESTION}", str(testsubmition.TPSAdvice4Testing))
emailtemplates = emailtemplates.replace(
"${PACKAGEFORTESTING}", str(testsubmition.TPSPackageAddress))
emailtemplates = emailtemplates.replace(
"${BUILDURL}",
str(
TestSubmitionService.getbuildurl(
testsubmition.TPSJenkinsJobName, buildno)))
emailtemplates = emailtemplates.replace(
"${BUILDLOGURL}",
str(
TestSubmitionService.getbuildlog(
testsubmition.TPSJenkinsJobName, buildno)))
emailtemplates = emailtemplates.replace(
"${BUILDSTATUS}",
str(TestSubmitionService.getbuildstatus(buildstatus)))
emailtemplates = emailtemplates.replace(
"${CODECHANGELOG}",
TestSubmitionService.get_changelog(testsubmition.TPSCodeChangeLog))
return emailtemplates
def task_delayed_today(project_id, version_id, request):
if str(project_id) == "0":
project_all_tasks = TaskService.all_my_tasks(
request, request.user.id)
else:
project_all_tasks = TaskService.project_all_tasks(0, project_id)
project_all_tasks = project_all_tasks.exclude(Status=2).filter(
Parent__isnull=True)
if str(version_id) != "0":
project_all_tasks = project_all_tasks.filter(
Version=int(version_id))
return project_all_tasks.filter(
DeadLine__lt=DateTimeHelper.get_now_date()).count()
def task_finished_today(project_id, version_id, request):
if str(project_id) == "0":
project_all_tasks = TaskService.all_my_tasks(
request, request.user.id)
else:
project_all_tasks = TaskService.project_all_tasks(0, project_id)
if str(version_id) != "0":
project_all_tasks = project_all_tasks.filter(
Version=int(version_id))
project_all_tasks = project_all_tasks.filter(Parent__isnull=True)
return project_all_tasks.filter(
FinishedDate=DateTimeHelper.get_now_date()).count()
def borrow_device(request):
message=""
device_id=request.POST.get("device_id",0)
device=Device.objects.get(device_id)
if DeviceService.is_ready(device):
device.DeviceStatus=3
device.DeviceBorrorwTime=DateTimeHelper.getcnow()
device.DeviceBorrower=request.user.id
device.save()
DeviceService.log_borrow_activity(request.user,device)
else:
message="此设备已经被借走，请联系管理员或者设备使用人。"
return message
def get_build_process(self,ci_task_queue):
result=20
if ci_task_queue:
if ci_task_queue.StartTime:
start_time=ci_task_queue.StartTime+datetime.timedelta(hours=8)
duration=DateTimeHelper.get_time_to_now(str(start_time)[:19],"%Y-%m-%d %H:%M:%S")
result=int(duration)/10
if result>90:
result=90
elif result<0:
result=5
else:
result=5
return result
def init_device(request,device):
new_device=device
new_device.DeviceName=request.POST.get("DeviceName")
new_device.DeviceNumber=request.POST.get("DeviceNumber")
new_device.DeviceOS=request.POST.get("DeviceOS")
new_device.DeviceOSVersion=request.POST.get("DeviceOSVersion")
new_device.DeviceScreenSize=request.POST.get("DeviceScreenSize")
new_device.DeviceType=request.POST.get("DeviceType")
new_device.DeviceBorrower=request.POST.get("DeviceBorrower")
if new_device.DeviceBorrower!=0:
new_device.DeviceStatus=2
device.DeviceBorrorwTime=DateTimeHelper.getcnow()
DeviceService.log_lend_activity(request.user,device)
return new_device
def get_perday_closedbugcounts_data(submitionid):
bugcounts = list()
result = list()
query_info = BugReportService.get_query_info(submitionid)
openedresult = DAL_BugReport.get_closed_bugcounts_perday(
str(query_info[0]), str(query_info[1]), query_info[2])
result_dict = BugReportService.get_chartdata(openedresult,
str(query_info[0]),
str(query_info[1]))
datelist = DateTimeHelper.generate_datelist(str(query_info[0]),
str(query_info[1]))
for date in datelist:
bugcounts.append(result_dict[str(date)])
result.append(datelist)
result.append(bugcounts)
return result
def stop_ci_task(request,task_id):
command_type=TaskQueueCommandTypeEnum.TaskQueueCommandType_Stop
tq_uuid=request.GET.get("TaskUUID","")
tq_tasks = TaskQueue.objects.all().filter(TaskUUID=tq_uuid).filter(Command=command_type)
if not tq_tasks.exists():
ci_task=CITask.objects.get(int(task_id))
queuetask=TaskQueue()
queuetask.EnqueueTime=DateTimeHelper.get_local_now()
queuetask.TaskType=ci_task.TaskType
queuetask.Command=command_type
queuetask.Priority=7
queuetask.Status =TaskQueueStatusEnum.QueueTaskStatus_New
queuetask.TaskID=int(task_id)
queuetask.TaskUUID=tq_uuid
queuetask.save()
else:
queuetask = tq_tasks[0]
message="任务ID为:"+str(task_id)+"的取消执行指令已经下发，请耐心等待。"
CITaskService.send_task_enqueue_message()
return [queuetask.id,message,queuetask.TaskUUID]
def update_issue(issue_id, field, value, new_text, user_id):
result = False
try:
issue = ProjectIssue.objects.get(int(issue_id))
old_value = str(issue.__dict__[field])
if old_value != str(value):
if field == "OSVersion":
temp = value.split(",")
issue.__dict__[field] = int(temp[0])
issue.__dict__['DeviceOS'] = int(temp[1])
else:
issue.__dict__[field] = value
issue.UpdateTime = DateTimeHelper.getcnow()
issue.save()
if field == 'Processor':
IssueService.send_notification_email(issue,"更新了问题",EMAIL_TEMPLATES['Issue'])
result = True
IssueService.create_issue_activity(issue, field, value, old_value, new_text, user_id, 2, 1)
except Exception as ex:
SimpleLogger.exception(ex)
return result
def fortesting_finished(login_user, fortesting, status):
message = "测试完成通知，已经发送给所有项目成员！"
build_summary = "已经完成测试！"
result = []
try:
notification_status = eval(fortesting.EmailNotificationStatus)[int(status) - 1] == 0
if notification_status:
email_notification_status = ForTestingService.get_email_notification_status(
fortesting.EmailNotificationStatus, status)
fortesting.EmailNotificationStatus = email_notification_status
fortesting.TestingFinishedDate = DateTimeHelper.getcnow()
fortesting.save()
# email_template=EMAIL_TEMPLATES['TestingFinished']
# ForTestingService.send_notification_email(fortesting.id,build_summary,email_template)
ForTestingService.log_finish_testing_activity(login_user, fortesting)
result.append(notification_status)
result.append(message)
except Exception as ex:
message = str(ex)
SimpleLogger.exception(ex)
return result
def get_all_openedbugcounts_data(submitionid):
bugcounts = list()
result = list()
query_info = BugReportService.get_query_info(submitionid)
openedresult = DAL_BugReport.get_opened_bugcounts_perday(
str(query_info[0]), str(query_info[1]), query_info[2])
result_dict = BugReportService.get_chartdata(openedresult,
str(query_info[0]),
str(query_info[1]))
datelist = DateTimeHelper.generate_datelist(str(query_info[0]),
str(query_info[1]))
i = 0
for date in datelist:
if len(bugcounts):
all_opendbugcounts = bugcounts[i] + int(result_dict[str(date)])
i = i + 1
else:
all_opendbugcounts = int(result_dict[str(date)])
i = 0
bugcounts.append(all_opendbugcounts)
all_opendbugcounts = 0
result.append(datelist)
result.append(bugcounts)
return result
