Change error messages according to instructions document

server/router/routeutils/response.go

@@ -39,7 +39,7 @@ func ResponseAPIErrorWithData(c echo.Context, status int, message string, redire
 		Error:    true,
 		Message:  message,
 		Redirect: redirect,
-		Data:	  data,
+		Data:     data,
 	}
 
 	return c.JSON(status, returnValue)
@@ -92,11 +92,12 @@ func ResponseAPINotFoundError(c echo.Context) error {
 	return ResponseAPIError(c, http.StatusNotFound, "Not Found", false)
 }
 
-//ResponseAPINotEligible returns a standard API not eligible to the response
+//ResponseAPINotEligibleError returns a standard API not eligible to the response
 func ResponseAPINotEligibleError(c echo.Context) error {
-	return ResponseAPIError(c, http.StatusForbidden, "Eligibility Not Found or Error", false)
+	return ResponseAPIError(c, http.StatusForbidden, "Member does not have active insurance coverage", false)
 }
 
+//ResponseAPINotEligibleWithMessageError returns a standard API not eligible to the response with custom message
 func ResponseAPINotEligibleWithMessageError(c echo.Context, message string) error {
 	return ResponseAPIError(c, http.StatusForbidden, message, false)
 }

server/router/usersroute/controller.go

@@ -1,15 +1,15 @@
 package usersroute
 
 import (
+	"bytes"
 	b64 "encoding/base64"
+	"encoding/json"
 	"fmt"
 	"math/rand"
+	"net/http"
+	"strings"
 	"sync"
 	"time"
-	"net/http"
-	"encoding/json"
-	"bytes"
-	"strings"
 
 	"bitbucket.org/nemt/nemt-portal-api/application/applicationservice"
 	"bitbucket.org/nemt/nemt-portal-api/application/third/eligibility/bcbsi"
@@ -19,8 +19,8 @@ import (
 	"bitbucket.org/nemt/nemt-portal-api/infra/cache"
 	"bitbucket.org/nemt/nemt-portal-api/infra/config"
 	"bitbucket.org/nemt/nemt-portal-api/server/authorization"
-	"bitbucket.org/nemt/nemt-portal-api/server/validation"
 	"bitbucket.org/nemt/nemt-portal-api/server/router/routeutils"
+	"bitbucket.org/nemt/nemt-portal-api/server/validation"
 	"github.com/labstack/echo"
 	"golang.org/x/net/context"
 	"googlemaps.github.io/maps"
@@ -346,7 +346,7 @@ func (c *controller) handleMember(ctx echo.Context) error {
 	}
 
 	//Validate member
-	if validationErrors := validation.ValidateEligibility(&user) ; len(validationErrors) > 0 {
+	if validationErrors := validation.ValidateEligibility(&user); len(validationErrors) > 0 {
 		return routeutils.ResponseAPICustomValidationError(ctx, "eligibility validation failed", validationErrors)
 	}
 
@@ -409,44 +409,44 @@ func (c *controller) handleMember(ctx echo.Context) error {
 	eligibility.ServiceInfo.ServiceTypeCodes = []string{"30"}
 
 	/*
-	resp, err := c.bcbsi.BXE.Get271(eligibility)
+		resp, err := c.bcbsi.BXE.Get271(eligibility)
-	if err != nil {
+		if err != nil {
-		fmt.Println("Eligibility Not Found or Error: ", err.Error())
+			fmt.Println("Eligibility Not Found or Error: ", err.Error())
-		return routeutils.ResponseAPINotEligibleError(ctx)
+			return routeutils.ResponseAPINotEligibleError(ctx)
-	} 
+		}
 	*/
 
 	//This part is emulating eligibility check for testing purposes
 	client := &http.Client{}
 	eligibilityJson, err := json.Marshal(eligibility)
 	if err != nil {
-		return routeutils.HandleAPIError(ctx, err)
+		return routeutils.ResponseAPINotEligibleError(ctx)
 	}
 	req, _ := http.NewRequest("POST", c.cfg.Eligibility.Url, bytes.NewBuffer(eligibilityJson))
 	req.Header.Add("App", c.cfg.HTTP.Auth.AppKey)
 	req.Header.Add("Token", ctx.Request().Header.Get("Token"))
 	req.Header.Add("Content-Type", "application/json")
-	
+
 	resp, err := client.Do(req)
 	if err != nil {
-		return routeutils.HandleAPIError(ctx, err)
+		return routeutils.ResponseAPINotEligibleError(ctx)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode < 200 || resp.StatusCode > 300 {
-		return routeutils.ResponseAPINotEligibleWithMessageError(ctx, "Cannot check eligibility")
+		return routeutils.ResponseAPINotEligibleError(ctx)
 	}
 
 	eligibilityResponse := viewmodel.Interchange271{}
 	decoder := json.NewDecoder(resp.Body)
 	err = decoder.Decode(&eligibilityResponse)
 	if err != nil {
-		return routeutils.ResponseAPINotEligibleWithMessageError(ctx, "Cannot check eligibility")
+		return routeutils.ResponseAPINotEligibleError(ctx)
 	}
 	//================================================================
 
 	if len(eligibilityResponse.Division.HealthCareEligibilityResponse.LoopHL0030) < 1 {
-		return routeutils.ResponseAPINotEligibleWithMessageError(ctx, "Cannot check eligibility")	
+		return routeutils.ResponseAPINotEligibleError(ctx)
 	}
 
 	address := viewmodel.Address{}
@@ -467,17 +467,17 @@ func (c *controller) handleMember(ctx echo.Context) error {
 	if len(cleanZipcode) > zipcodeTrimLength {
 		trimmedZipcode = cleanZipcode[:zipcodeTrimLength]
 	}
-	
+
 	_, err = c.svc.Zipcodes.GetByParticipatingZipcode(trimmedZipcode)
 
-	if err != nil{
+	if err != nil {
-		return routeutils.ResponseAPINotEligibleWithMessageError(ctx, "Member's Home zipcode, " + trimmedZipcode + ", is not currently eligible for participation in this program")
+		return routeutils.ResponseAPINotEligibleWithMessageError(ctx, "Member's Home zipcode, "+trimmedZipcode+", is not currently eligible for participation in this program")
 	}
 
 	googleMapsAPI, err := maps.NewClient(maps.WithClientIDAndSignature("gme-bluecrossandblue1", "msqgD-jdqCyR0M_1u5C1HION5iI="))
 	if err != nil {
 		fmt.Println("Error to instantiate googles api: ", err.Error())
-		return routeutils.HandleAPIError(ctx,err)
+		return routeutils.HandleAPIError(ctx, err)
 	}
 
 	r := &maps.GeocodingRequest{
@@ -487,7 +487,7 @@ func (c *controller) handleMember(ctx echo.Context) error {
 	result, err := googleMapsAPI.Geocode(context.Background(), r)
 	if err != nil {
 		fmt.Println("Error to instantiate googles api: ", err.Error())
-		return routeutils.HandleAPIError(ctx,err)
+		return routeutils.HandleAPIError(ctx, err)
 	}
 
 	if len(result) > 0 {
@@ -497,7 +497,7 @@ func (c *controller) handleMember(ctx echo.Context) error {
 		_, err := c.svc.Users.SaveAddress(address)
 		if err != nil {
 			fmt.Println("Error to save address: ", err.Error())
-			return routeutils.HandleAPIError(ctx,err)
+			return routeutils.HandleAPIError(ctx, err)
 		}
 	}
 
@@ -597,7 +597,7 @@ func (c *controller) handlePortal(ctx echo.Context) error {
 	}
 	user.Pass = string(pass)
 
-	if passwordValidationErrors := validation.ValidatePassword(&user) ; len(passwordValidationErrors) > 0 {
+	if passwordValidationErrors := validation.ValidatePassword(&user); len(passwordValidationErrors) > 0 {
 		return routeutils.ResponseAPICustomValidationError(ctx, "Password not strong enough", passwordValidationErrors)
 	}
 

server/validation/tnc.go

@@ -1,34 +1,36 @@
 package validation
 
 import (
-	"fmt"
+
-	"regexp"
-	"strconv"
 	"time"
+	"fmt"
+	"strconv"
+	"regexp"
 
 	"bitbucket.org/nemt/nemt-portal-api/application/viewmodel"
 	"bitbucket.org/nemt/nemt-portal-api/infra/errors"
+
 )
 
 const (
-	tripTypeFromVisit         = "from_visit"
+	tripTypeFromVisit			= "from_visit"
-	tripTypeToVisit           = "to_visit"
+	tripTypeToVisit				= "to_visit"
-	tripTypeFromVisitWillCall = "from_visit_call"
+	tripTypeFromVisitWillCall	= "from_visit_call"
-	tripTypeRoundTrip         = "roundtrip"
+	tripTypeRoundTrip			= "roundtrip"
-	tripTypeRountTripWillCall = "roundtrip_call"
+	tripTypeRountTripWillCall	= "roundtrip_call"
 )
 
 const (
-	loadingTime       = 30 //in minutes
+	loadingTime					= 30 //in minutes
-	minimumLoadTime   = 30 //in minutes
+	minimumLoadTime				= 30 //in minutes
-	minimumPickupTime = 10 //in minutes
+	minimumPickupTime			= 10 //in minutes
 )
 
 const (
-	hoursInDay     = 24
+	hoursInDay					= 24
-	hoursIn180Days = 24 * 180
+	hoursIn180Days				= 24*180
-	time8Hours     = 8
+	time8Hours					= 8
-	time10Minutes  = 10
+	time10Minutes				= 10
 )
 
 func isMixedIDValid(id string) bool {
@@ -36,7 +38,7 @@ func isMixedIDValid(id string) bool {
 	hasLowerCase := false
 	hasNumber := false
 
-	for _, character := range id {
+	for _, character := range (id) {
 		hasUpperCase = hasUpperCase || ((character >= 65) && (character <= 90))
 		hasLowerCase = hasLowerCase || ((character >= 97) && (character <= 122))
 		hasNumber = hasNumber || ((character >= 48) && (character <= 57))
@@ -51,162 +53,163 @@ func ValidateRide(requestRide *viewmodel.RideRequest, user *viewmodel.User) []er
 
 	//Step #1 validation
 
-	if !validUUIDregex.MatchString(user.ID) {
+	if !validUUIDregex.MatchString(user.ID){
-		result = append(result, errors.ValidationError{Field: "user_uuid", Message: "Step #1 - Choose a Member"})
+		result = append(result, errors.ValidationError{Field : "user_uuid", Message : "Step #1 - Choose a Member" })
 	}
 
 	fmt.Println("\n\n", requestRide.Origin.ID, "\n\n")
 	if !isMixedIDValid(requestRide.Origin.ID) {
 		//it is not UUID or similar to UUID, let's try with just a number
-		if originID, err := strconv.Atoi(requestRide.Origin.ID); err != nil || originID <= 0 {
+		if originID, err := strconv.Atoi(requestRide.Origin.ID) ; err!= nil || originID <= 0 {
 			//it is not a number
-			result = append(result, errors.ValidationError{Field: "origin.id", Message: "Step #1 - Choose a Pickup Address"})
+			result = append (result, errors.ValidationError{Field : "origin.id", Message : "Step #1 - Choose a Pickup Address"})
-		}
+		}	
 	}
 
 	if !requestRide.UserConsent {
-		result = append(result, errors.ValidationError{Field: "user_consent", Message: "Step #1 - Member must consent to Terms of Use"})
+		result = append (result, errors.ValidationError{Field : "user_consent", Message : "Step #1 - Member must consent to Terms of Use"})
-	}
+	} 
 
 	//Step #2 validation
 
 	fmt.Println("\n\n", requestRide.Destination.ID, "\n\n")
 	if !isMixedIDValid(requestRide.Destination.ID) {
 		//it is not UUID or similar to UUID, let's try with just a number
-		if destinationID, err := strconv.Atoi(requestRide.Destination.ID); err != nil || destinationID <= 0 {
+		if destinationID, err := strconv.Atoi(requestRide.Destination.ID) ; err!= nil || destinationID <= 0 {
-			result = append(result, errors.ValidationError{Field: "destination.id", Message: "Step #2 - Choose a Provider"})
+			result = append (result, errors.ValidationError{Field : "destination.id", Message : "Step #2 - Choose a Provider"})
-		}
+		}	
 	}
 
 	//Step #3 validation
 
 	isVisitDayToday := requestRide.VisitDate.Day() == time.Now().Day() && requestRide.VisitDate.Month() == time.Now().Month() && requestRide.VisitDate.Year() == time.Now().Year()
-	before8Hours := time.Now().Add(-time.Hour * time8Hours)
+	before8Hours := time.Now().Add(-time.Hour*time8Hours)
 
 	if requestRide.VisitDate == nil {
-		result = append(result, errors.ValidationError{Field: "visit_date", Message: "Step #3 - Choose a Date for the Visit"})
+		result = append (result, errors.ValidationError{Field : "visit_date", Message : "Step #3 - Choose a Date for the Visit"})
-	} else {
+	}else{
-		dayBeforeToday := time.Now().Add(-time.Hour * hoursInDay)
+		dayBeforeToday := time.Now().Add(-time.Hour*hoursInDay)
 		if requestRide.VisitDate.Before(dayBeforeToday) {
-			result = append(result, errors.ValidationError{Field: "visit_date", Message: "Step #3 - Visit cannot occur more than one day before today"})
+			result = append (result, errors.ValidationError{Field : "visit_date", Message : "Step #3 - Visit cannot occur more than one day before today"})
 		}
 
-		dayAfter180Days := time.Now().Add(time.Hour * hoursIn180Days)
+		dayAfter180Days := time.Now().Add(time.Hour*hoursIn180Days)
 		if requestRide.VisitDate.After(dayAfter180Days) {
-			result = append(result, errors.ValidationError{Field: "visit_date", Message: "Step #3 - Visit cannot occur more than 180 days after today"})
+			result = append (result, errors.ValidationError{Field : "visit_date", Message : "Step #3 - Visit cannot occur more than 180 days after today"})
 		}
 
 		if requestRide.VisitTime == nil {
-			result = append(result, errors.ValidationError{Field: "visit_time", Message: "Step #3 - Choose a Time for the Visit"})
+			result = append (result, errors.ValidationError{Field : "visit_time", Message : "Step #3 - Choose a Time for the Visit"})
-		} else {
+		}else{
 			if isVisitDayToday && requestRide.VisitTime.Before(before8Hours) {
-				result = append(result, errors.ValidationError{Field: "visit_time", Message: "Step #3 - Visit is more than 8 hours in the past"})
+				result = append (result, errors.ValidationError{Field : "visit_time", Message : "Step #3 - Visit is more than 8 hours in the past"})
 			}
 		}
 	}
 
 	//Step #4 validation
 
-	timeWithDurationAndLoadingTime := requestRide.VisitTime.Add(-time.Duration(requestRide.Duration) * time.Second).Add(-loadingTime * time.Minute)
+	timeWithDurationAndLoadingTime := requestRide.VisitTime.Add(-time.Duration(requestRide.Duration)*time.Second).Add(-loadingTime*time.Minute)
-	after10Minutes := time.Now().Add(time.Minute * time10Minutes)
+	after10Minutes := time.Now().Add(time.Minute*time10Minutes)
 
 	isTripTypeValid := true
 
 	switch requestRide.TripType.Key {
-	case tripTypeToVisit:
+		case tripTypeToVisit:
-		if requestRide.PickupTime == nil {
+			if requestRide.PickupTime == nil {
-			result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Choose a Pickup Time"})
+				result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Choose a Pickup Time"})
-		} else {
+			}else{
-			if requestRide.PickupTime.After(*requestRide.VisitTime) {
+				if requestRide.PickupTime.After(*requestRide.VisitTime) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time must occur before Visit Time"})
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time must occur before Visit Time"})
-			}
-
-			if requestRide.PickupTime.After(timeWithDurationAndLoadingTime) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time less than required time before Visit Time"})
-			}
-
-			if isVisitDayToday && requestRide.PickupTime.Before(before8Hours) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Visit cannot occour in the past"})
-			}
-		}
-
-	case tripTypeFromVisit:
-		if requestRide.PickupTime == nil {
-			result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Choose a Pickup Time"})
-		} else {
-			timeWithMinimumPickupTime := time.Now().Add(minimumPickupTime * time.Minute)
-			if isVisitDayToday && requestRide.PickupTime.Before(timeWithMinimumPickupTime) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: fmt.Sprint("Step #4 - Time must be more than %d minutes from now", minimumPickupTime)})
-			}
-
-			if requestRide.PickupTime.Before(*requestRide.VisitTime) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time less than required time after Visit Time"})
-			}
-
-			timeWithMinimumLoadTime := time.Now().Add(minimumLoadTime * time.Minute)
-			if requestRide.PickupTime.Before(timeWithMinimumLoadTime) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time less than Minimum Load Time before Visit Time"})
-			}
-		}
-
-	case tripTypeFromVisitWillCall:
-		//no special validation for this case
-
-	case tripTypeRoundTrip:
-		if requestRide.PickupTime == nil {
-			result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Choose a Pickup Time"})
-		} else {
-			if requestRide.PickupTime.After(*requestRide.VisitTime) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time must occur before Visit Time"})
-			}
-
-			if requestRide.PickupTime.After(timeWithDurationAndLoadingTime) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time less than required time before Visit Time"})
-			}
-
-			if isVisitDayToday && requestRide.PickupTime.Before(after10Minutes) {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time must be at least 10 minutes from now"})
-			}
-		}
-
-		if requestRide.ReturnTime == nil {
-			result = append(result, errors.ValidationError{Field: "return_time", Message: "Step #4 - Choose a Pickup Time"})
-		} else {
-			if isVisitDayToday {
-				if requestRide.ReturnTime.Before(before8Hours) {
-					result = append(result, errors.ValidationError{Field: "return_time", Message: "Step #4 - Return Time is more than 8 hours after Visit Time"})
 				}
-
+	
-				if requestRide.ReturnTime.Before(after10Minutes) {
+				if requestRide.PickupTime.After(timeWithDurationAndLoadingTime) {
-					result = append(result, errors.ValidationError{Field: "return_time", Message: "Step #4 - Return Time must be at least 10 minutes from now"})
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time less than required time before Visit Time"})
+				}
+	
+				if isVisitDayToday && requestRide.PickupTime.Before(before8Hours) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Visit cannot occour in the past"})
 				}
 			}
-		}
 
-	case tripTypeRountTripWillCall:
+		case tripTypeFromVisit :
-		if requestRide.PickupTime == nil {
+			if requestRide.PickupTime == nil {
-			result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Choose a Pickup Time"})
+				result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Choose a Pickup Time"})
-		} else {
+			}else{
-			if requestRide.PickupTime.After(*requestRide.VisitTime) {
+				timeWithMinimumPickupTime := time.Now().Add(minimumPickupTime*time.Minute)
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time must occur before Visit Time"})
+				if isVisitDayToday && requestRide.PickupTime.Before(timeWithMinimumPickupTime) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : fmt.Sprint("Step #4 - Time must be more than %d minutes from now",minimumPickupTime)})
+				}
+
+				if requestRide.PickupTime.Before(*requestRide.VisitTime) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time less than required time after Visit Time"})
+				}
+
+				timeWithMinimumLoadTime := time.Now().Add(minimumLoadTime*time.Minute)
+				if requestRide.PickupTime.Before(timeWithMinimumLoadTime) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time less than Minimum Load Time before Visit Time"})
+				}
 			}
 
-			if requestRide.PickupTime.After(timeWithDurationAndLoadingTime) {
+		case tripTypeFromVisitWillCall:
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Pickup Time less than required time after Visit Time"})
+			//no special validation for this case
+
+		case tripTypeRoundTrip:
+			if requestRide.PickupTime == nil {
+				result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Choose a Pickup Time"})
+			}else{
+				if requestRide.PickupTime.After(*requestRide.VisitTime) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time must occur before Visit Time"})
+				}
+	
+				if requestRide.PickupTime.After(timeWithDurationAndLoadingTime) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time less than required time before Visit Time"})
+				}
+	
+				if isVisitDayToday && requestRide.PickupTime.Before(after10Minutes) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time must be at least 10 minutes from now"})
+				}
 			}
 
-			if isVisitDayToday && requestRide.PickupTime.Before(before8Hours) {
+			if requestRide.ReturnTime == nil {
-				result = append(result, errors.ValidationError{Field: "pickup_time", Message: "Step #4 - Visit cannot occur in the past "})
+				result = append (result, errors.ValidationError{Field : "return_time", Message : "Step #4 - Choose a Pickup Time"})
+			}else{
+				if isVisitDayToday {
+					if requestRide.ReturnTime.Before(before8Hours) {
+						result = append (result, errors.ValidationError{Field : "return_time", Message : "Step #4 - Return Time is more than 8 hours after Visit Time"})
+					}
+	
+					if requestRide.ReturnTime.Before(after10Minutes) {
+						result = append (result, errors.ValidationError{Field : "return_time", Message : "Step #4 - Return Time must be at least 10 minutes from now"})
+					}
+				}
 			}
-		}
 
-	default:
+		case tripTypeRountTripWillCall:
-		isTripTypeValid = false
+			if requestRide.PickupTime == nil {
+				result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Choose a Pickup Time"})
+			}else{
+				if requestRide.PickupTime.After(*requestRide.VisitTime) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time must occur before Visit Time"})
+				}
+	
+				if requestRide.PickupTime.After(timeWithDurationAndLoadingTime) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Pickup Time less than required time after Visit Time"})
+				}
+	
+				if isVisitDayToday && requestRide.PickupTime.Before(before8Hours) {
+					result = append (result, errors.ValidationError{Field : "pickup_time", Message : "Step #4 - Visit cannot occur in the past "})
+				}
+			}
+
+		default:
+			isTripTypeValid = false
 	}
 
 	if !isTripTypeValid {
-		result = append(result, errors.ValidationError{Field: "trip_type.key", Message: "Step #4 - Choose a Trip Type"})
+		result = append (result, errors.ValidationError{Field : "trip_type.key", Message : "Step #4 - Choose a Trip Type"})
 	}
 
+
 	return result
-}
+}