refactor respond page

Signed-off-by: Ismael Ibuan <[email protected]>

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/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/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

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

@@ -235,6 +235,39 @@ func (r *itemRepository) UpdateItemApproverEmail(id, approverEmail, username str
 	defer row.Close()
 	return nil
 }
+func (r *itemRepository) ItemIsAuthorized(appId, appModuleId, itemId, approverEmail string) (*model.ItemIsAuthorized, error) {
+	row, err := r.Query("PR_Items_IsAuthorized",
+		sql.Named("ApplicationId", appId),
+		sql.Named("ApplicationModuleId", appModuleId),
+		sql.Named("ItemId", itemId),
+		sql.Named("ApproverEmail", approverEmail),
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer row.Close()
+
+	result, err := r.RowsToMap(row)
+	if err != nil {
+		return nil, err
+	}
+
+	i := model.ItemIsAuthorized{
+		IsAuthorized: result[0]["IsAuthorized"] == "1",
+	}
+
+	if result[0]["IsApproved"] != nil {
+		i.IsApproved = &model.NullBool{Value: result[0]["IsApproved"].(bool)}
+	} else {
+		i.IsApproved = nil
+	}
+
+	if result[0]["RequireRemarks"] != nil {
+		i.RequireRemarks = result[0]["RequireRemarks"].(bool)
+	}
+
+	return &i, nil
+}
 
 func (r *itemRepository) UpdateItemCallback(id string, isCallbackFailed bool) error {
 	row, err := r.Query("PR_Items_Update_Callback",

src/goapp/routes.go

@@ -11,7 +11,7 @@ import (
 func setPageRoutes() {
 	httpRouter.GET("/", m.Chain(ctrl.ItemPage.MyRequests, m.AzureAuth()))
 	httpRouter.GET("/myapprovals", m.Chain(ctrl.ItemPage.MyApprovals, m.AzureAuth()))
-	httpRouter.GET("/response/{appGuid}/{appModuleGuid}/{itemGuid}/{isApproved}", m.Chain(rtApprovals.ResponseHandler, m.AzureAuth()))
+	httpRouter.GET("/response/{appGuid}/{appModuleGuid}/{itemGuid}/{isApproved}", m.Chain(ctrl.ItemPage.RespondToItem, m.AzureAuth()))
 	httpRouter.GET("/responsereassigned/{appGuid}/{appModuleGuid}/{itemGuid}/{isApproved}/{ApproveText}/{RejectText}", m.Chain(rtApprovals.ResponseReassignedeHandler, m.AzureAuth()))
 
 	httpRouter.GET("/loginredirect", rtPages.LoginRedirectHandler)

src/goapp/routes/pages/approvals/response.go

@@ -108,76 +108,6 @@ func ResponseReassignedeHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 }
-func ResponseHandler(w http.ResponseWriter, r *http.Request) {
-	switch r.Method {
-	case "GET":
-		var username string
-		sessionaz, _ := session.Store.Get(r, "auth-session")
-		iprofile := sessionaz.Values["profile"]
-
-		if iprofile != nil {
-			profile := iprofile.(map[string]interface{})
-			username = profile["preferred_username"].(string)
-		}
-		params := mux.Vars(r)
-
-		appGuid := params["appGuid"]
-		appModuleGuid := params["appModuleGuid"]
-		itemGuid := params["itemGuid"]
-		isApproved := params["isApproved"]
-
-		sqlParamsIsAuth := map[string]interface{}{
-			"ApplicationId":       appGuid,
-			"ApplicationModuleId": appModuleGuid,
-			"ItemId":              itemGuid,
-			"ApproverEmail":       username,
-		}
-
-		sqlParamsItems := map[string]interface{}{
-			"Id": itemGuid,
-		}
-
-		db := connectSql()
-		defer db.Close()
-		resIsAuth, err := db.ExecuteStoredProcedureWithResult("PR_RESPONSE_IsAuthorized", sqlParamsIsAuth)
-		handleErrorReturn(w, err)
-
-		isAuth := resIsAuth[0]["IsAuthorized"]
-		if isAuth == "0" {
-			template.UseTemplate(&w, r, "Unauthorized", nil)
-		} else {
-			isProcessed := resIsAuth[0]["IsApproved"]
-			if isProcessed != nil {
-				var text string
-				if isProcessed == true {
-					text = "approved"
-				} else {
-					text = "rejected"
-				}
-				data := map[string]interface{}{
-					"response": text,
-				}
-				template.UseTemplate(&w, r, "AlreadyProcessed", data)
-			} else {
-				resItems, err := db.ExecuteStoredProcedureWithResult("PR_Items_Select_ById", sqlParamsItems)
-
-				handleErrorReturn(w, err)
-				requireRemarks := resIsAuth[0]["RequireRemarks"]
-				data := map[string]interface{}{
-					"ApplicationId":       appGuid,
-					"ApplicationModuleId": appModuleGuid,
-					"ItemId":              itemGuid,
-					"ApproverEmail":       username,
-					"IsApproved":          isApproved,
-					"Data":                resItems[0],
-					"RequireRemarks":      requireRemarks,
-				}
-				template.UseTemplate(&w, r, "response", data)
-			}
-
-		}
-	}
-}
 
 func ProcessFailedCallbacks() {
 	db := connectSql()

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

@@ -8,6 +8,7 @@ type ItemService interface {
 	GetItemById(id string) (*model.Item, error)
 	GetAll(itemOptions model.ItemOptions) (model.Response, error)
 	InsertItem(item model.ItemInsertRequest) (string, error)
+	ItemIsAuthorized(appId, appModuleId, itemId, approverEmail string) (*model.ItemIsAuthorized, error)
 	UpdateItemApproverEmail(itemId, approverEmail, username string) error
 	UpdateItemCallback(itemId string, isCallbackFailed bool) error
 	UpdateItemDateSent(itemId string) error

src/goapp/service/item/item-service.go

@@ -83,6 +83,14 @@ func (s *itemService) InsertItem(item model.ItemInsertRequest) (string, error) {
 	return id, nil
 }
 
+func (s *itemService) ItemIsAuthorized(appId, appModuleId, itemId, approverEmail string) (*model.ItemIsAuthorized, error) {
+	itemIsAuthorized, err := s.Repository.Item.ItemIsAuthorized(appId, appModuleId, itemId, approverEmail)
+	if err != nil {
+		return nil, err
+	}
+	return itemIsAuthorized, nil
+}
+
 func (s *itemService) UpdateItemApproverEmail(itemId, approverEmail, username string) error {
 	err := s.Repository.Item.UpdateItemApproverEmail(itemId, approverEmail, username)
 	if err != nil {

src/goapp/templates/AlreadyProcessed.html → src/goapp/templates/already-processed.html

@@ -4,7 +4,7 @@
       <main class="sm:flex">
         <div style="text-align: center;">
           <h1 class="text-4xl font-extrabold text-gray-900 tracking-tight sm:text-5xl">Processed</h1>
-          <p class="mt-1 text-base text-gray-500">You have already {{.response}} this item.</p>
+          <p class="mt-1 text-base text-gray-500">You have already {{.Response}} this item.</p>
         </div>
       </main>
     </div>