How to use

isPermitted

method

in

com.icodici.universa.contract.Contract

public boolean isPermitted(String permissionName, PublicKey... keys) throws Quantiser.QuantiserException {
  HashSet<PublicKey> keysSet = new HashSet<>(Arrays.asList(keys));
  return this.currentContract.isPermitted(permissionName, keysSet);
}

/**
 * Checks if permission of given type exists and is allowed for given key record
 * @param permissionName type of permission to check for
 * @param keyRecord key record to check permission with
 * @return permission allowed for keyRecord is found
 * @throws Quantiser.QuantiserException if quantas limit was reached during check
 */
public boolean isPermitted(String permissionName, KeyRecord keyRecord) throws Quantiser.QuantiserException {
  return isPermitted(permissionName, keyRecord.getPublicKey());
}

private void checkRevokePermissions(Set<Contract> revokes) throws Quantiser.QuantiserException {
  for (Contract rc : revokes) {
    //check if revoking parent => no permission is needed
    if(getParent() != null && rc.getId().equals(getParent()))
      continue;
    if (!rc.isPermitted("revoke", getEffectiveKeys()))
      addError(FORBIDDEN, "revokingItem", "revocation not permitted for item " + rc.getId());
  }
}

} else if(contract.getStateData().containsKey("transaction_units")) {
  if(!contract.isPermitted("decrement_permission",publicKeys)) {
    addError(Errors.NOT_SIGNED.name(),contractPath,"contract is not operational for given keys (including the one in the wallet already)");
    continue;

assertTrue(emittedContract.isPermitted("revoke", ownerPublicKeys));
assertTrue(emittedContract.isPermitted("revoke", issuerPublicKeys));
assertTrue(emittedContract.isPermitted("change_owner", ownerPublicKeys));
assertFalse(emittedContract.isPermitted("change_owner", issuerPublicKeys));
assertTrue(emittedContract.isPermitted("split_join", ownerPublicKeys));
assertFalse(emittedContract.isPermitted("split_join", issuerPublicKeys));

@Test
public void goodNotary() throws Exception {
  Set<PrivateKey> martyPrivateKeys = new HashSet<>();
  Set<PrivateKey> stepaPrivateKeys = new HashSet<>();
  Set<PublicKey> martyPublicKeys = new HashSet<>();
  Set<PublicKey> stepaPublicKeys = new HashSet<>();
  martyPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/marty_mcfly.private.unikey")));
  stepaPrivateKeys.add(new PrivateKey(Do.read(rootPath + "keys/stepan_mamontov.private.unikey")));
  for (PrivateKey pk : stepaPrivateKeys)
    stepaPublicKeys.add(pk.getPublicKey());
  for (PrivateKey pk : martyPrivateKeys)
    martyPublicKeys.add(pk.getPublicKey());
  Contract notaryContract = ContractsService.createNotaryContract(martyPrivateKeys, stepaPublicKeys);
  notaryContract.check();
  notaryContract.traceErrors();
  assertTrue(notaryContract.isOk());
  assertTrue(notaryContract.getOwner().isAllowedForKeys(stepaPublicKeys));
  assertTrue(notaryContract.getIssuer().isAllowedForKeys(martyPrivateKeys));
  assertTrue(notaryContract.getCreator().isAllowedForKeys(martyPrivateKeys));
  assertFalse(notaryContract.getOwner().isAllowedForKeys(martyPrivateKeys));
  assertFalse(notaryContract.getIssuer().isAllowedForKeys(stepaPublicKeys));
  assertFalse(notaryContract.getCreator().isAllowedForKeys(stepaPublicKeys));
  assertTrue(notaryContract.getExpiresAt().isAfter(ZonedDateTime.now().plusMonths(3)));
  assertTrue(notaryContract.getCreatedAt().isBefore(ZonedDateTime.now()));
  assertTrue(notaryContract.isPermitted("revoke", stepaPublicKeys));
  assertTrue(notaryContract.isPermitted("revoke", martyPublicKeys));
  assertTrue(notaryContract.isPermitted("change_owner", stepaPublicKeys));
  assertFalse(notaryContract.isPermitted("change_owner", martyPublicKeys));
}

assertTrue(notaryContract.getCreatedAt().isBefore(ZonedDateTime.now()));
assertTrue(notaryContract.isPermitted("revoke", ownerPublicKeys));
assertTrue(notaryContract.isPermitted("revoke", issuerPublicKeys));
assertTrue(notaryContract.isPermitted("change_owner", ownerPublicKeys));
assertFalse(notaryContract.isPermitted("change_owner", issuerPublicKeys));

assertEquals(((List)splitJoinParams.get("join_match_fields")).get(0), "state.origin");
assertTrue(shareContract.isPermitted("revoke", ownerPublicKeys));
assertTrue(shareContract.isPermitted("revoke", issuerPublicKeys));
assertTrue(shareContract.isPermitted("change_owner", ownerPublicKeys));
assertFalse(shareContract.isPermitted("change_owner", issuerPublicKeys));
assertTrue(shareContract.isPermitted("split_join", ownerPublicKeys));
assertFalse(shareContract.isPermitted("split_join", issuerPublicKeys));

assertEquals(((List)splitJoinParams.get("join_match_fields")).get(0), "state.origin");
assertTrue(tokenContract.isPermitted("revoke", ownerPublicKeys));
assertTrue(tokenContract.isPermitted("revoke", issuerPublicKeys));
assertTrue(tokenContract.isPermitted("change_owner", ownerPublicKeys));
assertFalse(tokenContract.isPermitted("change_owner", issuerPublicKeys));
assertTrue(tokenContract.isPermitted("split_join", ownerPublicKeys));
assertFalse(tokenContract.isPermitted("split_join", issuerPublicKeys));

assertTrue(tokenContract.isPermitted("revoke", stepaPublicKeys));
assertTrue(tokenContract.isPermitted("revoke", martyPublicKeys));
assertTrue(tokenContract.isPermitted("change_owner", stepaPublicKeys));
assertFalse(tokenContract.isPermitted("change_owner", martyPublicKeys));
assertTrue(tokenContract.isPermitted("split_join", stepaPublicKeys));
assertFalse(tokenContract.isPermitted("split_join", martyPublicKeys));

assertTrue(shareContract.isPermitted("revoke", stepaPublicKeys));
assertTrue(shareContract.isPermitted("revoke", martyPublicKeys));
assertTrue(shareContract.isPermitted("change_owner", stepaPublicKeys));
assertFalse(shareContract.isPermitted("change_owner", martyPublicKeys));
assertTrue(shareContract.isPermitted("split_join", stepaPublicKeys));
assertFalse(shareContract.isPermitted("split_join", martyPublicKeys));

if (!isPermitted("decrement_permission", getSealedByKeys())) {
  res = false;
  addError(Errors.BAD_VALUE, "decrement_permission is missing");

  assertTrue(c.isPermitted("change_owner", owner));
  assertFalse(c.isPermitted("change_owner", issuer));
  assertTrue(c.isPermitted("revoke", owner));
  assertFalse(c.isPermitted("revoke", issuer));
} catch (Quantiser.QuantiserException e) {
  e.printStackTrace();

assertTrue(notaryContract.getCreatedAt().isBefore(ZonedDateTime.now()));
assertTrue(notaryContract.isPermitted("revoke", stepaPublicKeys));
assertTrue(notaryContract.isPermitted("revoke", martyPublicKeys));
assertTrue(notaryContract.isPermitted("change_owner", stepaPublicKeys));
assertFalse(notaryContract.isPermitted("change_owner", martyPublicKeys));

assertTrue(notaryContract.getCreatedAt().isBefore(ZonedDateTime.now()));
assertTrue(notaryContract.isPermitted("revoke", notariusPublicKeys));
assertTrue(notaryContract.isPermitted("revoke", issuerPublicKeys));
assertTrue(notaryContract.isPermitted("change_owner", notariusPublicKeys));
assertFalse(notaryContract.isPermitted("change_owner", issuerPublicKeys));

assertTrue(notaryContract.isPermitted("revoke", stepaPublicKeys));
assertTrue(notaryContract.isPermitted("revoke", martyPublicKeys));
assertTrue(notaryContract.isPermitted("change_owner", stepaPublicKeys));
assertFalse(notaryContract.isPermitted("change_owner", martyPublicKeys));