github.com/diadata-org/diadata@v1.4.593/pkg/http/restServer/kafkaApi/kafkaApi.go (about)

     1  package kafkaApi
     2  
     3  import (
     4  	"net/http"
     5  	"strconv"
     6  
     7  	"github.com/diadata-org/diadata/pkg/dia/helpers/kafkaHelper"
     8  	"github.com/gin-gonic/gin"
     9  	log "github.com/sirupsen/logrus"
    10  )
    11  
    12  var (
    13  	Apis = map[int]*RestApi{
    14  		kafkaHelper.TopicFiltersBlock: NewRestApi(kafkaHelper.TopicFiltersBlock),
    15  		kafkaHelper.TopicTrades:       NewRestApi(kafkaHelper.TopicTrades),
    16  		kafkaHelper.TopicTradesBlock:  NewRestApi(kafkaHelper.TopicTradesBlock),
    17  	}
    18  )
    19  
    20  // @hello
    21  // returns some kafka messages
    22  type resultApi struct {
    23  	Offset   int64         `json:"offset"`
    24  	Messages []interface{} `json:"messages"`
    25  }
    26  
    27  type RestApi struct {
    28  	topic int
    29  	// writer *kafka.Writer //TOFIX reorganise the api
    30  }
    31  
    32  func SendError(c *gin.Context, errorCode int, err error) {
    33  	c.JSON(errorCode,
    34  		&APIError{
    35  			ErrorCode:    errorCode,
    36  			ErrorMessage: err.Error(),
    37  		})
    38  }
    39  
    40  func getOffset(c *gin.Context) int64 {
    41  	offsetQuery := c.Query("offset")
    42  	if offsetQuery == "" {
    43  		offsetQuery = "-1" // will go to the latest element if no offset is specified
    44  	}
    45  	log.Printf("offsetQuery %v", offsetQuery)
    46  	offset, _ := strconv.Atoi(offsetQuery)
    47  	return int64(offset)
    48  }
    49  
    50  func Process(c *gin.Context, topic int) {
    51  	elements, _ := strconv.Atoi(c.Query("elements"))
    52  	result, err := Apis[topic].Get(getOffset(c), elements)
    53  	if err == nil {
    54  		c.JSON(http.StatusOK, result)
    55  	} else {
    56  		SendError(c, http.StatusInternalServerError, err)
    57  	}
    58  }
    59  
    60  //
    61  // @Summary Add a new pet to the store
    62  // @Description get string by ID
    63  // @Accept  json
    64  // @Produce  json
    65  // @Param   some_id     path    int     true        "Some ID"
    66  // @Success 200 {string} string	"ok"
    67  // @Failure 400 {object} restApi.APIError "We need ID!!"
    68  // @Failure 404 {object} restApi.APIError "Can not find ID"
    69  // @Router /testapi/get-string-by-int/{some_id} [get]
    70  
    71  func (s *RestApi) Get(offset int64, elements int) (map[string]interface{}, error) {
    72  
    73  	if (elements == 0) || (elements > 100) {
    74  		elements = 100
    75  	}
    76  
    77  	result := &resultApi{}
    78  
    79  	maxOffset, err := kafkaHelper.ReadOffset(s.topic)
    80  
    81  	if err != nil {
    82  		return nil, err
    83  	}
    84  
    85  	maxOffset--
    86  
    87  	if offset > maxOffset {
    88  		offset = maxOffset
    89  	}
    90  	if offset < 0 {
    91  		offset = maxOffset
    92  	}
    93  	result.Offset = offset
    94  
    95  	nbElements := int(maxOffset - offset + 1)
    96  	if nbElements > elements {
    97  		nbElements = elements
    98  	}
    99  	log.Printf("Get: maxOffset %v offset:%v nbElements:%v ", maxOffset, offset, nbElements)
   100  
   101  	element, err := kafkaHelper.GetElements(s.topic, offset, nbElements)
   102  
   103  	if err != nil {
   104  		return nil, err
   105  	}
   106  	result.Messages = append(result.Messages, element)
   107  
   108  	r := map[string]interface{}{
   109  		"Result": result,
   110  	}
   111  
   112  	return r, nil
   113  
   114  }
   115  
   116  func NewRestApi(topic int) *RestApi {
   117  	s := &RestApi{
   118  		topic: topic,
   119  	}
   120  	return s
   121  }