[AB-137] fixing occurrences for templates in cases entities do not exist anymore

fixing feature mode retrieval to adapt to lowercase
fixing disable exp role creation and retrieval
removing ansible code

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/commands/ListDisabledExperienceRoles.java

@@ -19,6 +19,7 @@ import dev.sheldan.abstracto.experience.models.database.ADisabledExpRole;
 import dev.sheldan.abstracto.experience.models.templates.DisabledExperienceRolesModel;
 import dev.sheldan.abstracto.experience.service.management.DisabledExpRoleManagementService;
 import net.dv8tion.jda.api.entities.Message;
+import net.dv8tion.jda.api.entities.Role;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -51,10 +52,14 @@ public class ListDisabledExperienceRoles extends AbstractConditionableCommand {
         List<ADisabledExpRole> disabledRolesForServer = disabledExpRoleManagementService.getDisabledRolesForServer(server);
         DisabledExperienceRolesModel disabledExperienceRolesModel = (DisabledExperienceRolesModel) ContextConverter.fromCommandContext(commandContext, DisabledExperienceRolesModel.class);
         disabledRolesForServer.forEach(aDisabledExpRole -> {
+            Role jdaRole = null;
+            if(!aDisabledExpRole.getRole().getDeleted()) {
+                jdaRole = roleService.getRoleFromGuild(aDisabledExpRole.getRole());
+            }
             FullRole role = FullRole
                     .builder()
                     .role(aDisabledExpRole.getRole())
-                    .serverRole(roleService.getRoleFromGuild(aDisabledExpRole.getRole()))
+                    .serverRole(jdaRole)
                     .build();
             disabledExperienceRolesModel.getRoles().add(role);
         });

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/converter/LeaderBoardModelConverter.java

@@ -4,11 +4,14 @@ import dev.sheldan.abstracto.core.models.database.AUserInAServer;
 import dev.sheldan.abstracto.core.service.MemberService;
 import dev.sheldan.abstracto.experience.models.LeaderBoard;
 import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
+import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
+import dev.sheldan.abstracto.experience.service.management.UserExperienceManagementService;
 import lombok.extern.slf4j.Slf4j;
 import net.dv8tion.jda.api.entities.Member;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -24,6 +27,12 @@ public class LeaderBoardModelConverter {
     @Autowired
     private MemberService memberService;
 
+    @Autowired
+    private UserExperienceManagementService userExperienceManagementService;
+
+    @Autowired
+    private LeaderBoardModelConverter self;
+
     /**
      * Converts the complete {@link LeaderBoard leaderBoard} into a list of {@link LeaderBoardEntryModel leaderbaordEntryModels} which contain additional
      * information available for rendering the leader board ({@link Member member} reference and more)
@@ -50,13 +59,21 @@ public class LeaderBoardModelConverter {
      */
     public CompletableFuture<LeaderBoardEntryModel> fromLeaderBoardEntry(LeaderBoardEntry leaderBoardEntry) {
         AUserInAServer entryUser = leaderBoardEntry.getExperience().getUser();
-        return memberService.getMemberInServerAsync(entryUser.getServerReference().getId(), entryUser.getUserReference().getId()).thenApply(member ->
-            LeaderBoardEntryModel
-                    .builder()
-                    .experience(leaderBoardEntry.getExperience())
-                    .member(member).rank(leaderBoardEntry.getRank())
-                    .rank(leaderBoardEntry.getRank())
-                    .build()
-        );
+        Long userInServerId = leaderBoardEntry.getExperience().getUser().getUserInServerId();
+        Integer rank = leaderBoardEntry.getRank();
+        return memberService.getMemberInServerAsync(entryUser.getServerReference().getId(), entryUser.getUserReference().getId())
+            .thenApply(member -> self.buildLeaderBoardModel(userInServerId, member, rank))
+                .exceptionally(throwable -> self.buildLeaderBoardModel(userInServerId, null, rank));
+    }
+
+    @Transactional
+    public LeaderBoardEntryModel buildLeaderBoardModel(Long userInServerId, Member member, Integer rank) {
+        AUserExperience experience = userExperienceManagementService.findByUserInServerId(userInServerId);
+        return LeaderBoardEntryModel
+                .builder()
+                .experience(experience)
+                .member(member)
+                .rank(rank)
+                .build();
     }
 }

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/main/java/dev/sheldan/abstracto/experience/service/management/DisabledExpRoleManagementServiceBean.java

@@ -21,6 +21,7 @@ public class DisabledExpRoleManagementServiceBean implements DisabledExpRoleMana
     public ADisabledExpRole setRoleToBeDisabledForExp(ARole role) {
         ADisabledExpRole newRole = ADisabledExpRole
                 .builder()
+                .id(role.getId())
                 .role(role)
                 .build();
         log.info("Adding disabled exp role {} for server {}.", role.getId(), role.getServer().getId());
@@ -39,7 +40,7 @@ public class DisabledExpRoleManagementServiceBean implements DisabledExpRoleMana
 
     @Override
     public boolean isExperienceDisabledForRole(ARole role) {
-        return disabledExpRoleRepository.existsByRole(role);
+        return disabledExpRoleRepository.existsById(role.getId());
     }
 
 

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/commands/ListDisabledExperienceRolesTest.java

@@ -44,10 +44,12 @@ public class ListDisabledExperienceRolesTest {
     @Mock
     private ServerManagementService serverManagementService;
 
+    @Mock
+    private AServer server;
+
     @Test
     public void testCommandExecutionNoRolesFound() {
         CommandContext context = CommandTestUtilities.getNoParameters();
-        AServer server = Mockito.mock(AServer.class);
         when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
         when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(new ArrayList<>());
         when(channelService.sendEmbedTemplateInTextChannelList(eq("list_disabled_experience_roles"),
@@ -60,14 +62,20 @@ public class ListDisabledExperienceRolesTest {
     @Test
     public void testCommandExecutionRolesFound() {
         CommandContext context = CommandTestUtilities.getNoParameters();
-        AServer server = Mockito.mock(AServer.class);
         ADisabledExpRole disabledExpRole1 = Mockito.mock(ADisabledExpRole.class);
         ADisabledExpRole disabledExpRole2 = Mockito.mock(ADisabledExpRole.class);
         when(disabledExpRoleManagementService.getDisabledRolesForServer(server)).thenReturn(Arrays.asList(disabledExpRole1, disabledExpRole2));
         Role role1 = Mockito.mock(Role.class);
         Role role2 = Mockito.mock(Role.class);
-        when(roleService.getRoleFromGuild(disabledExpRole1.getRole())).thenReturn(role1);
-        when(roleService.getRoleFromGuild(disabledExpRole2.getRole())).thenReturn(role2);
+
+        ARole aRole = Mockito.mock(ARole.class);
+        ARole aRole2 = Mockito.mock(ARole.class);
+        when(roleService.getRoleFromGuild(aRole)).thenReturn(role1);
+        when(roleService.getRoleFromGuild(aRole2)).thenReturn(role2);
+        when(aRole.getDeleted()).thenReturn(false);
+        when(aRole2.getDeleted()).thenReturn(false);
+        when(disabledExpRole1.getRole()).thenReturn(aRole);
+        when(disabledExpRole2.getRole()).thenReturn(aRole2);
         when(serverManagementService.loadServer(context.getGuild())).thenReturn(server);
         when(channelService.sendEmbedTemplateInTextChannelList(eq("list_disabled_experience_roles"),
                 any(DisabledExperienceRolesModel.class), eq(context.getChannel()))).thenReturn(CommandTestUtilities.messageFutureList());

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/converter/LeaderBoardModelConverterTest.java

@@ -9,7 +9,6 @@ import dev.sheldan.abstracto.experience.models.LeaderBoardEntry;
 import dev.sheldan.abstracto.experience.models.database.AUserExperience;
 import dev.sheldan.abstracto.experience.models.templates.LeaderBoardEntryModel;
 import net.dv8tion.jda.api.entities.Member;
-import net.dv8tion.jda.api.entities.User;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -33,58 +32,60 @@ public class LeaderBoardModelConverterTest {
     @Mock
     private MemberService memberService;
 
+    @Mock
+    private LeaderBoardModelConverter self;
+
     private static final Long SERVER_ID = 4L;
     private static final Long USER_ID = 5L;
     private static final Long USER_ID_2 = 6L;
+    private static final Long USER_IN_SERVER_ID = 7L;
+    private static final Long USER_IN_SERVER_ID_2 = 8L;
 
     @Test
     public void testFromLeaderBoard() {
         Integer firstRank = 1;
-        Long firstExperience = 1L;
 
-        LeaderBoardEntry entry = getEntry(firstExperience, firstRank, USER_ID);
+        LeaderBoardEntry entry = getEntry(firstRank, USER_ID, USER_IN_SERVER_ID);
         Integer secondRank = 2;
-        Long secondExperience = 2L;
-        LeaderBoardEntry entry2 = getEntry(secondExperience, secondRank, USER_ID_2);
+        LeaderBoardEntryModel firstEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
+        LeaderBoardEntryModel secondEntryModel = Mockito.mock(LeaderBoardEntryModel.class);
+        LeaderBoardEntry entry2 = getEntry(secondRank, USER_ID_2, USER_IN_SERVER_ID_2);
         List<LeaderBoardEntry> entries = Arrays.asList(entry, entry2);
         LeaderBoard leaderBoard = Mockito.mock(LeaderBoard.class);
         when(leaderBoard.getEntries()).thenReturn(entries);
         Member member = Mockito.mock(Member.class);
         when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
         when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID_2)).thenReturn(CompletableFuture.completedFuture(member));
+        when(self.buildLeaderBoardModel(USER_IN_SERVER_ID, member, firstRank)).thenReturn(firstEntryModel);
+        when(self.buildLeaderBoardModel(USER_IN_SERVER_ID_2, member, secondRank)).thenReturn(secondEntryModel);
         List<CompletableFuture<LeaderBoardEntryModel>> leaderBoardEntryModels = testUnit.fromLeaderBoard(leaderBoard);
         LeaderBoardEntryModel firstEntry = leaderBoardEntryModels.get(0).join();
-        Assert.assertEquals(firstRank, firstEntry.getRank());
-        Assert.assertEquals(firstExperience, firstEntry.getExperience().getExperience());
+        Assert.assertEquals(firstEntryModel, firstEntry);
         LeaderBoardEntryModel secondEntry = leaderBoardEntryModels.get(1).join();
-        Assert.assertEquals(secondRank, secondEntry.getRank());
-        Assert.assertEquals(secondExperience, secondEntry.getExperience().getExperience());
+        Assert.assertEquals(secondEntryModel, secondEntry);
         Assert.assertEquals(entries.size(), leaderBoardEntryModels.size());
     }
 
     @Test
     public void testFromEntry() {
         Integer rank = 2;
-        LeaderBoardEntry entry = getEntry(1L, rank, USER_ID);
+        LeaderBoardEntry entry = getEntry(rank, USER_ID, USER_IN_SERVER_ID);
         Member member = Mockito.mock(Member.class);
-        User user = Mockito.mock(User.class);
-        when(user.getIdLong()).thenReturn(USER_ID);
-        when(member.getUser()).thenReturn(user);
+        LeaderBoardEntryModel entryModelMock = Mockito.mock(LeaderBoardEntryModel.class);
         when(memberService.getMemberInServerAsync(SERVER_ID, USER_ID)).thenReturn(CompletableFuture.completedFuture(member));
+        when(self.buildLeaderBoardModel(USER_IN_SERVER_ID, member, rank)).thenReturn(entryModelMock);
         CompletableFuture<LeaderBoardEntryModel> leaderBoardEntryModel = testUnit.fromLeaderBoardEntry(entry);
         LeaderBoardEntryModel entryModel = leaderBoardEntryModel.join();
-        Assert.assertEquals(rank, entryModel.getRank());
-        Assert.assertEquals(USER_ID, entryModel.getExperience().getUser().getUserReference().getId());
-        Assert.assertEquals(USER_ID.longValue(), entryModel.getMember().getUser().getIdLong());
+        Assert.assertEquals(entryModelMock, entryModel);
     }
 
-    private LeaderBoardEntry getEntry(Long experienceCount, Integer rank, Long userId) {
+    private LeaderBoardEntry getEntry(Integer rank, Long userId, Long userInServerId) {
         AUserExperience experience = Mockito.mock(AUserExperience.class);
-        when(experience.getExperience()).thenReturn(experienceCount);
         AUserInAServer userInAServer = Mockito.mock(AUserInAServer.class);
         when(experience.getUser()).thenReturn(userInAServer);
         AUser user = Mockito.mock(AUser.class);
         when(userInAServer.getUserReference()).thenReturn(user);
+        when(userInAServer.getUserInServerId()).thenReturn(userInServerId);
         when(user.getId()).thenReturn(userId);
         AServer server = Mockito.mock(AServer.class);
         when(server.getId()).thenReturn(SERVER_ID);

abstracto-application/abstracto-modules/experience-tracking/experience-tracking-impl/src/test/java/dev/sheldan/abstracto/experience/service/management/DisabledExpRoleManagementServiceBeanTest.java

@@ -39,10 +39,12 @@ public class DisabledExpRoleManagementServiceBeanTest {
     @Test
     public void testIfRoleIsDisabled() {
         ARole aRole = Mockito.mock(ARole.class);
-        when(disabledExpRoleRepository.existsByRole(aRole)).thenReturn(true);
+        Long roleId = 1L;
+        when(aRole.getId()).thenReturn(roleId);
+        when(disabledExpRoleRepository.existsById(roleId)).thenReturn(true);
         boolean experienceDisabledForRole = testUnit.isExperienceDisabledForRole(aRole);
         Assert.assertTrue(experienceDisabledForRole);
-        verify(disabledExpRoleRepository, times(1)).existsByRole(aRole);
+        verify(disabledExpRoleRepository, times(1)).existsById(roleId);
     }
 
     @Test