dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts@v1.0.2/clients/http/event.go (about)

     1  //
     2  // Copyright (C) 2021-2023 IOTech Ltd
     3  // Copyright (C) 2023 Intel Corporation
     4  //
     5  // SPDX-License-Identifier: Apache-2.0
     6  
     7  package http
     8  
     9  import (
    10  	"context"
    11  	"net/url"
    12  	"path"
    13  	"strconv"
    14  
    15  	"dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/clients/http/utils"
    16  	"dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/clients/interfaces"
    17  	"dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/common"
    18  	dtoCommon "dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/dtos/common"
    19  	"dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/dtos/requests"
    20  	"dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/dtos/responses"
    21  	"dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/errors"
    22  )
    23  
    24  type eventClient struct {
    25  	baseUrl               string
    26  	authInjector          interfaces.AuthenticationInjector
    27  	enableNameFieldEscape bool
    28  }
    29  
    30  // NewEventClient creates an instance of EventClient
    31  func NewEventClient(baseUrl string, authInjector interfaces.AuthenticationInjector, enableNameFieldEscape bool) interfaces.EventClient {
    32  	return &eventClient{
    33  		baseUrl:               baseUrl,
    34  		authInjector:          authInjector,
    35  		enableNameFieldEscape: enableNameFieldEscape,
    36  	}
    37  }
    38  
    39  func (ec *eventClient) Add(ctx context.Context, serviceName string, req requests.AddEventRequest) (
    40  	dtoCommon.BaseWithIdResponse, errors.EdgeX) {
    41  	path := common.NewPathBuilder().EnableNameFieldEscape(ec.enableNameFieldEscape).
    42  		SetPath(common.ApiEventRoute).SetNameFieldPath(serviceName).SetNameFieldPath(req.Event.ProfileName).SetNameFieldPath(req.Event.DeviceName).SetNameFieldPath(req.Event.SourceName).BuildPath()
    43  	var br dtoCommon.BaseWithIdResponse
    44  
    45  	bytes, encoding, err := req.Encode()
    46  	if err != nil {
    47  		return br, errors.NewCommonEdgeXWrapper(err)
    48  	}
    49  
    50  	err = utils.PostRequest(ctx, &br, ec.baseUrl, path, bytes, encoding, ec.authInjector)
    51  	if err != nil {
    52  		return br, errors.NewCommonEdgeXWrapper(err)
    53  	}
    54  	return br, nil
    55  }
    56  
    57  func (ec *eventClient) AllEvents(ctx context.Context, offset, limit int) (responses.MultiEventsResponse, errors.EdgeX) {
    58  	requestParams := url.Values{}
    59  	requestParams.Set(common.Offset, strconv.Itoa(offset))
    60  	requestParams.Set(common.Limit, strconv.Itoa(limit))
    61  	res := responses.MultiEventsResponse{}
    62  	err := utils.GetRequest(ctx, &res, ec.baseUrl, common.ApiAllEventRoute, requestParams, ec.authInjector)
    63  	if err != nil {
    64  		return res, errors.NewCommonEdgeXWrapper(err)
    65  	}
    66  	return res, nil
    67  }
    68  
    69  func (ec *eventClient) EventCount(ctx context.Context) (dtoCommon.CountResponse, errors.EdgeX) {
    70  	res := dtoCommon.CountResponse{}
    71  	err := utils.GetRequest(ctx, &res, ec.baseUrl, common.ApiEventCountRoute, nil, ec.authInjector)
    72  	if err != nil {
    73  		return res, errors.NewCommonEdgeXWrapper(err)
    74  	}
    75  	return res, nil
    76  }
    77  
    78  func (ec *eventClient) EventCountByDeviceName(ctx context.Context, name string) (dtoCommon.CountResponse, errors.EdgeX) {
    79  	requestPath := path.Join(common.ApiEventCountRoute, common.Device, common.Name, name)
    80  	res := dtoCommon.CountResponse{}
    81  	err := utils.GetRequest(ctx, &res, ec.baseUrl, requestPath, nil, ec.authInjector)
    82  	if err != nil {
    83  		return res, errors.NewCommonEdgeXWrapper(err)
    84  	}
    85  	return res, nil
    86  }
    87  
    88  func (ec *eventClient) EventsByDeviceName(ctx context.Context, name string, offset, limit int) (
    89  	responses.MultiEventsResponse, errors.EdgeX) {
    90  	requestPath := path.Join(common.ApiEventRoute, common.Device, common.Name, name)
    91  	requestParams := url.Values{}
    92  	requestParams.Set(common.Offset, strconv.Itoa(offset))
    93  	requestParams.Set(common.Limit, strconv.Itoa(limit))
    94  	res := responses.MultiEventsResponse{}
    95  	err := utils.GetRequest(ctx, &res, ec.baseUrl, requestPath, requestParams, ec.authInjector)
    96  	if err != nil {
    97  		return res, errors.NewCommonEdgeXWrapper(err)
    98  	}
    99  	return res, nil
   100  }
   101  
   102  func (ec *eventClient) DeleteByDeviceName(ctx context.Context, name string) (dtoCommon.BaseResponse, errors.EdgeX) {
   103  	path := path.Join(common.ApiEventRoute, common.Device, common.Name, name)
   104  	res := dtoCommon.BaseResponse{}
   105  	err := utils.DeleteRequest(ctx, &res, ec.baseUrl, path, ec.authInjector)
   106  	if err != nil {
   107  		return res, errors.NewCommonEdgeXWrapper(err)
   108  	}
   109  	return res, nil
   110  }
   111  
   112  func (ec *eventClient) EventsByTimeRange(ctx context.Context, start, end, offset, limit int) (
   113  	responses.MultiEventsResponse, errors.EdgeX) {
   114  	requestPath := path.Join(common.ApiEventRoute, common.Start, strconv.Itoa(start), common.End, strconv.Itoa(end))
   115  	requestParams := url.Values{}
   116  	requestParams.Set(common.Offset, strconv.Itoa(offset))
   117  	requestParams.Set(common.Limit, strconv.Itoa(limit))
   118  	res := responses.MultiEventsResponse{}
   119  	err := utils.GetRequest(ctx, &res, ec.baseUrl, requestPath, requestParams, ec.authInjector)
   120  	if err != nil {
   121  		return res, errors.NewCommonEdgeXWrapper(err)
   122  	}
   123  	return res, nil
   124  }
   125  
   126  func (ec *eventClient) DeleteByAge(ctx context.Context, age int) (dtoCommon.BaseResponse, errors.EdgeX) {
   127  	path := path.Join(common.ApiEventRoute, common.Age, strconv.Itoa(age))
   128  	res := dtoCommon.BaseResponse{}
   129  	err := utils.DeleteRequest(ctx, &res, ec.baseUrl, path, ec.authInjector)
   130  	if err != nil {
   131  		return res, errors.NewCommonEdgeXWrapper(err)
   132  	}
   133  	return res, nil
   134  }
   135  
   136  func (ec *eventClient) UpdateDeviceSilence(ctx context.Context, req requests.DeviceStatusRequest) (responses.DeviceStatusResponse, errors.EdgeX) {
   137  	path := path.Join(common.ApiDeviceStatusRoute, common.Name, req.Status.DeviceName)
   138  	var br responses.DeviceStatusResponse
   139  
   140  	err := utils.PatchRequest(ctx, &br, ec.baseUrl, path, nil, req, ec.authInjector)
   141  	if err != nil {
   142  		return br, errors.NewCommonEdgeXWrapper(err)
   143  	}
   144  	return br, nil
   145  }