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) } }