Skip to content
Snippets Groups Projects
Select Git revision
  • 701c80c454d123f95012e2bc8257071650f4c5f0
  • master default
  • rtde
  • tmp-gpg-key-workaround-2
  • tmp-gpg-key-workaround
  • 68-git-lfs-error-in-ddeploy-job
  • split-build-and-test
  • 66-jazzy-support
  • 62-deploy-jobs-do-not-pull-files-from-lfs-manual-lfs-pull
  • 62-deploy-jobs-do-not-pull-files-from-lfs-custom-docker-image
  • py3-without-industrial-ci-test
  • 58-add-yolo-pip-package-support
  • 55-collision-between-test-jobs-due-to-dds-autodiscovery-ros2
  • 52-ddeploy-job-failing-when-enforcing-labels-alt-quick-dind-test
  • 48-python3_syntax
  • 46-default-docker-image-name-too-long
  • 45-double-pipeline-triggered-if-merge-request-has-melodic-branch-name
  • 40-repo-is-ros-testing
  • test-badges
  • test-lfs-concept
  • add-packages
21 results

README.adoc

Blame
  • stub.go 3.88 KiB
    /**
     * 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
    }