Make null models declarative no-ops and use boolean map for user group membership

commons/src/main/java/com/deftdevs/bootstrapi/commons/model/UserModel.java

@@ -44,7 +44,7 @@ public class UserModel {
     private String password;
 
     @XmlElement
-    private Map<String, GroupModel> groups;
+    private Map<String, Boolean> groups;
 
     // Example instances for documentation and tests
 

commons/src/main/java/com/deftdevs/bootstrapi/commons/service/AbstractDirectoriesService.java

@@ -22,20 +22,34 @@
         final Map<String, AbstractDirectoryModel> resultDirectories = new LinkedHashMap<>();
 
         for (Map.Entry<String, ? extends AbstractDirectoryModel> directoryModelEntry : directoryModels.entrySet()) {
+            final String directoryName = directoryModelEntry.getKey();
             final AbstractDirectoryModel directoryModel = directoryModelEntry.getValue();
+            final AbstractDirectoryModel existingDirectoryModel = existingDirectoriesByName.get(directoryName);
+
+            if (directoryModel == null) {
+                // declarative no-op: null model + existing entity → return as-is;
+                // null model + missing entity → nothing to do
+                if (existingDirectoryModel != null) {
+                    resultDirectories.put(existingDirectoryModel.getName(), existingDirectoryModel);
+                }
+                continue;
+            }
+
+            if (directoryModel.getName() == null) {
+                directoryModel.setName(directoryName);
+            }
 
             // Check if directoryModel is not an instance of any supported class
             if (getSupportedClassesForUpdate().stream().noneMatch(clazz -> clazz.isInstance(directoryModel))) {
                 throw new BadRequestException(String.format("Updating directory type '%s' is not supported (yet)", directoryModel.getClass()));
             }
 
-            final AbstractDirectoryModel existingDirectoryModel = existingDirectoriesByName.get(directoryModelEntry.getKey());
             final AbstractDirectoryModel resultDirectoryModel;
 
             if (existingDirectoryModel != null) {
-                resultDirectoryModel = setDirectory(existingDirectoryModel.getId(), directoryModelEntry.getValue());
+                resultDirectoryModel = setDirectory(existingDirectoryModel.getId(), directoryModel);
             } else {
-                resultDirectoryModel = addDirectory(directoryModelEntry.getValue());
+                resultDirectoryModel = addDirectory(directoryModel);
             }
 
             resultDirectories.put(resultDirectoryModel.getName(), resultDirectoryModel);

commons/src/main/java/com/deftdevs/bootstrapi/commons/service/DefaultApplicationLinksServiceImpl.java

@@ -106,6 +106,15 @@ public Map<String, ApplicationLinkModel> setApplicationLinks(
             final String name = applicationLinkModelEntry.getKey();
             final ApplicationLinkModel applicationLinkModel = applicationLinkModelEntry.getValue();
 
+            // declarative no-op: null model means "leave this entry untouched"
+            if (applicationLinkModel == null) {
+                continue;
+            }
+
+            if (applicationLinkModel.getName() == null) {
+                applicationLinkModel.setName(name);
+            }
+
             if (linkModelMap.containsKey(name)) {
                 setApplicationLink(linkModelMap.get(name).getUuid(), applicationLinkModel);
             } else {

commons/src/test/java/com/deftdevs/bootstrapi/commons/service/DefaultApplicationLinkServiceTest.java

@@ -45,6 +45,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.anyBoolean;
 import static org.mockito.Mockito.doNothing;
@@ -108,6 +109,34 @@ void testGetApplicationLink() throws URISyntaxException, NoAccessException, NoSu
         assertEquals(applicationLinkModel, appLinkResponse);
     }
 
+    @Test
+    void testSetApplicationLinksNullModelMissingLinkSkipsEntry() {
+        doReturn(Collections.emptyList()).when(mutatingApplicationLinkService).getApplicationLinks();
+        final Map<String, ApplicationLinkModel> applicationLinkModels = Collections.singletonMap("missing-link", null);
+        assertTrue(applicationLinkService.setApplicationLinks(applicationLinkModels).isEmpty());
+    }
+
+    @Test
+    void testSetApplicationLinksNullNameUsesMapKey()
+            throws URISyntaxException, NoAccessException, NoSuchApplinkException, TypeNotInstalledException {
+
+        final ApplicationLink applicationLink = createApplicationLink();
+        final ApplicationLinkModel applicationLinkModel = createApplicationLinkModel();
+        final String mapKey = applicationLinkModel.getName();
+        applicationLinkModel.setName(null);
+        final Map<String, ApplicationLinkModel> applicationLinkModels = Collections.singletonMap(mapKey, applicationLinkModel);
+        doReturn(Collections.singletonList(applicationLink)).when(mutatingApplicationLinkService).getApplicationLinks();
+        doReturn(applicationLink).when(mutatingApplicationLinkService).getApplicationLink(any());
+        doReturn(applicationLink).when(mutatingApplicationLinkService).addApplicationLink(any(), any(), any());
+        doReturn(new DefaultApplicationType()).when(typeAccessor).getApplicationType(any());
+        doReturn(OAuthConfig.createDisabledConfig()).when(applicationLinksAuthConfigHelper).getOutgoingOAuthConfig(any());
+        doReturn(OAuthConfig.createDisabledConfig()).when(applicationLinksAuthConfigHelper).getIncomingOAuthConfig(any());
+        doReturn(createApplinkStatus(applicationLink, AVAILABLE)).when(applinkStatusService).getApplinkStatus(any());
+
+        applicationLinkService.setApplicationLinks(applicationLinkModels);
+        assertEquals(mapKey, applicationLinkModel.getName());
+    }
+
     @Test
     void testSetApplicationLinks()
             throws URISyntaxException, NoAccessException, NoSuchApplinkException, TypeNotInstalledException {

confluence/Models/UserModel.md

@@ -10,7 +10,7 @@
 | **email** | **String** |  | [optional] [default to null] |
 | **active** | **Boolean** |  | [optional] [default to null] |
 | **password** | **String** |  | [optional] [default to null] |
-| **groups** | [**Map**](GroupModel.md) |  | [optional] [default to null] |
+| **groups** | **Map** |  | [optional] [default to null] |
 
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
 

crowd/Models/UserModel.md

@@ -10,7 +10,7 @@
 | **email** | **String** |  | [optional] [default to null] |
 | **active** | **Boolean** |  | [optional] [default to null] |
 | **password** | **String** |  | [optional] [default to null] |
-| **groups** | [**Map**](GroupModel.md) |  | [optional] [default to null] |
+| **groups** | **Map** |  | [optional] [default to null] |
 
 [[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)
 

crowd/src/main/java/com/deftdevs/bootstrapi/crowd/config/ServiceConfig.java

@@ -93,8 +93,7 @@ public TrustedProxiesService trustedProxiesService() {
     public UsersService usersService() {
         return new UsersServiceImpl(
                 atlassianConfig.crowdService(),
-                atlassianConfig.directoryManager(),
-                groupsService());
+                atlassianConfig.directoryManager());
     }
 
 }

crowd/src/main/java/com/deftdevs/bootstrapi/crowd/service/ApplicationsServiceImpl.java

@@ -64,10 +64,27 @@
         final Map<String, ApplicationModel> resultApplicationModels = new LinkedHashMap<>();
 
         for (Map.Entry<String, ApplicationModel> applicationModelEntry : applicationModels.entrySet()) {
+            final String applicationName = applicationModelEntry.getKey();
             final ApplicationModel applicationModel = applicationModelEntry.getValue();
 
+            if (applicationModel == null) {
+                // declarative no-op: null model + existing entity → return as-is;
+                // null model + missing entity → nothing to do
+                try {
+                    final Application existingApplication = applicationManager.findByName(applicationName);
+                    resultApplicationModels.put(applicationName, getApplication(existingApplication.getId()));
+                } catch (ApplicationNotFoundException ignored) {
+                    // nothing to do
+                }
+                continue;
+            }
+
+            if (applicationModel.getName() == null) {
+                applicationModel.setName(applicationName);
+            }
+
             try {
-                final Application application = applicationManager.findByName(applicationModelEntry.getKey());
+                final Application application = applicationManager.findByName(applicationName);
                 final ApplicationModel updatedApplicationModel = setApplication(application.getId(), applicationModel);
                 resultApplicationModels.put(updatedApplicationModel.getName(), updatedApplicationModel);
             } catch (ApplicationNotFoundException ignored) {

crowd/src/main/java/com/deftdevs/bootstrapi/crowd/service/GroupsServiceImpl.java

@@ -49,28 +49,46 @@ public GroupModel createGroup(
             final long directoryId,
             final GroupModel groupModel) {
 
-        if (groupModel.getName() == null) {
+        if (groupModel == null) {
+            throw new BadRequestException("Cannot create group, a full group model is required");
+        }
+
+        return createGroup(directoryId, groupModel.getName(), groupModel);
+    }
+
+    GroupModel createGroup(
+            final long directoryId,
+            final String groupName,
+            final GroupModel groupModel) {
+
+        final String effectiveGroupName = groupModel.getName() != null ? groupModel.getName() : groupName;
+
+        if (effectiveGroupName == null) {
             throw new BadRequestException("Cannot create group, group name is required");
         }
 
-        final Group existingGroup = findGroup(directoryId, groupModel.getName());
+        if (groupName != null && !effectiveGroupName.equals(groupName)) {
+            throw new BadRequestException("Cannot create group, two different group names provided");
+        }
+
+        final Group existingGroup = findGroup(directoryId, effectiveGroupName);
 
         if (existingGroup != null) {
-            throw new BadRequestException(String.format("Group '%s' already exists", groupModel.getName()));
+            throw new BadRequestException(String.format("Group '%s' already exists", effectiveGroupName));
         }
 
-        final GroupTemplate groupTemplate = new GroupTemplate(groupModel.getName(), directoryId);
+        final GroupTemplate groupTemplate = new GroupTemplate(effectiveGroupName, directoryId);
         groupTemplate.setDescription(groupModel.getDescription());
         groupTemplate.setActive(groupModel.getActive() == null || groupModel.getActive());
 
         try {
             return GroupModelUtil.toGroupModel(directoryManager.addGroup(directoryId, groupTemplate));
         } catch (DirectoryPermissionException | InvalidGroupException e) {
             // A permission exception should only happen if we try adding the group
-            // a user in a read-only directory, so treat this as a bad request
+            // in a read-only directory, so treat this as a bad request
             throw new BadRequestException(e);
         } catch (com.atlassian.crowd.exception.DirectoryNotFoundException | OperationFailedException e) {
-            // At this point, we know the group exists, thus directory not found
+            // At this point, we know the directory exists, thus directory not found
             // should never happen, so if it does, treat it as an internal server error
             throw new InternalServerErrorException(e);
         }
@@ -109,9 +127,10 @@ public GroupModel setGroup(
 
         if (group == null) {
             if (groupModel == null) {
-                throw new GroupNotFoundException(groupName);
+                // declarative no-op: null model + missing entity → nothing to do
+                return null;
             }
-            return createGroup(directoryId, groupModel);
+            return createGroup(directoryId, groupName, groupModel);
         }
 
         if (groupModel == null) {
@@ -132,8 +151,17 @@ public Map<String, GroupModel> setGroups(
 
         final Map<String, GroupModel> resultGroupModels = new LinkedHashMap<>();
         for (Map.Entry<String, GroupModel> entry : groupModels.entrySet()) {
-            final GroupModel resultGroupModel = setGroup(directoryId, entry.getKey(), entry.getValue());
-            resultGroupModels.put(resultGroupModel.getName(), resultGroupModel);
+            final String groupName = entry.getKey();
+            final GroupModel groupModel = entry.getValue();
+
+            if (groupModel != null && groupModel.getName() == null) {
+                groupModel.setName(groupName);
+            }
+
+            final GroupModel resultGroupModel = setGroup(directoryId, groupName, groupModel);
+            if (resultGroupModel != null) {
+                resultGroupModels.put(resultGroupModel.getName(), resultGroupModel);
+            }
         }
         return resultGroupModels;
     }