Merge pull request #138 from Avanade/116-refactor-approver-response-page

116 refactor approver response page

src/goapp/controller/item/item-controller-dto.go

@@ -1,5 +1,7 @@
 package item
 
+import "main/model"
+
 type ReassignItemCallback struct {
 	Id                  string `json:"Id"`
 	ApproverEmail       string `json:"ApproverEmail"`
@@ -9,3 +11,14 @@ type ReassignItemCallback struct {
 	ApproveText         string `json:"ApproveText"`
 	RejectText          string `json:"RejectText"`
 }
+
+type RespondePageData struct {
+	ApplicationId       string
+	ApplicationModuleId string
+	ItemId              string
+	ApproverEmail       string
+	IsApproved          string
+	Data                model.Item
+	RequireRemarks      bool
+	Response            string
+}

src/goapp/controller/item/item-controller-interface.go

@@ -12,4 +12,5 @@ type ItemController interface {
 type ItemPageController interface {
 	MyRequests(w http.ResponseWriter, r *http.Request)
 	MyApprovals(w http.ResponseWriter, r *http.Request)
+	RespondToItem(w http.ResponseWriter, r *http.Request)
 }

src/goapp/controller/item/item-page-controller.go

@@ -8,6 +8,8 @@ import (
 	"main/pkg/session"
 	"main/service"
 	"net/http"
+
+	"github.com/gorilla/mux"
 )
 
 type itemPageController struct {
@@ -99,3 +101,81 @@ func (c *itemPageController) MyApprovals(w http.ResponseWriter, r *http.Request)
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 	}
 }
+
+func (c *itemPageController) RespondToItem(w http.ResponseWriter, r *http.Request) {
+	session, _ := session.Store.Get(r, "auth-session")
+
+	var profile map[string]interface{}
+	u := session.Values["profile"]
+	profile, ok := u.(map[string]interface{})
+	if !ok {
+		http.Error(w, "Error getting user data", http.StatusInternalServerError)
+		return
+	}
+	user := model.AzureUser{
+		Name:  profile["name"].(string),
+		Email: profile["preferred_username"].(string),
+	}
+
+	params := mux.Vars(r)
+
+	itemIsAuthorized, err := c.Service.Item.ItemIsAuthorized(
+		params["appGuid"],
+		params["appModuleGuid"],
+		params["itemGuid"],
+		user.Email,
+	)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if !itemIsAuthorized.IsAuthorized {
+		t, d := c.Service.Template.UseTemplate("Unauthorized", r.URL.Path, user, nil)
+		err = t.Execute(w, d)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+	} else {
+		if itemIsAuthorized.IsApproved != nil {
+			var text string
+			if itemIsAuthorized.IsApproved.Value {
+				text = "approved"
+			} else {
+				text = "rejected"
+			}
+
+			data := RespondePageData{
+				Response: text,
+			}
+
+			t, d := c.Service.Template.UseTemplate("already-processed", r.URL.Path, user, data)
+			err = t.Execute(w, d)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+			}
+		} else {
+			item, err := c.Service.Item.GetItemById(params["itemGuid"])
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+				return
+			}
+
+			data := RespondePageData{
+				ApplicationId:       params["appGuid"],
+				ApplicationModuleId: params["appModuleGuid"],
+				ItemId:              params["itemGuid"],
+				ApproverEmail:       user.Email,
+				IsApproved:          params["isApproved"],
+				Data:                *item,
+				RequireRemarks:      itemIsAuthorized.RequireRemarks,
+			}
+
+			t, d := c.Service.Template.UseTemplate("response", r.URL.Path, user, data)
+			err = t.Execute(w, d)
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusInternalServerError)
+			}
+		}
+	}
+}

src/goapp/infrastructure/database/database.go

@@ -5,70 +5,63 @@ import (
 	"database/sql"
 	"fmt"
 	"main/config"
+	"time"
 
 	_ "github.com/microsoft/go-mssqldb"
 )
 
 type Database struct {
-	connString string
+	db *sql.DB
 }
 
 func NewDatabase(config config.ConfigManager) Database {
-	fmt.Println("ConnectDb New")
 	connectionString := config.GetDatabaseConnectionString()
-	return Database{
-		connString: connectionString,
-	}
-}
 
-func (d *Database) Connect() (*sql.DB, error) {
-	conn, err := sql.Open("sqlserver", d.connString)
+	conn, err := sql.Open("sqlserver", connectionString)
 	if err != nil {
-		return nil, err
+		fmt.Println(err.Error())
+		return Database{db: nil}
 	}
 
-	return conn, nil
-}
+	conn.SetMaxOpenConns(10)
+	conn.SetMaxIdleConns(10)
+	conn.SetConnMaxLifetime(5 * time.Minute)
 
-func (d *Database) Query(query string, args ...any) (*sql.Rows, error) {
-	conn, err := d.Connect()
+	err = conn.Ping()
 	if err != nil {
-		return nil, err
+		fmt.Println(err.Error())
+		return Database{db: nil}
+	}
+
+	fmt.Println("Database connection established and configured.")
+
+	return Database{
+		db: conn,
 	}
-	defer conn.Close()
+}
 
+func (d *Database) Query(query string, args ...any) (*sql.Rows, error) {
 	ctx := context.Background()
-	rows, err := conn.QueryContext(ctx, query, args...)
+	rows, err := d.db.QueryContext(ctx, query, args...)
 	if err != nil {
 		return nil, err
 	}
 	return rows, nil
 }
 
 func (d *Database) QueryRow(query string, args ...any) (*sql.Row, error) {
-	conn, err := d.Connect()
-	if err != nil {
-		return nil, err
-	}
-	defer conn.Close()
-
 	ctx := context.Background()
-	row := conn.QueryRowContext(ctx, query, args...)
+	row := d.db.QueryRowContext(ctx, query, args...)
 	if row == nil {
-		err = fmt.Errorf("QueryRowContext returned nil")
+		err := fmt.Errorf("QueryRowContext returned nil")
+		return nil, err
 	}
 	return row, nil
 }
 
 func (d *Database) Execute(query string, args ...any) error {
-	conn, err := d.Connect()
-	if err != nil {
-		return err
-	}
-	defer conn.Close()
-
 	ctx := context.Background()
-	_, err = conn.ExecContext(ctx, query, args...)
+	_, err := d.db.ExecContext(ctx, query, args...)
 	if err != nil {
 		return err
 	}

src/goapp/model/item.go

@@ -89,3 +89,13 @@ type ResponseCallback struct {
 	ResponseDate string `json:"responseDate"`
 	RespondedBy  string `json:"respondedBy"`
 }
+
+type ItemIsAuthorized struct {
+	IsAuthorized   bool      `json:"isAuthorized"`
+	IsApproved     *NullBool `json:"isApproved"`
+	RequireRemarks bool      `json:"requireRemarks"`
+}
+
+type NullBool struct {
+	Value bool
+}

src/goapp/model/template.go

@@ -3,7 +3,7 @@ package model
 type MasterPageData struct {
 	Header           Headers
 	Profile          AzureUser
-	Content          interface{}
+	Content          interface{} `json:"content"`
 	Footers          []Footer
 	OrganizationName string
 }

src/goapp/public/css/output.css

@@ -1847,18 +1847,14 @@ select {
   top: 50%;
 }
 
-.top-5 {
-  top: 1.25rem;
+.top-8 {
+  top: 2rem;
 }
 
 .top-full {
   top: 100%;
 }
 
-.top-8 {
-  top: 2rem;
-}
-
 .isolate {
   isolation: isolate;
 }

src/goapp/repository/app-module/app-module-repository.go

@@ -24,6 +24,7 @@ func (r *applicationModuleRepository) GetApplicationModuleByIdAndApplicationId(a
 	if err != nil {
 		return nil, err
 	}
+	defer rowApplicationModule.Close()
 
 	applicationModule, err := r.RowsToMap(rowApplicationModule)
 	if err != nil {
@@ -61,6 +62,7 @@ func (r *applicationModuleRepository) GetAll() ([]model.ApplicationModule, error
 	if err != nil {
 		return nil, err
 	}
+	defer rowApplicationModules.Close()
 
 	applicationModules, err := r.RowsToMap(rowApplicationModules)
 	if err != nil {

src/goapp/repository/approval-request-approver/approval-request-approver-repository.go

@@ -17,14 +17,15 @@ func NewApprovalRequestApproverRepository(db *db.Database) ApprovalRequestApprov
 }
 
 func (r *approvalRequestApproverRepository) InsertApprovalRequestApprover(approver model.ApprovalRequestApprover) error {
-	_, err := r.Query("PR_ApprovalRequestApprovers_Insert",
+	row, err := r.Query("PR_ApprovalRequestApprovers_Insert",
 		sql.Named("ItemId", approver.ItemId),
 		sql.Named("ApproverEmail", approver.ApproverEmail),
 	)
 
 	if err != nil {
 		return err
 	}
+	defer row.Close()
 
 	return nil
 }
@@ -35,6 +36,7 @@ func (r *approvalRequestApproverRepository) GetApproversByItemId(itemId string)
 	if err != nil {
 		return nil, err
 	}
+	defer rowApprovers.Close()
 
 	approvers, err := r.RowsToMap(rowApprovers)
 	if err != nil {

src/goapp/repository/item/item-repository-interface.go

@@ -9,6 +9,7 @@ type ItemRepository interface {
 	GetItemsBy(itemOptions model.ItemOptions) ([]model.Item, error)
 	GetTotalItemsBy(itemOptions model.ItemOptions) (int, error)
 	InsertItem(appModuleId, subject, body, requesterEmail string) (string, error)
+	ItemIsAuthorized(appId, appModuleId, itemId, approverEmail string) (*model.ItemIsAuthorized, error)
 	UpdateItemApproverEmail(id, approverEmail, username string) error
 	UpdateItemCallback(id string, isCallbackFailed bool) error
 	UpdateItemDateSent(id string) error