blob: 155a24d7c19135faba48c4b2241ffba951198475 [file] [log] [blame]
package quotaBucket
import (
"errors"
"fmt"
"reflect"
)
func (qBucket *QuotaBucket) FromAPIRequest(quotaBucketMap map[string]interface{}) error {
var edgeOrgID, id, timeUnit, quotaType, bucketType string
var interval, maxCount int
var startTime int64
var preciseAtSecondsLevel bool
fmt.Println("quotaBucketMap: ", quotaBucketMap)
value, ok := quotaBucketMap["edgeOrgID"]
if !ok {
return errors.New(`missing field: 'edgeOrgID' is required`)
}
if edgeOrgIDType := reflect.TypeOf(value); edgeOrgIDType.Kind() != reflect.String {
return errors.New(`invalid type : 'edgeOrgID' should be a string`)
}
edgeOrgID = value.(string)
//fmt.Println("edgeOrgID: ", edgeOrgID)
value, ok = quotaBucketMap["id"]
if !ok {
return errors.New(`missing field: 'id' is required`)
}
if idType := reflect.TypeOf(value); idType.Kind() != reflect.String {
return errors.New(`invalid type : 'id' should be a string`)
}
id = value.(string)
//fmt.Println("id: ", id)
value, ok = quotaBucketMap["interval"]
if !ok {
return errors.New(`missing field: 'interval' is required`)
}
//from input when its read its float, need to then convert to int.
if intervalType := reflect.TypeOf(value); intervalType.Kind() != reflect.Float64 {
return errors.New(`invalid type : 'interval' should be a number`)
}
intervalFloat := value.(float64)
interval = int(intervalFloat)
//fmt.Println("interval: ", interval)
//TimeUnit {SECOND, MINUTE, HOUR, DAY, WEEK, MONTH}
value, ok = quotaBucketMap["timeUnit"]
if !ok {
return errors.New(`missing field: 'timeUnit' is required`)
}
if timeUnitType := reflect.TypeOf(value); timeUnitType.Kind() != reflect.String {
return errors.New(`invalid type : 'timeUnit' should be a string`)
}
timeUnit = value.(string)
//fmt.Println("timeUnit: ", timeUnit)
//Type {CALENDAR, FLEXI, ROLLING_WINDOW}
value, ok = quotaBucketMap["quotaType"]
if !ok {
return errors.New(`missing field: 'quotaType' is required`)
}
if quotaTypeType := reflect.TypeOf(value); quotaTypeType.Kind() != reflect.String {
return errors.New(`invalid type : 'quotaType' should be a string`)
}
quotaType = value.(string)
//fmt.Println("quotaType: ", quotaType)
value, ok = quotaBucketMap["preciseAtSecondsLevel"]
if !ok {
return errors.New(`missing field: 'preciseAtSecondsLevel' is required`)
}
if preciseAtSecondsLevelType := reflect.TypeOf(value); preciseAtSecondsLevelType.Kind() != reflect.Bool {
return errors.New(`invalid type : 'preciseAtSecondsLevel' should be boolean`)
}
preciseAtSecondsLevel = value.(bool)
//fmt.Println("preciseAtSecondsLevel: ", preciseAtSecondsLevel)
value, ok = quotaBucketMap["startTime"]
if !ok {
return errors.New(`missing field: 'startTime' is required`)
}
//from input when its read its float, need to then convert to int.
if startTimeType := reflect.TypeOf(value); startTimeType.Kind() != reflect.Float64 {
return errors.New(`invalid type : 'startTime' should be UNIX timestamp`)
}
startTimeFloat := value.(float64)
startTime = int64(startTimeFloat)
//fmt.Println("startTime: ", startTime)
quotaPeriod := QuotaPeriod{}
value, ok = quotaBucketMap["period"]
//if period is not sent in the request, it is calculated based in the startTime, quotaType and interval.
if ok {
var inStartInt, startInt, endInt int64
isPeriodMap := reflect.TypeOf(value)
if isPeriodMap.Kind() != reflect.Map {
return errors.New(`invalid type : 'period' should be a Map`)
}
periodMap := value.(map[string]interface{})
inStartTimeValue, ok := periodMap["inputStartTime"]
if !ok {
//set period.inputStart time from qBucket.startTime
inStartInt = startTime
} else {
if inStartType := reflect.TypeOf(inStartTimeValue); inStartType.Kind() != reflect.Float64 {
return errors.New(`invalid type : 'inputStartTime' in 'period' should be UNIX timestamp`)
}
inStartFloat := inStartTimeValue.(float64)
inStartInt = int64(inStartFloat)
if startTime != inStartInt {
return errors.New(`invalid value : 'inputStartTime' in 'period' should be same as 'startTime'' in request`)
}
}
startTimeValue, ok := periodMap["startTime"]
if !ok {
return errors.New(`missing field : 'startTime' in 'period' cannot be empty`)
}
if periodStartType := reflect.TypeOf(startTimeValue); periodStartType.Kind() != reflect.Float64 {
return errors.New(`invalid type : 'startTime' in 'period' should be UNIX timestamp`)
}
periodStartFloat := startTimeValue.(float64)
startInt = int64(periodStartFloat)
periodEndValue, ok := periodMap["endTime"]
if !ok {
return errors.New(`missing field : 'endTime' in 'period' cannot be empty`)
}
if periodEndType := reflect.TypeOf(periodEndValue); periodEndType.Kind() != reflect.Float64 {
return errors.New(`invalid type : 'endTime' in 'period' should be UNIX timestamp`)
}
periodEndFloat := periodEndValue.(float64)
endInt = int64(periodEndFloat)
quotaPeriod = NewQuotaPeriod(inStartInt, startInt, endInt)
}
value, ok = quotaBucketMap["maxCount"]
if !ok {
return errors.New(`missing field: 'maxCount' is required`)
}
//from input when its read its float, need to then convert to int.
if maxCountType := reflect.TypeOf(value); maxCountType.Kind() != reflect.Float64 {
return errors.New(`invalid type : 'maxCount' should be a number`)
}
maxCountFloat := value.(float64)
maxCount = int(maxCountFloat)
//fmt.Println("maxCount: ", maxCount)
value, ok = quotaBucketMap["bucketType"]
if !ok {
return errors.New(`missing field: 'bucketType' is required`)
}
if bucketTypeType := reflect.TypeOf(value); bucketTypeType.Kind() != reflect.String {
return errors.New(`invalid type : 'bucketType' should be a string`)
}
bucketType = value.(string)
//fmt.Println("bucketType: ", bucketType)
newQBucket := NewQuotaBucket(edgeOrgID, id, interval, timeUnit, quotaType, preciseAtSecondsLevel, quotaPeriod, startTime, maxCount, bucketType)
qBucket.quotaBucketData = newQBucket.quotaBucketData
if err := qBucket.Validate(); err != nil {
return errors.New("failed in Validating the quotaBucket: " + err.Error())
}
return nil
}