func (g *GithubTracker) fetch(f githubFetcher) chan TrackerItemContent {
item := make(chan TrackerItemContent)
go func() {
opts := &github.SearchOptions{
ListOptions: github.ListOptions{
PerPage: 20,
},
}
for {
result, response, err := f.listIssues(g.Query, opts)
if _, ok := err.(*github.RateLimitError); ok {
log.Warn(nil, map[string]interface{}{
"query": g.Query,
"opts": opts,
}, "reached rate limit when listing Github issues")
break
}
issues := result.Issues
for _, l := range issues {
id, _ := json.Marshal(l.URL)
content, _ := json.Marshal(l)
item <- TrackerItemContent{ID: string(id), Content: content}
}
if response.NextPage == 0 {
break
}
opts.ListOptions.Page = response.NextPage
}
close(item)
}()
return item
}
func fillUser(claims *keycloakTokenClaims, user *account.User) error {
user.FullName = claims.Name
user.Email = claims.Email
image, err := generateGravatarURL(claims.Email)
if err != nil {
log.Warn(nil, map[string]interface{}{
"userFullName": user.FullName,
"err": err,
}, "error when generating gravatar")
return errors.New("Error when generating gravatar " + err.Error())
}
user.ImageURL = image
return nil
}
// parseSearchString accepts a raw string and generates a searchKeyword object
func parseSearchString(rawSearchString string) (searchKeyword, error) {
// TODO remove special characters and exclaimations if any
rawSearchString = strings.Trim(rawSearchString, "/") // get rid of trailing slashes
rawSearchString = strings.Trim(rawSearchString, "\"")
parts := strings.Fields(rawSearchString)
var res searchKeyword
for _, part := range parts {
// QueryUnescape is required in case of encoded url strings.
// And does not harm regular search strings
// but this processing is required because at this moment, we do not know if
// search input is a regular string or a URL
part, err := url.QueryUnescape(part)
if err != nil {
log.Warn(nil, map[string]interface{}{
"pkg": "search",
"part": part,
}, "unable to escape url!")
}
// IF part is for search with id:1234
// TODO: need to find out the way to use ID fields.
if strings.HasPrefix(part, "id:") {
res.id = append(res.id, strings.TrimPrefix(part, "id:")+":*A")
} else if strings.HasPrefix(part, "type:") {
typeName := strings.TrimPrefix(part, "type:")
if len(typeName) == 0 {
return res, errors.NewBadParameterError("Type name must not be empty", part)
}
res.workItemTypes = append(res.workItemTypes, typeName)
} else if govalidator.IsURL(part) {
part := strings.ToLower(part)
part = trimProtocolFromURLString(part)
searchQueryFromURL := getSearchQueryFromURLString(part)
res.words = append(res.words, searchQueryFromURL)
} else {
part := strings.ToLower(part)
part = sanitizeURL(part)
res.words = append(res.words, part+":*")
}
}
return res, nil
}
func printUserInfo() {
u, err := user.Current()
if err != nil {
log.Warn(nil, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to get current user")
} else {
log.Info(nil, map[string]interface{}{
"username": u.Username,
"uuid": u.Uid,
}, "Running as user name '%s' with UID %s.", u.Username, u.Uid)
/*
g, err := user.LookupGroupId(u.Gid)
if err != nil {
fmt.Printf("Failed to lookup group: %", err.Error())
} else {
fmt.Printf("Running with group \"%s\" with GID %s.\n", g.Name, g.Gid)
}
*/
}
}