product-api-repo-trade-func.rosetta

namespace cdm.api.repo : <"API for access to repo components.">
version "${project.version}"

import cdm.base.*
import cdm.base.math.*
import cdm.base.datetime.*
import cdm.base.staticdata.party.*
import cdm.base.staticdata.identifier.*
import cdm.base.staticdata.asset.common.*

import cdm.observable.asset.*
import cdm.observable.common.*
import cdm.observable.event.*
import cdm.product.template.*
import cdm.product.asset.*
import cdm.product.common.schedule.*
import cdm.product.common.settlement.*
import cdm.product.collateral.*
import cdm.event.common.*

import cdm.legaldocumentation.common.*
import cdm.legaldocumentation.master.*

import cdm.event.workflow.*
import cdm.event.position.*
import cdm.event.common.*

import cdm.product.template.*

import cdm.api.repo.common.*

func GetTradeUTI:
	inputs:
        trade Trade (1..1)
	output:
		uti string (1..1)
	
	alias tradeIdentiferObject:
		trade->tradeIdentifier
		
	alias utiElement:
		trade->tradeIdentifier
		then filter identifierType = TradeIdentifierTypeEnum->UniqueTransactionIdentifier
		then only-element
	
	set uti:
		utiElement-> assignedIdentifier->identifier first
		
func SetTradeUTI:
	inputs:
        before Trade (1..1)
		uti string (1..1)
	output:
		after Trade (1..1)
		
	set after:before
	set after->tradeIdentifier->identifierType:TradeIdentifierTypeEnum->UniqueTransactionIdentifier
	set after->tradeIdentifier->assignedIdentifier->identifier:uti

func GetRepoRate:
	inputs:
        trade Trade (1..1)
	output:
		repoRate string (1..1)
	
	alias fixedRate:
		trade->tradableProduct->tradeLot->priceQuantity
		
    alias currentRatePrice: <"Filter interest rate price and make it into a single element">
        fixedRate
            extract price
            then flatten
            then filter priceType = PriceTypeEnum -> InterestRate
            then only-element
	
	set repoRate:
		currentRatePrice -> value to-string
		
func SetRepoRate:
	inputs:
		before Trade (1..1)
		repoRate number (1..1)
	output:
		after Trade (1..1)
		
	set after:before
	set after->tradableProduct->tradeLot->priceQuantity->price->priceType:PriceTypeEnum -> InterestRate
	set after->tradableProduct->tradeLot->priceQuantity->price->value:repoRate 

func GetFloatingRateIndexSpread:
	inputs:
        trade Trade (1..1)
	output:
		spread number (1..1)
	
	alias floatingRate:
		trade->tradableProduct->tradeLot->priceQuantity
		
    alias currentRatePrice: <"Filter interest rate price and make it into a single element">
        floatingRate
            extract price
            then flatten
            then filter priceType = PriceTypeEnum -> InterestRate
            then only-element
	
	alias IsFloatingRate:
		trade->tradableProduct->product->contractualProduct->economicTerms->payout->interestRatePayout->rateSpecification->floatingRate exists
			
	condition IsFloatingRateCondition:
		trade->tradableProduct->product->contractualProduct->economicTerms->payout->interestRatePayout->rateSpecification->floatingRate exists
		
	set spread:
		if  IsFloatingRate 
		then currentRatePrice
            then extract [ item -> composite]
			then filter [ item -> operandType = PriceOperandEnum -> ForwardPoint ] //Enum to be replaced with Spread
			then extract [ item -> operand ] * 100.0
		
func GetFloatingRateIndexPrice: //To be done
	inputs:
        trade Trade (1..1)
	output:
		spread number (1..1)
	
	alias floatingRate:
		trade->tradableProduct->tradeLot->priceQuantity
		
    alias currentRatePrice: <"Filter interest rate price and make it into a single element">
        floatingRate
            extract price
            then flatten
            then filter priceType = PriceTypeEnum -> InterestRate
            then only-element
	
	alias IsFloatingRate:
		trade->tradableProduct->product->contractualProduct->economicTerms->payout->interestRatePayout->rateSpecification->floatingRate exists
			
	condition IsFloatingRateCondition:
		trade->tradableProduct->product->contractualProduct->economicTerms->payout->interestRatePayout->rateSpecification->floatingRate exists
		
	set spread:
		currentRatePrice
            then extract [ item -> composite]
			then filter [ item -> operandType = PriceOperandEnum -> ForwardPoint ] //Enum to be replaced with Spread
			then extract [ item -> baseValue] * 100.0


func GetPurchasePrice:
    inputs:
        trade Trade (1..1)
    output:
        value number (0..*)

    set value:
		trade->tradableProduct -> tradeLot only-element -> priceQuantity
		extract [ item -> price ]
		then flatten
		then filter [ item -> perUnitOf->financialUnit  = FinancialUnitEnum->ContractualProduct ]
		then extract [ item -> composite -> baseValue ]
		
func GetRePurchasePrice:
    inputs:
        trade Trade (1..1)
    output:
        value number (0..*)

    set value:
		trade->tradableProduct -> tradeLot only-element -> priceQuantity
		extract [ item -> price ]
		then flatten
		then filter [ item -> perUnitOf->financialUnit  = FinancialUnitEnum->ContractualProduct ]
		then extract [ item -> value]
		
func GetRepoInterest:
    inputs:
        trade Trade (1..1)
    output:
        value number (0..*)

    set value:
		trade->tradableProduct -> tradeLot only-element -> priceQuantity
		extract [ item -> price ]
		then flatten
		then filter [ item -> perUnitOf->financialUnit  = FinancialUnitEnum->ContractualProduct ]
		then extract [ item -> composite -> operand]


func GetCollateralQuantity:
        inputs:
			trade Trade (1..1)
        output:
            value number (0..1)

        set value:
            trade->tradableProduct -> tradeLot only-element -> priceQuantity
            extract [ item -> quantity ]
            then flatten
            then extract [ item -> value ]
            then last


func GetCollateralDirtyPrice: 
        inputs:
			trade Trade (1..1)
        output:
            value number (0..*)

        set value:
            trade->tradableProduct -> tradeLot only-element -> priceQuantity
            extract [ item -> price ]
            then flatten
            then filter [ item -> priceType = PriceTypeEnum -> AssetPrice ]
            then extract [ item -> value ] * 100.0
			
func GetCollateralCleanPrice:
        inputs:
			trade Trade (1..1)
        output:
            value number (0..*)

        set value:
            trade->tradableProduct -> tradeLot only-element -> priceQuantity
            extract [ item -> price ]
            then flatten
            then filter [ item -> priceType = PriceTypeEnum -> AssetPrice ]
            then extract [ item -> composite]
			then filter [ item -> operandType = PriceOperandEnum -> AccruedInterest ]
			then extract [ item -> baseValue ] * 100.0
			
func GetCollateralAccruedInterestPrice:
        inputs:
			trade Trade (1..1)
        output:
            value number (0..*)

        set value:
            trade->tradableProduct -> tradeLot only-element -> priceQuantity
            extract [ item -> price ]
            then flatten
            then filter [ item -> priceType = PriceTypeEnum -> AssetPrice ]
            then extract [ item -> composite]
			then filter [ item -> operandType = PriceOperandEnum -> AccruedInterest ]
			then extract [ item -> operand ] * 100.0

func GetCollateralAccruedInterest: //To be done
        inputs:
			trade Trade (1..1)
        output:
            value number (0..*)

		alias collateralQuantity:
			GetCollateralQuantity(trade)
		alias collateralAcrruedPrice:
			GetCollateralAccruedInterestPrice(trade)
			
        set value:
			collateralQuantity * collateralAcrruedPrice
			
			
func GetCollateralMarginAdjustedPrice: //To be done
        inputs:
			trade Trade (1..1)
        output:
            value number (0..*)

		alias dirtyPrice:
			GetCollateralDirtyPrice(trade)
		
		alias margin:
			GetMargin(trade->tradableProduct->product)
			
        set value:
			dirtyPrice * margin
			
func GetHairCut:
		inputs:
			product Product (1..1)
		output:
			haircut number (1..*)
			
		set haircut:
			product->contractualProduct->economicTerms->collateral->collateralPortfolio->collateralPosition->product->contractualProduct->economicTerms->collateral->collateralProvisions->eligibleCollateral->treatment->valuationTreatment->haircutPercentage * 100.0
	

func SetHairCut:
		inputs:
			before Product (1..1)
			haircut number (1..1)
		output:
			after Product (1..1)
		
		set after:before
		set after->contractualProduct->economicTerms->collateral->collateralPortfolio->collateralPosition->product->contractualProduct->economicTerms->collateral->collateralProvisions->eligibleCollateral->treatment->valuationTreatment->haircutPercentage:haircut


func GetMargin:
		inputs:
			product Product (1..1)
		output:
			margin number (1..*)
			
		
		set margin:
		product->contractualProduct->economicTerms->collateral->collateralPortfolio->collateralPosition->product->contractualProduct->economicTerms->collateral->collateralProvisions->eligibleCollateral->treatment->valuationTreatment->marginPercentage * 100.0
	
			
			
func GetAgreementType:
	inputs:
        contractDetails ContractDetails (1..1)
	output:
		agreementType string (1..1)

	set agreementType:
		contractDetails->documentation->legalAgreementIdentification->agreementName->masterAgreementType first to-string

func SetAgreementType:
		inputs:
			before ContractDetails (1..1)
			agreementType MasterAgreementTypeEnum (1..1)
		output:
			after ContractDetails (1..1)
		
		set after:before
		set after->documentation->legalAgreementIdentification->agreementName->masterAgreementType:agreementType
	
func GetAgreementDate:
	inputs:
        trade Trade (1..1)
	output:
		agreementDate string (1..1)

	set agreementDate:
		trade->contractDetails->documentation->legalAgreementIdentification->vintage first to-string
	
func SetAgreementDate:
		inputs:
			before ContractDetails (1..1)
			agreementVintage int(1..1)
		output:
			after ContractDetails (1..1)
		
		set after:before
		set	after->documentation->legalAgreementIdentification->vintage:agreementVintage
		

func GetExecutionVenueId:
	inputs:
        trade Trade (1..1)
	output:
		venueId string (1..1)

	set venueId:
		trade->executionDetails->executionVenue->entityId first to-string
		


func GetExecutionVenueName:
	inputs:
        trade Trade (1..1)
	output:
		venueName string (1..1)

	set venueName:
		trade->executionDetails->executionVenue->name to-string
		
	
func GetTradeDirection:
	inputs:
		trade Trade (1..1)
		party Party (1..1)
	output:
		direction string (1..1)
		
	alias IsBuyer:
		trade
			extract [item -> partyRole]
			then filter [item -> role = PartyRoleEnum -> Buyer]
	
	set direction:
		if (IsBuyer exists)
		then "BUY"
		else "SELL"
		
		
		
func Create_FixedRateFixedTermRepoTrade:
	inputs:
		tradeDate date (1..1)
		purchaseDate date (1..1)
		repurchaseDate date (1..1)
		uti string (1..1)
		buyer Party (1..1)
		seller Party (1..1)
		repoRate number (1..1)
		product Product (1..1)
		purchasePrice number (1..1)
		repruchasePrice number (1..1)
		executionDetails ExecutionDetails (1..1)
		contractDetails ContractDetails (1..1)
	output:
		trade Trade (1..1)

		set trade:SetTradeDate(trade,tradeDate)
		set trade:SetTradeUTI(trade,uti)
		set trade:SetBuyer(trade, buyer)
		set trade:SetSeller(trade,seller)
		set trade:SetRepoRate(trade,repoRate)
		set trade->tradableProduct->product:product
		set trade->executionDetails:executionDetails
		set trade->contractDetails:contractDetails
	

func Create_ExecutedRepoTradeState:
	inputs:
		trade Trade (1..1)
	output:
		tradeState TradeState (1..1)
	
		set tradeState->trade:trade
		set tradeState->state->positionState:PositionStatusEnum->Executed

func Create_RepoExecutionInstruction:
		inputs:
			trade Trade (1..1)
		output:
			instruction Instruction (1..1)
			
		set instruction->before:empty
		set instruction->primitiveInstruction:Create_RepoExecutionPrimitiveInstruction(trade)
		
func Create_RepoExecutionPrimitiveInstruction:
		inputs:
			trade Trade (1..1)
		output:
			exInst PrimitiveInstruction (1..1)
		
		
		set exInst->execution->product:trade->tradableProduct->product
		set exInst->execution->tradeDate:trade->tradeDate
		set exInst->execution->parties:trade->party
		set exInst->execution->partyRoles:trade->partyRole
		set exInst->execution->executionDetails:trade->executionDetails
		set exInst->execution->tradeIdentifier:trade->tradeIdentifier

	
func Create_RepoBusinessEvent:
	inputs:
		eventDate date (1..1)
		effectiveDate date (1..1)
		instruction Instruction (1..1)
	output:
		businessEvent BusinessEvent (1..1)
		
		set businessEvent->instruction:instruction
		set businessEvent->effectiveDate:effectiveDate
		set businessEvent->eventDate:eventDate