├── favicon.ico
├── Dockerfile
├── startApp.sh
├── gondalfConfig.json
├── setup.md
├── util_test.go
├── License.md
├── db_test.go
├── structs.go
├── scheduledJobs.go
├── server.go
├── dbStructs.go
├── Godeps
    └── Godeps.json
├── db.go
├── handlers.go
├── util.go
├── README.md
├── handlerUtils.go
├── handlerUtils_test.go
└── coverage.html


/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/thezelus/gondalf/HEAD/favicon.ico


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
1 | FROM golang:1.3.3-onbuild
2 | CMD ["./gondalf"]
3 | CMD bash -C "./startApp.sh"
4 | EXPOSE 3000


--------------------------------------------------------------------------------
/startApp.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 | 
3 | go run db.go dbStructs.go handlers.go handlerUtils.go structs.go util.go scheduledJobs.go server.go $1
4 | 


--------------------------------------------------------------------------------
/gondalfConfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "dbUsername": "postgres",
 3 |     "dbPassword": "postgres",
 4 |     "dbHost": "localhost",
 5 |     "dbPort": "5432",
 6 |     "dbName": "gondalf",
 7 |     "dbSSLmode": "disable",
 8 |     "dbMaxIdleConnections": "10",
 9 |     "dbMaxOpenConnections": "100",
10 |     "appPort":"3000",
11 |     "appGracefulShutdownTimeinSeconds":"10",
12 |     "appPropertiesRefreshTimeinMinutes":"10"
13 | }


--------------------------------------------------------------------------------
/setup.md:
--------------------------------------------------------------------------------
 1 | ###Project setup###
 2 | 
 3 | go get github.com/go-martini/martini
 4 | 
 5 | go get github.com/martini-contrib/binding
 6 | 
 7 | go get github.com/jinzhu/gorm
 8 | 
 9 | go get github.com/lib/pq
10 | 
11 | go get github.com/gosimple/conf
12 | 
13 | go get code.google.com/p/go-uuid/uuid
14 | 
15 | go get code.google.com/p/go.crypto/bcrypt
16 | 
17 | go get github.com/martini-contrib/render
18 | 
19 | go get github.com/stretchr/graceful
20 | 
21 | 
22 | ####To run the server####
23 | 
24 | (For initializing db)
25 | 
26 | go run *.go -initdb=true
27 | 
28 | ####Test dependencies####
29 | 
30 | go get github.com/axw/gocov/gocov
31 | 
32 | go get gopkg.in/matm/v1/gocov-html
33 | 
34 | go get gopkg.in/check.v1
35 | 
36 | To generate coverage report run "gocov test | gocov-html > coverage.html"
37 | 
38 | 
39 | 


--------------------------------------------------------------------------------
/util_test.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"testing"
 5 | 	. "gopkg.in/check.v1"
 6 | )
 7 | 
 8 | func TestUtilMethods(t *testing.T) {
 9 | 	TestingT(t)
10 | }
11 | 
12 | type UtilTestSuite struct{}
13 | 
14 | var _ = Suite(&UtilTestSuite{})
15 | 
16 | func (suite *UtilTestSuite) SetUpSuite(c *C) {
17 | 	initDbFlag := false
18 | 	InitApp(testLogFile, &initDbFlag)
19 | 	TRACE.Println("UtilTestSuite Setup")
20 | }
21 | 
22 | func (suite *UtilTestSuite) TearDownSuite(c *C) {
23 | 	TRACE.Println("UtilTestSuite TearDown")
24 | 	defer cleanUpAfterShutdown()
25 | }
26 | 
27 | func (suite *UtilTestSuite) TestGetAppProperties(c *C) {
28 | 	TRACE.Println("Running test: TestGetAppProperties")
29 | 
30 | 	webtimeOut, err := GetAppProperties("WebTimeOut")
31 | 	c.Assert(webtimeOut, Equals, "30")
32 | 	c.Assert(err, IsNil)
33 | 
34 | 	invalidProperty, err := GetAppProperties("InvalidProperty")
35 | 	c.Assert(invalidProperty, Equals, "")
36 | 	c.Assert(err.Error(), Equals, "App property InvalidProperty not set")
37 | }
38 | 


--------------------------------------------------------------------------------
/License.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Abhishek Sharma
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/db_test.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"testing"
 5 | 	. "gopkg.in/check.v1"
 6 | )
 7 | 
 8 | func TestDbMethods(t *testing.T) {
 9 | 	TestingT(t)
10 | }
11 | 
12 | type DbMethodsTestSuite struct{}
13 | 
14 | var _ = Suite(&DbMethodsTestSuite{})
15 | 
16 | func (suite *DbMethodsTestSuite) SetUpSuite(c *C) {
17 | 	initDbFlag := false
18 | 	InitApp(testLogFile, &initDbFlag)
19 | 	TRACE.Println("DbMethodsTestSuite Setup")
20 | }
21 | 
22 | func (suite *DbMethodsTestSuite) TearDownSuite(c *C) {
23 | 	TRACE.Println("DbMethodsTestSuite TearDown")
24 | 	defer cleanUpAfterShutdown()
25 | }
26 | 
27 | func (suite *DbMethodsTestSuite) TestInsertAppPropertiesMultipleTimes(c *C) {
28 | 	TRACE.Println("Running test: TestInsertAppPropertiesMultipleTimes")
29 | 	tx := dbConnection.Begin()
30 | 
31 | 	c.Check(InsertAppProperties(tx), Equals, true)
32 | 
33 | 	c.Assert(InsertAppProperties(tx), Equals, true)
34 | 
35 | 	tx.Rollback()
36 | }
37 | 
38 | func (suite *DbMethodsTestSuite) TestInsertDeviceTypesMultipleTimes(c *C) {
39 | 	TRACE.Println("Running test: TestInsertDeviceTypesMultipleTimes")
40 | 	tx := dbConnection.Begin()
41 | 
42 | 	c.Check(InsertDeviceTypes(tx), Equals, true)
43 | 
44 | 	c.Assert(InsertDeviceTypes(tx), Equals, true)
45 | 
46 | 	tx.Rollback()
47 | }
48 | 


--------------------------------------------------------------------------------
/structs.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | type ConnectionParameters struct {
 4 | 	username string
 5 | 	password string
 6 | 	host     string
 7 | 	port     string
 8 | 	dbname   string
 9 | 	sslmode  string
10 | }
11 | 
12 | type LoginCredential struct {
13 | 	Username string `json:"username" binding:"required"`
14 | 	Password string `json:"password" binding:"required"`
15 | 	DeviceId int    `json:"deviceId" binding:"required"`
16 | }
17 | 
18 | type CreateUserRequest struct {
19 | 	Username  string `json:"username" binding:"required"`
20 | 	LegalName string `json:"legalname" binding:"required"`
21 | 	Password  string `json:"password" binding:"required"`
22 | }
23 | 
24 | type ValidateUsernameRequest struct {
25 | 	Username string `json:"username" binding:"required"`
26 | }
27 | 
28 | type ChangePasswordRequest struct {
29 | 	Username    string `json:"username" binding:"required"`
30 | 	OldPassword string `json:"oldPassword" binding:"required"`
31 | 	NewPassword string `json:"newPassword" binding:"required"`
32 | 	DeviceId    int    `json:"deviceId" binding:"required"`
33 | }
34 | 
35 | type ValidateSessionTokenRequest struct {
36 | 	SessionToken string `json:"sessionToken" binding:"required"`
37 | }
38 | 
39 | type CheckPermissionRequest struct {
40 | 	UserId                int64  `json:"userId" binding:"required"`
41 | 	PermissionDescription string `json:"permissionDescription" binding:"required"`
42 | }
43 | 
44 | type ErrorResponse struct {
45 | 	Status      string `json:"status" binding:"required"`
46 | 	Message     string `json:"message" binding:"required"`
47 | 	Description string `json:"description"`
48 | }
49 | 


--------------------------------------------------------------------------------
/scheduledJobs.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/spf13/viper"
 5 | 	"strconv"
 6 | 	"time"
 7 | )
 8 | 
 9 | func StartScheduledJobs() {
10 | 	JobRefreshAppProperties()
11 | 	JobArchiveExpiredSessionToken()
12 | }
13 | 
14 | func JobRefreshAppProperties() {
15 | 
16 | 	LoadConfigurationFromFile()
17 | 	appPropertiesRefreshTimeinMinutes, err := strconv.Atoi(viper.GetString("appPropertiesRefreshTimeinMinutes"))
18 | 	if err != nil {
19 | 		ERROR.Panicln("appPropertiesRefreshTimeinMinutes missing from the config file")
20 | 	}
21 | 
22 | 	ticker := time.NewTicker(time.Duration(appPropertiesRefreshTimeinMinutes) * time.Minute)
23 | 	TRACE.Println("Starting goroutine for refreshing app properties")
24 | 	go func() {
25 | 		for {
26 | 			select {
27 | 			case <-ticker.C:
28 | 				LoadAppPropertiesFromDb()
29 | 			case <-quit:
30 | 				TRACE.Println("Quit signal: JobRefreshAppProperties")
31 | 				ticker.Stop()
32 | 			}
33 | 		}
34 | 	}()
35 | }
36 | 
37 | func JobArchiveExpiredSessionToken() {
38 | 
39 | 	tokenCleanUpFrequencyString, err := GetAppProperties("TokenCleanUpFrequency")
40 | 	if err != nil {
41 | 		ERROR.Println(err.Error())
42 | 	}
43 | 
44 | 	tokenCleanUpFrequencyInteger, err := strconv.Atoi(tokenCleanUpFrequencyString)
45 | 	if err != nil {
46 | 		ERROR.Println("String to integer conversion failed for TokenCleanUpFrequency reverting to default value of 180 minutes")
47 | 		tokenCleanUpFrequencyInteger = 180
48 | 	}
49 | 
50 | 	ticker := time.NewTicker(time.Duration(tokenCleanUpFrequencyInteger) * time.Minute)
51 | 	TRACE.Println("Starting goroutine for token archiving")
52 | 	go func() {
53 | 		for {
54 | 			select {
55 | 			case <-ticker.C:
56 | 				ArchiveTokenAfterCutOffTime(&dbConnection)
57 | 			case <-quit:
58 | 				TRACE.Println("Quit signal: JobArchiveExpiredSessionToken")
59 | 			}
60 | 		}
61 | 	}()
62 | 
63 | }
64 | 


--------------------------------------------------------------------------------
/server.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"flag"
 5 | 	"os"
 6 | 	"strconv"
 7 | 	"time"
 8 | 
 9 | 	"github.com/go-martini/martini"
10 | 	"github.com/jinzhu/gorm"
11 | 	"github.com/martini-contrib/binding"
12 | 	"github.com/martini-contrib/render"
13 | 	"github.com/spf13/viper"
14 | 	"github.com/stretchr/graceful"
15 | )
16 | 
17 | var (
18 | 	dbConnection gorm.DB
19 | 	configName   = "gondalfConfig"
20 | 	logFile      = "gondalf.log"
21 | 	testLogFile  = "testLogs.log"
22 | 	properties   []AppProperties
23 | 	file         *os.File
24 | 	quit         = make(chan struct{})
25 | )
26 | 
27 | func main() {
28 | 
29 | 	initializeDB := flag.Bool("initdb", false, "initalizing database")
30 | 	flag.Parse()
31 | 
32 | 	InitApp(logFile, initializeDB)
33 | 
34 | 	m := martini.Classic()
35 | 	m.Use(render.Renderer())
36 | 	m.Use(martini.Recovery())
37 | 
38 | 	//status
39 | 	m.Get("/status", StatusHandler)
40 | 
41 | 	//Login end point
42 | 	m.Post("/auth/login", binding.Bind(LoginCredential{}), LoginHandler)
43 | 
44 | 	//Create new user
45 | 	m.Post("/user/create", binding.Bind(CreateUserRequest{}), CreateUserHandler)
46 | 
47 | 	//Validate unique username
48 | 	m.Post("/validate/username", binding.Bind(ValidateUsernameRequest{}), ValidateUsernameHandler)
49 | 
50 | 	//Validate session token
51 | 	m.Post("/validate/token", binding.Bind(ValidateSessionTokenRequest{}), ValidateSessionTokenHandler)
52 | 
53 | 	//Change password
54 | 	m.Post("/user/changePassword", binding.Bind(ChangePasswordRequest{}), ChangePasswordHandler)
55 | 
56 | 	//Check permission
57 | 	m.Post("/user/checkPermission", binding.Bind(CheckPermissionRequest{}), CheckPermissionsForUserHandler)
58 | 
59 | 	appGracefulShutdownTimeinSeconds, err := strconv.Atoi(viper.GetString("appGracefulShutdownTimeinSeconds"))
60 | 	if err != nil {
61 | 		ERROR.Panicln("Cannot start the server, shutdown time missing from config file")
62 | 	}
63 | 
64 | 	graceful.Run(":"+viper.GetString("appPort"), time.Duration(appGracefulShutdownTimeinSeconds)*time.Second, m)
65 | 
66 | 	defer cleanUpAfterShutdown()
67 | }
68 | 
69 | func cleanUpAfterShutdown() {
70 | 	//TRACE.Println("Sending kill signal to all routines by closing quit channel")
71 | 	//close(quit)
72 | 
73 | 	TRACE.Println("Cleaning up dbConnection and file stream")
74 | 	dbConnection.Close()
75 | 	file.Close()
76 | }
77 | 


--------------------------------------------------------------------------------
/dbStructs.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "time"
 4 | 
 5 | type User struct {
 6 | 	Id        int64
 7 | 	UserName  string    `sql:"size:256;not null;unique"`
 8 | 	LegalName string    `sql:"size:256;not null"`
 9 | 	Password  string    `sql:"not null"`
10 | 	UpdatedAt time.Time `sql:"not null"`
11 | 	Active    bool      `sql:"not null"`
12 | }
13 | 
14 | type Permission struct {
15 | 	Id                    int64
16 | 	PermissionDescription string `sql:"not null; size: 512"`
17 | }
18 | 
19 | type Group struct {
20 | 	Id               int64
21 | 	GroupDescription string `sql:"not null; size: 512"`
22 | }
23 | 
24 | type GroupPermission struct {
25 | 	Id           int64
26 | 	GroupId      int64 `sql:"not null"`
27 | 	PermissionId int64 `sql:"not null"`
28 | }
29 | 
30 | type UserGroup struct {
31 | 	Id      int64
32 | 	UserId  int64 `sql:"not null"`
33 | 	GroupId int64 `sql:"not null"`
34 | }
35 | 
36 | type AppProperties struct {
37 | 	Id            int64
38 | 	PropertyName  string    `sql:"not null;unique"`
39 | 	PropertyValue string    `sql:"type:varchar(256);not null"`
40 | 	UpdatedAt     time.Time `sql:"not null"`
41 | }
42 | 
43 | type ActivityLog struct {
44 | 	Id           int64
45 | 	UserId       int64     `sql:"not null"`
46 | 	TokenId      int64     `sql:"not null"`
47 | 	ActivityTime time.Time `sql:"not null"`
48 | 	Event        string    `sql:"size:255"`
49 | }
50 | 
51 | type Token struct {
52 | 	Id             int64
53 | 	Token          string `sql:"type:varchar(256);not null;unique"`
54 | 	UserId         int64
55 | 	Key            string `sql:"type:varchar(256);not null"`
56 | 	CreatedAt      time.Time
57 | 	LastAccessedAt time.Time
58 | 	ExpiresAt      time.Time
59 | 	DeviceTypeId   int
60 | 	Active         bool `sql:not null`
61 | }
62 | 
63 | type ArchivedToken struct {
64 | 	Id             int64
65 | 	Token          string `sql:"type:varchar(256);not null;unique"`
66 | 	UserId         int64
67 | 	Key            string `sql:"type:varchar(256);not null"`
68 | 	CreatedAt      time.Time
69 | 	LastAccessedAt time.Time
70 | 	ExpiresAt      time.Time
71 | 	DeviceTypeId   int
72 | 	Active         bool `sql:not null`
73 | }
74 | 
75 | type DeviceType struct {
76 | 	Id         int
77 | 	Device     string `sql:"not null"`
78 | 	DeviceCode int    `sql:"not null;unique"`
79 | }
80 | 
81 | type PasswordRecord struct {
82 | 	Id         int
83 | 	UserId     int64
84 | 	LoginCount int
85 | 	CreatedAt  time.Time
86 | 	UpdatedAt  time.Time
87 | }
88 | 


--------------------------------------------------------------------------------
/Godeps/Godeps.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"ImportPath": "gondalf",
 3 | 	"GoVersion": "go1.3.3",
 4 | 	"Deps": [
 5 | 		{
 6 | 			"ImportPath": "code.google.com/p/go-uuid/uuid",
 7 | 			"Comment": "null-12",
 8 | 			"Rev": "7dda39b2e7d5e265014674c5af696ba4186679e9"
 9 | 		},
10 | 		{
11 | 			"ImportPath": "code.google.com/p/go.crypto/bcrypt",
12 | 			"Comment": "null-212",
13 | 			"Rev": "1064b89a6fb591df0dd65422295b8498916b092f"
14 | 		},
15 | 		{
16 | 			"ImportPath": "code.google.com/p/go.crypto/blowfish",
17 | 			"Comment": "null-212",
18 | 			"Rev": "1064b89a6fb591df0dd65422295b8498916b092f"
19 | 		},
20 | 		{
21 | 			"ImportPath": "github.com/BurntSushi/toml",
22 | 			"Comment": "v0.1.0",
23 | 			"Rev": "2ceedfee35ad3848e49308ab0c9a4f640cfb5fb2"
24 | 		},
25 | 		{
26 | 			"ImportPath": "github.com/codegangsta/inject",
27 | 			"Comment": "v1.0-rc1",
28 | 			"Rev": "37d7f8432a3e684eef9b2edece76bdfa6ac85b39"
29 | 		},
30 | 		{
31 | 			"ImportPath": "github.com/go-martini/martini",
32 | 			"Comment": "v1.0-3-gadaa8f7",
33 | 			"Rev": "adaa8f7fe1224a8f0fac72d23ee80c149b21f0fb"
34 | 		},
35 | 		{
36 | 			"ImportPath": "github.com/jinzhu/gorm",
37 | 			"Rev": "744cb7dfda9ee8c681dc17b540cf8db9fa74f726"
38 | 		},
39 | 		{
40 | 			"ImportPath": "github.com/kr/pretty",
41 | 			"Comment": "go.weekly.2011-12-22-24-gf31442d",
42 | 			"Rev": "f31442d60e51465c69811e2107ae978868dbea5c"
43 | 		},
44 | 		{
45 | 			"ImportPath": "github.com/kr/text",
46 | 			"Rev": "6807e777504f54ad073ecef66747de158294b639"
47 | 		},
48 | 		{
49 | 			"ImportPath": "github.com/lib/pq",
50 | 			"Rev": "50a04ed4e5268fb34ca6d885202b569ef89c0a7a"
51 | 		},
52 | 		{
53 | 			"ImportPath": "github.com/martini-contrib/binding",
54 | 			"Rev": "f506d6896ca9a8d797ab6b3744f74c3bcd05eb7a"
55 | 		},
56 | 		{
57 | 			"ImportPath": "github.com/martini-contrib/render",
58 | 			"Rev": "c8d058a00a82f27bfc8a49d62525b7c60efcf5b8"
59 | 		},
60 | 		{
61 | 			"ImportPath": "github.com/mitchellh/mapstructure",
62 | 			"Rev": "740c764bc6149d3f1806231418adb9f52c11bcbf"
63 | 		},
64 | 		{
65 | 			"ImportPath": "github.com/spf13/cast",
66 | 			"Rev": "770890fb156e3654a3aaa7e696971f7e5a73df4a"
67 | 		},
68 | 		{
69 | 			"ImportPath": "github.com/spf13/jwalterweatherman",
70 | 			"Rev": "e3682f3b5526cf86abc2d415aa312cd5531e3d0a"
71 | 		},
72 | 		{
73 | 			"ImportPath": "github.com/spf13/pflag",
74 | 			"Rev": "463bdc838f2b35e9307e91d480878bda5fff7232"
75 | 		},
76 | 		{
77 | 			"ImportPath": "github.com/spf13/viper",
78 | 			"Rev": "83fd92627cc9834ceccb85544b1fab7bf52150a0"
79 | 		},
80 | 		{
81 | 			"ImportPath": "github.com/stretchr/graceful",
82 | 			"Rev": "1302e8f6efee4be1ed63e592b4a8a95a245a66ba"
83 | 		},
84 | 		{
85 | 			"ImportPath": "gopkg.in/check.v1",
86 | 			"Rev": "871360013c92e1c715c2de6d06b54899468a8a2d"
87 | 		},
88 | 		{
89 | 			"ImportPath": "gopkg.in/yaml.v1",
90 | 			"Rev": "9f9df34309c04878acc86042b16630b0f696e1de"
91 | 		}
92 | 	]
93 | }
94 | 


--------------------------------------------------------------------------------
/db.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"strconv"
  5 | 	"time"
  6 | 
  7 | 	"github.com/jinzhu/gorm"
  8 | 	_ "github.com/lib/pq"
  9 | 	"github.com/spf13/viper"
 10 | )
 11 | 
 12 | //Method to initialize by automigrating new tables and adding columns to old ones.
 13 | //This method doesn't change any existing column types or delete columns.
 14 | //Corresponding DB structures can be found in dbStructs.go
 15 | //App properties entries are also initialized here
 16 | func InitDB() {
 17 | 
 18 | 	dbConnection.AutoMigrate(User{})
 19 | 	dbConnection.AutoMigrate(Permission{})
 20 | 	dbConnection.AutoMigrate(Group{})
 21 | 	dbConnection.AutoMigrate(GroupPermission{})
 22 | 	dbConnection.AutoMigrate(UserGroup{})
 23 | 
 24 | 	dbConnection.AutoMigrate(AppProperties{})
 25 | 	dbConnection.AutoMigrate(ActivityLog{})
 26 | 
 27 | 	dbConnection.AutoMigrate(Token{})
 28 | 	dbConnection.AutoMigrate(ArchivedToken{})
 29 | 	dbConnection.AutoMigrate(DeviceType{})
 30 | 	dbConnection.AutoMigrate(PasswordRecord{})
 31 | 
 32 | 	InsertAppProperties(&dbConnection)
 33 | 	InsertDeviceTypes(&dbConnection)
 34 | }
 35 | 
 36 | func InsertAppProperties(db *gorm.DB) bool {
 37 | 
 38 | 	webTimeOut := AppProperties{PropertyName: "WebTimeOut", PropertyValue: "30", UpdatedAt: time.Now().UTC()}
 39 | 	mobileTimeOut := AppProperties{PropertyName: "MobileTimeOut", PropertyValue: "720", UpdatedAt: time.Now().UTC()}
 40 | 	dbDebugLogs := AppProperties{PropertyName: "DbDebugLogs", PropertyValue: "false", UpdatedAt: time.Now().UTC()}
 41 | 	timeExtension := AppProperties{PropertyName: "TimeExtension", PropertyValue: "5", UpdatedAt: time.Now().UTC()}
 42 | 	tokenCutOffTime := AppProperties{PropertyName: "TokenCutOffTime", PropertyValue: "30", UpdatedAt: time.Now().UTC()}
 43 | 	tokenCleanUpFrequency := AppProperties{PropertyName: "TokenCleanUpFrequency", PropertyValue: "180", UpdatedAt: time.Now().UTC()}
 44 | 
 45 | 	propertiesSlice := []AppProperties{webTimeOut, mobileTimeOut, dbDebugLogs, timeExtension, tokenCutOffTime, tokenCleanUpFrequency}
 46 | 
 47 | 	for i := range propertiesSlice {
 48 | 		existsErr := db.Where(&AppProperties{PropertyName: propertiesSlice[i].PropertyName}).Find(&AppProperties{}).Error
 49 | 		if existsErr == gorm.RecordNotFound {
 50 | 			db.Save(&propertiesSlice[i])
 51 | 		}
 52 | 	}
 53 | 
 54 | 	return true
 55 | }
 56 | 
 57 | func InsertDeviceTypes(db *gorm.DB) bool {
 58 | 	webDevice := DeviceType{Device: "web", DeviceCode: web}
 59 | 	mobileDevice := DeviceType{Device: "mobile", DeviceCode: mobile}
 60 | 
 61 | 	devicesSlice := []DeviceType{webDevice, mobileDevice}
 62 | 
 63 | 	for i := range devicesSlice {
 64 | 		existsErr := db.Where(&devicesSlice[i]).Find(&DeviceType{}).Error
 65 | 		if existsErr == gorm.RecordNotFound {
 66 | 			db.Save(&devicesSlice[i])
 67 | 		}
 68 | 	}
 69 | 
 70 | 	return true
 71 | }
 72 | 
 73 | //Returns a database connection with connection pooling
 74 | func GetDBConnection() gorm.DB {
 75 | 
 76 | 	LoadConfigurationFromFile()
 77 | 
 78 | 	var connParam ConnectionParameters
 79 | 
 80 | 	connParam.username = viper.GetString("dbUsername")
 81 | 	connParam.password = viper.GetString("dbPassword")
 82 | 	connParam.host = viper.GetString("dbHost")
 83 | 	connParam.port = viper.GetString("dbPort")
 84 | 	connParam.dbname = viper.GetString("dbName")
 85 | 	connParam.sslmode = viper.GetString("dbSSLmode")
 86 | 
 87 | 	source := "user=" + connParam.username +
 88 | 		" password=" + connParam.password +
 89 | 		" dbname=" + connParam.dbname +
 90 | 		" port=" + connParam.port +
 91 | 		" host=" + connParam.host +
 92 | 		" sslmode=" + connParam.sslmode
 93 | 
 94 | 	db, err := gorm.Open("postgres", source)
 95 | 
 96 | 	if err != nil {
 97 | 		ERROR.Panicln("Error opening DB connection")
 98 | 	}
 99 | 
100 | 	TRACE.Println("DB Connection opened")
101 | 
102 | 	maxIdleConnections, _ := strconv.Atoi(viper.GetString("dbMaxIdleConnections"))
103 | 	maxOpenConnections, _ := strconv.Atoi(viper.GetString("dbMaxOpenConnections"))
104 | 
105 | 	db.DB().SetMaxIdleConns(maxIdleConnections)
106 | 	db.DB().SetMaxOpenConns(maxOpenConnections)
107 | 	db.DB().Ping()
108 | 
109 | 	return db
110 | }
111 | 


--------------------------------------------------------------------------------
/handlers.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"github.com/martini-contrib/render"
  5 | )
  6 | 
  7 | //Returns current server status
  8 | func StatusHandler(r render.Render) {
  9 | 	r.JSON(200, map[string]interface{}{"status": Status()})
 10 | }
 11 | 
 12 | //Logins a user by checking login credentials, returns a UserToken if login is successful
 13 | func LoginHandler(login LoginCredential, r render.Render) {
 14 | 
 15 | 	authenticateUserErr := AuthenticateUser(login.Username, login.Password, &dbConnection)
 16 | 
 17 | 	if authenticateUserErr == nil {
 18 | 		sessionToken, err := CreateNewTokenDbEntry(login, &dbConnection)
 19 | 		if err != nil {
 20 | 			ERROR.Println(DatabaseError.Error() + " :" + login.Username)
 21 | 			response := ErrorResponse{Status: "Internal Server Error", Message: SystemError.Error(), Description: ""}
 22 | 			r.JSON(500, response)
 23 | 		} else {
 24 | 			r.JSON(200, map[string]interface{}{"sessionToken": sessionToken})
 25 | 		}
 26 | 	} else if authenticateUserErr == FirstLoginPasswordChange {
 27 | 		response := ErrorResponse{Status: "Forbidden", Message: FirstLoginPasswordChange.Error(), Description: ""}
 28 | 		r.JSON(403, response)
 29 | 	} else {
 30 | 		response := ErrorResponse{Status: "Unauthorized", Message: AuthenticationFailed.Error(), Description: ""}
 31 | 		r.JSON(401, response)
 32 | 	}
 33 | }
 34 | 
 35 | func ValidateUsernameHandler(usernameRequest ValidateUsernameRequest, r render.Render) {
 36 | 
 37 | 	validUsernameFlag := ValidateUniqueUsername(usernameRequest.Username, &dbConnection)
 38 | 
 39 | 	r.JSON(200, map[string]interface{}{"valid": validUsernameFlag})
 40 | }
 41 | 
 42 | func CreateUserHandler(request CreateUserRequest, r render.Render) {
 43 | 
 44 | 	status, err := CreateNewUser(request, &dbConnection)
 45 | 	if err != nil {
 46 | 		ERROR.Println(err.Error())
 47 | 		var response ErrorResponse
 48 | 		if status == 500 {
 49 | 			response = ErrorResponse{Status: "Internal Server Error", Message: SystemError.Error(), Description: ""}
 50 | 		} else if status == 409 {
 51 | 			response = ErrorResponse{Status: "Conflict", Message: err.Error(), Description: ""}
 52 | 		}
 53 | 		r.JSON(status, response)
 54 | 	} else {
 55 | 		r.JSON(status, map[string]interface{}{"userCreated": true})
 56 | 	}
 57 | }
 58 | 
 59 | func ChangePasswordHandler(request ChangePasswordRequest, r render.Render) {
 60 | 
 61 | 	authenticateUserError := AuthenticateUser(request.Username, request.OldPassword, &dbConnection)
 62 | 	if authenticateUserError == nil || authenticateUserError == FirstLoginPasswordChange {
 63 | 		status, changePasswordError := ChangePassword(request.Username, request.NewPassword, &dbConnection)
 64 | 		if changePasswordError == nil {
 65 | 			login := LoginCredential{Username: request.Username, Password: request.NewPassword, DeviceId: request.DeviceId}
 66 | 			sessionToken, err := CreateNewTokenDbEntry(login, &dbConnection)
 67 | 			if err == nil {
 68 | 				r.JSON(200, map[string]interface{}{"passwordChanged": true, "sessionToken": sessionToken})
 69 | 			} else {
 70 | 				ERROR.Println("DB entry failed for token, returning 500")
 71 | 				response := ErrorResponse{Status: "Internal Server Error", Message: "Password changed with but encountered: " + SystemError.Error(), Description: ""}
 72 | 				r.JSON(500, response)
 73 | 			}
 74 | 		} else {
 75 | 			var response ErrorResponse
 76 | 			if status == 401 {
 77 | 				response = ErrorResponse{Status: "Unauthorized", Message: AuthenticationFailed.Error(), Description: ""}
 78 | 			} else if status == 500 {
 79 | 				response = ErrorResponse{Status: "Internal Server Error", Message: SystemError.Error(), Description: ""}
 80 | 			}
 81 | 			r.JSON(status, response)
 82 | 		}
 83 | 	} else {
 84 | 		response := ErrorResponse{Status: "Unauthorized", Message: AuthenticationFailed.Error(), Description: ""}
 85 | 		r.JSON(401, response)
 86 | 	}
 87 | 
 88 | }
 89 | 
 90 | func ValidateSessionTokenHandler(request ValidateSessionTokenRequest, r render.Render) {
 91 | 
 92 | 	err, userId := ValidateSessionToken(request.SessionToken, &dbConnection)
 93 | 
 94 | 	if err == nil {
 95 | 		r.JSON(200, map[string]interface{}{"userId": userId})
 96 | 	} else {
 97 | 		ERROR.Println("Error validating sessionToken: " + request.SessionToken + ", error:" + err.Error())
 98 | 		if err == InvalidSessionToken {
 99 | 			response := ErrorResponse{Status: "Unauthorized", Message: InvalidSessionToken.Error(), Description: ""}
100 | 			r.JSON(401, response)
101 | 		} else if err == ExpiredSessionToken {
102 | 			response := ErrorResponse{Status: "Forbidden", Message: ExpiredSessionToken.Error(), Description: ""}
103 | 			r.JSON(403, response)
104 | 		} else {
105 | 			response := ErrorResponse{Status: "Internal Server Error", Message: SystemError.Error(), Description: ""}
106 | 			r.JSON(500, response)
107 | 		}
108 | 	}
109 | }
110 | 
111 | func CheckPermissionsForUserHandler(request CheckPermissionRequest, r render.Render) {
112 | 
113 | 	err := CheckPermissionsForUser(request.UserId, Permission{PermissionDescription: request.PermissionDescription}, &dbConnection)
114 | 
115 | 	if err == nil {
116 | 		r.JSON(200, map[string]interface{}{"permissionCheck": true})
117 | 	} else if err == PermissionDenied {
118 | 		response := ErrorResponse{Status: "Unauthorized", Message: PermissionDenied.Error(), Description: ""}
119 | 		r.JSON(401, response)
120 | 	} else {
121 | 		response := ErrorResponse{Status: "Internal Server Error", Message: SystemError.Error(), Description: ""}
122 | 		r.JSON(500, response)
123 | 	}
124 | 
125 | }
126 | 


--------------------------------------------------------------------------------
/util.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"fmt"
  6 | 	"io"
  7 | 	"log"
  8 | 	"os"
  9 | 	"strconv"
 10 | 	"time"
 11 | 
 12 | 	"github.com/jinzhu/gorm"
 13 | 	"github.com/spf13/viper"
 14 | )
 15 | 
 16 | //Error types:
 17 | //
 18 | //Invalid Session Token
 19 | //Expired Session Token
 20 | //Unregistered User
 21 | //Invalid Password
 22 | //First Login Change Password
 23 | //Authentication Failed
 24 | //Encryption Failed
 25 | //Database Error
 26 | //Permission Denied
 27 | 
 28 | var (
 29 | 	TRACE    *log.Logger
 30 | 	INFO     *log.Logger
 31 | 	WARNING  *log.Logger
 32 | 	ERROR    *log.Logger
 33 | 	DATABASE *log.Logger
 34 | 
 35 | 	InvalidSessionToken      = errors.New("Invalid Session Token")
 36 | 	ExpiredSessionToken      = errors.New("Expired Session Token")
 37 | 	UnregisteredUser         = errors.New("Unregistered User")
 38 | 	IncorrectPassword        = errors.New("Invalid Password")
 39 | 	FirstLoginPasswordChange = errors.New("First Login Change Password")
 40 | 	AuthenticationFailed     = errors.New("Authentication Failed")
 41 | 	EncryptionError          = errors.New("Encryption Failed")
 42 | 	DatabaseError            = errors.New("Database Error")
 43 | 	PermissionDenied         = errors.New("Permission Denied")
 44 | 	SystemError              = errors.New("System Error")
 45 | 	DuplicateUsernameError   = errors.New("Duplicate username")
 46 | )
 47 | 
 48 | //Constant values:
 49 | //For web use 1
 50 | //For mobile use 2
 51 | const (
 52 | 	web    = 1
 53 | 	mobile = 2
 54 | 
 55 | 	LOGIN           = "LOGIN"
 56 | 	PASSWORD_CHANGE = "PASSWORD_CHANGE"
 57 | )
 58 | 
 59 | //Initializes the app by setting up logging file, defaults to stdout in case of error opening the specified file.
 60 | //Opens the DB connection
 61 | //Initialized DB with tables if -initdb=true option is passed when starting the app
 62 | func InitApp(logFileName string, initializeDB *bool) {
 63 | 	var err error
 64 | 	file, err = os.OpenFile(logFileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
 65 | 	if err != nil {
 66 | 		fmt.Println("Log file cannot be opened")
 67 | 		file.Close()
 68 | 		file = os.Stdout
 69 | 	}
 70 | 
 71 | 	InitLogger(file, file, file, file, file)
 72 | 	TRACE.Println("Logger initialized to file " + logFileName)
 73 | 
 74 | 	dbConnection = GetDBConnection()
 75 | 	TRACE.Println("Global connection object initialized")
 76 | 
 77 | 	TRACE.Println(string(strconv.AppendBool([]byte("Application started with Init DB flag value "), *initializeDB)))
 78 | 
 79 | 	if *initializeDB == true {
 80 | 		TRACE.Println("DB Init Start")
 81 | 		InitDB()
 82 | 		TRACE.Println("DB Init Complete")
 83 | 	}
 84 | 
 85 | 	LoadAppPropertiesFromDb()
 86 | 
 87 | 	dbLoggerPropertyValue, err := GetAppProperties("DbDebugLogs")
 88 | 
 89 | 	if err == nil {
 90 | 		dbLoggerFlag, err := strconv.ParseBool(dbLoggerPropertyValue)
 91 | 		if err == nil && dbLoggerFlag {
 92 | 			dbConnection.LogMode(dbLoggerFlag)
 93 | 			dbConnection.SetLogger(DATABASE)
 94 | 			TRACE.Println("Database logger initialized")
 95 | 		}
 96 | 	}
 97 | 
 98 | 	StartScheduledJobs()
 99 | }
100 | 
101 | func InitLogger(traceHandle io.Writer, infoHandle io.Writer, warningHandle io.Writer, errorHandle io.Writer, databaseHandle io.Writer) {
102 | 
103 | 	TRACE = log.New(traceHandle, "TRACE: ", log.Ldate|log.Ltime|log.Lshortfile)
104 | 
105 | 	INFO = log.New(infoHandle, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
106 | 
107 | 	WARNING = log.New(warningHandle, "WARNING: ", log.Ldate|log.Ltime|log.Lshortfile)
108 | 
109 | 	ERROR = log.New(errorHandle, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)
110 | 
111 | 	DATABASE = log.New(databaseHandle, "DATABASE: ", log.Ldate|log.Ltime|log.Lshortfile)
112 | }
113 | 
114 | func GetAppProperties(propertyName string) (string, error) {
115 | 	for index := range properties {
116 | 		if properties[index].PropertyName == propertyName {
117 | 			return properties[index].PropertyValue, nil
118 | 		}
119 | 	}
120 | 	return "", errors.New("App property " + propertyName + " not set")
121 | }
122 | 
123 | func LoadConfigurationFromFile() {
124 | 	TRACE.Println("Loading configuration from " + configName)
125 | 
126 | 	viper.SetConfigName(configName)
127 | 	viper.AddConfigPath(".")
128 | 	err := viper.ReadInConfig()
129 | 
130 | 	if err != nil {
131 | 		panic("Configuration couldn't be initialized, panicking now " + err.Error())
132 | 	}
133 | }
134 | 
135 | func LoadAppPropertiesFromDb() {
136 | 	dbConnection.Find(&properties)
137 | 	TRACE.Println("App properties array initialized at: " + time.Now().String())
138 | }
139 | 
140 | func ArchiveTokenAfterCutOffTime(db *gorm.DB) {
141 | 
142 | 	tokenCutOffTimeString, err := GetAppProperties("TokenCutOffTime")
143 | 	if err != nil {
144 | 		ERROR.Println(err.Error())
145 | 	}
146 | 
147 | 	tokenCutOffTimeInteger, err := strconv.Atoi(tokenCutOffTimeString)
148 | 	if err != nil {
149 | 		ERROR.Println("String to integer conversion failed for TokenCutOffTime, reverting to default value = 30 minutes")
150 | 		tokenCutOffTimeInteger = 30
151 | 	}
152 | 
153 | 	TRACE.Println("Token archiving started at: " + time.Now().String())
154 | 
155 | 	db.Exec("UPDATE TABLE tokens SET active = ? WHERE (SELECT EXTRACT(MINUTE FROM (? - expires_at)) FROM tokens) > ?", false, time.Now().UTC(), tokenCutOffTimeInteger)
156 | 
157 | 	db.Exec("INSERT INTO archived_tokens (token, user_id, key, created_at, last_accessed_at, expires_at, device_type_id, active)(SELECT (token, user_id, key, created_at, last_accessed_at, expires_at, device_type_id, active) WHERE active = ?)", false)
158 | 
159 | 	db.Exec("DELETE FROM tokens WHERE active = ?", false)
160 | 
161 | 	TRACE.Println("Token archiving completed at: " + time.Now().String())
162 | }
163 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Please feel free to create a new issue if you come across one or want a new feature to be added. I am looking for contributors, feel free to send pull requests.
  2 | 
  3 | ##What is Gondalf?##
  4 | Gondalf is a ready to deploy microservice that provides user management, authentication, and role based authorization features out of box. Gondalf is built using [martini](https://github.com/go-martini/martini) and [gorm](https://github.com/jinzhu/gorm), and uses [postgresql](http://www.postgresql.org) as the default database.
  5 | 
  6 | ##Features:##
  7 | 
  8 | ###1. User management###
  9 | - User creation
 10 | - Validating unique username
 11 | - Password change on first login
 12 | - Encrypted password storage
 13 | - Activity logs
 14 | 
 15 | ###2. Authentication###
 16 | - User authentication
 17 | - Token-based authentication
 18 | - Custom token expiry and renewal times
 19 | 
 20 | ###3. Authorization###
 21 | - Role-based authorization including group permissions
 22 | 
 23 | 
 24 | ##Why Gondalf?##
 25 | Over the course of multiple projects I realized that there are some common features that can be packed into a single microservice and can be used right out of the box. Gondalf is the first piece in that set.
 26 | 
 27 | 
 28 | ##TODO List##
 29 | - [X] Add end points for permission checking
 30 | - [X] Input timeout values and server port from config file
 31 | - [X] Refresh app properties from DB after fixed interval
 32 | - [X] Add a cron job for cleaning up and archiving expired session tokens to keep the validation request latency low
 33 | - [X] Dockerize gondalf
 34 | - [X] Refactored the API to include a consistent error payload
 35 | - [ ] Add more events to Activity Logs
 36 | - [ ] Improve documentation - add details about logging, app properties, and configuration 
 37 | - [ ] Switch to [negroni](https://github.com/codegangsta/negroni) and [gorilla mux](http://www.gorillatoolkit.org/pkg/mux)
 38 | - [ ] Add TLS support for the end point
 39 | - [ ] Provide one click deploy solution
 40 | - [ ] Add CI on checkins
 41 | - [ ] Add support for other databases
 42 | 
 43 | 
 44 | ###Why call it *Gondalf* ?###
 45 | 
 46 | Because  <img src="http://www.reactiongifs.com/wp-content/uploads/2013/12/shall-not-pass.gif" width="150px" height="75px"/> and it is Go, so why not both?
 47 | 
 48 | 
 49 |  
 50 | ##Installation Instructions:##
 51 | 
 52 | - Clone the repository in a local directory
 53 | 
 54 | - Database configuration can be set under the the config file named gondalf.config
 55 | 
 56 | - Gondalf creates required tables using the configuration provided in the config file. For this the 
 57 | initdb flag should be set to true when starting the app.
 58 | 
 59 | `$ bash startApp.sh -initdb=true` 
 60 | 
 61 | ###App Properties###
 62 | 
 63 | These are set in a table called "app_properties" and are initially set to default values when the application is started with "intidb" flag.
 64 | 
 65 | - *WebTimeOut* - Defines the inactivity time after which a session token created from web login is considered expired, default value is 30 minutes
 66 | - *MobileTimeOut* - Defines the inactivity time after which a session token created from mobile login is considered expired, default value is 720 minutes
 67 | - *TimeExtension* - Defines the time extension provided to a session token (web or mobile) if it is validated with less than 5 minutes of life time remaining. This is done to avoid stale tokens lingering around on devices. Default set to 5 minutes.
 68 | - *DbDebugLogs* - Flag for turning on printing of database debugging logs, default value is false.
 69 | - *TokenCutOffTime* - Defines the time after which an expired token will be marked for clean-up. Default value is 30 minutes.
 70 | - *TokenCleanUpFrequency* - Defines the frequency of clean-up i.e. time between scheduler execution. Default value is 180 minutes.
 71 | 
 72 | ##Request and Response formats##
 73 | 
 74 | ###Error Codes###
 75 | 
 76 | - Invalid Session Token
 77 | - Expired Session Token
 78 | - Unregistered User
 79 | - Invalid Password
 80 | - First Login Change Password
 81 | - Authentication Failed
 82 | - Encryption Failed
 83 | - Database Error
 84 | - Permission Denied
 85 | - System Error
 86 | - Duplicate Username Error
 87 | 
 88 | ###LoginCredential###
 89 | 
 90 | ####Request####
 91 | 
 92 | ```javascript
 93 | {
 94 |   "username": "test2User",
 95 |   "password" : "testPassword",
 96 |   "deviceId" : 1
 97 | }
 98 | ```
 99 | 
100 | deviceId code 1 for web, 2 for mobile
101 | 
102 | ####Response####
103 | 
104 | ```javascript
105 | {
106 |   "sessionToken": "testSessionToken",
107 | }
108 | ```
109 | 
110 | ###ValidateUsername###
111 | 
112 | For validating unique username
113 | 
114 | ####Request####
115 | 
116 | ```javascript
117 | {
118 | 	"username": "test2User"
119 | }
120 | ```
121 | 
122 | ####Response####
123 | 
124 | ```javascript
125 | {
126 | 	"valid": true
127 | }
128 | ```
129 | 
130 | ###CreateUser###
131 | 
132 | ####Request####
133 | 
134 | ```javascript
135 | {
136 | 	"username": "test2User",
137 | 	"legalname": "testLegalName",
138 | 	"password": "testPassword"
139 | }
140 | ```
141 | ####Response####
142 | 
143 | ```javascript
144 | {
145 | 	"userCreated": true
146 | }
147 | ```
148 | 
149 | ###Change password###
150 | 
151 | ####Request####
152 | 
153 | ```javascript
154 | {
155 | 	"username": "test2User",
156 | 	"oldPassword": "testOldPassword",
157 | 	"newPassword": "newTestPassword",
158 | 	"deviceId": 1
159 | }
160 | ```
161 | 
162 | ####Response####
163 | 
164 | If the old credentials are correct then:
165 | 
166 | ```javascript
167 | {
168 | 	"passwordChanged": true,
169 | 	"sessionToken": "testSessionToken"
170 | }
171 | ```
172 | 
173 | ###Validate Session Token###
174 | 
175 | ####Request####
176 | 
177 | ```javascript
178 | {
179 | 	"sessionToken": "testSessionToken"
180 | }
181 | ```
182 | 
183 | ####Response####
184 | 
185 | ```javascript
186 | {
187 | 	"userId": 1234
188 | }
189 | ```
190 | 
191 | ###Permission Checking###
192 | 
193 | ####Request####
194 | 
195 | ```javascript
196 | {
197 |   "userId": 123456,
198 |   "permissionDescription" : "ADMIN"
199 | }
200 | ````
201 | 
202 | ####Response####
203 | 
204 | ```javascript
205 | {
206 |   "permissionResult" : true
207 | }
208 | ```
209 | 
210 | ###Error Response###
211 | 
212 | ```javascript
213 | {
214 | 	"status": "Internal Server Error" / "Unauthorized" / "Conflict" / "Forbidden",
215 | 	"message": "Invalid Session Token" / "Expired Session Token" etc.,
216 | 	"description": ""
217 | }
218 | ```


--------------------------------------------------------------------------------
/handlerUtils.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"crypto/hmac"
  5 | 	"crypto/sha256"
  6 | 	"encoding/base64"
  7 | 	"errors"
  8 | 	"strconv"
  9 | 	"time"
 10 | 
 11 | 	"code.google.com/p/go-uuid/uuid"
 12 | 	"code.google.com/p/go.crypto/bcrypt"
 13 | 	"github.com/jinzhu/gorm"
 14 | )
 15 | 
 16 | //Authenticates the user by checking username/password against the DB values
 17 | func AuthenticateUser(username string, password string, db *gorm.DB) error {
 18 | 	var user User
 19 | 
 20 | 	dbErr := db.Where(&User{UserName: username}).Find(&user).Error
 21 | 	if dbErr != nil {
 22 | 		if dbErr == gorm.RecordNotFound {
 23 | 			WARNING.Println(UnregisteredUser.Error() + " ,username: " + username)
 24 | 			return UnregisteredUser
 25 | 		} else {
 26 | 			ERROR.Println(dbErr.Error())
 27 | 			return DatabaseError
 28 | 		}
 29 | 	}
 30 | 
 31 | 	TRACE.Println("Login attempt by userId " + strconv.FormatInt(user.Id, 10))
 32 | 	passwordCompareErr := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password))
 33 | 	if passwordCompareErr != nil {
 34 | 		WARNING.Println(passwordCompareErr.Error() + ", userId: " + strconv.FormatInt(user.Id, 10))
 35 | 		return IncorrectPassword
 36 | 	}
 37 | 
 38 | 	var passwordRecord PasswordRecord
 39 | 
 40 | 	dbPasswordRecordErr := db.Where(&PasswordRecord{UserId: user.Id}).Find(&passwordRecord).Error
 41 | 	if dbPasswordRecordErr != nil {
 42 | 		ERROR.Println(dbPasswordRecordErr.Error() + ", userId: " + strconv.FormatInt(user.Id, 10))
 43 | 		return DatabaseError
 44 | 	}
 45 | 
 46 | 	if dbPasswordRecordErr == nil && passwordRecord.LoginCount == 0 {
 47 | 		TRACE.Println(FirstLoginPasswordChange.Error() + ", userId: " + strconv.FormatInt(user.Id, 10))
 48 | 		return FirstLoginPasswordChange
 49 | 	}
 50 | 
 51 | 	TRACE.Println("User authenticated, userId: " + strconv.FormatInt(user.Id, 10))
 52 | 	return nil
 53 | }
 54 | 
 55 | //Create new token entry in the database
 56 | func CreateNewTokenDbEntry(login LoginCredential, db *gorm.DB) (string, error) {
 57 | 	user := User{}
 58 | 	db.Where(&User{UserName: login.Username}).Find(&user)
 59 | 
 60 | 	token := Token{}
 61 | 	token.UserId = user.Id
 62 | 	token.Key = uuid.New()
 63 | 	token.CreatedAt = time.Now().UTC()
 64 | 	token.LastAccessedAt = time.Now().UTC()
 65 | 	token.Token = generateSessionToken(login.Username+token.CreatedAt.String(), token.Key)
 66 | 	token.Active = true
 67 | 	expiryTime, err := GetTimeOutValue(login.DeviceId)
 68 | 	if err != nil {
 69 | 		ERROR.Println(err.Error())
 70 | 		return "", err
 71 | 	}
 72 | 
 73 | 	token.ExpiresAt = expiryTime
 74 | 
 75 | 	var device DeviceType
 76 | 	db.Where(&DeviceType{DeviceCode: login.DeviceId}).Find(&device)
 77 | 
 78 | 	token.DeviceTypeId = device.Id
 79 | 
 80 | 	db.Save(&token)
 81 | 
 82 | 	db.Save(&ActivityLog{UserId: token.UserId, TokenId: token.Id, ActivityTime: time.Now().UTC(), Event: LOGIN})
 83 | 
 84 | 	return token.Token, nil
 85 | }
 86 | 
 87 | //Reads app property to get time out value based on the device ID
 88 | func GetTimeOutValue(deviceId int) (time.Time, error) {
 89 | 
 90 | 	var propName string
 91 | 
 92 | 	if deviceId == web {
 93 | 		propName = "WebTimeOut"
 94 | 	} else if deviceId == mobile {
 95 | 		propName = "MobileTimeOut"
 96 | 	} else {
 97 | 		ERROR.Println("Invalid deviceId")
 98 | 		return time.Time{}, errors.New("Invalid device")
 99 | 	}
100 | 
101 | 	timeOutString, err := GetAppProperties(propName)
102 | 
103 | 	if err != nil {
104 | 		ERROR.Println(err.Error())
105 | 		return time.Time{}, err
106 | 	}
107 | 
108 | 	timeOutValue, err := strconv.Atoi(timeOutString)
109 | 
110 | 	if err != nil {
111 | 		ERROR.Println("String to integer conversion failed for " + propName)
112 | 		return time.Time{}, err
113 | 	}
114 | 
115 | 	expiryTime := time.Now().UTC().Add(time.Duration(timeOutValue) * time.Minute)
116 | 
117 | 	return expiryTime, nil
118 | }
119 | 
120 | //Generates Session Token based on string and key provided
121 | func generateSessionToken(message string, key string) string {
122 | 	keyBytes := []byte(key)
123 | 	h := hmac.New(sha256.New, keyBytes)
124 | 	h.Write([]byte(message))
125 | 	return base64.StdEncoding.EncodeToString(h.Sum(nil))
126 | }
127 | 
128 | func CreateNewUser(request CreateUserRequest, db *gorm.DB) (int, error) {
129 | 
130 | 	var err error
131 | 
132 | 	if ValidateUniqueUsername(request.Username, db) {
133 | 
134 | 		var user User
135 | 
136 | 		user.UserName = request.Username
137 | 		user.LegalName = request.LegalName
138 | 		user.Password, err = EncryptPassword(request.Password)
139 | 		user.UpdatedAt = time.Now().UTC()
140 | 		user.Active = false
141 | 
142 | 		if err != nil {
143 | 			ERROR.Println(err.Error())
144 | 			return 500, EncryptionError
145 | 		}
146 | 
147 | 		db.Save(&user)
148 | 		TRACE.Println("New user created, userId: " + strconv.FormatInt(user.Id, 10))
149 | 
150 | 		db.Save(&PasswordRecord{UserId: user.Id, LoginCount: 0})
151 | 		TRACE.Println("New password record created, userId: " + strconv.FormatInt(user.Id, 10))
152 | 
153 | 		return 200, nil
154 | 	}
155 | 
156 | 	ERROR.Println("Duplicate username " + request.Username + " server validation in create user")
157 | 	return 409, DuplicateUsernameError
158 | }
159 | 
160 | //Returns true if the username is valid i.e. doesn't already exist, else returns false.
161 | func ValidateUniqueUsername(username string, db *gorm.DB) bool {
162 | 
163 | 	TRACE.Println("Validating username " + username)
164 | 	err := db.Where(&User{UserName: username}).First(&User{}).Error
165 | 
166 | 	if err == gorm.RecordNotFound {
167 | 		return true
168 | 	}
169 | 	WARNING.Println("Username " + username + " already present")
170 | 	return false
171 | }
172 | 
173 | func EncryptPassword(password string) (string, error) {
174 | 
175 | 	encryptedPasswordBytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
176 | 
177 | 	if err != nil {
178 | 		return "", err
179 | 	}
180 | 
181 | 	return string(encryptedPasswordBytes), nil
182 | }
183 | 
184 | func Status() string {
185 | 	return "alive at " + time.Now().String()
186 | }
187 | 
188 | func ValidateSessionToken(sessionToken string, db *gorm.DB) (error, int64) {
189 | 	var token Token
190 | 
191 | 	dbErr := db.Where(&Token{Token: sessionToken}).Find(&token).Error
192 | 	if dbErr != nil {
193 | 		if dbErr == gorm.RecordNotFound {
194 | 			WARNING.Println(InvalidSessionToken.Error() + ", sessionToken: " + sessionToken)
195 | 			return InvalidSessionToken, -1
196 | 		}
197 | 		ERROR.Println(dbErr.Error() + ", sessionToken: " + sessionToken)
198 | 		return dbErr, -1
199 | 	}
200 | 
201 | 	if token.Active && token.ExpiresAt.After(time.Now().UTC()) {
202 | 		TRACE.Println("SessionToken validated: " + sessionToken)
203 | 		timeLeft := token.ExpiresAt.Sub(time.Now().UTC())
204 | 		if timeLeft.Minutes() < 5 {
205 | 			token.ExpiresAt = token.ExpiresAt.Add(time.Duration(GetTimeExtension()) * time.Minute)
206 | 		}
207 | 		token.LastAccessedAt = time.Now().UTC()
208 | 		db.Save(&token)
209 | 		return nil, token.UserId
210 | 	}
211 | 
212 | 	return ExpiredSessionToken, -1
213 | }
214 | 
215 | func GetTimeExtension() int {
216 | 
217 | 	timeExtensionString, err := GetAppProperties("TimeExtension")
218 | 	if err != nil {
219 | 		ERROR.Println(err.Error())
220 | 		return 0
221 | 	}
222 | 
223 | 	extension, conversionErr := strconv.Atoi(timeExtensionString)
224 | 	if conversionErr != nil {
225 | 		ERROR.Println(conversionErr.Error())
226 | 		return 0
227 | 	}
228 | 
229 | 	return extension
230 | }
231 | 
232 | func ChangePassword(username string, newpassword string, db *gorm.DB) (int, error) {
233 | 	var user User
234 | 	var err error
235 | 
236 | 	dbErr := db.Where(&User{UserName: username}).Find(&user).Error
237 | 	if dbErr != nil {
238 | 		if dbErr == gorm.RecordNotFound {
239 | 			WARNING.Println(UnregisteredUser.Error() + " ,username: " + username)
240 | 			return 401, UnregisteredUser
241 | 		} else {
242 | 			ERROR.Println(dbErr.Error())
243 | 			return 500, DatabaseError
244 | 		}
245 | 	}
246 | 
247 | 	user.Password, err = EncryptPassword(newpassword)
248 | 	if err != nil {
249 | 		ERROR.Println(err.Error())
250 | 		return 500, EncryptionError
251 | 	}
252 | 
253 | 	db.Save(&user)
254 | 	updatePasswordErr := UpdatePasswordRecordLoginCount(user.Id, false, db)
255 | 
256 | 	if updatePasswordErr != nil {
257 | 		ERROR.Println("Password record not updated for userId: " + strconv.FormatInt(user.Id, 10) + ", Error details: " + updatePasswordErr.Error())
258 | 		return 500, DatabaseError
259 | 	}
260 | 
261 | 	db.Save(&ActivityLog{UserId: user.Id, TokenId: -1, ActivityTime: time.Now().UTC(), Event: PASSWORD_CHANGE})
262 | 	TRACE.Println("Password changed for userId: " + strconv.FormatInt(user.Id, 10))
263 | 
264 | 	return 200, nil
265 | }
266 | 
267 | //UpdatePasswordRecordLoginCount if resetFlag = true, LoginCount it reset to 0 else it is incremented by 1
268 | func UpdatePasswordRecordLoginCount(userid int64, resetFlag bool, db *gorm.DB) error {
269 | 	var record PasswordRecord
270 | 	dbErr := db.Where(&PasswordRecord{UserId: userid}).Find(&record).Error
271 | 	if dbErr != nil {
272 | 		return dbErr
273 | 	}
274 | 
275 | 	if resetFlag {
276 | 		record.LoginCount = 0
277 | 	} else {
278 | 		record.LoginCount++
279 | 	}
280 | 
281 | 	db.Save(&record)
282 | 
283 | 	return nil
284 | }
285 | 
286 | //CheckPermissions for user
287 | //TODO: Refactor with raw sql if performance bottleneck
288 | func CheckPermissionsForUser(userid int64, permission Permission, db *gorm.DB) error {
289 | 	if userid == int64(-1) {
290 | 		return PermissionDenied
291 | 	}
292 | 
293 | 	err := db.Where(&Permission{PermissionDescription: permission.PermissionDescription}).Find(&permission).Error
294 | 	if err != nil {
295 | 		ERROR.Println(err.Error() + " while checking permission for: " + permission.PermissionDescription)
296 | 		return err
297 | 	}
298 | 
299 | 	var groupPermission GroupPermission
300 | 	err = db.Where(&GroupPermission{PermissionId: permission.Id}).Find(&groupPermission).Error
301 | 	if err != nil {
302 | 		ERROR.Println(err.Error() + " while finding groupPermission for: " + strconv.FormatInt(permission.Id, 10))
303 | 		return err
304 | 	}
305 | 
306 | 	var userGroup UserGroup
307 | 	err = db.Where(&UserGroup{UserId: userid, GroupId: groupPermission.GroupId}).Find(&userGroup).Error
308 | 	if err == gorm.RecordNotFound {
309 | 		WARNING.Println(PermissionDenied.Error() + " for user: " + strconv.FormatInt(userid, 10) +
310 | 			" for Permission: " + permission.PermissionDescription)
311 | 		return PermissionDenied
312 | 	} else if err != nil {
313 | 		ERROR.Println(err.Error() + " in UserGroup while searching for userId: " + strconv.FormatInt(userid, 10) +
314 | 			" and groupId: " + strconv.FormatInt(groupPermission.GroupId, 10))
315 | 		return err
316 | 	}
317 | 
318 | 	TRACE.Println("Permission verified for userId: " + strconv.FormatInt(userid, 10) + " , permission: " + permission.PermissionDescription)
319 | 	return nil
320 | }
321 | 
322 | //End session for logout
323 | 


--------------------------------------------------------------------------------
/handlerUtils_test.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"strconv"
  5 | 	"testing"
  6 | 
  7 | 	"code.google.com/p/go.crypto/bcrypt"
  8 | 	"github.com/jinzhu/gorm"
  9 | 	. "gopkg.in/check.v1"
 10 | )
 11 | 
 12 | func TestHandlerUtils(t *testing.T) {
 13 | 	TestingT(t)
 14 | }
 15 | 
 16 | type HandlerUtilsTestSuite struct{}
 17 | 
 18 | var _ = Suite(&HandlerUtilsTestSuite{})
 19 | 
 20 | func (suite *HandlerUtilsTestSuite) SetUpSuite(c *C) {
 21 | 	initDbFlag := false
 22 | 	InitApp(testLogFile, &initDbFlag)
 23 | 	TRACE.Println("HandlerUtilsTestSuite Setup")
 24 | }
 25 | 
 26 | func (suite *HandlerUtilsTestSuite) TearDownSuite(c *C) {
 27 | 	TRACE.Println("HandlerUtilsTestSuite TearDown")
 28 | 	defer cleanUpAfterShutdown()
 29 | }
 30 | 
 31 | func (suite *HandlerUtilsTestSuite) TestGenerateSessionToken(c *C) {
 32 | 	TRACE.Println("Running test: TestGenerateSessionToken")
 33 | 
 34 | 	expectedSessionToken := "8N7PlLvnGgnE2gFU7+AkSxmAc02cXFkOLlFD5gTuOjo="
 35 | 
 36 | 	actualSessionToken := generateSessionToken("testMessage", "testKey")
 37 | 
 38 | 	c.Assert(expectedSessionToken, Equals, actualSessionToken)
 39 | }
 40 | 
 41 | func (suite *HandlerUtilsTestSuite) TestCreateNewUserWithUniqueUsername(c *C) {
 42 | 	TRACE.Println("Running test: TestCreateNewUserWithUniqueUsername")
 43 | 
 44 | 	tx := dbConnection.Begin()
 45 | 
 46 | 	testString := "UniqueTestUser123321"
 47 | 
 48 | 	var testCreateUserRequest CreateUserRequest
 49 | 	testCreateUserRequest.Username = testString
 50 | 	testCreateUserRequest.LegalName = testString
 51 | 	testCreateUserRequest.Password = testString
 52 | 
 53 | 	status, err := CreateNewUser(testCreateUserRequest, tx)
 54 | 
 55 | 	c.Check(err, IsNil)
 56 | 	c.Assert(status, Equals, 200)
 57 | 
 58 | 	var user User
 59 | 
 60 | 	dbErr := tx.Where(&User{UserName: testString}).First(&user).Error
 61 | 	c.Assert(dbErr, IsNil)
 62 | 	comparePasswordErr := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(testString))
 63 | 	c.Assert(comparePasswordErr, IsNil)
 64 | 
 65 | 	var passwordRecord PasswordRecord
 66 | 	tx.Where(&PasswordRecord{UserId: user.Id}).Find(&passwordRecord)
 67 | 	c.Assert(passwordRecord.LoginCount, Equals, 0)
 68 | 
 69 | 	tx.Rollback()
 70 | }
 71 | 
 72 | func (suite *HandlerUtilsTestSuite) TestCreateNewUserWithDuplicateUsername(c *C) {
 73 | 	TRACE.Println("Running test: TestCreateNewUserWithDuplicateUsername")
 74 | 
 75 | 	tx := dbConnection.Begin()
 76 | 
 77 | 	testString := "UniqueTestUser123321"
 78 | 
 79 | 	var testCreateUserRequest CreateUserRequest
 80 | 	testCreateUserRequest.Username = testString
 81 | 	testCreateUserRequest.LegalName = testString
 82 | 	testCreateUserRequest.Password = testString
 83 | 
 84 | 	status, err := CreateNewUser(testCreateUserRequest, tx)
 85 | 
 86 | 	c.Check(err, IsNil)
 87 | 	c.Assert(status, Equals, 200)
 88 | 
 89 | 	dbErr := tx.Where(&User{UserName: testString}).First(&User{}).Error
 90 | 
 91 | 	c.Assert(dbErr, IsNil)
 92 | 
 93 | 	statusDuplicateEntry, err := CreateNewUser(testCreateUserRequest, tx)
 94 | 
 95 | 	c.Check(statusDuplicateEntry, Equals, 409)
 96 | 	c.Assert(err, NotNil)
 97 | 
 98 | 	tx.Rollback()
 99 | }
100 | 
101 | func (suite *HandlerUtilsTestSuite) TestCreateNewTokenDbEntry(c *C) {
102 | 	TRACE.Println("Running test: TestCreateNewTokenDbEntry")
103 | 
104 | 	tx := dbConnection.Begin()
105 | 
106 | 	testString := "UniqueTestUser123321"
107 | 
108 | 	var testCreateUserRequest = CreateUserRequest{Username: testString,
109 | 		LegalName: testString, Password: testString}
110 | 
111 | 	status, err := CreateNewUser(testCreateUserRequest, tx)
112 | 
113 | 	c.Check(err, IsNil)
114 | 	c.Assert(status, Equals, 200)
115 | 
116 | 	var user User
117 | 	dbErr := tx.Where(&User{UserName: testString}).Find(&user).Error
118 | 	c.Assert(dbErr, IsNil)
119 | 
120 | 	var testLoginCredential = LoginCredential{Username: testString, Password: testString,
121 | 		DeviceId: web}
122 | 
123 | 	sessionToken, err := CreateNewTokenDbEntry(testLoginCredential, tx)
124 | 
125 | 	var token Token
126 | 	dbErr = tx.Where(&Token{Token: sessionToken}).Find(&token).Error
127 | 	c.Assert(dbErr, IsNil)
128 | 
129 | 	var activityLog ActivityLog
130 | 	dbErr = tx.Where(&ActivityLog{UserId: user.Id, TokenId: token.Id}).Find(&activityLog).Error
131 | 	c.Assert(dbErr, IsNil)
132 | 
133 | 	tx.Rollback()
134 | }
135 | 
136 | func (suite *HandlerUtilsTestSuite) TestGetTimeOutValue(c *C) {
137 | 
138 | 	var err error
139 | 
140 | 	_, err = GetTimeOutValue(web)
141 | 	c.Assert(err, IsNil)
142 | 
143 | 	_, err = GetTimeOutValue(mobile)
144 | 	c.Assert(err, IsNil)
145 | 
146 | 	_, err = GetTimeOutValue(-100)
147 | 	c.Assert(err.Error(), Equals, "Invalid device")
148 | }
149 | 
150 | func (suite *HandlerUtilsTestSuite) TestAuthenticateUser(c *C) {
151 | 	TRACE.Println("Running test: TestAuthenticateUser")
152 | 	tx := dbConnection.Begin()
153 | 
154 | 	testString := "UniqueTestUser123321"
155 | 
156 | 	testCreateUserRequest := CreateUserRequest{Username: testString, LegalName: testString, Password: testString}
157 | 	status, err := CreateNewUser(testCreateUserRequest, tx)
158 | 
159 | 	c.Assert(status, Equals, 200)
160 | 	c.Assert(err, IsNil)
161 | 
162 | 	validLoginCredential := LoginCredential{Username: testString, Password: testString, DeviceId: mobile}
163 | 	invalidLoginCredentialWrongPassword := LoginCredential{Username: testString, Password: "invalid", DeviceId: mobile}
164 | 	invalidLoginCredentialWrongUsername := LoginCredential{Username: "invalid", Password: testString, DeviceId: mobile}
165 | 
166 | 	c.Assert(AuthenticateUser(validLoginCredential.Username, validLoginCredential.Password, tx), Equals, FirstLoginPasswordChange)
167 | 	c.Assert(AuthenticateUser(invalidLoginCredentialWrongPassword.Username, invalidLoginCredentialWrongPassword.Password, tx), Equals, IncorrectPassword)
168 | 	c.Assert(AuthenticateUser(invalidLoginCredentialWrongUsername.Username, invalidLoginCredentialWrongUsername.Password, tx), Equals, UnregisteredUser)
169 | 
170 | 	newPassword := "newPassword"
171 | 	changePasswordStatus, chagePasswordErr := ChangePassword(validLoginCredential.Username, newPassword, tx)
172 | 	c.Assert(changePasswordStatus, Equals, 200)
173 | 	c.Assert(chagePasswordErr, IsNil)
174 | 
175 | 	newValidLoginCredential := LoginCredential{Username: testString, Password: newPassword, DeviceId: mobile}
176 | 	c.Assert(AuthenticateUser(newValidLoginCredential.Username, newValidLoginCredential.Password, tx), Equals, nil)
177 | 
178 | 	tx.Rollback()
179 | }
180 | 
181 | func (suite *HandlerUtilsTestSuite) TestGetTimeExtension(c *C) {
182 | 	TRACE.Println("Running test: TestGetTimeExtension")
183 | 	var timeExtensionFromDb AppProperties
184 | 
185 | 	dbConnection.Where(&AppProperties{PropertyName: "TimeExtension"}).Find(&timeExtensionFromDb)
186 | 
187 | 	timeExtensionFromMethod := GetTimeExtension()
188 | 
189 | 	extension, conversionErr := strconv.Atoi(timeExtensionFromDb.PropertyValue)
190 | 
191 | 	c.Check(conversionErr, IsNil)
192 | 	c.Assert(extension, Equals, timeExtensionFromMethod)
193 | }
194 | 
195 | func (suite *HandlerUtilsTestSuite) TestChangePassword(c *C) {
196 | 	TRACE.Println("Running test: TestChangePassword")
197 | 	tx := dbConnection.Begin()
198 | 
199 | 	testString := "UniqueTestUser123321"
200 | 
201 | 	testCreateUserRequest := CreateUserRequest{Username: testString, LegalName: testString, Password: testString}
202 | 	status, err := CreateNewUser(testCreateUserRequest, tx)
203 | 
204 | 	c.Assert(err, IsNil)
205 | 	c.Assert(status, Equals, 200)
206 | 
207 | 	var testUser User
208 | 
209 | 	tx.Where(&User{UserName: testString}).Find(&testUser)
210 | 
211 | 	compareErr := bcrypt.CompareHashAndPassword([]byte(testUser.Password), []byte(testString))
212 | 	c.Assert(compareErr, IsNil)
213 | 
214 | 	newPassword := "newPassword"
215 | 	changePasswordStatus, changePasswordErr := ChangePassword(testString, newPassword, tx)
216 | 	c.Assert(changePasswordErr, IsNil)
217 | 	c.Assert(changePasswordStatus, Equals, 200)
218 | 
219 | 	tx.Where(&User{UserName: testString}).Find(&testUser)
220 | 
221 | 	compareErr = bcrypt.CompareHashAndPassword([]byte(testUser.Password), []byte(newPassword))
222 | 	c.Assert(compareErr, IsNil)
223 | 
224 | 	changePasswordStatusUnregisteredUser, changePasswordErrUnregisteredUser := ChangePassword("unregisteredUser123321", newPassword, tx)
225 | 	c.Assert(changePasswordErrUnregisteredUser, Equals, UnregisteredUser)
226 | 	c.Assert(changePasswordStatusUnregisteredUser, Equals, 401)
227 | 
228 | 	tx.Rollback()
229 | }
230 | 
231 | func (suite *HandlerUtilsTestSuite) TestValidateSessionToken(c *C) {
232 | 	TRACE.Println("Running test: TestValidateSessionToken")
233 | 
234 | 	tx := dbConnection.Begin()
235 | 
236 | 	testString := "UniqueTestUser123321"
237 | 
238 | 	var testCreateUserRequest = CreateUserRequest{Username: testString,
239 | 		LegalName: testString, Password: testString}
240 | 
241 | 	status, err := CreateNewUser(testCreateUserRequest, tx)
242 | 
243 | 	c.Check(err, IsNil)
244 | 	c.Assert(status, Equals, 200)
245 | 
246 | 	var user User
247 | 	dbErr := tx.Where(&User{UserName: testString}).Find(&user).Error
248 | 	c.Assert(dbErr, IsNil)
249 | 
250 | 	newPassword := "newPassword"
251 | 	changePasswordStatus, chagePasswordErr := ChangePassword(user.UserName, newPassword, tx)
252 | 	c.Assert(changePasswordStatus, Equals, 200)
253 | 	c.Assert(chagePasswordErr, IsNil)
254 | 
255 | 	var testLoginCredential = LoginCredential{Username: testString, Password: newPassword,
256 | 		DeviceId: web}
257 | 
258 | 	sessionToken, err := CreateNewTokenDbEntry(testLoginCredential, tx)
259 | 	c.Assert(err, IsNil)
260 | 
261 | 	var token Token
262 | 	dbErr = tx.Where(&Token{Token: sessionToken}).Find(&token).Error
263 | 	c.Assert(dbErr, IsNil)
264 | 
265 | 	var activityLog ActivityLog
266 | 	dbErr = tx.Where(&ActivityLog{UserId: user.Id, TokenId: token.Id}).Find(&activityLog).Error
267 | 	c.Assert(dbErr, IsNil)
268 | 
269 | 	err, userId := ValidateSessionToken("testSessionToken", tx)
270 | 	c.Assert(err, Equals, InvalidSessionToken)
271 | 	c.Assert(userId, Equals, int64(-1))
272 | 
273 | 	err, userId = ValidateSessionToken(sessionToken, tx)
274 | 	c.Assert(err, IsNil)
275 | 	c.Assert(userId, Equals, token.UserId)
276 | 
277 | 	token.Active = false
278 | 	tx.Save(&token)
279 | 
280 | 	err, userId = ValidateSessionToken(sessionToken, tx)
281 | 	c.Assert(err, Equals, ExpiredSessionToken)
282 | 	c.Assert(userId, Equals, int64(-1))
283 | 
284 | 	tx.Rollback()
285 | 
286 | }
287 | 
288 | func (suite *HandlerUtilsTestSuite) TestCheckPermissions(c *C) {
289 | 	TRACE.Println("Running test :TestCheckPermissions")
290 | 
291 | 	tx := dbConnection.Begin()
292 | 
293 | 	validPermission := Permission{PermissionDescription: "VALID_PERMISSION"}
294 | 	invalidPermission := Permission{PermissionDescription: "INVALID_PERMISSION"}
295 | 
296 | 	validGroup := Group{GroupDescription: "VALID_GROUP"}
297 | 	invalidGroup := Group{GroupDescription: "INVALID_GROUP"}
298 | 
299 | 	user := User{UserName: "User128256", LegalName: "User128256", Password: "Password128256", Active: true}
300 | 	tx.Save(&user)
301 | 	c.Assert(user.Id, NotNil)
302 | 
303 | 	tx.Save(&validPermission)
304 | 	tx.Save(&invalidPermission)
305 | 
306 | 	tx.Save(&validGroup)
307 | 	tx.Save(&invalidGroup)
308 | 
309 | 	groupPermission := GroupPermission{GroupId: validGroup.Id, PermissionId: validPermission.Id}
310 | 	tx.Save(&groupPermission)
311 | 
312 | 	userGroup := UserGroup{UserId: user.Id, GroupId: validGroup.Id}
313 | 	tx.Save(&userGroup)
314 | 
315 | 	err := CheckPermissionsForUser(int64(-1), validPermission, tx)
316 | 	c.Assert(err, Equals, PermissionDenied)
317 | 
318 | 	err = CheckPermissionsForUser(user.Id, invalidPermission, tx)
319 | 	c.Assert(err, Equals, gorm.RecordNotFound)
320 | 
321 | 	absentPermission := Permission{PermissionDescription: "NOT_PRESENT"}
322 | 	err = CheckPermissionsForUser(user.Id, absentPermission, tx)
323 | 	c.Assert(err, Equals, gorm.RecordNotFound)
324 | 
325 | 	invalidGroupPermission := GroupPermission{GroupId: invalidGroup.Id, PermissionId: invalidPermission.Id}
326 | 	tx.Save(&invalidGroupPermission)
327 | 
328 | 	err = CheckPermissionsForUser(user.Id, invalidPermission, tx)
329 | 	c.Assert(err, Equals, PermissionDenied)
330 | 
331 | 	err = CheckPermissionsForUser(user.Id, validPermission, tx)
332 | 	c.Assert(err, IsNil)
333 | 
334 | 	tx.Rollback()
335 | }
336 | 


--------------------------------------------------------------------------------
/coverage.html:
--------------------------------------------------------------------------------
  1 | 
  2 | <html>
  3 |     <head>
  4 |         <title>Coverage Report</title>
  5 |         
  6 |         <style type="text/css">
  7 |             body { background-color: #fff; }
  8 |             table {
  9 |                 margin-left: 10px;
 10 |                 border-collapse: collapse;
 11 |             }
 12 |             td { 
 13 |                 background-color: #fff; 
 14 |                 padding: 2px;
 15 |             }
 16 |             table.overview td {
 17 |                 padding-right: 20px;
 18 |             }
 19 |             td.percent, td.linecount { text-align: right; }
 20 |             div.package, #totalcov { 
 21 |                 color: #fff;
 22 |                 background-color: #375eab; 
 23 |                 font-size: 16px;
 24 |                 font-weight: bold;
 25 |                 padding: 10px;
 26 |                 border-radius: 5px 5px 5px 5px;
 27 |             }
 28 |             div.package, #totalcov { 
 29 |                 float: right; 
 30 |                 right: 10px;
 31 |             }
 32 |             #totalcov { 
 33 |                 top: 10px;
 34 |                 position: relative;
 35 |                 background-color: #fff;
 36 |                 color: #000;
 37 |                 border: 1px solid #375eab;
 38 |                 clear: both;
 39 |             }
 40 |             #summaryWrapper {
 41 |                 position: fixed;
 42 |                 top: 10px;
 43 |                 float: right;
 44 |                 right: 10px;
 45 | 
 46 |             }
 47 |             span.packageTotal {
 48 |                 float: right;
 49 |                 color: #000;
 50 |             }
 51 |             #doctitle { 
 52 |                 background-color: #fff; 
 53 |                 font-size: 24px;
 54 |                 margin-top: 20px;
 55 |                 margin-left: 10px;
 56 |                 color: #375eab;
 57 |                 font-weight: bold;
 58 |             }
 59 |             #about {
 60 |                 margin-left: 18px;
 61 |                 font-size: 10px;
 62 |             }
 63 |             table tr:last-child td {
 64 |                 font-weight: bold;
 65 |             }
 66 |             .functitle, .funcname { 
 67 |                 text-align: center; 
 68 |                 font-size: 20px; 
 69 |                 font-weight: bold; 
 70 |                 color: 375eab; 
 71 |             }
 72 |             .funcname {
 73 |                 text-align: left;
 74 |                 margin-top: 20px;
 75 |                 margin-left: 10px;
 76 |                 margin-bottom: 20px;
 77 |                 padding: 2px 5px 5px;
 78 |                 background-color: #e0ebf5;
 79 |             }
 80 |             table.listing {
 81 |                 margin-left: 10px;
 82 |             }
 83 |             table.listing td {
 84 |                 padding: 0px;
 85 |                 font-size: 12px;
 86 |                 background-color: #eee; 
 87 |                 vertical-align: top;
 88 |                 padding-left: 10px;
 89 |                 border-bottom: 1px solid #fff;
 90 |             }
 91 |             table.listing td:first-child {
 92 |                 text-align: right;
 93 |                 font-weight: bold;
 94 |                 vertical-align: center;
 95 |             }
 96 |             table.listing tr.miss td {
 97 |                 background-color: #FFBBB8;
 98 |             }
 99 |             table.listing tr:last-child td {
100 |                 font-weight: normal;
101 |                 color: #000;
102 |             }
103 |             table.listing tr:last-child td:first-child {
104 |                 font-weight: bold;
105 |             }
106 |             .info {
107 |                 margin-left: 10px;
108 |             }
109 |             .info code {
110 |             }
111 |             pre { margin: 1px; }
112 |             pre.cmd { 
113 |                 background-color: #e9e9e9;
114 |                 border-radius: 5px 5px 5px 5px;
115 |                 padding: 10px;
116 |                 margin: 20px;
117 |                 line-height: 18px;
118 |                 font-size; 14px;
119 |             }
120 |             a { 
121 |                 text-decoration: none; 
122 |                 color: #375eab;
123 |             }
124 |             a:hover { text-decoration: underline; }
125 |             p { margin-left: 10px; }
126 |         </style>
127 |         
128 |     </head>
129 |     <body>
130 |         <div id="doctitle">Coverage Report</div>
131 |     <div id="about">Generated on 28 Nov 14 00:46 -0700 with <a href="https://github.com/matm/gocov-html">gocov-html</a></div><div id="pkg_gondalf" class="funcname">Package Overview: gondalf <span class="packageTotal">58.61%</span></div><p>This is a coverage report created after analysis of the <code>gondalf</code> package. It 
132 |         has been generated with the following command:</p><pre class="cmd">gocov test gondalf | gocov-html</pre>        <p>Here are the stats. Please select a function name to view its implementation and see what's left for testing.</p><table class="overview">
133 | <tr id="s_fn_ValidateUniqueUsername"><td><code><a href="#fn_ValidateUniqueUsername">ValidateUniqueUsername(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>100.00%</code></td><td class="linecount"><code>6/6</code></td></tr>
134 | <tr id="s_fn_InitLogger"><td><code><a href="#fn_InitLogger">InitLogger(...)</a></code></td><td><code>gondalf/util.go</code></td><td class="percent"><code>100.00%</code></td><td class="linecount"><code>5/5</code></td></tr>
135 | <tr id="s_fn_generateSessionToken"><td><code><a href="#fn_generateSessionToken">generateSessionToken(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>100.00%</code></td><td class="linecount"><code>4/4</code></td></tr>
136 | <tr id="s_fn_GetAppProperties"><td><code><a href="#fn_GetAppProperties">GetAppProperties(...)</a></code></td><td><code>gondalf/util.go</code></td><td class="percent"><code>100.00%</code></td><td class="linecount"><code>4/4</code></td></tr>
137 | <tr id="s_fn_cleanUpAfterShutdown"><td><code><a href="#fn_cleanUpAfterShutdown">cleanUpAfterShutdown(...)</a></code></td><td><code>gondalf/server.go</code></td><td class="percent"><code>100.00%</code></td><td class="linecount"><code>3/3</code></td></tr>
138 | <tr id="s_fn_LoadAppPropertiesFromDb"><td><code><a href="#fn_LoadAppPropertiesFromDb">LoadAppPropertiesFromDb(...)</a></code></td><td><code>gondalf/util.go</code></td><td class="percent"><code>100.00%</code></td><td class="linecount"><code>2/2</code></td></tr>
139 | <tr id="s_fn_StartScheduledJobs"><td><code><a href="#fn_StartScheduledJobs">StartScheduledJobs(...)</a></code></td><td><code>gondalf/scheduledJobs.go</code></td><td class="percent"><code>100.00%</code></td><td class="linecount"><code>2/2</code></td></tr>
140 | <tr id="s_fn_GetDBConnection"><td><code><a href="#fn_GetDBConnection">GetDBConnection(...)</a></code></td><td><code>gondalf/db.go</code></td><td class="percent"><code>94.74%</code></td><td class="linecount"><code>18/19</code></td></tr>
141 | <tr id="s_fn_InsertAppProperties"><td><code><a href="#fn_InsertAppProperties">InsertAppProperties(...)</a></code></td><td><code>gondalf/db.go</code></td><td class="percent"><code>91.67%</code></td><td class="linecount"><code>11/12</code></td></tr>
142 | <tr id="s_fn_CheckPermissionsForUser"><td><code><a href="#fn_CheckPermissionsForUser">CheckPermissionsForUser(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>90.48%</code></td><td class="linecount"><code>19/21</code></td></tr>
143 | <tr id="s_fn_CreateNewTokenDbEntry"><td><code><a href="#fn_CreateNewTokenDbEntry">CreateNewTokenDbEntry(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>90.00%</code></td><td class="linecount"><code>18/20</code></td></tr>
144 | <tr id="s_fn_CreateNewUser"><td><code><a href="#fn_CreateNewUser">CreateNewUser(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>88.89%</code></td><td class="linecount"><code>16/18</code></td></tr>
145 | <tr id="s_fn_InsertDeviceTypes"><td><code><a href="#fn_InsertDeviceTypes">InsertDeviceTypes(...)</a></code></td><td><code>gondalf/db.go</code></td><td class="percent"><code>87.50%</code></td><td class="linecount"><code>7/8</code></td></tr>
146 | <tr id="s_fn_JobRefreshAppProperties"><td><code><a href="#fn_JobRefreshAppProperties">JobRefreshAppProperties(...)</a></code></td><td><code>gondalf/scheduledJobs.go</code></td><td class="percent"><code>85.71%</code></td><td class="linecount"><code>6/7</code></td></tr>
147 | <tr id="s_fn_LoadConfigurationFromFile"><td><code><a href="#fn_LoadConfigurationFromFile">LoadConfigurationFromFile(...)</a></code></td><td><code>gondalf/util.go</code></td><td class="percent"><code>83.33%</code></td><td class="linecount"><code>5/6</code></td></tr>
148 | <tr id="s_fn_AuthenticateUser"><td><code><a href="#fn_AuthenticateUser">AuthenticateUser(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>82.61%</code></td><td class="linecount"><code>19/23</code></td></tr>
149 | <tr id="s_fn_ValidateSessionToken"><td><code><a href="#fn_ValidateSessionToken">ValidateSessionToken(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>82.35%</code></td><td class="linecount"><code>14/17</code></td></tr>
150 | <tr id="s_fn_UpdatePasswordRecordLoginCount"><td><code><a href="#fn_UpdatePasswordRecordLoginCount">UpdatePasswordRecordLoginCount(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>77.78%</code></td><td class="linecount"><code>7/9</code></td></tr>
151 | <tr id="s_fn_GetTimeOutValue"><td><code><a href="#fn_GetTimeOutValue">GetTimeOutValue(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>76.47%</code></td><td class="linecount"><code>13/17</code></td></tr>
152 | <tr id="s_fn_EncryptPassword"><td><code><a href="#fn_EncryptPassword">EncryptPassword(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>75.00%</code></td><td class="linecount"><code>3/4</code></td></tr>
153 | <tr id="s_fn_ChangePassword"><td><code><a href="#fn_ChangePassword">ChangePassword(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>71.43%</code></td><td class="linecount"><code>15/21</code></td></tr>
154 | <tr id="s_fn_JobArchiveExpiredSessionToken"><td><code><a href="#fn_JobArchiveExpiredSessionToken">JobArchiveExpiredSessionToken(...)</a></code></td><td><code>gondalf/scheduledJobs.go</code></td><td class="percent"><code>70.00%</code></td><td class="linecount"><code>7/10</code></td></tr>
155 | <tr id="s_fn_InitApp"><td><code><a href="#fn_InitApp">InitApp(...)</a></code></td><td><code>gondalf/util.go</code></td><td class="percent"><code>62.50%</code></td><td class="linecount"><code>15/24</code></td></tr>
156 | <tr id="s_fn_GetTimeExtension"><td><code><a href="#fn_GetTimeExtension">GetTimeExtension(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>55.56%</code></td><td class="linecount"><code>5/9</code></td></tr>
157 | <tr id="s_fn_@52:5"><td><code><a href="#fn_@52:5">@52:5(...)</a></code></td><td><code>gondalf/scheduledJobs.go</code></td><td class="percent"><code>50.00%</code></td><td class="linecount"><code>2/4</code></td></tr>
158 | <tr id="s_fn_@24:5"><td><code><a href="#fn_@24:5">@24:5(...)</a></code></td><td><code>gondalf/scheduledJobs.go</code></td><td class="percent"><code>40.00%</code></td><td class="linecount"><code>2/5</code></td></tr>
159 | <tr id="s_fn_ChangePasswordHandler"><td><code><a href="#fn_ChangePasswordHandler">ChangePasswordHandler(...)</a></code></td><td><code>gondalf/handlers.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/19</code></td></tr>
160 | <tr id="s_fn_main"><td><code><a href="#fn_main">main(...)</a></code></td><td><code>gondalf/server.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/18</code></td></tr>
161 | <tr id="s_fn_InitDB"><td><code><a href="#fn_InitDB">InitDB(...)</a></code></td><td><code>gondalf/db.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/13</code></td></tr>
162 | <tr id="s_fn_LoginHandler"><td><code><a href="#fn_LoginHandler">LoginHandler(...)</a></code></td><td><code>gondalf/handlers.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/13</code></td></tr>
163 | <tr id="s_fn_ValidateSessionTokenHandler"><td><code><a href="#fn_ValidateSessionTokenHandler">ValidateSessionTokenHandler(...)</a></code></td><td><code>gondalf/handlers.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/12</code></td></tr>
164 | <tr id="s_fn_ArchiveTokenAfterCutOffTime"><td><code><a href="#fn_ArchiveTokenAfterCutOffTime">ArchiveTokenAfterCutOffTime(...)</a></code></td><td><code>gondalf/util.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/12</code></td></tr>
165 | <tr id="s_fn_CreateUserHandler"><td><code><a href="#fn_CreateUserHandler">CreateUserHandler(...)</a></code></td><td><code>gondalf/handlers.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/10</code></td></tr>
166 | <tr id="s_fn_CheckPermissionsForUserHandler"><td><code><a href="#fn_CheckPermissionsForUserHandler">CheckPermissionsForUserHandler(...)</a></code></td><td><code>gondalf/handlers.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/8</code></td></tr>
167 | <tr id="s_fn_ValidateUsernameHandler"><td><code><a href="#fn_ValidateUsernameHandler">ValidateUsernameHandler(...)</a></code></td><td><code>gondalf/handlers.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/2</code></td></tr>
168 | <tr id="s_fn_StatusHandler"><td><code><a href="#fn_StatusHandler">StatusHandler(...)</a></code></td><td><code>gondalf/handlers.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/1</code></td></tr>
169 | <tr id="s_fn_Status"><td><code><a href="#fn_Status">Status(...)</a></code></td><td><code>gondalf/handlerUtils.go</code></td><td class="percent"><code>0.00%</code></td><td class="linecount"><code>0/1</code></td></tr>
170 | <tr><td colspan="2"><code>gondalf</code></td><td class="percent"><code>58.61%</code></td><td class="linecount"><code>228/389</code></td></tr>
171 | </table>
172 | 
173 | <div class="funcname" id="fn_ValidateUniqueUsername">func ValidateUniqueUsername</div><div class="info"><a href="#s_fn_ValidateUniqueUsername">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
174 | <tr><td>161</td><td><code><pre>func ValidateUniqueUsername(username string, db *gorm.DB) bool {</pre></code></td></tr><tr><td>162</td><td><code><pre></pre></code></td></tr><tr><td>163</td><td><code><pre>        TRACE.Println(&#34;Validating username &#34; + username)</pre></code></td></tr><tr><td>164</td><td><code><pre>        err := db.Where(&amp;User{UserName: username}).First(&amp;User{}).Error</pre></code></td></tr><tr><td>165</td><td><code><pre></pre></code></td></tr><tr><td>166</td><td><code><pre>        if err == gorm.RecordNotFound {</pre></code></td></tr><tr><td>167</td><td><code><pre>                return true</pre></code></td></tr><tr><td>168</td><td><code><pre>        }</pre></code></td></tr><tr><td>169</td><td><code><pre>        WARNING.Println(&#34;Username &#34; + username + &#34; already present&#34;)</pre></code></td></tr><tr><td>170</td><td><code><pre>        return false</pre></code></td></tr><tr><td>171</td><td><code><pre>}</pre></code></td></tr></table>
175 | 
176 | <div class="funcname" id="fn_InitLogger">func InitLogger</div><div class="info"><a href="#s_fn_InitLogger">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/util.go</code>:</p></div><table class="listing">
177 | <tr><td>101</td><td><code><pre>func InitLogger(traceHandle io.Writer, infoHandle io.Writer, warningHandle io.Writer, errorHandle io.Writer, databaseHandle io.Writer) {</pre></code></td></tr><tr><td>102</td><td><code><pre></pre></code></td></tr><tr><td>103</td><td><code><pre>        TRACE = log.New(traceHandle, &#34;TRACE: &#34;, log.Ldate|log.Ltime|log.Lshortfile)</pre></code></td></tr><tr><td>104</td><td><code><pre></pre></code></td></tr><tr><td>105</td><td><code><pre>        INFO = log.New(infoHandle, &#34;INFO: &#34;, log.Ldate|log.Ltime|log.Lshortfile)</pre></code></td></tr><tr><td>106</td><td><code><pre></pre></code></td></tr><tr><td>107</td><td><code><pre>        WARNING = log.New(warningHandle, &#34;WARNING: &#34;, log.Ldate|log.Ltime|log.Lshortfile)</pre></code></td></tr><tr><td>108</td><td><code><pre></pre></code></td></tr><tr><td>109</td><td><code><pre>        ERROR = log.New(errorHandle, &#34;ERROR: &#34;, log.Ldate|log.Ltime|log.Lshortfile)</pre></code></td></tr><tr><td>110</td><td><code><pre></pre></code></td></tr><tr><td>111</td><td><code><pre>        DATABASE = log.New(databaseHandle, &#34;DATABASE: &#34;, log.Ldate|log.Ltime|log.Lshortfile)</pre></code></td></tr><tr><td>112</td><td><code><pre>}</pre></code></td></tr></table>
178 | 
179 | <div class="funcname" id="fn_generateSessionToken">func generateSessionToken</div><div class="info"><a href="#s_fn_generateSessionToken">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
180 | <tr><td>121</td><td><code><pre>func generateSessionToken(message string, key string) string {</pre></code></td></tr><tr><td>122</td><td><code><pre>        keyBytes := []byte(key)</pre></code></td></tr><tr><td>123</td><td><code><pre>        h := hmac.New(sha256.New, keyBytes)</pre></code></td></tr><tr><td>124</td><td><code><pre>        h.Write([]byte(message))</pre></code></td></tr><tr><td>125</td><td><code><pre>        return base64.StdEncoding.EncodeToString(h.Sum(nil))</pre></code></td></tr><tr><td>126</td><td><code><pre>}</pre></code></td></tr></table>
181 | 
182 | <div class="funcname" id="fn_GetAppProperties">func GetAppProperties</div><div class="info"><a href="#s_fn_GetAppProperties">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/util.go</code>:</p></div><table class="listing">
183 | <tr><td>114</td><td><code><pre>func GetAppProperties(propertyName string) (string, error) {</pre></code></td></tr><tr><td>115</td><td><code><pre>        for index := range properties {</pre></code></td></tr><tr><td>116</td><td><code><pre>                if properties[index].PropertyName == propertyName {</pre></code></td></tr><tr><td>117</td><td><code><pre>                        return properties[index].PropertyValue, nil</pre></code></td></tr><tr><td>118</td><td><code><pre>                }</pre></code></td></tr><tr><td>119</td><td><code><pre>        }</pre></code></td></tr><tr><td>120</td><td><code><pre>        return &#34;&#34;, errors.New(&#34;App property &#34; + propertyName + &#34; not set&#34;)</pre></code></td></tr><tr><td>121</td><td><code><pre>}</pre></code></td></tr></table>
184 | 
185 | <div class="funcname" id="fn_cleanUpAfterShutdown">func cleanUpAfterShutdown</div><div class="info"><a href="#s_fn_cleanUpAfterShutdown">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/server.go</code>:</p></div><table class="listing">
186 | <tr><td>69</td><td><code><pre>func cleanUpAfterShutdown() {</pre></code></td></tr><tr><td>70</td><td><code><pre>        //TRACE.Println(&#34;Sending kill signal to all routines by closing quit channel&#34;)</pre></code></td></tr><tr><td>71</td><td><code><pre>        //close(quit)</pre></code></td></tr><tr><td>72</td><td><code><pre></pre></code></td></tr><tr><td>73</td><td><code><pre>        TRACE.Println(&#34;Cleaning up dbConnection and file stream&#34;)</pre></code></td></tr><tr><td>74</td><td><code><pre>        dbConnection.Close()</pre></code></td></tr><tr><td>75</td><td><code><pre>        file.Close()</pre></code></td></tr><tr><td>76</td><td><code><pre>}</pre></code></td></tr></table>
187 | 
188 | <div class="funcname" id="fn_LoadAppPropertiesFromDb">func LoadAppPropertiesFromDb</div><div class="info"><a href="#s_fn_LoadAppPropertiesFromDb">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/util.go</code>:</p></div><table class="listing">
189 | <tr><td>135</td><td><code><pre>func LoadAppPropertiesFromDb() {</pre></code></td></tr><tr><td>136</td><td><code><pre>        dbConnection.Find(&amp;properties)</pre></code></td></tr><tr><td>137</td><td><code><pre>        TRACE.Println(&#34;App properties array initialized at: &#34; + time.Now().String())</pre></code></td></tr><tr><td>138</td><td><code><pre>}</pre></code></td></tr></table>
190 | 
191 | <div class="funcname" id="fn_StartScheduledJobs">func StartScheduledJobs</div><div class="info"><a href="#s_fn_StartScheduledJobs">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/scheduledJobs.go</code>:</p></div><table class="listing">
192 | <tr><td>9</td><td><code><pre>func StartScheduledJobs() {</pre></code></td></tr><tr><td>10</td><td><code><pre>        JobRefreshAppProperties()</pre></code></td></tr><tr><td>11</td><td><code><pre>        JobArchiveExpiredSessionToken()</pre></code></td></tr><tr><td>12</td><td><code><pre>}</pre></code></td></tr></table>
193 | 
194 | <div class="funcname" id="fn_GetDBConnection">func GetDBConnection</div><div class="info"><a href="#s_fn_GetDBConnection">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/db.go</code>:</p></div><table class="listing">
195 | <tr><td>74</td><td><code><pre>func GetDBConnection() gorm.DB {</pre></code></td></tr><tr><td>75</td><td><code><pre></pre></code></td></tr><tr><td>76</td><td><code><pre>        LoadConfigurationFromFile()</pre></code></td></tr><tr><td>77</td><td><code><pre></pre></code></td></tr><tr><td>78</td><td><code><pre>        var connParam ConnectionParameters</pre></code></td></tr><tr><td>79</td><td><code><pre></pre></code></td></tr><tr><td>80</td><td><code><pre>        connParam.username = viper.GetString(&#34;dbUsername&#34;)</pre></code></td></tr><tr><td>81</td><td><code><pre>        connParam.password = viper.GetString(&#34;dbPassword&#34;)</pre></code></td></tr><tr><td>82</td><td><code><pre>        connParam.host = viper.GetString(&#34;dbHost&#34;)</pre></code></td></tr><tr><td>83</td><td><code><pre>        connParam.port = viper.GetString(&#34;dbPort&#34;)</pre></code></td></tr><tr><td>84</td><td><code><pre>        connParam.dbname = viper.GetString(&#34;dbName&#34;)</pre></code></td></tr><tr><td>85</td><td><code><pre>        connParam.sslmode = viper.GetString(&#34;dbSSLmode&#34;)</pre></code></td></tr><tr><td>86</td><td><code><pre></pre></code></td></tr><tr><td>87</td><td><code><pre>        source := &#34;user=&#34; + connParam.username +</pre></code></td></tr><tr><td>88</td><td><code><pre>                &#34; password=&#34; + connParam.password +</pre></code></td></tr><tr><td>89</td><td><code><pre>                &#34; dbname=&#34; + connParam.dbname +</pre></code></td></tr><tr><td>90</td><td><code><pre>                &#34; port=&#34; + connParam.port +</pre></code></td></tr><tr><td>91</td><td><code><pre>                &#34; host=&#34; + connParam.host +</pre></code></td></tr><tr><td>92</td><td><code><pre>                &#34; sslmode=&#34; + connParam.sslmode</pre></code></td></tr><tr><td>93</td><td><code><pre></pre></code></td></tr><tr><td>94</td><td><code><pre>        db, err := gorm.Open(&#34;postgres&#34;, source)</pre></code></td></tr><tr><td>95</td><td><code><pre></pre></code></td></tr><tr><td>96</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>97</td><td><code><pre>                ERROR.Panicln(&#34;Error opening DB connection&#34;)</pre></code></td></tr><tr><td>98</td><td><code><pre>        }</pre></code></td></tr><tr><td>99</td><td><code><pre></pre></code></td></tr><tr><td>100</td><td><code><pre>        TRACE.Println(&#34;DB Connection opened&#34;)</pre></code></td></tr><tr><td>101</td><td><code><pre></pre></code></td></tr><tr><td>102</td><td><code><pre>        maxIdleConnections, _ := strconv.Atoi(viper.GetString(&#34;dbMaxIdleConnections&#34;))</pre></code></td></tr><tr><td>103</td><td><code><pre>        maxOpenConnections, _ := strconv.Atoi(viper.GetString(&#34;dbMaxOpenConnections&#34;))</pre></code></td></tr><tr><td>104</td><td><code><pre></pre></code></td></tr><tr><td>105</td><td><code><pre>        db.DB().SetMaxIdleConns(maxIdleConnections)</pre></code></td></tr><tr><td>106</td><td><code><pre>        db.DB().SetMaxOpenConns(maxOpenConnections)</pre></code></td></tr><tr><td>107</td><td><code><pre>        db.DB().Ping()</pre></code></td></tr><tr><td>108</td><td><code><pre></pre></code></td></tr><tr><td>109</td><td><code><pre>        return db</pre></code></td></tr><tr><td>110</td><td><code><pre>}</pre></code></td></tr></table>
196 | 
197 | <div class="funcname" id="fn_InsertAppProperties">func InsertAppProperties</div><div class="info"><a href="#s_fn_InsertAppProperties">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/db.go</code>:</p></div><table class="listing">
198 | <tr><td>36</td><td><code><pre>func InsertAppProperties(db *gorm.DB) bool {</pre></code></td></tr><tr><td>37</td><td><code><pre></pre></code></td></tr><tr><td>38</td><td><code><pre>        webTimeOut := AppProperties{PropertyName: &#34;WebTimeOut&#34;, PropertyValue: &#34;30&#34;, UpdatedAt: time.Now().UTC()}</pre></code></td></tr><tr><td>39</td><td><code><pre>        mobileTimeOut := AppProperties{PropertyName: &#34;MobileTimeOut&#34;, PropertyValue: &#34;720&#34;, UpdatedAt: time.Now().UTC()}</pre></code></td></tr><tr><td>40</td><td><code><pre>        dbDebugLogs := AppProperties{PropertyName: &#34;DbDebugLogs&#34;, PropertyValue: &#34;false&#34;, UpdatedAt: time.Now().UTC()}</pre></code></td></tr><tr><td>41</td><td><code><pre>        timeExtension := AppProperties{PropertyName: &#34;TimeExtension&#34;, PropertyValue: &#34;5&#34;, UpdatedAt: time.Now().UTC()}</pre></code></td></tr><tr><td>42</td><td><code><pre>        tokenCutOffTime := AppProperties{PropertyName: &#34;TokenCutOffTime&#34;, PropertyValue: &#34;30&#34;, UpdatedAt: time.Now().UTC()}</pre></code></td></tr><tr><td>43</td><td><code><pre>        tokenCleanUpFrequency := AppProperties{PropertyName: &#34;TokenCleanUpFrequency&#34;, PropertyValue: &#34;180&#34;, UpdatedAt: time.Now().UTC()}</pre></code></td></tr><tr><td>44</td><td><code><pre></pre></code></td></tr><tr><td>45</td><td><code><pre>        propertiesSlice := []AppProperties{webTimeOut, mobileTimeOut, dbDebugLogs, timeExtension, tokenCutOffTime, tokenCleanUpFrequency}</pre></code></td></tr><tr><td>46</td><td><code><pre></pre></code></td></tr><tr><td>47</td><td><code><pre>        for i := range propertiesSlice {</pre></code></td></tr><tr><td>48</td><td><code><pre>                existsErr := db.Where(&amp;AppProperties{PropertyName: propertiesSlice[i].PropertyName}).Find(&amp;AppProperties{}).Error</pre></code></td></tr><tr><td>49</td><td><code><pre>                if existsErr == gorm.RecordNotFound {</pre></code></td></tr><tr class="miss"><td>50</td><td><code><pre>                        db.Save(&amp;propertiesSlice[i])</pre></code></td></tr><tr><td>51</td><td><code><pre>                }</pre></code></td></tr><tr><td>52</td><td><code><pre>        }</pre></code></td></tr><tr><td>53</td><td><code><pre></pre></code></td></tr><tr><td>54</td><td><code><pre>        return true</pre></code></td></tr><tr><td>55</td><td><code><pre>}</pre></code></td></tr></table>
199 | 
200 | <div class="funcname" id="fn_CheckPermissionsForUser">func CheckPermissionsForUser</div><div class="info"><a href="#s_fn_CheckPermissionsForUser">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
201 | <tr><td>288</td><td><code><pre>func CheckPermissionsForUser(userid int64, permission Permission, db *gorm.DB) error {</pre></code></td></tr><tr><td>289</td><td><code><pre>        if userid == int64(-1) {</pre></code></td></tr><tr><td>290</td><td><code><pre>                return PermissionDenied</pre></code></td></tr><tr><td>291</td><td><code><pre>        }</pre></code></td></tr><tr><td>292</td><td><code><pre></pre></code></td></tr><tr><td>293</td><td><code><pre>        err := db.Where(&amp;Permission{PermissionDescription: permission.PermissionDescription}).Find(&amp;permission).Error</pre></code></td></tr><tr><td>294</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr><td>295</td><td><code><pre>                ERROR.Println(err.Error() + &#34; while checking permission for: &#34; + permission.PermissionDescription)</pre></code></td></tr><tr><td>296</td><td><code><pre>                return err</pre></code></td></tr><tr><td>297</td><td><code><pre>        }</pre></code></td></tr><tr><td>298</td><td><code><pre></pre></code></td></tr><tr><td>299</td><td><code><pre>        var groupPermission GroupPermission</pre></code></td></tr><tr><td>300</td><td><code><pre>        err = db.Where(&amp;GroupPermission{PermissionId: permission.Id}).Find(&amp;groupPermission).Error</pre></code></td></tr><tr><td>301</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr><td>302</td><td><code><pre>                ERROR.Println(err.Error() + &#34; while finding groupPermission for: &#34; + strconv.FormatInt(permission.Id, 10))</pre></code></td></tr><tr><td>303</td><td><code><pre>                return err</pre></code></td></tr><tr><td>304</td><td><code><pre>        }</pre></code></td></tr><tr><td>305</td><td><code><pre></pre></code></td></tr><tr><td>306</td><td><code><pre>        var userGroup UserGroup</pre></code></td></tr><tr><td>307</td><td><code><pre>        err = db.Where(&amp;UserGroup{UserId: userid, GroupId: groupPermission.GroupId}).Find(&amp;userGroup).Error</pre></code></td></tr><tr><td>308</td><td><code><pre>        if err == gorm.RecordNotFound {</pre></code></td></tr><tr><td>309</td><td><code><pre>                WARNING.Println(PermissionDenied.Error() + &#34; for user: &#34; + strconv.FormatInt(userid, 10) +</pre></code></td></tr><tr><td>310</td><td><code><pre>                        &#34; for Permission: &#34; + permission.PermissionDescription)</pre></code></td></tr><tr><td>311</td><td><code><pre>                return PermissionDenied</pre></code></td></tr><tr><td>312</td><td><code><pre>        } else if err != nil {</pre></code></td></tr><tr class="miss"><td>313</td><td><code><pre>                ERROR.Println(err.Error() + &#34; in UserGroup while searching for userId: &#34; + strconv.FormatInt(userid, 10) +</pre></code></td></tr><tr><td>314</td><td><code><pre>                        &#34; and groupId: &#34; + strconv.FormatInt(groupPermission.GroupId, 10))</pre></code></td></tr><tr class="miss"><td>315</td><td><code><pre>                return err</pre></code></td></tr><tr><td>316</td><td><code><pre>        }</pre></code></td></tr><tr><td>317</td><td><code><pre></pre></code></td></tr><tr><td>318</td><td><code><pre>        TRACE.Println(&#34;Permission verified for userId: &#34; + strconv.FormatInt(userid, 10) + &#34; , permission: &#34; + permission.PermissionDescription)</pre></code></td></tr><tr><td>319</td><td><code><pre>        return nil</pre></code></td></tr><tr><td>320</td><td><code><pre>}</pre></code></td></tr></table>
202 | 
203 | <div class="funcname" id="fn_CreateNewTokenDbEntry">func CreateNewTokenDbEntry</div><div class="info"><a href="#s_fn_CreateNewTokenDbEntry">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
204 | <tr><td>56</td><td><code><pre>func CreateNewTokenDbEntry(login LoginCredential, db *gorm.DB) (string, error) {</pre></code></td></tr><tr><td>57</td><td><code><pre>        user := User{}</pre></code></td></tr><tr><td>58</td><td><code><pre>        db.Where(&amp;User{UserName: login.Username}).Find(&amp;user)</pre></code></td></tr><tr><td>59</td><td><code><pre></pre></code></td></tr><tr><td>60</td><td><code><pre>        token := Token{}</pre></code></td></tr><tr><td>61</td><td><code><pre>        token.UserId = user.Id</pre></code></td></tr><tr><td>62</td><td><code><pre>        token.Key = uuid.New()</pre></code></td></tr><tr><td>63</td><td><code><pre>        token.CreatedAt = time.Now().UTC()</pre></code></td></tr><tr><td>64</td><td><code><pre>        token.LastAccessedAt = time.Now().UTC()</pre></code></td></tr><tr><td>65</td><td><code><pre>        token.Token = generateSessionToken(login.Username+token.CreatedAt.String(), token.Key)</pre></code></td></tr><tr><td>66</td><td><code><pre>        token.Active = true</pre></code></td></tr><tr><td>67</td><td><code><pre>        expiryTime, err := GetTimeOutValue(login.DeviceId)</pre></code></td></tr><tr><td>68</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>69</td><td><code><pre>                ERROR.Println(err.Error())</pre></code></td></tr><tr class="miss"><td>70</td><td><code><pre>                return &#34;&#34;, err</pre></code></td></tr><tr><td>71</td><td><code><pre>        }</pre></code></td></tr><tr><td>72</td><td><code><pre></pre></code></td></tr><tr><td>73</td><td><code><pre>        token.ExpiresAt = expiryTime</pre></code></td></tr><tr><td>74</td><td><code><pre></pre></code></td></tr><tr><td>75</td><td><code><pre>        var device DeviceType</pre></code></td></tr><tr><td>76</td><td><code><pre>        db.Where(&amp;DeviceType{DeviceCode: login.DeviceId}).Find(&amp;device)</pre></code></td></tr><tr><td>77</td><td><code><pre></pre></code></td></tr><tr><td>78</td><td><code><pre>        token.DeviceTypeId = device.Id</pre></code></td></tr><tr><td>79</td><td><code><pre></pre></code></td></tr><tr><td>80</td><td><code><pre>        db.Save(&amp;token)</pre></code></td></tr><tr><td>81</td><td><code><pre></pre></code></td></tr><tr><td>82</td><td><code><pre>        db.Save(&amp;ActivityLog{UserId: token.UserId, TokenId: token.Id, ActivityTime: time.Now().UTC(), Event: LOGIN})</pre></code></td></tr><tr><td>83</td><td><code><pre></pre></code></td></tr><tr><td>84</td><td><code><pre>        return token.Token, nil</pre></code></td></tr><tr><td>85</td><td><code><pre>}</pre></code></td></tr></table>
205 | 
206 | <div class="funcname" id="fn_CreateNewUser">func CreateNewUser</div><div class="info"><a href="#s_fn_CreateNewUser">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
207 | <tr><td>128</td><td><code><pre>func CreateNewUser(request CreateUserRequest, db *gorm.DB) (int, error) {</pre></code></td></tr><tr><td>129</td><td><code><pre></pre></code></td></tr><tr><td>130</td><td><code><pre>        var err error</pre></code></td></tr><tr><td>131</td><td><code><pre></pre></code></td></tr><tr><td>132</td><td><code><pre>        if ValidateUniqueUsername(request.Username, db) {</pre></code></td></tr><tr><td>133</td><td><code><pre></pre></code></td></tr><tr><td>134</td><td><code><pre>                var user User</pre></code></td></tr><tr><td>135</td><td><code><pre></pre></code></td></tr><tr><td>136</td><td><code><pre>                user.UserName = request.Username</pre></code></td></tr><tr><td>137</td><td><code><pre>                user.LegalName = request.LegalName</pre></code></td></tr><tr><td>138</td><td><code><pre>                user.Password, err = EncryptPassword(request.Password)</pre></code></td></tr><tr><td>139</td><td><code><pre>                user.UpdatedAt = time.Now().UTC()</pre></code></td></tr><tr><td>140</td><td><code><pre>                user.Active = false</pre></code></td></tr><tr><td>141</td><td><code><pre></pre></code></td></tr><tr><td>142</td><td><code><pre>                if err != nil {</pre></code></td></tr><tr class="miss"><td>143</td><td><code><pre>                        ERROR.Println(err.Error())</pre></code></td></tr><tr class="miss"><td>144</td><td><code><pre>                        return 500, EncryptionError</pre></code></td></tr><tr><td>145</td><td><code><pre>                }</pre></code></td></tr><tr><td>146</td><td><code><pre></pre></code></td></tr><tr><td>147</td><td><code><pre>                db.Save(&amp;user)</pre></code></td></tr><tr><td>148</td><td><code><pre>                TRACE.Println(&#34;New user created, userId: &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr><td>149</td><td><code><pre></pre></code></td></tr><tr><td>150</td><td><code><pre>                db.Save(&amp;PasswordRecord{UserId: user.Id, LoginCount: 0})</pre></code></td></tr><tr><td>151</td><td><code><pre>                TRACE.Println(&#34;New password record created, userId: &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr><td>152</td><td><code><pre></pre></code></td></tr><tr><td>153</td><td><code><pre>                return 200, nil</pre></code></td></tr><tr><td>154</td><td><code><pre>        }</pre></code></td></tr><tr><td>155</td><td><code><pre></pre></code></td></tr><tr><td>156</td><td><code><pre>        ERROR.Println(&#34;Duplicate username &#34; + request.Username + &#34; server validation in create user&#34;)</pre></code></td></tr><tr><td>157</td><td><code><pre>        return 409, DuplicateUsernameError</pre></code></td></tr><tr><td>158</td><td><code><pre>}</pre></code></td></tr></table>
208 | 
209 | <div class="funcname" id="fn_InsertDeviceTypes">func InsertDeviceTypes</div><div class="info"><a href="#s_fn_InsertDeviceTypes">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/db.go</code>:</p></div><table class="listing">
210 | <tr><td>57</td><td><code><pre>func InsertDeviceTypes(db *gorm.DB) bool {</pre></code></td></tr><tr><td>58</td><td><code><pre>        webDevice := DeviceType{Device: &#34;web&#34;, DeviceCode: web}</pre></code></td></tr><tr><td>59</td><td><code><pre>        mobileDevice := DeviceType{Device: &#34;mobile&#34;, DeviceCode: mobile}</pre></code></td></tr><tr><td>60</td><td><code><pre></pre></code></td></tr><tr><td>61</td><td><code><pre>        devicesSlice := []DeviceType{webDevice, mobileDevice}</pre></code></td></tr><tr><td>62</td><td><code><pre></pre></code></td></tr><tr><td>63</td><td><code><pre>        for i := range devicesSlice {</pre></code></td></tr><tr><td>64</td><td><code><pre>                existsErr := db.Where(&amp;devicesSlice[i]).Find(&amp;DeviceType{}).Error</pre></code></td></tr><tr><td>65</td><td><code><pre>                if existsErr == gorm.RecordNotFound {</pre></code></td></tr><tr class="miss"><td>66</td><td><code><pre>                        db.Save(&amp;devicesSlice[i])</pre></code></td></tr><tr><td>67</td><td><code><pre>                }</pre></code></td></tr><tr><td>68</td><td><code><pre>        }</pre></code></td></tr><tr><td>69</td><td><code><pre></pre></code></td></tr><tr><td>70</td><td><code><pre>        return true</pre></code></td></tr><tr><td>71</td><td><code><pre>}</pre></code></td></tr></table>
211 | 
212 | <div class="funcname" id="fn_JobRefreshAppProperties">func JobRefreshAppProperties</div><div class="info"><a href="#s_fn_JobRefreshAppProperties">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/scheduledJobs.go</code>:</p></div><table class="listing">
213 | <tr><td>14</td><td><code><pre>func JobRefreshAppProperties() {</pre></code></td></tr><tr><td>15</td><td><code><pre></pre></code></td></tr><tr><td>16</td><td><code><pre>        LoadConfigurationFromFile()</pre></code></td></tr><tr><td>17</td><td><code><pre>        appPropertiesRefreshTimeinMinutes, err := strconv.Atoi(viper.GetString(&#34;appPropertiesRefreshTimeinMinutes&#34;))</pre></code></td></tr><tr><td>18</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>19</td><td><code><pre>                ERROR.Panicln(&#34;appPropertiesRefreshTimeinMinutes missing from the config file&#34;)</pre></code></td></tr><tr><td>20</td><td><code><pre>        }</pre></code></td></tr><tr><td>21</td><td><code><pre></pre></code></td></tr><tr><td>22</td><td><code><pre>        ticker := time.NewTicker(time.Duration(appPropertiesRefreshTimeinMinutes) * time.Minute)</pre></code></td></tr><tr><td>23</td><td><code><pre>        TRACE.Println(&#34;Starting goroutine for refreshing app properties&#34;)</pre></code></td></tr><tr><td>24</td><td><code><pre>        go func() {</pre></code></td></tr><tr><td>25</td><td><code><pre>                for {</pre></code></td></tr><tr><td>26</td><td><code><pre>                        select {</pre></code></td></tr><tr><td>27</td><td><code><pre>                        case &lt;-ticker.C:</pre></code></td></tr><tr><td>28</td><td><code><pre>                                LoadAppPropertiesFromDb()</pre></code></td></tr><tr><td>29</td><td><code><pre>                        case &lt;-quit:</pre></code></td></tr><tr><td>30</td><td><code><pre>                                TRACE.Println(&#34;Quit signal: JobRefreshAppProperties&#34;)</pre></code></td></tr><tr><td>31</td><td><code><pre>                                ticker.Stop()</pre></code></td></tr><tr><td>32</td><td><code><pre>                        }</pre></code></td></tr><tr><td>33</td><td><code><pre>                }</pre></code></td></tr><tr><td>34</td><td><code><pre>        }()</pre></code></td></tr><tr><td>35</td><td><code><pre>}</pre></code></td></tr></table>
214 | 
215 | <div class="funcname" id="fn_LoadConfigurationFromFile">func LoadConfigurationFromFile</div><div class="info"><a href="#s_fn_LoadConfigurationFromFile">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/util.go</code>:</p></div><table class="listing">
216 | <tr><td>123</td><td><code><pre>func LoadConfigurationFromFile() {</pre></code></td></tr><tr><td>124</td><td><code><pre>        TRACE.Println(&#34;Loading configuration from &#34; + configName)</pre></code></td></tr><tr><td>125</td><td><code><pre></pre></code></td></tr><tr><td>126</td><td><code><pre>        viper.SetConfigName(configName)</pre></code></td></tr><tr><td>127</td><td><code><pre>        viper.AddConfigPath(&#34;.&#34;)</pre></code></td></tr><tr><td>128</td><td><code><pre>        err := viper.ReadInConfig()</pre></code></td></tr><tr><td>129</td><td><code><pre></pre></code></td></tr><tr><td>130</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>131</td><td><code><pre>                panic(&#34;Configuration couldn&#39;t be initialized, panicking now &#34; + err.Error())</pre></code></td></tr><tr><td>132</td><td><code><pre>        }</pre></code></td></tr><tr><td>133</td><td><code><pre>}</pre></code></td></tr></table>
217 | 
218 | <div class="funcname" id="fn_AuthenticateUser">func AuthenticateUser</div><div class="info"><a href="#s_fn_AuthenticateUser">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
219 | <tr><td>17</td><td><code><pre>func AuthenticateUser(username string, password string, db *gorm.DB) error {</pre></code></td></tr><tr><td>18</td><td><code><pre>        var user User</pre></code></td></tr><tr><td>19</td><td><code><pre></pre></code></td></tr><tr><td>20</td><td><code><pre>        dbErr := db.Where(&amp;User{UserName: username}).Find(&amp;user).Error</pre></code></td></tr><tr><td>21</td><td><code><pre>        if dbErr != nil {</pre></code></td></tr><tr><td>22</td><td><code><pre>                if dbErr == gorm.RecordNotFound {</pre></code></td></tr><tr><td>23</td><td><code><pre>                        WARNING.Println(UnregisteredUser.Error() + &#34; ,username: &#34; + username)</pre></code></td></tr><tr><td>24</td><td><code><pre>                        return UnregisteredUser</pre></code></td></tr><tr><td>25</td><td><code><pre>                } else {</pre></code></td></tr><tr class="miss"><td>26</td><td><code><pre>                        ERROR.Println(dbErr.Error())</pre></code></td></tr><tr class="miss"><td>27</td><td><code><pre>                        return DatabaseError</pre></code></td></tr><tr><td>28</td><td><code><pre>                }</pre></code></td></tr><tr><td>29</td><td><code><pre>        }</pre></code></td></tr><tr><td>30</td><td><code><pre></pre></code></td></tr><tr><td>31</td><td><code><pre>        TRACE.Println(&#34;Login attempt by userId &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr><td>32</td><td><code><pre>        passwordCompareErr := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password))</pre></code></td></tr><tr><td>33</td><td><code><pre>        if passwordCompareErr != nil {</pre></code></td></tr><tr><td>34</td><td><code><pre>                WARNING.Println(passwordCompareErr.Error() + &#34;, userId: &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr><td>35</td><td><code><pre>                return IncorrectPassword</pre></code></td></tr><tr><td>36</td><td><code><pre>        }</pre></code></td></tr><tr><td>37</td><td><code><pre></pre></code></td></tr><tr><td>38</td><td><code><pre>        var passwordRecord PasswordRecord</pre></code></td></tr><tr><td>39</td><td><code><pre></pre></code></td></tr><tr><td>40</td><td><code><pre>        dbPasswordRecordErr := db.Where(&amp;PasswordRecord{UserId: user.Id}).Find(&amp;passwordRecord).Error</pre></code></td></tr><tr><td>41</td><td><code><pre>        if dbPasswordRecordErr != nil {</pre></code></td></tr><tr class="miss"><td>42</td><td><code><pre>                ERROR.Println(dbPasswordRecordErr.Error() + &#34;, userId: &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr class="miss"><td>43</td><td><code><pre>                return DatabaseError</pre></code></td></tr><tr><td>44</td><td><code><pre>        }</pre></code></td></tr><tr><td>45</td><td><code><pre></pre></code></td></tr><tr><td>46</td><td><code><pre>        if dbPasswordRecordErr == nil &amp;&amp; passwordRecord.LoginCount == 0 {</pre></code></td></tr><tr><td>47</td><td><code><pre>                TRACE.Println(FirstLoginPasswordChange.Error() + &#34;, userId: &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr><td>48</td><td><code><pre>                return FirstLoginPasswordChange</pre></code></td></tr><tr><td>49</td><td><code><pre>        }</pre></code></td></tr><tr><td>50</td><td><code><pre></pre></code></td></tr><tr><td>51</td><td><code><pre>        TRACE.Println(&#34;User authenticated, userId: &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr><td>52</td><td><code><pre>        return nil</pre></code></td></tr><tr><td>53</td><td><code><pre>}</pre></code></td></tr></table>
220 | 
221 | <div class="funcname" id="fn_ValidateSessionToken">func ValidateSessionToken</div><div class="info"><a href="#s_fn_ValidateSessionToken">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
222 | <tr><td>188</td><td><code><pre>func ValidateSessionToken(sessionToken string, db *gorm.DB) (error, int64) {</pre></code></td></tr><tr><td>189</td><td><code><pre>        var token Token</pre></code></td></tr><tr><td>190</td><td><code><pre></pre></code></td></tr><tr><td>191</td><td><code><pre>        dbErr := db.Where(&amp;Token{Token: sessionToken}).Find(&amp;token).Error</pre></code></td></tr><tr><td>192</td><td><code><pre>        if dbErr != nil {</pre></code></td></tr><tr><td>193</td><td><code><pre>                if dbErr == gorm.RecordNotFound {</pre></code></td></tr><tr><td>194</td><td><code><pre>                        WARNING.Println(InvalidSessionToken.Error() + &#34;, sessionToken: &#34; + sessionToken)</pre></code></td></tr><tr><td>195</td><td><code><pre>                        return InvalidSessionToken, -1</pre></code></td></tr><tr><td>196</td><td><code><pre>                }</pre></code></td></tr><tr class="miss"><td>197</td><td><code><pre>                ERROR.Println(dbErr.Error() + &#34;, sessionToken: &#34; + sessionToken)</pre></code></td></tr><tr class="miss"><td>198</td><td><code><pre>                return dbErr, -1</pre></code></td></tr><tr><td>199</td><td><code><pre>        }</pre></code></td></tr><tr><td>200</td><td><code><pre></pre></code></td></tr><tr><td>201</td><td><code><pre>        if token.Active &amp;&amp; token.ExpiresAt.After(time.Now().UTC()) {</pre></code></td></tr><tr><td>202</td><td><code><pre>                TRACE.Println(&#34;SessionToken validated: &#34; + sessionToken)</pre></code></td></tr><tr><td>203</td><td><code><pre>                timeLeft := token.ExpiresAt.Sub(time.Now().UTC())</pre></code></td></tr><tr><td>204</td><td><code><pre>                if timeLeft.Minutes() &lt; 5 {</pre></code></td></tr><tr class="miss"><td>205</td><td><code><pre>                        token.ExpiresAt = token.ExpiresAt.Add(time.Duration(GetTimeExtension()) * time.Minute)</pre></code></td></tr><tr><td>206</td><td><code><pre>                }</pre></code></td></tr><tr><td>207</td><td><code><pre>                token.LastAccessedAt = time.Now().UTC()</pre></code></td></tr><tr><td>208</td><td><code><pre>                db.Save(&amp;token)</pre></code></td></tr><tr><td>209</td><td><code><pre>                return nil, token.UserId</pre></code></td></tr><tr><td>210</td><td><code><pre>        }</pre></code></td></tr><tr><td>211</td><td><code><pre></pre></code></td></tr><tr><td>212</td><td><code><pre>        return ExpiredSessionToken, -1</pre></code></td></tr><tr><td>213</td><td><code><pre>}</pre></code></td></tr></table>
223 | 
224 | <div class="funcname" id="fn_UpdatePasswordRecordLoginCount">func UpdatePasswordRecordLoginCount</div><div class="info"><a href="#s_fn_UpdatePasswordRecordLoginCount">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
225 | <tr><td>268</td><td><code><pre>func UpdatePasswordRecordLoginCount(userid int64, resetFlag bool, db *gorm.DB) error {</pre></code></td></tr><tr><td>269</td><td><code><pre>        var record PasswordRecord</pre></code></td></tr><tr><td>270</td><td><code><pre>        dbErr := db.Where(&amp;PasswordRecord{UserId: userid}).Find(&amp;record).Error</pre></code></td></tr><tr><td>271</td><td><code><pre>        if dbErr != nil {</pre></code></td></tr><tr class="miss"><td>272</td><td><code><pre>                return dbErr</pre></code></td></tr><tr><td>273</td><td><code><pre>        }</pre></code></td></tr><tr><td>274</td><td><code><pre></pre></code></td></tr><tr><td>275</td><td><code><pre>        if resetFlag {</pre></code></td></tr><tr class="miss"><td>276</td><td><code><pre>                record.LoginCount = 0</pre></code></td></tr><tr><td>277</td><td><code><pre>        } else {</pre></code></td></tr><tr><td>278</td><td><code><pre>                record.LoginCount++</pre></code></td></tr><tr><td>279</td><td><code><pre>        }</pre></code></td></tr><tr><td>280</td><td><code><pre></pre></code></td></tr><tr><td>281</td><td><code><pre>        db.Save(&amp;record)</pre></code></td></tr><tr><td>282</td><td><code><pre></pre></code></td></tr><tr><td>283</td><td><code><pre>        return nil</pre></code></td></tr><tr><td>284</td><td><code><pre>}</pre></code></td></tr></table>
226 | 
227 | <div class="funcname" id="fn_GetTimeOutValue">func GetTimeOutValue</div><div class="info"><a href="#s_fn_GetTimeOutValue">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
228 | <tr><td>88</td><td><code><pre>func GetTimeOutValue(deviceId int) (time.Time, error) {</pre></code></td></tr><tr><td>89</td><td><code><pre></pre></code></td></tr><tr><td>90</td><td><code><pre>        var propName string</pre></code></td></tr><tr><td>91</td><td><code><pre></pre></code></td></tr><tr><td>92</td><td><code><pre>        if deviceId == web {</pre></code></td></tr><tr><td>93</td><td><code><pre>                propName = &#34;WebTimeOut&#34;</pre></code></td></tr><tr><td>94</td><td><code><pre>        } else if deviceId == mobile {</pre></code></td></tr><tr><td>95</td><td><code><pre>                propName = &#34;MobileTimeOut&#34;</pre></code></td></tr><tr><td>96</td><td><code><pre>        } else {</pre></code></td></tr><tr><td>97</td><td><code><pre>                ERROR.Println(&#34;Invalid deviceId&#34;)</pre></code></td></tr><tr><td>98</td><td><code><pre>                return time.Time{}, errors.New(&#34;Invalid device&#34;)</pre></code></td></tr><tr><td>99</td><td><code><pre>        }</pre></code></td></tr><tr><td>100</td><td><code><pre></pre></code></td></tr><tr><td>101</td><td><code><pre>        timeOutString, err := GetAppProperties(propName)</pre></code></td></tr><tr><td>102</td><td><code><pre></pre></code></td></tr><tr><td>103</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>104</td><td><code><pre>                ERROR.Println(err.Error())</pre></code></td></tr><tr class="miss"><td>105</td><td><code><pre>                return time.Time{}, err</pre></code></td></tr><tr><td>106</td><td><code><pre>        }</pre></code></td></tr><tr><td>107</td><td><code><pre></pre></code></td></tr><tr><td>108</td><td><code><pre>        timeOutValue, err := strconv.Atoi(timeOutString)</pre></code></td></tr><tr><td>109</td><td><code><pre></pre></code></td></tr><tr><td>110</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>111</td><td><code><pre>                ERROR.Println(&#34;String to integer conversion failed for &#34; + propName)</pre></code></td></tr><tr class="miss"><td>112</td><td><code><pre>                return time.Time{}, err</pre></code></td></tr><tr><td>113</td><td><code><pre>        }</pre></code></td></tr><tr><td>114</td><td><code><pre></pre></code></td></tr><tr><td>115</td><td><code><pre>        expiryTime := time.Now().UTC().Add(time.Duration(timeOutValue) * time.Minute)</pre></code></td></tr><tr><td>116</td><td><code><pre></pre></code></td></tr><tr><td>117</td><td><code><pre>        return expiryTime, nil</pre></code></td></tr><tr><td>118</td><td><code><pre>}</pre></code></td></tr></table>
229 | 
230 | <div class="funcname" id="fn_EncryptPassword">func EncryptPassword</div><div class="info"><a href="#s_fn_EncryptPassword">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
231 | <tr><td>173</td><td><code><pre>func EncryptPassword(password string) (string, error) {</pre></code></td></tr><tr><td>174</td><td><code><pre></pre></code></td></tr><tr><td>175</td><td><code><pre>        encryptedPasswordBytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)</pre></code></td></tr><tr><td>176</td><td><code><pre></pre></code></td></tr><tr><td>177</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>178</td><td><code><pre>                return &#34;&#34;, err</pre></code></td></tr><tr><td>179</td><td><code><pre>        }</pre></code></td></tr><tr><td>180</td><td><code><pre></pre></code></td></tr><tr><td>181</td><td><code><pre>        return string(encryptedPasswordBytes), nil</pre></code></td></tr><tr><td>182</td><td><code><pre>}</pre></code></td></tr></table>
232 | 
233 | <div class="funcname" id="fn_ChangePassword">func ChangePassword</div><div class="info"><a href="#s_fn_ChangePassword">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
234 | <tr><td>232</td><td><code><pre>func ChangePassword(username string, newpassword string, db *gorm.DB) (int, error) {</pre></code></td></tr><tr><td>233</td><td><code><pre>        var user User</pre></code></td></tr><tr><td>234</td><td><code><pre>        var err error</pre></code></td></tr><tr><td>235</td><td><code><pre></pre></code></td></tr><tr><td>236</td><td><code><pre>        dbErr := db.Where(&amp;User{UserName: username}).Find(&amp;user).Error</pre></code></td></tr><tr><td>237</td><td><code><pre>        if dbErr != nil {</pre></code></td></tr><tr><td>238</td><td><code><pre>                if dbErr == gorm.RecordNotFound {</pre></code></td></tr><tr><td>239</td><td><code><pre>                        WARNING.Println(UnregisteredUser.Error() + &#34; ,username: &#34; + username)</pre></code></td></tr><tr><td>240</td><td><code><pre>                        return 401, UnregisteredUser</pre></code></td></tr><tr><td>241</td><td><code><pre>                } else {</pre></code></td></tr><tr class="miss"><td>242</td><td><code><pre>                        ERROR.Println(dbErr.Error())</pre></code></td></tr><tr class="miss"><td>243</td><td><code><pre>                        return 500, DatabaseError</pre></code></td></tr><tr><td>244</td><td><code><pre>                }</pre></code></td></tr><tr><td>245</td><td><code><pre>        }</pre></code></td></tr><tr><td>246</td><td><code><pre></pre></code></td></tr><tr><td>247</td><td><code><pre>        user.Password, err = EncryptPassword(newpassword)</pre></code></td></tr><tr><td>248</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>249</td><td><code><pre>                ERROR.Println(err.Error())</pre></code></td></tr><tr class="miss"><td>250</td><td><code><pre>                return 500, EncryptionError</pre></code></td></tr><tr><td>251</td><td><code><pre>        }</pre></code></td></tr><tr><td>252</td><td><code><pre></pre></code></td></tr><tr><td>253</td><td><code><pre>        db.Save(&amp;user)</pre></code></td></tr><tr><td>254</td><td><code><pre>        updatePasswordErr := UpdatePasswordRecordLoginCount(user.Id, false, db)</pre></code></td></tr><tr><td>255</td><td><code><pre></pre></code></td></tr><tr><td>256</td><td><code><pre>        if updatePasswordErr != nil {</pre></code></td></tr><tr class="miss"><td>257</td><td><code><pre>                ERROR.Println(&#34;Password record not updated for userId: &#34; + strconv.FormatInt(user.Id, 10) + &#34;, Error details: &#34; + updatePasswordErr.Error())</pre></code></td></tr><tr class="miss"><td>258</td><td><code><pre>                return 500, DatabaseError</pre></code></td></tr><tr><td>259</td><td><code><pre>        }</pre></code></td></tr><tr><td>260</td><td><code><pre></pre></code></td></tr><tr><td>261</td><td><code><pre>        db.Save(&amp;ActivityLog{UserId: user.Id, TokenId: -1, ActivityTime: time.Now().UTC(), Event: PASSWORD_CHANGE})</pre></code></td></tr><tr><td>262</td><td><code><pre>        TRACE.Println(&#34;Password changed for userId: &#34; + strconv.FormatInt(user.Id, 10))</pre></code></td></tr><tr><td>263</td><td><code><pre></pre></code></td></tr><tr><td>264</td><td><code><pre>        return 200, nil</pre></code></td></tr><tr><td>265</td><td><code><pre>}</pre></code></td></tr></table>
235 | 
236 | <div class="funcname" id="fn_JobArchiveExpiredSessionToken">func JobArchiveExpiredSessionToken</div><div class="info"><a href="#s_fn_JobArchiveExpiredSessionToken">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/scheduledJobs.go</code>:</p></div><table class="listing">
237 | <tr><td>37</td><td><code><pre>func JobArchiveExpiredSessionToken() {</pre></code></td></tr><tr><td>38</td><td><code><pre></pre></code></td></tr><tr><td>39</td><td><code><pre>        tokenCleanUpFrequencyString, err := GetAppProperties(&#34;TokenCleanUpFrequency&#34;)</pre></code></td></tr><tr><td>40</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>41</td><td><code><pre>                ERROR.Println(err.Error())</pre></code></td></tr><tr><td>42</td><td><code><pre>        }</pre></code></td></tr><tr><td>43</td><td><code><pre></pre></code></td></tr><tr><td>44</td><td><code><pre>        tokenCleanUpFrequencyInteger, err := strconv.Atoi(tokenCleanUpFrequencyString)</pre></code></td></tr><tr><td>45</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>46</td><td><code><pre>                ERROR.Println(&#34;String to integer conversion failed for TokenCleanUpFrequency reverting to default value of 180 minutes&#34;)</pre></code></td></tr><tr class="miss"><td>47</td><td><code><pre>                tokenCleanUpFrequencyInteger = 180</pre></code></td></tr><tr><td>48</td><td><code><pre>        }</pre></code></td></tr><tr><td>49</td><td><code><pre></pre></code></td></tr><tr><td>50</td><td><code><pre>        ticker := time.NewTicker(time.Duration(tokenCleanUpFrequencyInteger) * time.Minute)</pre></code></td></tr><tr><td>51</td><td><code><pre>        TRACE.Println(&#34;Starting goroutine for token archiving&#34;)</pre></code></td></tr><tr><td>52</td><td><code><pre>        go func() {</pre></code></td></tr><tr><td>53</td><td><code><pre>                for {</pre></code></td></tr><tr><td>54</td><td><code><pre>                        select {</pre></code></td></tr><tr><td>55</td><td><code><pre>                        case &lt;-ticker.C:</pre></code></td></tr><tr><td>56</td><td><code><pre>                                ArchiveTokenAfterCutOffTime(&amp;dbConnection)</pre></code></td></tr><tr><td>57</td><td><code><pre>                        case &lt;-quit:</pre></code></td></tr><tr><td>58</td><td><code><pre>                                TRACE.Println(&#34;Quit signal: JobArchiveExpiredSessionToken&#34;)</pre></code></td></tr><tr><td>59</td><td><code><pre>                        }</pre></code></td></tr><tr><td>60</td><td><code><pre>                }</pre></code></td></tr><tr><td>61</td><td><code><pre>        }()</pre></code></td></tr><tr><td>62</td><td><code><pre></pre></code></td></tr><tr><td>63</td><td><code><pre>}</pre></code></td></tr></table>
238 | 
239 | <div class="funcname" id="fn_InitApp">func InitApp</div><div class="info"><a href="#s_fn_InitApp">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/util.go</code>:</p></div><table class="listing">
240 | <tr><td>62</td><td><code><pre>func InitApp(logFileName string, initializeDB *bool) {</pre></code></td></tr><tr><td>63</td><td><code><pre>        var err error</pre></code></td></tr><tr><td>64</td><td><code><pre>        file, err = os.OpenFile(logFileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)</pre></code></td></tr><tr><td>65</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>66</td><td><code><pre>                fmt.Println(&#34;Log file cannot be opened&#34;)</pre></code></td></tr><tr class="miss"><td>67</td><td><code><pre>                file.Close()</pre></code></td></tr><tr class="miss"><td>68</td><td><code><pre>                file = os.Stdout</pre></code></td></tr><tr><td>69</td><td><code><pre>        }</pre></code></td></tr><tr><td>70</td><td><code><pre></pre></code></td></tr><tr><td>71</td><td><code><pre>        InitLogger(file, file, file, file, file)</pre></code></td></tr><tr><td>72</td><td><code><pre>        TRACE.Println(&#34;Logger initialized to file &#34; + logFileName)</pre></code></td></tr><tr><td>73</td><td><code><pre></pre></code></td></tr><tr><td>74</td><td><code><pre>        dbConnection = GetDBConnection()</pre></code></td></tr><tr><td>75</td><td><code><pre>        TRACE.Println(&#34;Global connection object initialized&#34;)</pre></code></td></tr><tr><td>76</td><td><code><pre></pre></code></td></tr><tr><td>77</td><td><code><pre>        TRACE.Println(string(strconv.AppendBool([]byte(&#34;Application started with Init DB flag value &#34;), *initializeDB)))</pre></code></td></tr><tr><td>78</td><td><code><pre></pre></code></td></tr><tr><td>79</td><td><code><pre>        if *initializeDB == true {</pre></code></td></tr><tr class="miss"><td>80</td><td><code><pre>                TRACE.Println(&#34;DB Init Start&#34;)</pre></code></td></tr><tr class="miss"><td>81</td><td><code><pre>                InitDB()</pre></code></td></tr><tr class="miss"><td>82</td><td><code><pre>                TRACE.Println(&#34;DB Init Complete&#34;)</pre></code></td></tr><tr><td>83</td><td><code><pre>        }</pre></code></td></tr><tr><td>84</td><td><code><pre></pre></code></td></tr><tr><td>85</td><td><code><pre>        LoadAppPropertiesFromDb()</pre></code></td></tr><tr><td>86</td><td><code><pre></pre></code></td></tr><tr><td>87</td><td><code><pre>        dbLoggerPropertyValue, err := GetAppProperties(&#34;DbDebugLogs&#34;)</pre></code></td></tr><tr><td>88</td><td><code><pre></pre></code></td></tr><tr><td>89</td><td><code><pre>        if err == nil {</pre></code></td></tr><tr><td>90</td><td><code><pre>                dbLoggerFlag, err := strconv.ParseBool(dbLoggerPropertyValue)</pre></code></td></tr><tr><td>91</td><td><code><pre>                if err == nil &amp;&amp; dbLoggerFlag {</pre></code></td></tr><tr class="miss"><td>92</td><td><code><pre>                        dbConnection.LogMode(dbLoggerFlag)</pre></code></td></tr><tr class="miss"><td>93</td><td><code><pre>                        dbConnection.SetLogger(DATABASE)</pre></code></td></tr><tr class="miss"><td>94</td><td><code><pre>                        TRACE.Println(&#34;Database logger initialized&#34;)</pre></code></td></tr><tr><td>95</td><td><code><pre>                }</pre></code></td></tr><tr><td>96</td><td><code><pre>        }</pre></code></td></tr><tr><td>97</td><td><code><pre></pre></code></td></tr><tr><td>98</td><td><code><pre>        StartScheduledJobs()</pre></code></td></tr><tr><td>99</td><td><code><pre>}</pre></code></td></tr></table>
241 | 
242 | <div class="funcname" id="fn_GetTimeExtension">func GetTimeExtension</div><div class="info"><a href="#s_fn_GetTimeExtension">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
243 | <tr><td>215</td><td><code><pre>func GetTimeExtension() int {</pre></code></td></tr><tr><td>216</td><td><code><pre></pre></code></td></tr><tr><td>217</td><td><code><pre>        timeExtensionString, err := GetAppProperties(&#34;TimeExtension&#34;)</pre></code></td></tr><tr><td>218</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>219</td><td><code><pre>                ERROR.Println(err.Error())</pre></code></td></tr><tr class="miss"><td>220</td><td><code><pre>                return 0</pre></code></td></tr><tr><td>221</td><td><code><pre>        }</pre></code></td></tr><tr><td>222</td><td><code><pre></pre></code></td></tr><tr><td>223</td><td><code><pre>        extension, conversionErr := strconv.Atoi(timeExtensionString)</pre></code></td></tr><tr><td>224</td><td><code><pre>        if conversionErr != nil {</pre></code></td></tr><tr class="miss"><td>225</td><td><code><pre>                ERROR.Println(conversionErr.Error())</pre></code></td></tr><tr class="miss"><td>226</td><td><code><pre>                return 0</pre></code></td></tr><tr><td>227</td><td><code><pre>        }</pre></code></td></tr><tr><td>228</td><td><code><pre></pre></code></td></tr><tr><td>229</td><td><code><pre>        return extension</pre></code></td></tr><tr><td>230</td><td><code><pre>}</pre></code></td></tr></table>
244 | 
245 | <div class="funcname" id="fn_@52:5">func @52:5</div><div class="info"><a href="#s_fn_@52:5">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/scheduledJobs.go</code>:</p></div><table class="listing">
246 | <tr><td>52</td><td><code><pre>func() {</pre></code></td></tr><tr><td>53</td><td><code><pre>                for {</pre></code></td></tr><tr><td>54</td><td><code><pre>                        select {</pre></code></td></tr><tr><td>55</td><td><code><pre>                        case &lt;-ticker.C:</pre></code></td></tr><tr class="miss"><td>56</td><td><code><pre>                                ArchiveTokenAfterCutOffTime(&amp;dbConnection)</pre></code></td></tr><tr><td>57</td><td><code><pre>                        case &lt;-quit:</pre></code></td></tr><tr class="miss"><td>58</td><td><code><pre>                                TRACE.Println(&#34;Quit signal: JobArchiveExpiredSessionToken&#34;)</pre></code></td></tr><tr><td>59</td><td><code><pre>                        }</pre></code></td></tr><tr><td>60</td><td><code><pre>                }</pre></code></td></tr><tr><td>61</td><td><code><pre>        }</pre></code></td></tr></table>
247 | 
248 | <div class="funcname" id="fn_@24:5">func @24:5</div><div class="info"><a href="#s_fn_@24:5">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/scheduledJobs.go</code>:</p></div><table class="listing">
249 | <tr><td>24</td><td><code><pre>func() {</pre></code></td></tr><tr><td>25</td><td><code><pre>                for {</pre></code></td></tr><tr><td>26</td><td><code><pre>                        select {</pre></code></td></tr><tr><td>27</td><td><code><pre>                        case &lt;-ticker.C:</pre></code></td></tr><tr class="miss"><td>28</td><td><code><pre>                                LoadAppPropertiesFromDb()</pre></code></td></tr><tr><td>29</td><td><code><pre>                        case &lt;-quit:</pre></code></td></tr><tr class="miss"><td>30</td><td><code><pre>                                TRACE.Println(&#34;Quit signal: JobRefreshAppProperties&#34;)</pre></code></td></tr><tr class="miss"><td>31</td><td><code><pre>                                ticker.Stop()</pre></code></td></tr><tr><td>32</td><td><code><pre>                        }</pre></code></td></tr><tr><td>33</td><td><code><pre>                }</pre></code></td></tr><tr><td>34</td><td><code><pre>        }</pre></code></td></tr></table>
250 | 
251 | <div class="funcname" id="fn_ChangePasswordHandler">func ChangePasswordHandler</div><div class="info"><a href="#s_fn_ChangePasswordHandler">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlers.go</code>:</p></div><table class="listing">
252 | <tr><td>59</td><td><code><pre>func ChangePasswordHandler(request ChangePasswordRequest, r render.Render) {</pre></code></td></tr><tr><td>60</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>61</td><td><code><pre>        authenticateUserError := AuthenticateUser(request.Username, request.OldPassword, &amp;dbConnection)</pre></code></td></tr><tr class="miss"><td>62</td><td><code><pre>        if authenticateUserError == nil || authenticateUserError == FirstLoginPasswordChange {</pre></code></td></tr><tr class="miss"><td>63</td><td><code><pre>                status, changePasswordError := ChangePassword(request.Username, request.NewPassword, &amp;dbConnection)</pre></code></td></tr><tr class="miss"><td>64</td><td><code><pre>                if changePasswordError == nil {</pre></code></td></tr><tr class="miss"><td>65</td><td><code><pre>                        login := LoginCredential{Username: request.Username, Password: request.NewPassword, DeviceId: request.DeviceId}</pre></code></td></tr><tr class="miss"><td>66</td><td><code><pre>                        sessionToken, err := CreateNewTokenDbEntry(login, &amp;dbConnection)</pre></code></td></tr><tr class="miss"><td>67</td><td><code><pre>                        if err == nil {</pre></code></td></tr><tr class="miss"><td>68</td><td><code><pre>                                r.JSON(200, map[string]interface{}{&#34;passwordChanged&#34;: true, &#34;sessionToken&#34;: sessionToken})</pre></code></td></tr><tr><td>69</td><td><code><pre>                        } else {</pre></code></td></tr><tr class="miss"><td>70</td><td><code><pre>                                ERROR.Println(&#34;DB entry failed for token, returning 500&#34;)</pre></code></td></tr><tr class="miss"><td>71</td><td><code><pre>                                response := ErrorResponse{Status: &#34;Internal Server Error&#34;, Message: &#34;Password changed with but encountered: &#34; + SystemError.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>72</td><td><code><pre>                                r.JSON(500, response)</pre></code></td></tr><tr><td>73</td><td><code><pre>                        }</pre></code></td></tr><tr><td>74</td><td><code><pre>                } else {</pre></code></td></tr><tr class="miss"><td>75</td><td><code><pre>                        var response ErrorResponse</pre></code></td></tr><tr class="miss"><td>76</td><td><code><pre>                        if status == 401 {</pre></code></td></tr><tr class="miss"><td>77</td><td><code><pre>                                response = ErrorResponse{Status: &#34;Unauthorized&#34;, Message: AuthenticationFailed.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>78</td><td><code><pre>                        } else if status == 500 {</pre></code></td></tr><tr class="miss"><td>79</td><td><code><pre>                                response = ErrorResponse{Status: &#34;Internal Server Error&#34;, Message: SystemError.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr><td>80</td><td><code><pre>                        }</pre></code></td></tr><tr class="miss"><td>81</td><td><code><pre>                        r.JSON(status, response)</pre></code></td></tr><tr><td>82</td><td><code><pre>                }</pre></code></td></tr><tr><td>83</td><td><code><pre>        } else {</pre></code></td></tr><tr class="miss"><td>84</td><td><code><pre>                response := ErrorResponse{Status: &#34;Unauthorized&#34;, Message: AuthenticationFailed.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>85</td><td><code><pre>                r.JSON(401, response)</pre></code></td></tr><tr><td>86</td><td><code><pre>        }</pre></code></td></tr><tr><td>87</td><td><code><pre></pre></code></td></tr><tr><td>88</td><td><code><pre>}</pre></code></td></tr></table>
253 | 
254 | <div class="funcname" id="fn_main">func main</div><div class="info"><a href="#s_fn_main">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/server.go</code>:</p></div><table class="listing">
255 | <tr><td>27</td><td><code><pre>func main() {</pre></code></td></tr><tr><td>28</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>29</td><td><code><pre>        initializeDB := flag.Bool(&#34;initdb&#34;, false, &#34;initalizing database&#34;)</pre></code></td></tr><tr class="miss"><td>30</td><td><code><pre>        flag.Parse()</pre></code></td></tr><tr><td>31</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>32</td><td><code><pre>        InitApp(logFile, initializeDB)</pre></code></td></tr><tr><td>33</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>34</td><td><code><pre>        m := martini.Classic()</pre></code></td></tr><tr class="miss"><td>35</td><td><code><pre>        m.Use(render.Renderer())</pre></code></td></tr><tr class="miss"><td>36</td><td><code><pre>        m.Use(martini.Recovery())</pre></code></td></tr><tr><td>37</td><td><code><pre></pre></code></td></tr><tr><td>38</td><td><code><pre>        //status</pre></code></td></tr><tr class="miss"><td>39</td><td><code><pre>        m.Get(&#34;/status&#34;, StatusHandler)</pre></code></td></tr><tr><td>40</td><td><code><pre></pre></code></td></tr><tr><td>41</td><td><code><pre>        //Login end point</pre></code></td></tr><tr class="miss"><td>42</td><td><code><pre>        m.Post(&#34;/auth/login&#34;, binding.Bind(LoginCredential{}), LoginHandler)</pre></code></td></tr><tr><td>43</td><td><code><pre></pre></code></td></tr><tr><td>44</td><td><code><pre>        //Create new user</pre></code></td></tr><tr class="miss"><td>45</td><td><code><pre>        m.Post(&#34;/user/create&#34;, binding.Bind(CreateUserRequest{}), CreateUserHandler)</pre></code></td></tr><tr><td>46</td><td><code><pre></pre></code></td></tr><tr><td>47</td><td><code><pre>        //Validate unique username</pre></code></td></tr><tr class="miss"><td>48</td><td><code><pre>        m.Post(&#34;/validate/username&#34;, binding.Bind(ValidateUsernameRequest{}), ValidateUsernameHandler)</pre></code></td></tr><tr><td>49</td><td><code><pre></pre></code></td></tr><tr><td>50</td><td><code><pre>        //Validate session token</pre></code></td></tr><tr class="miss"><td>51</td><td><code><pre>        m.Post(&#34;/validate/token&#34;, binding.Bind(ValidateSessionTokenRequest{}), ValidateSessionTokenHandler)</pre></code></td></tr><tr><td>52</td><td><code><pre></pre></code></td></tr><tr><td>53</td><td><code><pre>        //Change password</pre></code></td></tr><tr class="miss"><td>54</td><td><code><pre>        m.Post(&#34;/user/changePassword&#34;, binding.Bind(ChangePasswordRequest{}), ChangePasswordHandler)</pre></code></td></tr><tr><td>55</td><td><code><pre></pre></code></td></tr><tr><td>56</td><td><code><pre>        //Check permission</pre></code></td></tr><tr class="miss"><td>57</td><td><code><pre>        m.Post(&#34;/user/checkPermission&#34;, binding.Bind(CheckPermissionRequest{}), CheckPermissionsForUserHandler)</pre></code></td></tr><tr><td>58</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>59</td><td><code><pre>        appGracefulShutdownTimeinSeconds, err := strconv.Atoi(viper.GetString(&#34;appGracefulShutdownTimeinSeconds&#34;))</pre></code></td></tr><tr class="miss"><td>60</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>61</td><td><code><pre>                ERROR.Panicln(&#34;Cannot start the server, shutdown time missing from config file&#34;)</pre></code></td></tr><tr><td>62</td><td><code><pre>        }</pre></code></td></tr><tr><td>63</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>64</td><td><code><pre>        graceful.Run(&#34;:&#34;+viper.GetString(&#34;appPort&#34;), time.Duration(appGracefulShutdownTimeinSeconds)*time.Second, m)</pre></code></td></tr><tr><td>65</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>66</td><td><code><pre>        defer cleanUpAfterShutdown()</pre></code></td></tr><tr><td>67</td><td><code><pre>}</pre></code></td></tr></table>
256 | 
257 | <div class="funcname" id="fn_InitDB">func InitDB</div><div class="info"><a href="#s_fn_InitDB">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/db.go</code>:</p></div><table class="listing">
258 | <tr><td>16</td><td><code><pre>func InitDB() {</pre></code></td></tr><tr><td>17</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>18</td><td><code><pre>        dbConnection.AutoMigrate(User{})</pre></code></td></tr><tr class="miss"><td>19</td><td><code><pre>        dbConnection.AutoMigrate(Permission{})</pre></code></td></tr><tr class="miss"><td>20</td><td><code><pre>        dbConnection.AutoMigrate(Group{})</pre></code></td></tr><tr class="miss"><td>21</td><td><code><pre>        dbConnection.AutoMigrate(GroupPermission{})</pre></code></td></tr><tr class="miss"><td>22</td><td><code><pre>        dbConnection.AutoMigrate(UserGroup{})</pre></code></td></tr><tr><td>23</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>24</td><td><code><pre>        dbConnection.AutoMigrate(AppProperties{})</pre></code></td></tr><tr class="miss"><td>25</td><td><code><pre>        dbConnection.AutoMigrate(ActivityLog{})</pre></code></td></tr><tr><td>26</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>27</td><td><code><pre>        dbConnection.AutoMigrate(Token{})</pre></code></td></tr><tr class="miss"><td>28</td><td><code><pre>        dbConnection.AutoMigrate(ArchivedToken{})</pre></code></td></tr><tr class="miss"><td>29</td><td><code><pre>        dbConnection.AutoMigrate(DeviceType{})</pre></code></td></tr><tr class="miss"><td>30</td><td><code><pre>        dbConnection.AutoMigrate(PasswordRecord{})</pre></code></td></tr><tr><td>31</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>32</td><td><code><pre>        InsertAppProperties(&amp;dbConnection)</pre></code></td></tr><tr class="miss"><td>33</td><td><code><pre>        InsertDeviceTypes(&amp;dbConnection)</pre></code></td></tr><tr><td>34</td><td><code><pre>}</pre></code></td></tr></table>
259 | 
260 | <div class="funcname" id="fn_LoginHandler">func LoginHandler</div><div class="info"><a href="#s_fn_LoginHandler">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlers.go</code>:</p></div><table class="listing">
261 | <tr><td>13</td><td><code><pre>func LoginHandler(login LoginCredential, r render.Render) {</pre></code></td></tr><tr><td>14</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>15</td><td><code><pre>        authenticateUserErr := AuthenticateUser(login.Username, login.Password, &amp;dbConnection)</pre></code></td></tr><tr><td>16</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>17</td><td><code><pre>        if authenticateUserErr == nil {</pre></code></td></tr><tr class="miss"><td>18</td><td><code><pre>                sessionToken, err := CreateNewTokenDbEntry(login, &amp;dbConnection)</pre></code></td></tr><tr class="miss"><td>19</td><td><code><pre>                if err != nil {</pre></code></td></tr><tr class="miss"><td>20</td><td><code><pre>                        ERROR.Println(DatabaseError.Error() + &#34; :&#34; + login.Username)</pre></code></td></tr><tr class="miss"><td>21</td><td><code><pre>                        response := ErrorResponse{Status: &#34;Internal Server Error&#34;, Message: SystemError.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>22</td><td><code><pre>                        r.JSON(500, response)</pre></code></td></tr><tr><td>23</td><td><code><pre>                } else {</pre></code></td></tr><tr class="miss"><td>24</td><td><code><pre>                        r.JSON(200, map[string]interface{}{&#34;sessionToken&#34;: sessionToken})</pre></code></td></tr><tr><td>25</td><td><code><pre>                }</pre></code></td></tr><tr class="miss"><td>26</td><td><code><pre>        } else if authenticateUserErr == FirstLoginPasswordChange {</pre></code></td></tr><tr class="miss"><td>27</td><td><code><pre>                response := ErrorResponse{Status: &#34;Forbidden&#34;, Message: FirstLoginPasswordChange.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>28</td><td><code><pre>                r.JSON(403, response)</pre></code></td></tr><tr><td>29</td><td><code><pre>        } else {</pre></code></td></tr><tr class="miss"><td>30</td><td><code><pre>                response := ErrorResponse{Status: &#34;Unauthorized&#34;, Message: AuthenticationFailed.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>31</td><td><code><pre>                r.JSON(401, response)</pre></code></td></tr><tr><td>32</td><td><code><pre>        }</pre></code></td></tr><tr><td>33</td><td><code><pre>}</pre></code></td></tr></table>
262 | 
263 | <div class="funcname" id="fn_ValidateSessionTokenHandler">func ValidateSessionTokenHandler</div><div class="info"><a href="#s_fn_ValidateSessionTokenHandler">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlers.go</code>:</p></div><table class="listing">
264 | <tr><td>90</td><td><code><pre>func ValidateSessionTokenHandler(request ValidateSessionTokenRequest, r render.Render) {</pre></code></td></tr><tr><td>91</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>92</td><td><code><pre>        err, userId := ValidateSessionToken(request.SessionToken, &amp;dbConnection)</pre></code></td></tr><tr><td>93</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>94</td><td><code><pre>        if err == nil {</pre></code></td></tr><tr class="miss"><td>95</td><td><code><pre>                r.JSON(200, map[string]interface{}{&#34;userId&#34;: userId})</pre></code></td></tr><tr><td>96</td><td><code><pre>        } else {</pre></code></td></tr><tr class="miss"><td>97</td><td><code><pre>                ERROR.Println(&#34;Error validating sessionToken: &#34; + request.SessionToken + &#34;, error:&#34; + err.Error())</pre></code></td></tr><tr class="miss"><td>98</td><td><code><pre>                if err == InvalidSessionToken {</pre></code></td></tr><tr class="miss"><td>99</td><td><code><pre>                        response := ErrorResponse{Status: &#34;Unauthorized&#34;, Message: InvalidSessionToken.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>100</td><td><code><pre>                        r.JSON(401, response)</pre></code></td></tr><tr class="miss"><td>101</td><td><code><pre>                } else if err == ExpiredSessionToken {</pre></code></td></tr><tr class="miss"><td>102</td><td><code><pre>                        response := ErrorResponse{Status: &#34;Forbidden&#34;, Message: ExpiredSessionToken.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>103</td><td><code><pre>                        r.JSON(403, response)</pre></code></td></tr><tr><td>104</td><td><code><pre>                } else {</pre></code></td></tr><tr class="miss"><td>105</td><td><code><pre>                        response := ErrorResponse{Status: &#34;Internal Server Error&#34;, Message: SystemError.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>106</td><td><code><pre>                        r.JSON(500, response)</pre></code></td></tr><tr><td>107</td><td><code><pre>                }</pre></code></td></tr><tr><td>108</td><td><code><pre>        }</pre></code></td></tr><tr><td>109</td><td><code><pre>}</pre></code></td></tr></table>
265 | 
266 | <div class="funcname" id="fn_ArchiveTokenAfterCutOffTime">func ArchiveTokenAfterCutOffTime</div><div class="info"><a href="#s_fn_ArchiveTokenAfterCutOffTime">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/util.go</code>:</p></div><table class="listing">
267 | <tr><td>140</td><td><code><pre>func ArchiveTokenAfterCutOffTime(db *gorm.DB) {</pre></code></td></tr><tr><td>141</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>142</td><td><code><pre>        tokenCutOffTimeString, err := GetAppProperties(&#34;TokenCutOffTime&#34;)</pre></code></td></tr><tr class="miss"><td>143</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>144</td><td><code><pre>                ERROR.Println(err.Error())</pre></code></td></tr><tr><td>145</td><td><code><pre>        }</pre></code></td></tr><tr><td>146</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>147</td><td><code><pre>        tokenCutOffTimeInteger, err := strconv.Atoi(tokenCutOffTimeString)</pre></code></td></tr><tr class="miss"><td>148</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>149</td><td><code><pre>                ERROR.Println(&#34;String to integer conversion failed for TokenCutOffTime, reverting to default value = 30 minutes&#34;)</pre></code></td></tr><tr class="miss"><td>150</td><td><code><pre>                tokenCutOffTimeInteger = 30</pre></code></td></tr><tr><td>151</td><td><code><pre>        }</pre></code></td></tr><tr><td>152</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>153</td><td><code><pre>        TRACE.Println(&#34;Token archiving started at: &#34; + time.Now().String())</pre></code></td></tr><tr><td>154</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>155</td><td><code><pre>        db.Exec(&#34;UPDATE TABLE tokens SET active = ? WHERE (SELECT EXTRACT(MINUTE FROM (? - expires_at)) FROM tokens) &gt; ?&#34;, false, time.Now().UTC(), tokenCutOffTimeInteger)</pre></code></td></tr><tr><td>156</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>157</td><td><code><pre>        db.Exec(&#34;INSERT INTO archived_tokens (token, user_id, key, created_at, last_accessed_at, expires_at, device_type_id, active)(SELECT (token, user_id, key, created_at, last_accessed_at, expires_at, device_type_id, active) WHERE active = ?)&#34;, false)</pre></code></td></tr><tr><td>158</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>159</td><td><code><pre>        db.Exec(&#34;DELETE FROM tokens WHERE active = ?&#34;, false)</pre></code></td></tr><tr><td>160</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>161</td><td><code><pre>        TRACE.Println(&#34;Token archiving completed at: &#34; + time.Now().String())</pre></code></td></tr><tr><td>162</td><td><code><pre>}</pre></code></td></tr></table>
268 | 
269 | <div class="funcname" id="fn_CreateUserHandler">func CreateUserHandler</div><div class="info"><a href="#s_fn_CreateUserHandler">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlers.go</code>:</p></div><table class="listing">
270 | <tr><td>42</td><td><code><pre>func CreateUserHandler(request CreateUserRequest, r render.Render) {</pre></code></td></tr><tr><td>43</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>44</td><td><code><pre>        status, err := CreateNewUser(request, &amp;dbConnection)</pre></code></td></tr><tr class="miss"><td>45</td><td><code><pre>        if err != nil {</pre></code></td></tr><tr class="miss"><td>46</td><td><code><pre>                ERROR.Println(err.Error())</pre></code></td></tr><tr class="miss"><td>47</td><td><code><pre>                var response ErrorResponse</pre></code></td></tr><tr class="miss"><td>48</td><td><code><pre>                if status == 500 {</pre></code></td></tr><tr class="miss"><td>49</td><td><code><pre>                        response = ErrorResponse{Status: &#34;Internal Server Error&#34;, Message: SystemError.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>50</td><td><code><pre>                } else if status == 409 {</pre></code></td></tr><tr class="miss"><td>51</td><td><code><pre>                        response = ErrorResponse{Status: &#34;Conflict&#34;, Message: err.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr><td>52</td><td><code><pre>                }</pre></code></td></tr><tr class="miss"><td>53</td><td><code><pre>                r.JSON(status, response)</pre></code></td></tr><tr><td>54</td><td><code><pre>        } else {</pre></code></td></tr><tr class="miss"><td>55</td><td><code><pre>                r.JSON(status, map[string]interface{}{&#34;userCreated&#34;: true})</pre></code></td></tr><tr><td>56</td><td><code><pre>        }</pre></code></td></tr><tr><td>57</td><td><code><pre>}</pre></code></td></tr></table>
271 | 
272 | <div class="funcname" id="fn_CheckPermissionsForUserHandler">func CheckPermissionsForUserHandler</div><div class="info"><a href="#s_fn_CheckPermissionsForUserHandler">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlers.go</code>:</p></div><table class="listing">
273 | <tr><td>111</td><td><code><pre>func CheckPermissionsForUserHandler(request CheckPermissionRequest, r render.Render) {</pre></code></td></tr><tr><td>112</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>113</td><td><code><pre>        err := CheckPermissionsForUser(request.UserId, Permission{PermissionDescription: request.PermissionDescription}, &amp;dbConnection)</pre></code></td></tr><tr><td>114</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>115</td><td><code><pre>        if err == nil {</pre></code></td></tr><tr class="miss"><td>116</td><td><code><pre>                r.JSON(200, map[string]interface{}{&#34;permissionCheck&#34;: true})</pre></code></td></tr><tr class="miss"><td>117</td><td><code><pre>        } else if err == PermissionDenied {</pre></code></td></tr><tr class="miss"><td>118</td><td><code><pre>                response := ErrorResponse{Status: &#34;Unauthorized&#34;, Message: PermissionDenied.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>119</td><td><code><pre>                r.JSON(401, response)</pre></code></td></tr><tr><td>120</td><td><code><pre>        } else {</pre></code></td></tr><tr class="miss"><td>121</td><td><code><pre>                response := ErrorResponse{Status: &#34;Internal Server Error&#34;, Message: SystemError.Error(), Description: &#34;&#34;}</pre></code></td></tr><tr class="miss"><td>122</td><td><code><pre>                r.JSON(500, response)</pre></code></td></tr><tr><td>123</td><td><code><pre>        }</pre></code></td></tr><tr><td>124</td><td><code><pre></pre></code></td></tr><tr><td>125</td><td><code><pre>}</pre></code></td></tr></table>
274 | 
275 | <div class="funcname" id="fn_ValidateUsernameHandler">func ValidateUsernameHandler</div><div class="info"><a href="#s_fn_ValidateUsernameHandler">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlers.go</code>:</p></div><table class="listing">
276 | <tr><td>35</td><td><code><pre>func ValidateUsernameHandler(usernameRequest ValidateUsernameRequest, r render.Render) {</pre></code></td></tr><tr><td>36</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>37</td><td><code><pre>        validUsernameFlag := ValidateUniqueUsername(usernameRequest.Username, &amp;dbConnection)</pre></code></td></tr><tr><td>38</td><td><code><pre></pre></code></td></tr><tr class="miss"><td>39</td><td><code><pre>        r.JSON(200, map[string]interface{}{&#34;valid&#34;: validUsernameFlag})</pre></code></td></tr><tr><td>40</td><td><code><pre>}</pre></code></td></tr></table>
277 | 
278 | <div class="funcname" id="fn_StatusHandler">func StatusHandler</div><div class="info"><a href="#s_fn_StatusHandler">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlers.go</code>:</p></div><table class="listing">
279 | <tr><td>8</td><td><code><pre>func StatusHandler(r render.Render) {</pre></code></td></tr><tr class="miss"><td>9</td><td><code><pre>        r.JSON(200, map[string]interface{}{&#34;status&#34;: Status()})</pre></code></td></tr><tr><td>10</td><td><code><pre>}</pre></code></td></tr></table>
280 | 
281 | <div class="funcname" id="fn_Status">func Status</div><div class="info"><a href="#s_fn_Status">Back</a><p>In <code>/Users/absharma/Desktop/code/gocode/src/gondalf/handlerUtils.go</code>:</p></div><table class="listing">
282 | <tr><td>184</td><td><code><pre>func Status() string {</pre></code></td></tr><tr class="miss"><td>185</td><td><code><pre>        return &#34;alive at &#34; + time.Now().String()</pre></code></td></tr><tr><td>186</td><td><code><pre>}</pre></code></td></tr></table>
283 | 
284 | <!-- Can be parsed by external script
285 | PACKAGE:gondalf DONE:58.61
286 | -->
287 | 
288 | <div id="summaryWrapper"><div class="package">gondalf</div>
289 | <div id="totalcov">58.61%</div>
290 | </div>
291 |     </body>
292 | 


--------------------------------------------------------------------------------