fixed validation

controllers/common.go

@@ -58,14 +58,13 @@ func GetPeersList(networkName string) ([]models.PeersResponse, error) {
 	return peers, err
 }
 
-func ValidateNode(operation string, networkName string, node models.Node) error {
+func ValidateNodeCreate(networkName string, node models.Node) error {
 
 	v := validator.New()
-	fmt.Println("Address: " + node.Address)
 	_ = v.RegisterValidation("address_check", func(fl validator.FieldLevel) bool {
 		isIpv4 := functions.IsIpv4Net(node.Address)
-		notEmptyCheck := node.Address != ""
+		empty := node.Address == ""
-		return (notEmptyCheck && isIpv4)
+		return (empty || isIpv4)
 	})
 	_ = v.RegisterValidation("endpoint_check", func(fl validator.FieldLevel) bool {
 		//var isFieldUnique bool = functions.IsFieldUnique(networkName, "endpoint", node.Endpoint)
@@ -76,13 +75,13 @@ func ValidateNode(operation string, networkName string, node models.Node) error
 	_ = v.RegisterValidation("localaddress_check", func(fl validator.FieldLevel) bool {
 		//var isFieldUnique bool = functions.IsFieldUnique(networkName, "endpoint", node.Endpoint)
 		isIpv4 := functions.IsIpv4Net(node.LocalAddress)
-		notEmptyCheck := node.LocalAddress != ""
+		empty := node.LocalAddress == ""
-		return (notEmptyCheck && isIpv4)
+		return (empty || isIpv4)
 	})
 
 	_ = v.RegisterValidation("macaddress_unique", func(fl validator.FieldLevel) bool {
 		var isFieldUnique bool = functions.IsFieldUnique(networkName, "macaddress", node.MacAddress)
-		return isFieldUnique || operation == "update"
+		return isFieldUnique
 	})
 
 	_ = v.RegisterValidation("macaddress_valid", func(fl validator.FieldLevel) bool {
@@ -120,6 +119,66 @@ func ValidateNode(operation string, networkName string, node models.Node) error
 	return err
 }
 
+func ValidateNodeUpdate(networkName string, node models.Node) error {
+
+        v := validator.New()
+        _ = v.RegisterValidation("address_check", func(fl validator.FieldLevel) bool {
+                isIpv4 := functions.IsIpv4Net(node.Address)
+                empty := node.Address == ""
+                return (empty || isIpv4)
+        })
+        _ = v.RegisterValidation("endpoint_check", func(fl validator.FieldLevel) bool {
+                //var isFieldUnique bool = functions.IsFieldUnique(networkName, "endpoint", node.Endpoint)
+                isIpv4 := functions.IsIpv4Net(node.Endpoint)
+                empty := node.Endpoint == ""
+                return (empty || isIpv4)
+        })
+        _ = v.RegisterValidation("localaddress_check", func(fl validator.FieldLevel) bool {
+                //var isFieldUnique bool = functions.IsFieldUnique(networkName, "endpoint", node.Endpoint)
+                isIpv4 := functions.IsIpv4Net(node.LocalAddress)
+                empty := node.LocalAddress == ""
+                return (empty || isIpv4)
+        })
+
+        _ = v.RegisterValidation("macaddress_unique", func(fl validator.FieldLevel) bool {
+                return true
+        })
+
+        _ = v.RegisterValidation("macaddress_valid", func(fl validator.FieldLevel) bool {
+                _, err := net.ParseMAC(node.MacAddress)
+                return err == nil
+        })
+
+        _ = v.RegisterValidation("name_valid", func(fl validator.FieldLevel) bool {
+                isvalid := functions.NameInNodeCharSet(node.Name)
+                return isvalid
+        })
+
+        _ = v.RegisterValidation("network_exists", func(fl validator.FieldLevel) bool {
+                _, err := node.GetNetwork()
+                return err == nil
+        })
+        _ = v.RegisterValidation("pubkey_check", func(fl validator.FieldLevel) bool {
+                empty := node.PublicKey == ""
+                isBase64 := functions.IsBase64(node.PublicKey)
+                return (empty || isBase64)
+        })
+        _ = v.RegisterValidation("password_check", func(fl validator.FieldLevel) bool {
+                empty := node.Password == ""
+                goodLength := len(node.Password) > 5
+                return (empty || goodLength)
+        })
+
+        err := v.Struct(node)
+
+        if err != nil {
+                for _, e := range err.(validator.ValidationErrors) {
+                        fmt.Println(e)
+                }
+        }
+        return err
+}
+
 func UpdateNode(nodechange models.Node, node models.Node) (models.Node, error) {
 	//Question: Is there a better way  of doing  this than a bunch of "if" statements? probably...
 	//Eventually, lets have a better way to check if any of the fields are filled out...

controllers/nodeGrpcController.go

@@ -82,7 +82,7 @@ func (s *NodeServiceServer) CreateNode(ctx context.Context, req *nodepb.CreateNo
                         ListenPort:  data.GetListenport(),
 	}
 
-        err := ValidateNode("create", node.Network, node)
+        err := ValidateNodeCreate(node.Network, node)
 
         if err != nil {
                 // return internal gRPC error to be handled later
@@ -227,7 +227,7 @@ func (s *NodeServiceServer) UpdateNode(ctx context.Context, req *nodepb.UpdateNo
         network, _ := functions.GetParentNetwork(networkName)
 
 
-	err := ValidateNode("update", networkName, nodechange)
+	err := ValidateNodeUpdate(networkName, nodechange)
         if err != nil {
                 return nil, err
         }

controllers/nodeHttpController.go

@@ -509,7 +509,7 @@ func createNode(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	err = ValidateNode("create", networkName, node)
+	err = ValidateNodeCreate(networkName, node)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return
@@ -765,7 +765,7 @@ func updateNode(w http.ResponseWriter, r *http.Request) {
 	if nodechange.MacAddress == "" {
 		nodechange.MacAddress = node.MacAddress
 	}
-	err = ValidateNode("update", params["network"], nodechange)
+	err = ValidateNodeUpdate(params["network"], nodechange)
 	if err != nil {
 		returnErrorResponse(w, r, formatError(err, "badrequest"))
 		return