id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
13,400 | fabric8-services/fabric8-wit | space/authz/authz.go | InjectAuthzService | func InjectAuthzService(service AuthzService) goa.Middleware {
return func(h goa.Handler) goa.Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
ctxWithAuthzServ := tokencontext.ContextWithSpaceAuthzService(ctx, &AuthzServiceManagerWrapper{Service: service, Config: service.Configuration()})
return h(ctxWithAuthzServ, rw, req)
}
}
} | go | func InjectAuthzService(service AuthzService) goa.Middleware {
return func(h goa.Handler) goa.Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
ctxWithAuthzServ := tokencontext.ContextWithSpaceAuthzService(ctx, &AuthzServiceManagerWrapper{Service: service, Config: service.Configuration()})
return h(ctxWithAuthzServ, rw, req)
}
}
} | [
"func",
"InjectAuthzService",
"(",
"service",
"AuthzService",
")",
"goa",
".",
"Middleware",
"{",
"return",
"func",
"(",
"h",
"goa",
".",
"Handler",
")",
"goa",
".",
"Handler",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"rw",
"htt... | // InjectAuthzService is a middleware responsible for setting up AuthzService in the context for every request. | [
"InjectAuthzService",
"is",
"a",
"middleware",
"responsible",
"for",
"setting",
"up",
"AuthzService",
"in",
"the",
"context",
"for",
"every",
"request",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/space/authz/authz.go#L139-L146 |
13,401 | fabric8-services/fabric8-wit | space/authz/authz.go | Authorize | func Authorize(ctx context.Context, spaceID string) (bool, error) {
srv := tokencontext.ReadSpaceAuthzServiceFromContext(ctx)
if srv == nil {
log.Error(ctx, map[string]interface{}{
"space_id": spaceID,
}, "Missing space authz service")
return false, errs.New("missing space authz service")
}
manager := srv.(AuthzServiceManager)
return manager.AuthzService().Authorize(ctx, spaceID)
} | go | func Authorize(ctx context.Context, spaceID string) (bool, error) {
srv := tokencontext.ReadSpaceAuthzServiceFromContext(ctx)
if srv == nil {
log.Error(ctx, map[string]interface{}{
"space_id": spaceID,
}, "Missing space authz service")
return false, errs.New("missing space authz service")
}
manager := srv.(AuthzServiceManager)
return manager.AuthzService().Authorize(ctx, spaceID)
} | [
"func",
"Authorize",
"(",
"ctx",
"context",
".",
"Context",
",",
"spaceID",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"srv",
":=",
"tokencontext",
".",
"ReadSpaceAuthzServiceFromContext",
"(",
"ctx",
")",
"\n",
"if",
"srv",
"==",
"nil",
"{",
"l... | // Authorize returns true and the corresponding Requesting Party Token if the current user is among the space collaborators | [
"Authorize",
"returns",
"true",
"and",
"the",
"corresponding",
"Requesting",
"Party",
"Token",
"if",
"the",
"current",
"user",
"is",
"among",
"the",
"space",
"collaborators"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/space/authz/authz.go#L149-L160 |
13,402 | fabric8-services/fabric8-wit | goasupport/forward_signer.go | Sign | func (f forwardSigner) Sign(request *http.Request) error {
request.Header.Set("Authorization", "Bearer "+f.token)
return nil
} | go | func (f forwardSigner) Sign(request *http.Request) error {
request.Header.Set("Authorization", "Bearer "+f.token)
return nil
} | [
"func",
"(",
"f",
"forwardSigner",
")",
"Sign",
"(",
"request",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"request",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"f",
".",
"token",
")",
"\n",
"return",
"nil",
"\n",
"}"
... | // Sign set the Auth header | [
"Sign",
"set",
"the",
"Auth",
"header"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/goasupport/forward_signer.go#L17-L20 |
13,403 | fabric8-services/fabric8-wit | goasupport/forward_signer.go | NewForwardSigner | func NewForwardSigner(ctx context.Context) goaclient.Signer {
token := goajwt.ContextJWT(ctx)
if token == nil {
return nil
}
return &forwardSigner{token: token.Raw}
} | go | func NewForwardSigner(ctx context.Context) goaclient.Signer {
token := goajwt.ContextJWT(ctx)
if token == nil {
return nil
}
return &forwardSigner{token: token.Raw}
} | [
"func",
"NewForwardSigner",
"(",
"ctx",
"context",
".",
"Context",
")",
"goaclient",
".",
"Signer",
"{",
"token",
":=",
"goajwt",
".",
"ContextJWT",
"(",
"ctx",
")",
"\n",
"if",
"token",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&"... | // NewForwardSigner return a new signer based on current context | [
"NewForwardSigner",
"return",
"a",
"new",
"signer",
"based",
"on",
"current",
"context"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/goasupport/forward_signer.go#L23-L29 |
13,404 | fabric8-services/fabric8-wit | controller/trackerquery.go | NewTrackerqueryController | func NewTrackerqueryController(service *goa.Service, db application.DB, scheduler *remoteworkitem.Scheduler, configuration trackerQueryConfiguration, authService auth.AuthService) *TrackerqueryController {
return &TrackerqueryController{
Controller: service.NewController("TrackerqueryController"),
db: db,
scheduler: scheduler,
configuration: configuration,
authService: authService,
}
} | go | func NewTrackerqueryController(service *goa.Service, db application.DB, scheduler *remoteworkitem.Scheduler, configuration trackerQueryConfiguration, authService auth.AuthService) *TrackerqueryController {
return &TrackerqueryController{
Controller: service.NewController("TrackerqueryController"),
db: db,
scheduler: scheduler,
configuration: configuration,
authService: authService,
}
} | [
"func",
"NewTrackerqueryController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"db",
"application",
".",
"DB",
",",
"scheduler",
"*",
"remoteworkitem",
".",
"Scheduler",
",",
"configuration",
"trackerQueryConfiguration",
",",
"authService",
"auth",
".",
"Au... | // NewTrackerqueryController creates a trackerquery controller. | [
"NewTrackerqueryController",
"creates",
"a",
"trackerquery",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/trackerquery.go#L45-L53 |
13,405 | fabric8-services/fabric8-wit | controller/trackerquery.go | ConvertTrackerQueriesToApp | func ConvertTrackerQueriesToApp(appl application.Application, request *http.Request, trackerqueries []remoteworkitem.TrackerQuery) []*app.TrackerQuery {
var ls = []*app.TrackerQuery{}
for _, i := range trackerqueries {
ls = append(ls, convertTrackerQueryToApp(appl, request, i))
}
return ls
} | go | func ConvertTrackerQueriesToApp(appl application.Application, request *http.Request, trackerqueries []remoteworkitem.TrackerQuery) []*app.TrackerQuery {
var ls = []*app.TrackerQuery{}
for _, i := range trackerqueries {
ls = append(ls, convertTrackerQueryToApp(appl, request, i))
}
return ls
} | [
"func",
"ConvertTrackerQueriesToApp",
"(",
"appl",
"application",
".",
"Application",
",",
"request",
"*",
"http",
".",
"Request",
",",
"trackerqueries",
"[",
"]",
"remoteworkitem",
".",
"TrackerQuery",
")",
"[",
"]",
"*",
"app",
".",
"TrackerQuery",
"{",
"var... | // ConvertTrackerQueriesToApp from internal to external REST representation | [
"ConvertTrackerQueriesToApp",
"from",
"internal",
"to",
"external",
"REST",
"representation"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/trackerquery.go#L217-L223 |
13,406 | fabric8-services/fabric8-wit | controller/trackerquery.go | convertTrackerQueryToApp | func convertTrackerQueryToApp(appl application.Application, request *http.Request, trackerquery remoteworkitem.TrackerQuery) *app.TrackerQuery {
trackerQueryStringType := remoteworkitem.APIStringTypeTrackerQuery
selfURL := rest.AbsoluteURL(request, app.TrackerqueryHref(trackerquery.ID))
t := &app.TrackerQuery{
Type: trackerQueryStringType,
ID: &trackerquery.ID,
Attributes: &app.TrackerQueryAttributes{
Query: trackerquery.Query,
Schedule: trackerquery.Schedule,
},
Links: &app.GenericLinks{
Self: &selfURL,
},
}
return t
} | go | func convertTrackerQueryToApp(appl application.Application, request *http.Request, trackerquery remoteworkitem.TrackerQuery) *app.TrackerQuery {
trackerQueryStringType := remoteworkitem.APIStringTypeTrackerQuery
selfURL := rest.AbsoluteURL(request, app.TrackerqueryHref(trackerquery.ID))
t := &app.TrackerQuery{
Type: trackerQueryStringType,
ID: &trackerquery.ID,
Attributes: &app.TrackerQueryAttributes{
Query: trackerquery.Query,
Schedule: trackerquery.Schedule,
},
Links: &app.GenericLinks{
Self: &selfURL,
},
}
return t
} | [
"func",
"convertTrackerQueryToApp",
"(",
"appl",
"application",
".",
"Application",
",",
"request",
"*",
"http",
".",
"Request",
",",
"trackerquery",
"remoteworkitem",
".",
"TrackerQuery",
")",
"*",
"app",
".",
"TrackerQuery",
"{",
"trackerQueryStringType",
":=",
... | // ConvertTrackerQueryToApp converts from internal to external REST representation | [
"ConvertTrackerQueryToApp",
"converts",
"from",
"internal",
"to",
"external",
"REST",
"representation"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/trackerquery.go#L226-L241 |
13,407 | fabric8-services/fabric8-wit | criteria/expression_substring.go | Substring | func Substring(left Expression, right Expression) Expression {
return reparent(&SubstringExpression{binaryExpression{expression{}, left, right}})
} | go | func Substring(left Expression, right Expression) Expression {
return reparent(&SubstringExpression{binaryExpression{expression{}, left, right}})
} | [
"func",
"Substring",
"(",
"left",
"Expression",
",",
"right",
"Expression",
")",
"Expression",
"{",
"return",
"reparent",
"(",
"&",
"SubstringExpression",
"{",
"binaryExpression",
"{",
"expression",
"{",
"}",
",",
"left",
",",
"right",
"}",
"}",
")",
"\n",
... | // Substring constructs an SubstringExpression | [
"Substring",
"constructs",
"an",
"SubstringExpression"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/criteria/expression_substring.go#L18-L20 |
13,408 | fabric8-services/fabric8-wit | metric/recorder.go | Recorder | func Recorder() goa.Middleware {
registerMetrics()
return func(h goa.Handler) goa.Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
startTime := time.Now()
err := h(ctx, rw, req)
// record metrics
method, entity, code := labelsVal(ctx)
recordReqsTotal(method, entity, code)
recordReqSize(method, entity, code, req)
recordResSize(method, entity, code, goa.ContextResponse(ctx))
recordReqDuration(method, entity, code, startTime)
return err
}
}
} | go | func Recorder() goa.Middleware {
registerMetrics()
return func(h goa.Handler) goa.Handler {
return func(ctx context.Context, rw http.ResponseWriter, req *http.Request) error {
startTime := time.Now()
err := h(ctx, rw, req)
// record metrics
method, entity, code := labelsVal(ctx)
recordReqsTotal(method, entity, code)
recordReqSize(method, entity, code, req)
recordResSize(method, entity, code, goa.ContextResponse(ctx))
recordReqDuration(method, entity, code, startTime)
return err
}
}
} | [
"func",
"Recorder",
"(",
")",
"goa",
".",
"Middleware",
"{",
"registerMetrics",
"(",
")",
"\n\n",
"return",
"func",
"(",
"h",
"goa",
".",
"Handler",
")",
"goa",
".",
"Handler",
"{",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"rw",
... | // Recorder record prometheus metrics related to http request and response. | [
"Recorder",
"record",
"prometheus",
"metrics",
"related",
"to",
"http",
"request",
"and",
"response",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/metric/recorder.go#L16-L34 |
13,409 | fabric8-services/fabric8-wit | metric/recorder.go | entityVal | func entityVal(ctrl string) (entity string) {
if strings.HasSuffix(ctrl, "Controller") {
entity = strings.ToLower(strings.TrimSuffix(ctrl, "Controller"))
}
return entity
} | go | func entityVal(ctrl string) (entity string) {
if strings.HasSuffix(ctrl, "Controller") {
entity = strings.ToLower(strings.TrimSuffix(ctrl, "Controller"))
}
return entity
} | [
"func",
"entityVal",
"(",
"ctrl",
"string",
")",
"(",
"entity",
"string",
")",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"ctrl",
",",
"\"",
"\"",
")",
"{",
"entity",
"=",
"strings",
".",
"ToLower",
"(",
"strings",
".",
"TrimSuffix",
"(",
"ctrl",
"... | // ctrl=SpaceController -> entity=space | [
"ctrl",
"=",
"SpaceController",
"-",
">",
"entity",
"=",
"space"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/metric/recorder.go#L70-L75 |
13,410 | fabric8-services/fabric8-wit | metric/recorder.go | codeVal | func codeVal(status int) string {
code := (status - (status % 100)) / 100
return strconv.Itoa(code) + "xx"
} | go | func codeVal(status int) string {
code := (status - (status % 100)) / 100
return strconv.Itoa(code) + "xx"
} | [
"func",
"codeVal",
"(",
"status",
"int",
")",
"string",
"{",
"code",
":=",
"(",
"status",
"-",
"(",
"status",
"%",
"100",
")",
")",
"/",
"100",
"\n",
"return",
"strconv",
".",
"Itoa",
"(",
"code",
")",
"+",
"\"",
"\"",
"\n",
"}"
] | // Group HTTP status code in the form of 2xx, 3xx etc. | [
"Group",
"HTTP",
"status",
"code",
"in",
"the",
"form",
"of",
"2xx",
"3xx",
"etc",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/metric/recorder.go#L78-L81 |
13,411 | fabric8-services/fabric8-wit | resource/require.go | checkEnvVars | func checkEnvVars(envVars ...string) *string {
var res string
for _, envVar := range envVars {
v, isSet := os.LookupEnv(envVar)
// If we don't explicitly opt out from unit tests
// by specifying F8_RESOURCE_UNIT_TEST=0
// we're going to run them
if !isSet && envVar == UnitTest {
continue
}
// Skip test if environment variable is not set.
if !isSet {
res = fmt.Sprintf(StSkipReasonNotSet, envVar)
return &res
}
// Try to convert to boolean value
isTrue, err := strconv.ParseBool(v)
if err != nil {
res = fmt.Sprintf(StSkipReasonParseError, envVar, v)
return &res
}
if !isTrue {
res = fmt.Sprintf(StSkipReasonValueFalse, envVar, v)
return &res
}
}
return nil
} | go | func checkEnvVars(envVars ...string) *string {
var res string
for _, envVar := range envVars {
v, isSet := os.LookupEnv(envVar)
// If we don't explicitly opt out from unit tests
// by specifying F8_RESOURCE_UNIT_TEST=0
// we're going to run them
if !isSet && envVar == UnitTest {
continue
}
// Skip test if environment variable is not set.
if !isSet {
res = fmt.Sprintf(StSkipReasonNotSet, envVar)
return &res
}
// Try to convert to boolean value
isTrue, err := strconv.ParseBool(v)
if err != nil {
res = fmt.Sprintf(StSkipReasonParseError, envVar, v)
return &res
}
if !isTrue {
res = fmt.Sprintf(StSkipReasonValueFalse, envVar, v)
return &res
}
}
return nil
} | [
"func",
"checkEnvVars",
"(",
"envVars",
"...",
"string",
")",
"*",
"string",
"{",
"var",
"res",
"string",
"\n",
"for",
"_",
",",
"envVar",
":=",
"range",
"envVars",
"{",
"v",
",",
"isSet",
":=",
"os",
".",
"LookupEnv",
"(",
"envVar",
")",
"\n\n",
"//... | // checkEnvVars returns a skip reason if one of the given environment variables
// cannot be found or evalutes to false. | [
"checkEnvVars",
"returns",
"a",
"skip",
"reason",
"if",
"one",
"of",
"the",
"given",
"environment",
"variables",
"cannot",
"be",
"found",
"or",
"evalutes",
"to",
"false",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/resource/require.go#L56-L86 |
13,412 | fabric8-services/fabric8-wit | search/search_repository.go | NewGormSearchRepository | func NewGormSearchRepository(db *gorm.DB) *GormSearchRepository {
return &GormSearchRepository{db, workitem.NewWorkItemTypeRepository(db)}
} | go | func NewGormSearchRepository(db *gorm.DB) *GormSearchRepository {
return &GormSearchRepository{db, workitem.NewWorkItemTypeRepository(db)}
} | [
"func",
"NewGormSearchRepository",
"(",
"db",
"*",
"gorm",
".",
"DB",
")",
"*",
"GormSearchRepository",
"{",
"return",
"&",
"GormSearchRepository",
"{",
"db",
",",
"workitem",
".",
"NewWorkItemTypeRepository",
"(",
"db",
")",
"}",
"\n",
"}"
] | // NewGormSearchRepository creates a new search repository | [
"NewGormSearchRepository",
"creates",
"a",
"new",
"search",
"repository"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/search/search_repository.go#L57-L59 |
13,413 | fabric8-services/fabric8-wit | search/search_repository.go | RegisterAsKnownURL | func RegisterAsKnownURL(name, urlRegex string) {
compiledRegex := regexp.MustCompile(urlRegex)
groupNames := compiledRegex.SubexpNames()
knownURLLock.Lock()
defer knownURLLock.Unlock()
knownURLs[name] = KnownURL{
URLRegex: urlRegex,
compiledRegex: regexp.MustCompile(urlRegex),
groupNamesInRegex: groupNames,
}
} | go | func RegisterAsKnownURL(name, urlRegex string) {
compiledRegex := regexp.MustCompile(urlRegex)
groupNames := compiledRegex.SubexpNames()
knownURLLock.Lock()
defer knownURLLock.Unlock()
knownURLs[name] = KnownURL{
URLRegex: urlRegex,
compiledRegex: regexp.MustCompile(urlRegex),
groupNamesInRegex: groupNames,
}
} | [
"func",
"RegisterAsKnownURL",
"(",
"name",
",",
"urlRegex",
"string",
")",
"{",
"compiledRegex",
":=",
"regexp",
".",
"MustCompile",
"(",
"urlRegex",
")",
"\n",
"groupNames",
":=",
"compiledRegex",
".",
"SubexpNames",
"(",
")",
"\n",
"knownURLLock",
".",
"Lock... | // RegisterAsKnownURL appends to KnownURLs | [
"RegisterAsKnownURL",
"appends",
"to",
"KnownURLs"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/search/search_repository.go#L95-L105 |
13,414 | fabric8-services/fabric8-wit | search/search_repository.go | parseSearchString | func parseSearchString(ctx context.Context, 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{}{
"part": part,
}, "unable to escape url!")
}
// IF part is for search with number:1234
// TODO: need to find out the way to use ID fields.
if strings.HasPrefix(part, "number:") {
res.number = append(res.number, strings.TrimPrefix(part, "number:")+":*A")
} else if strings.HasPrefix(part, "type:") {
typeIDStr := strings.TrimPrefix(part, "type:")
if len(typeIDStr) == 0 {
log.Error(ctx, map[string]interface{}{}, "type: part is empty")
return res, errors.NewBadParameterError("Type ID must not be empty", part)
}
typeID, err := uuid.FromString(typeIDStr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"typeID": typeIDStr,
}, "failed to convert type ID string to UUID")
return res, errors.NewBadParameterError("failed to parse type ID string as UUID", typeIDStr)
}
res.workItemTypes = append(res.workItemTypes, typeID)
} else if govalidator.IsURL(part) {
log.Debug(ctx, map[string]interface{}{"url": part}, "found a URL in the query string")
part := strings.ToLower(part)
part = trimProtocolFromURLString(part)
searchQueryFromURL := getSearchQueryFromURLString(part)
log.Debug(ctx, map[string]interface{}{"url": part, "search_query": searchQueryFromURL}, "found a URL in the query string")
res.words = append(res.words, searchQueryFromURL)
} else {
part := strings.ToLower(part)
part = sanitizeURL(part)
res.words = append(res.words, part+":*")
}
}
log.Info(nil, nil, "Search keywords: '%s' -> %v", rawSearchString, res)
return res, nil
} | go | func parseSearchString(ctx context.Context, 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{}{
"part": part,
}, "unable to escape url!")
}
// IF part is for search with number:1234
// TODO: need to find out the way to use ID fields.
if strings.HasPrefix(part, "number:") {
res.number = append(res.number, strings.TrimPrefix(part, "number:")+":*A")
} else if strings.HasPrefix(part, "type:") {
typeIDStr := strings.TrimPrefix(part, "type:")
if len(typeIDStr) == 0 {
log.Error(ctx, map[string]interface{}{}, "type: part is empty")
return res, errors.NewBadParameterError("Type ID must not be empty", part)
}
typeID, err := uuid.FromString(typeIDStr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"typeID": typeIDStr,
}, "failed to convert type ID string to UUID")
return res, errors.NewBadParameterError("failed to parse type ID string as UUID", typeIDStr)
}
res.workItemTypes = append(res.workItemTypes, typeID)
} else if govalidator.IsURL(part) {
log.Debug(ctx, map[string]interface{}{"url": part}, "found a URL in the query string")
part := strings.ToLower(part)
part = trimProtocolFromURLString(part)
searchQueryFromURL := getSearchQueryFromURLString(part)
log.Debug(ctx, map[string]interface{}{"url": part, "search_query": searchQueryFromURL}, "found a URL in the query string")
res.words = append(res.words, searchQueryFromURL)
} else {
part := strings.ToLower(part)
part = sanitizeURL(part)
res.words = append(res.words, part+":*")
}
}
log.Info(nil, nil, "Search keywords: '%s' -> %v", rawSearchString, res)
return res, nil
} | [
"func",
"parseSearchString",
"(",
"ctx",
"context",
".",
"Context",
",",
"rawSearchString",
"string",
")",
"(",
"searchKeyword",
",",
"error",
")",
"{",
"// TODO remove special characters and exclaimations if any",
"rawSearchString",
"=",
"strings",
".",
"Trim",
"(",
... | // parseSearchString accepts a raw string and generates a searchKeyword object | [
"parseSearchString",
"accepts",
"a",
"raw",
"string",
"and",
"generates",
"a",
"searchKeyword",
"object"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/search/search_repository.go#L216-L268 |
13,415 | fabric8-services/fabric8-wit | search/search_repository.go | ParseFilterString | func ParseFilterString(ctx context.Context, rawSearchString string) (criteria.Expression, *QueryOptions, error) {
fm := map[string]interface{}{}
// Parsing/Unmarshalling JSON encoding/json
err := json.Unmarshal([]byte(rawSearchString), &fm)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"rawSearchString": rawSearchString,
}, "failed to unmarshal raw search string")
return nil, nil, errors.NewBadParameterError("expression", rawSearchString+": "+err.Error())
}
q := Query{}
parseMap(fm, &q)
q.Options = parseOptions(fm)
exp, err := q.generateExpression()
return exp, q.Options, err
} | go | func ParseFilterString(ctx context.Context, rawSearchString string) (criteria.Expression, *QueryOptions, error) {
fm := map[string]interface{}{}
// Parsing/Unmarshalling JSON encoding/json
err := json.Unmarshal([]byte(rawSearchString), &fm)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"rawSearchString": rawSearchString,
}, "failed to unmarshal raw search string")
return nil, nil, errors.NewBadParameterError("expression", rawSearchString+": "+err.Error())
}
q := Query{}
parseMap(fm, &q)
q.Options = parseOptions(fm)
exp, err := q.generateExpression()
return exp, q.Options, err
} | [
"func",
"ParseFilterString",
"(",
"ctx",
"context",
".",
"Context",
",",
"rawSearchString",
"string",
")",
"(",
"criteria",
".",
"Expression",
",",
"*",
"QueryOptions",
",",
"error",
")",
"{",
"fm",
":=",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
... | // ParseFilterString accepts a raw string and generates a criteria expression | [
"ParseFilterString",
"accepts",
"a",
"raw",
"string",
"and",
"generates",
"a",
"criteria",
"expression"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/search/search_repository.go#L545-L564 |
13,416 | fabric8-services/fabric8-wit | search/search_repository.go | generateSQLSearchInfo | func generateSQLSearchInfo(keywords searchKeyword) (sqlParameter string) {
numberStr := strings.Join(keywords.number, " & ")
wordStr := strings.Join(keywords.words, " & ")
var fragments []string
for _, v := range []string{numberStr, wordStr} {
if v != "" {
fragments = append(fragments, v)
}
}
searchStr := strings.Join(fragments, " & ")
return searchStr
} | go | func generateSQLSearchInfo(keywords searchKeyword) (sqlParameter string) {
numberStr := strings.Join(keywords.number, " & ")
wordStr := strings.Join(keywords.words, " & ")
var fragments []string
for _, v := range []string{numberStr, wordStr} {
if v != "" {
fragments = append(fragments, v)
}
}
searchStr := strings.Join(fragments, " & ")
return searchStr
} | [
"func",
"generateSQLSearchInfo",
"(",
"keywords",
"searchKeyword",
")",
"(",
"sqlParameter",
"string",
")",
"{",
"numberStr",
":=",
"strings",
".",
"Join",
"(",
"keywords",
".",
"number",
",",
"\"",
"\"",
")",
"\n",
"wordStr",
":=",
"strings",
".",
"Join",
... | // generateSQLSearchInfo accepts searchKeyword and join them in a way that can be used in sql | [
"generateSQLSearchInfo",
"accepts",
"searchKeyword",
"and",
"join",
"them",
"in",
"a",
"way",
"that",
"can",
"be",
"used",
"in",
"sql"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/search/search_repository.go#L567-L578 |
13,417 | fabric8-services/fabric8-wit | search/search_repository.go | SearchFullText | func (r *GormSearchRepository) SearchFullText(ctx context.Context, rawSearchString string, start *int, limit *int, spaceID *string) ([]workitem.WorkItem, int, error) {
// parse
// generateSearchQuery
// ....
parsedSearchDict, err := parseSearchString(ctx, rawSearchString)
if err != nil {
return nil, 0, errs.WithStack(err)
}
sqlSearchQueryParameter := generateSQLSearchInfo(parsedSearchDict)
var rows []workitem.WorkItemStorage
log.Debug(ctx, map[string]interface{}{"search query": sqlSearchQueryParameter}, "searching for work items")
rows, count, err := r.search(ctx, sqlSearchQueryParameter, parsedSearchDict.workItemTypes, start, limit, spaceID)
if err != nil {
return nil, 0, errs.WithStack(err)
}
result := make([]workitem.WorkItem, len(rows))
for index, value := range rows {
var err error
// FIXME: Against best practice http://go-database-sql.org/retrieving.html
wiType, err := r.witr.Load(ctx, value.Type)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"wit": value.Type,
}, "failed to load work item type")
spew.Dump(value)
return nil, 0, errors.NewInternalError(ctx, errs.Wrap(err, "failed to load work item type"))
}
wiModel, err := workitem.ConvertWorkItemStorageToModel(wiType, &value)
if err != nil {
return nil, 0, errors.NewConversionError(err.Error())
}
result[index] = *wiModel
}
return result, count, nil
} | go | func (r *GormSearchRepository) SearchFullText(ctx context.Context, rawSearchString string, start *int, limit *int, spaceID *string) ([]workitem.WorkItem, int, error) {
// parse
// generateSearchQuery
// ....
parsedSearchDict, err := parseSearchString(ctx, rawSearchString)
if err != nil {
return nil, 0, errs.WithStack(err)
}
sqlSearchQueryParameter := generateSQLSearchInfo(parsedSearchDict)
var rows []workitem.WorkItemStorage
log.Debug(ctx, map[string]interface{}{"search query": sqlSearchQueryParameter}, "searching for work items")
rows, count, err := r.search(ctx, sqlSearchQueryParameter, parsedSearchDict.workItemTypes, start, limit, spaceID)
if err != nil {
return nil, 0, errs.WithStack(err)
}
result := make([]workitem.WorkItem, len(rows))
for index, value := range rows {
var err error
// FIXME: Against best practice http://go-database-sql.org/retrieving.html
wiType, err := r.witr.Load(ctx, value.Type)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"wit": value.Type,
}, "failed to load work item type")
spew.Dump(value)
return nil, 0, errors.NewInternalError(ctx, errs.Wrap(err, "failed to load work item type"))
}
wiModel, err := workitem.ConvertWorkItemStorageToModel(wiType, &value)
if err != nil {
return nil, 0, errors.NewConversionError(err.Error())
}
result[index] = *wiModel
}
return result, count, nil
} | [
"func",
"(",
"r",
"*",
"GormSearchRepository",
")",
"SearchFullText",
"(",
"ctx",
"context",
".",
"Context",
",",
"rawSearchString",
"string",
",",
"start",
"*",
"int",
",",
"limit",
"*",
"int",
",",
"spaceID",
"*",
"string",
")",
"(",
"[",
"]",
"workite... | // SearchFullText Search returns work items for the given query | [
"SearchFullText",
"Search",
"returns",
"work",
"items",
"for",
"the",
"given",
"query"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/search/search_repository.go#L663-L701 |
13,418 | fabric8-services/fabric8-wit | tool/wit-cli/main.go | newJWTSigner | func newJWTSigner(key, format string) goaclient.Signer {
return &goaclient.APIKeySigner{
SignQuery: false,
KeyName: "Authorization",
KeyValue: key,
Format: format,
}
} | go | func newJWTSigner(key, format string) goaclient.Signer {
return &goaclient.APIKeySigner{
SignQuery: false,
KeyName: "Authorization",
KeyValue: key,
Format: format,
}
} | [
"func",
"newJWTSigner",
"(",
"key",
",",
"format",
"string",
")",
"goaclient",
".",
"Signer",
"{",
"return",
"&",
"goaclient",
".",
"APIKeySigner",
"{",
"SignQuery",
":",
"false",
",",
"KeyName",
":",
"\"",
"\"",
",",
"KeyValue",
":",
"key",
",",
"Format... | // newJWTSigner returns the request signer used for authenticating
// against the jwt security scheme. | [
"newJWTSigner",
"returns",
"the",
"request",
"signer",
"used",
"for",
"authenticating",
"against",
"the",
"jwt",
"security",
"scheme",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/tool/wit-cli/main.go#L64-L72 |
13,419 | fabric8-services/fabric8-wit | criteria/criteria.go | IterateParents | func IterateParents(exp Expression, f func(Expression) bool) {
if exp != nil {
exp = exp.Parent()
}
for exp != nil {
if !f(exp) {
return
}
exp = exp.Parent()
}
} | go | func IterateParents(exp Expression, f func(Expression) bool) {
if exp != nil {
exp = exp.Parent()
}
for exp != nil {
if !f(exp) {
return
}
exp = exp.Parent()
}
} | [
"func",
"IterateParents",
"(",
"exp",
"Expression",
",",
"f",
"func",
"(",
"Expression",
")",
"bool",
")",
"{",
"if",
"exp",
"!=",
"nil",
"{",
"exp",
"=",
"exp",
".",
"Parent",
"(",
")",
"\n",
"}",
"\n",
"for",
"exp",
"!=",
"nil",
"{",
"if",
"!",... | // IterateParents calls f for every member of the parent chain
// Stops iterating if f returns false | [
"IterateParents",
"calls",
"f",
"for",
"every",
"member",
"of",
"the",
"parent",
"chain",
"Stops",
"iterating",
"if",
"f",
"returns",
"false"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/criteria/criteria.go#L5-L15 |
13,420 | fabric8-services/fabric8-wit | controller/permission.go | CRUDWorkItem | func (p *PermissionDefinition) CRUDWorkItem() []string {
return []string{p.CreateWorkItem, p.ReadWorkItem, p.UpdateWorkItem, p.DeleteWorkItem}
} | go | func (p *PermissionDefinition) CRUDWorkItem() []string {
return []string{p.CreateWorkItem, p.ReadWorkItem, p.UpdateWorkItem, p.DeleteWorkItem}
} | [
"func",
"(",
"p",
"*",
"PermissionDefinition",
")",
"CRUDWorkItem",
"(",
")",
"[",
"]",
"string",
"{",
"return",
"[",
"]",
"string",
"{",
"p",
".",
"CreateWorkItem",
",",
"p",
".",
"ReadWorkItem",
",",
"p",
".",
"UpdateWorkItem",
",",
"p",
".",
"Delete... | // CRUDWorkItem returns all CRUD permissions for a WorkItem | [
"CRUDWorkItem",
"returns",
"all",
"CRUD",
"permissions",
"for",
"a",
"WorkItem"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/permission.go#L12-L14 |
13,421 | fabric8-services/fabric8-wit | criteria/expression_and.go | And | func And(left Expression, right Expression) Expression {
return reparent(&AndExpression{binaryExpression{expression{}, left, right}})
} | go | func And(left Expression, right Expression) Expression {
return reparent(&AndExpression{binaryExpression{expression{}, left, right}})
} | [
"func",
"And",
"(",
"left",
"Expression",
",",
"right",
"Expression",
")",
"Expression",
"{",
"return",
"reparent",
"(",
"&",
"AndExpression",
"{",
"binaryExpression",
"{",
"expression",
"{",
"}",
",",
"left",
",",
"right",
"}",
"}",
")",
"\n",
"}"
] | // And constructs an AndExpression | [
"And",
"constructs",
"an",
"AndExpression"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/criteria/expression_and.go#L18-L20 |
13,422 | fabric8-services/fabric8-wit | rendering/markdown.go | MarkdownCommonHighlighter | func MarkdownCommonHighlighter(input []byte) []byte {
renderer := highlightHTMLRenderer{blackfriday.HtmlRenderer(commonHTMLFlags, "", ""), 0}
return blackfriday.MarkdownOptions(input, &renderer, blackfriday.Options{
Extensions: commonExtensions})
} | go | func MarkdownCommonHighlighter(input []byte) []byte {
renderer := highlightHTMLRenderer{blackfriday.HtmlRenderer(commonHTMLFlags, "", ""), 0}
return blackfriday.MarkdownOptions(input, &renderer, blackfriday.Options{
Extensions: commonExtensions})
} | [
"func",
"MarkdownCommonHighlighter",
"(",
"input",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"renderer",
":=",
"highlightHTMLRenderer",
"{",
"blackfriday",
".",
"HtmlRenderer",
"(",
"commonHTMLFlags",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
",",
"0",
"}... | // MarkdownCommonHighlighter uses the blackfriday.MarkdownCommon setup but also includes
// code-prettify formatting of BlockCode segments | [
"MarkdownCommonHighlighter",
"uses",
"the",
"blackfriday",
".",
"MarkdownCommon",
"setup",
"but",
"also",
"includes",
"code",
"-",
"prettify",
"formatting",
"of",
"BlockCode",
"segments"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/rendering/markdown.go#L36-L40 |
13,423 | fabric8-services/fabric8-wit | rendering/markdown.go | ListItem | func (h *highlightHTMLRenderer) ListItem(out *bytes.Buffer, text []byte, flags int) {
switch {
case bytes.HasPrefix(text, []byte("[ ] ")):
text = append([]byte(fmt.Sprintf(`<input class="markdown-checkbox" type="checkbox" disabled="disabled" data-checkbox-index="%d"></input>`, h.checkboxIndex)), text[4:]...)
h.checkboxIndex++
case bytes.HasPrefix(text, []byte("[x] ")) || bytes.HasPrefix(text, []byte("[X] ")):
text = append([]byte(fmt.Sprintf(`<input class="markdown-checkbox" type="checkbox" disabled="disabled" checked="" data-checkbox-index="%d"></input>`, h.checkboxIndex)), text[4:]...)
h.checkboxIndex++
}
h.Renderer.ListItem(out, text, flags)
} | go | func (h *highlightHTMLRenderer) ListItem(out *bytes.Buffer, text []byte, flags int) {
switch {
case bytes.HasPrefix(text, []byte("[ ] ")):
text = append([]byte(fmt.Sprintf(`<input class="markdown-checkbox" type="checkbox" disabled="disabled" data-checkbox-index="%d"></input>`, h.checkboxIndex)), text[4:]...)
h.checkboxIndex++
case bytes.HasPrefix(text, []byte("[x] ")) || bytes.HasPrefix(text, []byte("[X] ")):
text = append([]byte(fmt.Sprintf(`<input class="markdown-checkbox" type="checkbox" disabled="disabled" checked="" data-checkbox-index="%d"></input>`, h.checkboxIndex)), text[4:]...)
h.checkboxIndex++
}
h.Renderer.ListItem(out, text, flags)
} | [
"func",
"(",
"h",
"*",
"highlightHTMLRenderer",
")",
"ListItem",
"(",
"out",
"*",
"bytes",
".",
"Buffer",
",",
"text",
"[",
"]",
"byte",
",",
"flags",
"int",
")",
"{",
"switch",
"{",
"case",
"bytes",
".",
"HasPrefix",
"(",
"text",
",",
"[",
"]",
"b... | // ListItem overrides the default ListItem render and adds support for GH-style
// checkboxes on service side. For the contents of the list item beyond the
// checkbox prefix, the default Html.ListItem is called.
// This adds a data-checkbox-index attribute that contains the ordinal of the
// checkbox in the rendered Markdown. This can be used by the ui to find the
// reference to the original Markdown code from a rendered HTML. | [
"ListItem",
"overrides",
"the",
"default",
"ListItem",
"render",
"and",
"adds",
"support",
"for",
"GH",
"-",
"style",
"checkboxes",
"on",
"service",
"side",
".",
"For",
"the",
"contents",
"of",
"the",
"list",
"item",
"beyond",
"the",
"checkbox",
"prefix",
"t... | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/rendering/markdown.go#L53-L63 |
13,424 | fabric8-services/fabric8-wit | rendering/markdown.go | BlockCode | func (h highlightHTMLRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string) {
highlighted, err := syntaxhighlight.AsHTML(text)
if err != nil {
h.Renderer.BlockCode(out, text, lang)
} else {
if out.Len() > 0 {
out.WriteByte('\n')
}
// parse out the language names/classes
count := 0
for _, elt := range strings.Fields(lang) {
if elt[0] == '.' {
elt = elt[1:]
}
if len(elt) == 0 {
continue
}
if count == 0 {
out.WriteString("<pre><code class=\"prettyprint language-")
} else {
out.WriteByte(' ')
}
out.Write([]byte(elt)) // attrEscape(out, []byte(elt))
count++
}
if count == 0 {
out.WriteString("<pre><code class=\"prettyprint\">")
} else {
out.WriteString("\">")
}
out.Write(highlighted)
out.WriteString("</code></pre>\n")
}
} | go | func (h highlightHTMLRenderer) BlockCode(out *bytes.Buffer, text []byte, lang string) {
highlighted, err := syntaxhighlight.AsHTML(text)
if err != nil {
h.Renderer.BlockCode(out, text, lang)
} else {
if out.Len() > 0 {
out.WriteByte('\n')
}
// parse out the language names/classes
count := 0
for _, elt := range strings.Fields(lang) {
if elt[0] == '.' {
elt = elt[1:]
}
if len(elt) == 0 {
continue
}
if count == 0 {
out.WriteString("<pre><code class=\"prettyprint language-")
} else {
out.WriteByte(' ')
}
out.Write([]byte(elt)) // attrEscape(out, []byte(elt))
count++
}
if count == 0 {
out.WriteString("<pre><code class=\"prettyprint\">")
} else {
out.WriteString("\">")
}
out.Write(highlighted)
out.WriteString("</code></pre>\n")
}
} | [
"func",
"(",
"h",
"highlightHTMLRenderer",
")",
"BlockCode",
"(",
"out",
"*",
"bytes",
".",
"Buffer",
",",
"text",
"[",
"]",
"byte",
",",
"lang",
"string",
")",
"{",
"highlighted",
",",
"err",
":=",
"syntaxhighlight",
".",
"AsHTML",
"(",
"text",
")",
"... | // BlackCode overrides the standard Html Renderer to add support for prettify of source code within block
// If highlighter fail, normal Html.BlockCode is called | [
"BlackCode",
"overrides",
"the",
"standard",
"Html",
"Renderer",
"to",
"add",
"support",
"for",
"prettify",
"of",
"source",
"code",
"within",
"block",
"If",
"highlighter",
"fail",
"normal",
"Html",
".",
"BlockCode",
"is",
"called"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/rendering/markdown.go#L67-L104 |
13,425 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | ParseSortWorkItemsBy | func ParseSortWorkItemsBy(s *string) (SortWorkItemsBy, error) {
if s == nil {
// this is the default case
// which returns workitems with highest execution order
return SortWorkItemsByDefault, nil
}
var sort SortWorkItemsBy
switch *s {
case "execution":
sort = SortWorkItemsByExecutionAsc
case "-execution":
sort = SortWorkItemsByExecutionDesc
case "created":
sort = SortWorkItemsByCreatedAtAsc
case "-created":
sort = SortWorkItemsByCreatedAtDesc
case "updated":
sort = SortWorkItemsByUpdatedAtAsc
case "-updated":
sort = SortWorkItemsByUpdatedAtDesc
default:
return SortWorkItemsBy(""), errors.NewBadParameterError("sort", *s)
}
return sort, nil
} | go | func ParseSortWorkItemsBy(s *string) (SortWorkItemsBy, error) {
if s == nil {
// this is the default case
// which returns workitems with highest execution order
return SortWorkItemsByDefault, nil
}
var sort SortWorkItemsBy
switch *s {
case "execution":
sort = SortWorkItemsByExecutionAsc
case "-execution":
sort = SortWorkItemsByExecutionDesc
case "created":
sort = SortWorkItemsByCreatedAtAsc
case "-created":
sort = SortWorkItemsByCreatedAtDesc
case "updated":
sort = SortWorkItemsByUpdatedAtAsc
case "-updated":
sort = SortWorkItemsByUpdatedAtDesc
default:
return SortWorkItemsBy(""), errors.NewBadParameterError("sort", *s)
}
return sort, nil
} | [
"func",
"ParseSortWorkItemsBy",
"(",
"s",
"*",
"string",
")",
"(",
"SortWorkItemsBy",
",",
"error",
")",
"{",
"if",
"s",
"==",
"nil",
"{",
"// this is the default case",
"// which returns workitems with highest execution order",
"return",
"SortWorkItemsByDefault",
",",
... | // ParseSortWorkItemsBy parses the string input and returns object of type SortWorkItemsBy
// which can directly be used while querying database to order the output. | [
"ParseSortWorkItemsBy",
"parses",
"the",
"string",
"input",
"and",
"returns",
"object",
"of",
"type",
"SortWorkItemsBy",
"which",
"can",
"directly",
"be",
"used",
"while",
"querying",
"database",
"to",
"order",
"the",
"output",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L62-L87 |
13,426 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | NewWorkItemRepository | func NewWorkItemRepository(db *gorm.DB) *GormWorkItemRepository {
repository := &GormWorkItemRepository{
db: db,
winr: numbersequence.NewWorkItemNumberSequenceRepository(db),
witr: &GormWorkItemTypeRepository{db},
wirr: &GormRevisionRepository{db},
space: space.NewRepository(db),
}
return repository
} | go | func NewWorkItemRepository(db *gorm.DB) *GormWorkItemRepository {
repository := &GormWorkItemRepository{
db: db,
winr: numbersequence.NewWorkItemNumberSequenceRepository(db),
witr: &GormWorkItemTypeRepository{db},
wirr: &GormRevisionRepository{db},
space: space.NewRepository(db),
}
return repository
} | [
"func",
"NewWorkItemRepository",
"(",
"db",
"*",
"gorm",
".",
"DB",
")",
"*",
"GormWorkItemRepository",
"{",
"repository",
":=",
"&",
"GormWorkItemRepository",
"{",
"db",
":",
"db",
",",
"winr",
":",
"numbersequence",
".",
"NewWorkItemNumberSequenceRepository",
"(... | // NewWorkItemRepository creates a GormWorkItemRepository | [
"NewWorkItemRepository",
"creates",
"a",
"GormWorkItemRepository"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L110-L119 |
13,427 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | LoadBatchFromDB | func (r *GormWorkItemRepository) LoadBatchFromDB(ctx context.Context, ids []uuid.UUID) ([]WorkItemStorage, error) {
log.Info(nil, map[string]interface{}{
"wi_ids": ids,
}, "Loading work items")
res := []WorkItemStorage{}
tx := r.db.Model(WorkItemStorage{}).Where("id IN (?)", ids).Find(&res)
if tx.Error != nil {
return nil, errors.NewInternalError(ctx, tx.Error)
}
return res, nil
} | go | func (r *GormWorkItemRepository) LoadBatchFromDB(ctx context.Context, ids []uuid.UUID) ([]WorkItemStorage, error) {
log.Info(nil, map[string]interface{}{
"wi_ids": ids,
}, "Loading work items")
res := []WorkItemStorage{}
tx := r.db.Model(WorkItemStorage{}).Where("id IN (?)", ids).Find(&res)
if tx.Error != nil {
return nil, errors.NewInternalError(ctx, tx.Error)
}
return res, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"LoadBatchFromDB",
"(",
"ctx",
"context",
".",
"Context",
",",
"ids",
"[",
"]",
"uuid",
".",
"UUID",
")",
"(",
"[",
"]",
"WorkItemStorage",
",",
"error",
")",
"{",
"log",
".",
"Info",
"(",
"nil",
... | // LoadBatchFromDB returns the work items using IN query expression. | [
"LoadBatchFromDB",
"returns",
"the",
"work",
"items",
"using",
"IN",
"query",
"expression",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L155-L166 |
13,428 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | LoadByID | func (r *GormWorkItemRepository) LoadByID(ctx context.Context, id uuid.UUID) (*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "loadById"}, time.Now())
res, err := r.LoadFromDB(ctx, id)
if err != nil {
return nil, errs.WithStack(err)
}
wiType, err := r.witr.Load(ctx, res.Type)
if err != nil {
return nil, errors.NewInternalError(ctx, err)
}
return ConvertWorkItemStorageToModel(wiType, res)
} | go | func (r *GormWorkItemRepository) LoadByID(ctx context.Context, id uuid.UUID) (*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "loadById"}, time.Now())
res, err := r.LoadFromDB(ctx, id)
if err != nil {
return nil, errs.WithStack(err)
}
wiType, err := r.witr.Load(ctx, res.Type)
if err != nil {
return nil, errors.NewInternalError(ctx, err)
}
return ConvertWorkItemStorageToModel(wiType, res)
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"LoadByID",
"(",
"ctx",
"context",
".",
"Context",
",",
"id",
"uuid",
".",
"UUID",
")",
"(",
"*",
"WorkItem",
",",
"error",
")",
"{",
"defer",
"goa",
".",
"MeasureSince",
"(",
"[",
"]",
"string",
... | // LoadByID returns the work item for the given id
// returns NotFoundError, ConversionError or InternalError | [
"LoadByID",
"returns",
"the",
"work",
"item",
"for",
"the",
"given",
"id",
"returns",
"NotFoundError",
"ConversionError",
"or",
"InternalError"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L170-L181 |
13,429 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | LoadBatchByID | func (r *GormWorkItemRepository) LoadBatchByID(ctx context.Context, ids []uuid.UUID) ([]*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "loadBatchById"}, time.Now())
res, err := r.LoadBatchFromDB(ctx, ids)
if err != nil {
return nil, errs.WithStack(err)
}
workitems := []*WorkItem{}
for _, ele := range res {
wiType, err := r.witr.Load(ctx, ele.Type)
if err != nil {
log.Error(nil, map[string]interface{}{
"wit_id": ele.Type,
"err": err,
}, "error in loading type from DB")
return nil, errors.NewInternalError(ctx, err)
}
convertedWI, err := ConvertWorkItemStorageToModel(wiType, &ele)
if err != nil {
log.Error(nil, map[string]interface{}{
"wi_id": ele.ID,
"err": err,
}, "error in converting WI")
}
workitems = append(workitems, convertedWI)
}
return workitems, nil
} | go | func (r *GormWorkItemRepository) LoadBatchByID(ctx context.Context, ids []uuid.UUID) ([]*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "loadBatchById"}, time.Now())
res, err := r.LoadBatchFromDB(ctx, ids)
if err != nil {
return nil, errs.WithStack(err)
}
workitems := []*WorkItem{}
for _, ele := range res {
wiType, err := r.witr.Load(ctx, ele.Type)
if err != nil {
log.Error(nil, map[string]interface{}{
"wit_id": ele.Type,
"err": err,
}, "error in loading type from DB")
return nil, errors.NewInternalError(ctx, err)
}
convertedWI, err := ConvertWorkItemStorageToModel(wiType, &ele)
if err != nil {
log.Error(nil, map[string]interface{}{
"wi_id": ele.ID,
"err": err,
}, "error in converting WI")
}
workitems = append(workitems, convertedWI)
}
return workitems, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"LoadBatchByID",
"(",
"ctx",
"context",
".",
"Context",
",",
"ids",
"[",
"]",
"uuid",
".",
"UUID",
")",
"(",
"[",
"]",
"*",
"WorkItem",
",",
"error",
")",
"{",
"defer",
"goa",
".",
"MeasureSince",
... | // LoadBatchByID returns work items for the given ids | [
"LoadBatchByID",
"returns",
"work",
"items",
"for",
"the",
"given",
"ids"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L184-L210 |
13,430 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | Load | func (r *GormWorkItemRepository) Load(ctx context.Context, spaceID uuid.UUID, wiNumber int) (*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "load"}, time.Now())
wiStorage, wiType, err := r.loadWorkItemStorage(ctx, spaceID, wiNumber, false)
if err != nil {
return nil, err
}
return ConvertWorkItemStorageToModel(wiType, wiStorage)
} | go | func (r *GormWorkItemRepository) Load(ctx context.Context, spaceID uuid.UUID, wiNumber int) (*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "load"}, time.Now())
wiStorage, wiType, err := r.loadWorkItemStorage(ctx, spaceID, wiNumber, false)
if err != nil {
return nil, err
}
return ConvertWorkItemStorageToModel(wiType, wiStorage)
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"Load",
"(",
"ctx",
"context",
".",
"Context",
",",
"spaceID",
"uuid",
".",
"UUID",
",",
"wiNumber",
"int",
")",
"(",
"*",
"WorkItem",
",",
"error",
")",
"{",
"defer",
"goa",
".",
"MeasureSince",
"(... | // Load returns the work item for the given spaceID and item id
// returns NotFoundError, ConversionError or InternalError | [
"Load",
"returns",
"the",
"work",
"item",
"for",
"the",
"given",
"spaceID",
"and",
"item",
"id",
"returns",
"NotFoundError",
"ConversionError",
"or",
"InternalError"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L214-L221 |
13,431 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | LookupIDByNamedSpaceAndNumber | func (r *GormWorkItemRepository) LookupIDByNamedSpaceAndNumber(ctx context.Context, ownerName, spaceName string, wiNumber int) (*uuid.UUID, *uuid.UUID, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "lookupIDByNamedSpaceAndNumber"}, time.Now())
log.Debug(nil, map[string]interface{}{
"wi_number": wiNumber,
"space_name": spaceName,
"owner_name": ownerName,
}, "Loading work item")
query := fmt.Sprintf(`select wi.id, wi.space_id from %[1]s wi
join %[2]s s on wi.space_id = s.id
join %[3]s i on s.owner_id = i.id
where lower(i.username) = lower(?) and
lower(s.name) = lower(?) and
wi.number = ? and
s.deleted_at IS NULL
and i.deleted_at IS NULL`,
WorkItemStorage{}.TableName(), space.Space{}.TableName(), account.Identity{}.TableName())
// 'scan' destination must be slice or struct
type Result struct {
WiID uuid.UUID `gorm:"column:id"`
// TODO(xcoulon) SpaceID can be removed once PR for #1452 is merged, as we won't need it anymore in the controller
SpaceID uuid.UUID
}
var result Result
db := r.db.Raw(query, ownerName, spaceName, wiNumber).Scan(&result)
if db.RecordNotFound() {
log.Error(nil, map[string]interface{}{
"wi_number": wiNumber,
"space_name": spaceName,
"owner_name": ownerName,
}, "work item not found")
return nil, nil, errors.NewNotFoundError("work item", strconv.Itoa(wiNumber))
}
if db.Error != nil {
return nil, nil, errors.NewInternalError(ctx, errs.Wrap(db.Error, "error while looking up a work item ID"))
}
log.Debug(ctx, map[string]interface{}{
"wi_number": wiNumber,
"space_name": spaceName,
"owner_name": ownerName,
}, "Matching work item with ID='%s' in space with ID='%s'", result.WiID.String(), result.SpaceID.String())
return &result.WiID, &result.SpaceID, nil
} | go | func (r *GormWorkItemRepository) LookupIDByNamedSpaceAndNumber(ctx context.Context, ownerName, spaceName string, wiNumber int) (*uuid.UUID, *uuid.UUID, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "lookupIDByNamedSpaceAndNumber"}, time.Now())
log.Debug(nil, map[string]interface{}{
"wi_number": wiNumber,
"space_name": spaceName,
"owner_name": ownerName,
}, "Loading work item")
query := fmt.Sprintf(`select wi.id, wi.space_id from %[1]s wi
join %[2]s s on wi.space_id = s.id
join %[3]s i on s.owner_id = i.id
where lower(i.username) = lower(?) and
lower(s.name) = lower(?) and
wi.number = ? and
s.deleted_at IS NULL
and i.deleted_at IS NULL`,
WorkItemStorage{}.TableName(), space.Space{}.TableName(), account.Identity{}.TableName())
// 'scan' destination must be slice or struct
type Result struct {
WiID uuid.UUID `gorm:"column:id"`
// TODO(xcoulon) SpaceID can be removed once PR for #1452 is merged, as we won't need it anymore in the controller
SpaceID uuid.UUID
}
var result Result
db := r.db.Raw(query, ownerName, spaceName, wiNumber).Scan(&result)
if db.RecordNotFound() {
log.Error(nil, map[string]interface{}{
"wi_number": wiNumber,
"space_name": spaceName,
"owner_name": ownerName,
}, "work item not found")
return nil, nil, errors.NewNotFoundError("work item", strconv.Itoa(wiNumber))
}
if db.Error != nil {
return nil, nil, errors.NewInternalError(ctx, errs.Wrap(db.Error, "error while looking up a work item ID"))
}
log.Debug(ctx, map[string]interface{}{
"wi_number": wiNumber,
"space_name": spaceName,
"owner_name": ownerName,
}, "Matching work item with ID='%s' in space with ID='%s'", result.WiID.String(), result.SpaceID.String())
return &result.WiID, &result.SpaceID, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"LookupIDByNamedSpaceAndNumber",
"(",
"ctx",
"context",
".",
"Context",
",",
"ownerName",
",",
"spaceName",
"string",
",",
"wiNumber",
"int",
")",
"(",
"*",
"uuid",
".",
"UUID",
",",
"*",
"uuid",
".",
"... | // LookupIDByNamedSpaceAndNumber returns the work item's ID for the given owner name, space name and item number
// returns NotFoundError, ConversionError or InternalError | [
"LookupIDByNamedSpaceAndNumber",
"returns",
"the",
"work",
"item",
"s",
"ID",
"for",
"the",
"given",
"owner",
"name",
"space",
"name",
"and",
"item",
"number",
"returns",
"NotFoundError",
"ConversionError",
"or",
"InternalError"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L225-L266 |
13,432 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | LoadBottomWorkitem | func (r *GormWorkItemRepository) LoadBottomWorkitem(ctx context.Context, spaceID uuid.UUID) (*WorkItem, error) {
res := WorkItemStorage{}
db := r.db.Model(WorkItemStorage{})
query := fmt.Sprintf("execution_order = (SELECT min(execution_order) FROM %[1]s where space_id=?)",
WorkItemStorage{}.TableName(),
)
db = db.Where(query, spaceID).First(&res)
if db.Error != nil && !db.RecordNotFound() {
return nil, errors.NewInternalError(ctx, db.Error)
}
wiType, err := r.witr.Load(ctx, res.Type)
if err != nil {
return nil, errors.NewInternalError(ctx, err)
}
return ConvertWorkItemStorageToModel(wiType, &res)
} | go | func (r *GormWorkItemRepository) LoadBottomWorkitem(ctx context.Context, spaceID uuid.UUID) (*WorkItem, error) {
res := WorkItemStorage{}
db := r.db.Model(WorkItemStorage{})
query := fmt.Sprintf("execution_order = (SELECT min(execution_order) FROM %[1]s where space_id=?)",
WorkItemStorage{}.TableName(),
)
db = db.Where(query, spaceID).First(&res)
if db.Error != nil && !db.RecordNotFound() {
return nil, errors.NewInternalError(ctx, db.Error)
}
wiType, err := r.witr.Load(ctx, res.Type)
if err != nil {
return nil, errors.NewInternalError(ctx, err)
}
return ConvertWorkItemStorageToModel(wiType, &res)
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"LoadBottomWorkitem",
"(",
"ctx",
"context",
".",
"Context",
",",
"spaceID",
"uuid",
".",
"UUID",
")",
"(",
"*",
"WorkItem",
",",
"error",
")",
"{",
"res",
":=",
"WorkItemStorage",
"{",
"}",
"\n",
"db... | // LoadBottomWorkitem returns bottom work item of the list. Bottom most workitem has the lowest order.
// returns NotFoundError, ConversionError or InternalError | [
"LoadBottomWorkitem",
"returns",
"bottom",
"work",
"item",
"of",
"the",
"list",
".",
"Bottom",
"most",
"workitem",
"has",
"the",
"lowest",
"order",
".",
"returns",
"NotFoundError",
"ConversionError",
"or",
"InternalError"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L324-L339 |
13,433 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | LoadHighestOrder | func (r *GormWorkItemRepository) LoadHighestOrder(ctx context.Context, spaceID uuid.UUID) (float64, error) {
res := WorkItemStorage{}
db := r.db.Model(WorkItemStorage{})
query := fmt.Sprintf("execution_order = (SELECT max(execution_order) FROM %[1]s where space_id=?)",
WorkItemStorage{}.TableName(),
)
db = db.Where(query, spaceID).First(&res)
if db.Error != nil && !db.RecordNotFound() {
return 0, errors.NewInternalError(ctx, db.Error)
}
order, err := strconv.ParseFloat(fmt.Sprintf("%v", res.ExecutionOrder), 64)
if err != nil {
return 0, errors.NewInternalError(ctx, err)
}
return order, nil
} | go | func (r *GormWorkItemRepository) LoadHighestOrder(ctx context.Context, spaceID uuid.UUID) (float64, error) {
res := WorkItemStorage{}
db := r.db.Model(WorkItemStorage{})
query := fmt.Sprintf("execution_order = (SELECT max(execution_order) FROM %[1]s where space_id=?)",
WorkItemStorage{}.TableName(),
)
db = db.Where(query, spaceID).First(&res)
if db.Error != nil && !db.RecordNotFound() {
return 0, errors.NewInternalError(ctx, db.Error)
}
order, err := strconv.ParseFloat(fmt.Sprintf("%v", res.ExecutionOrder), 64)
if err != nil {
return 0, errors.NewInternalError(ctx, err)
}
return order, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"LoadHighestOrder",
"(",
"ctx",
"context",
".",
"Context",
",",
"spaceID",
"uuid",
".",
"UUID",
")",
"(",
"float64",
",",
"error",
")",
"{",
"res",
":=",
"WorkItemStorage",
"{",
"}",
"\n",
"db",
":=",... | // LoadHighestOrder returns the highest execution order in the given space | [
"LoadHighestOrder",
"returns",
"the",
"highest",
"execution",
"order",
"in",
"the",
"given",
"space"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L342-L357 |
13,434 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | Delete | func (r *GormWorkItemRepository) Delete(ctx context.Context, workitemID uuid.UUID, suppressorID uuid.UUID) error {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "delete"}, time.Now())
var workItem = WorkItemStorage{}
workItem.ID = workitemID
// retrieve the current version of the work item to delete
r.db.Select("id, version, type").Where("id = ?", workitemID).Find(&workItem)
// delete the work item
tx := r.db.Delete(workItem)
if err := tx.Error; err != nil {
return errors.NewInternalError(ctx, err)
}
if tx.RowsAffected == 0 {
return errors.NewNotFoundError("work item", workitemID.String())
}
// store a revision of the deleted work item
_, err := r.wirr.Create(context.Background(), suppressorID, RevisionTypeDelete, workItem)
if err != nil {
return errs.Wrapf(err, "error while deleting work item")
}
log.Debug(ctx, map[string]interface{}{"wi_id": workitemID}, "Work item deleted successfully!")
return nil
} | go | func (r *GormWorkItemRepository) Delete(ctx context.Context, workitemID uuid.UUID, suppressorID uuid.UUID) error {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "delete"}, time.Now())
var workItem = WorkItemStorage{}
workItem.ID = workitemID
// retrieve the current version of the work item to delete
r.db.Select("id, version, type").Where("id = ?", workitemID).Find(&workItem)
// delete the work item
tx := r.db.Delete(workItem)
if err := tx.Error; err != nil {
return errors.NewInternalError(ctx, err)
}
if tx.RowsAffected == 0 {
return errors.NewNotFoundError("work item", workitemID.String())
}
// store a revision of the deleted work item
_, err := r.wirr.Create(context.Background(), suppressorID, RevisionTypeDelete, workItem)
if err != nil {
return errs.Wrapf(err, "error while deleting work item")
}
log.Debug(ctx, map[string]interface{}{"wi_id": workitemID}, "Work item deleted successfully!")
return nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
",",
"workitemID",
"uuid",
".",
"UUID",
",",
"suppressorID",
"uuid",
".",
"UUID",
")",
"error",
"{",
"defer",
"goa",
".",
"MeasureSince",
"(",
"[",
"]"... | // Delete deletes the work item with the given id
// returns NotFoundError or InternalError | [
"Delete",
"deletes",
"the",
"work",
"item",
"with",
"the",
"given",
"id",
"returns",
"NotFoundError",
"or",
"InternalError"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L361-L382 |
13,435 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | FindFirstItem | func (r *GormWorkItemRepository) FindFirstItem(ctx context.Context, spaceID uuid.UUID, id uuid.UUID) (*float64, error) {
res := WorkItemStorage{}
tx := r.db.Model(WorkItemStorage{}).Where("id=? and space_id=?", id, spaceID).First(&res)
if tx.RecordNotFound() {
return nil, errors.NewNotFoundError("work item", id.String())
}
if tx.Error != nil {
return nil, errors.NewInternalError(ctx, tx.Error)
}
return &res.ExecutionOrder, nil
} | go | func (r *GormWorkItemRepository) FindFirstItem(ctx context.Context, spaceID uuid.UUID, id uuid.UUID) (*float64, error) {
res := WorkItemStorage{}
tx := r.db.Model(WorkItemStorage{}).Where("id=? and space_id=?", id, spaceID).First(&res)
if tx.RecordNotFound() {
return nil, errors.NewNotFoundError("work item", id.String())
}
if tx.Error != nil {
return nil, errors.NewInternalError(ctx, tx.Error)
}
return &res.ExecutionOrder, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"FindFirstItem",
"(",
"ctx",
"context",
".",
"Context",
",",
"spaceID",
"uuid",
".",
"UUID",
",",
"id",
"uuid",
".",
"UUID",
")",
"(",
"*",
"float64",
",",
"error",
")",
"{",
"res",
":=",
"WorkItemS... | // FindFirstItem returns the order of the target workitem | [
"FindFirstItem",
"returns",
"the",
"order",
"of",
"the",
"target",
"workitem"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L425-L435 |
13,436 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | ConvertWorkItemStorageToModel | func ConvertWorkItemStorageToModel(wiType *WorkItemType, wi *WorkItemStorage) (*WorkItem, error) {
result, err := wiType.ConvertWorkItemStorageToModel(*wi)
if err != nil {
return nil, errors.NewConversionError(err.Error())
}
if _, ok := wiType.Fields[SystemCreatedAt]; ok {
result.Fields[SystemCreatedAt] = wi.CreatedAt
}
if _, ok := wiType.Fields[SystemUpdatedAt]; ok {
result.Fields[SystemUpdatedAt] = wi.UpdatedAt
}
if _, ok := wiType.Fields[SystemOrder]; ok {
result.Fields[SystemOrder] = wi.ExecutionOrder
}
if _, ok := wiType.Fields[SystemNumber]; ok {
result.Fields[SystemNumber] = wi.Number
}
return result, nil
} | go | func ConvertWorkItemStorageToModel(wiType *WorkItemType, wi *WorkItemStorage) (*WorkItem, error) {
result, err := wiType.ConvertWorkItemStorageToModel(*wi)
if err != nil {
return nil, errors.NewConversionError(err.Error())
}
if _, ok := wiType.Fields[SystemCreatedAt]; ok {
result.Fields[SystemCreatedAt] = wi.CreatedAt
}
if _, ok := wiType.Fields[SystemUpdatedAt]; ok {
result.Fields[SystemUpdatedAt] = wi.UpdatedAt
}
if _, ok := wiType.Fields[SystemOrder]; ok {
result.Fields[SystemOrder] = wi.ExecutionOrder
}
if _, ok := wiType.Fields[SystemNumber]; ok {
result.Fields[SystemNumber] = wi.Number
}
return result, nil
} | [
"func",
"ConvertWorkItemStorageToModel",
"(",
"wiType",
"*",
"WorkItemType",
",",
"wi",
"*",
"WorkItemStorage",
")",
"(",
"*",
"WorkItem",
",",
"error",
")",
"{",
"result",
",",
"err",
":=",
"wiType",
".",
"ConvertWorkItemStorageToModel",
"(",
"*",
"wi",
")",
... | // ConvertWorkItemStorageToModel convert work item model to app WI | [
"ConvertWorkItemStorageToModel",
"convert",
"work",
"item",
"model",
"to",
"app",
"WI"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L766-L785 |
13,437 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | Count | func (r *GormWorkItemRepository) Count(ctx context.Context, spaceID uuid.UUID, criteria criteria.Expression) (int, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "count"}, time.Now())
where, parameters, joins, compileError := Compile(criteria)
if compileError != nil {
return 0, errors.NewBadParameterError("expression", criteria)
}
where = where + " AND space_id = ?"
parameters = append(parameters, spaceID)
var count int
db := r.db.Model(&WorkItemStorage{}).Where(where, parameters...)
for _, j := range joins {
if err := j.Validate(db); err != nil {
log.Error(ctx, map[string]interface{}{"expression": criteria, "err": err}, "table join not valid")
return 0, errors.NewBadParameterError("expression", criteria).Expected("valid table join")
}
db = db.Joins(j.GetJoinExpression())
}
db = db.Count(&count)
if db.Error != nil {
return 0, errors.NewInternalError(ctx, errs.Wrapf(db.Error, "failed to count work items that match this criteria: %s", criteria))
}
return count, nil
} | go | func (r *GormWorkItemRepository) Count(ctx context.Context, spaceID uuid.UUID, criteria criteria.Expression) (int, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "count"}, time.Now())
where, parameters, joins, compileError := Compile(criteria)
if compileError != nil {
return 0, errors.NewBadParameterError("expression", criteria)
}
where = where + " AND space_id = ?"
parameters = append(parameters, spaceID)
var count int
db := r.db.Model(&WorkItemStorage{}).Where(where, parameters...)
for _, j := range joins {
if err := j.Validate(db); err != nil {
log.Error(ctx, map[string]interface{}{"expression": criteria, "err": err}, "table join not valid")
return 0, errors.NewBadParameterError("expression", criteria).Expected("valid table join")
}
db = db.Joins(j.GetJoinExpression())
}
db = db.Count(&count)
if db.Error != nil {
return 0, errors.NewInternalError(ctx, errs.Wrapf(db.Error, "failed to count work items that match this criteria: %s", criteria))
}
return count, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"Count",
"(",
"ctx",
"context",
".",
"Context",
",",
"spaceID",
"uuid",
".",
"UUID",
",",
"criteria",
"criteria",
".",
"Expression",
")",
"(",
"int",
",",
"error",
")",
"{",
"defer",
"goa",
".",
"Me... | // Count returns the amount of work item that satisfy the given criteria.Expression | [
"Count",
"returns",
"the",
"amount",
"of",
"work",
"item",
"that",
"satisfy",
"the",
"given",
"criteria",
".",
"Expression"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L908-L932 |
13,438 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | GetCountsPerIteration | func (r *GormWorkItemRepository) GetCountsPerIteration(ctx context.Context, spaceID uuid.UUID) (map[string]WICountsPerIteration, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "getCountsPerIteration"}, time.Now())
db := r.db.Model(&iteration.Iteration{}).Where("space_id = ?", spaceID)
if db.Error != nil {
return nil, errors.NewInternalError(ctx, db.Error)
}
wiMap, err := r.getAllIterationWithCounts(ctx, db, spaceID)
if err != nil {
return nil, err
}
countsMap, err := r.getFinalCountAddingChild(ctx, db, spaceID, wiMap)
if err != nil {
return nil, err
}
return countsMap, nil
} | go | func (r *GormWorkItemRepository) GetCountsPerIteration(ctx context.Context, spaceID uuid.UUID) (map[string]WICountsPerIteration, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "getCountsPerIteration"}, time.Now())
db := r.db.Model(&iteration.Iteration{}).Where("space_id = ?", spaceID)
if db.Error != nil {
return nil, errors.NewInternalError(ctx, db.Error)
}
wiMap, err := r.getAllIterationWithCounts(ctx, db, spaceID)
if err != nil {
return nil, err
}
countsMap, err := r.getFinalCountAddingChild(ctx, db, spaceID, wiMap)
if err != nil {
return nil, err
}
return countsMap, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"GetCountsPerIteration",
"(",
"ctx",
"context",
".",
"Context",
",",
"spaceID",
"uuid",
".",
"UUID",
")",
"(",
"map",
"[",
"string",
"]",
"WICountsPerIteration",
",",
"error",
")",
"{",
"defer",
"goa",
... | // GetCountsPerIteration counts WIs including iteration-children and returns a map of iterationID->WICountsPerIteration | [
"GetCountsPerIteration",
"counts",
"WIs",
"including",
"iteration",
"-",
"children",
"and",
"returns",
"a",
"map",
"of",
"iterationID",
"-",
">",
"WICountsPerIteration"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L1062-L1079 |
13,439 | fabric8-services/fabric8-wit | workitem/workitem_repository.go | LoadByIteration | func (r *GormWorkItemRepository) LoadByIteration(ctx context.Context, iterationID uuid.UUID) ([]*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "loadByIteration"}, time.Now())
log.Info(nil, map[string]interface{}{
"itr_id": iterationID,
}, "Loading work items for iteration")
res := []WorkItemStorage{}
filter := fmt.Sprintf(`fields @> '{"%s":"%s"}'`, SystemIteration, iterationID)
tx := r.db.Model(WorkItemStorage{}).Where(filter).Find(&res)
if tx.Error != nil {
return nil, errors.NewInternalError(ctx, tx.Error)
}
workitems := []*WorkItem{}
for _, ele := range res {
wiType, err := r.witr.Load(ctx, ele.Type)
if err != nil {
log.Error(nil, map[string]interface{}{
"wit_id": ele.Type,
"err": err,
}, "error in loading type from DB")
return nil, errors.NewInternalError(ctx, err)
}
convertedWI, err := ConvertWorkItemStorageToModel(wiType, &ele)
if err != nil {
log.Error(nil, map[string]interface{}{
"wi_id": ele.ID,
"err": err,
}, "error in converting WI")
return nil, errs.Wrap(err, "error when converting WI")
}
workitems = append(workitems, convertedWI)
}
return workitems, nil
} | go | func (r *GormWorkItemRepository) LoadByIteration(ctx context.Context, iterationID uuid.UUID) ([]*WorkItem, error) {
defer goa.MeasureSince([]string{"goa", "db", "workitem", "loadByIteration"}, time.Now())
log.Info(nil, map[string]interface{}{
"itr_id": iterationID,
}, "Loading work items for iteration")
res := []WorkItemStorage{}
filter := fmt.Sprintf(`fields @> '{"%s":"%s"}'`, SystemIteration, iterationID)
tx := r.db.Model(WorkItemStorage{}).Where(filter).Find(&res)
if tx.Error != nil {
return nil, errors.NewInternalError(ctx, tx.Error)
}
workitems := []*WorkItem{}
for _, ele := range res {
wiType, err := r.witr.Load(ctx, ele.Type)
if err != nil {
log.Error(nil, map[string]interface{}{
"wit_id": ele.Type,
"err": err,
}, "error in loading type from DB")
return nil, errors.NewInternalError(ctx, err)
}
convertedWI, err := ConvertWorkItemStorageToModel(wiType, &ele)
if err != nil {
log.Error(nil, map[string]interface{}{
"wi_id": ele.ID,
"err": err,
}, "error in converting WI")
return nil, errs.Wrap(err, "error when converting WI")
}
workitems = append(workitems, convertedWI)
}
return workitems, nil
} | [
"func",
"(",
"r",
"*",
"GormWorkItemRepository",
")",
"LoadByIteration",
"(",
"ctx",
"context",
".",
"Context",
",",
"iterationID",
"uuid",
".",
"UUID",
")",
"(",
"[",
"]",
"*",
"WorkItem",
",",
"error",
")",
"{",
"defer",
"goa",
".",
"MeasureSince",
"("... | // LoadByIteration returns the list of work items belongs to given iteration | [
"LoadByIteration",
"returns",
"the",
"list",
"of",
"work",
"items",
"belongs",
"to",
"given",
"iteration"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_repository.go#L1145-L1178 |
13,440 | fabric8-services/fabric8-wit | controller/namedspaces.go | NewNamedspacesController | func NewNamedspacesController(service *goa.Service, db application.DB) *NamedspacesController {
return &NamedspacesController{Controller: service.NewController("NamedspacesController"), db: db}
} | go | func NewNamedspacesController(service *goa.Service, db application.DB) *NamedspacesController {
return &NamedspacesController{Controller: service.NewController("NamedspacesController"), db: db}
} | [
"func",
"NewNamedspacesController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"db",
"application",
".",
"DB",
")",
"*",
"NamedspacesController",
"{",
"return",
"&",
"NamedspacesController",
"{",
"Controller",
":",
"service",
".",
"NewController",
"(",
"\"... | // NewNamedspacesController creates a namedspaces controller. | [
"NewNamedspacesController",
"creates",
"a",
"namedspaces",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/namedspaces.go#L23-L25 |
13,441 | fabric8-services/fabric8-wit | workitem/workitem_storage.go | Equal | func (wi WorkItemStorage) Equal(u convert.Equaler) bool {
other, ok := u.(WorkItemStorage)
if !ok {
return false
}
if !convert.CascadeEqual(wi.Lifecycle, other.Lifecycle) {
return false
}
if wi.Number != other.Number {
return false
}
if wi.Type != other.Type {
return false
}
if wi.ID != other.ID {
return false
}
if wi.Version != other.Version {
return false
}
if wi.ExecutionOrder != other.ExecutionOrder {
return false
}
if wi.Number != other.Number {
return false
}
if wi.SpaceID != other.SpaceID {
return false
}
if !reflect.DeepEqual(wi.RelationShipsChangedAt, other.RelationShipsChangedAt) {
return false
}
return convert.CascadeEqual(wi.Fields, other.Fields)
} | go | func (wi WorkItemStorage) Equal(u convert.Equaler) bool {
other, ok := u.(WorkItemStorage)
if !ok {
return false
}
if !convert.CascadeEqual(wi.Lifecycle, other.Lifecycle) {
return false
}
if wi.Number != other.Number {
return false
}
if wi.Type != other.Type {
return false
}
if wi.ID != other.ID {
return false
}
if wi.Version != other.Version {
return false
}
if wi.ExecutionOrder != other.ExecutionOrder {
return false
}
if wi.Number != other.Number {
return false
}
if wi.SpaceID != other.SpaceID {
return false
}
if !reflect.DeepEqual(wi.RelationShipsChangedAt, other.RelationShipsChangedAt) {
return false
}
return convert.CascadeEqual(wi.Fields, other.Fields)
} | [
"func",
"(",
"wi",
"WorkItemStorage",
")",
"Equal",
"(",
"u",
"convert",
".",
"Equaler",
")",
"bool",
"{",
"other",
",",
"ok",
":=",
"u",
".",
"(",
"WorkItemStorage",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"!",
... | // Equal returns true if two WorkItem objects are equal; otherwise false is returned. | [
"Equal",
"returns",
"true",
"if",
"two",
"WorkItem",
"objects",
"are",
"equal",
";",
"otherwise",
"false",
"is",
"returned",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_storage.go#L50-L83 |
13,442 | fabric8-services/fabric8-wit | workitem/workitem_storage.go | ParseWorkItemIDToUint64 | func ParseWorkItemIDToUint64(wiIDStr string) (uint64, error) {
wiID, err := strconv.ParseUint(wiIDStr, 10, 64)
if err != nil {
return 0, errors.NewNotFoundError("work item ID", wiIDStr)
}
return wiID, nil
} | go | func ParseWorkItemIDToUint64(wiIDStr string) (uint64, error) {
wiID, err := strconv.ParseUint(wiIDStr, 10, 64)
if err != nil {
return 0, errors.NewNotFoundError("work item ID", wiIDStr)
}
return wiID, nil
} | [
"func",
"ParseWorkItemIDToUint64",
"(",
"wiIDStr",
"string",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"wiID",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"wiIDStr",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // ParseWorkItemIDToUint64 does what it says | [
"ParseWorkItemIDToUint64",
"does",
"what",
"it",
"says"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitem_storage.go#L98-L104 |
13,443 | fabric8-services/fabric8-wit | migration/migration.go | MigrateToNextVersion | func MigrateToNextVersion(tx *sql.Tx, nextVersion *int64, m Migrations, catalog string) error {
// Obtain exclusive transaction level advisory that doesn't depend on any table.
// Once obtained, the lock is held for the remainder of the current transaction.
// (There is no UNLOCK TABLE command; locks are always released at transaction end.)
if _, err := tx.Exec("SELECT pg_advisory_xact_lock($1)", AdvisoryLockID); err != nil {
return errs.Wrapf(err, "failed to acquire lock: %s\n", AdvisoryLockID)
}
// Determine current version and adjust the outmost loop
// iterator variable "version"
currentVersion, err := getCurrentVersion(tx, catalog)
if err != nil {
return errs.WithStack(err)
}
*nextVersion = currentVersion + 1
if *nextVersion >= int64(len(m)) {
// No further updates to apply (this is NOT an error)
log.Info(nil, map[string]interface{}{
"next_version": *nextVersion,
"current_version": currentVersion,
}, "Current version %d. Nothing to update.", currentVersion)
return nil
}
log.Info(nil, map[string]interface{}{
"next_version": *nextVersion,
"current_version": currentVersion,
}, "Attempt to update DB to version %v", *nextVersion)
// Apply all the updates of the next version
for j := range m[*nextVersion] {
if err := m[*nextVersion][j](tx); err != nil {
return errs.Errorf("failed to execute migration of step %d of version %d: %s\n", j, *nextVersion, err)
}
}
if _, err := tx.Exec("INSERT INTO version(version) VALUES($1)", *nextVersion); err != nil {
return errs.Errorf("failed to update DB to version %d: %s\n", *nextVersion, err)
}
log.Info(nil, map[string]interface{}{
"next_version": *nextVersion,
"current_version": currentVersion,
}, "Successfully updated DB to version %v", *nextVersion)
return nil
} | go | func MigrateToNextVersion(tx *sql.Tx, nextVersion *int64, m Migrations, catalog string) error {
// Obtain exclusive transaction level advisory that doesn't depend on any table.
// Once obtained, the lock is held for the remainder of the current transaction.
// (There is no UNLOCK TABLE command; locks are always released at transaction end.)
if _, err := tx.Exec("SELECT pg_advisory_xact_lock($1)", AdvisoryLockID); err != nil {
return errs.Wrapf(err, "failed to acquire lock: %s\n", AdvisoryLockID)
}
// Determine current version and adjust the outmost loop
// iterator variable "version"
currentVersion, err := getCurrentVersion(tx, catalog)
if err != nil {
return errs.WithStack(err)
}
*nextVersion = currentVersion + 1
if *nextVersion >= int64(len(m)) {
// No further updates to apply (this is NOT an error)
log.Info(nil, map[string]interface{}{
"next_version": *nextVersion,
"current_version": currentVersion,
}, "Current version %d. Nothing to update.", currentVersion)
return nil
}
log.Info(nil, map[string]interface{}{
"next_version": *nextVersion,
"current_version": currentVersion,
}, "Attempt to update DB to version %v", *nextVersion)
// Apply all the updates of the next version
for j := range m[*nextVersion] {
if err := m[*nextVersion][j](tx); err != nil {
return errs.Errorf("failed to execute migration of step %d of version %d: %s\n", j, *nextVersion, err)
}
}
if _, err := tx.Exec("INSERT INTO version(version) VALUES($1)", *nextVersion); err != nil {
return errs.Errorf("failed to update DB to version %d: %s\n", *nextVersion, err)
}
log.Info(nil, map[string]interface{}{
"next_version": *nextVersion,
"current_version": currentVersion,
}, "Successfully updated DB to version %v", *nextVersion)
return nil
} | [
"func",
"MigrateToNextVersion",
"(",
"tx",
"*",
"sql",
".",
"Tx",
",",
"nextVersion",
"*",
"int64",
",",
"m",
"Migrations",
",",
"catalog",
"string",
")",
"error",
"{",
"// Obtain exclusive transaction level advisory that doesn't depend on any table.",
"// Once obtained, ... | // MigrateToNextVersion migrates the database to the nextVersion.
// If the database is already at nextVersion or higher, the nextVersion
// will be set to the actual next version. | [
"MigrateToNextVersion",
"migrates",
"the",
"database",
"to",
"the",
"nextVersion",
".",
"If",
"the",
"database",
"is",
"already",
"at",
"nextVersion",
"or",
"higher",
"the",
"nextVersion",
"will",
"be",
"set",
"to",
"the",
"actual",
"next",
"version",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/migration/migration.go#L545-L591 |
13,444 | fabric8-services/fabric8-wit | migration/migration.go | getCurrentVersion | func getCurrentVersion(db *sql.Tx, catalog string) (int64, error) {
query := `SELECT EXISTS(
SELECT 1 FROM information_schema.tables
WHERE table_catalog=$1
AND table_name='version')`
row := db.QueryRow(query, catalog)
var exists bool
if err := row.Scan(&exists); err != nil {
return -1, errs.Errorf(`failed to scan if table "version" exists: %s\n`, err)
}
if !exists {
// table doesn't exist
return -1, nil
}
row = db.QueryRow("SELECT max(version) as current FROM version")
var current int64 = -1
if err := row.Scan(¤t); err != nil {
return -1, errs.Errorf(`failed to scan max version in table "version": %s\n`, err)
}
return current, nil
} | go | func getCurrentVersion(db *sql.Tx, catalog string) (int64, error) {
query := `SELECT EXISTS(
SELECT 1 FROM information_schema.tables
WHERE table_catalog=$1
AND table_name='version')`
row := db.QueryRow(query, catalog)
var exists bool
if err := row.Scan(&exists); err != nil {
return -1, errs.Errorf(`failed to scan if table "version" exists: %s\n`, err)
}
if !exists {
// table doesn't exist
return -1, nil
}
row = db.QueryRow("SELECT max(version) as current FROM version")
var current int64 = -1
if err := row.Scan(¤t); err != nil {
return -1, errs.Errorf(`failed to scan max version in table "version": %s\n`, err)
}
return current, nil
} | [
"func",
"getCurrentVersion",
"(",
"db",
"*",
"sql",
".",
"Tx",
",",
"catalog",
"string",
")",
"(",
"int64",
",",
"error",
")",
"{",
"query",
":=",
"`SELECT EXISTS(\n\t\t\t\tSELECT 1 FROM information_schema.tables\n\t\t\t\tWHERE table_catalog=$1\n\t\t\t\tAND table_name='versio... | // getCurrentVersion returns the highest version from the version
// table or -1 if that table does not exist.
//
// Returning -1 simplifies the logic of the migration process because
// the next version is always the current version + 1 which results
// in -1 + 1 = 0 which is exactly what we want as the first version. | [
"getCurrentVersion",
"returns",
"the",
"highest",
"version",
"from",
"the",
"version",
"table",
"or",
"-",
"1",
"if",
"that",
"table",
"does",
"not",
"exist",
".",
"Returning",
"-",
"1",
"simplifies",
"the",
"logic",
"of",
"the",
"migration",
"process",
"bec... | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/migration/migration.go#L599-L624 |
13,445 | fabric8-services/fabric8-wit | workitem/json_storage.go | Validate | func (j *FieldDefinitions) Validate() error {
if j == nil {
return errs.New("fields not defined")
}
for name, field := range *j {
if err := field.Validate(); err != nil {
return errs.Wrapf(err, "failed to validate field %s", name)
}
}
return nil
} | go | func (j *FieldDefinitions) Validate() error {
if j == nil {
return errs.New("fields not defined")
}
for name, field := range *j {
if err := field.Validate(); err != nil {
return errs.Wrapf(err, "failed to validate field %s", name)
}
}
return nil
} | [
"func",
"(",
"j",
"*",
"FieldDefinitions",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"j",
"==",
"nil",
"{",
"return",
"errs",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"name",
",",
"field",
":=",
"range",
"*",
"j",
"{",
"if... | // Validate checks that each field definition is valid | [
"Validate",
"checks",
"that",
"each",
"field",
"definition",
"is",
"valid"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/json_storage.go#L73-L83 |
13,446 | fabric8-services/fabric8-wit | controller/endpoints.go | NewEndpointsController | func NewEndpointsController(service *goa.Service) *EndpointsController {
return &EndpointsController{
Controller: service.NewController("EndpointsController"),
FileHandler: workingFileFetcher{},
}
} | go | func NewEndpointsController(service *goa.Service) *EndpointsController {
return &EndpointsController{
Controller: service.NewController("EndpointsController"),
FileHandler: workingFileFetcher{},
}
} | [
"func",
"NewEndpointsController",
"(",
"service",
"*",
"goa",
".",
"Service",
")",
"*",
"EndpointsController",
"{",
"return",
"&",
"EndpointsController",
"{",
"Controller",
":",
"service",
".",
"NewController",
"(",
"\"",
"\"",
")",
",",
"FileHandler",
":",
"w... | // NewEndpointsController creates an endpoints controller. | [
"NewEndpointsController",
"creates",
"an",
"endpoints",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/endpoints.go#L47-L52 |
13,447 | fabric8-services/fabric8-wit | controller/endpoints.go | getEndpoints | func getEndpoints(ctx *app.ListEndpointsContext, fileHandler asseter) (*app.Endpoints, error) {
// Get an unmarshal swagger specification
swaggerJSON, err := fileHandler.Asset(embeddedSwaggerSpecFile)
if err != nil {
// TODO(tinakurian): fix error handling
return nil, errors.NewNotFoundError("file", embeddedSwaggerSpecFile)
}
var result map[string]interface{}
err = json.Unmarshal(swaggerJSON, &result)
if err != nil {
return nil, errs.Wrapf(err, `unable to unmarshal the file with id "%s"`, embeddedSwaggerSpecFile)
}
// Get and iterate over paths from swagger specification.
swaggerPaths, ok := result["paths"]
if !ok {
return nil, errors.NewInternalErrorFromString(`failed to find field "paths" in swagger specification`)
}
swaggerPathz, ok := swaggerPaths.(map[string]interface{})
if !ok {
return nil, errors.NewInternalErrorFromString(`unable to assert concrete type map for field "paths" in swagger specification`)
}
basePathObj, ok := result["basePath"]
if !ok {
return nil, errors.NewInternalErrorFromString(`failed to find field "basePath" in swagger specification`)
}
basePath, ok := basePathObj.(string)
if !ok {
return nil, errors.NewInternalErrorFromString(`unable to assert concrete type string for field "basePath" in swagger specification`)
}
absoluteBasePath := rest.AbsoluteURL(ctx.Request, basePath)
// the namedPaths map stores paths as key and URLs as values
namedPaths := make(map[string]interface{})
for path, swaggerPath := range swaggerPathz {
// Currently not supporting endpoints that contain parameters.
if !strings.Contains(path, "{") {
key := path
pathsObj, ok := swaggerPath.(map[string]interface{})
if !ok {
return nil, errors.NewInternalErrorFromString("unable to assert concrete type map for field `paths` in swagger specification")
}
// Get the x-tag value. If the tag exists, use it as path name.
xtagObj, ok := pathsObj["x-tag"]
if ok {
xtag, ok := xtagObj.(string)
if !ok {
return nil, errors.NewInternalErrorFromString("unable to assert concrete type string for field `x-tag` in swagger specification")
}
key = xtag
}
// cleanup the key to conform to JSONAPI member names
key = jsonapi.FormatMemberName(key)
// Set the related field and link objects for each name.
if key != "" {
namedPaths[key] = map[string]interface{}{
"links": map[string]string{
"related": absoluteBasePath + path,
},
}
}
}
}
return &app.Endpoints{
Type: "endpoints",
ID: uuid.NewV4(),
Relationships: namedPaths,
Links: &app.GenericLinks{
Self: ptr.String(absoluteBasePath),
},
}, nil
} | go | func getEndpoints(ctx *app.ListEndpointsContext, fileHandler asseter) (*app.Endpoints, error) {
// Get an unmarshal swagger specification
swaggerJSON, err := fileHandler.Asset(embeddedSwaggerSpecFile)
if err != nil {
// TODO(tinakurian): fix error handling
return nil, errors.NewNotFoundError("file", embeddedSwaggerSpecFile)
}
var result map[string]interface{}
err = json.Unmarshal(swaggerJSON, &result)
if err != nil {
return nil, errs.Wrapf(err, `unable to unmarshal the file with id "%s"`, embeddedSwaggerSpecFile)
}
// Get and iterate over paths from swagger specification.
swaggerPaths, ok := result["paths"]
if !ok {
return nil, errors.NewInternalErrorFromString(`failed to find field "paths" in swagger specification`)
}
swaggerPathz, ok := swaggerPaths.(map[string]interface{})
if !ok {
return nil, errors.NewInternalErrorFromString(`unable to assert concrete type map for field "paths" in swagger specification`)
}
basePathObj, ok := result["basePath"]
if !ok {
return nil, errors.NewInternalErrorFromString(`failed to find field "basePath" in swagger specification`)
}
basePath, ok := basePathObj.(string)
if !ok {
return nil, errors.NewInternalErrorFromString(`unable to assert concrete type string for field "basePath" in swagger specification`)
}
absoluteBasePath := rest.AbsoluteURL(ctx.Request, basePath)
// the namedPaths map stores paths as key and URLs as values
namedPaths := make(map[string]interface{})
for path, swaggerPath := range swaggerPathz {
// Currently not supporting endpoints that contain parameters.
if !strings.Contains(path, "{") {
key := path
pathsObj, ok := swaggerPath.(map[string]interface{})
if !ok {
return nil, errors.NewInternalErrorFromString("unable to assert concrete type map for field `paths` in swagger specification")
}
// Get the x-tag value. If the tag exists, use it as path name.
xtagObj, ok := pathsObj["x-tag"]
if ok {
xtag, ok := xtagObj.(string)
if !ok {
return nil, errors.NewInternalErrorFromString("unable to assert concrete type string for field `x-tag` in swagger specification")
}
key = xtag
}
// cleanup the key to conform to JSONAPI member names
key = jsonapi.FormatMemberName(key)
// Set the related field and link objects for each name.
if key != "" {
namedPaths[key] = map[string]interface{}{
"links": map[string]string{
"related": absoluteBasePath + path,
},
}
}
}
}
return &app.Endpoints{
Type: "endpoints",
ID: uuid.NewV4(),
Relationships: namedPaths,
Links: &app.GenericLinks{
Self: ptr.String(absoluteBasePath),
},
}, nil
} | [
"func",
"getEndpoints",
"(",
"ctx",
"*",
"app",
".",
"ListEndpointsContext",
",",
"fileHandler",
"asseter",
")",
"(",
"*",
"app",
".",
"Endpoints",
",",
"error",
")",
"{",
"// Get an unmarshal swagger specification",
"swaggerJSON",
",",
"err",
":=",
"fileHandler",... | // Get a list of all endpoints formatted to json api format. | [
"Get",
"a",
"list",
"of",
"all",
"endpoints",
"formatted",
"to",
"json",
"api",
"format",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/endpoints.go#L73-L156 |
13,448 | fabric8-services/fabric8-wit | controller/deployments_urlprovider.go | NewURLProvider | func NewURLProvider(ctx context.Context, config *configuration.Registry, osioclient OpenshiftIOClient) (kubernetes.BaseURLProvider, error) {
userServices, err := osioclient.GetUserServices(ctx)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "error accessing Tenant API")
return nil, err
}
token := goajwt.ContextJWT(ctx).Raw
proxyURL := config.GetOpenshiftProxyURL()
up, err := newTenantURLProviderFromTenant(userServices, token, proxyURL)
if err != nil {
return nil, err
}
// create Auth API client - required to get OSO tokens
authClient, err := auth.CreateClient(ctx, config)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "error accessing Auth server")
return nil, errs.Wrap(err, "error creating Auth client")
}
up.TokenRetriever = &tokenRetriever{
authClient: authClient,
context: ctx,
}
// if we're not using a proxy then the API URL is actually the cluster of namespace 0,
// so the apiToken should be the token for that cluster.
// there should be no defaults, but that's deferred later
if len(proxyURL) == 0 {
tokenData, err := up.TokenForService(up.apiURL)
if err != nil {
return nil, err
}
up.apiToken = *tokenData
}
return up, nil
} | go | func NewURLProvider(ctx context.Context, config *configuration.Registry, osioclient OpenshiftIOClient) (kubernetes.BaseURLProvider, error) {
userServices, err := osioclient.GetUserServices(ctx)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "error accessing Tenant API")
return nil, err
}
token := goajwt.ContextJWT(ctx).Raw
proxyURL := config.GetOpenshiftProxyURL()
up, err := newTenantURLProviderFromTenant(userServices, token, proxyURL)
if err != nil {
return nil, err
}
// create Auth API client - required to get OSO tokens
authClient, err := auth.CreateClient(ctx, config)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "error accessing Auth server")
return nil, errs.Wrap(err, "error creating Auth client")
}
up.TokenRetriever = &tokenRetriever{
authClient: authClient,
context: ctx,
}
// if we're not using a proxy then the API URL is actually the cluster of namespace 0,
// so the apiToken should be the token for that cluster.
// there should be no defaults, but that's deferred later
if len(proxyURL) == 0 {
tokenData, err := up.TokenForService(up.apiURL)
if err != nil {
return nil, err
}
up.apiToken = *tokenData
}
return up, nil
} | [
"func",
"NewURLProvider",
"(",
"ctx",
"context",
".",
"Context",
",",
"config",
"*",
"configuration",
".",
"Registry",
",",
"osioclient",
"OpenshiftIOClient",
")",
"(",
"kubernetes",
".",
"BaseURLProvider",
",",
"error",
")",
"{",
"userServices",
",",
"err",
"... | // NewURLProvider looks at what servers are available and create a BaseURLProvder that fits | [
"NewURLProvider",
"looks",
"at",
"what",
"servers",
"are",
"available",
"and",
"create",
"a",
"BaseURLProvder",
"that",
"fits"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/deployments_urlprovider.go#L92-L134 |
13,449 | fabric8-services/fabric8-wit | controller/deployments_urlprovider.go | newTenantURLProviderFromTenant | func newTenantURLProviderFromTenant(t *app.UserService, token string, proxyURL string) (*tenantURLProvider, error) {
if t.ID == nil {
log.Error(nil, map[string]interface{}{}, "app.UserService is malformed: no ID field")
return nil, errs.New("app.UserService is malformed: no ID field")
}
if t.Attributes == nil {
log.Error(nil, map[string]interface{}{
"tenant": *t.ID,
}, "app.UserService is malformed: no Attribute field ID=%s", *t.ID)
return nil, errs.Errorf("app.UserService is malformed: no Attribute field (ID=%s)", *t.ID)
}
if len(t.Attributes.Namespaces) == 0 {
log.Error(nil, map[string]interface{}{
"tenant": *t.ID,
}, "this tenant has no namespaces: %s", *t.ID)
return nil, errs.Errorf("app.UserService is malformed: no Namespaces (ID=%s)", *t.ID)
}
defaultNamespace := t.Attributes.Namespaces[0]
namespaceMap := make(map[string]*app.NamespaceAttributes)
for i, namespace := range t.Attributes.Namespaces {
namespaceMap[*namespace.Name] = t.Attributes.Namespaces[i]
if namespace.Type != nil && *namespace.Type == "user" {
defaultNamespace = namespace
}
}
defaultClusterURL := *defaultNamespace.ClusterURL
if len(proxyURL) != 0 {
// all non-metric API calls go via the proxy
defaultClusterURL = proxyURL
}
provider := &tenantURLProvider{
apiURL: defaultClusterURL,
apiToken: token,
tenant: t,
namespaces: namespaceMap,
}
return provider, nil
} | go | func newTenantURLProviderFromTenant(t *app.UserService, token string, proxyURL string) (*tenantURLProvider, error) {
if t.ID == nil {
log.Error(nil, map[string]interface{}{}, "app.UserService is malformed: no ID field")
return nil, errs.New("app.UserService is malformed: no ID field")
}
if t.Attributes == nil {
log.Error(nil, map[string]interface{}{
"tenant": *t.ID,
}, "app.UserService is malformed: no Attribute field ID=%s", *t.ID)
return nil, errs.Errorf("app.UserService is malformed: no Attribute field (ID=%s)", *t.ID)
}
if len(t.Attributes.Namespaces) == 0 {
log.Error(nil, map[string]interface{}{
"tenant": *t.ID,
}, "this tenant has no namespaces: %s", *t.ID)
return nil, errs.Errorf("app.UserService is malformed: no Namespaces (ID=%s)", *t.ID)
}
defaultNamespace := t.Attributes.Namespaces[0]
namespaceMap := make(map[string]*app.NamespaceAttributes)
for i, namespace := range t.Attributes.Namespaces {
namespaceMap[*namespace.Name] = t.Attributes.Namespaces[i]
if namespace.Type != nil && *namespace.Type == "user" {
defaultNamespace = namespace
}
}
defaultClusterURL := *defaultNamespace.ClusterURL
if len(proxyURL) != 0 {
// all non-metric API calls go via the proxy
defaultClusterURL = proxyURL
}
provider := &tenantURLProvider{
apiURL: defaultClusterURL,
apiToken: token,
tenant: t,
namespaces: namespaceMap,
}
return provider, nil
} | [
"func",
"newTenantURLProviderFromTenant",
"(",
"t",
"*",
"app",
".",
"UserService",
",",
"token",
"string",
",",
"proxyURL",
"string",
")",
"(",
"*",
"tenantURLProvider",
",",
"error",
")",
"{",
"if",
"t",
".",
"ID",
"==",
"nil",
"{",
"log",
".",
"Error"... | // newTenantURLProviderFromTenant create a provider from a UserService object | [
"newTenantURLProviderFromTenant",
"create",
"a",
"provider",
"from",
"a",
"UserService",
"object"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/deployments_urlprovider.go#L137-L181 |
13,450 | fabric8-services/fabric8-wit | controller/deployments_urlprovider.go | GetEnvironmentMapping | func (up *tenantURLProvider) GetEnvironmentMapping() map[string]string {
result := make(map[string]string)
// Exclude internal namespaces where the user cannot deploy applications
// Deployments API will receive requests by environment name (e.g. "run", "stage").
// These names correspond to the "type" attribute in Namespaces.
for envNS, attr := range up.namespaces {
envName := attr.Type
if envName == nil || len(*envName) == 0 {
log.Error(nil, map[string]interface{}{
"namespace": envNS,
}, "namespace has no type")
} else {
result[*envName] = envNS
}
}
return result
} | go | func (up *tenantURLProvider) GetEnvironmentMapping() map[string]string {
result := make(map[string]string)
// Exclude internal namespaces where the user cannot deploy applications
// Deployments API will receive requests by environment name (e.g. "run", "stage").
// These names correspond to the "type" attribute in Namespaces.
for envNS, attr := range up.namespaces {
envName := attr.Type
if envName == nil || len(*envName) == 0 {
log.Error(nil, map[string]interface{}{
"namespace": envNS,
}, "namespace has no type")
} else {
result[*envName] = envNS
}
}
return result
} | [
"func",
"(",
"up",
"*",
"tenantURLProvider",
")",
"GetEnvironmentMapping",
"(",
")",
"map",
"[",
"string",
"]",
"string",
"{",
"result",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"// Exclude internal namespaces where the user cannot deploy... | // GetEnvironmentMapping returns a map whose keys are environment names, and values are the Kubernetes namespaces
// that represent those environments | [
"GetEnvironmentMapping",
"returns",
"a",
"map",
"whose",
"keys",
"are",
"environment",
"names",
"and",
"values",
"are",
"the",
"Kubernetes",
"namespaces",
"that",
"represent",
"those",
"environments"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/deployments_urlprovider.go#L190-L207 |
13,451 | fabric8-services/fabric8-wit | controller/deployments_urlprovider.go | CanDeploy | func (up *tenantURLProvider) CanDeploy(envType string) bool {
_, pres := internalNamespaceTypes[envType]
return !pres
} | go | func (up *tenantURLProvider) CanDeploy(envType string) bool {
_, pres := internalNamespaceTypes[envType]
return !pres
} | [
"func",
"(",
"up",
"*",
"tenantURLProvider",
")",
"CanDeploy",
"(",
"envType",
"string",
")",
"bool",
"{",
"_",
",",
"pres",
":=",
"internalNamespaceTypes",
"[",
"envType",
"]",
"\n",
"return",
"!",
"pres",
"\n",
"}"
] | // CanDeploy returns true if the environment type provided can be deployed to as part of a pipeline | [
"CanDeploy",
"returns",
"true",
"if",
"the",
"environment",
"type",
"provided",
"can",
"be",
"deployed",
"to",
"as",
"part",
"of",
"a",
"pipeline"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/deployments_urlprovider.go#L213-L216 |
13,452 | fabric8-services/fabric8-wit | controller/features.go | NewFeaturesController | func NewFeaturesController(service *goa.Service, config FeaturesControllerConfiguration) *FeaturesController {
return &FeaturesController{
Controller: service.NewController("FeaturesController"),
config: config,
}
} | go | func NewFeaturesController(service *goa.Service, config FeaturesControllerConfiguration) *FeaturesController {
return &FeaturesController{
Controller: service.NewController("FeaturesController"),
config: config,
}
} | [
"func",
"NewFeaturesController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"config",
"FeaturesControllerConfiguration",
")",
"*",
"FeaturesController",
"{",
"return",
"&",
"FeaturesController",
"{",
"Controller",
":",
"service",
".",
"NewController",
"(",
"\"... | // NewFeaturesController creates a features controller. | [
"NewFeaturesController",
"creates",
"a",
"features",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/features.go#L21-L26 |
13,453 | fabric8-services/fabric8-wit | controller/area.go | NewAreaController | func NewAreaController(service *goa.Service, db application.DB, config AreaControllerConfiguration) *AreaController {
return &AreaController{
Controller: service.NewController("AreaController"),
db: db,
config: config}
} | go | func NewAreaController(service *goa.Service, db application.DB, config AreaControllerConfiguration) *AreaController {
return &AreaController{
Controller: service.NewController("AreaController"),
db: db,
config: config}
} | [
"func",
"NewAreaController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"db",
"application",
".",
"DB",
",",
"config",
"AreaControllerConfiguration",
")",
"*",
"AreaController",
"{",
"return",
"&",
"AreaController",
"{",
"Controller",
":",
"service",
".",
... | // NewAreaController creates a area controller. | [
"NewAreaController",
"creates",
"a",
"area",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/area.go#L40-L45 |
13,454 | fabric8-services/fabric8-wit | controller/area.go | ShowChildren | func (c *AreaController) ShowChildren(ctx *app.ShowChildrenAreaContext) error {
id, err := uuid.FromString(ctx.ID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrNotFound(err.Error()))
}
var children []area.Area
err = application.Transactional(c.db, func(appl application.Application) error {
parentArea, err := appl.Areas().Load(ctx, id)
if err != nil {
return err
}
children, err = appl.Areas().ListChildren(ctx, parentArea)
return err
})
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
return ctx.ConditionalEntities(children, c.config.GetCacheControlAreas, func() error {
res := &app.AreaList{}
res.Data = ConvertAreas(c.db, ctx.Request, children, addResolvedPath)
return ctx.OK(res)
})
} | go | func (c *AreaController) ShowChildren(ctx *app.ShowChildrenAreaContext) error {
id, err := uuid.FromString(ctx.ID)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrNotFound(err.Error()))
}
var children []area.Area
err = application.Transactional(c.db, func(appl application.Application) error {
parentArea, err := appl.Areas().Load(ctx, id)
if err != nil {
return err
}
children, err = appl.Areas().ListChildren(ctx, parentArea)
return err
})
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
return ctx.ConditionalEntities(children, c.config.GetCacheControlAreas, func() error {
res := &app.AreaList{}
res.Data = ConvertAreas(c.db, ctx.Request, children, addResolvedPath)
return ctx.OK(res)
})
} | [
"func",
"(",
"c",
"*",
"AreaController",
")",
"ShowChildren",
"(",
"ctx",
"*",
"app",
".",
"ShowChildrenAreaContext",
")",
"error",
"{",
"id",
",",
"err",
":=",
"uuid",
".",
"FromString",
"(",
"ctx",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{... | // ShowChildren runs the show-children action | [
"ShowChildren",
"runs",
"the",
"show",
"-",
"children",
"action"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/area.go#L48-L71 |
13,455 | fabric8-services/fabric8-wit | controller/area.go | ConvertAreas | func ConvertAreas(db application.DB, request *http.Request, areas []area.Area, additional ...AreaConvertFunc) []*app.Area {
var is = []*app.Area{}
for _, i := range areas {
is = append(is, ConvertArea(db, request, i, additional...))
}
return is
} | go | func ConvertAreas(db application.DB, request *http.Request, areas []area.Area, additional ...AreaConvertFunc) []*app.Area {
var is = []*app.Area{}
for _, i := range areas {
is = append(is, ConvertArea(db, request, i, additional...))
}
return is
} | [
"func",
"ConvertAreas",
"(",
"db",
"application",
".",
"DB",
",",
"request",
"*",
"http",
".",
"Request",
",",
"areas",
"[",
"]",
"area",
".",
"Area",
",",
"additional",
"...",
"AreaConvertFunc",
")",
"[",
"]",
"*",
"app",
".",
"Area",
"{",
"var",
"i... | // ConvertAreas converts between internal and external REST representation | [
"ConvertAreas",
"converts",
"between",
"internal",
"and",
"external",
"REST",
"representation"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/area.go#L193-L199 |
13,456 | fabric8-services/fabric8-wit | controller/area.go | ConvertArea | func ConvertArea(db application.DB, request *http.Request, ar area.Area, options ...AreaConvertFunc) *app.Area {
relatedURL := rest.AbsoluteURL(request, app.AreaHref(ar.ID))
childURL := rest.AbsoluteURL(request, app.AreaHref(ar.ID)+"/children")
spaceRelatedURL := rest.AbsoluteURL(request, app.SpaceHref(ar.SpaceID))
i := &app.Area{
Type: area.APIStringTypeAreas,
ID: &ar.ID,
Attributes: &app.AreaAttributes{
Name: &ar.Name,
CreatedAt: &ar.CreatedAt,
UpdatedAt: &ar.UpdatedAt,
Version: &ar.Version,
ParentPath: ptr.String(ar.Path.ParentPath().String()),
Number: &ar.Number,
},
Relationships: &app.AreaRelations{
Space: &app.RelationGeneric{
Data: &app.GenericData{
Type: &space.SpaceType,
ID: ptr.String(ar.SpaceID.String()),
},
Links: &app.GenericLinks{
Self: &spaceRelatedURL,
Related: &spaceRelatedURL,
},
},
Children: &app.RelationGeneric{
Links: &app.GenericLinks{
Self: &childURL,
Related: &childURL,
},
},
},
Links: &app.GenericLinks{
Self: &relatedURL,
Related: &relatedURL,
},
}
// Now check the path, if the path is empty, then this is the topmost area
// in a specific space.
if !ar.Path.ParentPath().IsEmpty() {
parent := ar.Path.ParentID().String()
i.Relationships.Parent = &app.RelationGeneric{
Data: &app.GenericData{
Type: ptr.String(area.APIStringTypeAreas),
ID: &parent,
},
Links: &app.GenericLinks{
// Only the immediate parent's URL.
Self: ptr.String(rest.AbsoluteURL(request, app.AreaHref(parent))),
},
}
}
for _, opt := range options {
opt(db, request, &ar, i)
}
return i
} | go | func ConvertArea(db application.DB, request *http.Request, ar area.Area, options ...AreaConvertFunc) *app.Area {
relatedURL := rest.AbsoluteURL(request, app.AreaHref(ar.ID))
childURL := rest.AbsoluteURL(request, app.AreaHref(ar.ID)+"/children")
spaceRelatedURL := rest.AbsoluteURL(request, app.SpaceHref(ar.SpaceID))
i := &app.Area{
Type: area.APIStringTypeAreas,
ID: &ar.ID,
Attributes: &app.AreaAttributes{
Name: &ar.Name,
CreatedAt: &ar.CreatedAt,
UpdatedAt: &ar.UpdatedAt,
Version: &ar.Version,
ParentPath: ptr.String(ar.Path.ParentPath().String()),
Number: &ar.Number,
},
Relationships: &app.AreaRelations{
Space: &app.RelationGeneric{
Data: &app.GenericData{
Type: &space.SpaceType,
ID: ptr.String(ar.SpaceID.String()),
},
Links: &app.GenericLinks{
Self: &spaceRelatedURL,
Related: &spaceRelatedURL,
},
},
Children: &app.RelationGeneric{
Links: &app.GenericLinks{
Self: &childURL,
Related: &childURL,
},
},
},
Links: &app.GenericLinks{
Self: &relatedURL,
Related: &relatedURL,
},
}
// Now check the path, if the path is empty, then this is the topmost area
// in a specific space.
if !ar.Path.ParentPath().IsEmpty() {
parent := ar.Path.ParentID().String()
i.Relationships.Parent = &app.RelationGeneric{
Data: &app.GenericData{
Type: ptr.String(area.APIStringTypeAreas),
ID: &parent,
},
Links: &app.GenericLinks{
// Only the immediate parent's URL.
Self: ptr.String(rest.AbsoluteURL(request, app.AreaHref(parent))),
},
}
}
for _, opt := range options {
opt(db, request, &ar, i)
}
return i
} | [
"func",
"ConvertArea",
"(",
"db",
"application",
".",
"DB",
",",
"request",
"*",
"http",
".",
"Request",
",",
"ar",
"area",
".",
"Area",
",",
"options",
"...",
"AreaConvertFunc",
")",
"*",
"app",
".",
"Area",
"{",
"relatedURL",
":=",
"rest",
".",
"Abso... | // ConvertArea converts between internal and external REST representation | [
"ConvertArea",
"converts",
"between",
"internal",
"and",
"external",
"REST",
"representation"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/area.go#L202-L260 |
13,457 | fabric8-services/fabric8-wit | controller/area.go | ConvertAreaSimple | func ConvertAreaSimple(request *http.Request, id interface{}) (*app.GenericData, *app.GenericLinks) {
t := area.APIStringTypeAreas
i := fmt.Sprint(id)
data := &app.GenericData{
Type: &t,
ID: &i,
}
relatedURL := rest.AbsoluteURL(request, app.AreaHref(i))
links := &app.GenericLinks{
Self: &relatedURL,
Related: &relatedURL,
}
return data, links
} | go | func ConvertAreaSimple(request *http.Request, id interface{}) (*app.GenericData, *app.GenericLinks) {
t := area.APIStringTypeAreas
i := fmt.Sprint(id)
data := &app.GenericData{
Type: &t,
ID: &i,
}
relatedURL := rest.AbsoluteURL(request, app.AreaHref(i))
links := &app.GenericLinks{
Self: &relatedURL,
Related: &relatedURL,
}
return data, links
} | [
"func",
"ConvertAreaSimple",
"(",
"request",
"*",
"http",
".",
"Request",
",",
"id",
"interface",
"{",
"}",
")",
"(",
"*",
"app",
".",
"GenericData",
",",
"*",
"app",
".",
"GenericLinks",
")",
"{",
"t",
":=",
"area",
".",
"APIStringTypeAreas",
"\n",
"i... | // ConvertAreaSimple converts a simple area ID into a Generic Relationship
// data+links element | [
"ConvertAreaSimple",
"converts",
"a",
"simple",
"area",
"ID",
"into",
"a",
"Generic",
"Relationship",
"data",
"+",
"links",
"element"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/area.go#L264-L277 |
13,458 | fabric8-services/fabric8-wit | controller/work_item_type_group.go | NewWorkItemTypeGroupController | func NewWorkItemTypeGroupController(service *goa.Service, db application.DB) *WorkItemTypeGroupController {
return &WorkItemTypeGroupController{
Controller: service.NewController("WorkItemTypeGroupController"),
db: db,
}
} | go | func NewWorkItemTypeGroupController(service *goa.Service, db application.DB) *WorkItemTypeGroupController {
return &WorkItemTypeGroupController{
Controller: service.NewController("WorkItemTypeGroupController"),
db: db,
}
} | [
"func",
"NewWorkItemTypeGroupController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"db",
"application",
".",
"DB",
")",
"*",
"WorkItemTypeGroupController",
"{",
"return",
"&",
"WorkItemTypeGroupController",
"{",
"Controller",
":",
"service",
".",
"NewControl... | // NewWorkItemTypeGroupController creates a work_item_type_group controller. | [
"NewWorkItemTypeGroupController",
"creates",
"a",
"work_item_type_group",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/work_item_type_group.go#L27-L32 |
13,459 | fabric8-services/fabric8-wit | controller/work_item_type_group.go | Show | func (c *WorkItemTypeGroupController) Show(ctx *app.ShowWorkItemTypeGroupContext) error {
var typeGroup *workitem.WorkItemTypeGroup
var err error
err = application.Transactional(c.db, func(appl application.Application) error {
typeGroup, err = appl.WorkItemTypeGroups().Load(ctx, ctx.GroupID)
if err != nil {
return errs.WithStack(err)
}
return nil
})
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
return ctx.OK(&app.WorkItemTypeGroupSingle{
Data: ConvertTypeGroup(ctx.Request, *typeGroup),
})
} | go | func (c *WorkItemTypeGroupController) Show(ctx *app.ShowWorkItemTypeGroupContext) error {
var typeGroup *workitem.WorkItemTypeGroup
var err error
err = application.Transactional(c.db, func(appl application.Application) error {
typeGroup, err = appl.WorkItemTypeGroups().Load(ctx, ctx.GroupID)
if err != nil {
return errs.WithStack(err)
}
return nil
})
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
return ctx.OK(&app.WorkItemTypeGroupSingle{
Data: ConvertTypeGroup(ctx.Request, *typeGroup),
})
} | [
"func",
"(",
"c",
"*",
"WorkItemTypeGroupController",
")",
"Show",
"(",
"ctx",
"*",
"app",
".",
"ShowWorkItemTypeGroupContext",
")",
"error",
"{",
"var",
"typeGroup",
"*",
"workitem",
".",
"WorkItemTypeGroup",
"\n",
"var",
"err",
"error",
"\n",
"err",
"=",
"... | // Show runs the list action. | [
"Show",
"runs",
"the",
"list",
"action",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/work_item_type_group.go#L35-L51 |
13,460 | fabric8-services/fabric8-wit | controller/work_item_type_group.go | ConvertTypeGroup | func ConvertTypeGroup(request *http.Request, tg workitem.WorkItemTypeGroup) *app.WorkItemTypeGroupData {
workitemtypes := "workitemtypes"
workItemTypeGroupRelatedURL := rest.AbsoluteURL(request, app.WorkItemTypeGroupHref(tg.ID))
createdAt := tg.CreatedAt.UTC()
updatedAt := tg.UpdatedAt.UTC()
// Every work item type group except the one in the "iteration" bucket are
// meant to be shown in the sidebar.
showInSidebar := (tg.Bucket != workitem.BucketIteration)
res := &app.WorkItemTypeGroupData{
ID: &tg.ID,
Type: APIWorkItemTypeGroups,
Links: &app.GenericLinks{
Related: &workItemTypeGroupRelatedURL,
},
Attributes: &app.WorkItemTypeGroupAttributes{
Bucket: tg.Bucket.String(),
Name: tg.Name,
Description: tg.Description,
Icon: tg.Icon,
CreatedAt: &createdAt,
UpdatedAt: &updatedAt,
ShowInSidebar: &showInSidebar,
},
Relationships: &app.WorkItemTypeGroupRelationships{
TypeList: &app.RelationGenericList{
Data: make([]*app.GenericData, len(tg.TypeList)),
},
SpaceTemplate: &app.RelationGeneric{
Data: &app.GenericData{
ID: ptr.String(tg.SpaceTemplateID.String()),
Type: &APISpaceTemplates,
},
},
},
}
for i, witID := range tg.TypeList {
// witRelatedURL := rest.AbsoluteURL(request, app.WorkitemtypeHref(space.SystemSpace, witID))
idStr := witID.String()
res.Relationships.TypeList.Data[i] = &app.GenericData{
ID: &idStr,
Type: &workitemtypes,
// Links: &app.GenericLinks{
// Related: &witRelatedURL,
// },
}
}
return res
} | go | func ConvertTypeGroup(request *http.Request, tg workitem.WorkItemTypeGroup) *app.WorkItemTypeGroupData {
workitemtypes := "workitemtypes"
workItemTypeGroupRelatedURL := rest.AbsoluteURL(request, app.WorkItemTypeGroupHref(tg.ID))
createdAt := tg.CreatedAt.UTC()
updatedAt := tg.UpdatedAt.UTC()
// Every work item type group except the one in the "iteration" bucket are
// meant to be shown in the sidebar.
showInSidebar := (tg.Bucket != workitem.BucketIteration)
res := &app.WorkItemTypeGroupData{
ID: &tg.ID,
Type: APIWorkItemTypeGroups,
Links: &app.GenericLinks{
Related: &workItemTypeGroupRelatedURL,
},
Attributes: &app.WorkItemTypeGroupAttributes{
Bucket: tg.Bucket.String(),
Name: tg.Name,
Description: tg.Description,
Icon: tg.Icon,
CreatedAt: &createdAt,
UpdatedAt: &updatedAt,
ShowInSidebar: &showInSidebar,
},
Relationships: &app.WorkItemTypeGroupRelationships{
TypeList: &app.RelationGenericList{
Data: make([]*app.GenericData, len(tg.TypeList)),
},
SpaceTemplate: &app.RelationGeneric{
Data: &app.GenericData{
ID: ptr.String(tg.SpaceTemplateID.String()),
Type: &APISpaceTemplates,
},
},
},
}
for i, witID := range tg.TypeList {
// witRelatedURL := rest.AbsoluteURL(request, app.WorkitemtypeHref(space.SystemSpace, witID))
idStr := witID.String()
res.Relationships.TypeList.Data[i] = &app.GenericData{
ID: &idStr,
Type: &workitemtypes,
// Links: &app.GenericLinks{
// Related: &witRelatedURL,
// },
}
}
return res
} | [
"func",
"ConvertTypeGroup",
"(",
"request",
"*",
"http",
".",
"Request",
",",
"tg",
"workitem",
".",
"WorkItemTypeGroup",
")",
"*",
"app",
".",
"WorkItemTypeGroupData",
"{",
"workitemtypes",
":=",
"\"",
"\"",
"\n",
"workItemTypeGroupRelatedURL",
":=",
"rest",
".... | // ConvertTypeGroup converts WorkitemTypeGroup model to a response resource
// object for jsonapi.org specification | [
"ConvertTypeGroup",
"converts",
"WorkitemTypeGroup",
"model",
"to",
"a",
"response",
"resource",
"object",
"for",
"jsonapi",
".",
"org",
"specification"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/work_item_type_group.go#L55-L104 |
13,461 | fabric8-services/fabric8-wit | gormapplication/application.go | Commit | func (g *GormTransaction) Commit() error {
err := g.db.Commit().Error
g.db = nil
return errors.WithStack(err)
} | go | func (g *GormTransaction) Commit() error {
err := g.db.Commit().Error
g.db = nil
return errors.WithStack(err)
} | [
"func",
"(",
"g",
"*",
"GormTransaction",
")",
"Commit",
"(",
")",
"error",
"{",
"err",
":=",
"g",
".",
"db",
".",
"Commit",
"(",
")",
".",
"Error",
"\n",
"g",
".",
"db",
"=",
"nil",
"\n",
"return",
"errors",
".",
"WithStack",
"(",
"err",
")",
... | // Commit implements TransactionSupport | [
"Commit",
"implements",
"TransactionSupport"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/gormapplication/application.go#L204-L208 |
13,462 | fabric8-services/fabric8-wit | codebase/che/client.go | NewStarterClient | func NewStarterClient(cheStarterURL, openshiftMasterURL string, namespace string, client *http.Client) Client {
return &StarterClient{cheStarterURL: cheStarterURL, openshiftMasterURL: openshiftMasterURL, namespace: namespace, client: client}
} | go | func NewStarterClient(cheStarterURL, openshiftMasterURL string, namespace string, client *http.Client) Client {
return &StarterClient{cheStarterURL: cheStarterURL, openshiftMasterURL: openshiftMasterURL, namespace: namespace, client: client}
} | [
"func",
"NewStarterClient",
"(",
"cheStarterURL",
",",
"openshiftMasterURL",
"string",
",",
"namespace",
"string",
",",
"client",
"*",
"http",
".",
"Client",
")",
"Client",
"{",
"return",
"&",
"StarterClient",
"{",
"cheStarterURL",
":",
"cheStarterURL",
",",
"op... | // NewStarterClient is a helper function to create a new CheStarter client
// Uses http.DefaultClient | [
"NewStarterClient",
"is",
"a",
"helper",
"function",
"to",
"create",
"a",
"new",
"CheStarter",
"client",
"Uses",
"http",
".",
"DefaultClient"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/codebase/che/client.go#L29-L31 |
13,463 | fabric8-services/fabric8-wit | codebase/che/client.go | CreateWorkspace | func (cs *StarterClient) CreateWorkspace(ctx context.Context, workspace WorkspaceRequest) (*WorkspaceResponse, error) {
body, err := json.Marshal(&workspace)
if err != nil {
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": err,
}, "failed to create request object")
return nil, err
}
req, err := http.NewRequest("POST", cs.targetURL("workspace"), bytes.NewReader(body))
if err != nil {
return nil, err
}
cs.setHeaders(ctx, req)
if log.IsDebug() {
b, _ := httputil.DumpRequest(req, true)
log.Debug(ctx, map[string]interface{}{
"request": string(b),
}, "request object")
}
resp, err := cs.client.Do(req)
if err != nil {
return nil, err
}
defer rest.CloseResponse(resp)
if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
workspaceErr := StarterError{}
err = json.NewDecoder(resp.Body).Decode(&workspaceErr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": err,
}, "failed to decode error response from create workspace for repository")
return nil, err
}
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": workspaceErr.String(),
}, "failed to execute create workspace for repository")
return nil, &workspaceErr
}
workspaceResp := WorkspaceResponse{}
err = json.NewDecoder(resp.Body).Decode(&workspaceResp)
if err != nil {
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": err,
}, "failed to decode response from create workspace for repository")
return nil, err
}
return &workspaceResp, nil
} | go | func (cs *StarterClient) CreateWorkspace(ctx context.Context, workspace WorkspaceRequest) (*WorkspaceResponse, error) {
body, err := json.Marshal(&workspace)
if err != nil {
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": err,
}, "failed to create request object")
return nil, err
}
req, err := http.NewRequest("POST", cs.targetURL("workspace"), bytes.NewReader(body))
if err != nil {
return nil, err
}
cs.setHeaders(ctx, req)
if log.IsDebug() {
b, _ := httputil.DumpRequest(req, true)
log.Debug(ctx, map[string]interface{}{
"request": string(b),
}, "request object")
}
resp, err := cs.client.Do(req)
if err != nil {
return nil, err
}
defer rest.CloseResponse(resp)
if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
workspaceErr := StarterError{}
err = json.NewDecoder(resp.Body).Decode(&workspaceErr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": err,
}, "failed to decode error response from create workspace for repository")
return nil, err
}
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": workspaceErr.String(),
}, "failed to execute create workspace for repository")
return nil, &workspaceErr
}
workspaceResp := WorkspaceResponse{}
err = json.NewDecoder(resp.Body).Decode(&workspaceResp)
if err != nil {
log.Error(ctx, map[string]interface{}{
"workspace_id": workspace.Name,
"workspace_stack_id": workspace.StackID,
"workspace": workspace,
"err": err,
}, "failed to decode response from create workspace for repository")
return nil, err
}
return &workspaceResp, nil
} | [
"func",
"(",
"cs",
"*",
"StarterClient",
")",
"CreateWorkspace",
"(",
"ctx",
"context",
".",
"Context",
",",
"workspace",
"WorkspaceRequest",
")",
"(",
"*",
"WorkspaceResponse",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",... | // CreateWorkspace creates a new Che Workspace based on a repository | [
"CreateWorkspace",
"creates",
"a",
"new",
"Che",
"Workspace",
"based",
"on",
"a",
"repository"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/codebase/che/client.go#L112-L177 |
13,464 | fabric8-services/fabric8-wit | codebase/che/client.go | DeleteWorkspace | func (cs *StarterClient) DeleteWorkspace(ctx context.Context, workspaceName string) error {
req, err := http.NewRequest("DELETE", cs.targetURL(fmt.Sprintf("workspace/%s", workspaceName)), nil)
if err != nil {
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": err,
}, "failed to create request object")
return err
}
cs.setHeaders(ctx, req)
if log.IsDebug() {
b, _ := httputil.DumpRequest(req, true)
log.Debug(ctx, map[string]interface{}{
"request": string(b),
}, "request object")
}
resp, err := cs.client.Do(req)
if err != nil {
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": err,
}, "failed to delete workspace")
return err
}
defer rest.CloseResponse(resp)
if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
workspaceErr := StarterError{}
err = json.NewDecoder(resp.Body).Decode(&workspaceErr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": err,
}, "failed to decode error response from list workspace for repository")
return err
}
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": workspaceErr.String(),
}, "failed to delete workspace")
return &workspaceErr
}
return nil
} | go | func (cs *StarterClient) DeleteWorkspace(ctx context.Context, workspaceName string) error {
req, err := http.NewRequest("DELETE", cs.targetURL(fmt.Sprintf("workspace/%s", workspaceName)), nil)
if err != nil {
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": err,
}, "failed to create request object")
return err
}
cs.setHeaders(ctx, req)
if log.IsDebug() {
b, _ := httputil.DumpRequest(req, true)
log.Debug(ctx, map[string]interface{}{
"request": string(b),
}, "request object")
}
resp, err := cs.client.Do(req)
if err != nil {
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": err,
}, "failed to delete workspace")
return err
}
defer rest.CloseResponse(resp)
if resp.StatusCode != http.StatusNoContent && resp.StatusCode != http.StatusOK {
workspaceErr := StarterError{}
err = json.NewDecoder(resp.Body).Decode(&workspaceErr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": err,
}, "failed to decode error response from list workspace for repository")
return err
}
log.Error(ctx, map[string]interface{}{
"name": workspaceName,
"masterURL": cs.cheStarterURL,
"namespace": cs.namespace,
"err": workspaceErr.String(),
}, "failed to delete workspace")
return &workspaceErr
}
return nil
} | [
"func",
"(",
"cs",
"*",
"StarterClient",
")",
"DeleteWorkspace",
"(",
"ctx",
"context",
".",
"Context",
",",
"workspaceName",
"string",
")",
"error",
"{",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"cs",
".",
"targetURL",
... | // DeleteWorkspace deletes a Che Workspace by its name | [
"DeleteWorkspace",
"deletes",
"a",
"Che",
"Workspace",
"by",
"its",
"name"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/codebase/che/client.go#L180-L235 |
13,465 | fabric8-services/fabric8-wit | codebase/che/client.go | GetCheServerState | func (cs *StarterClient) GetCheServerState(ctx context.Context) (*ServerStateResponse, error) {
req, err := http.NewRequest("GET", cs.targetURL("server"), nil)
if err != nil {
return nil, err
}
cs.setHeaders(ctx, req)
if log.IsDebug() {
b, _ := httputil.DumpRequest(req, true)
log.Debug(ctx, map[string]interface{}{
"request": string(b),
}, "dump of the request to get the che server state")
}
resp, err := cs.client.Do(req)
if err != nil {
return nil, err
}
defer rest.CloseResponse(resp)
if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
statusErr := StarterError{}
err = json.NewDecoder(resp.Body).Decode(&statusErr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "failed to decode error response from get che server state")
return nil, err
}
log.Error(ctx, map[string]interface{}{
"err": statusErr.String(),
}, "failed to execute get che server state")
return nil, &statusErr
}
cheServerStateResponse := ServerStateResponse{}
err = json.NewDecoder(resp.Body).Decode(&cheServerStateResponse)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "failed to decode response from getting che server state")
return nil, err
}
return &cheServerStateResponse, nil
} | go | func (cs *StarterClient) GetCheServerState(ctx context.Context) (*ServerStateResponse, error) {
req, err := http.NewRequest("GET", cs.targetURL("server"), nil)
if err != nil {
return nil, err
}
cs.setHeaders(ctx, req)
if log.IsDebug() {
b, _ := httputil.DumpRequest(req, true)
log.Debug(ctx, map[string]interface{}{
"request": string(b),
}, "dump of the request to get the che server state")
}
resp, err := cs.client.Do(req)
if err != nil {
return nil, err
}
defer rest.CloseResponse(resp)
if resp.StatusCode != http.StatusCreated && resp.StatusCode != http.StatusOK {
statusErr := StarterError{}
err = json.NewDecoder(resp.Body).Decode(&statusErr)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "failed to decode error response from get che server state")
return nil, err
}
log.Error(ctx, map[string]interface{}{
"err": statusErr.String(),
}, "failed to execute get che server state")
return nil, &statusErr
}
cheServerStateResponse := ServerStateResponse{}
err = json.NewDecoder(resp.Body).Decode(&cheServerStateResponse)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "failed to decode response from getting che server state")
return nil, err
}
return &cheServerStateResponse, nil
} | [
"func",
"(",
"cs",
"*",
"StarterClient",
")",
"GetCheServerState",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"ServerStateResponse",
",",
"error",
")",
"{",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"cs",
".",... | // GetCheServerState get che server state. | [
"GetCheServerState",
"get",
"che",
"server",
"state",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/codebase/che/client.go#L293-L341 |
13,466 | fabric8-services/fabric8-wit | remoteworkitem/jira.go | Fetch | func (j *JiraTracker) Fetch(authToken string) chan TrackerItemContent {
f := jiraIssueFetcher{}
client, _ := jira.NewClient(nil, j.URL)
f.client = client
return j.fetch(&f)
} | go | func (j *JiraTracker) Fetch(authToken string) chan TrackerItemContent {
f := jiraIssueFetcher{}
client, _ := jira.NewClient(nil, j.URL)
f.client = client
return j.fetch(&f)
} | [
"func",
"(",
"j",
"*",
"JiraTracker",
")",
"Fetch",
"(",
"authToken",
"string",
")",
"chan",
"TrackerItemContent",
"{",
"f",
":=",
"jiraIssueFetcher",
"{",
"}",
"\n",
"client",
",",
"_",
":=",
"jira",
".",
"NewClient",
"(",
"nil",
",",
"j",
".",
"URL",... | // Fetch collects data from Jira | [
"Fetch",
"collects",
"data",
"from",
"Jira"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/remoteworkitem/jira.go#L33-L38 |
13,467 | fabric8-services/fabric8-wit | workitem/link/ancestor.go | GetDistinctAncestorIDs | func (l AncestorList) GetDistinctAncestorIDs() id.Slice {
m := id.Map{}
for _, ancestor := range l {
m[ancestor.ID] = struct{}{}
}
return m.ToSlice()
} | go | func (l AncestorList) GetDistinctAncestorIDs() id.Slice {
m := id.Map{}
for _, ancestor := range l {
m[ancestor.ID] = struct{}{}
}
return m.ToSlice()
} | [
"func",
"(",
"l",
"AncestorList",
")",
"GetDistinctAncestorIDs",
"(",
")",
"id",
".",
"Slice",
"{",
"m",
":=",
"id",
".",
"Map",
"{",
"}",
"\n",
"for",
"_",
",",
"ancestor",
":=",
"range",
"l",
"{",
"m",
"[",
"ancestor",
".",
"ID",
"]",
"=",
"str... | // GetDistinctAncestorIDs returns a list with distinct ancestor IDs. | [
"GetDistinctAncestorIDs",
"returns",
"a",
"list",
"with",
"distinct",
"ancestor",
"IDs",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/link/ancestor.go#L35-L41 |
13,468 | fabric8-services/fabric8-wit | workitem/link/ancestor.go | GetParentOf | func (l AncestorList) GetParentOf(workItemID uuid.UUID) *Ancestor {
for _, a := range l {
if a.DirectChildID == workItemID {
return &a
}
}
return nil
} | go | func (l AncestorList) GetParentOf(workItemID uuid.UUID) *Ancestor {
for _, a := range l {
if a.DirectChildID == workItemID {
return &a
}
}
return nil
} | [
"func",
"(",
"l",
"AncestorList",
")",
"GetParentOf",
"(",
"workItemID",
"uuid",
".",
"UUID",
")",
"*",
"Ancestor",
"{",
"for",
"_",
",",
"a",
":=",
"range",
"l",
"{",
"if",
"a",
".",
"DirectChildID",
"==",
"workItemID",
"{",
"return",
"&",
"a",
"\n"... | // GetParentOf returns the first parent item that we can find in the list of
// ancestors; otherwise nil is returned. | [
"GetParentOf",
"returns",
"the",
"first",
"parent",
"item",
"that",
"we",
"can",
"find",
"in",
"the",
"list",
"of",
"ancestors",
";",
"otherwise",
"nil",
"is",
"returned",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/link/ancestor.go#L45-L52 |
13,469 | fabric8-services/fabric8-wit | workitem/typegroup.go | Equal | func (witg WorkItemTypeGroup) Equal(u convert.Equaler) bool {
other, ok := u.(WorkItemTypeGroup)
if !ok {
return false
}
if witg.ID != other.ID {
return false
}
if witg.SpaceTemplateID != other.SpaceTemplateID {
return false
}
if !convert.CascadeEqual(witg.Lifecycle, other.Lifecycle) {
return false
}
if witg.Name != other.Name {
return false
}
if !reflect.DeepEqual(witg.Description, other.Description) {
return false
}
if witg.Bucket != other.Bucket {
return false
}
if witg.Icon != other.Icon {
return false
}
if witg.Position != other.Position {
return false
}
if len(witg.TypeList) != len(other.TypeList) {
return false
}
for i := range witg.TypeList {
if witg.TypeList[i] != other.TypeList[i] {
return false
}
}
return true
} | go | func (witg WorkItemTypeGroup) Equal(u convert.Equaler) bool {
other, ok := u.(WorkItemTypeGroup)
if !ok {
return false
}
if witg.ID != other.ID {
return false
}
if witg.SpaceTemplateID != other.SpaceTemplateID {
return false
}
if !convert.CascadeEqual(witg.Lifecycle, other.Lifecycle) {
return false
}
if witg.Name != other.Name {
return false
}
if !reflect.DeepEqual(witg.Description, other.Description) {
return false
}
if witg.Bucket != other.Bucket {
return false
}
if witg.Icon != other.Icon {
return false
}
if witg.Position != other.Position {
return false
}
if len(witg.TypeList) != len(other.TypeList) {
return false
}
for i := range witg.TypeList {
if witg.TypeList[i] != other.TypeList[i] {
return false
}
}
return true
} | [
"func",
"(",
"witg",
"WorkItemTypeGroup",
")",
"Equal",
"(",
"u",
"convert",
".",
"Equaler",
")",
"bool",
"{",
"other",
",",
"ok",
":=",
"u",
".",
"(",
"WorkItemTypeGroup",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
... | // Equal returns true if two WorkItemTypeGroup objects are equal; otherwise false is returned. | [
"Equal",
"returns",
"true",
"if",
"two",
"WorkItemTypeGroup",
"objects",
"are",
"equal",
";",
"otherwise",
"false",
"is",
"returned",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/typegroup.go#L59-L97 |
13,470 | fabric8-services/fabric8-wit | workitem/typegroup.go | TypeGroups | func TypeGroups() []WorkItemTypeGroup {
scenariosID := uuid.FromStringOrNil("feb28a28-44a6-43f8-946a-bae987713891")
experiencesID := uuid.FromStringOrNil("d4e2c859-f416-4e9a-a3e0-e7bb4e1b454b")
requirementsID := uuid.FromStringOrNil("bb1de8b6-3175-4821-abe9-50d0a64f19a2")
executionID := uuid.FromStringOrNil("7fdfde54-9cf2-4098-b33b-30cd505dcfc3")
return []WorkItemTypeGroup{
// There can be more than one groups in the "Portfolio" bucket
{
ID: scenariosID,
Bucket: BucketPortfolio,
Name: "Scenarios",
Icon: "fa fa-bullseye",
TypeList: []uuid.UUID{
SystemScenario,
SystemFundamental,
SystemPapercuts,
},
},
{
ID: experiencesID,
Bucket: BucketPortfolio,
Name: "Experiences",
Icon: "pficon pficon-infrastructure",
TypeList: []uuid.UUID{
SystemExperience,
SystemValueProposition,
},
},
// There's always only one group in the "Requirement" bucket
{
ID: requirementsID,
Bucket: BucketRequirement,
Name: "Requirements",
Icon: "fa fa-list-ul",
TypeList: []uuid.UUID{
SystemFeature,
SystemBug,
},
},
// There's always only one group in the "Iteration" bucket
{
ID: executionID,
Bucket: BucketIteration,
Name: "Execution",
Icon: "fa fa-repeat",
TypeList: []uuid.UUID{
SystemTask,
SystemBug,
SystemFeature,
},
},
}
} | go | func TypeGroups() []WorkItemTypeGroup {
scenariosID := uuid.FromStringOrNil("feb28a28-44a6-43f8-946a-bae987713891")
experiencesID := uuid.FromStringOrNil("d4e2c859-f416-4e9a-a3e0-e7bb4e1b454b")
requirementsID := uuid.FromStringOrNil("bb1de8b6-3175-4821-abe9-50d0a64f19a2")
executionID := uuid.FromStringOrNil("7fdfde54-9cf2-4098-b33b-30cd505dcfc3")
return []WorkItemTypeGroup{
// There can be more than one groups in the "Portfolio" bucket
{
ID: scenariosID,
Bucket: BucketPortfolio,
Name: "Scenarios",
Icon: "fa fa-bullseye",
TypeList: []uuid.UUID{
SystemScenario,
SystemFundamental,
SystemPapercuts,
},
},
{
ID: experiencesID,
Bucket: BucketPortfolio,
Name: "Experiences",
Icon: "pficon pficon-infrastructure",
TypeList: []uuid.UUID{
SystemExperience,
SystemValueProposition,
},
},
// There's always only one group in the "Requirement" bucket
{
ID: requirementsID,
Bucket: BucketRequirement,
Name: "Requirements",
Icon: "fa fa-list-ul",
TypeList: []uuid.UUID{
SystemFeature,
SystemBug,
},
},
// There's always only one group in the "Iteration" bucket
{
ID: executionID,
Bucket: BucketIteration,
Name: "Execution",
Icon: "fa fa-repeat",
TypeList: []uuid.UUID{
SystemTask,
SystemBug,
SystemFeature,
},
},
}
} | [
"func",
"TypeGroups",
"(",
")",
"[",
"]",
"WorkItemTypeGroup",
"{",
"scenariosID",
":=",
"uuid",
".",
"FromStringOrNil",
"(",
"\"",
"\"",
")",
"\n",
"experiencesID",
":=",
"uuid",
".",
"FromStringOrNil",
"(",
"\"",
"\"",
")",
"\n",
"requirementsID",
":=",
... | // TypeGroups returns the list of work item type groups | [
"TypeGroups",
"returns",
"the",
"list",
"of",
"work",
"item",
"type",
"groups"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/typegroup.go#L133-L186 |
13,471 | fabric8-services/fabric8-wit | workitem/typegroup.go | TypeGroupByName | func TypeGroupByName(name string) *WorkItemTypeGroup {
for _, t := range TypeGroups() {
if t.Name == name {
return &t
}
}
return nil
} | go | func TypeGroupByName(name string) *WorkItemTypeGroup {
for _, t := range TypeGroups() {
if t.Name == name {
return &t
}
}
return nil
} | [
"func",
"TypeGroupByName",
"(",
"name",
"string",
")",
"*",
"WorkItemTypeGroup",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"TypeGroups",
"(",
")",
"{",
"if",
"t",
".",
"Name",
"==",
"name",
"{",
"return",
"&",
"t",
"\n",
"}",
"\n",
"}",
"\n",
"retu... | // TypeGroupByName returns a type group based on its name if such a group
// exists; otherwise nil is returned. | [
"TypeGroupByName",
"returns",
"a",
"type",
"group",
"based",
"on",
"its",
"name",
"if",
"such",
"a",
"group",
"exists",
";",
"otherwise",
"nil",
"is",
"returned",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/typegroup.go#L190-L197 |
13,472 | fabric8-services/fabric8-wit | workitem/typegroup.go | TypeGroupsByBucket | func TypeGroupsByBucket(bucket TypeBucket) []WorkItemTypeGroup {
res := []WorkItemTypeGroup{}
for _, t := range TypeGroups() {
if t.Bucket == bucket {
res = append(res, t)
}
}
return res
} | go | func TypeGroupsByBucket(bucket TypeBucket) []WorkItemTypeGroup {
res := []WorkItemTypeGroup{}
for _, t := range TypeGroups() {
if t.Bucket == bucket {
res = append(res, t)
}
}
return res
} | [
"func",
"TypeGroupsByBucket",
"(",
"bucket",
"TypeBucket",
")",
"[",
"]",
"WorkItemTypeGroup",
"{",
"res",
":=",
"[",
"]",
"WorkItemTypeGroup",
"{",
"}",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"TypeGroups",
"(",
")",
"{",
"if",
"t",
".",
"Bucket",
... | // TypeGroupsByBucket returns all type groups which fall into the given bucket | [
"TypeGroupsByBucket",
"returns",
"all",
"type",
"groups",
"which",
"fall",
"into",
"the",
"given",
"bucket"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/typegroup.go#L200-L208 |
13,473 | fabric8-services/fabric8-wit | controller/workitemtypes.go | NewWorkitemtypesController | func NewWorkitemtypesController(service *goa.Service, db application.DB, config workItemTypesControllerConfiguration) *WorkitemtypesController {
return &WorkitemtypesController{
Controller: service.NewController("WorkitemtypesController"),
db: db,
config: config,
}
} | go | func NewWorkitemtypesController(service *goa.Service, db application.DB, config workItemTypesControllerConfiguration) *WorkitemtypesController {
return &WorkitemtypesController{
Controller: service.NewController("WorkitemtypesController"),
db: db,
config: config,
}
} | [
"func",
"NewWorkitemtypesController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"db",
"application",
".",
"DB",
",",
"config",
"workItemTypesControllerConfiguration",
")",
"*",
"WorkitemtypesController",
"{",
"return",
"&",
"WorkitemtypesController",
"{",
"Cont... | // NewWorkitemtypesController creates a workitemtype controller. | [
"NewWorkitemtypesController",
"creates",
"a",
"workitemtype",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/workitemtypes.go#L25-L31 |
13,474 | fabric8-services/fabric8-wit | controller/workitemtypes.go | List | func (c *WorkitemtypesController) List(ctx *app.ListWorkitemtypesContext) error {
log.Debug(ctx, map[string]interface{}{"space_id": ctx.SpaceTemplateID}, "Listing work item types per space template")
result := &app.WorkItemTypeList{}
err := application.Transactional(c.db, func(appl application.Application) error {
witModels, err := appl.WorkItemTypes().List(ctx.Context, ctx.SpaceTemplateID)
if err != nil {
return errs.Wrap(err, "Error listing work item types")
}
return ctx.ConditionalEntities(witModels, c.config.GetCacheControlWorkItemTypes, func() error {
// convert from model to app
// result := &app.WorkItemTypeList{}
result.Data = make([]*app.WorkItemTypeData, len(witModels))
for index, value := range witModels {
wit := ConvertWorkItemTypeFromModel(ctx.Request, &value)
result.Data[index] = &wit
}
return nil
})
})
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
return ctx.OK(result)
} | go | func (c *WorkitemtypesController) List(ctx *app.ListWorkitemtypesContext) error {
log.Debug(ctx, map[string]interface{}{"space_id": ctx.SpaceTemplateID}, "Listing work item types per space template")
result := &app.WorkItemTypeList{}
err := application.Transactional(c.db, func(appl application.Application) error {
witModels, err := appl.WorkItemTypes().List(ctx.Context, ctx.SpaceTemplateID)
if err != nil {
return errs.Wrap(err, "Error listing work item types")
}
return ctx.ConditionalEntities(witModels, c.config.GetCacheControlWorkItemTypes, func() error {
// convert from model to app
// result := &app.WorkItemTypeList{}
result.Data = make([]*app.WorkItemTypeData, len(witModels))
for index, value := range witModels {
wit := ConvertWorkItemTypeFromModel(ctx.Request, &value)
result.Data[index] = &wit
}
return nil
})
})
if err != nil {
return jsonapi.JSONErrorResponse(ctx, err)
}
return ctx.OK(result)
} | [
"func",
"(",
"c",
"*",
"WorkitemtypesController",
")",
"List",
"(",
"ctx",
"*",
"app",
".",
"ListWorkitemtypesContext",
")",
"error",
"{",
"log",
".",
"Debug",
"(",
"ctx",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"... | // List runs the list action | [
"List",
"runs",
"the",
"list",
"action"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/workitemtypes.go#L34-L58 |
13,475 | fabric8-services/fabric8-wit | controller/space_codebases.go | NewSpaceCodebasesController | func NewSpaceCodebasesController(service *goa.Service, db application.DB) *SpaceCodebasesController {
return &SpaceCodebasesController{Controller: service.NewController("SpaceCodebasesController"), db: db}
} | go | func NewSpaceCodebasesController(service *goa.Service, db application.DB) *SpaceCodebasesController {
return &SpaceCodebasesController{Controller: service.NewController("SpaceCodebasesController"), db: db}
} | [
"func",
"NewSpaceCodebasesController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"db",
"application",
".",
"DB",
")",
"*",
"SpaceCodebasesController",
"{",
"return",
"&",
"SpaceCodebasesController",
"{",
"Controller",
":",
"service",
".",
"NewController",
"... | // NewSpaceCodebasesController creates a space-codebases controller. | [
"NewSpaceCodebasesController",
"creates",
"a",
"space",
"-",
"codebases",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/space_codebases.go#L22-L24 |
13,476 | fabric8-services/fabric8-wit | criteria/expression_equals.go | Equals | func Equals(left Expression, right Expression) Expression {
return reparent(&EqualsExpression{binaryExpression{expression{}, left, right}})
} | go | func Equals(left Expression, right Expression) Expression {
return reparent(&EqualsExpression{binaryExpression{expression{}, left, right}})
} | [
"func",
"Equals",
"(",
"left",
"Expression",
",",
"right",
"Expression",
")",
"Expression",
"{",
"return",
"reparent",
"(",
"&",
"EqualsExpression",
"{",
"binaryExpression",
"{",
"expression",
"{",
"}",
",",
"left",
",",
"right",
"}",
"}",
")",
"\n",
"}"
] | // Equals constructs an EqualsExpression | [
"Equals",
"constructs",
"an",
"EqualsExpression"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/criteria/expression_equals.go#L18-L20 |
13,477 | fabric8-services/fabric8-wit | log/context.go | extractIdentityID | func extractIdentityID(ctx context.Context) (string, error) {
token := goajwt.ContextJWT(ctx)
if token == nil {
return "", errors.New("Missing token")
}
id := token.Claims.(jwt.MapClaims)["sub"]
if id == nil {
return "", errors.New("Missing sub")
}
return id.(string), nil
} | go | func extractIdentityID(ctx context.Context) (string, error) {
token := goajwt.ContextJWT(ctx)
if token == nil {
return "", errors.New("Missing token")
}
id := token.Claims.(jwt.MapClaims)["sub"]
if id == nil {
return "", errors.New("Missing sub")
}
return id.(string), nil
} | [
"func",
"extractIdentityID",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"string",
",",
"error",
")",
"{",
"token",
":=",
"goajwt",
".",
"ContextJWT",
"(",
"ctx",
")",
"\n",
"if",
"token",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"errors",
"... | // extractIdentityID obtains the identity ID out of the authentication context | [
"extractIdentityID",
"obtains",
"the",
"identity",
"ID",
"out",
"of",
"the",
"authentication",
"context"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/log/context.go#L14-L25 |
13,478 | fabric8-services/fabric8-wit | log/context.go | ExtractRequestID | func ExtractRequestID(ctx context.Context) string {
reqID := middleware.ContextRequestID(ctx)
if reqID == "" {
return client.ContextRequestID(ctx)
}
return reqID
} | go | func ExtractRequestID(ctx context.Context) string {
reqID := middleware.ContextRequestID(ctx)
if reqID == "" {
return client.ContextRequestID(ctx)
}
return reqID
} | [
"func",
"ExtractRequestID",
"(",
"ctx",
"context",
".",
"Context",
")",
"string",
"{",
"reqID",
":=",
"middleware",
".",
"ContextRequestID",
"(",
"ctx",
")",
"\n",
"if",
"reqID",
"==",
"\"",
"\"",
"{",
"return",
"client",
".",
"ContextRequestID",
"(",
"ctx... | // ExtractRequestID obtains the request ID either from a goa client or middleware | [
"ExtractRequestID",
"obtains",
"the",
"request",
"ID",
"either",
"from",
"a",
"goa",
"client",
"or",
"middleware"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/log/context.go#L28-L35 |
13,479 | fabric8-services/fabric8-wit | criteria/iterator.go | IteratePostOrder | func IteratePostOrder(exp Expression, visitorFunction func(exp Expression) bool) {
exp.Accept(&postOrderIterator{visitorFunction})
} | go | func IteratePostOrder(exp Expression, visitorFunction func(exp Expression) bool) {
exp.Accept(&postOrderIterator{visitorFunction})
} | [
"func",
"IteratePostOrder",
"(",
"exp",
"Expression",
",",
"visitorFunction",
"func",
"(",
"exp",
"Expression",
")",
"bool",
")",
"{",
"exp",
".",
"Accept",
"(",
"&",
"postOrderIterator",
"{",
"visitorFunction",
"}",
")",
"\n",
"}"
] | // IteratePostOrder walks the expression tree in depth-first, left to right
// order. The iteration stops if visitorFunction returns false. | [
"IteratePostOrder",
"walks",
"the",
"expression",
"tree",
"in",
"depth",
"-",
"first",
"left",
"to",
"right",
"order",
".",
"The",
"iteration",
"stops",
"if",
"visitorFunction",
"returns",
"false",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/criteria/iterator.go#L5-L7 |
13,480 | fabric8-services/fabric8-wit | comment/comment_revision_repository.go | Create | func (r *GormCommentRevisionRepository) Create(ctx context.Context, modifierID uuid.UUID, revisionType RevisionType, c Comment) error {
log.Debug(nil, map[string]interface{}{
"modifier_id": modifierID,
"revision_type": revisionType,
}, "Storing a revision after operation on comment.")
tx := r.db
revision := &Revision{
ModifierIdentity: modifierID,
Time: time.Now(),
Type: revisionType,
CommentID: c.ID,
CommentParentID: c.ParentID,
CommentBody: &c.Body,
CommentMarkup: &c.Markup,
}
// if there is a valid parent comment id, add it the the stuct
if c.ParentCommentID.Valid == true {
revision.CommentParentCommentID = id.NullUUID{
UUID: c.ParentCommentID.UUID,
Valid: true,
}
}
if revision.Type == RevisionTypeDelete {
revision.CommentBody = nil
revision.CommentMarkup = nil
}
if err := tx.Create(&revision).Error; err != nil {
return errors.NewInternalError(ctx, errs.Wrap(err, "failed to create new comment revision"))
}
log.Debug(ctx, map[string]interface{}{"comment_id": c.ID}, "comment revision occurrence created")
return nil
} | go | func (r *GormCommentRevisionRepository) Create(ctx context.Context, modifierID uuid.UUID, revisionType RevisionType, c Comment) error {
log.Debug(nil, map[string]interface{}{
"modifier_id": modifierID,
"revision_type": revisionType,
}, "Storing a revision after operation on comment.")
tx := r.db
revision := &Revision{
ModifierIdentity: modifierID,
Time: time.Now(),
Type: revisionType,
CommentID: c.ID,
CommentParentID: c.ParentID,
CommentBody: &c.Body,
CommentMarkup: &c.Markup,
}
// if there is a valid parent comment id, add it the the stuct
if c.ParentCommentID.Valid == true {
revision.CommentParentCommentID = id.NullUUID{
UUID: c.ParentCommentID.UUID,
Valid: true,
}
}
if revision.Type == RevisionTypeDelete {
revision.CommentBody = nil
revision.CommentMarkup = nil
}
if err := tx.Create(&revision).Error; err != nil {
return errors.NewInternalError(ctx, errs.Wrap(err, "failed to create new comment revision"))
}
log.Debug(ctx, map[string]interface{}{"comment_id": c.ID}, "comment revision occurrence created")
return nil
} | [
"func",
"(",
"r",
"*",
"GormCommentRevisionRepository",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"modifierID",
"uuid",
".",
"UUID",
",",
"revisionType",
"RevisionType",
",",
"c",
"Comment",
")",
"error",
"{",
"log",
".",
"Debug",
"(",
"ni... | // Create stores a new revision for the given comment. | [
"Create",
"stores",
"a",
"new",
"revision",
"for",
"the",
"given",
"comment",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/comment/comment_revision_repository.go#L37-L69 |
13,481 | fabric8-services/fabric8-wit | controller/planner_backlog.go | NewPlannerBacklogController | func NewPlannerBacklogController(service *goa.Service, db application.DB, config PlannerBacklogControllerConfig) *PlannerBacklogController {
return &PlannerBacklogController{
Controller: service.NewController("PlannerBacklogController"),
db: db,
config: config,
}
} | go | func NewPlannerBacklogController(service *goa.Service, db application.DB, config PlannerBacklogControllerConfig) *PlannerBacklogController {
return &PlannerBacklogController{
Controller: service.NewController("PlannerBacklogController"),
db: db,
config: config,
}
} | [
"func",
"NewPlannerBacklogController",
"(",
"service",
"*",
"goa",
".",
"Service",
",",
"db",
"application",
".",
"DB",
",",
"config",
"PlannerBacklogControllerConfig",
")",
"*",
"PlannerBacklogController",
"{",
"return",
"&",
"PlannerBacklogController",
"{",
"Control... | // NewPlannerBacklogController creates a planner_backlog controller. | [
"NewPlannerBacklogController",
"creates",
"a",
"planner_backlog",
"controller",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/planner_backlog.go#L32-L38 |
13,482 | fabric8-services/fabric8-wit | controller/planner_backlog.go | generateBacklogExpression | func generateBacklogExpression(ctx context.Context, db application.DB, spaceID uuid.UUID, exp criteria.Expression) (criteria.Expression, error) {
notClosed := criteria.Not(criteria.Field(workitem.SystemState), criteria.Literal(workitem.SystemStateClosed))
if exp != nil {
exp = criteria.And(exp, notClosed)
} else {
exp = notClosed
}
log.Debug(ctx, map[string]interface{}{"space_id": spaceID, "db": db}, "generating backlog expression")
err := application.Transactional(db, func(appl application.Application) error {
// Get the space template ID from the space
space, err := appl.Spaces().Load(ctx, spaceID)
if err != nil {
return errs.Wrapf(err, "unable to fetch space: %s", spaceID)
}
// Get the root iteration
itr, err := appl.Iterations().Root(ctx, spaceID)
if err != nil {
log.Error(ctx, map[string]interface{}{"space_id": spaceID, "err": err}, "failed to locate root iteration")
return errs.Wrap(err, "unable to fetch root iteration")
}
exp = criteria.Equals(criteria.Field(workitem.SystemIteration), criteria.Literal(itr.ID.String()))
// Get the list of work item types that derive of PlannerItem in the space
var expWits criteria.Expression
wits, err := appl.WorkItemTypes().ListPlannerItemTypes(ctx, space.SpaceTemplateID)
if err != nil {
return errs.Wrap(err, "unable to fetch work item types that derive from planner item")
}
if len(wits) >= 1 {
expWits = criteria.Equals(criteria.Field("Type"), criteria.Literal(wits[0].ID.String()))
for _, wit := range wits[1:] {
witIDStr := wit.ID.String()
expWits = criteria.Or(expWits, criteria.Equals(criteria.Field("Type"), criteria.Literal(witIDStr)))
}
exp = criteria.And(exp, expWits)
}
if len(wits) == 0 {
// We set exp to nil to return an empty array
exp = nil
}
return nil
})
if err != nil {
return nil, err
}
return exp, nil
} | go | func generateBacklogExpression(ctx context.Context, db application.DB, spaceID uuid.UUID, exp criteria.Expression) (criteria.Expression, error) {
notClosed := criteria.Not(criteria.Field(workitem.SystemState), criteria.Literal(workitem.SystemStateClosed))
if exp != nil {
exp = criteria.And(exp, notClosed)
} else {
exp = notClosed
}
log.Debug(ctx, map[string]interface{}{"space_id": spaceID, "db": db}, "generating backlog expression")
err := application.Transactional(db, func(appl application.Application) error {
// Get the space template ID from the space
space, err := appl.Spaces().Load(ctx, spaceID)
if err != nil {
return errs.Wrapf(err, "unable to fetch space: %s", spaceID)
}
// Get the root iteration
itr, err := appl.Iterations().Root(ctx, spaceID)
if err != nil {
log.Error(ctx, map[string]interface{}{"space_id": spaceID, "err": err}, "failed to locate root iteration")
return errs.Wrap(err, "unable to fetch root iteration")
}
exp = criteria.Equals(criteria.Field(workitem.SystemIteration), criteria.Literal(itr.ID.String()))
// Get the list of work item types that derive of PlannerItem in the space
var expWits criteria.Expression
wits, err := appl.WorkItemTypes().ListPlannerItemTypes(ctx, space.SpaceTemplateID)
if err != nil {
return errs.Wrap(err, "unable to fetch work item types that derive from planner item")
}
if len(wits) >= 1 {
expWits = criteria.Equals(criteria.Field("Type"), criteria.Literal(wits[0].ID.String()))
for _, wit := range wits[1:] {
witIDStr := wit.ID.String()
expWits = criteria.Or(expWits, criteria.Equals(criteria.Field("Type"), criteria.Literal(witIDStr)))
}
exp = criteria.And(exp, expWits)
}
if len(wits) == 0 {
// We set exp to nil to return an empty array
exp = nil
}
return nil
})
if err != nil {
return nil, err
}
return exp, nil
} | [
"func",
"generateBacklogExpression",
"(",
"ctx",
"context",
".",
"Context",
",",
"db",
"application",
".",
"DB",
",",
"spaceID",
"uuid",
".",
"UUID",
",",
"exp",
"criteria",
".",
"Expression",
")",
"(",
"criteria",
".",
"Expression",
",",
"error",
")",
"{"... | // generateBacklogExpression creates the expression to query for backlog items | [
"generateBacklogExpression",
"creates",
"the",
"expression",
"to",
"query",
"for",
"backlog",
"items"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/planner_backlog.go#L79-L128 |
13,483 | fabric8-services/fabric8-wit | controller/users.go | CreateUserAsServiceAccount | func (c *UsersController) CreateUserAsServiceAccount(ctx *app.CreateUserAsServiceAccountUsersContext) error {
isSvcAccount, err := isServiceAccount(ctx, serviceNameAuth)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "failed to determine if account is a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(err))
}
if !isSvcAccount {
log.Error(ctx, map[string]interface{}{
"identity_id": ctx.ID,
}, "account used to call create api is not a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(errs.New("a non-service account tried to create a user.")))
}
return c.createUserInDB(ctx)
} | go | func (c *UsersController) CreateUserAsServiceAccount(ctx *app.CreateUserAsServiceAccountUsersContext) error {
isSvcAccount, err := isServiceAccount(ctx, serviceNameAuth)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
}, "failed to determine if account is a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(err))
}
if !isSvcAccount {
log.Error(ctx, map[string]interface{}{
"identity_id": ctx.ID,
}, "account used to call create api is not a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(errs.New("a non-service account tried to create a user.")))
}
return c.createUserInDB(ctx)
} | [
"func",
"(",
"c",
"*",
"UsersController",
")",
"CreateUserAsServiceAccount",
"(",
"ctx",
"*",
"app",
".",
"CreateUserAsServiceAccountUsersContext",
")",
"error",
"{",
"isSvcAccount",
",",
"err",
":=",
"isServiceAccount",
"(",
"ctx",
",",
"serviceNameAuth",
")",
"\... | // CreateUserAsServiceAccount updates a user when requested using a service account token | [
"CreateUserAsServiceAccount",
"updates",
"a",
"user",
"when",
"requested",
"using",
"a",
"service",
"account",
"token"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/users.go#L252-L270 |
13,484 | fabric8-services/fabric8-wit | controller/users.go | UpdateUserAsServiceAccount | func (c *UsersController) UpdateUserAsServiceAccount(ctx *app.UpdateUserAsServiceAccountUsersContext) error {
isSvcAccount, err := isServiceAccount(ctx, serviceNameAuth)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"identity_id": ctx.ID,
}, "failed to determine if account is a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(err))
}
if !isSvcAccount {
log.Error(ctx, map[string]interface{}{
"identity_id": ctx.ID,
}, "failed to determine if account is a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(errs.New("a non-service account tried to updated a user.")))
}
idString := ctx.ID
id, err := uuid.FromString(idString)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrBadRequest(errs.New("incorrect identity")))
}
return c.updateUserInDB(&id, ctx)
} | go | func (c *UsersController) UpdateUserAsServiceAccount(ctx *app.UpdateUserAsServiceAccountUsersContext) error {
isSvcAccount, err := isServiceAccount(ctx, serviceNameAuth)
if err != nil {
log.Error(ctx, map[string]interface{}{
"err": err,
"identity_id": ctx.ID,
}, "failed to determine if account is a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(err))
}
if !isSvcAccount {
log.Error(ctx, map[string]interface{}{
"identity_id": ctx.ID,
}, "failed to determine if account is a service account")
return jsonapi.JSONErrorResponse(ctx, goa.ErrUnauthorized(errs.New("a non-service account tried to updated a user.")))
}
idString := ctx.ID
id, err := uuid.FromString(idString)
if err != nil {
return jsonapi.JSONErrorResponse(ctx, goa.ErrBadRequest(errs.New("incorrect identity")))
}
return c.updateUserInDB(&id, ctx)
} | [
"func",
"(",
"c",
"*",
"UsersController",
")",
"UpdateUserAsServiceAccount",
"(",
"ctx",
"*",
"app",
".",
"UpdateUserAsServiceAccountUsersContext",
")",
"error",
"{",
"isSvcAccount",
",",
"err",
":=",
"isServiceAccount",
"(",
"ctx",
",",
"serviceNameAuth",
")",
"\... | // UpdateUserAsServiceAccount updates a user when requested using a service account token | [
"UpdateUserAsServiceAccount",
"updates",
"a",
"user",
"when",
"requested",
"using",
"a",
"service",
"account",
"token"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/users.go#L362-L385 |
13,485 | fabric8-services/fabric8-wit | controller/users.go | Update | func (c *UsersController) Update(ctx *app.UpdateUsersContext) error {
return proxy.RouteHTTP(ctx, c.config.GetAuthShortServiceHostName())
} | go | func (c *UsersController) Update(ctx *app.UpdateUsersContext) error {
return proxy.RouteHTTP(ctx, c.config.GetAuthShortServiceHostName())
} | [
"func",
"(",
"c",
"*",
"UsersController",
")",
"Update",
"(",
"ctx",
"*",
"app",
".",
"UpdateUsersContext",
")",
"error",
"{",
"return",
"proxy",
".",
"RouteHTTP",
"(",
"ctx",
",",
"c",
".",
"config",
".",
"GetAuthShortServiceHostName",
"(",
")",
")",
"\... | // Update updates the authorized user based on the provided Token | [
"Update",
"updates",
"the",
"authorized",
"user",
"based",
"on",
"the",
"provided",
"Token"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/controller/users.go#L487-L489 |
13,486 | fabric8-services/fabric8-wit | query/query.go | Create | func (r *GormQueryRepository) Create(ctx context.Context, q *Query) error {
defer goa.MeasureSince([]string{"goa", "db", "Query", "create"}, time.Now())
q.ID = uuid.NewV4()
if q.Creator == uuid.Nil {
return errors.NewBadParameterError("creator cannot be nil", q.Creator).Expected("valid user ID")
}
var v map[string]interface{}
if err := json.Unmarshal([]byte(q.Fields), &v); err != nil {
return errors.NewBadParameterError("query field is invalid JSON syntax", q.Fields).Expected("valid JSON")
}
// Parse fields to make sure that query is valid
exp, _, err := search.ParseFilterString(ctx, q.Fields)
if err != nil || exp == nil {
log.Error(ctx, map[string]interface{}{
"space_id": q.SpaceID,
"fields": q.Fields,
}, "unable to parse the query fields")
return err
}
err = r.db.Create(q).Error
if err != nil {
if gormsupport.IsCheckViolation(err, "queries_title_check") {
return errors.NewBadParameterError("Title", q.Title).Expected("not empty")
}
// combination of title, space ID and creator should be unique
if gormsupport.IsUniqueViolation(err, "queries_title_space_id_creator_unique") {
log.Error(ctx, map[string]interface{}{
"err": err,
"title": q.Title,
"space_id": q.SpaceID,
}, "unable to create query because a query with same title already exists in the space by same creator")
return errors.NewDataConflictError(fmt.Sprintf("query already exists with title = %s , space_id = %s, creator = %s", q.Title, q.SpaceID, q.Creator))
}
log.Error(ctx, map[string]interface{}{}, "error adding Query: %s", err.Error())
return err
}
return nil
} | go | func (r *GormQueryRepository) Create(ctx context.Context, q *Query) error {
defer goa.MeasureSince([]string{"goa", "db", "Query", "create"}, time.Now())
q.ID = uuid.NewV4()
if q.Creator == uuid.Nil {
return errors.NewBadParameterError("creator cannot be nil", q.Creator).Expected("valid user ID")
}
var v map[string]interface{}
if err := json.Unmarshal([]byte(q.Fields), &v); err != nil {
return errors.NewBadParameterError("query field is invalid JSON syntax", q.Fields).Expected("valid JSON")
}
// Parse fields to make sure that query is valid
exp, _, err := search.ParseFilterString(ctx, q.Fields)
if err != nil || exp == nil {
log.Error(ctx, map[string]interface{}{
"space_id": q.SpaceID,
"fields": q.Fields,
}, "unable to parse the query fields")
return err
}
err = r.db.Create(q).Error
if err != nil {
if gormsupport.IsCheckViolation(err, "queries_title_check") {
return errors.NewBadParameterError("Title", q.Title).Expected("not empty")
}
// combination of title, space ID and creator should be unique
if gormsupport.IsUniqueViolation(err, "queries_title_space_id_creator_unique") {
log.Error(ctx, map[string]interface{}{
"err": err,
"title": q.Title,
"space_id": q.SpaceID,
}, "unable to create query because a query with same title already exists in the space by same creator")
return errors.NewDataConflictError(fmt.Sprintf("query already exists with title = %s , space_id = %s, creator = %s", q.Title, q.SpaceID, q.Creator))
}
log.Error(ctx, map[string]interface{}{}, "error adding Query: %s", err.Error())
return err
}
return nil
} | [
"func",
"(",
"r",
"*",
"GormQueryRepository",
")",
"Create",
"(",
"ctx",
"context",
".",
"Context",
",",
"q",
"*",
"Query",
")",
"error",
"{",
"defer",
"goa",
".",
"MeasureSince",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\""... | // Create a new query | [
"Create",
"a",
"new",
"query"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/query/query.go#L82-L119 |
13,487 | fabric8-services/fabric8-wit | query/query.go | Save | func (r *GormQueryRepository) Save(ctx context.Context, q Query) (*Query, error) {
defer goa.MeasureSince([]string{"goa", "db", "query", "save"}, time.Now())
if strings.TrimSpace(q.Title) == "" {
return nil, errors.NewBadParameterError("query title cannot be empty string", q.Title).Expected("non empty string")
}
var v map[string]interface{}
if err := json.Unmarshal([]byte(q.Fields), &v); err != nil {
return nil, errors.NewBadParameterError("query field is invalid JSON syntax", q.Fields).Expected("valid JSON")
}
qry := Query{}
tx := r.db.Where("id = ?", q.ID).First(&qry)
oldVersion := q.Version
q.Version = qry.Version + 1
if tx.RecordNotFound() {
log.Error(ctx, map[string]interface{}{
"query_id": q.ID,
}, "query cannot be found")
return nil, errors.NewNotFoundError("query", q.ID.String())
}
if err := tx.Error; err != nil {
log.Error(ctx, map[string]interface{}{
"query_id": q.ID,
"err": err,
}, "unknown error happened when searching the query")
return nil, errors.NewInternalError(ctx, err)
}
tx = tx.Where("Version = ?", oldVersion).Save(&q)
if err := tx.Error; err != nil {
// combination of name and space ID should be unique
if gormsupport.IsUniqueViolation(err, "queries_title_space_id_creator_unique") {
log.Error(ctx, map[string]interface{}{
"err": err,
"title": q.Title,
"space_id": q.SpaceID,
}, "unable to create query because a query with same title already exists in the space")
return nil, errors.NewDataConflictError(fmt.Sprintf("query already exists with title = %s , space_id = %s", q.Title, q.SpaceID.String()))
}
log.Error(ctx, map[string]interface{}{
"query_id": q.ID,
"err": err,
}, "unable to save the query")
return nil, errors.NewInternalError(ctx, err)
}
if tx.RowsAffected == 0 {
return nil, errors.NewVersionConflictError("version conflict")
}
log.Debug(ctx, map[string]interface{}{
"query_id": q.ID,
}, "query updated successfully")
return &q, nil
} | go | func (r *GormQueryRepository) Save(ctx context.Context, q Query) (*Query, error) {
defer goa.MeasureSince([]string{"goa", "db", "query", "save"}, time.Now())
if strings.TrimSpace(q.Title) == "" {
return nil, errors.NewBadParameterError("query title cannot be empty string", q.Title).Expected("non empty string")
}
var v map[string]interface{}
if err := json.Unmarshal([]byte(q.Fields), &v); err != nil {
return nil, errors.NewBadParameterError("query field is invalid JSON syntax", q.Fields).Expected("valid JSON")
}
qry := Query{}
tx := r.db.Where("id = ?", q.ID).First(&qry)
oldVersion := q.Version
q.Version = qry.Version + 1
if tx.RecordNotFound() {
log.Error(ctx, map[string]interface{}{
"query_id": q.ID,
}, "query cannot be found")
return nil, errors.NewNotFoundError("query", q.ID.String())
}
if err := tx.Error; err != nil {
log.Error(ctx, map[string]interface{}{
"query_id": q.ID,
"err": err,
}, "unknown error happened when searching the query")
return nil, errors.NewInternalError(ctx, err)
}
tx = tx.Where("Version = ?", oldVersion).Save(&q)
if err := tx.Error; err != nil {
// combination of name and space ID should be unique
if gormsupport.IsUniqueViolation(err, "queries_title_space_id_creator_unique") {
log.Error(ctx, map[string]interface{}{
"err": err,
"title": q.Title,
"space_id": q.SpaceID,
}, "unable to create query because a query with same title already exists in the space")
return nil, errors.NewDataConflictError(fmt.Sprintf("query already exists with title = %s , space_id = %s", q.Title, q.SpaceID.String()))
}
log.Error(ctx, map[string]interface{}{
"query_id": q.ID,
"err": err,
}, "unable to save the query")
return nil, errors.NewInternalError(ctx, err)
}
if tx.RowsAffected == 0 {
return nil, errors.NewVersionConflictError("version conflict")
}
log.Debug(ctx, map[string]interface{}{
"query_id": q.ID,
}, "query updated successfully")
return &q, nil
} | [
"func",
"(",
"r",
"*",
"GormQueryRepository",
")",
"Save",
"(",
"ctx",
"context",
".",
"Context",
",",
"q",
"Query",
")",
"(",
"*",
"Query",
",",
"error",
")",
"{",
"defer",
"goa",
".",
"MeasureSince",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",... | // Save update the given query | [
"Save",
"update",
"the",
"given",
"query"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/query/query.go#L122-L173 |
13,488 | fabric8-services/fabric8-wit | query/query.go | Load | func (r *GormQueryRepository) Load(ctx context.Context, ID uuid.UUID, spaceID uuid.UUID) (*Query, error) {
defer goa.MeasureSince([]string{"goa", "db", "query", "show"}, time.Now())
q := Query{}
tx := r.db.Where("id = ? and space_id = ?", ID, spaceID).First(&q)
if tx.RecordNotFound() {
log.Error(ctx, map[string]interface{}{
"query_id": ID.String(),
}, "record not found")
return nil, errors.NewNotFoundError("query", ID.String())
}
if tx.Error != nil {
log.Error(ctx, map[string]interface{}{
"err": tx.Error,
"query_id": ID.String(),
}, "unable to load the query by ID")
return nil, errors.NewInternalError(ctx, tx.Error)
}
return &q, nil
} | go | func (r *GormQueryRepository) Load(ctx context.Context, ID uuid.UUID, spaceID uuid.UUID) (*Query, error) {
defer goa.MeasureSince([]string{"goa", "db", "query", "show"}, time.Now())
q := Query{}
tx := r.db.Where("id = ? and space_id = ?", ID, spaceID).First(&q)
if tx.RecordNotFound() {
log.Error(ctx, map[string]interface{}{
"query_id": ID.String(),
}, "record not found")
return nil, errors.NewNotFoundError("query", ID.String())
}
if tx.Error != nil {
log.Error(ctx, map[string]interface{}{
"err": tx.Error,
"query_id": ID.String(),
}, "unable to load the query by ID")
return nil, errors.NewInternalError(ctx, tx.Error)
}
return &q, nil
} | [
"func",
"(",
"r",
"*",
"GormQueryRepository",
")",
"Load",
"(",
"ctx",
"context",
".",
"Context",
",",
"ID",
"uuid",
".",
"UUID",
",",
"spaceID",
"uuid",
".",
"UUID",
")",
"(",
"*",
"Query",
",",
"error",
")",
"{",
"defer",
"goa",
".",
"MeasureSince"... | // Load Query in a space | [
"Load",
"Query",
"in",
"a",
"space"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/query/query.go#L198-L216 |
13,489 | fabric8-services/fabric8-wit | query/query.go | Delete | func (r *GormQueryRepository) Delete(ctx context.Context, ID uuid.UUID) error {
defer goa.MeasureSince([]string{"goa", "db", "query", "delete"}, time.Now())
q := Query{ID: ID}
tx := r.db.Delete(q)
if err := tx.Error; err != nil {
log.Error(ctx, map[string]interface{}{
"query_id": ID.String(),
}, "unable to delete the query")
return errors.NewInternalError(ctx, err)
}
if tx.RowsAffected == 0 {
log.Error(ctx, map[string]interface{}{
"query_id": ID.String(),
}, "no row was affected by the delete operation")
return errors.NewNotFoundError("query", ID.String())
}
return nil
} | go | func (r *GormQueryRepository) Delete(ctx context.Context, ID uuid.UUID) error {
defer goa.MeasureSince([]string{"goa", "db", "query", "delete"}, time.Now())
q := Query{ID: ID}
tx := r.db.Delete(q)
if err := tx.Error; err != nil {
log.Error(ctx, map[string]interface{}{
"query_id": ID.String(),
}, "unable to delete the query")
return errors.NewInternalError(ctx, err)
}
if tx.RowsAffected == 0 {
log.Error(ctx, map[string]interface{}{
"query_id": ID.String(),
}, "no row was affected by the delete operation")
return errors.NewNotFoundError("query", ID.String())
}
return nil
} | [
"func",
"(",
"r",
"*",
"GormQueryRepository",
")",
"Delete",
"(",
"ctx",
"context",
".",
"Context",
",",
"ID",
"uuid",
".",
"UUID",
")",
"error",
"{",
"defer",
"goa",
".",
"MeasureSince",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"... | // Delete deletes the query with the given id, returns NotFoundError or InternalError | [
"Delete",
"deletes",
"the",
"query",
"with",
"the",
"given",
"id",
"returns",
"NotFoundError",
"or",
"InternalError"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/query/query.go#L219-L237 |
13,490 | fabric8-services/fabric8-wit | rest/proxy/error.go | ConvertHTTPErrorCode | func ConvertHTTPErrorCode(statusCode int, responseBody string) error {
switch statusCode {
case http.StatusNotFound:
return errors.NewNotFoundErrorFromString(responseBody)
case http.StatusBadRequest:
return errors.NewBadParameterErrorFromString(responseBody)
case http.StatusConflict:
return errors.NewDataConflictError(responseBody)
case http.StatusUnauthorized:
return errors.NewUnauthorizedError(responseBody)
case http.StatusForbidden:
return errors.NewForbiddenError(responseBody)
default:
return errors.NewInternalErrorFromString(responseBody)
}
} | go | func ConvertHTTPErrorCode(statusCode int, responseBody string) error {
switch statusCode {
case http.StatusNotFound:
return errors.NewNotFoundErrorFromString(responseBody)
case http.StatusBadRequest:
return errors.NewBadParameterErrorFromString(responseBody)
case http.StatusConflict:
return errors.NewDataConflictError(responseBody)
case http.StatusUnauthorized:
return errors.NewUnauthorizedError(responseBody)
case http.StatusForbidden:
return errors.NewForbiddenError(responseBody)
default:
return errors.NewInternalErrorFromString(responseBody)
}
} | [
"func",
"ConvertHTTPErrorCode",
"(",
"statusCode",
"int",
",",
"responseBody",
"string",
")",
"error",
"{",
"switch",
"statusCode",
"{",
"case",
"http",
".",
"StatusNotFound",
":",
"return",
"errors",
".",
"NewNotFoundErrorFromString",
"(",
"responseBody",
")",
"\... | // ConvertHTTPErrorCode converts an http status code to an instance of type error | [
"ConvertHTTPErrorCode",
"converts",
"an",
"http",
"status",
"code",
"to",
"an",
"instance",
"of",
"type",
"error"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/rest/proxy/error.go#L9-L31 |
13,491 | fabric8-services/fabric8-wit | token/token.go | NewManager | func NewManager(config tokenManagerConfiguration) (Manager, error) {
// Load public keys from Auth service and add them to the manager
tm := &tokenManager{
publicKeysMap: map[string]*rsa.PublicKey{},
}
keysEndpoint := fmt.Sprintf("%s%s", config.GetAuthServiceURL(), authservice.KeysTokenPath())
remoteKeys, err := authjwk.FetchKeys(keysEndpoint)
if err != nil {
log.Error(nil, map[string]interface{}{
"err": err,
"keys_url": keysEndpoint,
}, "unable to load public keys from remote service")
return nil, errors.New("unable to load public keys from remote service")
}
for _, remoteKey := range remoteKeys {
tm.publicKeysMap[remoteKey.KeyID] = remoteKey.Key
tm.publicKeys = append(tm.publicKeys, &PublicKey{KeyID: remoteKey.KeyID, Key: remoteKey.Key})
log.Info(nil, map[string]interface{}{
"kid": remoteKey.KeyID,
}, "Public key added")
}
devModeURL := config.GetKeycloakDevModeURL()
if devModeURL != "" {
remoteKeys, err = authjwk.FetchKeys(fmt.Sprintf("%s/protocol/openid-connect/certs", devModeURL))
if err != nil {
log.Error(nil, map[string]interface{}{
"err": err,
"keys_url": devModeURL,
}, "unable to load public keys from remote service in Dev Mode")
return nil, errors.New("unable to load public keys from remote service in Dev Mode")
}
for _, remoteKey := range remoteKeys {
tm.publicKeysMap[remoteKey.KeyID] = remoteKey.Key
tm.publicKeys = append(tm.publicKeys, &PublicKey{KeyID: remoteKey.KeyID, Key: remoteKey.Key})
log.Info(nil, map[string]interface{}{
"kid": remoteKey.KeyID,
}, "Public key added")
}
// Add the public key which will be used to verify tokens generated in dev mode
rsaKey, err := jwt.ParseRSAPrivateKeyFromPEM([]byte(configuration.DevModeRsaPrivateKey))
if err != nil {
return nil, err
}
tm.publicKeysMap["test-key"] = &rsaKey.PublicKey
tm.publicKeys = append(tm.publicKeys, &PublicKey{KeyID: "test-key", Key: &rsaKey.PublicKey})
log.Info(nil, map[string]interface{}{
"kid": "test-key",
}, "Public key added")
}
return tm, nil
} | go | func NewManager(config tokenManagerConfiguration) (Manager, error) {
// Load public keys from Auth service and add them to the manager
tm := &tokenManager{
publicKeysMap: map[string]*rsa.PublicKey{},
}
keysEndpoint := fmt.Sprintf("%s%s", config.GetAuthServiceURL(), authservice.KeysTokenPath())
remoteKeys, err := authjwk.FetchKeys(keysEndpoint)
if err != nil {
log.Error(nil, map[string]interface{}{
"err": err,
"keys_url": keysEndpoint,
}, "unable to load public keys from remote service")
return nil, errors.New("unable to load public keys from remote service")
}
for _, remoteKey := range remoteKeys {
tm.publicKeysMap[remoteKey.KeyID] = remoteKey.Key
tm.publicKeys = append(tm.publicKeys, &PublicKey{KeyID: remoteKey.KeyID, Key: remoteKey.Key})
log.Info(nil, map[string]interface{}{
"kid": remoteKey.KeyID,
}, "Public key added")
}
devModeURL := config.GetKeycloakDevModeURL()
if devModeURL != "" {
remoteKeys, err = authjwk.FetchKeys(fmt.Sprintf("%s/protocol/openid-connect/certs", devModeURL))
if err != nil {
log.Error(nil, map[string]interface{}{
"err": err,
"keys_url": devModeURL,
}, "unable to load public keys from remote service in Dev Mode")
return nil, errors.New("unable to load public keys from remote service in Dev Mode")
}
for _, remoteKey := range remoteKeys {
tm.publicKeysMap[remoteKey.KeyID] = remoteKey.Key
tm.publicKeys = append(tm.publicKeys, &PublicKey{KeyID: remoteKey.KeyID, Key: remoteKey.Key})
log.Info(nil, map[string]interface{}{
"kid": remoteKey.KeyID,
}, "Public key added")
}
// Add the public key which will be used to verify tokens generated in dev mode
rsaKey, err := jwt.ParseRSAPrivateKeyFromPEM([]byte(configuration.DevModeRsaPrivateKey))
if err != nil {
return nil, err
}
tm.publicKeysMap["test-key"] = &rsaKey.PublicKey
tm.publicKeys = append(tm.publicKeys, &PublicKey{KeyID: "test-key", Key: &rsaKey.PublicKey})
log.Info(nil, map[string]interface{}{
"kid": "test-key",
}, "Public key added")
}
return tm, nil
} | [
"func",
"NewManager",
"(",
"config",
"tokenManagerConfiguration",
")",
"(",
"Manager",
",",
"error",
")",
"{",
"// Load public keys from Auth service and add them to the manager",
"tm",
":=",
"&",
"tokenManager",
"{",
"publicKeysMap",
":",
"map",
"[",
"string",
"]",
"... | // NewManager returns a new token Manager for handling tokens | [
"NewManager",
"returns",
"a",
"new",
"token",
"Manager",
"for",
"handling",
"tokens"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/token/token.go#L70-L123 |
13,492 | fabric8-services/fabric8-wit | token/token.go | NewManagerWithPublicKey | func NewManagerWithPublicKey(id string, key *rsa.PublicKey) Manager {
return &tokenManager{
publicKeysMap: map[string]*rsa.PublicKey{id: key},
publicKeys: []*PublicKey{{KeyID: id, Key: key}},
}
} | go | func NewManagerWithPublicKey(id string, key *rsa.PublicKey) Manager {
return &tokenManager{
publicKeysMap: map[string]*rsa.PublicKey{id: key},
publicKeys: []*PublicKey{{KeyID: id, Key: key}},
}
} | [
"func",
"NewManagerWithPublicKey",
"(",
"id",
"string",
",",
"key",
"*",
"rsa",
".",
"PublicKey",
")",
"Manager",
"{",
"return",
"&",
"tokenManager",
"{",
"publicKeysMap",
":",
"map",
"[",
"string",
"]",
"*",
"rsa",
".",
"PublicKey",
"{",
"id",
":",
"key... | // NewManagerWithPublicKey returns a new token Manager for handling tokens with the only public key | [
"NewManagerWithPublicKey",
"returns",
"a",
"new",
"token",
"Manager",
"for",
"handling",
"tokens",
"with",
"the",
"only",
"public",
"key"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/token/token.go#L126-L131 |
13,493 | fabric8-services/fabric8-wit | token/token.go | ParseToken | func (mgm *tokenManager) ParseToken(ctx context.Context, tokenString string) (*TokenClaims, error) {
token, err := jwt.ParseWithClaims(tokenString, &TokenClaims{}, func(token *jwt.Token) (interface{}, error) {
kid, ok := token.Header["kid"]
if !ok {
log.Error(ctx, map[string]interface{}{}, "There is no 'kid' header in the token")
return nil, errors.New("there is no 'kid' header in the token")
}
key := mgm.PublicKey(fmt.Sprintf("%s", kid))
if key == nil {
log.Error(ctx, map[string]interface{}{
"kid": kid,
}, "There is no public key with such ID")
return nil, errors.Errorf("there is no public key with such ID: %s", kid)
}
return key, nil
})
if err != nil {
return nil, err
}
claims := token.Claims.(*TokenClaims)
if token.Valid {
return claims, nil
}
return nil, errors.WithStack(errors.New("token is not valid"))
} | go | func (mgm *tokenManager) ParseToken(ctx context.Context, tokenString string) (*TokenClaims, error) {
token, err := jwt.ParseWithClaims(tokenString, &TokenClaims{}, func(token *jwt.Token) (interface{}, error) {
kid, ok := token.Header["kid"]
if !ok {
log.Error(ctx, map[string]interface{}{}, "There is no 'kid' header in the token")
return nil, errors.New("there is no 'kid' header in the token")
}
key := mgm.PublicKey(fmt.Sprintf("%s", kid))
if key == nil {
log.Error(ctx, map[string]interface{}{
"kid": kid,
}, "There is no public key with such ID")
return nil, errors.Errorf("there is no public key with such ID: %s", kid)
}
return key, nil
})
if err != nil {
return nil, err
}
claims := token.Claims.(*TokenClaims)
if token.Valid {
return claims, nil
}
return nil, errors.WithStack(errors.New("token is not valid"))
} | [
"func",
"(",
"mgm",
"*",
"tokenManager",
")",
"ParseToken",
"(",
"ctx",
"context",
".",
"Context",
",",
"tokenString",
"string",
")",
"(",
"*",
"TokenClaims",
",",
"error",
")",
"{",
"token",
",",
"err",
":=",
"jwt",
".",
"ParseWithClaims",
"(",
"tokenSt... | // ParseToken parses token claims | [
"ParseToken",
"parses",
"token",
"claims"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/token/token.go#L149-L173 |
13,494 | fabric8-services/fabric8-wit | token/token.go | CheckClaims | func CheckClaims(claims *TokenClaims) error {
if claims.Subject == "" {
return errors.New("subject claim not found in token")
}
_, err := uuid.FromString(claims.Subject)
if err != nil {
return errors.New("subject claim from token is not UUID " + err.Error())
}
if claims.Username == "" {
return errors.New("username claim not found in token")
}
if claims.Email == "" {
return errors.New("email claim not found in token")
}
return nil
} | go | func CheckClaims(claims *TokenClaims) error {
if claims.Subject == "" {
return errors.New("subject claim not found in token")
}
_, err := uuid.FromString(claims.Subject)
if err != nil {
return errors.New("subject claim from token is not UUID " + err.Error())
}
if claims.Username == "" {
return errors.New("username claim not found in token")
}
if claims.Email == "" {
return errors.New("email claim not found in token")
}
return nil
} | [
"func",
"CheckClaims",
"(",
"claims",
"*",
"TokenClaims",
")",
"error",
"{",
"if",
"claims",
".",
"Subject",
"==",
"\"",
"\"",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"uuid",
".",
"FromStri... | // CheckClaims checks if all the required claims are present in the access token | [
"CheckClaims",
"checks",
"if",
"all",
"the",
"required",
"claims",
"are",
"present",
"in",
"the",
"access",
"token"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/token/token.go#L206-L221 |
13,495 | fabric8-services/fabric8-wit | token/token.go | ReadManagerFromContext | func ReadManagerFromContext(ctx context.Context) (*Manager, error) {
tm := tokencontext.ReadTokenManagerFromContext(ctx)
if tm == nil {
log.Error(ctx, map[string]interface{}{
"token": tm,
}, "missing token manager")
return nil, errors.New("Missing token manager")
}
tokenManager := tm.(Manager)
return &tokenManager, nil
} | go | func ReadManagerFromContext(ctx context.Context) (*Manager, error) {
tm := tokencontext.ReadTokenManagerFromContext(ctx)
if tm == nil {
log.Error(ctx, map[string]interface{}{
"token": tm,
}, "missing token manager")
return nil, errors.New("Missing token manager")
}
tokenManager := tm.(Manager)
return &tokenManager, nil
} | [
"func",
"ReadManagerFromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"Manager",
",",
"error",
")",
"{",
"tm",
":=",
"tokencontext",
".",
"ReadTokenManagerFromContext",
"(",
"ctx",
")",
"\n",
"if",
"tm",
"==",
"nil",
"{",
"log",
".",
"E... | // ReadManagerFromContext extracts the token manager from the context | [
"ReadManagerFromContext",
"extracts",
"the",
"token",
"manager",
"from",
"the",
"context"
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/token/token.go#L224-L235 |
13,496 | fabric8-services/fabric8-wit | iteration/state.go | CheckValid | func (s State) CheckValid() error {
switch s {
case StateNew, StateStart, StateClose:
return nil
default:
return errors.NewBadParameterError("iteration state", s).Expected(StateNew + "|" + StateStart + "|" + StateClose)
}
} | go | func (s State) CheckValid() error {
switch s {
case StateNew, StateStart, StateClose:
return nil
default:
return errors.NewBadParameterError("iteration state", s).Expected(StateNew + "|" + StateStart + "|" + StateClose)
}
} | [
"func",
"(",
"s",
"State",
")",
"CheckValid",
"(",
")",
"error",
"{",
"switch",
"s",
"{",
"case",
"StateNew",
",",
"StateStart",
",",
"StateClose",
":",
"return",
"nil",
"\n",
"default",
":",
"return",
"errors",
".",
"NewBadParameterError",
"(",
"\"",
"\... | // CheckValid returns nil if the given iteration state is valid; otherwise a
// BadParameterError is returned. | [
"CheckValid",
"returns",
"nil",
"if",
"the",
"given",
"iteration",
"state",
"is",
"valid",
";",
"otherwise",
"a",
"BadParameterError",
"is",
"returned",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/iteration/state.go#L58-L65 |
13,497 | fabric8-services/fabric8-wit | workitem/workitemtype.go | Validate | func (wit WorkItemType) Validate() error {
if strings.TrimSpace(wit.Name) == "" {
return errs.Errorf(`work item type name "%s" when trimmed has a zero-length`, wit.Name)
}
if err := wit.Fields.Validate(); err != nil {
return errs.Wrapf(err, "failed to validate work item type's fields")
}
return nil
} | go | func (wit WorkItemType) Validate() error {
if strings.TrimSpace(wit.Name) == "" {
return errs.Errorf(`work item type name "%s" when trimmed has a zero-length`, wit.Name)
}
if err := wit.Fields.Validate(); err != nil {
return errs.Wrapf(err, "failed to validate work item type's fields")
}
return nil
} | [
"func",
"(",
"wit",
"WorkItemType",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"strings",
".",
"TrimSpace",
"(",
"wit",
".",
"Name",
")",
"==",
"\"",
"\"",
"{",
"return",
"errs",
".",
"Errorf",
"(",
"`work item type name \"%s\" when trimmed has a zero-leng... | // Validate runs some checks on the work item type to ensure the field
// definitions make sense. | [
"Validate",
"runs",
"some",
"checks",
"on",
"the",
"work",
"item",
"type",
"to",
"ensure",
"the",
"field",
"definitions",
"make",
"sense",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitemtype.go#L120-L128 |
13,498 | fabric8-services/fabric8-wit | workitem/workitemtype.go | strPtrIsNilOrContentIsEqual | func strPtrIsNilOrContentIsEqual(l, r *string) bool {
if l == nil && r != nil {
return false
}
if l != nil && r == nil {
return false
}
if l == nil && r == nil {
return true
}
return *l == *r
} | go | func strPtrIsNilOrContentIsEqual(l, r *string) bool {
if l == nil && r != nil {
return false
}
if l != nil && r == nil {
return false
}
if l == nil && r == nil {
return true
}
return *l == *r
} | [
"func",
"strPtrIsNilOrContentIsEqual",
"(",
"l",
",",
"r",
"*",
"string",
")",
"bool",
"{",
"if",
"l",
"==",
"nil",
"&&",
"r",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"l",
"!=",
"nil",
"&&",
"r",
"==",
"nil",
"{",
"return",
"f... | // returns true if the left hand and right hand side string
// pointers either both point to nil or reference the same
// content; otherwise false is returned. | [
"returns",
"true",
"if",
"the",
"left",
"hand",
"and",
"right",
"hand",
"side",
"string",
"pointers",
"either",
"both",
"point",
"to",
"nil",
"or",
"reference",
"the",
"same",
"content",
";",
"otherwise",
"false",
"is",
"returned",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitemtype.go#L159-L170 |
13,499 | fabric8-services/fabric8-wit | workitem/workitemtype.go | Equal | func (wit WorkItemType) Equal(u convert.Equaler) bool {
other, ok := u.(WorkItemType)
if !ok {
return false
}
if wit.ID != other.ID {
return false
}
if !convert.CascadeEqual(wit.Lifecycle, other.Lifecycle) {
return false
}
if wit.Version != other.Version {
return false
}
if wit.Name != other.Name {
return false
}
if wit.Extends != other.Extends {
return false
}
if wit.CanConstruct != other.CanConstruct {
return false
}
if !reflect.DeepEqual(wit.Description, other.Description) {
return false
}
if wit.Icon != other.Icon {
return false
}
if wit.Path != other.Path {
return false
}
if len(wit.ChildTypeIDs) != len(other.ChildTypeIDs) {
return false
}
for i := range wit.ChildTypeIDs {
if wit.ChildTypeIDs[i] != other.ChildTypeIDs[i] {
return false
}
}
if len(wit.Fields) != len(other.Fields) {
return false
}
for witKey, witVal := range wit.Fields {
otherVal, keyFound := other.Fields[witKey]
if !keyFound {
return false
}
if !convert.CascadeEqual(witVal, otherVal) {
return false
}
}
if wit.SpaceTemplateID != other.SpaceTemplateID {
return false
}
return true
} | go | func (wit WorkItemType) Equal(u convert.Equaler) bool {
other, ok := u.(WorkItemType)
if !ok {
return false
}
if wit.ID != other.ID {
return false
}
if !convert.CascadeEqual(wit.Lifecycle, other.Lifecycle) {
return false
}
if wit.Version != other.Version {
return false
}
if wit.Name != other.Name {
return false
}
if wit.Extends != other.Extends {
return false
}
if wit.CanConstruct != other.CanConstruct {
return false
}
if !reflect.DeepEqual(wit.Description, other.Description) {
return false
}
if wit.Icon != other.Icon {
return false
}
if wit.Path != other.Path {
return false
}
if len(wit.ChildTypeIDs) != len(other.ChildTypeIDs) {
return false
}
for i := range wit.ChildTypeIDs {
if wit.ChildTypeIDs[i] != other.ChildTypeIDs[i] {
return false
}
}
if len(wit.Fields) != len(other.Fields) {
return false
}
for witKey, witVal := range wit.Fields {
otherVal, keyFound := other.Fields[witKey]
if !keyFound {
return false
}
if !convert.CascadeEqual(witVal, otherVal) {
return false
}
}
if wit.SpaceTemplateID != other.SpaceTemplateID {
return false
}
return true
} | [
"func",
"(",
"wit",
"WorkItemType",
")",
"Equal",
"(",
"u",
"convert",
".",
"Equaler",
")",
"bool",
"{",
"other",
",",
"ok",
":=",
"u",
".",
"(",
"WorkItemType",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"wit",
".... | // Equal returns true if two WorkItemType objects are equal; otherwise false is returned. | [
"Equal",
"returns",
"true",
"if",
"two",
"WorkItemType",
"objects",
"are",
"equal",
";",
"otherwise",
"false",
"is",
"returned",
"."
] | 54759c80c42ff2cf29b352e0f6c9330ce4ad7fce | https://github.com/fabric8-services/fabric8-wit/blob/54759c80c42ff2cf29b352e0f6c9330ce4ad7fce/workitem/workitemtype.go#L173-L229 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.