How to use

getPermissions

method

in

com.icodici.universa.contract.Contract

public static List<Wallet> determineWallets(List<Contract> contracts) {
  Map<Object, Wallet> wallets = new HashMap<>();
  for (Contract contract : contracts) {
    if (contract.getPermissions() == null) continue;
    Collection<Permission> splitJoinCollection = contract.getPermissions().get("split_join");
    if (splitJoinCollection == null || splitJoinCollection.size() == 0) continue;
    Object split_join = splitJoinCollection.toArray()[0];
    if (!(split_join instanceof SplitJoinPermission)) continue;
    Object join_match_fields = ((SplitJoinPermission) split_join).getParams().get("join_match_fields");
    Object field;
    if (join_match_fields instanceof List) field = ((List) join_match_fields).get(0);
    else field = join_match_fields;
    Wallet wallet = wallets.get(field);
    if (wallet == null) {
      wallet = new Wallet();
    }
    wallet.addContract(contract);
    wallets.put(field, wallet);
  }
  return new ArrayList<>(wallets.values());
}

private boolean hasSimilarPermission(Contract contract, Collection<PublicKey> keys, boolean checkAllowance) {
  Collection<Permission> permissions = contract.getPermissions().get("split_join");
  if(permissions == null)
    return false;
  return permissions.stream().anyMatch(p -> {
    if(!((SplitJoinPermission)p).fieldName.equals(fieldName)) {
      return false;
    }
    if(!((SplitJoinPermission)p).minUnit.equals(minUnit)) {
      return false;
    }
    if(!((SplitJoinPermission)p).minValue.equals(minValue)) {
      return false;
    }
    if(((SplitJoinPermission)p).mergeFields.size() != mergeFields.size()) {
      return false;
    }
    if(!((SplitJoinPermission)p).mergeFields.containsAll(mergeFields)) {
      return false;
    }
    if(checkAllowance && !p.isAllowedFor(keys)) {
      return false;
    }
    return true;
  });
}

public void addPermission(Permission perm) {
  // We need to assign contract-unique id
  if (perm.getId() == null) {
    if (permissionIds == null) {
      permissionIds =
          getPermissions().values().stream()
              .map(x -> x.getId())
              .collect(Collectors.toSet());
    }
    while (true) {
      String id = Ut.randomString(6);
      if (!permissionIds.contains(id)) {
        permissionIds.add(id);
        perm.setId(id);
        break;
      }
    }
  }
  permissions.put(perm.getName(), perm);
}

private void excludePermittedChanges() throws Quantiser.QuantiserException {
  Set<PublicKey> checkingKeys = changed.getEffectiveKeys();
  for (String key : existing.getPermissions().keySet()) {
    Collection<Permission> permissions = existing.getPermissions().get(key);
    boolean permissionQuantized = false;
    for (Permission permission : permissions) {
      if (permission.isAllowedForKeys(checkingKeys)) {
        if(!permissionQuantized) {
          changed.checkApplicablePermissionQuantized(permission);
          permissionQuantized = true;
        }
        permission.checkChanges(existing, changed, stateChanges,revokingItems,checkingKeys);
      }
    }
  }
}

for(Permission permission : contract.getPermissions().values()) {
  if(permission instanceof ChangeOwnerPermission) {
    if(!(permission.getRole() instanceof RoleLink) || ((RoleLink)permission.getRole()).getRole() != contract.getOwner())

@Test(timeout = 90000)
public void declinePaymentAndPaymentWithRemovedPermissions() throws Exception {
  Set<PrivateKey> stepaPrivateKeys = new HashSet<>();
  stepaPrivateKeys.add(new PrivateKey(Do.read(ROOT_PATH + "keys/stepan_mamontov.private.unikey")));
  Contract uContract = getApprovedUContract();
  Contract modifiedU = uContract.createRevision(stepaPrivateKeys);
  modifiedU.getPermissions().remove("revoke");
  modifiedU.seal();
  // stepaPrivateKeys - is also U keys
  Parcel parcel =  ContractsService.createParcel(modifiedU, uContract, 150, stepaPrivateKeys);
  System.out.println("-------------");
  node.registerParcel(parcel);
  synchronized (uContractLock) {
    uContract = parcel.getPaymentContract();
  }
  waitAndCheckState(parcel, ItemState.UNDEFINED);
}

@Test(timeout = 90000)
public void checkPayment_missingDecrementPermission() throws Exception {
  Contract payment = checkPayment_preparePaymentContract(checkPayment_preparePrivateKeys());
  payment.getPermissions().remove("decrement_permission");
  boolean res = payment.paymentCheck(config.getUIssuerKeys());
  payment.traceErrors();
  assertFalse(res);
}

assertThat(c.getPermissions().getFirst("change_owner").getRole(), is(instanceOf(RoleLink.class)));
assertTrue(c.getPermissions().getFirst("change_owner").getRole().isAllowedForKeys(new HashSet(Do.listOf(ownerKey1))));
c.traceErrors();
assertTrue(c.check());
assertEquals(c, ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getContract());
Role cOwner = c.getOwner();
assertTrue (cOwner.isAllowedForKeys(new HashSet<>(Do.listOf(ownerKey1))));
assertEquals(c, ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getContract());
assertEquals(c.getOwner(), ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getRole());
assertEquals(c2, ((RoleLink) c2.getPermissions().getFirst("change_owner").getRole()).getContract());
assertEquals(c, ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getContract());
c2.setOwnerKey(ownerKey3);
assertNotEquals(c.getOwner(), c2.getOwner());
assertEquals(c.getOwner(), ((RoleLink) c.getPermissions().getFirst("change_owner").getRole()).getRole());

emittedContract.traceErrors();
assertEquals(emittedContract.getPermissions().get("split_join").size(), 1);
Binder splitJoinParams = emittedContract.getPermissions().get("split_join").iterator().next().getParams();
assertEquals(splitJoinParams.get("min_value"), "0.01");
assertEquals(splitJoinParams.get("min_unit"), "0.01");

assertThat(c.getPermissions().getFirst("change_owner").getRole(), is(instanceOf(RoleLink.class)));
assertTrue(c.getPermissions().getFirst("change_owner").getRole().isAllowedForKeys(new HashSet(Do.listOf(ownerKey1))));

c.addNewItems(jobCertificate);
Role r = c.getPermissions().getFirst("decrement_permission").getRole();
assertThat(r, is(instanceOf(ListRole.class)));
assertFalse(r.isAllowedForKeys(stepaPublicKeys));
assertTrue(r.isAllowedForKeys(stepaPublicKeys));
System.out.println("decrement permission :" + c.getPermissions().get("decrement_permission"));
c.traceErrors();
assertTrue(c.isOk());
assertEquals(c, (c.getPermissions().getFirst("decrement_permission").getRole()).getContract());
assertEquals(c2, c2.getPermissions().getFirst("decrement_permission").getRole().getContract());
c3.getStateData().set("units", c.getStateData().getIntOrThrow("units") - 1);
c3.addNewItems(jobCertificate);
assertEquals(c3, c3.getPermissions().getFirst("decrement_permission").getRole().getContract());

assertEquals(shareContract.getPermissions().get("split_join").size(), 1);
Binder splitJoinParams = shareContract.getPermissions().get("split_join").iterator().next().getParams();
assertEquals(splitJoinParams.get("min_value"), 1);
assertEquals(splitJoinParams.get("min_unit"), 1);

assertEquals(tokenContract.getPermissions().get("split_join").size(), 1);
Binder splitJoinParams = tokenContract.getPermissions().get("split_join").iterator().next().getParams();
assertEquals(splitJoinParams.get("min_value"), "0.01");
assertEquals(splitJoinParams.get("min_unit"), "0.01");

assertEquals(tokenContract.getPermissions().get("split_join").size(), 1);
Binder splitJoinParams = tokenContract.getPermissions().get("split_join").iterator().next().getParams();
assertEquals(splitJoinParams.get("min_value"), "0.01");
assertEquals(splitJoinParams.get("min_unit"), "0.01");

assertEquals(shareContract.getPermissions().get("split_join").size(), 1);
Binder splitJoinParams = shareContract.getPermissions().get("split_join").iterator().next().getParams();
assertEquals(splitJoinParams.get("min_value"), 1);
assertEquals(splitJoinParams.get("min_unit"), 1);

assertEquals(NSmartContract.SmartContractType.FOLLOWER1.name(), desContract.get("definition.extended_type"));
Multimap<String, Permission> permissions = desContract.getPermissions();
Collection<Permission> mdp = permissions.get("modify_data");
assertNotNull(mdp);
permissions = desContract.getPermissions();
mdp = permissions.get("modify_data");
assertNotNull(mdp);

assertEquals(NSmartContract.SmartContractType.FOLLOWER1.name(), smartContract.get("definition.extended_type"));
Multimap<String, Permission> permissions = smartContract.getPermissions();
Collection<Permission> mdp = permissions.get("modify_data");
assertNotNull(mdp);

assertEquals(NSmartContract.SmartContractType.FOLLOWER1.name(), smartContract.get("definition.extended_type"));
Multimap<String, Permission> permissions = smartContract.getPermissions();
Collection<Permission> mdp = permissions.get("modify_data");
assertNotNull(mdp);

assertEquals(NSmartContract.SmartContractType.SLOT1.name(), smartContract.get("definition.extended_type"));
Multimap<String, Permission> permissions = smartContract.getPermissions();
Collection<Permission> mdp = permissions.get("modify_data");
assertNotNull(mdp);

Multimap<String, Permission> permissions = smartContract.getPermissions();
Collection<Permission> mdp = permissions.get("modify_data");
assertNotNull(mdp);