Beispiel #1
0
        public async Task GetChannelOwner_ChannelOwner_RetrievedChannelOwner(int ChannelId, int UserId, int OwnerId, string ChannelName, int NewUserId)
        {
            ChannelModel model = new ChannelModel();

            model.OwnerId = OwnerId;
            model.Name    = ChannelName;

            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);
            await messagingService.CreateChannelAsync(model);

            try
            {
                int ownerId = await messagingService.GetChannelOwnerAsync(ChannelId);

                if (ownerId == 1)
                {
                    Assert.IsTrue(true);
                }
                else
                {
                    Assert.IsTrue(false);
                }
            }
            catch
            {
                Assert.IsTrue(false);
            }
        }
Beispiel #2
0
        public async Task deleteMessage_MessageSentThenDeleted_MessageDeleted(int channelId, int userId, string message)
        {
            MessageModel model = new MessageModel();

            model.ChannelId = channelId;
            model.UserId    = userId;
            model.Message   = message;


            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);

            await messagingService.SendMessageAsync(model);

            await messagingService.DeleteMessageAsync(0);


            IEnumerable <MessageModel> models = await messagesRepo.GetAllMessagesByChannelIdAsync(channelId);

            if (models.Count() == 1)
            {
                Assert.IsTrue(true);
            }
            else
            {
                Assert.IsTrue(false);
            }
        }
Beispiel #3
0
        public async Task RemoveUserFromChannel_RemoveUser_UserRemoved(int ChannelId, int UserId, int OwnerId, string ChannelName, int AddUser)
        {
            ChannelModel model = new ChannelModel();

            model.OwnerId = OwnerId;
            model.Name    = ChannelName;

            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);
            await messagingService.CreateChannelAsync(model);

            await messagingService.AddUserToChannelAsync(AddUser, ChannelId);

            await messagingService.RemoveUserFromChannelAsync(ChannelId, AddUser);

            try
            {
                IEnumerable <UserIdModel> users = await messagingService.GetAllUsersInChannelAsync(ChannelId);

                bool done = false;
                foreach (UserIdModel user in users)
                {
                    if (user.UserId == AddUser)
                    {
                        Assert.IsTrue(false);
                        done = true;
                    }
                }
                if (done == false)
                {
                    Assert.IsTrue(true);
                }
            }
            catch
            {
                Assert.IsTrue(false);
            }
        }
Beispiel #4
0
        public async Task sendMessage_MessageSent_MessageCreated(int channelId, int userId, string message)
        {
            MessageModel model = new MessageModel();

            model.ChannelId = channelId;
            model.UserId    = userId;
            model.Message   = message;


            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);

            try{
                await messagingService.SendMessageAsync(model);
            }
            catch
            {
                Assert.IsTrue(false);
            }

            IEnumerable <MessageModel> models = await messagesRepo.GetAllMessagesByChannelIdAsync(channelId);


            foreach (MessageModel modelList in models)
            {
                if (modelList.Message == model.Message)
                {
                    Assert.IsTrue(true);
                }
                else
                {
                    Assert.IsTrue(false);
                }
            }
        }
Beispiel #5
0
        public async Task SetOffline_TurnUserOffline_UserSetOffline(int ChannelId, int UserId, int OwnerId, string ChannelName, int NewUserId)
        {
            ChannelModel model = new ChannelModel();

            model.OwnerId = OwnerId;
            model.Name    = ChannelName;

            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);

            try
            {
                await messagingService.CreateChannelAsync(model);

                await messagingService.AddUserToChannelAsync(NewUserId, ChannelId);

                await messagingService.SetUserOfflineAsync(NewUserId);
            }
            catch
            {
                Assert.IsTrue(false);
            }

            string newUserStatus = await userChannelsRepo.GetStatus(NewUserId);

            if (newUserStatus == "Offline")
            {
                Assert.IsTrue(true);
            }
            else
            {
                Assert.IsTrue(false);
            }
        }
Beispiel #6
0
        public async Task DeleteChannel_ChannelDeletion_ChannelDeleted(int ChannelId, int OwnerId, string ChannelName)
        {
            ChannelModel model = new ChannelModel();

            model.OwnerId = OwnerId;
            model.Name    = ChannelName;
            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);

            try
            {
                await messagingService.CreateChannelAsync(model);
            }
            catch
            {
                Assert.IsTrue(false);
            }
            try
            {
                await messagingService.DeleteChannelAsync(ChannelId);
            }
            catch
            {
                Assert.IsTrue(false);
            }

            ChannelModel channelModel = await channelsRepo.GetChannelbyIdAsync(ChannelId);

            if (channelModel != null)
            {
                Assert.IsTrue(false);
            }
            Assert.IsTrue(true);
        }
Beispiel #7
0
        public async Task GetAllChannelMessages_GetMessages_RetrievedAllMessages(int channelId, int userId, string message)
        {
            MessageModel model = new MessageModel();

            model.ChannelId = channelId;
            model.UserId    = userId;
            model.Message   = message;


            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);

            try
            {
                await messagingService.SendMessageAsync(model);

                IEnumerable <MessageModel> messages = await messagingService.GetAllChannelMessagesAsync(channelId);

                if (messages.Count() != 0)
                {
                    Assert.IsTrue(true);
                }
                else
                {
                    Assert.IsTrue(false);
                }
            }
            catch
            {
                Assert.IsTrue(false);
            }
        }
Beispiel #8
0
        public async Task CreateChannel_ChannelCreatation_ChannelCreated(int OwnerId, string name)
        {
            ChannelModel model = new ChannelModel();

            model.OwnerId = OwnerId;
            model.Name    = name;


            IDataGateway           dataGateway           = new SQLServerGateway();
            IConnectionStringData  connectionString      = new ConnectionStringData();
            IMessagesRepo          messagesRepo          = new MessagesRepo(dataGateway, connectionString);
            IChannelsRepo          channelsRepo          = new ChannelsRepo(dataGateway, connectionString);
            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            IUserChannelsRepo      userChannelsRepo      = new UserChannelsRepo(dataGateway, connectionString);
            IMessagingService      messagingService      = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);

            try
            {
                await messagingService.CreateChannelAsync(model);

                IEnumerable <ChannelModel> channels = await messagingService.GetAllUserChannelsAsync(OwnerId);

                if (channels.Count() != 0)
                {
                    Assert.IsTrue(true);
                }
                else
                {
                    Assert.IsTrue(false);
                }
            }
            catch
            {
                Assert.IsTrue(false);
            }
        }
Beispiel #9
0
        public async Task Init()
        {
            IDataGateway                   dataGateway      = new SQLServerGateway();
            IConnectionStringData          connectionString = new ConnectionStringData();
            IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString);

            IUserChannelsRepo userChannelsRepo = new UserChannelsRepo(dataGateway, connectionString);
            var userChannels = await userChannelsRepo.GetAllUserChannelsAsync();

            foreach (var userChannel in userChannels)
            {
                await userChannelsRepo.DeleteUserChannelsByIdAsync(userChannel.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserChannels", 0, connectionString, dataGateway);


            IMessagesRepo messagesRepo = new MessagesRepo(dataGateway, connectionString);
            var           messages     = await messagesRepo.GetAllMessagesAsync();

            foreach (var message in messages)
            {
                await messagesRepo.DeleteMessageByIdAsync(message.Id);
            }

            await DataAccessTestHelper.ReseedAsync("Messages", 0, connectionString, dataGateway);


            IChannelsRepo channelsRepo = new ChannelsRepo(dataGateway, connectionString);
            var           channels     = await channelsRepo.GetAllChannelsAsync();

            foreach (var channel in channels)
            {
                await channelsRepo.DeleteChannelbyIdAsync(channel.Id);
            }

            await DataAccessTestHelper.ReseedAsync("Channels", 0, connectionString, dataGateway);



            IPublicUserProfileRepo publicUserProfileRepo = new PublicUserProfileRepo(dataGateway, connectionString);
            var profiles = await publicUserProfileRepo.GetAllPublicProfiles();

            foreach (var profile in profiles)
            {
                await publicUserProfileRepo.DeletePublicProfileById(profile.Id);
            }

            await DataAccessTestHelper.ReseedAsync("PublicUserProfile", 0, connectionString, dataGateway);



            var settings = await userAccountSettingsRepository.GetAllSettings();

            foreach (var setting in settings)
            {
                await userAccountSettingsRepository.DeleteUserAccountSettingsByUserId(setting.UserId);
            }

            await DataAccessTestHelper.ReseedAsync("UserAccountSettings", 0, connectionString, dataGateway);

            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            var accounts = await userAccountRepository.GetAllAccounts();

            foreach (var account in accounts)
            {
                await userAccountRepository.DeleteAccountById(account.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserAccount", 0, connectionString, dataGateway);



            int i = 1;
            UserAccountModel userAccountModel = new UserAccountModel();

            userAccountModel.Id            = i;
            userAccountModel.Username      = "******" + i;
            userAccountModel.Password      = "" + i;
            userAccountModel.Salt          = "" + i;
            userAccountModel.EmailAddress  = "TestEmailAddress" + i;
            userAccountModel.AccountType   = "TestAccountType" + i;
            userAccountModel.AccountStatus = "TestAccountStatus" + i;
            userAccountModel.CreationDate  = DateTimeOffset.UtcNow;
            userAccountModel.UpdationDate  = DateTimeOffset.UtcNow;

            await userAccountRepository.CreateAccount(userAccountModel);

            UserAccountRepository userAccountRepo     = new UserAccountRepository(new SQLServerGateway(), new ConnectionStringData());
            ICryptographyService  cryptographyService = new CryptographyService(userAccountRepo);

            await cryptographyService.newPasswordEncryptAsync("Password", 1);

            UserAccountSettingsModel userAccountSettingsModel = new UserAccountSettingsModel();

            userAccountSettingsModel.Id         = 0;
            userAccountSettingsModel.UserId     = 1;
            userAccountSettingsModel.FontSize   = 12;
            userAccountSettingsModel.FontStyle  = "Time New Roman";
            userAccountSettingsModel.ThemeColor = "White";


            IAuthenticationService  authenticationService      = new AuthenticationService(userAccountRepository);
            IAccountSettingsService userAccountSettingsManager = new AccountSettingsService(userAccountRepository, userAccountSettingsRepository, cryptographyService, authenticationService);


            await userAccountSettingsManager.CreateUserAccountSettingsAsync(userAccountSettingsModel);


            i = 2;
            userAccountModel.Id            = i;
            userAccountModel.Username      = "******" + i;
            userAccountModel.Password      = "" + i;
            userAccountModel.Salt          = "" + i;
            userAccountModel.EmailAddress  = "TestEmailAddress" + i;
            userAccountModel.AccountType   = "TestAccountType" + i;
            userAccountModel.AccountStatus = "TestAccountStatus" + i;
            userAccountModel.CreationDate  = DateTimeOffset.UtcNow;
            userAccountModel.UpdationDate  = DateTimeOffset.UtcNow;

            await userAccountRepository.CreateAccount(userAccountModel);


            await cryptographyService.newPasswordEncryptAsync("Password", 1);

            userAccountSettingsModel.Id         = 0;
            userAccountSettingsModel.UserId     = 1;
            userAccountSettingsModel.FontSize   = 12;
            userAccountSettingsModel.FontStyle  = "Time New Roman";
            userAccountSettingsModel.ThemeColor = "White";



            await userAccountSettingsManager.CreateUserAccountSettingsAsync(userAccountSettingsModel);
        }
Beispiel #10
0
        public async Task CleanUp()
        {
            IDataGateway                   dataGateway      = new SQLServerGateway();
            IConnectionStringData          connectionString = new ConnectionStringData();
            IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString);



            IMessagesRepo messagesRepo = new MessagesRepo(dataGateway, connectionString);

            IUserChannelsRepo userChannelsRepo = new UserChannelsRepo(dataGateway, connectionString);
            var userChannels = await userChannelsRepo.GetAllUserChannelsAsync();

            foreach (var userChannel in userChannels)
            {
                await userChannelsRepo.DeleteUserChannelsByIdAsync(userChannel.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserChannels", 0, connectionString, dataGateway);



            var messages = await messagesRepo.GetAllMessagesAsync();

            foreach (var message in messages)
            {
                await messagesRepo.DeleteMessageByIdAsync(message.Id);
            }

            await DataAccessTestHelper.ReseedAsync("Messages", 0, connectionString, dataGateway);


            IChannelsRepo channelsRepo = new ChannelsRepo(dataGateway, connectionString);
            var           channels     = await channelsRepo.GetAllChannelsAsync();

            foreach (var channel in channels)
            {
                await channelsRepo.DeleteChannelbyIdAsync(channel.Id);
            }

            await DataAccessTestHelper.ReseedAsync("Channels", 0, connectionString, dataGateway);



            var settings = await userAccountSettingsRepository.GetAllSettings();

            foreach (var setting in settings)
            {
                await userAccountSettingsRepository.DeleteUserAccountSettingsByUserId(setting.UserId);
            }

            await DataAccessTestHelper.ReseedAsync("UserAccountSettings", 0, connectionString, dataGateway);

            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            var accounts = await userAccountRepository.GetAllAccounts();

            foreach (var account in accounts)
            {
                await userAccountRepository.DeleteAccountById(account.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserAccount", 0, connectionString, dataGateway);



            IPublicUserProfileRepo publicUserProfileRepo = new PublicUserProfileRepo(dataGateway, connectionString);
            var profiles = await publicUserProfileRepo.GetAllPublicProfiles();

            foreach (var profile in profiles)
            {
                await publicUserProfileRepo.DeletePublicProfileById(profile.Id);
            }

            await DataAccessTestHelper.ReseedAsync("PublicUserProfile", 0, connectionString, dataGateway);
        }
Beispiel #11
0
        public async Task SeedUsers(int seedAmount)
        {
            await TestCleaner.CleanDatabase();

            IDataGateway                       dataGateway       = new SQLServerGateway();
            IConnectionStringData              connectionString  = new ConnectionStringData();
            IListingRepository                 listingRepository = new ListingRepository(dataGateway, connectionString);
            ICollaborationRepository           listingCollaborationRepository    = new CollaborationRepository(dataGateway, connectionString);
            IRelationshipRepository            listingRelationshipRepository     = new RelationshipRepository(dataGateway, connectionString);
            ITeamModelRepository               listingTeamModelRepository        = new TeamModelRepository(dataGateway, connectionString);
            IUserAccountRepository             userAccountRepository             = new UserAccountRepository(dataGateway, connectionString);
            IUserProfileRepository             userProfileRepository             = new UserProfileRepository(dataGateway, connectionString);
            IUserAccountSettingsRepository     userAccountSettingsRepository     = new UserAccountSettingRepository(dataGateway, connectionString);
            IAssignmentPolicyRepository        assignmentPolicyRepository        = new AssignmentPolicyRepository(dataGateway, connectionString);
            IAssignmentPolicyPairingRepository assignmentPolicyPairingRepository = new AssignmentPolicyPairingRepository(dataGateway, connectionString);
            IScopeRepository                   scopeRepsitory           = new ScopeRepository(dataGateway, connectionString);
            IClaimRepository                   claimRepository          = new ClaimRepository(dataGateway, connectionString);
            IScopeClaimRepository              scopeClaimRepository     = new ScopeClaimRepository(dataGateway, connectionString);
            IUserScopeClaimRepository          userScopeClaimRepository = new UserScopeClaimRepository(dataGateway, connectionString);
            IScopeService                      scopeService             = new ScopeService(claimRepository, scopeRepsitory, scopeClaimRepository, userScopeClaimRepository);
            ICryptographyService               cryptographyService      = new CryptographyService(userAccountRepository);
            IAssignmentPolicyService           assignmentPolicyService  = new AssignmentPolicyService(assignmentPolicyRepository, assignmentPolicyPairingRepository, scopeRepsitory, scopeService);
            IClaimsService                     claimService             = new ClaimsService(claimRepository, scopeRepsitory, scopeClaimRepository, userScopeClaimRepository);
            IListingCreationService            listingCreationService   = new ListingCreationService(listingRepository, listingCollaborationRepository, listingRelationshipRepository,
                                                                                                     listingTeamModelRepository);

            var accounts = await userAccountRepository.GetAllAccounts();

            var accountSettings = await userAccountSettingsRepository.GetAllSettings();

            IUserChannelsRepo userChannelsRepo = new UserChannelsRepo(dataGateway, connectionString);
            var userChannels = await userChannelsRepo.GetAllUserChannelsAsync();

            foreach (var userChannel in userChannels)
            {
                await userChannelsRepo.DeleteUserChannelsByIdAsync(userChannel.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserChannels", 0, connectionString, dataGateway);

            IMessagesRepo messagesRepo = new MessagesRepo(dataGateway, connectionString);
            var           messages     = await messagesRepo.GetAllMessagesAsync();

            foreach (var message in messages)
            {
                await messagesRepo.DeleteMessageByIdAsync(message.Id);
            }

            await DataAccessTestHelper.ReseedAsync("Messages", 0, connectionString, dataGateway);

            IChannelsRepo channelsRepo = new ChannelsRepo(dataGateway, connectionString);
            var           channels     = await channelsRepo.GetAllChannelsAsync();

            foreach (var channel in channels)
            {
                await channelsRepo.DeleteChannelbyIdAsync(channel.Id);
            }


            IAccountVerificationRepo accountVerification = new AccountVerificationRepo(dataGateway, connectionString);
            var verfications = await accountVerification.GetAllAccountVerifications();

            foreach (var verfication in verfications)
            {
                await accountVerification.DeleteAccountVerificationById(verfication.Id);
            }

            await DataAccessTestHelper.ReseedAsync("AccountVerification", 0, connectionString, dataGateway);

            IPublicUserProfileRepo publicUserProfileRepo = new PublicUserProfileRepo(dataGateway, connectionString);
            var publicProfiles = await publicUserProfileRepo.GetAllPublicProfiles();

            foreach (var profile in publicProfiles)
            {
                await publicUserProfileRepo.DeletePublicProfileById(profile.Id);
            }

            await DataAccessTestHelper.ReseedAsync("PublicUserProfile", 0, connectionString, dataGateway);

            if (accounts != null)
            {
                var numRows = accounts.ToList().Count;

                for (int i = 1; i <= numRows; ++i)
                {
                    await userAccountSettingsRepository.DeleteUserAccountSettingsByUserId(i);
                }
            }

            await TestCleaner.CleanDatabase();

            await DataAccessTestHelper.ReseedAsync("UserAccountSettings", 0, connectionString, dataGateway);


            IUserAccountService userAccountService = new UserAccountService(userAccountRepository);
            IUserProfileService userProfileService = new UserProfileService(userProfileRepository);

            var assignedScopes = new List <ScopeModel>();
            var namedScopes    = new List <string>()
            {
                "friends_list:read,", "friends_list:write,", "friends_list:delete,", "friends_list:block,",
                "friends_list:approve,", "user_profile:read,", "user_profile:report,", "user_profile:write,", "user_profile.friends_list.status:read,",
                "application:read,", "user_profile.visibility:read,", "user_profile.photo:upload,", "messaging:send,", "messaging:get,", "messaging.users:get,", "messaging.channels:addUser,", "messaging.channels:removeUser,", "channels.user:getall,", "channels:create,", "channels:getowner,", "channels:delete,", "message:delete,", "channel:setonline,", "channel:setoffline,",
                "account:delete,", "account:passwordchange,", "account.fontszie:change,", "account.email:change,", "account.fontSize:get,", "account.fontstyle:change,", "account.fontstyle:get,", "account.theme:change,", "account.theme:get,",
                "listings:read,", "listings:write,"
            };
            var claims = new List <ClaimModel>();

            claims.Add(new ClaimModel()
            {
                Type      = "channel_owner",
                Value     = "false",
                IsDefault = true
            });
            claims.Add(new ClaimModel()
            {
                Type      = "Moderator",
                Value     = "false",
                IsDefault = true
            });

            var currentClaims = await claimService.GetAllClaims();

            foreach (var claim in claims)
            {
                foreach (var currentClaim in currentClaims)
                {
                    if (claim.Type == currentClaim.Type)
                    {
                        continue;
                    }
                }

                await claimService.CreateClaim(claim);
            }

            var databaseClaims = await claimService.GetAllClaims();

            foreach (var scope in namedScopes)
            {
                assignedScopes.Add(new ScopeModel()
                {
                    Type        = scope,
                    Claims      = databaseClaims,
                    Description = null,
                    IsDefault   = true
                });
            }

            assignedScopes.ForEach(async x => await scopeService.CreateScope(x));
            var scopes             = (await scopeService.GetAllScopes()).ToList();
            var assignmentPolicies = await assignmentPolicyService.CreateAssignmentPolicy(new BusinessModels.UserAccessControl.AssignmentPolicyModel()
            {
                Default             = true,
                Name                = "DefaultAccessPolicy",
                AssignedScopes      = scopes,
                Priority            = 1,
                RequiredAccountType = "user"
            });

            var adminPolicies = await assignmentPolicyService.CreateAssignmentPolicy(new BusinessModels.UserAccessControl.AssignmentPolicyModel()
            {
                Default             = true,
                Name                = "DefaultAdminPolicy",
                AssignedScopes      = scopes,
                Priority            = 1,
                RequiredAccountType = "admin"
            });

            PublicUserProfileManager publicUserProfileManager = new PublicUserProfileManager(new PublicUserProfileService(publicUserProfileRepo, new ValidationService(userAccountService, userProfileService)));
            IAccountVerificationRepo accountVerificationRepo  = new AccountVerificationRepo(new SQLServerGateway(), new ConnectionStringData());

            IDictionary <string, string> _testConfigKeys = new Dictionary <string, string>();

            _testConfigKeys.Add("Sender", "*****@*****.**");
            _testConfigKeys.Add("TrackOpens", "true");
            _testConfigKeys.Add("Subject", "Welcome!");
            _testConfigKeys.Add("TextBody", "Welcome to InfiniMuse!");
            _testConfigKeys.Add("MessageStream", "outbound");
            _testConfigKeys.Add("Tag", "Welcome");
            _testConfigKeys.Add("HtmlBody", "Thank you for registering! Please confirm your account with the link: <a href='{0}'>Confirm Your Account!</a><strong>Once confirmed you will have access to the features.</strong>");

            IConfiguration configuration = new ConfigurationBuilder()
                                           .AddInMemoryCollection(_testConfigKeys)
                                           .Build();
            EmailService emailService = new EmailService(new UserAccountRepository
                                                             (new SQLServerGateway(), new ConnectionStringData()), new AccountVerificationRepo
                                                             (new SQLServerGateway(), new ConnectionStringData()), new UserAccountService(new UserAccountRepository
                                                                                                                                              (new SQLServerGateway(), new ConnectionStringData())), configuration);

            for (int i = 1; i < seedAmount; ++i)
            {
                UserAccountModel         userAccountModel         = new UserAccountModel();
                UserProfileModel         userProfileModel         = new UserProfileModel();
                UserAccountSettingsModel userAccountSettingsModel = new UserAccountSettingsModel();

                userAccountModel.Id            = i;
                userAccountModel.Username      = "******" + i;
                userAccountModel.Password      = "" + i;
                userAccountModel.Salt          = "" + i;
                userAccountModel.EmailAddress  = "TestEmailAddress" + i;
                userAccountModel.AccountType   = "user";
                userAccountModel.AccountStatus = "TestAccountStatus" + i;
                userAccountModel.CreationDate  = DateTimeOffset.UtcNow;
                userAccountModel.UpdationDate  = DateTimeOffset.UtcNow;

                userProfileModel.Id            = i;
                userProfileModel.FirstName     = "TestFirstName" + i;
                userProfileModel.Surname       = "TestSurname" + i;
                userProfileModel.DateOfBirth   = DateTimeOffset.UtcNow;
                userProfileModel.UserAccountId = userAccountModel.Id;

                userAccountSettingsModel.Id         = i;
                userAccountSettingsModel.UserId     = userAccountModel.Id;
                userAccountSettingsModel.FontSize   = 12;
                userAccountSettingsModel.FontStyle  = "Default";
                userAccountSettingsModel.ThemeColor = "Light";

                await userAccountRepository.CreateAccount(userAccountModel);

                await cryptographyService.newPasswordEncryptAsync("T" + i, i);

                await userProfileRepository.CreateUserProfile(userProfileModel);

                await userAccountSettingsRepository.CreateUserAccountSettings(userAccountSettingsModel);

                PublicUserProfileModel publicUserProfileModel = new PublicUserProfileModel();
                publicUserProfileModel.UserId = userAccountModel.Id;

                publicUserProfileModel.Description = "My name is " + userAccountModel.Username;
                publicUserProfileModel.Visibility  = "Public";
                publicUserProfileModel.Age         = userAccountModel.Id + 20;
                publicUserProfileModel.Hobbies     = "These are my hobbies";
                publicUserProfileModel.Intrests    = "These are my intrests";
                publicUserProfileModel.Height      = "This is how tall I am";
                await publicUserProfileManager.CeatePublicUserProfileAsync(publicUserProfileModel);

                await emailService.CreateVerificationToken(publicUserProfileModel.UserId);
            }

            IMessagingService messagingService = new MessagingService(messagesRepo, channelsRepo, userChannelsRepo, userAccountRepository);

            ChannelModel model = new ChannelModel();

            model.OwnerId = 1;
            model.Name    = "Jakes Group";
            await messagingService.CreateChannelAsync(model);

            for (int i = 2; i < 19; i++)
            {
                await messagingService.AddUserToChannelAsync(i, 1);
            }

            IFriendListRepo friendListRepo = new FriendListRepo(dataGateway, connectionString);

            IFriendRequestListRepo friendRequestListRepo = new FriendRequestListRepo(dataGateway, connectionString);

            IFriendBlockListRepo friendBlockListRepo = new FriendBlockListRepo(dataGateway, connectionString);

            IEnumerable <FriendsListJunctionModel> friends = await friendListRepo.GetAllFriends();

            foreach (var friend in friends)
            {
                await friendListRepo.DeleteFriendListbyId(friend.Id);
            }

            await DataAccessTestHelper.ReseedAsync("FriendsList", 0, connectionString, dataGateway);

            IEnumerable <FriendsListJunctionModel> requets = await friendRequestListRepo.GetAllFriendRequests();

            foreach (var request in requets)
            {
                await friendRequestListRepo.DeleteFriendRequestListbyId(request.Id);
            }

            await DataAccessTestHelper.ReseedAsync("FriendRequestList", 0, connectionString, dataGateway);

            IEnumerable <FriendsListJunctionModel> blocks = await friendBlockListRepo.GetAllFriendBlocks();

            foreach (var block in blocks)
            {
                await friendBlockListRepo.DeleteFriendBlockbyId(block.Id);
            }

            await DataAccessTestHelper.ReseedAsync("FriendBlockList", 0, connectionString, dataGateway);


            for (int i = 0; i < 20; i++)
            {
                BusinessCollaborationModel newBusinessCollaborationModel = new BusinessCollaborationModel();
                BusinessListingModel       newBusinessListingModel       = new BusinessListingModel();

                newBusinessCollaborationModel.Title   = "TestTitle" + i;
                newBusinessCollaborationModel.Details = "TestDetails" + i;
                newBusinessCollaborationModel.City    = "TestCity" + i;
                newBusinessCollaborationModel.State   = "TestState" + i;
                newBusinessCollaborationModel.NumberOfParticipants = i;
                newBusinessCollaborationModel.InPersonOrRemote     = "InpersonOrRemoteTest" + i;
                newBusinessCollaborationModel.UserAccountId        = i;
                newBusinessCollaborationModel.CollaborationType    = "TestcollaborationType" + i;
                newBusinessCollaborationModel.InvolvementType      = "InvolvementType" + i;
                newBusinessCollaborationModel.Experience           = "Testexperience" + i;
                newBusinessCollaborationModel.CollaborationType    = "TestCollaborationType" + i;
                newBusinessCollaborationModel.InvolvementType      = "TestInvolvementType" + i;
                newBusinessCollaborationModel.Experience           = "TestExperience" + i;


                await listingCreationService.CreateListing(newBusinessCollaborationModel);
            }
            for (int i = 21; i < 40; i++)
            {
                BusinessRelationshipModel newBusinessRelationshipModel = new BusinessRelationshipModel();
                BusinessListingModel      newBusinessListingModel1     = new BusinessListingModel();

                newBusinessRelationshipModel.Title   = "TestTitle" + i;
                newBusinessRelationshipModel.Details = "TestDetails" + i;
                newBusinessRelationshipModel.City    = "TestCity" + i;
                newBusinessRelationshipModel.State   = "TestState" + i;
                newBusinessRelationshipModel.NumberOfParticipants = i;
                newBusinessRelationshipModel.InPersonOrRemote     = "InpersonOrRemoteTest" + i;
                newBusinessRelationshipModel.UserAccountId        = i;
                newBusinessRelationshipModel.RelationshipType     = "TestcollaborationType" + i;
                newBusinessRelationshipModel.Age              = 21;
                newBusinessRelationshipModel.Interests        = "TestInterests" + i;
                newBusinessRelationshipModel.GenderPreference = "TestGenderPreference" + i;

                await listingCreationService.CreateListing(newBusinessRelationshipModel);
            }
            for (int i = 41; i < 60; i++)
            {
                BusinessTeamModel    newBusinessTeamModel     = new BusinessTeamModel();
                BusinessListingModel newBusinessListingModel1 = new BusinessListingModel();

                newBusinessTeamModel.Title   = "TestTitle" + i;
                newBusinessTeamModel.Details = "TestDetails" + i;
                newBusinessTeamModel.City    = "TestCity" + i;
                newBusinessTeamModel.State   = "TestState" + i;
                newBusinessTeamModel.NumberOfParticipants = i;
                newBusinessTeamModel.InPersonOrRemote     = "InpersonOrRemoteTest" + i;
                newBusinessTeamModel.UserAccountId        = i + 1;
                newBusinessTeamModel.TeamType             = "TestTeamType" + i;
                newBusinessTeamModel.GameType             = "TestGameType" + i;
                newBusinessTeamModel.Platform             = "TestPlatform" + i;
                newBusinessTeamModel.Experience           = "TestExperience" + i;


                await listingCreationService.CreateListing(newBusinessTeamModel);
            }

            IUserReportsRepo          userReportsRepo          = new UserReportsRepo(dataGateway, connectionString);
            IValidationService        validationService        = new ValidationService(userAccountService, userProfileService);
            IPublicUserProfileService publicUserProfileService = new PublicUserProfileService(publicUserProfileRepo, validationService);

            IUserInteractionService userInteractionService = new UserInteractionService(friendBlockListRepo, friendListRepo, friendRequestListRepo, userReportsRepo, validationService);
            IFriendListManager      friendListManager      = new FriendListManager(userAccountRepository, publicUserProfileService, userInteractionService);

            for (int i = 10; i < 15; i++)
            {
                await friendListManager.RequestFriendAsync(1, i);
            }

            await friendListManager.RequestFriendAsync(18, 1);


            for (int i = 2; i < 10; i++)
            {
                await friendListManager.RequestFriendAsync(1, i);

                await friendListManager.ConfirmFriendAsync(1, i);
            }

            for (int i = 3; i < 10; i++)
            {
                await friendListManager.RequestFriendAsync(2, i);

                await friendListManager.ConfirmFriendAsync(2, i);
            }

            await friendListManager.BlockFriendAsync(19, 1);

            MessageModel messageModel = new MessageModel();

            messageModel.ChannelId = 1;
            messageModel.UserId    = 1;
            messageModel.Message   = "Hi Tim";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 1;
            messageModel.UserId    = 2;
            messageModel.Message   = "Whats up Jake";
            await messagingService.SendMessageAsync(messageModel);

            model         = new ChannelModel();
            model.OwnerId = 3;
            model.Name    = "Richards Group";
            await messagingService.CreateChannelAsync(model);

            await messagingService.AddUserToChannelAsync(1, 2);

            await messagingService.AddUserToChannelAsync(2, 2);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 3;
            messageModel.Message   = "Hi Jake and Tim";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 1;
            messageModel.Message   = "Whats up Richard how are you doing";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 3;
            messageModel.Message   = "Im Chilling";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 3;
            messageModel.Message   = "Just doing some homework";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 1;
            messageModel.Message   = "Oh nice, I started spring break this week and I finished all of my homework a few days ago so im just relaxing playing some warzone";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 3;
            messageModel.Message   = "Oh sweet";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 2;
            messageModel.Message   = "Whats up guys its me Tim";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 3;
            messageModel.Message   = "Hey Tim";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 1;
            messageModel.Message   = "Whats up tim";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 2;
            messageModel.Message   = "Nothing much guys";
            await messagingService.SendMessageAsync(messageModel);

            messageModel           = new MessageModel();
            messageModel.ChannelId = 2;
            messageModel.UserId    = 1;
            messageModel.Message   = "You guys wanna hop on warzone with me";
            await messagingService.SendMessageAsync(messageModel);
        }
        public async Task CleanUp()
        {
            IDataGateway                   dataGateway      = new SQLServerGateway();
            IConnectionStringData          connectionString = new ConnectionStringData();
            IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString);



            IMessagesRepo messagesRepo = new MessagesRepo(dataGateway, connectionString);

            IUserChannelsRepo userChannelsRepo = new UserChannelsRepo(dataGateway, connectionString);
            var userChannels = await userChannelsRepo.GetAllUserChannelsAsync();

            foreach (var userChannel in userChannels)
            {
                await userChannelsRepo.DeleteUserChannelsByIdAsync(userChannel.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserChannels", 0, connectionString, dataGateway);



            var messages = await messagesRepo.GetAllMessagesAsync();

            foreach (var message in messages)
            {
                await messagesRepo.DeleteMessageByIdAsync(message.Id);
            }

            await DataAccessTestHelper.ReseedAsync("Messages", 0, connectionString, dataGateway);


            IChannelsRepo channelsRepo = new ChannelsRepo(dataGateway, connectionString);
            var           channels     = await channelsRepo.GetAllChannelsAsync();

            foreach (var channel in channels)
            {
                await channelsRepo.DeleteChannelbyIdAsync(channel.Id);
            }

            await DataAccessTestHelper.ReseedAsync("Channels", 0, connectionString, dataGateway);


            IPublicUserProfileRepo publicUserProfileRepo = new PublicUserProfileRepo(dataGateway, connectionString);

            var profiles = await publicUserProfileRepo.GetAllPublicProfiles();

            foreach (var profile in profiles)
            {
                await publicUserProfileRepo.DeletePublicProfileById(profile.Id);
            }

            await DataAccessTestHelper.ReseedAsync("PublicUserProfile", 0, connectionString, dataGateway);



            var settings = await userAccountSettingsRepository.GetAllSettings();

            foreach (var setting in settings)
            {
                await userAccountSettingsRepository.DeleteUserAccountSettingsByUserId(setting.UserId);
            }

            await DataAccessTestHelper.ReseedAsync("UserAccountSettings", 0, connectionString, dataGateway);

            IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
            var accounts = await userAccountRepository.GetAllAccounts();

            foreach (var account in accounts)
            {
                await userAccountRepository.DeleteAccountById(account.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserAccount", 0, connectionString, dataGateway);


            IFriendListRepo friendListRepo = new FriendListRepo(dataGateway, connectionString);
            IEnumerable <FriendsListJunctionModel> friends = await friendListRepo.GetAllFriends();

            foreach (var friend in friends)
            {
                await friendListRepo.DeleteFriendListbyId(friend.Id);
            }

            await DataAccessTestHelper.ReseedAsync("FriendsList", 0, connectionString, dataGateway);


            IFriendRequestListRepo friendRequestListRepo = new FriendRequestListRepo(dataGateway, connectionString);

            IEnumerable <FriendsListJunctionModel> requets = await friendRequestListRepo.GetAllFriendRequests();

            foreach (var request in requets)
            {
                await friendRequestListRepo.DeleteFriendRequestListbyId(request.Id);
            }

            await DataAccessTestHelper.ReseedAsync("FriendRequestList", 0, connectionString, dataGateway);


            IFriendBlockListRepo friendBlockListRepo = new FriendBlockListRepo(dataGateway, connectionString);

            IEnumerable <FriendsListJunctionModel> blocks = await friendBlockListRepo.GetAllFriendBlocks();

            foreach (var block in blocks)
            {
                await friendBlockListRepo.DeleteFriendBlockbyId(block.Id);
            }

            await DataAccessTestHelper.ReseedAsync("FriendBlockList", 0, connectionString, dataGateway);

            IUserReportsRepo userReportsRepo = new UserReportsRepo(dataGateway, connectionString);

            IEnumerable <UserReportsModel> reports = await userReportsRepo.GetAllReports();

            foreach (var report in reports)
            {
                await userReportsRepo.DeleteReportById(report.Id);
            }

            await DataAccessTestHelper.ReseedAsync("UserReports", 0, connectionString, dataGateway);
        }