You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
764 lines
22 KiB
764 lines
22 KiB
package service |
|
|
|
import ( |
|
"context" |
|
"fmt" |
|
"strconv" |
|
"strings" |
|
"sync" |
|
"time" |
|
|
|
"go-common/app/admin/ep/marthe/model" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
) |
|
|
|
// UpdateTapdBugTpl Update Tapd Bug Tpl. |
|
func (s *Service) UpdateTapdBugTpl(c context.Context, username string, req *model.UpdateTapdBugTplRequest) (rep map[string]interface{}, err error) { |
|
//check if access to workspace |
|
if !s.AccessToWorkspace(req.WorkspaceID, username) { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
|
|
//check sql |
|
if _, err = s.CheckTapdBugTplSQL(c, req.IssueFilterSQL); err != nil { |
|
return |
|
} |
|
|
|
tapdBugTemplate := &model.TapdBugTemplate{ |
|
ID: req.ID, |
|
WorkspaceID: req.WorkspaceID, |
|
BuglyProjectId: req.BuglyProjectId, |
|
IssueFilterSQL: req.IssueFilterSQL, |
|
SeverityKey: req.SeverityKey, |
|
UpdateBy: username, |
|
|
|
TapdProperty: req.TapdProperty, |
|
} |
|
|
|
if req.ID > 0 { |
|
err = s.dao.UpdateTapdBugTemplate(tapdBugTemplate) |
|
} else { |
|
// add new |
|
err = s.dao.InsertTapdBugTemplate(tapdBugTemplate) |
|
} |
|
|
|
rep = make(map[string]interface{}) |
|
rep["template_id"] = tapdBugTemplate.ID |
|
return |
|
} |
|
|
|
// QueryTapdBugTpl Query Tapd Bug Tpl |
|
func (s *Service) QueryTapdBugTpl(c context.Context, req *model.QueryTapdBugTemplateRequest) (rep *model.PaginateTapdBugTemplates, err error) { |
|
var ( |
|
total int64 |
|
tapdBugTemplates []*model.TapdBugTemplate |
|
tapdBugTemplateWithProjectNames []*model.TapdBugTemplateWithProjectName |
|
) |
|
if total, tapdBugTemplates, err = s.dao.FindTapdBugTemplates(req); err != nil { |
|
return |
|
} |
|
|
|
for _, tapdBugTemplate := range tapdBugTemplates { |
|
var buglyProject *model.BuglyProject |
|
if buglyProject, err = s.dao.QueryBuglyProject(tapdBugTemplate.BuglyProjectId); err != nil { |
|
return |
|
} |
|
|
|
if req.ProjectName == "" || strings.Contains(buglyProject.ProjectName, req.ProjectName) { |
|
tapdBugTemplateWithProjectName := &model.TapdBugTemplateWithProjectName{ |
|
TapdBugTemplate: tapdBugTemplate, |
|
ProjectName: buglyProject.ProjectName, |
|
} |
|
tapdBugTemplateWithProjectNames = append(tapdBugTemplateWithProjectNames, tapdBugTemplateWithProjectName) |
|
} |
|
} |
|
|
|
rep = &model.PaginateTapdBugTemplates{ |
|
PaginationRep: model.PaginationRep{ |
|
Total: total, |
|
PageSize: req.PageSize, |
|
PageNum: req.PageNum, |
|
}, |
|
TapdBugTemplateWithProjectNames: tapdBugTemplateWithProjectNames, |
|
} |
|
return |
|
|
|
} |
|
|
|
// QueryAllTapdBugTpl Query All Tapd Bug Tpl |
|
func (s *Service) QueryAllTapdBugTpl(c context.Context) (rep []*model.TapdBugTemplateShortResponse, err error) { |
|
var tapdBugTemplates []*model.TapdBugTemplate |
|
|
|
if tapdBugTemplates, err = s.dao.QueryAllTapdBugTemplates(); err != nil { |
|
return |
|
} |
|
|
|
for _, tapdBugTemplate := range tapdBugTemplates { |
|
var buglyProject *model.BuglyProject |
|
if buglyProject, err = s.dao.QueryBuglyProject(tapdBugTemplate.BuglyProjectId); err != nil { |
|
return |
|
} |
|
|
|
ret := &model.TapdBugTemplateShortResponse{ |
|
ID: tapdBugTemplate.ID, |
|
WorkspaceID: tapdBugTemplate.WorkspaceID, |
|
BuglyProjectId: tapdBugTemplate.BuglyProjectId, |
|
BuglyProjectName: buglyProject.ProjectName, |
|
} |
|
rep = append(rep, ret) |
|
} |
|
|
|
return |
|
} |
|
|
|
// UpdateTapdBugVersionTpl Update Tapd Bug Version Tpl. |
|
func (s *Service) UpdateTapdBugVersionTpl(c context.Context, username string, req *model.UpdateTapdBugVersionTplRequest) (rep map[string]interface{}, err error) { |
|
|
|
// check sql |
|
if req.IssueFilterSQL != "" { |
|
if _, err = s.CheckTapdBugTplSQL(c, req.IssueFilterSQL); err != nil { |
|
return |
|
} |
|
} |
|
|
|
//check project id |
|
var tmp *model.TapdBugTemplate |
|
|
|
if tmp, err = s.dao.QueryTapdBugTemplate(req.ProjectTemplateID); err != nil { |
|
return |
|
} |
|
|
|
if tmp.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
//check if access to workspace |
|
if !s.AccessToWorkspace(tmp.WorkspaceID, username) { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
|
|
tapdBugVersionTemplate := &model.TapdBugVersionTemplate{ |
|
ID: req.ID, |
|
Version: req.Version, |
|
ProjectTemplateID: req.ProjectTemplateID, |
|
|
|
IssueFilterSQL: req.IssueFilterSQL, |
|
SeverityKey: req.SeverityKey, |
|
UpdateBy: username, |
|
|
|
TapdProperty: req.TapdProperty, |
|
} |
|
|
|
if req.ID > 0 { |
|
err = s.dao.UpdateTapdBugVersionTemplate(tapdBugVersionTemplate) |
|
} else { |
|
// add new |
|
err = s.dao.InsertTapdBugVersionTemplate(tapdBugVersionTemplate) |
|
} |
|
|
|
rep = make(map[string]interface{}) |
|
rep["version_template_id"] = tapdBugVersionTemplate.ID |
|
return |
|
} |
|
|
|
// QueryTapdBugVersionTpl Query Tapd Bug Version Tpl |
|
func (s *Service) QueryTapdBugVersionTpl(c context.Context, req *model.QueryTapdBugVersionTemplateRequest) (rep *model.PaginateTapdBugVersionTemplates, err error) { |
|
var ( |
|
total int64 |
|
tapdBugVersionTemplates []*model.TapdBugVersionTemplate |
|
) |
|
if total, tapdBugVersionTemplates, err = s.dao.FindTapdBugVersionTemplates(req); err != nil { |
|
return |
|
} |
|
rep = &model.PaginateTapdBugVersionTemplates{ |
|
PaginationRep: model.PaginationRep{ |
|
Total: total, |
|
PageSize: req.PageSize, |
|
PageNum: req.PageNum, |
|
}, |
|
TapdBugVersionTemplates: tapdBugVersionTemplates, |
|
} |
|
return |
|
|
|
} |
|
|
|
// CheckTapdBugTplSQL Check Tapd Bug Tpl SQL. |
|
func (s *Service) CheckTapdBugTplSQL(c context.Context, sql string) (rep map[string]interface{}, err error) { |
|
var buglyIssues []*model.BuglyIssue |
|
if buglyIssues, err = s.getBuglyIssuesByFilterSQLWithNoTapdBug(sql); err != nil { |
|
err = ecode.MartheFilterSqlError |
|
return |
|
} |
|
rep = make(map[string]interface{}) |
|
rep["count"] = len(buglyIssues) |
|
return |
|
} |
|
|
|
// BugInsertTapdWithProject Bug Insert Tapd With Project. |
|
func (s *Service) BugInsertTapdWithProject(c context.Context, id int64, username string) (rep map[string]interface{}, err error) { |
|
var count int |
|
count, err = s.bugInsertTapd(id, 0, username) |
|
rep = make(map[string]interface{}) |
|
rep["tapd_bug_count"] = count |
|
return |
|
|
|
} |
|
|
|
// BugInsertTapdWithVersion Bug Insert Tapd With Version. |
|
func (s *Service) BugInsertTapdWithVersion(c context.Context, id int64, username string) (rep map[string]interface{}, err error) { |
|
var count int |
|
count, err = s.bugInsertTapd(0, id, username) |
|
rep = make(map[string]interface{}) |
|
rep["tapd_bug_count"] = count |
|
return |
|
} |
|
|
|
func (s *Service) bugInsertTapd(projectTemplateId, versionTemplateId int64, username string) (count int, err error) { |
|
|
|
var ( |
|
tapdBugTemplate *model.TapdBugTemplate |
|
tapdBugVersionTemplate *model.TapdBugVersionTemplate |
|
buglyIssues []*model.BuglyIssue |
|
tapdBugRecords []*model.TapdBugRecord |
|
) |
|
|
|
if (projectTemplateId == 0 && versionTemplateId == 0) || (projectTemplateId > 0 && versionTemplateId > 0) { |
|
return |
|
} |
|
|
|
if projectTemplateId > 0 { |
|
if tapdBugTemplate, err = s.dao.QueryTapdBugTemplate(projectTemplateId); err != nil { |
|
return |
|
} |
|
|
|
if tapdBugTemplate.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
} else if versionTemplateId > 0 { |
|
if tapdBugVersionTemplate, err = s.dao.QueryTapdBugVersionTemplate(versionTemplateId); err != nil { |
|
return |
|
} |
|
|
|
if tapdBugVersionTemplate.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
projectTemplateId = tapdBugVersionTemplate.ProjectTemplateID |
|
|
|
if tapdBugTemplate, err = s.dao.QueryTapdBugTemplate(projectTemplateId); err != nil { |
|
return |
|
} |
|
|
|
if tapdBugTemplate.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
if err = s.UpdateTplAsVersionTpl(tapdBugVersionTemplate, tapdBugTemplate); err != nil { |
|
return |
|
} |
|
} |
|
|
|
// get map lock, every project tpl 串行 |
|
insertLock := s.getTapdBugInsertLock(projectTemplateId) |
|
insertLock.Lock() |
|
defer insertLock.Unlock() |
|
|
|
//check if access to workspace |
|
if !s.AccessToWorkspace(tapdBugTemplate.WorkspaceID, username) { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
|
|
if tapdBugRecords, err = s.dao.QueryTapdBugRecordByProjectIDAndStatus(projectTemplateId, model.InsertBugStatusRunning); err != nil { |
|
return |
|
} |
|
|
|
if len(tapdBugRecords) > 0 { |
|
err = ecode.MartheTaskInRunning |
|
return |
|
} |
|
|
|
if buglyIssues, err = s.getBuglyIssuesByFilterSQLWithNoTapdBug(tapdBugTemplate.IssueFilterSQL); err != nil { |
|
return |
|
} |
|
|
|
count = len(buglyIssues) |
|
|
|
if count > 0 { |
|
tapdBugInsertLog := &model.TapdBugRecord{ |
|
ProjectTemplateID: projectTemplateId, |
|
VersionTemplateID: versionTemplateId, |
|
Operator: username, |
|
Count: count, |
|
IssueFilterSQL: tapdBugTemplate.IssueFilterSQL, |
|
Status: model.InsertBugStatusRunning, |
|
} |
|
|
|
if err = s.dao.InsertTapdBugRecord(tapdBugInsertLog); err != nil { |
|
return |
|
} |
|
|
|
s.tapdBugCache.Do(context.TODO(), func(ctx context.Context) { |
|
|
|
defer func() { |
|
if err != nil { |
|
tapdBugInsertLog.Status = model.InsertBugStatusFailed |
|
} else { |
|
tapdBugInsertLog.Status = model.InsertBugStatusDone |
|
} |
|
err = s.dao.UpdateTapdBugRecord(tapdBugInsertLog) |
|
}() |
|
|
|
for _, buglyIssue := range buglyIssues { |
|
var ( |
|
bug *model.Bug |
|
bugID string |
|
) |
|
|
|
if bug, err = s.getBugModel(buglyIssue, tapdBugTemplate); err != nil { |
|
log.Error("getLiveIOSBugModel error (%v)", err) |
|
continue |
|
} |
|
|
|
if bugID, err = s.dao.CreateBug(bug); err != nil && bugID == "" { |
|
log.Error("CreateBug error (%v)", err) |
|
continue |
|
} |
|
log.Info("insert issue no: [%s], bug number [%s]", buglyIssue.IssueNo, bugID) |
|
|
|
if err = s.dao.UpdateBuglyIssueTapdBugID(buglyIssue.ID, bugID); err != nil { |
|
log.Error("UpdateIssueRecordTapdBugID error (%v)", err) |
|
continue |
|
} |
|
|
|
buglyIssue.TapdBugID = bugID |
|
|
|
if err = s.updateBugInTapd(tapdBugTemplate, buglyIssue, time.Now()); err != nil { |
|
continue |
|
} |
|
|
|
log.Info("update issue no [%s], bug number [%s]", buglyIssue.IssueNo, buglyIssue.TapdBugID) |
|
} |
|
}) |
|
} |
|
|
|
return |
|
} |
|
|
|
func (s *Service) getBugModel(bugIssue *model.BuglyIssue, bugTemplate *model.TapdBugTemplate) (bug *model.Bug, err error) { |
|
title := fmt.Sprintf(bugTemplate.Title, bugIssue.IssueNo, bugIssue.Version, bugIssue.Title, strconv.Itoa(bugIssue.HappenTimes), strconv.Itoa(bugIssue.UserTimes)) |
|
description := fmt.Sprintf(bugTemplate.Description, title, bugIssue.KeyStack, |
|
bugIssue.IssueLink, bugIssue.IssueLink, bugIssue.IssueLink, |
|
bugIssue.Detail) |
|
|
|
bug = &model.Bug{ |
|
Title: title, |
|
Description: description, |
|
Priority: bugTemplate.Priority, |
|
Severity: bugTemplate.Severity, |
|
Module: bugTemplate.Module, |
|
Status: bugTemplate.Status, |
|
Reporter: bugTemplate.Reporter, |
|
BugType: bugTemplate.BugType, |
|
CurrentOwner: bugTemplate.CurrentOwner, |
|
Source: bugTemplate.Source, |
|
OriginPhase: bugTemplate.OriginPhase, |
|
Platform: bugTemplate.Platform, |
|
ReleaseID: bugTemplate.ReleaseID, |
|
CustomFieldThree: bugTemplate.CustomFieldThree, |
|
CustomFieldFour: bugTemplate.CustomFieldFour, |
|
WorkspaceID: bugTemplate.WorkspaceID, |
|
IterationID: bugTemplate.IterationID, |
|
} |
|
return |
|
} |
|
|
|
// UpdateTplAsVersionTpl Update Tpl As Version Tpl. |
|
func (s *Service) UpdateTplAsVersionTpl(tapdBugVersionTemplate *model.TapdBugVersionTemplate, tapdBugTemplate *model.TapdBugTemplate) (err error) { |
|
|
|
if tapdBugVersionTemplate.ProjectTemplateID != tapdBugTemplate.ID { |
|
log.Error("projectID should be [%s],actual [%s]", tapdBugVersionTemplate.ProjectTemplateID, tapdBugTemplate.ID) |
|
return |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Title) != "" { |
|
tapdBugTemplate.Title = tapdBugVersionTemplate.Title |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Description) != "" { |
|
tapdBugTemplate.Description = tapdBugVersionTemplate.Description |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.CurrentOwner) != "" { |
|
tapdBugTemplate.CurrentOwner = tapdBugVersionTemplate.CurrentOwner |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Platform) != "" { |
|
tapdBugTemplate.Platform = tapdBugVersionTemplate.Platform |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Module) != "" { |
|
tapdBugTemplate.Module = tapdBugVersionTemplate.Module |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.IterationID) != "" { |
|
tapdBugTemplate.IterationID = tapdBugVersionTemplate.IterationID |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.ReleaseID) != "" { |
|
tapdBugTemplate.ReleaseID = tapdBugVersionTemplate.ReleaseID |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Priority) != "" { |
|
tapdBugTemplate.Priority = tapdBugVersionTemplate.Priority |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Severity) != "" { |
|
tapdBugTemplate.Severity = tapdBugVersionTemplate.Severity |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Source) != "" { |
|
tapdBugTemplate.Source = tapdBugVersionTemplate.Source |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.CustomFieldFour) != "" { |
|
tapdBugTemplate.CustomFieldFour = tapdBugVersionTemplate.CustomFieldFour |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.BugType) != "" { |
|
tapdBugTemplate.BugType = tapdBugVersionTemplate.BugType |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.OriginPhase) != "" { |
|
tapdBugTemplate.OriginPhase = tapdBugVersionTemplate.OriginPhase |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.CustomFieldThree) != "" { |
|
tapdBugTemplate.CustomFieldThree = tapdBugVersionTemplate.CustomFieldThree |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Reporter) != "" { |
|
tapdBugTemplate.Reporter = tapdBugVersionTemplate.Reporter |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.Status) != "" { |
|
tapdBugTemplate.Status = tapdBugVersionTemplate.Status |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.IssueFilterSQL) != "" { |
|
tapdBugTemplate.IssueFilterSQL = tapdBugVersionTemplate.IssueFilterSQL |
|
} |
|
|
|
if strings.TrimSpace(tapdBugVersionTemplate.SeverityKey) != "" { |
|
tapdBugTemplate.SeverityKey = tapdBugVersionTemplate.SeverityKey |
|
} |
|
|
|
return |
|
} |
|
|
|
// BatchRunUpdateBugInTapd Batch Run Update Bug In Tapd. |
|
func (s *Service) BatchRunUpdateBugInTapd() (err error) { |
|
var buglyIssues []*model.BuglyIssue |
|
if buglyIssues, err = s.dao.GetBuglyIssuesHasInTapd(); err != nil { |
|
return |
|
} |
|
|
|
for _, buglyIssue := range buglyIssues { |
|
var ( |
|
tapdBugTemplate *model.TapdBugTemplate |
|
tapdBugVersionTemplate *model.TapdBugVersionTemplate |
|
) |
|
if tapdBugTemplate, err = s.dao.QueryTapdBugTemplateByProjectID(buglyIssue.ProjectID); err != nil { |
|
continue |
|
} |
|
|
|
if tapdBugTemplate.ID == 0 { |
|
continue |
|
} |
|
|
|
if tapdBugVersionTemplate, err = s.dao.QueryTapdBugVersionTemplateByVersion(buglyIssue.Version); err != nil { |
|
continue |
|
} |
|
|
|
if tapdBugVersionTemplate.ID > 0 { |
|
if err = s.UpdateTplAsVersionTpl(tapdBugVersionTemplate, tapdBugTemplate); err != nil { |
|
continue |
|
} |
|
} |
|
err = s.updateBugInTapd(tapdBugTemplate, buglyIssue, time.Now()) |
|
} |
|
|
|
return |
|
} |
|
|
|
func (s *Service) updateBugInTapd(tapdBugTemplate *model.TapdBugTemplate, bugIssue *model.BuglyIssue, timeNow time.Time) (err error) { |
|
var bug *model.Bug |
|
|
|
// update title |
|
title := fmt.Sprintf(tapdBugTemplate.Title, bugIssue.IssueNo, bugIssue.Version, bugIssue.Title, strconv.Itoa(bugIssue.HappenTimes), strconv.Itoa(bugIssue.UserTimes)) |
|
|
|
if bug, err = s.dao.BugPre(tapdBugTemplate.WorkspaceID, bugIssue.TapdBugID); err != nil { |
|
log.Error("BugPre projectId %s, error (%v)", bugIssue.ProjectID, err) |
|
return |
|
} |
|
|
|
bug.Title = title |
|
|
|
// update priority |
|
var ( |
|
tapdBugPriorityConfs []*model.TapdBugPriorityConf |
|
) |
|
if tapdBugPriorityConfs, err = s.dao.QueryTapdBugPriorityConfsByProjectTemplateIdAndStatus(tapdBugTemplate.ID, model.TapdBugPriorityConfEnable); err != nil { |
|
return |
|
} |
|
|
|
for _, tmpTapdBugPriorityConf := range tapdBugPriorityConfs { |
|
if timeNow.After(tmpTapdBugPriorityConf.StartTime) && timeNow.Before(tmpTapdBugPriorityConf.EndTime) { |
|
if bugIssue.UserTimes >= tmpTapdBugPriorityConf.Urgent || bugIssue.HappenTimes >= tmpTapdBugPriorityConf.Urgent { |
|
bug.Priority = "urgent" |
|
} else if bugIssue.UserTimes >= tmpTapdBugPriorityConf.High || bugIssue.HappenTimes >= tmpTapdBugPriorityConf.High { |
|
bug.Priority = "high" |
|
} else if bugIssue.UserTimes >= tmpTapdBugPriorityConf.Medium || bugIssue.HappenTimes >= tmpTapdBugPriorityConf.Medium { |
|
bug.Priority = "medium" |
|
} |
|
break |
|
} |
|
} |
|
|
|
// update serious |
|
if strings.TrimSpace(tapdBugTemplate.SeverityKey) != "" { |
|
keys := strings.Split(tapdBugTemplate.SeverityKey, ",") |
|
for _, key := range keys { |
|
if strings.Contains(bug.Description, key) { |
|
bug.Severity = "serious" |
|
break |
|
} |
|
} |
|
} |
|
|
|
updateBug := &model.UpdateBug{ |
|
Bug: bug, |
|
CurrentUser: bug.CurrentOwner, |
|
} |
|
|
|
if err := s.dao.UpdateBug(updateBug); err != nil { |
|
log.Error("UpdateBug bugid %s, error (%v)", bug.ID, err) |
|
} |
|
return |
|
} |
|
|
|
// QueryBugRecords Query Bug Records |
|
func (s *Service) QueryBugRecords(c context.Context, req *model.QueryBugRecordsRequest) (rep *model.PaginateBugRecords, err error) { |
|
var ( |
|
total int64 |
|
tapdBugRecords []*model.TapdBugRecord |
|
) |
|
if total, tapdBugRecords, err = s.dao.FindBugRecords(req); err != nil { |
|
return |
|
} |
|
rep = &model.PaginateBugRecords{ |
|
PaginationRep: model.PaginationRep{ |
|
Total: total, |
|
PageSize: req.PageSize, |
|
PageNum: req.PageNum, |
|
}, |
|
TapdBugRecords: tapdBugRecords, |
|
} |
|
return |
|
|
|
} |
|
|
|
// QueryTapdBugPriorityConfsRequest Query Tapd Bug Priority Confs Request |
|
func (s *Service) QueryTapdBugPriorityConfsRequest(c context.Context, req *model.QueryTapdBugPriorityConfsRequest) (rep *model.PaginateTapdBugPriorityConfs, err error) { |
|
var ( |
|
total int64 |
|
tapdBugPriorityConfs []*model.TapdBugPriorityConf |
|
) |
|
if total, tapdBugPriorityConfs, err = s.dao.FindTapdBugPriorityConfs(req); err != nil { |
|
return |
|
} |
|
rep = &model.PaginateTapdBugPriorityConfs{ |
|
PaginationRep: model.PaginationRep{ |
|
Total: total, |
|
PageSize: req.PageSize, |
|
PageNum: req.PageNum, |
|
}, |
|
TapdBugPriorityConfs: tapdBugPriorityConfs, |
|
} |
|
return |
|
|
|
} |
|
|
|
// UpdateTapdBugPriorityConf Update Tapd Bug Priority Conf. |
|
func (s *Service) UpdateTapdBugPriorityConf(c context.Context, username string, req *model.UpdateTapdBugPriorityConfRequest) (rep map[string]interface{}, err error) { |
|
var ( |
|
startTime time.Time |
|
endTime time.Time |
|
tapdBugPriorityConfsInDB []*model.TapdBugPriorityConf |
|
tapdBugTemplate *model.TapdBugTemplate |
|
) |
|
|
|
//check project id |
|
if tapdBugTemplate, err = s.dao.QueryTapdBugTemplate(req.ProjectTemplateID); err != nil { |
|
return |
|
} |
|
|
|
if tapdBugTemplate.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
|
|
//check if access to workspace |
|
if !s.AccessToWorkspace(tapdBugTemplate.WorkspaceID, username) { |
|
err = ecode.AccessDenied |
|
return |
|
} |
|
|
|
if startTime, err = time.ParseInLocation(model.TimeLayout, req.StartTime, time.Local); err != nil { |
|
return |
|
} |
|
|
|
if endTime, err = time.ParseInLocation(model.TimeLayout, req.EndTime, time.Local); err != nil { |
|
return |
|
} |
|
|
|
// when status == enable, check time if conflict |
|
if req.Status == model.TapdBugPriorityConfEnable { |
|
if tapdBugPriorityConfsInDB, err = s.dao.QueryTapdBugPriorityConfsByProjectTemplateIdAndStatus(req.ProjectTemplateID, model.TapdBugPriorityConfEnable); err != nil { |
|
return |
|
} |
|
|
|
for _, tapdBugPriorityConfInDB := range tapdBugPriorityConfsInDB { |
|
isStartTimeInDuration := tapdBugPriorityConfInDB.StartTime.After(startTime) && tapdBugPriorityConfInDB.StartTime.Before(endTime) |
|
isEndTimeInDuration := tapdBugPriorityConfInDB.EndTime.After(startTime) && tapdBugPriorityConfInDB.EndTime.Before(endTime) |
|
if isStartTimeInDuration || isEndTimeInDuration { |
|
err = ecode.MartheTimeConflictError |
|
return |
|
} |
|
} |
|
|
|
} |
|
|
|
tapdBugPriorityConf := &model.TapdBugPriorityConf{ |
|
ID: req.ID, |
|
ProjectTemplateID: req.ProjectTemplateID, |
|
Urgent: req.Urgent, |
|
High: req.High, |
|
Medium: req.Medium, |
|
UpdateBy: username, |
|
Status: req.Status, |
|
StartTime: startTime, |
|
EndTime: endTime, |
|
} |
|
|
|
if req.ID > 0 { |
|
err = s.dao.UpdateTapdBugPriorityConf(tapdBugPriorityConf) |
|
} else { |
|
// add new |
|
err = s.dao.InsertTapdBugPriorityConf(tapdBugPriorityConf) |
|
} |
|
|
|
rep = make(map[string]interface{}) |
|
rep["tapd_bug_priority_conf"] = tapdBugPriorityConf.ID |
|
return |
|
} |
|
|
|
// AccessToWorkspace Access To Workspace. |
|
func (s *Service) AccessToWorkspace(workspaceID, username string) (isAccess bool) { |
|
if !s.c.Tapd.BugOperateAuth { |
|
return true |
|
} |
|
|
|
var ( |
|
usernames []string |
|
contactInfo *model.ContactInfo |
|
err error |
|
) |
|
|
|
if contactInfo, err = s.dao.QueryContactInfoByUsername(username); err != nil { |
|
return |
|
} |
|
|
|
if contactInfo.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
if usernames, err = s.dao.WorkspaceUser(workspaceID); err != nil { |
|
return |
|
} |
|
|
|
for _, u := range usernames { |
|
if u == contactInfo.NickName { |
|
return true |
|
} |
|
} |
|
return |
|
} |
|
|
|
// HttpAccessToWorkspace Access To Workspace. |
|
func (s *Service) HttpAccessToWorkspace(c context.Context, workspaceID, username string) (rep map[string]interface{}, err error) { |
|
var ( |
|
usernames []string |
|
contactInfo *model.ContactInfo |
|
isAccess bool |
|
) |
|
|
|
if contactInfo, err = s.dao.QueryContactInfoByUsername(username); err != nil { |
|
return |
|
} |
|
|
|
if contactInfo.ID == 0 { |
|
err = ecode.NothingFound |
|
return |
|
} |
|
if usernames, err = s.dao.WorkspaceUser(workspaceID); err != nil { |
|
return |
|
} |
|
|
|
for _, u := range usernames { |
|
if u == contactInfo.NickName { |
|
isAccess = true |
|
break |
|
} |
|
} |
|
|
|
rep = make(map[string]interface{}) |
|
rep["is_access"] = isAccess |
|
rep["names"] = usernames |
|
return |
|
} |
|
|
|
func (s *Service) getBuglyIssuesByFilterSQLWithNoTapdBug(issueFilterSQL string) (buglyIssues []*model.BuglyIssue, err error) { |
|
var tmpBuglyIssues []*model.BuglyIssue |
|
|
|
if tmpBuglyIssues, err = s.dao.GetBuglyIssuesByFilterSQL(issueFilterSQL); err != nil { |
|
return |
|
} |
|
|
|
for _, buglyIssue := range tmpBuglyIssues { |
|
if buglyIssue.TapdBugID == "" { |
|
buglyIssues = append(buglyIssues, buglyIssue) |
|
} |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) getTapdBugInsertLock(projectTplId int64) (tapdBugInsertLock *sync.Mutex) { |
|
s.syncTapdBugInsertLock.Lock() |
|
defer s.syncTapdBugInsertLock.Unlock() |
|
|
|
var ok bool |
|
if tapdBugInsertLock, ok = s.mapTapdBugInsertLocks[projectTplId]; !ok { |
|
tapdBugInsertLock = new(sync.Mutex) |
|
s.mapTapdBugInsertLocks[projectTplId] = tapdBugInsertLock |
|
} |
|
return |
|
}
|
|
|