stub.go

/**
 * stub.go
 *
 * COPYRIGHT: FUNDACIÓN TECNALIA RESEARCH & INNOVATION, 2022.
 */

package stats

import (
	"encoding/json"
	"fmt"

	"git.code.tecnalia.com/blockchain/hypercog/model"
	"git.code.tecnalia.com/ledgerbuilder/sdk/core/util/logging"
	"git.code.tecnalia.com/ledgerbuilder/sdk/shared"
)

const GLOBAL_KEY = "global"
const ORG_LIST_KEY = "org_list"

type OrgList []string

var log = logging.NewGoLogger("stats")

func getStats(stub shared.LedgerBuildrStubInterface, key string) (st *model.RawStats, err error) {
	value, err := stub.GetState(key)
	if err != nil || len(value) == 0 {
		st = new(model.RawStats)
	} else {
		err = json.Unmarshal(value, &st)
		if err != nil  {
			return nil, err
		}
	}

	return st, nil
}

func putStats(stub shared.LedgerBuildrStubInterface, key string, stats *model.RawStats) (error) {
	serialized, err := json.Marshal(stats)
	if err != nil {
		return err
	}

	err = stub.PutState(key, serialized)
	if err != nil {
		return err
	}

	return nil
}

func getOrgList(stub shared.LedgerBuildrStubInterface) (st *OrgList, err error) {
	value, err := stub.GetState(ORG_LIST_KEY)
	if err != nil || len(value) == 0 {
		st = new(OrgList)
	} else {
		err = json.Unmarshal(value, &st)
		if err != nil  {
			return nil, err
		}
	}

	return st, nil
}

func resetStats(stub shared.LedgerBuildrStubInterface) (error) {
	err := stub.DelState(GLOBAL_KEY)
	if err != nil {
		return err
	}

	orgs, err := getOrgList(stub)
	if len(*orgs) > 0 {
		for _, org := range *orgs {
			err = stub.DelState(org)
			if err != nil {
				return err
			}
		}
	}

	err = stub.DelState(ORG_LIST_KEY)
	return err
}

func (orgs OrgList) contains(org string) (bool) {
	for _, o := range orgs {
        if o == org {
            return true
        }
    }
	return false
}

func addOrgIfNotExist(stub shared.LedgerBuildrStubInterface, org string) (err error) {
	orgs, err := getOrgList(stub)
	if err != nil {
		return err
	}

	if !orgs.contains(org) {
		newOrgs := append(*orgs, org)

		serialized, err := json.Marshal(newOrgs)
		if err != nil {
			return err
		}
	
		err = stub.PutState(ORG_LIST_KEY, serialized)
		if err != nil {
			return err
		}

		log.Debug("Added stat for new org")
	}

	return nil
}


func retrieveExistingStats(stub shared.LedgerBuildrStubInterface) (*model.RawStats, *model.RawStats, error) {
	org, err := stub.GetOrganization()
	if err != nil {
		return nil, nil, err
	}

	customStats, err := getStats(stub, org)
	if err != nil {
		return nil, nil, err
	}

	globalStats, err := getStats(stub , GLOBAL_KEY)
	if err != nil {
		return nil, nil, err
	}

	return globalStats, customStats, nil
}

func upgradeStats(stub shared.LedgerBuildrStubInterface, globalStats *model.RawStats, customStats *model.RawStats) (error) {
	org, err := stub.GetOrganization()
	if err != nil {
		return err
	}

	err = putStats(stub, org, customStats)
	if err != nil {
		return err
	}

	err = putStats(stub, GLOBAL_KEY, globalStats)
	if err != nil {
		return err
	}

	err = addOrgIfNotExist(stub, org)
	if err != nil {
		return err
	}

	log.Debug("Upgrading stats")
	return nil
}


func RegisterSlag(stub shared.LedgerBuildrStubInterface, quantity uint32, units string) (error) {
	globalStats, customStats, err := retrieveExistingStats(stub)
	if err != nil {
		return err
	}

	customStats.RegisterSlag(quantity, units)
	globalStats.RegisterSlag(quantity, units)

	err = upgradeStats(stub, globalStats, customStats)
	if err != nil {
		return err
	}

	return nil
}

func RegisterSale(stub shared.LedgerBuildrStubInterface, quantity uint32, price float32, units string) (error) {
	globalStats, orgStats, err := retrieveExistingStats(stub)
	if err != nil {
		return err
	}
	
	orgStats.UpgradeSell(quantity, price, units)
	orgStats.UpgradeSell(quantity, price, units)

	log.Debug(fmt.Sprintf("Sale registered in stats (quantity: %d %s, price: %.2f €)", quantity, units, price))

	err = upgradeStats(stub, globalStats, orgStats)
	if err != nil {
		return err
	}

	return nil
}