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.
407 lines
10 KiB
407 lines
10 KiB
package dao |
|
|
|
import ( |
|
"context" |
|
"encoding/json" |
|
"fmt" |
|
"net/http" |
|
|
|
"go-common/app/service/ep/footman/model" |
|
"go-common/library/cache/memcache" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
) |
|
|
|
const ( |
|
_userName = "bilibilinik" |
|
_password = "0989D4F0-AF9D-949F-C950-E22A3F891NIK" |
|
_startPN = 1 |
|
_successCode = 1 |
|
) |
|
|
|
//Iteration fetch iterations |
|
func (d *Dao) Iteration(iterationURL string) (res *model.IterationResponse, err error) { |
|
var req *http.Request |
|
res = &model.IterationResponse{} |
|
if req, err = d.newTapdRequest(http.MethodGet, iterationURL, nil); err != nil { |
|
return |
|
} |
|
err = d.httpClient.Do(context.TODO(), req, res) |
|
return |
|
} |
|
|
|
//Story fetch stories |
|
func (d *Dao) Story(storyURL string) (res *model.StoryResponse, err error) { |
|
var req *http.Request |
|
res = &model.StoryResponse{} |
|
if req, err = d.newTapdRequest(http.MethodGet, storyURL, nil); err != nil { |
|
return nil, ecode.MartheTapdErr |
|
} |
|
err = d.httpClient.Do(context.TODO(), req, res) |
|
return |
|
} |
|
|
|
//Bug Bug |
|
func (d *Dao) Bug(bugURL string) (res *model.BugResponse, err error) { |
|
var req *http.Request |
|
res = &model.BugResponse{} |
|
if req, err = d.newTapdRequest(http.MethodGet, bugURL, nil); err != nil { |
|
return nil, ecode.MartheTapdErr |
|
} |
|
err = d.httpClient.Do(context.TODO(), req, res) |
|
return |
|
} |
|
|
|
//BugPre Bug Pre |
|
func (d *Dao) BugPre(workSpaceID, bugID string) (bug *model.Bug, err error) { |
|
var ( |
|
req *http.Request |
|
res = &model.BugSingleResponse{} |
|
) |
|
|
|
url := fmt.Sprintf(model.BugPreURL, workSpaceID, bugID) |
|
if req, err = d.newTapdRequest(http.MethodGet, url, nil); err != nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
if err = d.httpClient.Do(context.TODO(), req, res); err != nil || res.Data == nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
bug = res.Data.Bug |
|
return |
|
} |
|
|
|
//SpecStory fetch specific story |
|
func (d *Dao) SpecStory(storyURL string) (res *model.SpecStoryResponse, err error) { |
|
var req *http.Request |
|
res = &model.SpecStoryResponse{} |
|
if req, err = d.newTapdRequest(http.MethodGet, storyURL, nil); err != nil { |
|
return |
|
} |
|
err = d.httpClient.Do(context.TODO(), req, res) |
|
return |
|
} |
|
|
|
//StoryChange fetch story changes |
|
func (d *Dao) StoryChange(storyChangeURL string) (res *model.StoryChangeResponse, err error) { |
|
var req *http.Request |
|
res = &model.StoryChangeResponse{} |
|
if req, err = d.newTapdRequest(http.MethodGet, storyChangeURL, nil); err != nil { |
|
return |
|
} |
|
err = d.httpClient.Do(context.TODO(), req, res) |
|
return |
|
} |
|
|
|
//NameMap fetch story status name mapping |
|
func (d *Dao) NameMap(nameMapURL string) (res *model.NameMapResponse, err error) { |
|
var req *http.Request |
|
res = &model.NameMapResponse{} |
|
if req, err = d.newTapdRequest(http.MethodGet, nameMapURL, nil); err != nil { |
|
return |
|
} |
|
err = d.httpClient.Do(context.TODO(), req, res) |
|
return |
|
} |
|
|
|
//Category fetch project category |
|
func (d *Dao) Category(categoryURL string) (res *model.CategoryResponse, err error) { |
|
var req *http.Request |
|
res = &model.CategoryResponse{} |
|
if req, err = d.newTapdRequest(http.MethodGet, categoryURL, nil); err != nil { |
|
return |
|
} |
|
err = d.httpClient.Do(context.TODO(), req, res) |
|
return |
|
} |
|
|
|
//AllIterations get all iterations by query url |
|
func (d *Dao) AllIterations(ps int, iterationURL string) (res *model.IterationResponse, err error) { |
|
var ( |
|
tempRes *model.IterationResponse |
|
iterationPage = _startPN |
|
tempPS = ps |
|
currentTime int |
|
) |
|
url := fmt.Sprintf(iterationURL, iterationPage) |
|
for tempPS == ps && currentTime < d.c.Tapd.RetryTime { |
|
if tempRes, err = d.Iteration(url); err != nil || len(tempRes.Data) == 0 { |
|
currentTime = currentTime + 1 |
|
err = nil |
|
continue |
|
} |
|
if res == nil { |
|
res = tempRes |
|
} else if len(tempRes.Data) > 0 { |
|
res.Data = append(res.Data, tempRes.Data...) |
|
} |
|
tempPS = len(tempRes.Data) |
|
iterationPage++ |
|
url = fmt.Sprintf(iterationURL, iterationPage) |
|
} |
|
return |
|
} |
|
|
|
//AllStories get all stories by query url |
|
func (d *Dao) AllStories(ps int, storyURL string) (res *model.StoryResponse, err error) { |
|
var ( |
|
tempRes *model.StoryResponse |
|
storyPage = _startPN |
|
tempPS = ps |
|
currentTime int |
|
) |
|
url := fmt.Sprintf(storyURL, storyPage) |
|
for tempPS == ps && currentTime < d.c.Tapd.RetryTime { |
|
if tempRes, err = d.Story(url); err != nil || len(tempRes.Data) == 0 { |
|
currentTime = currentTime + 1 |
|
err = nil |
|
continue |
|
} |
|
if res == nil { |
|
res = tempRes |
|
} else if len(tempRes.Data) > 0 { |
|
res.Data = append(res.Data, tempRes.Data...) |
|
} |
|
tempPS = len(tempRes.Data) |
|
storyPage++ |
|
url = fmt.Sprintf(storyURL, storyPage) |
|
} |
|
return |
|
} |
|
|
|
//AllStoryChanges get all story changes by query url |
|
func (d *Dao) AllStoryChanges(ps int, storyChangeURL string) (res *model.StoryChangeResponse, err error) { |
|
var ( |
|
tempRes *model.StoryChangeResponse |
|
storyChangePage = _startPN |
|
tempPS = ps |
|
currentTime int |
|
) |
|
url := fmt.Sprintf(storyChangeURL, storyChangePage) |
|
for tempPS == ps && currentTime < d.c.Tapd.RetryTime { |
|
if tempRes, err = d.StoryChange(url); err != nil || len(tempRes.Data) == 0 { |
|
currentTime = currentTime + 1 |
|
err = nil |
|
continue |
|
} |
|
if res == nil { |
|
res = tempRes |
|
} else if len(tempRes.Data) > 0 { |
|
res.Data = append(res.Data, tempRes.Data...) |
|
} |
|
tempPS = len(tempRes.Data) |
|
storyChangePage++ |
|
url = fmt.Sprintf(storyChangeURL, storyChangePage) |
|
} |
|
return |
|
} |
|
|
|
//AllCategories get all categories of project |
|
func (d *Dao) AllCategories(ps int, categoryURL string) (categoryMap map[string]string, err error) { |
|
var ( |
|
tempRes, res *model.CategoryResponse |
|
categoryPage = _startPN |
|
tempPS = ps |
|
currentTime int |
|
) |
|
url := fmt.Sprintf(categoryURL, categoryPage) |
|
for tempPS == ps && currentTime < d.c.Tapd.RetryTime { |
|
if tempRes, err = d.Category(url); err != nil { |
|
currentTime = currentTime + 1 |
|
err = nil |
|
continue |
|
} |
|
if res == nil { |
|
res = tempRes |
|
} else if len(tempRes.Data) > 0 { |
|
res.Data = append(res.Data, tempRes.Data...) |
|
} |
|
tempPS = len(tempRes.Data) |
|
categoryPage++ |
|
url = fmt.Sprintf(categoryURL, categoryPage) |
|
} |
|
|
|
categoryMap = make(map[string]string) |
|
for _, category := range res.Data { |
|
categoryMap[category.Category.ID] = category.Category.Name |
|
} |
|
return |
|
} |
|
|
|
//AllBugs All Bugs |
|
func (d *Dao) AllBugs(ps int, bugURL string) (res *model.BugResponse, err error) { |
|
var ( |
|
tempRes *model.BugResponse |
|
bugPage = _startPN |
|
tempPS = ps |
|
currentTime int |
|
) |
|
url := fmt.Sprintf(bugURL, bugPage) |
|
for tempPS == ps && currentTime < d.c.Tapd.RetryTime { |
|
if tempRes, err = d.Bug(url); err != nil || len(tempRes.Data) == 0 { |
|
currentTime = currentTime + 1 |
|
err = nil |
|
continue |
|
} |
|
if res == nil { |
|
res = tempRes |
|
} else if len(tempRes.Data) > 0 { |
|
res.Data = append(res.Data, tempRes.Data...) |
|
} |
|
tempPS = len(tempRes.Data) |
|
bugPage++ |
|
url = fmt.Sprintf(bugURL, bugPage) |
|
} |
|
return |
|
} |
|
|
|
//CategoryPre Category Pre |
|
func (d *Dao) CategoryPre(workSpaceID, releaseID string) (category *model.Category, err error) { |
|
var ( |
|
req *http.Request |
|
res = &model.CategoryPreResponse{} |
|
) |
|
|
|
releaseURL := fmt.Sprintf(model.CategoryPreURL, workSpaceID, releaseID) |
|
if req, err = d.newTapdRequest(http.MethodGet, releaseURL, nil); err != nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
if err = d.httpClient.Do(context.TODO(), req, res); err != nil || res.Data == nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
category = res.Data.Category |
|
return |
|
} |
|
|
|
// CategoryPreName Category PreName |
|
func (d *Dao) CategoryPreName(workspaceID, categoryID string) (categoryPreName string, err error) { |
|
var ( |
|
item *memcache.Item |
|
conn = d.mc.Get(context.Background()) |
|
category *model.Category |
|
) |
|
defer conn.Close() |
|
|
|
if item, err = conn.Get(workspaceID + categoryID); err == nil { |
|
if err = json.Unmarshal(item.Value, &categoryPreName); err != nil { |
|
log.Error("Json unmarshal err(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
if category, err = d.CategoryPre(workspaceID, categoryID); err != nil { |
|
return |
|
} |
|
categoryPreName = category.Name |
|
item = &memcache.Item{Key: workspaceID + categoryID, Object: category.Name, Flags: memcache.FlagJSON, Expiration: d.expire} |
|
d.cacheSave(context.Background(), item) |
|
return |
|
} |
|
|
|
//Release Release |
|
func (d *Dao) Release(workSpaceID, releaseID string) (release *model.Release, err error) { |
|
var ( |
|
req *http.Request |
|
res = &model.ReleaseResponse{} |
|
) |
|
|
|
releaseURL := fmt.Sprintf(model.ReleaseURL, workSpaceID, releaseID) |
|
if req, err = d.newTapdRequest(http.MethodGet, releaseURL, nil); err != nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
if err = d.httpClient.Do(context.TODO(), req, res); err != nil || res.Data == nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
release = res.Data.Release |
|
return |
|
} |
|
|
|
// ReleaseName ReleaseName |
|
func (d *Dao) ReleaseName(workspaceID, releaseID string) (releaseName string, err error) { |
|
var ( |
|
item *memcache.Item |
|
conn = d.mc.Get(context.Background()) |
|
release *model.Release |
|
) |
|
defer conn.Close() |
|
|
|
if item, err = conn.Get(workspaceID + releaseID); err == nil { |
|
if err = json.Unmarshal(item.Value, &releaseName); err != nil { |
|
log.Error("Json unmarshal err(%v)", err) |
|
} |
|
return |
|
} |
|
|
|
if release, err = d.Release(workspaceID, releaseID); err != nil { |
|
return |
|
} |
|
releaseName = release.Name |
|
item = &memcache.Item{Key: workspaceID + releaseID, Object: release.Name, Flags: memcache.FlagJSON, Expiration: d.expire} |
|
d.cacheSave(context.Background(), item) |
|
return |
|
} |
|
|
|
//newTapdRequest new tapd request |
|
func (d *Dao) newTapdRequest(method, url string, v interface{}) (req *http.Request, err error) { |
|
req, err = d.newRequest(method, url, v) |
|
req.SetBasicAuth(_userName, _password) |
|
return |
|
} |
|
|
|
// CreateBug Create Bug. |
|
func (d *Dao) CreateBug(bug *model.Bug) (bugID string, err error) { |
|
var ( |
|
req *http.Request |
|
res = &model.BugSingleResponse{} |
|
) |
|
|
|
if req, err = d.newTapdRequest(http.MethodPost, model.CreateBugURL, bug); err != nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
if err = d.httpClient.Do(context.TODO(), req, res); err != nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
if res.Status != _successCode { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
bugID = res.Data.Bug.ID |
|
return |
|
} |
|
|
|
// UpdateBug Update Bug. |
|
func (d *Dao) UpdateBug(bug *model.UpdateBug) (err error) { |
|
var ( |
|
req *http.Request |
|
res = &model.BugSingleResponse{} |
|
) |
|
|
|
if req, err = d.newTapdRequest(http.MethodPost, model.CreateBugURL, bug); err != nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
if err = d.httpClient.Do(context.TODO(), req, res); err != nil { |
|
err = ecode.MartheTapdErr |
|
return |
|
} |
|
|
|
if res.Status != _successCode { |
|
err = ecode.MartheTapdErr |
|
} |
|
|
|
return |
|
}
|
|
|