Added typeupdate and typeaccess

[nonrtric/plt/sme.git] / capifcore / internal / publishservice / publishservice.go

diff --git a/capifcore/internal/publishservice/publishservice.go b/capifcore/internal/publishservice/publishservice.go
index 3898a80..bf79899 100644 (file)
--- a/capifcore/internal/publishservice/publishservice.go
+++ b/capifcore/internal/publishservice/publishservice.go
@@ -42,9 +42,6 @@ import (
 
 //go:generate mockery --name PublishRegister
 type PublishRegister interface {
-       // Checks if the provided APIs are published.
-       // Returns true if all provided APIs have been published, false otherwise.
-       AreAPIsPublished(serviceDescriptions *[]publishapi.ServiceAPIDescription) bool
        // Checks if the provided API is published.
        // Returns true if the provided API has been published, false otherwise.
        IsAPIPublished(aefId, path string) bool
@@ -71,15 +68,6 @@ func NewPublishService(serviceRegister providermanagement.ServiceRegister, hm he
        }
 }
 
-func (ps *PublishService) AreAPIsPublished(serviceDescriptions *[]publishapi.ServiceAPIDescription) bool {
-
-       if serviceDescriptions != nil {
-               registeredApis := ps.getAllAefIds()
-               return checkNewDescriptions(*serviceDescriptions, registeredApis)
-       }
-       return true
-}
-
 func (ps *PublishService) getAllAefIds() []string {
        ps.lock.Lock()
        defer ps.lock.Unlock()
@@ -87,46 +75,12 @@ func (ps *PublishService) getAllAefIds() []string {
        allIds := []string{}
        for _, descriptions := range ps.publishedServices {
                for _, description := range descriptions {
-                       allIds = append(allIds, getIdsFromDescription(description)...)
-               }
-       }
-       return allIds
-}
-
-func getIdsFromDescription(description publishapi.ServiceAPIDescription) []string {
-       allIds := []string{}
-       if description.AefProfiles != nil {
-               for _, aefProfile := range *description.AefProfiles {
-                       allIds = append(allIds, aefProfile.AefId)
+                       allIds = append(allIds, description.GetAefIds()...)
                }
        }
        return allIds
 }
 
-func checkNewDescriptions(newDescriptions []publishapi.ServiceAPIDescription, registeredAefIds []string) bool {
-       registered := true
-       for _, newApi := range newDescriptions {
-               if !checkProfiles(newApi.AefProfiles, registeredAefIds) {
-                       registered = false
-                       break
-               }
-       }
-       return registered
-}
-
-func checkProfiles(newProfiles *[]publishapi.AefProfile, registeredAefIds []string) bool {
-       allRegistered := true
-       if newProfiles != nil {
-               for _, profile := range *newProfiles {
-                       if !slices.Contains(registeredAefIds, profile.AefId) {
-                               allRegistered = false
-                               break
-                       }
-               }
-       }
-       return allRegistered
-}
-
 func (ps *PublishService) IsAPIPublished(aefId, path string) bool {
        return slices.Contains(ps.getAllAefIds(), aefId)
 }
@@ -158,23 +112,30 @@ func (ps *PublishService) GetApfIdServiceApis(ctx echo.Context, apfId string) er
 // Publish a new API.
 func (ps *PublishService) PostApfIdServiceApis(ctx echo.Context, apfId string) error {
        var newServiceAPIDescription publishapi.ServiceAPIDescription
+       errorMsg := "Unable to publish the service due to %s "
        err := ctx.Bind(&newServiceAPIDescription)
        if err != nil {
-               return sendCoreError(ctx, http.StatusBadRequest, "Invalid format for service "+apfId)
+               return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errorMsg, "invalid format for service "+apfId))
+       }
+
+       if ps.isServicePublished(newServiceAPIDescription) {
+               return sendCoreError(ctx, http.StatusForbidden, fmt.Sprintf(errorMsg, "service already published"))
        }
 
+       if err := newServiceAPIDescription.Validate(); err != nil {
+               return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errorMsg, err))
+       }
        ps.lock.Lock()
        defer ps.lock.Unlock()
 
        registeredFuncs := ps.serviceRegister.GetAefsForPublisher(apfId)
        for _, profile := range *newServiceAPIDescription.AefProfiles {
                if !slices.Contains(registeredFuncs, profile.AefId) {
-                       return sendCoreError(ctx, http.StatusNotFound, fmt.Sprintf("Function %s not registered", profile.AefId))
+                       return sendCoreError(ctx, http.StatusNotFound, fmt.Sprintf(errorMsg, fmt.Sprintf("function %s not registered", profile.AefId)))
                }
        }
 
-       newId := "api_id_" + newServiceAPIDescription.ApiName
-       newServiceAPIDescription.ApiId = &newId
+       newServiceAPIDescription.PrepareNewService()
 
        shouldReturn, returnValue := ps.installHelmChart(newServiceAPIDescription, ctx)
        if shouldReturn {
@@ -200,6 +161,17 @@ func (ps *PublishService) PostApfIdServiceApis(ctx echo.Context, apfId string) e
        return nil
 }
 
+func (ps *PublishService) isServicePublished(newService publishapi.ServiceAPIDescription) bool {
+       for _, services := range ps.publishedServices {
+               for _, service := range services {
+                       if service.IsPublished(newService) {
+                               return true
+                       }
+               }
+       }
+       return false
+}
+
 func (ps *PublishService) installHelmChart(newServiceAPIDescription publishapi.ServiceAPIDescription, ctx echo.Context) (bool, error) {
        info := strings.Split(*newServiceAPIDescription.Description, ",")
        if len(info) == 5 {
@@ -288,11 +260,11 @@ func (ps *PublishService) PutApfIdServiceApisServiceApiId(ctx echo.Context, apfI
        if err != nil {
                return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
        }
-       ps.updateDescription(pos, apfId, &updatedServiceDescription, &publishedService)
        err = ps.checkProfilesRegistered(apfId, *updatedServiceDescription.AefProfiles)
        if err != nil {
                return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
        }
+       ps.updateDescription(pos, apfId, &updatedServiceDescription, &publishedService)
        publishedService.AefProfiles = updatedServiceDescription.AefProfiles
        ps.publishedServices[apfId][pos] = publishedService
        err = ctx.JSON(http.StatusOK, publishedService)
@@ -344,7 +316,6 @@ func (ps *PublishService) sendEvent(service publishapi.ServiceAPIDescription, ev
 }
 
 func (ps *PublishService) checkProfilesRegistered(apfId string, updatedProfiles []publishapi.AefProfile) error {
-
        registeredFuncs := ps.serviceRegister.GetAefsForPublisher(apfId)
        for _, profile := range updatedProfiles {
                if !slices.Contains(registeredFuncs, profile.AefId) {
@@ -352,7 +323,6 @@ func (ps *PublishService) checkProfilesRegistered(apfId string, updatedProfiles
                }
        }
        return nil
-
 }
 
 // This function wraps sending of an error in the Error format, and