func TestConvertExistingWorkItem(t *testing.T) {
resource.Require(t, resource.Database)
// Setting up the dependent tracker query and tracker data in the Database
tr := Tracker{URL: "https://api.github.com/", Type: ProviderGithub}
db = db.Create(&tr)
require.Nil(t, db.Error)
tq := TrackerQuery{Query: "some random query", Schedule: "0 0 0 * * *", TrackerID: tr.ID}
db = db.Create(&tq)
require.Nil(t, db.Error)
defer cleaner.DeleteCreatedEntities(db)()
t.Log("Created Tracker Query and Tracker")
models.Transactional(db, func(tx *gorm.DB) error {
t.Log("Adding a work item which wasn't present.")
remoteItemData := TrackerItemContent{
Content: []byte(`{"title":"linking","url":"http://github.com/sbose/api/testonly/1","state":"closed","body":"body of issue","user.login":"******","assignee.login":"******"}`),
ID: "http://github.com/sbose/api/testonly/1",
}
workItem, err := convert(tx, int(tq.ID), remoteItemData, ProviderGithub)
assert.Nil(t, err)
assert.Equal(t, "linking", workItem.Fields[workitem.SystemTitle])
assert.Equal(t, "sbose78", workItem.Fields[workitem.SystemCreator])
assert.Equal(t, "pranav", workItem.Fields[workitem.SystemAssignees].([]interface{})[0])
assert.Equal(t, "closed", workItem.Fields[workitem.SystemState])
return errors.WithStack(err)
})
t.Log("Updating the existing work item when it's reimported.")
models.Transactional(db, func(tx *gorm.DB) error {
remoteItemDataUpdated := TrackerItemContent{
Content: []byte(`{"title":"linking-updated","url":"http://github.com/api/testonly/1","state":"closed","body":"body of issue","user.login":"******","assignee.login":"******"}`),
ID: "http://github.com/sbose/api/testonly/1",
}
workItemUpdated, err := convert(tx, int(tq.ID), remoteItemDataUpdated, ProviderGithub)
assert.Nil(t, err)
assert.Equal(t, "linking-updated", workItemUpdated.Fields[workitem.SystemTitle])
assert.Equal(t, "sbose78", workItemUpdated.Fields[workitem.SystemCreator])
assert.Equal(t, "pranav", workItemUpdated.Fields[workitem.SystemAssignees].([]interface{})[0])
assert.Equal(t, "closed", workItemUpdated.Fields[workitem.SystemState])
wir := workitem.NewWorkItemRepository(tx)
wir.Delete(context.Background(), workItemUpdated.ID)
return errors.WithStack(err)
})
}
func TestMain(m *testing.M) {
var err error
if err = configuration.Setup(""); err != nil {
panic(fmt.Errorf("Failed to setup the configuration: %s", err.Error()))
}
if _, c := os.LookupEnv(resource.Database); c != false {
DB, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
panic("Failed to connect database: " + err.Error())
}
defer DB.Close()
// Make sure the database is populated with the correct types (e.g. bug etc.)
if configuration.GetPopulateCommonTypes() {
if err := models.Transactional(DB, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(context.Background(), tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
panic(err.Error())
}
}
// RemoteWorkItemScheduler now available for all other test cases
RwiScheduler = remoteworkitem.NewScheduler(DB)
}
os.Exit(func() int {
c := m.Run()
RwiScheduler.Stop()
return c
}())
}
// Create runs the create action.
func (c *UserspaceController) Create(ctx *app.CreateUserspaceContext) error {
return models.Transactional(c.db, func(db *gorm.DB) error {
path := ctx.RequestURI
data := Data{}
err := c.db.Where("path = ?", path).First(&data).Error
fmt.Println(err)
if err != nil {
data = Data{
ID: uuid.NewV4(),
Path: ctx.RequestURI,
Data: workitem.Fields(ctx.Payload),
}
err := c.db.Create(&data).Error
if err != nil {
goa.LogError(ctx, "error adding data", "error", err.Error())
return ctx.InternalServerError()
}
} else {
err := c.db.Model(&data).Update("data", workitem.Fields(ctx.Payload)).Error
if err != nil {
goa.LogError(ctx, "error updating data", "error", err.Error())
return ctx.InternalServerError()
}
}
return ctx.NoContent()
})
}
// The SetupSuite method will run before the tests in the suite are run.
// It sets up a database connection for all the tests in this suite without polluting global space.
func (s *workItemLinkTypeSuite) SetupSuite() {
var err error
if err = configuration.Setup(""); err != nil {
panic(fmt.Errorf("Failed to setup the configuration: %s", err.Error()))
}
s.db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
panic("Failed to connect database: " + err.Error())
}
// Make sure the database is populated with the correct types (e.g. bug etc.)
if err := models.Transactional(DB, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(context.Background(), tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
panic(err.Error())
}
svc := goa.New("workItemLinkTypeSuite-Service")
require.NotNil(s.T(), svc)
s.linkTypeCtrl = NewWorkItemLinkTypeController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.linkTypeCtrl)
s.linkCatCtrl = NewWorkItemLinkCategoryController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.linkCatCtrl)
// s.typeCtrl = NewWorkitemtypeController(svc, gormapplication.NewGormDB(DB))
// require.NotNil(s.T(), s.typeCtrl)
}
// The SetupSuite method will run before the tests in the suite are run.
// It sets up a database connection for all the tests in this suite without polluting global space.
func (s *workItemTypeSuite) SetupSuite() {
s.DBTestSuite.SetupSuite()
// Make sure the database is populated with the correct types (e.g. bug etc.)
if _, c := os.LookupEnv(resource.Database); c != false {
if err := models.Transactional(s.DB, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(context.Background(), tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
panic(err.Error())
}
}
}
// Show shows the record
func (c *UserspaceController) Show(ctx *app.ShowUserspaceContext) error {
return models.Transactional(c.db, func(db *gorm.DB) error {
path := ctx.RequestURI
data := Data{}
err := c.db.Where("path = ?", path).First(&data).Error
if err != nil {
return ctx.NotFound()
}
return ctx.OK(data.Data)
})
}
// The SetupSuite method will run before the tests in the suite are run.
// It sets up a database connection for all the tests in this suite without polluting global space.
func (s *workItemLinkSuite) SetupSuite() {
var err error
if err = configuration.Setup(""); err != nil {
panic(fmt.Errorf("Failed to setup the configuration: %s", err.Error()))
}
s.db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
panic("Failed to connect database: " + err.Error())
}
// Make sure the database is populated with the correct types (e.g. bug etc.)
if err := models.Transactional(DB, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(context.Background(), tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
panic(err.Error())
}
require.Nil(s.T(), err)
priv, err := almtoken.ParsePrivateKey([]byte(almtoken.RSAPrivateKey))
require.Nil(s.T(), err)
svc := goa.New("TestWorkItemLinkType-Service")
require.NotNil(s.T(), svc)
s.workItemLinkTypeCtrl = NewWorkItemLinkTypeController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemLinkTypeCtrl)
svc = goa.New("TestWorkItemLinkCategory-Service")
require.NotNil(s.T(), svc)
s.workItemLinkCategoryCtrl = NewWorkItemLinkCategoryController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemLinkCategoryCtrl)
svc = goa.New("TestWorkItemLink-Service")
require.NotNil(s.T(), svc)
s.workItemLinkCtrl = NewWorkItemLinkController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemLinkCtrl)
svc = goa.New("TestWorkItemRelationshipsLinks-Service")
require.NotNil(s.T(), svc)
s.workItemRelsLinksCtrl = NewWorkItemRelationshipsLinksController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemRelsLinksCtrl)
s.workItemSvc = testsupport.ServiceAsUser("TestWorkItem-Service", almtoken.NewManagerWithPrivateKey(priv), testsupport.TestIdentity)
require.NotNil(s.T(), s.workItemSvc)
s.workItemCtrl = NewWorkitemController(svc, gormapplication.NewGormDB(DB))
require.NotNil(s.T(), s.workItemCtrl)
}
func (s *searchRepositoryWhiteboxTest) TestSearchByID() {
models.Transactional(s.DB, func(tx *gorm.DB) error {
wir := workitem.NewWorkItemRepository(tx)
workItem := app.WorkItem{Fields: make(map[string]interface{})}
workItem.Fields = map[string]interface{}{
workitem.SystemTitle: "Search Test Sbose",
workitem.SystemDescription: rendering.NewMarkupContentFromLegacy("Description"),
workitem.SystemCreator: "sbose78",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "closed",
}
createdWorkItem, err := wir.Create(context.Background(), workitem.SystemBug, workItem.Fields, testsupport.TestIdentity.ID.String())
if err != nil {
s.T().Fatalf("Couldn't create test data: %+v", err)
}
defer wir.Delete(context.Background(), createdWorkItem.ID)
// Create a new workitem to have the ID in it's title. This should not come
// up in search results
workItem.Fields[workitem.SystemTitle] = "Search test sbose " + createdWorkItem.ID
_, err = wir.Create(context.Background(), workitem.SystemBug, workItem.Fields, testsupport.TestIdentity.ID.String())
if err != nil {
s.T().Fatalf("Couldn't create test data: %+v", err)
}
sr := NewGormSearchRepository(tx)
var start, limit int = 0, 100
searchString := "id:" + createdWorkItem.ID
workItemList, _, err := sr.SearchFullText(context.Background(), searchString, &start, &limit)
if err != nil {
s.T().Fatal("Error gettig search result ", err)
}
// ID is unique, hence search result set's length should be 1
assert.Equal(s.T(), len(workItemList), 1)
for _, workItemValue := range workItemList {
s.T().Log("Found search result for ID Search ", workItemValue.ID)
assert.Equal(s.T(), createdWorkItem.ID, workItemValue.ID)
}
return errors.WithStack(err)
})
}
func TestConvertGithubIssue(t *testing.T) {
resource.Require(t, resource.Database)
defer cleaner.DeleteCreatedEntities(db)()
t.Log("Scenario 3 : Mapping and persisting a Github issue")
tr := Tracker{URL: "https://api.github.com/", Type: ProviderGithub}
db = db.Create(&tr)
require.Nil(t, db.Error)
tq := TrackerQuery{Query: "some random query", Schedule: "0 0 0 * * *", TrackerID: tr.ID}
db.Create(&tq)
models.Transactional(db, func(tx *gorm.DB) error {
content, err := test.LoadTestData("github_issue_mapping.json", func() ([]byte, error) {
return provideRemoteData(GitIssueWithAssignee)
})
if err != nil {
t.Fatal(err)
}
remoteItemDataGithub := TrackerItemContent{
Content: content[:],
ID: GitIssueWithAssignee, // GH issue url
}
workItemGithub, err := convert(tx, int(tq.ID), remoteItemDataGithub, ProviderGithub)
assert.Nil(t, err)
assert.Equal(t, "map flatten : test case : with assignee", workItemGithub.Fields[workitem.SystemTitle])
assert.Equal(t, "sbose78", workItemGithub.Fields[workitem.SystemCreator])
assert.Equal(t, "sbose78", workItemGithub.Fields[workitem.SystemAssignees].([]interface{})[0])
assert.Equal(t, "open", workItemGithub.Fields[workitem.SystemState])
return errors.WithStack(err)
})
}
func TestMain(m *testing.M) {
var err error
if err = configuration.Setup(""); err != nil {
panic(fmt.Errorf("Failed to setup the configuration: %s", err.Error()))
}
if _, c := os.LookupEnv(resource.Database); c {
db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
panic("Failed to connect database: " + err.Error())
}
defer db.Close()
// Make sure the database is populated with the correct types (e.g. bug etc.)
if err := models.Transactional(db, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(context.Background(), tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
panic(err.Error())
}
}
os.Exit(m.Run())
}
// ScheduleAllQueries fetch and import of remote tracker items
func (s *Scheduler) ScheduleAllQueries() {
cr.Stop()
trackerQueries := fetchTrackerQueries(s.db)
for _, tq := range trackerQueries {
cr.AddFunc(tq.Schedule, func() {
tr := lookupProvider(tq)
for i := range tr.Fetch() {
models.Transactional(s.db, func(tx *gorm.DB) error {
// Save the remote items in a 'temporary' table.
err := upload(tx, tq.TrackerID, i)
if err != nil {
return errors.WithStack(err)
}
// Convert the remote item into a local work item and persist in the DB.
_, err = convert(tx, tq.TrackerID, i, tq.TrackerType)
return errors.WithStack(err)
})
}
})
}
cr.Start()
}
func (s *searchRepositoryWhiteboxTest) TestSearchByText() {
wir := workitem.NewWorkItemRepository(s.DB)
testDataSet := []SearchTestDescriptor{
{
wi: app.WorkItem{
Fields: map[string]interface{}{
workitem.SystemTitle: "test sbose title '12345678asdfgh'",
workitem.SystemDescription: rendering.NewMarkupContentFromLegacy(`"description" for search test`),
workitem.SystemCreator: "sbose78",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "closed",
},
},
searchString: `Sbose "deScription" '12345678asdfgh' `,
minimumResults: 1,
},
{
wi: app.WorkItem{
Fields: map[string]interface{}{
workitem.SystemTitle: "add new error types in models/errors.go'",
workitem.SystemDescription: rendering.NewMarkupContentFromLegacy(`Make sure remoteworkitem can access..`),
workitem.SystemCreator: "sbose78",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "closed",
},
},
searchString: `models/errors.go remoteworkitem `,
minimumResults: 1,
},
{
wi: app.WorkItem{
Fields: map[string]interface{}{
workitem.SystemTitle: "test sbose title '12345678asdfgh'",
workitem.SystemDescription: rendering.NewMarkupContentFromLegacy(`"description" for search test`),
workitem.SystemCreator: "sbose78",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "closed",
},
},
searchString: `Sbose "deScription" '12345678asdfgh' `,
minimumResults: 1,
},
{
wi: app.WorkItem{
// will test behaviour when null fields are present. In this case, "system.description" is nil
Fields: map[string]interface{}{
workitem.SystemTitle: "test nofield sbose title '12345678asdfgh'",
workitem.SystemCreator: "sbose78",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "closed",
},
},
searchString: `sbose nofield `,
minimumResults: 1,
},
{
wi: app.WorkItem{
// will test behaviour when null fields are present. In this case, "system.description" is nil
Fields: map[string]interface{}{
workitem.SystemTitle: "test should return 0 results'",
workitem.SystemCreator: "sbose78",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "closed",
},
},
searchString: `negative case `,
minimumResults: 0,
}, {
wi: app.WorkItem{
// search stirng with braces should be acceptable case
Fields: map[string]interface{}{
workitem.SystemTitle: "Bug reported by administrator for input = (value)",
workitem.SystemCreator: "pgore",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "new",
},
},
searchString: `(value) `,
minimumResults: 1,
}, {
wi: app.WorkItem{
// search stirng with surrounding braces should be acceptable case
Fields: map[string]interface{}{
workitem.SystemTitle: "trial for braces (pranav) {shoubhik} [aslak]",
workitem.SystemCreator: "pgore",
workitem.SystemAssignees: []string{"pranav"},
workitem.SystemState: "new",
},
},
searchString: `(pranav) {shoubhik} [aslak] `,
minimumResults: 1,
},
}
models.Transactional(s.DB, func(tx *gorm.DB) error {
for _, testData := range testDataSet {
workItem := testData.wi
searchString := testData.searchString
minimumResults := testData.minimumResults
workItemURLInSearchString := "http://demo.almighty.io/work-item/list/detail/"
createdWorkItem, err := wir.Create(context.Background(), workitem.SystemBug, workItem.Fields, testsupport.TestIdentity.ID.String())
if err != nil {
s.T().Fatal("Couldnt create test data")
}
defer wir.Delete(context.Background(), createdWorkItem.ID)
// create the URL and use it in the search string
workItemURLInSearchString = workItemURLInSearchString + createdWorkItem.ID
// had to dynamically create this since I didn't now the URL/ID of the workitem
// till the test data was created.
searchString = searchString + workItemURLInSearchString
searchString = fmt.Sprintf("\"%s\"", searchString)
s.T().Log("using search string: " + searchString)
sr := NewGormSearchRepository(tx)
var start, limit int = 0, 100
workItemList, _, err := sr.SearchFullText(context.Background(), searchString, &start, &limit)
if err != nil {
s.T().Fatal("Error getting search result ", err)
}
searchString = strings.Trim(searchString, "\"")
// Since this test adds test data, whether or not other workitems exist
// there must be at least 1 search result returned.
if len(workItemList) == minimumResults && minimumResults == 0 {
// no point checking further, we got what we wanted.
continue
} else if len(workItemList) < minimumResults {
s.T().Fatalf("At least %d search results was expected ", minimumResults)
}
// These keywords need a match in the textual part.
allKeywords := strings.Fields(searchString)
allKeywords = append(allKeywords, createdWorkItem.ID)
//[]string{workItemURLInSearchString, createdWorkItem.ID, `"Sbose"`, `"deScription"`, `'12345678asdfgh'`}
// These keywords need a match optionally either as URL string or ID
optionalKeywords := []string{workItemURLInSearchString, createdWorkItem.ID}
// We will now check the legitimacy of the search results.
// Iterate through all search results and see whether they meet the criteria
for _, workItemValue := range workItemList {
s.T().Log("Found search result ", workItemValue.ID)
for _, keyWord := range allKeywords {
workItemTitle := ""
if workItemValue.Fields[workitem.SystemTitle] != nil {
workItemTitle = strings.ToLower(workItemValue.Fields[workitem.SystemTitle].(string))
}
workItemDescription := ""
if workItemValue.Fields[workitem.SystemDescription] != nil {
descriptionField := workItemValue.Fields[workitem.SystemDescription].(rendering.MarkupContent)
workItemDescription = strings.ToLower(descriptionField.Content)
}
keyWord = strings.ToLower(keyWord)
if strings.Contains(workItemTitle, keyWord) || strings.Contains(workItemDescription, keyWord) {
// Check if the search keyword is present as text in the title/description
s.T().Logf("Found keyword %s in workitem %s", keyWord, workItemValue.ID)
} else if stringInSlice(keyWord, optionalKeywords) && strings.Contains(keyWord, workItemValue.ID) {
// If not present in title/description then it should be a URL or ID
s.T().Logf("Found keyword %s as ID %s from the URL", keyWord, workItemValue.ID)
} else {
s.T().Errorf("%s neither found in title %s nor in the description: %s", keyWord, workItemTitle, workItemDescription)
}
}
//defer wir.Delete(context.Background(), workItemValue.ID)
}
}
return nil
})
}
func main() {
// --------------------------------------------------------------------
// Parse flags
// --------------------------------------------------------------------
var configFilePath string
var printConfig bool
var migrateDB bool
var scheduler *remoteworkitem.Scheduler
flag.StringVar(&configFilePath, "config", "", "Path to the config file to read")
flag.BoolVar(&printConfig, "printConfig", false, "Prints the config (including merged environment variables) and exits")
flag.BoolVar(&migrateDB, "migrateDatabase", false, "Migrates the database to the newest version and exits.")
flag.Parse()
// Override default -config switch with environment variable only if -config switch was
// not explicitly given via the command line.
configSwitchIsSet := false
flag.Visit(func(f *flag.Flag) {
if f.Name == "config" {
configSwitchIsSet = true
}
})
if !configSwitchIsSet {
if envConfigPath, ok := os.LookupEnv("ALMIGHTY_CONFIG_FILE_PATH"); ok {
configFilePath = envConfigPath
}
}
var err error
if err = configuration.Setup(configFilePath); err != nil {
logrus.Panic(nil, map[string]interface{}{
"configFilePath": configFilePath,
"err": err,
}, "failed to setup the configuration")
}
if printConfig {
os.Exit(0)
}
// Initialized developer mode flag for the logger
log.InitializeLogger(configuration.IsPostgresDeveloperModeEnabled())
printUserInfo()
var db *gorm.DB
for {
db, err = gorm.Open("postgres", configuration.GetPostgresConfigString())
if err != nil {
db.Close()
log.Logger().Errorf("ERROR: Unable to open connection to database %v\n", err)
log.Logger().Infof("Retrying to connect in %v...\n", configuration.GetPostgresConnectionRetrySleep())
time.Sleep(configuration.GetPostgresConnectionRetrySleep())
} else {
defer db.Close()
break
}
}
if configuration.IsPostgresDeveloperModeEnabled() {
db = db.Debug()
}
// Migrate the schema
err = migration.Migrate(db.DB())
if err != nil {
log.Panic(nil, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed migration")
}
// Nothing to here except exit, since the migration is already performed.
if migrateDB {
os.Exit(0)
}
// Make sure the database is populated with the correct types (e.g. bug etc.)
if configuration.GetPopulateCommonTypes() {
// set a random request ID for the context
ctx, req_id := client.ContextWithRequestID(context.Background())
log.Debug(ctx, nil, "Initializing the population of the database... Request ID: %v", req_id)
if err := models.Transactional(db, func(tx *gorm.DB) error {
return migration.PopulateCommonTypes(ctx, tx, workitem.NewWorkItemTypeRepository(tx))
}); err != nil {
log.Panic(ctx, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to populate common types")
}
if err := models.Transactional(db, func(tx *gorm.DB) error {
return migration.BootstrapWorkItemLinking(ctx, link.NewWorkItemLinkCategoryRepository(tx), link.NewWorkItemLinkTypeRepository(tx))
}); err != nil {
log.Panic(ctx, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to bootstap work item linking")
}
}
// Scheduler to fetch and import remote tracker items
scheduler = remoteworkitem.NewScheduler(db)
defer scheduler.Stop()
scheduler.ScheduleAllQueries()
// Create service
service := goa.New("alm")
// Mount middleware
service.Use(middleware.RequestID())
service.Use(middleware.LogRequest(configuration.IsPostgresDeveloperModeEnabled()))
service.Use(gzip.Middleware(9))
service.Use(jsonapi.ErrorHandler(service, true))
service.Use(middleware.Recover())
service.WithLogger(goalogrus.New(log.Logger()))
publicKey, err := token.ParsePublicKey(configuration.GetTokenPublicKey())
if err != nil {
log.Panic(nil, map[string]interface{}{
"err": fmt.Sprintf("%+v", err),
}, "failed to parse public token")
}
// Setup Account/Login/Security
identityRepository := account.NewIdentityRepository(db)
userRepository := account.NewUserRepository(db)
tokenManager := token.NewManager(publicKey)
app.UseJWTMiddleware(service, jwt.New(publicKey, nil, app.NewJWTSecurity()))
service.Use(login.InjectTokenManager(tokenManager))
// Mount "login" controller
oauth := &oauth2.Config{
ClientID: configuration.GetKeycloakClientID(),
ClientSecret: configuration.GetKeycloakSecret(),
Scopes: []string{"user:email"},
Endpoint: oauth2.Endpoint{
AuthURL: configuration.GetKeycloakEndpointAuth(),
TokenURL: configuration.GetKeycloakEndpointToken(),
},
}
appDB := gormapplication.NewGormDB(db)
loginService := login.NewKeycloakOAuthProvider(oauth, identityRepository, userRepository, tokenManager, appDB)
loginCtrl := NewLoginController(service, loginService, tokenManager)
app.MountLoginController(service, loginCtrl)
// Mount "status" controller
statusCtrl := NewStatusController(service, db)
app.MountStatusController(service, statusCtrl)
// Mount "workitem" controller
workitemCtrl := NewWorkitemController(service, appDB)
app.MountWorkitemController(service, workitemCtrl)
// Mount "workitemtype" controller
workitemtypeCtrl := NewWorkitemtypeController(service, appDB)
app.MountWorkitemtypeController(service, workitemtypeCtrl)
// Mount "work item link category" controller
workItemLinkCategoryCtrl := NewWorkItemLinkCategoryController(service, appDB)
app.MountWorkItemLinkCategoryController(service, workItemLinkCategoryCtrl)
// Mount "work item link type" controller
workItemLinkTypeCtrl := NewWorkItemLinkTypeController(service, appDB)
app.MountWorkItemLinkTypeController(service, workItemLinkTypeCtrl)
// Mount "work item link" controller
workItemLinkCtrl := NewWorkItemLinkController(service, appDB)
app.MountWorkItemLinkController(service, workItemLinkCtrl)
// Mount "work item comments" controller
workItemCommentsCtrl := NewWorkItemCommentsController(service, appDB)
app.MountWorkItemCommentsController(service, workItemCommentsCtrl)
// Mount "work item relationships links" controller
workItemRelationshipsLinksCtrl := NewWorkItemRelationshipsLinksController(service, appDB)
app.MountWorkItemRelationshipsLinksController(service, workItemRelationshipsLinksCtrl)
// Mount "comments" controller
commentsCtrl := NewCommentsController(service, appDB)
app.MountCommentsController(service, commentsCtrl)
// Mount "tracker" controller
c5 := NewTrackerController(service, appDB, scheduler)
app.MountTrackerController(service, c5)
// Mount "trackerquery" controller
c6 := NewTrackerqueryController(service, appDB, scheduler)
app.MountTrackerqueryController(service, c6)
// Mount "space" controller
spaceCtrl := NewSpaceController(service, appDB)
app.MountSpaceController(service, spaceCtrl)
// Mount "user" controller
userCtrl := NewUserController(service, appDB, tokenManager)
app.MountUserController(service, userCtrl)
// Mount "search" controller
searchCtrl := NewSearchController(service, appDB)
app.MountSearchController(service, searchCtrl)
// Mount "indentity" controller
identityCtrl := NewIdentityController(service, appDB)
app.MountIdentityController(service, identityCtrl)
// Mount "users" controller
usersCtrl := NewUsersController(service, appDB)
app.MountUsersController(service, usersCtrl)
// Mount "iterations" controller
iterationCtrl := NewIterationController(service, appDB)
app.MountIterationController(service, iterationCtrl)
// Mount "spaceiterations" controller
spaceIterationCtrl := NewSpaceIterationsController(service, appDB)
app.MountSpaceIterationsController(service, spaceIterationCtrl)
// Mount "userspace" controller
userspaceCtrl := NewUserspaceController(service, db)
app.MountUserspaceController(service, userspaceCtrl)
// Mount "render" controller
renderCtrl := NewRenderController(service)
app.MountRenderController(service, renderCtrl)
// Mount "areas" controller
areaCtrl := NewAreaController(service, appDB)
app.MountAreaController(service, areaCtrl)
spaceAreaCtrl := NewSpaceAreasController(service, appDB)
app.MountSpaceAreasController(service, spaceAreaCtrl)
log.Logger().Infoln("Git Commit SHA: ", Commit)
log.Logger().Infoln("UTC Build Time: ", BuildTime)
log.Logger().Infoln("UTC Start Time: ", StartTime)
log.Logger().Infoln("Dev mode: ", configuration.IsPostgresDeveloperModeEnabled())
http.Handle("/api/", service.Mux)
http.Handle("/", http.FileServer(assetFS()))
http.Handle("/favicon.ico", http.NotFoundHandler())
// Start http
if err := http.ListenAndServe(configuration.GetHTTPAddress(), nil); err != nil {
log.Error(nil, map[string]interface{}{
"addr": configuration.GetHTTPAddress(),
"err": err,
}, "unable to connect to server")
service.LogError("startup", "err", err)
}
}