Update more functionality to publish service

Issue-ID: NONRTRIC-814
Signed-off-by: elinuxhenrik <henrik.b.andersson@est.tech>
Change-Id: Ie04f9f5466da701a63f8644b9324db68891ec3b9

diff --git a/capifcore/internal/publishservice/publishservice.go b/capifcore/internal/publishservice/publishservice.go
index 17f4b28..d85f077 100644 (file)
--- a/capifcore/internal/publishservice/publishservice.go
+++ b/capifcore/internal/publishservice/publishservice.go
@@ -296,6 +296,11 @@ func (ps *PublishService) PutApfIdServiceApisServiceApiId(ctx echo.Context, apfI
                go ps.sendEvent(publishedService, eventsapi.CAPIFEventSERVICEAPIUPDATE)
        }
 
+       pos, shouldReturn, returnValue = ps.updateProfiles(pos, apfId, updatedServiceDescription, publishedService, ctx)
+       if shouldReturn {
+               return returnValue
+       }
+
        err := ctx.JSON(http.StatusOK, ps.publishedServices[apfId][pos])
        if err != nil {
                // Something really bad happened, tell Echo that our handler failed
@@ -330,6 +335,28 @@ func getServiceFromRequest(ctx echo.Context) (publishapi.ServiceAPIDescription,
        return updatedServiceDescription, false, nil
 }
 
+func (ps *PublishService) updateProfiles(pos int, apfId string, updatedServiceDescription publishapi.ServiceAPIDescription, publishedService publishapi.ServiceAPIDescription, ctx echo.Context) (int, bool, error) {
+       registeredFuncs := ps.serviceRegister.GetAefsForPublisher(apfId)
+       for _, profile := range *updatedServiceDescription.AefProfiles {
+               if !slices.Contains(registeredFuncs, profile.AefId) {
+                       return 0, false, sendCoreError(ctx, http.StatusNotFound, fmt.Sprintf("Function %s not registered", profile.AefId))
+               }
+               if ps.checkIfProfileIsNew(profile.AefId, *publishedService.AefProfiles) {
+
+                       publishedService.AefProfiles = ps.addProfile(profile, publishedService)
+                       ps.publishedServices[apfId][pos] = publishedService
+
+               } else {
+                       pos, shouldReturn, returnValue := ps.updateProfile(profile, publishedService, ctx)
+                       if shouldReturn {
+                               return pos, true, returnValue
+                       }
+               }
+
+       }
+       return 0, false, nil
+}
+
 func (ps *PublishService) sendEvent(service publishapi.ServiceAPIDescription, eventType eventsapi.CAPIFEvent) {
        apiIds := []string{*service.ApiId}
        apis := []publishapi.ServiceAPIDescription{service}
@@ -343,6 +370,43 @@ func (ps *PublishService) sendEvent(service publishapi.ServiceAPIDescription, ev
        ps.eventChannel <- event
 }
 
+func (ps *PublishService) checkIfProfileIsNew(aefId string, publishedPofiles []publishapi.AefProfile) bool {
+       for _, profile := range publishedPofiles {
+               if profile.AefId == aefId {
+                       return false
+               }
+       }
+       return true
+}
+func (ps *PublishService) addProfile(profile publishapi.AefProfile, publishedService publishapi.ServiceAPIDescription) *[]publishapi.AefProfile {
+       registeredProfiles := *publishedService.AefProfiles
+       newProfiles := append(registeredProfiles, profile)
+       publishedService.AefProfiles = &newProfiles
+       return &newProfiles
+
+}
+
+func (*PublishService) updateProfile(profile publishapi.AefProfile, publishedService publishapi.ServiceAPIDescription, ctx echo.Context) (int, bool, error) {
+       pos, registeredProfile, err := getProfile(profile.AefId, publishedService.AefProfiles)
+       if err != nil {
+               return pos, true, sendCoreError(ctx, http.StatusBadRequest, "Unable to update service due to: "+err.Error())
+       }
+       if profile.DomainName != nil {
+               registeredProfile.DomainName = profile.DomainName
+               (*publishedService.AefProfiles)[pos] = registeredProfile
+       }
+       return -1, false, nil
+}
+
+func getProfile(profileId string, apiProfiles *[]publishapi.AefProfile) (int, publishapi.AefProfile, error) {
+       for pos, profile := range *apiProfiles {
+               if profile.AefId == profileId {
+                       return pos, profile, nil
+               }
+       }
+       return 0, publishapi.AefProfile{}, fmt.Errorf("profile with ID %s is not registered for the service", profileId)
+}
+
 // This function wraps sending of an error in the Error format, and
 // handling the failure to marshal that.
 func sendCoreError(ctx echo.Context, code int, message string) error {

diff --git a/capifcore/internal/publishservice/publishservice_test.go b/capifcore/internal/publishservice/publishservice_test.go
index cad151c..2483053 100644 (file)
--- a/capifcore/internal/publishservice/publishservice_test.go
+++ b/capifcore/internal/publishservice/publishservice_test.go
@@ -200,28 +200,64 @@ func TestUpdateDescription(t *testing.T) {
        aefId := "aefId"
        apiName := "apiName"
        description := "description"
+
        serviceRegisterMock := serviceMocks.ServiceRegister{}
-       serviceRegisterMock.On("GetAefsForPublisher", apfId).Return([]string{aefId, "otherAefId"})
+       serviceRegisterMock.On("GetAefsForPublisher", apfId).Return([]string{aefId, "otherAefId", "aefIdNew"})
        helmManagerMock := helmMocks.HelmManager{}
        helmManagerMock.On("InstallHelmChart", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil)
        serviceUnderTest, eventChannel, requestHandler := getEcho(&serviceRegisterMock, &helmManagerMock)
-
        serviceDescription := getServiceAPIDescription(aefId, apiName, description)
        serviceDescription.ApiId = &serviceApiId
        serviceUnderTest.publishedServices[apfId] = []publishapi.ServiceAPIDescription{serviceDescription}
+       (*serviceDescription.AefProfiles)[0].AefId = aefId
 
        //Modify the service
        updatedServiceDescription := getServiceAPIDescription(aefId, apiName, description)
-       updatedServiceDescription.ApiId = &description
+       updatedServiceDescription.ApiId = &serviceApiId
+       (*updatedServiceDescription.AefProfiles)[0].AefId = aefId
        newDescription := "new description"
        updatedServiceDescription.Description = &newDescription
+       newDomainName := "new domainName"
+       (*updatedServiceDescription.AefProfiles)[0].DomainName = &newDomainName
+
+       newProfileDomain := "new profile Domain name"
+       var protocol publishapi.Protocol = "HTTP_1_1"
+       test := make([]publishapi.AefProfile, 1)
+       test = *updatedServiceDescription.AefProfiles
+       test = append(test, publishapi.AefProfile{
+
+               AefId:      "aefIdNew",
+               DomainName: &newProfileDomain,
+               Protocol:   &protocol,
+               Versions: []publishapi.Version{
+                       {
+                               ApiVersion: "v1",
+                               Resources: &[]publishapi.Resource{
+                                       {
+                                               CommType: "REQUEST_RESPONSE",
+                                               Operations: &[]publishapi.Operation{
+                                                       "POST",
+                                               },
+                                               ResourceName: "app",
+                                               Uri:          "app",
+                                       },
+                               },
+                       },
+               },
+       },
+       )
+
+       updatedServiceDescription.AefProfiles = &test
+
        result := testutil.NewRequest().Put("/"+apfId+"/service-apis/"+serviceApiId).WithJsonBody(updatedServiceDescription).Go(t, requestHandler)
 
        var resultService publishapi.ServiceAPIDescription
        assert.Equal(t, http.StatusOK, result.Code())
        err := result.UnmarshalBodyToObject(&resultService)
        assert.NoError(t, err, "error unmarshaling response")
-       assert.Equal(t, resultService.Description, &newDescription)
+       assert.Equal(t, newDescription, *resultService.Description)
+       assert.Equal(t, newDomainName, *(*resultService.AefProfiles)[0].DomainName)
+       assert.Equal(t, "aefIdNew", (*resultService.AefProfiles)[1].AefId)
 
        if publishEvent, ok := waitForEvent(eventChannel, 1*time.Second); ok {
                assert.Fail(t, "No event sent")