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

     1  //
     2  // Copyright (C) 2020-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/responses"
    20  	"dev.azure.com/aidainnovazione0090/DeviceManager/_git/go-mod-core-contracts/errors"
    21  )
    22  
    23  type readingClient struct {
    24  	baseUrl               string
    25  	authInjector          interfaces.AuthenticationInjector
    26  	enableNameFieldEscape bool
    27  }
    28  
    29  // NewReadingClient creates an instance of ReadingClient
    30  func NewReadingClient(baseUrl string, authInjector interfaces.AuthenticationInjector, enableNameFieldEscape bool) interfaces.ReadingClient {
    31  	return &readingClient{
    32  		baseUrl:               baseUrl,
    33  		authInjector:          authInjector,
    34  		enableNameFieldEscape: enableNameFieldEscape,
    35  	}
    36  }
    37  
    38  func (rc readingClient) AllReadings(ctx context.Context, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
    39  	requestParams := url.Values{}
    40  	requestParams.Set(common.Offset, strconv.Itoa(offset))
    41  	requestParams.Set(common.Limit, strconv.Itoa(limit))
    42  	res := responses.MultiReadingsResponse{}
    43  	err := utils.GetRequest(ctx, &res, rc.baseUrl, common.ApiAllReadingRoute, requestParams, rc.authInjector)
    44  	if err != nil {
    45  		return res, errors.NewCommonEdgeXWrapper(err)
    46  	}
    47  	return res, nil
    48  }
    49  
    50  func (rc readingClient) ReadingCount(ctx context.Context) (dtoCommon.CountResponse, errors.EdgeX) {
    51  	res := dtoCommon.CountResponse{}
    52  	err := utils.GetRequest(ctx, &res, rc.baseUrl, common.ApiReadingCountRoute, nil, rc.authInjector)
    53  	if err != nil {
    54  		return res, errors.NewCommonEdgeXWrapper(err)
    55  	}
    56  	return res, nil
    57  }
    58  
    59  func (rc readingClient) ReadingCountByDeviceName(ctx context.Context, name string) (dtoCommon.CountResponse, errors.EdgeX) {
    60  	requestPath := path.Join(common.ApiReadingCountRoute, common.Device, common.Name, name)
    61  	res := dtoCommon.CountResponse{}
    62  	err := utils.GetRequest(ctx, &res, rc.baseUrl, requestPath, nil, rc.authInjector)
    63  	if err != nil {
    64  		return res, errors.NewCommonEdgeXWrapper(err)
    65  	}
    66  	return res, nil
    67  }
    68  
    69  func (rc readingClient) ReadingsByDeviceName(ctx context.Context, name string, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
    70  	requestPath := path.Join(common.ApiReadingRoute, common.Device, common.Name, name)
    71  	requestParams := url.Values{}
    72  	requestParams.Set(common.Offset, strconv.Itoa(offset))
    73  	requestParams.Set(common.Limit, strconv.Itoa(limit))
    74  	res := responses.MultiReadingsResponse{}
    75  	err := utils.GetRequest(ctx, &res, rc.baseUrl, requestPath, requestParams, rc.authInjector)
    76  	if err != nil {
    77  		return res, errors.NewCommonEdgeXWrapper(err)
    78  	}
    79  	return res, nil
    80  }
    81  
    82  func (rc readingClient) ReadingsByResourceName(ctx context.Context, name string, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
    83  	requestPath := common.NewPathBuilder().EnableNameFieldEscape(rc.enableNameFieldEscape).
    84  		SetPath(common.ApiReadingRoute).SetPath(common.ResourceName).SetNameFieldPath(name).BuildPath()
    85  	requestParams := url.Values{}
    86  	requestParams.Set(common.Offset, strconv.Itoa(offset))
    87  	requestParams.Set(common.Limit, strconv.Itoa(limit))
    88  	res := responses.MultiReadingsResponse{}
    89  	err := utils.GetRequest(ctx, &res, rc.baseUrl, requestPath, requestParams, rc.authInjector)
    90  	if err != nil {
    91  		return res, errors.NewCommonEdgeXWrapper(err)
    92  	}
    93  	return res, nil
    94  }
    95  
    96  func (rc readingClient) ReadingsByTimeRange(ctx context.Context, start, end, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
    97  	requestPath := path.Join(common.ApiReadingRoute, common.Start, strconv.Itoa(start), common.End, strconv.Itoa(end))
    98  	requestParams := url.Values{}
    99  	requestParams.Set(common.Offset, strconv.Itoa(offset))
   100  	requestParams.Set(common.Limit, strconv.Itoa(limit))
   101  	res := responses.MultiReadingsResponse{}
   102  	err := utils.GetRequest(ctx, &res, rc.baseUrl, requestPath, requestParams, rc.authInjector)
   103  	if err != nil {
   104  		return res, errors.NewCommonEdgeXWrapper(err)
   105  	}
   106  	return res, nil
   107  }
   108  
   109  // ReadingsByResourceNameAndTimeRange returns readings by resource name and specified time range. Readings are sorted in descending order of origin time.
   110  func (rc readingClient) ReadingsByResourceNameAndTimeRange(ctx context.Context, name string, start, end, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
   111  	requestPath := common.NewPathBuilder().EnableNameFieldEscape(rc.enableNameFieldEscape).
   112  		SetPath(common.ApiReadingRoute).SetPath(common.ResourceName).SetNameFieldPath(name).SetPath(common.Start).SetPath(strconv.Itoa(start)).SetPath(common.End).SetPath(strconv.Itoa(end)).BuildPath()
   113  	requestParams := url.Values{}
   114  	requestParams.Set(common.Offset, strconv.Itoa(offset))
   115  	requestParams.Set(common.Limit, strconv.Itoa(limit))
   116  	res := responses.MultiReadingsResponse{}
   117  	err := utils.GetRequest(ctx, &res, rc.baseUrl, requestPath, requestParams, rc.authInjector)
   118  	if err != nil {
   119  		return res, errors.NewCommonEdgeXWrapper(err)
   120  	}
   121  	return res, nil
   122  }
   123  
   124  func (rc readingClient) ReadingsByDeviceNameAndResourceName(ctx context.Context, deviceName, resourceName string, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
   125  	requestPath := common.NewPathBuilder().EnableNameFieldEscape(rc.enableNameFieldEscape).
   126  		SetPath(common.ApiReadingRoute).SetPath(common.Device).SetPath(common.Name).SetNameFieldPath(deviceName).SetPath(common.ResourceName).SetNameFieldPath(resourceName).BuildPath()
   127  	requestParams := url.Values{}
   128  	requestParams.Set(common.Offset, strconv.Itoa(offset))
   129  	requestParams.Set(common.Limit, strconv.Itoa(limit))
   130  	res := responses.MultiReadingsResponse{}
   131  	err := utils.GetRequest(ctx, &res, rc.baseUrl, requestPath, requestParams, rc.authInjector)
   132  	if err != nil {
   133  		return res, errors.NewCommonEdgeXWrapper(err)
   134  	}
   135  	return res, nil
   136  
   137  }
   138  
   139  func (rc readingClient) ReadingsByDeviceNameAndResourceNameAndTimeRange(ctx context.Context, deviceName, resourceName string, start, end, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
   140  	requestPath := common.NewPathBuilder().EnableNameFieldEscape(rc.enableNameFieldEscape).
   141  		SetPath(common.ApiReadingRoute).SetPath(common.Device).SetPath(common.Name).SetNameFieldPath(deviceName).SetPath(common.ResourceName).SetNameFieldPath(resourceName).
   142  		SetPath(common.Start).SetPath(strconv.Itoa(start)).SetPath(common.End).SetPath(strconv.Itoa(end)).BuildPath()
   143  	requestParams := url.Values{}
   144  	requestParams.Set(common.Offset, strconv.Itoa(offset))
   145  	requestParams.Set(common.Limit, strconv.Itoa(limit))
   146  	res := responses.MultiReadingsResponse{}
   147  	err := utils.GetRequest(ctx, &res, rc.baseUrl, requestPath, requestParams, rc.authInjector)
   148  	if err != nil {
   149  		return res, errors.NewCommonEdgeXWrapper(err)
   150  	}
   151  	return res, nil
   152  }
   153  
   154  func (rc readingClient) ReadingsByDeviceNameAndResourceNamesAndTimeRange(ctx context.Context, deviceName string, resourceNames []string, start, end, offset, limit int) (responses.MultiReadingsResponse, errors.EdgeX) {
   155  	requestPath := common.NewPathBuilder().EnableNameFieldEscape(rc.enableNameFieldEscape).
   156  		SetPath(common.ApiReadingRoute).SetPath(common.Device).SetPath(common.Name).SetNameFieldPath(deviceName).
   157  		SetPath(common.Start).SetPath(strconv.Itoa(start)).SetPath(common.End).SetPath(strconv.Itoa(end)).BuildPath()
   158  	requestParams := url.Values{}
   159  	requestParams.Set(common.Offset, strconv.Itoa(offset))
   160  	requestParams.Set(common.Limit, strconv.Itoa(limit))
   161  	var queryPayload map[string]interface{}
   162  	if len(resourceNames) > 0 { // gosimple S1009: len(nil slice) == 0
   163  		queryPayload = make(map[string]interface{}, 1)
   164  		queryPayload[common.ResourceNames] = resourceNames
   165  	}
   166  	res := responses.MultiReadingsResponse{}
   167  	err := utils.GetRequestWithBodyRawData(ctx, &res, rc.baseUrl, requestPath, requestParams, queryPayload, rc.authInjector)
   168  	if err != nil {
   169  		return res, errors.NewCommonEdgeXWrapper(err)
   170  	}
   171  	return res, nil
   172  }