422 lines
13 KiB
Go
422 lines
13 KiB
Go
|
package billing
|
|||
|
|
|
|||
|
|
import (
|
|||
|
|
"encoding/json"
|
|||
|
|
"sync"
|
|||
|
|
"time"
|
|||
|
|
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/dbs"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/billing/subscription"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/common/enum"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/common/pricing"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/order"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/peer"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/resources"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/resources/purchase_resource"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/models/utils"
|
|||
|
|
"cloud.o-forge.io/core/oc-lib/tools"
|
|||
|
|
"github.com/google/uuid"
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
type Bill struct {
|
|||
|
|
utils.AbstractObject
|
|||
|
|
OrderID string `json:"order_id" bson:"order_id" validate:"required"`
|
|||
|
|
Status enum.CompletionStatus `json:"status" bson:"status" default:"0"`
|
|||
|
|
SubOrders map[string]*PeerOrder `json:"sub_orders" bson:"sub_orders"`
|
|||
|
|
Total float64 `json:"total" bson:"total" validate:"required"`
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (ri *Bill) Extend(typ ...string) map[string][]tools.DataType {
|
|||
|
|
ext := ri.AbstractObject.Extend(typ...)
|
|||
|
|
for _, t := range typ {
|
|||
|
|
switch t {
|
|||
|
|
case "order":
|
|||
|
|
if _, ok := ext[t]; !ok {
|
|||
|
|
ext[t] = []tools.DataType{}
|
|||
|
|
}
|
|||
|
|
ext[t] = append(ext[t], tools.ORDER)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return ext
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// IsFullySettled retourne vrai quand chaque ligne de chaque peer-order est réglée.
|
|||
|
|
func (b *Bill) IsFullySettled() bool {
|
|||
|
|
for _, po := range b.SubOrders {
|
|||
|
|
for _, item := range po.Items {
|
|||
|
|
if !item.Settled {
|
|||
|
|
return false
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return true
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// SettledTotal retourne le montant total des lignes déjà réglées.
|
|||
|
|
func (b *Bill) SettledTotal() float64 {
|
|||
|
|
total := 0.0
|
|||
|
|
for _, po := range b.SubOrders {
|
|||
|
|
for _, item := range po.Items {
|
|||
|
|
if item.Settled {
|
|||
|
|
total += item.UnitPriceHT * float64(item.Quantity)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return total
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// MarkItemSettled marque une ligne comme réglée d'après son itemID
|
|||
|
|
// et propage le statut PAID sur le PeerOrder si toutes ses lignes sont réglées.
|
|||
|
|
func (b *Bill) MarkItemSettled(itemID string) bool {
|
|||
|
|
now := time.Now().UTC()
|
|||
|
|
for _, po := range b.SubOrders {
|
|||
|
|
for _, item := range po.Items {
|
|||
|
|
if item.ItemID == itemID {
|
|||
|
|
item.Settled = true
|
|||
|
|
item.SettledAt = &now
|
|||
|
|
// propage le statut PAID si toutes les lignes du peer sont réglées
|
|||
|
|
if po.IsFullySettled() {
|
|||
|
|
po.Status = enum.PAID
|
|||
|
|
}
|
|||
|
|
return true
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return false
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func GenerateBill(ord *order.Order, request *tools.APIRequest) (*Bill, error) {
|
|||
|
|
return &Bill{
|
|||
|
|
AbstractObject: utils.AbstractObject{
|
|||
|
|
Name: "bill_" + request.PeerID + "_" + time.Now().UTC().Format("2006-01-02T15:04:05"),
|
|||
|
|
IsDraft: false,
|
|||
|
|
},
|
|||
|
|
OrderID: ord.UUID,
|
|||
|
|
Status: enum.PENDING,
|
|||
|
|
}, nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// DraftFirstBill crée le premier brouillon de facture pour un order.
|
|||
|
|
// Règle :
|
|||
|
|
// - Calcul total indépendant du mode de paiement (photo du coût réel).
|
|||
|
|
// - Les purchases sont toujours BILL_ONCE / PAY_ONCE → réglées immédiatement.
|
|||
|
|
// - Les bookings avec BillingStrategy != BILL_ONCE génèrent des Subscription.
|
|||
|
|
// - Chaque ligne reçoit un ItemID unique pour le suivi de règlement.
|
|||
|
|
func DraftFirstBill(ord *order.Order, request *tools.APIRequest) (*Bill, error) {
|
|||
|
|
peers := map[string][]*PeerItemOrder{}
|
|||
|
|
|
|||
|
|
// Purchases : facturation immédiate, pas de subscription
|
|||
|
|
for _, p := range ord.Purchases {
|
|||
|
|
if _, ok := peers[p.DestPeerID]; !ok {
|
|||
|
|
peers[p.DestPeerID] = []*PeerItemOrder{}
|
|||
|
|
}
|
|||
|
|
peers[p.DestPeerID] = append(peers[p.DestPeerID], &PeerItemOrder{
|
|||
|
|
ItemID: uuid.New().String(),
|
|||
|
|
ResourceType: p.ResourceType,
|
|||
|
|
Purchase: p,
|
|||
|
|
Item: p.PricedItem,
|
|||
|
|
Quantity: 1,
|
|||
|
|
BillingStrategy: pricing.BILL_ONCE,
|
|||
|
|
PaymentType: pricing.PAY_ONCE,
|
|||
|
|
})
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Bookings : exclure les ressources déjà achetées (purchase_resource existant)
|
|||
|
|
purchasedIDs := map[string]bool{}
|
|||
|
|
for _, p := range ord.Purchases {
|
|||
|
|
purchasedIDs[p.ResourceID] = true
|
|||
|
|
}
|
|||
|
|
for _, b := range ord.Bookings {
|
|||
|
|
if purchasedIDs[b.ResourceID] {
|
|||
|
|
continue
|
|||
|
|
}
|
|||
|
|
if _, ok := peers[b.DestPeerID]; !ok {
|
|||
|
|
peers[b.DestPeerID] = []*PeerItemOrder{}
|
|||
|
|
}
|
|||
|
|
peers[b.DestPeerID] = append(peers[b.DestPeerID], &PeerItemOrder{
|
|||
|
|
ItemID: uuid.New().String(),
|
|||
|
|
ResourceType: b.ResourceType,
|
|||
|
|
Quantity: 1,
|
|||
|
|
Item: b.PricedItem,
|
|||
|
|
BillingStrategy: b.BillingStrategy,
|
|||
|
|
PaymentType: b.PaymentType,
|
|||
|
|
})
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Résolution des adresses de facturation peer
|
|||
|
|
peerOrders := map[string]*PeerOrder{}
|
|||
|
|
for peerID, items := range peers {
|
|||
|
|
pr, _, err := peer.NewAccessor(request).LoadOne(peerID)
|
|||
|
|
if err != nil {
|
|||
|
|
return nil, err
|
|||
|
|
}
|
|||
|
|
peerOrders[peerID] = &PeerOrder{
|
|||
|
|
PeerID: peerID,
|
|||
|
|
BillingAddress: pr.(*peer.Peer).WalletAddress,
|
|||
|
|
Items: items,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
bill := &Bill{
|
|||
|
|
AbstractObject: utils.AbstractObject{
|
|||
|
|
Name: "bill_" + request.PeerID + "_" + time.Now().UTC().Format("2006-01-02T15:04:05"),
|
|||
|
|
IsDraft: true,
|
|||
|
|
},
|
|||
|
|
OrderID: ord.UUID,
|
|||
|
|
Status: enum.PENDING,
|
|||
|
|
SubOrders: peerOrders,
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// 1. Calcul des totaux (indépendant du mode de paiement)
|
|||
|
|
if _, err := bill.SumUpBill(request); err != nil {
|
|||
|
|
return bill, err
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// 2. Création des subscriptions pour les lignes récurrentes
|
|||
|
|
subIDs, err := createRecurringSubscriptions(bill, request)
|
|||
|
|
if err != nil {
|
|||
|
|
return bill, err
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// 3. Liaison des subscription IDs à l'order pour traçabilité
|
|||
|
|
if len(subIDs) > 0 {
|
|||
|
|
ord.SubscriptionIDs = append(ord.SubscriptionIDs, subIDs...)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// 4. Persistance du brouillon de facture (les UnitPriceHT et SubscriptionID sont déjà set)
|
|||
|
|
stored, _, err := NewAccessor(request).StoreOne(bill)
|
|||
|
|
if err != nil {
|
|||
|
|
return bill, err
|
|||
|
|
}
|
|||
|
|
return stored.(*Bill), nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// createRecurringSubscriptions crée les Subscription pour chaque groupe
|
|||
|
|
// (peer × BillingStrategy) dont la stratégie est récurrente.
|
|||
|
|
// Modifie les PeerItemOrder en place (SubscriptionID).
|
|||
|
|
// Retourne les IDs de subscriptions créées.
|
|||
|
|
func createRecurringSubscriptions(b *Bill, request *tools.APIRequest) ([]string, error) {
|
|||
|
|
subIDs := []string{}
|
|||
|
|
|
|||
|
|
for peerID, po := range b.SubOrders {
|
|||
|
|
// Groupe les items récurrents par BillingStrategy
|
|||
|
|
byStrategy := map[pricing.BillingStrategy][]*PeerItemOrder{}
|
|||
|
|
for _, item := range po.Items {
|
|||
|
|
if item.BillingStrategy == pricing.BILL_ONCE {
|
|||
|
|
continue
|
|||
|
|
}
|
|||
|
|
byStrategy[item.BillingStrategy] = append(byStrategy[item.BillingStrategy], item)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for strategy, items := range byStrategy {
|
|||
|
|
subItems := make([]*subscription.SubscriptionItem, 0, len(items))
|
|||
|
|
totalAmount := 0.0
|
|||
|
|
for _, item := range items {
|
|||
|
|
subItems = append(subItems, &subscription.SubscriptionItem{
|
|||
|
|
ResourceType: item.ResourceType,
|
|||
|
|
Quantity: item.Quantity,
|
|||
|
|
UnitPrice: item.UnitPriceHT,
|
|||
|
|
})
|
|||
|
|
totalAmount += item.UnitPriceHT * float64(item.Quantity)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
var sub *subscription.Subscription
|
|||
|
|
switch strategy {
|
|||
|
|
case pricing.BILL_PER_YEAR:
|
|||
|
|
sub = subscription.NewYearlySubscription(request.PeerID, peerID, subItems, totalAmount, "EUR")
|
|||
|
|
case pricing.BILL_PER_WEEK:
|
|||
|
|
sub = subscription.NewWeeklySubscription(request.PeerID, peerID, subItems, totalAmount, "EUR")
|
|||
|
|
default: // BILL_PER_MONTH et tout autre cas récurrent
|
|||
|
|
sub = subscription.NewMonthlySubscription(request.PeerID, peerID, subItems, totalAmount, "EUR")
|
|||
|
|
}
|
|||
|
|
sub.IsDraft = true
|
|||
|
|
|
|||
|
|
res, _, err := subscription.NewAccessor(request).StoreOne(sub)
|
|||
|
|
if err != nil {
|
|||
|
|
return subIDs, err
|
|||
|
|
}
|
|||
|
|
storedSub := res.(*subscription.Subscription)
|
|||
|
|
subIDs = append(subIDs, storedSub.GetID())
|
|||
|
|
|
|||
|
|
// Lie le SubscriptionID à chaque ligne concernée
|
|||
|
|
for _, item := range items {
|
|||
|
|
item.SubscriptionID = storedSub.GetID()
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return subIDs, nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (d *Bill) GetAccessor(request *tools.APIRequest) utils.Accessor {
|
|||
|
|
return NewAccessor(request)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (r *Bill) StoreDraftDefault() {
|
|||
|
|
r.IsDraft = true
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (r *Bill) CanUpdate(set utils.DBObject) (bool, utils.DBObject) {
|
|||
|
|
if !r.IsDraft && r.Status != set.(*Bill).Status {
|
|||
|
|
return true, &Bill{Status: set.(*Bill).Status}
|
|||
|
|
}
|
|||
|
|
return r.IsDraft, set
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (r *Bill) CanDelete() bool {
|
|||
|
|
return r.IsDraft
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (d *Bill) SumUpBill(request *tools.APIRequest) (*Bill, error) {
|
|||
|
|
for _, b := range d.SubOrders {
|
|||
|
|
err := b.SumUpBill(request)
|
|||
|
|
if err != nil {
|
|||
|
|
return d, err
|
|||
|
|
}
|
|||
|
|
d.Total += b.Total
|
|||
|
|
}
|
|||
|
|
return d, nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------------------------------------------------------------------------
|
|||
|
|
// PeerOrder
|
|||
|
|
// ---------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
type PeerOrder struct {
|
|||
|
|
Error string `json:"error,omitempty" bson:"error,omitempty"`
|
|||
|
|
PeerID string `json:"peer_id,omitempty" bson:"peer_id,omitempty"`
|
|||
|
|
Status enum.CompletionStatus `json:"status" bson:"status" default:"0"`
|
|||
|
|
BillingAddress string `json:"billing_address,omitempty" bson:"billing_address,omitempty"`
|
|||
|
|
Items []*PeerItemOrder `json:"items,omitempty" bson:"items,omitempty"`
|
|||
|
|
Total float64 `json:"total,omitempty" bson:"total,omitempty"`
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// IsFullySettled retourne vrai si toutes les lignes de ce peer sont réglées.
|
|||
|
|
func (po *PeerOrder) IsFullySettled() bool {
|
|||
|
|
for _, item := range po.Items {
|
|||
|
|
if !item.Settled {
|
|||
|
|
return false
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return true
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func PricedByType(dt tools.DataType) pricing.PricedItemITF {
|
|||
|
|
switch dt {
|
|||
|
|
case tools.PROCESSING_RESOURCE:
|
|||
|
|
return &resources.PricedProcessingResource{}
|
|||
|
|
case tools.STORAGE_RESOURCE:
|
|||
|
|
return &resources.PricedStorageResource{}
|
|||
|
|
case tools.DATA_RESOURCE:
|
|||
|
|
return &resources.PricedDataResource{}
|
|||
|
|
case tools.COMPUTE_RESOURCE:
|
|||
|
|
return &resources.PricedComputeResource{}
|
|||
|
|
case tools.WORKFLOW_RESOURCE:
|
|||
|
|
return &resources.PricedResource[*pricing.ExploitPricingProfile[pricing.TimePricingStrategy]]{}
|
|||
|
|
}
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (d *PeerOrder) Pay(request *tools.APIRequest, response chan *PeerOrder, wg *sync.WaitGroup) {
|
|||
|
|
d.Status = enum.PENDING
|
|||
|
|
go func() {
|
|||
|
|
// DO SOMETHING TO PAY ON BLOCKCHAIN OR WHATEVER — UPDATE STATUS ON RETURN
|
|||
|
|
d.Status = enum.PAID // TO REMOVE LATER IT'S A MOCK
|
|||
|
|
if d.Status == enum.PAID {
|
|||
|
|
now := time.Now().UTC()
|
|||
|
|
for _, b := range d.Items {
|
|||
|
|
priced := PricedByType(b.ResourceType)
|
|||
|
|
bb, _ := json.Marshal(b.Item)
|
|||
|
|
json.Unmarshal(bb, priced)
|
|||
|
|
if !priced.IsPurchasable() {
|
|||
|
|
continue
|
|||
|
|
}
|
|||
|
|
accessor := purchase_resource.NewAccessor(request)
|
|||
|
|
accessor.StoreOne(&purchase_resource.PurchaseResource{
|
|||
|
|
ResourceID: priced.GetID(),
|
|||
|
|
ResourceType: priced.GetType(),
|
|||
|
|
EndDate: priced.GetLocationEnd(),
|
|||
|
|
})
|
|||
|
|
// Marque la ligne comme réglée
|
|||
|
|
b.Settled = true
|
|||
|
|
b.SettledAt = &now
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if d.Status != enum.PENDING {
|
|||
|
|
response <- d
|
|||
|
|
}
|
|||
|
|
wg.Done()
|
|||
|
|
}()
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (d *PeerOrder) SumUpBill(request *tools.APIRequest) error {
|
|||
|
|
for _, b := range d.Items {
|
|||
|
|
tot, err := b.GetPriceHT(request)
|
|||
|
|
if err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
d.Total += tot
|
|||
|
|
}
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// ---------------------------------------------------------------------------
|
|||
|
|
// PeerItemOrder
|
|||
|
|
// ---------------------------------------------------------------------------
|
|||
|
|
|
|||
|
|
// PeerItemOrder est une ligne de facture pour un peer donné.
|
|||
|
|
type PeerItemOrder struct {
|
|||
|
|
// ItemID identifie de manière unique cette ligne pour le suivi de règlement.
|
|||
|
|
ItemID string `json:"item_id,omitempty" bson:"item_id,omitempty"`
|
|||
|
|
ResourceType tools.DataType `json:"datatype,omitempty" bson:"datatype,omitempty"`
|
|||
|
|
Quantity int `json:"quantity,omitempty" bson:"quantity,omitempty"`
|
|||
|
|
Purchase *purchase_resource.PurchaseResource `json:"purchase,omitempty" bson:"purchase,omitempty"`
|
|||
|
|
Item map[string]interface{} `json:"item,omitempty" bson:"item,omitempty"`
|
|||
|
|
|
|||
|
|
BillingStrategy pricing.BillingStrategy `json:"billing_strategy" bson:"billing_strategy"`
|
|||
|
|
PaymentType pricing.PaymentType `json:"payment_type" bson:"payment_type"`
|
|||
|
|
|
|||
|
|
// UnitPriceHT est le prix unitaire HT calculé par SumUpBill/GetPriceHT.
|
|||
|
|
// Utilisé pour la création des subscriptions sans recalcul.
|
|||
|
|
UnitPriceHT float64 `json:"unit_price_ht,omitempty" bson:"unit_price_ht,omitempty"`
|
|||
|
|
|
|||
|
|
// SubscriptionID référence la Subscription créée pour les lignes récurrentes.
|
|||
|
|
// Vide pour les lignes BILL_ONCE.
|
|||
|
|
SubscriptionID string `json:"subscription_id,omitempty" bson:"subscription_id,omitempty"`
|
|||
|
|
|
|||
|
|
// Settled indique si cette ligne a été réglée (paiement confirmé).
|
|||
|
|
Settled bool `json:"settled" bson:"settled"`
|
|||
|
|
SettledAt *time.Time `json:"settled_at,omitempty" bson:"settled_at,omitempty"`
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (d *PeerItemOrder) GetPriceHT(request *tools.APIRequest) (float64, error) {
|
|||
|
|
if d.Purchase == nil {
|
|||
|
|
return 0, nil
|
|||
|
|
}
|
|||
|
|
priced := PricedByType(d.ResourceType)
|
|||
|
|
b, _ := json.Marshal(d.Item)
|
|||
|
|
err := json.Unmarshal(b, priced)
|
|||
|
|
if err != nil {
|
|||
|
|
return 0, err
|
|||
|
|
}
|
|||
|
|
accessor := purchase_resource.NewAccessor(request)
|
|||
|
|
search, code, _ := accessor.Search(&dbs.Filters{
|
|||
|
|
And: map[string][]dbs.Filter{
|
|||
|
|
"resource_id": {{Operator: dbs.EQUAL.String(), Value: priced.GetID()}},
|
|||
|
|
},
|
|||
|
|
}, "", d.Purchase.IsDraft, 0, 10000)
|
|||
|
|
if code == 200 && len(search) > 0 {
|
|||
|
|
for _, s := range search {
|
|||
|
|
if s.(*purchase_resource.PurchaseResource).EndDate == nil ||
|
|||
|
|
time.Now().UTC().After(*s.(*purchase_resource.PurchaseResource).EndDate) {
|
|||
|
|
return 0, nil
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
unitPrice, err := priced.GetPriceHT()
|
|||
|
|
if err != nil {
|
|||
|
|
return 0, err
|
|||
|
|
}
|
|||
|
|
d.UnitPriceHT = unitPrice // cache pour createRecurringSubscriptions
|
|||
|
|
return unitPrice * float64(d.Quantity), nil
|
|||
|
|
}
|