Class ContractManager
- java.lang.Object
-
- es.bsc.dataclay.util.management.AbstractManager
-
- es.bsc.dataclay.logic.contractmgr.ContractManager
-
- All Implemented Interfaces:
CommonManager
public final class ContractManager extends AbstractManager
This class is responsible to manage contracts: add, remove and modify.
-
-
Field Summary
-
Fields inherited from class es.bsc.dataclay.util.management.AbstractManager
dataSource
-
-
Constructor Summary
Constructors Constructor Description ContractManager(SQLiteDataSource dataSource)
Instantiates an Contract Manager that uses the Backend configuration provided.
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description void
checkActiveContracts(HashSet<ContractID> modelContracts)
This method checks whether the given contracts are activeboolean
checkImplementationHasContractForAccount(ImplementationID implementationID, AccountID accountID)
This method checks if the provided implementation is accessible from any contract of the user provided.boolean
checkImplementationHasNoContracts(ImplementationID implementationID)
This method checks if the provided implementation is accessible from any contract.boolean
checkInterfaceHasNoContracts(InterfaceID interfaceID)
This method checks that the provided interfaceID is not accessible from any contract.boolean
checkInterfacesInActiveContractsForAccount(AccountID accountID, Map<ContractID,InterfaceID> interfacesInContracts)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active and contain a specific interface.Map<ContractID,Contract>
checkInterfacesInActiveContractsForAccountAndReturnContractsInfo(AccountID accountID, Map<ContractID,InterfaceID> interfacesInContract)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active and contain a specific interface.boolean
checkNamespaceHasNoContracts(NamespaceID namespaceID)
This method checks if there is no contract associated with the provided namespacevoid
cleanCaches()
Method that cleans the caches of the manager.Map<ContractID,Contract>
getContractIDsOfApplicant(AccountID applicantAccountID)
Get all contract IDs of the user provided (as applicant)Map<ContractID,Contract>
getContractIDsOfApplicantWithProvider(AccountID applicantAccountID, NamespaceID namespaceIDofProvider)
Get all contract IDs of the user provided (as applicant) with a namespace provider.Map<ContractID,Contract>
getContractIDsOfProvider(AccountID providerAccountID)
Get all contract IDs of the user provided (as provider)Map<ContractID,Contract>
getContractIDsOfProvider(NamespaceID namespaceIDofProvider)
Get info of all contracts of the namespace provided indexed by their id.Contract
getContractInfo(ContractID contractID)
This method returns the info of a contractContractManagerDB
getDbHandler()
Method used for unit testing.Map<ContractID,Contract>
getInfoOfAllActiveContractsForAccount(AccountID accountID)
This method returns the info of all the active contracts which account is applicant of.Map<ContractID,Tuple<Map<InterfaceID,InterfaceInContract>,Calendar>>
getInfoOfMultipleContractsPerActiveContractsForAccount(AccountID accountID, Set<ContractID> contracts)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active.Map<ContractID,Tuple<Map<InterfaceID,InterfaceInContract>,Calendar>>
getInfoOfMultipleInterfacesPerActiveContractsForAccount(AccountID accountID, Map<ContractID,HashSet<InterfaceID>> interfacesInContracts)
This method returns the information of those interfaces in (still active) contract having the given account registered on them.LinkedHashMap<ContractID,Contract>
getInfoOfSomeActiveContractsForAccount(List<ContractID> contractsIDs, AccountID accountID)
This method returns the info of the contracts if they are still active and the given account is registered on them.Map<ContractID,InterfaceInContract>
getInfoOfSubsetOfInterfacesThatAreInActiveContractsForAccount(AccountID accountID, Map<ContractID,InterfaceID> interfacesInContracts)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active and contain the given interfaces.Map<ContractID,Contract>
getPublicContractIDsOfProvider(NamespaceID namespaceIDofProvider)
Get info of all contracts of the namespace provided indexed by their id.ContractID
newPrivateContract(Contract newContract)
Method that creates a new private contract with the provided account.ContractID
newPublicContract(Contract newContract)
Method that creates a new public contract.void
registerToPublicContract(AccountID applicantAccountID, ContractID contractID)
Method that allows an account to register to a public contract.
-
-
-
Constructor Detail
-
ContractManager
public ContractManager(SQLiteDataSource dataSource)
Instantiates an Contract Manager that uses the Backend configuration provided.
-
-
Method Detail
-
newPrivateContract
public ContractID newPrivateContract(Contract newContract) throws ParseException
Method that creates a new private contract with the provided account. The contract contains a set of Interfaces with its accessible methods, operations and properties. The Interfaces must refer to Metaclasses of the same Namespace, which is also provided in the method.- Parameters:
newContract
- Information of the contract to create- Returns:
- the id of the contract
- Throws:
ParseException
- parse exception.
-
newPublicContract
public ContractID newPublicContract(Contract newContract) throws ParseException
Method that creates a new public contract. The contract contains a set of Interfaces with its accessible methods, operations and properties. The Interfaces must refer to Metaclasses of the same Namespace, which is also provided in the method.- Parameters:
newContract
- Information of the contract to create- Returns:
- the id of the contract
- Throws:
ParseException
- parse exception.
-
registerToPublicContract
public void registerToPublicContract(AccountID applicantAccountID, ContractID contractID)
Method that allows an account to register to a public contract.- Parameters:
applicantAccountID
- the id of the applicant accountcontractID
- the id of the contract- Throws:
Exception
- if some exception occurs:
ContractNotExistException: if the contract does not exist
ContractNotPublicException: if the contract is not public
ContractNotActiveException: if the contract has expired
AccountAlreadyRegisteredInContract if the account is already registered to the contract
-
checkActiveContracts
public void checkActiveContracts(HashSet<ContractID> modelContracts)
This method checks whether the given contracts are active- Parameters:
modelContracts
- Contracts to be checked- Throws:
Exception
- if some exception occurs:
ContractNotExistException: if some contract does not exist.
ContractNotActiveException: if some contract is not active.
-
checkNamespaceHasNoContracts
public boolean checkNamespaceHasNoContracts(NamespaceID namespaceID)
This method checks if there is no contract associated with the provided namespace- Parameters:
namespaceID
- the namespace to be checked- Returns:
- true if there is no contract related with the namespace, false otherwise
- Throws:
Exception
- if some exception occurs
-
checkInterfaceHasNoContracts
public boolean checkInterfaceHasNoContracts(InterfaceID interfaceID)
This method checks that the provided interfaceID is not accessible from any contract.- Parameters:
interfaceID
- the id of the interface- Returns:
- true if there is no contract related with the interface, false otherwise
- Throws:
Exception
- if some exception occurs
-
checkImplementationHasNoContracts
public boolean checkImplementationHasNoContracts(ImplementationID implementationID)
This method checks if the provided implementation is accessible from any contract.- Parameters:
implementationID
- the id of the implementation- Returns:
- true if there is no contract related with the implementation, false otherwise
- Throws:
Exception
- if some exception occurs
-
checkImplementationHasContractForAccount
public boolean checkImplementationHasContractForAccount(ImplementationID implementationID, AccountID accountID)
This method checks if the provided implementation is accessible from any contract of the user provided.- Parameters:
implementationID
- the id of the implementationaccountID
- ID of account to check.- Returns:
- true if there is a contract related with the implementation an user, false otherwise
- Throws:
Exception
- if some exception occurs
-
checkInterfacesInActiveContractsForAccount
public boolean checkInterfacesInActiveContractsForAccount(AccountID accountID, Map<ContractID,InterfaceID> interfacesInContracts)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active and contain a specific interface.- Parameters:
accountID
- the account IDinterfacesInContracts
- the interface to be checked for each contract- Returns:
- true if the provided account is registered in all the contracts provided, they are active, and every contract contains the corresponding interface provided
- Throws:
Exception
- if some exception occurs:
ContractNotExistException: if the contract does not exist
-
checkInterfacesInActiveContractsForAccountAndReturnContractsInfo
public Map<ContractID,Contract> checkInterfacesInActiveContractsForAccountAndReturnContractsInfo(AccountID accountID, Map<ContractID,InterfaceID> interfacesInContract)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active and contain a specific interface. Finally returns the info of the contracts.- Parameters:
accountID
- ID of the accountinterfacesInContract
- the interface to be checked for each contract- Returns:
- info of the contracts
- Throws:
Exception
- if some exception occurs
-
getContractInfo
public Contract getContractInfo(ContractID contractID)
This method returns the info of a contract- Parameters:
contractID
- ID of the contract- Returns:
- info of the contract
- Throws:
Exception
- if some exception occurs:
ContractNotExistException: if the contract does not exist
-
getInfoOfSomeActiveContractsForAccount
public LinkedHashMap<ContractID,Contract> getInfoOfSomeActiveContractsForAccount(List<ContractID> contractsIDs, AccountID accountID)
This method returns the info of the contracts if they are still active and the given account is registered on them.- Parameters:
contractsIDs
- IDs of the contractsaccountID
- ID of the account that must be registered in the contract- Returns:
- the information about the contracts
- Throws:
Exception
- if some exception occurs:
ContractNotExistException: if the contract does not exist
AccountNotRegisteredInContract: if the account is not registered in the contract
ContractNotActiveException: if the contract is not active
-
getInfoOfAllActiveContractsForAccount
public Map<ContractID,Contract> getInfoOfAllActiveContractsForAccount(AccountID accountID)
This method returns the info of all the active contracts which account is applicant of.- Parameters:
accountID
- ID of the account that must be registered in the contract- Returns:
- the information about the contracts
- Throws:
Exception
- if some exception occurs
-
getContractIDsOfProvider
public Map<ContractID,Contract> getContractIDsOfProvider(NamespaceID namespaceIDofProvider)
Get info of all contracts of the namespace provided indexed by their id.- Parameters:
namespaceIDofProvider
- the namespace of the contract- Returns:
- The info of the contracts of the account provided in the namespace provided
- Throws:
Exception
- if some exception occurs
-
getPublicContractIDsOfProvider
public Map<ContractID,Contract> getPublicContractIDsOfProvider(NamespaceID namespaceIDofProvider)
Get info of all contracts of the namespace provided indexed by their id.- Parameters:
namespaceIDofProvider
- the namespace of the contract- Returns:
- The info of the contracts of the account provided in the namespace provided
- Throws:
Exception
- if some exception occurs
-
getContractIDsOfApplicant
public Map<ContractID,Contract> getContractIDsOfApplicant(AccountID applicantAccountID)
Get all contract IDs of the user provided (as applicant)- Parameters:
applicantAccountID
- the applicant user- Returns:
- The info of the contracts of the user (as applicant)
- Throws:
Exception
- if some exception occurs
-
getContractIDsOfProvider
public Map<ContractID,Contract> getContractIDsOfProvider(AccountID providerAccountID)
Get all contract IDs of the user provided (as provider)- Parameters:
providerAccountID
- the provider user- Returns:
- The info of the contracts of the user (as provider)
- Throws:
Exception
- if some exception occurs
-
getContractIDsOfApplicantWithProvider
public Map<ContractID,Contract> getContractIDsOfApplicantWithProvider(AccountID applicantAccountID, NamespaceID namespaceIDofProvider)
Get all contract IDs of the user provided (as applicant) with a namespace provider.- Parameters:
applicantAccountID
- the applicant user.namespaceIDofProvider
- the ID of the namespace provider.- Returns:
- The info of the contracts of the user (as applicant) with the given namespace.
- Throws:
Exception
- if some exception occurs
-
getInfoOfSubsetOfInterfacesThatAreInActiveContractsForAccount
public Map<ContractID,InterfaceInContract> getInfoOfSubsetOfInterfacesThatAreInActiveContractsForAccount(AccountID accountID, Map<ContractID,InterfaceID> interfacesInContracts)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active and contain the given interfaces. Finally, returns the information of such interfaces per contract.- Parameters:
accountID
- the account IDinterfacesInContracts
- the multiple interfaces per contract to be retrieved- Returns:
- all the info related with the given interfaces in contract (if contracts are active and account is actually registered on them)
- Throws:
Exception
- if some exception occurs:
ContractNotExistException: if the contract does not exist
AccountNotRegisteredInContract: if the account is not registred in some of the contracts
ContractNotActiveException: if any of the contracts is not active
InterfaceNotInContractException: if any of the interfaces is not in the corresponding contract
-
getInfoOfMultipleContractsPerActiveContractsForAccount
public Map<ContractID,Tuple<Map<InterfaceID,InterfaceInContract>,Calendar>> getInfoOfMultipleContractsPerActiveContractsForAccount(AccountID accountID, Set<ContractID> contracts)
This method checks whether the provided account is registered in the contracts provided and such contracts are still active. Finally, returns the information of the interfaces in contract.- Parameters:
accountID
- the account IDcontracts
- the multiple contracts to be checked- Returns:
- all the info related with the given contracts (if contracts are active and account is actually registered to them)
- Throws:
Exception
- if some exception occurs:
ContractNotExistException: if the contract does not exist
AccountNotRegisteredInContract: if the account is not registred in some of the contracts
ContractNotActiveException: if any of the contracts is not active
-
getInfoOfMultipleInterfacesPerActiveContractsForAccount
public Map<ContractID,Tuple<Map<InterfaceID,InterfaceInContract>,Calendar>> getInfoOfMultipleInterfacesPerActiveContractsForAccount(AccountID accountID, Map<ContractID,HashSet<InterfaceID>> interfacesInContracts)
This method returns the information of those interfaces in (still active) contract having the given account registered on them. If the any of the conditions is not satisfied, no error is produced but the info of such interface in contract is not returned.- Parameters:
accountID
- the account IDinterfacesInContracts
- the interfaces per contract to be retrieved- Returns:
- from the given interfaces in contracts, the info of those that are in active contracts and account is registered
- Throws:
Exception
- if some exception occurs.
-
getDbHandler
public ContractManagerDB getDbHandler()
Method used for unit testing.- Returns:
- The db handler reference of this manager.
-
cleanCaches
public void cleanCaches()
Description copied from interface:CommonManager
Method that cleans the caches of the manager. Used on testing.- Specified by:
cleanCaches
in interfaceCommonManager
- Specified by:
cleanCaches
in classAbstractManager
-
-