|
|
@@ -0,0 +1,437 @@ |
|
|
|
package models |
|
|
|
|
|
|
|
import ( |
|
|
|
"fmt" |
|
|
|
"time" |
|
|
|
|
|
|
|
"code.gitea.io/gitea/modules/log" |
|
|
|
"code.gitea.io/gitea/modules/timeutil" |
|
|
|
) |
|
|
|
|
|
|
|
type UserBusinessAnalysisForActivity struct { |
|
|
|
ID int64 `xorm:"pk"` |
|
|
|
CountDate int64 `xorm:"pk"` |
|
|
|
//action :ActionMergePullRequest // 11 |
|
|
|
CodeMergeCount int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
//action :ActionCommitRepo |
|
|
|
CommitCount int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
//issue // 10 |
|
|
|
IssueCount int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
//comment table current date |
|
|
|
CommentCount int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
|
|
|
|
//follow table |
|
|
|
WatchedCount int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
|
|
|
|
CommitCodeSize int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
//issue, issueassigees |
|
|
|
SolveIssueCount int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
//use |
|
|
|
RegistDate timeutil.TimeStamp `xorm:"NOT NULL"` |
|
|
|
|
|
|
|
//user |
|
|
|
Email string `xorm:"NOT NULL"` |
|
|
|
|
|
|
|
Phone string `xorm:"NULL"` |
|
|
|
//user |
|
|
|
Name string `xorm:"NOT NULL"` |
|
|
|
DataDate string `xorm:"NULL"` |
|
|
|
|
|
|
|
CloudBrainTaskNum int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
CommitDatasetNum int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
//0 |
|
|
|
CommitModelCount int `xorm:"NOT NULL DEFAULT 0"` |
|
|
|
} |
|
|
|
|
|
|
|
func QueryDataForActivity(startTime time.Time, endTime time.Time) []*UserBusinessAnalysisForActivity { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
|
|
|
|
result := make([]*UserBusinessAnalysisForActivity, 0) |
|
|
|
publicRepo := queryPublicRepo() |
|
|
|
start_unix := startTime.Unix() |
|
|
|
end_unix := endTime.Unix() |
|
|
|
|
|
|
|
CodeMergeCountMap := queryPullRequestPublic(start_unix, end_unix, publicRepo) |
|
|
|
CommitCodeSizeMap, err := GetAllUserPublicRepoKPIStats(startTime, endTime) |
|
|
|
if err != nil { |
|
|
|
log.Info("error,info=" + err.Error()) |
|
|
|
} |
|
|
|
CommitCountMap := queryCommitActionPublic(start_unix, end_unix, 5, publicRepo) |
|
|
|
IssueCountMap, publicRepoIssueIdMap := queryCreateIssuePublic(start_unix, end_unix, publicRepo) |
|
|
|
SolveIssueCountMap := querySolveIssuePublic(start_unix, end_unix, publicRepoIssueIdMap) |
|
|
|
WatchedCountMap, _ := queryFollow(start_unix, end_unix) |
|
|
|
CommentCountMap := queryCommentPublic(start_unix, end_unix, publicRepoIssueIdMap) |
|
|
|
PublicDataSet := queryAllPublicDataSet(publicRepo) |
|
|
|
DatasetFileNums := queryPublicDatasetFileNums(start_unix, end_unix, PublicDataSet) |
|
|
|
AiModelManageMap := queryUserModelPublic(start_unix, end_unix, publicRepo) |
|
|
|
|
|
|
|
cond := "type != 1 and is_active=true" |
|
|
|
count, err := sess.Where(cond).Count(new(User)) |
|
|
|
|
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
sess.Select("`user`.*").Table("user").Where(cond).OrderBy("id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
userList := make([]*User, 0) |
|
|
|
sess.Find(&userList) |
|
|
|
|
|
|
|
for i, userRecord := range userList { |
|
|
|
var dateRecord UserBusinessAnalysisForActivity |
|
|
|
dateRecord.ID = userRecord.ID |
|
|
|
log.Info("i=" + fmt.Sprint(i) + " userName=" + userRecord.Name) |
|
|
|
dateRecord.Email = userRecord.Email |
|
|
|
dateRecord.Phone = userRecord.PhoneNumber |
|
|
|
dateRecord.RegistDate = userRecord.CreatedUnix |
|
|
|
dateRecord.Name = userRecord.Name |
|
|
|
|
|
|
|
dateRecord.CodeMergeCount = getMapValue(dateRecord.ID, CodeMergeCountMap) |
|
|
|
dateRecord.CommitCount = getMapValue(dateRecord.ID, CommitCountMap) |
|
|
|
dateRecord.WatchedCount = getMapValue(dateRecord.ID, WatchedCountMap) |
|
|
|
dateRecord.CommitDatasetNum = getMapValue(dateRecord.ID, DatasetFileNums) |
|
|
|
dateRecord.IssueCount = getMapValue(dateRecord.ID, IssueCountMap) |
|
|
|
dateRecord.CommentCount = getMapValue(dateRecord.ID, CommentCountMap) |
|
|
|
if _, ok := CommitCodeSizeMap[dateRecord.Email]; !ok { |
|
|
|
dateRecord.CommitCodeSize = 0 |
|
|
|
} else { |
|
|
|
dateRecord.CommitCodeSize = int(CommitCodeSizeMap[dateRecord.Email].CommitLines) |
|
|
|
} |
|
|
|
dateRecord.SolveIssueCount = getMapValue(dateRecord.ID, SolveIssueCountMap) |
|
|
|
|
|
|
|
dateRecord.CommitModelCount = getMapValue(dateRecord.ID, AiModelManageMap) |
|
|
|
|
|
|
|
result = append(result, &dateRecord) |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return result |
|
|
|
} |
|
|
|
func querySolveIssuePublic(start_unix int64, end_unix int64, publicRepoIssueIdMap map[int64]int) map[int64]int { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
resultMap := make(map[int64]int) |
|
|
|
cond := "issue.is_closed=true and issue.closed_unix>=" + fmt.Sprint(start_unix) + " and issue.closed_unix<=" + fmt.Sprint(end_unix) |
|
|
|
|
|
|
|
count, err := sess.Table("issue_assignees").Join("inner", "issue", "issue.id=issue_assignees.issue_id").Where(cond).Count(new(IssueAssignees)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query issue error. return.") |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
issueAssigneesList := make([]*IssueAssignees, 0) |
|
|
|
sess.Select("issue_assignees.*").Table("issue_assignees"). |
|
|
|
Join("inner", "issue", "issue.id=issue_assignees.issue_id"). |
|
|
|
Where(cond).OrderBy("issue_assignees.id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
|
|
|
|
sess.Find(&issueAssigneesList) |
|
|
|
|
|
|
|
log.Info("query IssueAssignees size=" + fmt.Sprint(len(issueAssigneesList))) |
|
|
|
for _, issueAssigneesRecord := range issueAssigneesList { |
|
|
|
if isPublicRepo(issueAssigneesRecord.IssueID, publicRepoIssueIdMap) { |
|
|
|
if _, ok := resultMap[issueAssigneesRecord.AssigneeID]; !ok { |
|
|
|
resultMap[issueAssigneesRecord.AssigneeID] = 1 |
|
|
|
} else { |
|
|
|
resultMap[issueAssigneesRecord.AssigneeID] += 1 |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return resultMap |
|
|
|
} |
|
|
|
|
|
|
|
func queryPublicRepo() map[int64]int { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
resultMap := make(map[int64]int) |
|
|
|
|
|
|
|
count, err := sess.Table("repository").Count(new(Repository)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query Repository error. return.") |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
repositoryList := make([]*Repository, 0) |
|
|
|
sess.Select("*").Table("repository").OrderBy("id desc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
sess.Find(&repositoryList) |
|
|
|
log.Info("query repo size=" + fmt.Sprint(len(repositoryList))) |
|
|
|
for _, repositoryRecord := range repositoryList { |
|
|
|
if repositoryRecord.IsPrivate { |
|
|
|
continue |
|
|
|
} |
|
|
|
if _, ok := resultMap[repositoryRecord.ID]; !ok { |
|
|
|
resultMap[repositoryRecord.ID] = 1 |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return resultMap |
|
|
|
} |
|
|
|
|
|
|
|
func isPublicRepo(repoId int64, publicAllRepo map[int64]int) bool { |
|
|
|
if _, ok := publicAllRepo[repoId]; !ok { |
|
|
|
return false |
|
|
|
} |
|
|
|
return true |
|
|
|
} |
|
|
|
|
|
|
|
func queryPullRequestPublic(start_unix int64, end_unix int64, publicAllRepo map[int64]int) map[int64]int { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
resultMap := make(map[int64]int) |
|
|
|
cond := "pull_request.merged_unix>=" + fmt.Sprint(start_unix) + " and pull_request.merged_unix<=" + fmt.Sprint(end_unix) |
|
|
|
count, err := sess.Table("issue").Join("inner", "pull_request", "issue.id=pull_request.issue_id").Where(cond).Count(new(Issue)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query issue error. return.") |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
issueList := make([]*Issue, 0) |
|
|
|
sess.Select("issue.*").Table("issue").Join("inner", "pull_request", "issue.id=pull_request.issue_id").Where(cond).OrderBy("issue.id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
sess.Find(&issueList) |
|
|
|
log.Info("query issue(PR) size=" + fmt.Sprint(len(issueList))) |
|
|
|
for _, issueRecord := range issueList { |
|
|
|
if isPublicRepo(issueRecord.RepoID, publicAllRepo) { |
|
|
|
if _, ok := resultMap[issueRecord.PosterID]; !ok { |
|
|
|
resultMap[issueRecord.PosterID] = 1 |
|
|
|
} else { |
|
|
|
resultMap[issueRecord.PosterID] += 1 |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
|
|
|
|
func queryCommitActionPublic(start_unix int64, end_unix int64, actionType int64, publicAllRepo map[int64]int) map[int64]int { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
resultMap := make(map[int64]int) |
|
|
|
|
|
|
|
cond := "user_id=act_user_id and op_type=" + fmt.Sprint(actionType) + " and created_unix>=" + fmt.Sprint(start_unix) + " and created_unix<=" + fmt.Sprint(end_unix) |
|
|
|
|
|
|
|
count, err := sess.Where(cond).Count(new(Action)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query action error. return.") |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
sess.Select("id,user_id,op_type,act_user_id,repo_id").Table("action").Where(cond).OrderBy("id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
actionList := make([]*Action, 0) |
|
|
|
sess.Find(&actionList) |
|
|
|
|
|
|
|
log.Info("query action size=" + fmt.Sprint(len(actionList))) |
|
|
|
for _, actionRecord := range actionList { |
|
|
|
if isPublicRepo(actionRecord.RepoID, publicAllRepo) { |
|
|
|
if _, ok := resultMap[actionRecord.UserID]; !ok { |
|
|
|
resultMap[actionRecord.UserID] = 1 |
|
|
|
} else { |
|
|
|
resultMap[actionRecord.UserID] += 1 |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return resultMap |
|
|
|
} |
|
|
|
|
|
|
|
func queryCreateIssuePublic(start_unix int64, end_unix int64, publicAllRepo map[int64]int) (map[int64]int, map[int64]int) { |
|
|
|
|
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
resultMap := make(map[int64]int) |
|
|
|
publicRepoIssueIdMap := make(map[int64]int) |
|
|
|
cond := "is_pull=false and created_unix>=" + fmt.Sprint(start_unix) + " and created_unix<=" + fmt.Sprint(end_unix) |
|
|
|
|
|
|
|
count, err := sess.Where(cond).Count(new(Issue)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query Issue error. return.") |
|
|
|
return resultMap, publicRepoIssueIdMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
sess.Select("id,poster_id,repo_id").Table("issue").Where(cond).OrderBy("id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
issueList := make([]*Issue, 0) |
|
|
|
sess.Find(&issueList) |
|
|
|
log.Info("query issue size=" + fmt.Sprint(len(issueList))) |
|
|
|
for _, issueRecord := range issueList { |
|
|
|
if isPublicRepo(issueRecord.RepoID, publicAllRepo) { |
|
|
|
if _, ok := resultMap[issueRecord.PosterID]; !ok { |
|
|
|
resultMap[issueRecord.PosterID] = 1 |
|
|
|
} else { |
|
|
|
resultMap[issueRecord.PosterID] += 1 |
|
|
|
} |
|
|
|
publicRepoIssueIdMap[issueRecord.ID] = 1 |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
return resultMap, publicRepoIssueIdMap |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
func queryCommentPublic(start_unix int64, end_unix int64, publicRepoIssueIdMap map[int64]int) map[int64]int { |
|
|
|
|
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
cond := "created_unix>=" + fmt.Sprint(start_unix) + " and created_unix<=" + fmt.Sprint(end_unix) |
|
|
|
resultMap := make(map[int64]int) |
|
|
|
count, err := sess.Where(cond).Count(new(Comment)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query Comment error. return.") |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
sess.Select("id,type,poster_id").Table("comment").Where(cond).OrderBy("id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
commentList := make([]*Comment, 0) |
|
|
|
sess.Find(&commentList) |
|
|
|
log.Info("query Comment size=" + fmt.Sprint(len(commentList))) |
|
|
|
for _, commentRecord := range commentList { |
|
|
|
if isPublicRepo(commentRecord.IssueID, publicRepoIssueIdMap) { |
|
|
|
if _, ok := resultMap[commentRecord.PosterID]; !ok { |
|
|
|
resultMap[commentRecord.PosterID] = 1 |
|
|
|
} else { |
|
|
|
resultMap[commentRecord.PosterID] += 1 |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
|
|
|
|
func queryAllPublicDataSet(publicAllRepo map[int64]int) map[int64]int { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
publicDataSetIdMap := make(map[int64]int) |
|
|
|
count, err := sess.Count(new(Dataset)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query dataset error. return.") |
|
|
|
return publicDataSetIdMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
sess.Select("id,user_id,repo_id").Table(new(Dataset)).OrderBy("id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
datasetList := make([]*Dataset, 0) |
|
|
|
sess.Find(&datasetList) |
|
|
|
log.Info("query datasetList size=" + fmt.Sprint(len(datasetList))) |
|
|
|
for _, datasetRecord := range datasetList { |
|
|
|
if isPublicRepo(datasetRecord.RepoID, publicAllRepo) { |
|
|
|
publicDataSetIdMap[datasetRecord.ID] = 1 |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
return publicDataSetIdMap |
|
|
|
} |
|
|
|
|
|
|
|
func queryPublicDatasetFileNums(start_unix int64, end_unix int64, publicDataSetIdMap map[int64]int) map[int64]int { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
resultNumMap := make(map[int64]int) |
|
|
|
cond := " created_unix>=" + fmt.Sprint(start_unix) + " and created_unix<=" + fmt.Sprint(end_unix) |
|
|
|
|
|
|
|
count, err := sess.Where(cond).Count(new(Attachment)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query attachment error. return.") |
|
|
|
return resultNumMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
sess.Select("id,uploader_id,size,dataset_id").Table("attachment").Where(cond).OrderBy("id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
attachmentList := make([]*Attachment, 0) |
|
|
|
sess.Find(&attachmentList) |
|
|
|
|
|
|
|
log.Info("query Attachment size=" + fmt.Sprint(len(attachmentList))) |
|
|
|
for _, attachRecord := range attachmentList { |
|
|
|
if isPublicRepo(attachRecord.DatasetID, publicDataSetIdMap) { |
|
|
|
if _, ok := resultNumMap[attachRecord.UploaderID]; !ok { |
|
|
|
resultNumMap[attachRecord.UploaderID] = 1 |
|
|
|
} else { |
|
|
|
resultNumMap[attachRecord.UploaderID] += 1 |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
return resultNumMap |
|
|
|
} |
|
|
|
|
|
|
|
func queryUserModelPublic(start_unix int64, end_unix int64, publicAllRepo map[int64]int) map[int64]int { |
|
|
|
sess := x.NewSession() |
|
|
|
defer sess.Close() |
|
|
|
resultMap := make(map[int64]int) |
|
|
|
cond := " created_unix>=" + fmt.Sprint(start_unix) + " and created_unix<=" + fmt.Sprint(end_unix) |
|
|
|
count, err := sess.Where(cond).Count(new(AiModelManage)) |
|
|
|
if err != nil { |
|
|
|
log.Info("query AiModelManage error. return.") |
|
|
|
return resultMap |
|
|
|
} |
|
|
|
var indexTotal int64 |
|
|
|
indexTotal = 0 |
|
|
|
for { |
|
|
|
sess.Select("id,user_id,repo_id").Table("ai_model_manage").Where(cond).OrderBy("id asc").Limit(PAGE_SIZE, int(indexTotal)) |
|
|
|
aiModelList := make([]*AiModelManage, 0) |
|
|
|
sess.Find(&aiModelList) |
|
|
|
log.Info("query AiModelManage size=" + fmt.Sprint(len(aiModelList))) |
|
|
|
for _, aiModelRecord := range aiModelList { |
|
|
|
if isPublicRepo(aiModelRecord.RepoId, publicAllRepo) { |
|
|
|
if _, ok := resultMap[aiModelRecord.UserId]; !ok { |
|
|
|
resultMap[aiModelRecord.UserId] = 1 |
|
|
|
} else { |
|
|
|
resultMap[aiModelRecord.UserId] += 1 |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
indexTotal += PAGE_SIZE |
|
|
|
if indexTotal >= count { |
|
|
|
break |
|
|
|
} |
|
|
|
} |
|
|
|
return resultMap |
|
|
|
} |