fixed the role and policy update issues

server/action/organisation/application/policy/create.go

@@ -14,6 +14,7 @@ import (
 	"github.com/factly/x/errorx"
 	"github.com/factly/x/loggerx"
 	"github.com/factly/x/renderx"
+	"github.com/factly/x/slugx"
 	"github.com/go-chi/chi"
 )
 
@@ -90,7 +91,7 @@ func create(w http.ResponseWriter, r *http.Request) {
 	var policy model.ApplicationPolicy
 	policy.CreatedByID = uint(userID)
 	policy.Name = reqBody.Name
-	policy.Slug = reqBody.Slug
+	policy.Slug = slugx.Make(reqBody.Name)
 	policy.Description = reqBody.Description
 	policy.ApplicationID = uint(appID)
 	policy.Permissions = reqBody.Permissions

server/action/organisation/application/policy/update.go

@@ -14,6 +14,7 @@ import (
 	"github.com/factly/x/errorx"
 	"github.com/factly/x/loggerx"
 	"github.com/factly/x/renderx"
+	"github.com/factly/x/slugx"
 	"github.com/go-chi/chi"
 )
 
@@ -82,8 +83,26 @@ func update(w http.ResponseWriter, r *http.Request) {
 	policy.Description = reqBody.Description
 	policy.ApplicationID = uint(appID)
 	policy.Permissions = reqBody.Permissions
-	policy.Slug = reqBody.Slug
+	policy.Slug = slugx.Make(reqBody.Name)
 	policy.OrganisationID = uint(orgID)
+	tx := model.DB.Begin()
+	var count int64
+	err = tx.Model(&model.ApplicationPolicy{}).Where(&model.ApplicationPolicy{
+		ApplicationID: uint(appID),
+		Slug:          policy.Slug,
+	}).Count(&count).Error
+	if err != nil {
+		tx.Rollback()
+		loggerx.Error(err)
+		errorx.Render(w, errorx.Parser(errorx.DBError()))
+		return
+	}
+	if count >= 1 {
+		tx.Rollback()
+		loggerx.Error(errors.New("slug already exists"))
+		errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
+		return
+	}
 	roles := make([]model.ApplicationRole, 0)
 	for _, each := range reqBody.Roles {
 		appRole := model.ApplicationRole{}
@@ -103,7 +122,6 @@ func update(w http.ResponseWriter, r *http.Request) {
 	policy.Roles = roles
 
 	// updating the application policy on the kavachDB
-	tx := model.DB.Begin()
 	err = tx.Model(&model.ApplicationPolicy{}).Where("id = ?", policyID).Updates(&policy).Error
 	if err != nil {
 		tx.Rollback()

server/action/organisation/application/roles/update.go

@@ -105,8 +105,25 @@ func update(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	var count int64
+	err = model.DB.Model(&model.ApplicationRole{}).Where(&model.ApplicationRole{
+		ApplicationID: uint(appID),
+		Slug:    appRole.Slug,
+	}).Count(&count).Error
+	if err != nil || count > 0 {
+		if err != nil {
+			loggerx.Error(err)
+			errorx.Render(w, errorx.Parser(errorx.DBError()))
+		} else {
+			loggerx.Error(errors.New("slug already exists"))
+			errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
+		}
+		return
+	}
+
 	updateMap := map[string]interface{}{
 		"name":        appRole.Name,
+		"slug":        appRole.Slug,
 		"description": appRole.Description,
 	}
 	//update the application role

server/action/organisation/application/space/policy/create.go

@@ -14,6 +14,7 @@ import (
 	"github.com/factly/x/errorx"
 	"github.com/factly/x/loggerx"
 	"github.com/factly/x/renderx"
+	"github.com/factly/x/slugx"
 	"github.com/go-chi/chi"
 )
 
@@ -100,7 +101,7 @@ func create(w http.ResponseWriter, r *http.Request) {
 	// binding the policyReq to SpacePolicy model
 	var policy model.SpacePolicy
 	policy.CreatedByID = uint(userID)
-	policy.Slug = reqBody.Slug
+	policy.Slug = slugx.Make(reqBody.Name)
 	policy.Name = reqBody.Name
 	policy.Description = reqBody.Description
 	policy.SpaceID = uint(spaceID)
@@ -113,21 +114,21 @@ func create(w http.ResponseWriter, r *http.Request) {
 	policy.Roles = roles
 	// inserting space role to the kavachDB
 	tx := model.DB.Begin()
-
 	var count int64
 	err = tx.Model(&model.SpacePolicy{}).Where(&model.SpacePolicy{
 		SpaceID: uint(spaceID),
 		Slug:    policy.Slug,
 	}).Count(&count).Error
-	if err != nil || count > 0 {
+	if err != nil {
 		tx.Rollback()
-		if err != nil {
-			loggerx.Error(err)
-			errorx.Render(w, errorx.Parser(errorx.DBError()))
-		} else {
-			loggerx.Error(errors.New("slug already exists"))
-			errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
-		}
+		loggerx.Error(err)
+		errorx.Render(w, errorx.Parser(errorx.DBError()))
+		return
+	}
+	if count >= 1 {
+		tx.Rollback()
+		loggerx.Error(errors.New("slug already exists"))
+		errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
 		return
 	}
 

server/action/organisation/application/space/policy/update.go

@@ -14,6 +14,7 @@ import (
 	"github.com/factly/x/errorx"
 	"github.com/factly/x/loggerx"
 	"github.com/factly/x/renderx"
+	"github.com/factly/x/slugx"
 	"github.com/go-chi/chi"
 )
 
@@ -100,9 +101,27 @@ func update(w http.ResponseWriter, r *http.Request) {
 	policy.ID = uint(policyID)
 	policy.Name = reqBody.Name
 	policy.Description = reqBody.Description
-	policy.Slug = reqBody.Slug
+	policy.Slug = slugx.Make(reqBody.Name)
 	policy.SpaceID = uint(spaceID)
 	policy.Permissions = reqBody.Permissions
+	tx := model.DB.Begin()
+	var count int64
+	err = tx.Model(&model.SpacePolicy{}).Where(&model.SpacePolicy{
+		SpaceID: uint(spaceID),
+		Slug:    policy.Slug,
+	}).Count(&count).Error
+	if err != nil {
+		tx.Rollback()
+		loggerx.Error(err)
+		errorx.Render(w, errorx.Parser(errorx.DBError()))
+		return
+	}
+	if count >= 1 {
+		tx.Rollback()
+		loggerx.Error(errors.New("slug already exists"))
+		errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
+		return
+	}
 	roles := make([]model.SpaceRole, 0)
 	for _, each := range reqBody.Roles {
 		spaceRole := model.SpaceRole{}
@@ -122,7 +141,6 @@ func update(w http.ResponseWriter, r *http.Request) {
 	policy.Roles = roles
 
 	// updating the policy in the kavachDB
-	tx := model.DB.Begin()
 	err = tx.Model(&model.SpacePolicy{}).Where("id = ?", policyID).Updates(&policy).Error
 	if err != nil {
 		tx.Rollback()

server/action/organisation/application/space/roles/update.go

@@ -2,6 +2,7 @@ package roles
 
 import (
 	"encoding/json"
+	"errors"
 	"net/http"
 	"strconv"
 
@@ -94,10 +95,27 @@ func update(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	var count int64
+	err = model.DB.Model(&model.SpaceRole{}).Where(&model.SpaceRole{
+		SpaceID: uint(spaceID),
+		Slug:    spaceRole.Slug,
+	}).Count(&count).Error
+	if err != nil || count > 0 {
+		if err != nil {
+			loggerx.Error(err)
+			errorx.Render(w, errorx.Parser(errorx.DBError()))
+		} else {
+			loggerx.Error(errors.New("slug already exists"))
+			errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
+		}
+		return
+	}
+
 	updateMap := map[string]interface{}{
-		"name": spaceRole.Name,
+		"name":        spaceRole.Name,
+		"slug":        spaceRole.Slug,
 		"description": spaceRole.Description,
-	} 
+	}
 
 	//update the application role
 	err = model.DB.Model(&model.SpaceRole{}).Where("space_id = ? AND id = ?", spaceID, roleIDInt).Updates(updateMap).Error

server/action/organisation/policy/create.go

@@ -12,6 +12,7 @@ import (
 	"github.com/factly/x/errorx"
 	"github.com/factly/x/loggerx"
 	"github.com/factly/x/renderx"
+	"github.com/factly/x/slugx"
 	"github.com/go-chi/chi"
 )
 
@@ -62,7 +63,7 @@ func create(w http.ResponseWriter, r *http.Request) {
 	// binding policyReq to the model.OrganisationPolicy datamodel
 	var policy model.OrganisationPolicy
 	policy.CreatedByID = uint(userID)
-	policy.Slug = reqBody.Slug
+	policy.Slug = slugx.Make(reqBody.Name)
 	policy.Name = reqBody.Name
 	policy.Description = reqBody.Description
 	policy.OrganisationID = uint(orgID)

server/action/organisation/policy/update.go

@@ -2,6 +2,7 @@ package policy
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
@@ -12,6 +13,7 @@ import (
 	"github.com/factly/x/errorx"
 	"github.com/factly/x/loggerx"
 	"github.com/factly/x/renderx"
+	"github.com/factly/x/slugx"
 	"github.com/go-chi/chi"
 )
 
@@ -72,10 +74,28 @@ func update(w http.ResponseWriter, r *http.Request) {
 	policy := new(model.OrganisationPolicy)
 	policy.ID = uint(policyID)
 	policy.Name = reqBody.Name
-	policy.Slug = reqBody.Slug
+	policy.Slug = slugx.Make(reqBody.Name)
 	policy.Description = reqBody.Description
 	policy.OrganisationID = uint(orgID)
 	policy.Permissions = reqBody.Permissions
+	tx := model.DB.Begin()
+	var count int64
+	err = tx.Model(&model.OrganisationPolicy{}).Where(&model.OrganisationPolicy{
+		OrganisationID: uint(orgID),
+		Slug:           policy.Slug,
+	}).Count(&count).Error
+	if err != nil {
+		tx.Rollback()
+		loggerx.Error(err)
+		errorx.Render(w, errorx.Parser(errorx.DBError()))
+		return
+	}
+	if count >= 1 {
+		tx.Rollback()
+		loggerx.Error(errors.New("slug already exists"))
+		errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
+		return
+	}
 	roles := make([]model.OrganisationRole, 0)
 	for _, each := range reqBody.Roles {
 		organisationRole := model.OrganisationRole{}
@@ -93,7 +113,7 @@ func update(w http.ResponseWriter, r *http.Request) {
 	}
 
 	policy.Roles = roles
-	tx := model.DB.Begin()
+
 	err = model.DB.Model(&model.OrganisationPolicy{}).Where("id = ?", policyID).Updates(policy).Error
 	if err != nil {
 		loggerx.Error(err)

server/action/organisation/roles/update.go

@@ -2,6 +2,7 @@ package roles
 
 import (
 	"encoding/json"
+	"errors"
 	"net/http"
 	"strconv"
 
@@ -73,11 +74,27 @@ func update(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	var count int64
+	err = model.DB.Model(&model.OrganisationRole{}).Where(&model.OrganisationRole{
+		OrganisationID: uint(orgID),
+		Slug:    organisationRole.Slug,
+	}).Count(&count).Error
+	if err != nil || count > 0 {
+		if err != nil {
+			loggerx.Error(err)
+			errorx.Render(w, errorx.Parser(errorx.DBError()))
+		} else {
+			loggerx.Error(errors.New("slug already exists"))
+			errorx.Render(w, errorx.Parser(errorx.SameNameExist()))
+		}
+		return
+	}
+
 	updateMap := map[string]interface{}{
-		"name": organisationRole.Name,
+		"name":        organisationRole.Name,
+		"slug":        organisationRole.Slug,
 		"description": organisationRole.Description,
-	} 
-
+	}
 	//update the organisation role
 	err = model.DB.Model(&model.OrganisationRole{}).Where("organisation_id = ? AND id = ?", orgID, roleIDInt).Updates(updateMap).Error
 	if err != nil {

server/action/user/checker.go

@@ -130,12 +130,23 @@ func checker(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		user.IsActive = true
 		// record does not exist so create new user
-		err = model.DB.Create(&user).Error
+		var count int64
+		err = model.DB.Model(&model.User{}).Where(&model.User{
+			Email: user.Email,
+		}).Count(&count).Error
 		if err != nil {
 			loggerx.Error(err)
 			errorx.Render(w, errorx.Parser(errorx.DBError()))
 			return
 		}
+		if count == 0 {
+			err = model.DB.Create(&user).Error
+			if err != nil {
+				loggerx.Error(err)
+				errorx.Render(w, errorx.Parser(errorx.DBError()))
+				return
+			}
+		}
 	}
 
 	payload.Header = make(http.Header)