oc-lib/models/resources/priced_resource.go

package resources

import (
	"errors"
	"fmt"
	"time"

	"cloud.o-forge.io/core/oc-lib/models/booking"
	"cloud.o-forge.io/core/oc-lib/models/common/pricing"
	"cloud.o-forge.io/core/oc-lib/tools"
)

type BookingConfiguration struct {
	ExplicitBookingDurationS float64             `json:"explicit_location_duration_s,omitempty" bson:"explicit_location_duration_s,omitempty"`
	UsageStart               *time.Time          `json:"start,omitempty" bson:"start,omitempty"`
	UsageEnd                 *time.Time          `json:"end,omitempty" bson:"end,omitempty"`
	Mode                     booking.BookingMode `json:"mode,omitempty" bson:"mode,omitempty"`
}

type PricedResource struct {
	Name                 string                      `json:"name,omitempty" bson:"name,omitempty"`
	Logo                 string                      `json:"logo,omitempty" bson:"logo,omitempty"`
	InstancesRefs        map[string]string           `json:"instances_refs,omitempty" bson:"instances_refs,omitempty"`
	SelectedPricing      pricing.PricingProfileITF   `json:"selected_pricing,omitempty" bson:"selected_pricing,omitempty"`
	Quantity             int                         `json:"quantity,omitempty" bson:"quantity,omitempty"`
	BookingConfiguration *BookingConfiguration       `json:"booking_configuration,omitempty" bson:"booking_configuration,omitempty"`
	Variations           []*pricing.PricingVariation `json:"pricing_variations" bson:"pricing_variations"`
	CreatorID            string                      `json:"peer_id,omitempty" bson:"peer_id,omitempty"`
	ResourceID           string                      `json:"resource_id,omitempty" bson:"resource_id,omitempty"`
	ResourceType         tools.DataType              `json:"resource_type,omitempty" bson:"resource_type,omitempty"`
}

func (abs *PricedResource) GetQuantity() int {
	return abs.Quantity
}

func (abs *PricedResource) AddQuantity(amount int) {
	abs.Quantity += amount
}

func (abs *PricedResource) SelectPricing() pricing.PricingProfileITF {
	return abs.SelectedPricing
}

func (abs *PricedResource) GetID() string {
	return abs.ResourceID
}

func (abs *PricedResource) GetType() tools.DataType {
	return abs.ResourceType
}

func (abs *PricedResource) GetCreatorID() string {
	return abs.CreatorID
}

func (abs *PricedResource) IsPurchasable() bool {
	if abs.SelectedPricing == nil {
		return false
	}
	return (abs.SelectedPricing).IsPurchasable()
}

func (abs *PricedResource) IsBooked() bool {
	return true // For dev purposes, prevent that DB objects that don't have a Pricing are considered as not booked
	if abs.SelectedPricing == nil {
		return false
	}
	return (abs.SelectedPricing).IsBooked()
}

func (abs *PricedResource) GetLocationEnd() *time.Time {
	if abs.BookingConfiguration == nil {
		return nil
	}
	return abs.BookingConfiguration.UsageEnd
}

func (abs *PricedResource) GetLocationStart() *time.Time {
	if abs.BookingConfiguration == nil {
		return nil
	}
	return abs.BookingConfiguration.UsageStart
}

func (abs *PricedResource) SetLocationStart(start time.Time) {
	if abs.BookingConfiguration == nil {
		abs.BookingConfiguration = &BookingConfiguration{}
	}
	abs.BookingConfiguration.UsageStart = &start
}

func (abs *PricedResource) SetLocationEnd(end time.Time) {
	if abs.BookingConfiguration == nil {
		abs.BookingConfiguration = &BookingConfiguration{}
	}
	abs.BookingConfiguration.UsageEnd = &end
}

func (abs *PricedResource) GetBookingMode() booking.BookingMode {
	if abs.BookingConfiguration == nil {
		return booking.WHEN_POSSIBLE
	}
	return abs.BookingConfiguration.Mode
}

func (abs *PricedResource) GetExplicitDurationInS() float64 {
	if abs.BookingConfiguration == nil {
		abs.BookingConfiguration = &BookingConfiguration{}
	}
	if abs.BookingConfiguration.ExplicitBookingDurationS == 0 {
		if abs.BookingConfiguration.UsageEnd == nil && abs.BookingConfiguration.UsageStart == nil {
			return time.Duration(1 * time.Hour).Seconds()
		}
		if abs.BookingConfiguration.UsageEnd == nil {
			add := abs.BookingConfiguration.UsageStart.Add(time.Duration(1 * time.Hour))
			abs.BookingConfiguration.UsageEnd = &add
		}
		return abs.BookingConfiguration.UsageEnd.Sub(*abs.BookingConfiguration.UsageStart).Seconds()
	}
	return abs.BookingConfiguration.ExplicitBookingDurationS
}

func (r *PricedResource) GetPriceHT() (float64, error) {
	now := time.Now()
	if r.BookingConfiguration == nil {
		r.BookingConfiguration = &BookingConfiguration{}
	}
	fmt.Println("GetPriceHT", r.BookingConfiguration.UsageStart, r.BookingConfiguration.UsageEnd)
	if r.BookingConfiguration.UsageStart == nil {
		r.BookingConfiguration.UsageStart = &now
	}
	if r.BookingConfiguration.UsageEnd == nil {
		add := r.BookingConfiguration.UsageStart.Add(time.Duration(1 * time.Hour))
		r.BookingConfiguration.UsageEnd = &add
	}
	if r.SelectedPricing == nil {
		return 0, errors.New("pricing profile must be set on Priced Resource " + r.ResourceID)
	}
	pricing := r.SelectedPricing
	return pricing.GetPriceHT(1, 0, *r.BookingConfiguration.UsageStart, *r.BookingConfiguration.UsageEnd, r.Variations)
}