public void shareEntity()

in custos-core/sharing-core-impl/src/main/java/org/apache/custos/sharing/core/impl/SharingImpl.java [894:1015]
92 lines of code
16 McCabe index (conditional complexity)

    public void shareEntity(String tenantId, String entityId, String permissionType, List<String> userIds,
                            boolean cascade, String ownerType, String sharedBy) throws CustosSharingException {

        String internalPermissionId = permissionType + "@" + tenantId;


        String internalEntityId = entityId + "@" + tenantId;


        Optional<org.apache.custos.sharing.core.persistance.model.PermissionType> optionalPermissionType =
                permissionTypeRepository.findById(internalPermissionId);

        if (optionalPermissionType.isEmpty()) {
            String msg = "Permission type not found";
            LOGGER.error(msg);
            throw new CustosSharingException(msg);
        }

        Optional<org.apache.custos.sharing.core.persistance.model.Entity> entityOptional =
                entityRepository.findById(internalEntityId);

        if (entityOptional.isEmpty()) {
            String msg = " Entity with Id " + entityId + "  not found";
            LOGGER.error(msg);
            throw new CustosSharingException(msg);
        }


        Optional<org.apache.custos.sharing.core.persistance.model.PermissionType> optionalOwnerPermissionType =
                permissionTypeRepository.findByExternalIdAndTenantId(Constants.OWNER, tenantId);

        if (optionalOwnerPermissionType.get().getId().equals(internalPermissionId)) {
            String msg = "Owner permission type can not be assigned";
            LOGGER.error(msg);
            throw new CustosSharingException(msg);
        }

        String sharingType = null;
        List<Sharing> sharings = new ArrayList<>();

        if (cascade) {
            sharingType = Constants.DIRECT_CASCADING;
        } else {
            sharingType = Constants.DIRECT_NON_CASCADING;
        }


        for (String userId : userIds) {

            Sharing sharing = SharingMapper.createSharing(optionalPermissionType.get(),
                    entityOptional.get(), entityOptional.get(), userId, ownerType, sharingType, sharedBy,
                    tenantId);
            sharings.add(sharing);
        }

        if (cascade) {
            List<Sharing> childSharings = new ArrayList<>();
            childSharings = getAllSharingForChildEntities(entityOptional.get(), entityOptional.get(), userIds, tenantId,
                    optionalPermissionType.get(), childSharings, ownerType,
                    Constants.INDIRECT_CASCADING, sharedBy);
            if (!childSharings.isEmpty()) {
                sharings.addAll(childSharings);
            }
        }


        List<Sharing> effectiveSharings = new ArrayList<>();
        if (!sharings.isEmpty()) {
            sharings.forEach(shr -> {
                Optional<Sharing> sharing = sharingRepository.findById(shr.getId());
                if (sharing.isEmpty()) {
                    effectiveSharings.add(shr);
                }

            });

        }

        if (!effectiveSharings.isEmpty()) {
            sharingRepository.saveAll(effectiveSharings);

            //revoke other permissions
            for (String userId : userIds) {
                List<org.apache.custos.sharing.core.persistance.model.PermissionType> existingPermissionTypes =
                        permissionTypeRepository.findAllByTenantId(tenantId);

                existingPermissionTypes.forEach(permission -> {
                    if (!(permission.getExternalId().equals(Constants.OWNER) || permission.getId().equals(internalPermissionId))) {
                        sharingRepository.
                                deleteAllByEntityIdAndPermissionTypeIdAndAssociatingIdAndTenantIdAndInheritedParentId(
                                        internalEntityId,
                                        permission.getId(),
                                        userId,
                                        tenantId,
                                        internalEntityId);
                        sharingRepository.deleteAllByInheritedParentIdAndPermissionTypeIdAndTenantIdAndSharingTypeAndAssociatingId(
                                internalEntityId,
                                permission.getId(),
                                tenantId,
                                Constants.INDIRECT_CASCADING,
                                userId);
                    }
                });
            }


            List<String> checkTypes = new ArrayList<>();
            checkTypes.add(Constants.INDIRECT_CASCADING);
            checkTypes.add(Constants.DIRECT_CASCADING);
            checkTypes.add(Constants.DIRECT_NON_CASCADING);

            List<Sharing> newSharings = sharingRepository.findAllByEntityAndSharingType(tenantId,
                    internalEntityId, checkTypes);
            org.apache.custos.sharing.core.persistance.model.Entity entity = entityOptional.get();
            if (newSharings != null && newSharings.size() > 0) {
                entity.setSharedCount(newSharings.size());
                entityRepository.save(entity);
            }


        }
    }