public async Task ShouldDeleteMessage()
{
var firedEventsCount = 0;
var blackListRepository = new TestRepository <BlackList>();
var messageRepository = new TestRepository <Message>();
var conversationRepository = new TestRepository <Conversation>();
var conversationUserRepository = new TestRepository <ConversationUser>();
var attachmentRepository = new TestRepository <Attachment>();
var timeProvider = new TestTimeProvider();
var attachmentContentProvider = new TestAttachmentContentProvider();
var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);
var blackListService = new BlackListService(blackListRepository, _mapper);
var messageService = new MessageService(messageRepository, attachmentRepository, timeProvider, attachmentContentProvider, blackListService, conversationUserService, _mapper);
var sender = new User()
{
Id = 1
};
var conversation = new Conversation()
{
Id = 1
};
messageService.OnMessagesDeleted += (m) => firedEventsCount++;
var result = await messageService.SendMessageAsync(sender.Id,
conversation.Id, "test", new AttachmentDto[] { new AttachmentDto {
Id = 1, MessageId = 0
} });
await messageService.DeleteByIdsAsync(sender.Id, result.Entity.Id);
Assert.Empty(messageRepository.All());
Assert.Empty(attachmentRepository.All());
Assert.Equal(1, firedEventsCount);
}
public async Task ShouldUnblockUser()
{
var initiator = new User
{
Id = 1
};
var blocked = new User
{
Id = 2
};
var userRepository = new TestRepository <User>(new List <User>
{
initiator,
blocked
});
var blackListRepository = new TestRepository <BlackList>(new List <BlackList>()
{
new BlackList
{
Id = 1,
Blocked = blocked,
Initiator = initiator,
BlockedId = blocked.Id,
InitiatorId = initiator.Id
}
});
var blackListService = new BlackListService(blackListRepository, _mapper);
await blackListService.UnblockUserAsync(initiator.Id, blocked.Id);
Assert.True(!blackListRepository.Any(bl => bl.InitiatorId == initiator.Id && bl.BlockedId == blocked.Id));
}
public CommandHandlingService(IServiceProvider provider, DiscordSocketClient discord, CommandService commands)
{
InitializeLoader();
LoadDatabase();
_discord = discord;
_commands = commands;
_provider = provider;
_epService = _provider.GetService <EPService>();
_afkSertvice = _provider.GetService <AfkSertvice>();
_updateService = _provider.GetService <UserGuildUpdateService>();
_starBoardService = _provider.GetService <StarBoardService>();
_musicService = _provider.GetService <MusicService>();
_modService = _provider.GetService <ModService>();
_blackListService = _provider.GetService <BlackListService>();
_ratelimitService2 = _provider.GetService <RatelimitService2>();
_globalBans = _provider.GetService <GlobalBanService>();
_playingService = new PlayingWith(_discord);
SentryService.client = _discord;
ChangelogService.LoadChangelog();
_discord.MessageReceived += _epService.IncreaseEP;
_discord.MessageReceived += _afkSertvice.Client_MessageReceived;
_discord.UserJoined += _updateService.UserJoined;
_discord.UserLeft += _updateService.UserLeft;
_discord.ReactionAdded += _starBoardService.StarAddedNew;
_discord.ReactionRemoved += _starBoardService.StarRemovedNew;
_discord.UserVoiceStateUpdated += _musicService.CheckIfAlone;
//Bans
_discord.UserBanned += _modService.Client_UserBanned;
_discord.UserUnbanned += _modService.Client_UserUnbanned;
//Modlog
_discord.MessageDeleted += _modService.Client_MessageDeleted;
_discord.RoleCreated += _modService.Client_RoleCreated;
_discord.RoleDeleted += _modService.Client_RoleDeleted;
_discord.RoleUpdated += _modService.Client_RoleUpdated;
_discord.ChannelCreated += _modService.Client_ChannelCreated;
_discord.ChannelDestroyed += _modService.Client_ChannelDestroyed;
_discord.ChannelUpdated += _modService.Client_ChannelUpdated;
_discord.GuildUpdated += _modService.Client_GuildUpdated;
//Owner
_discord.MessageReceived += MessageReceived;
_discord.GuildAvailable += Client_GuildAvailable;
_discord.JoinedGuild += Client_JoinedGuild;
_discord.LeftGuild += Client_LeftGuild;
//CommandService
_commands.Log += CommandsOnLog;
}
public ActionResult BlackList(int p = -1)
{
List <BlackListEntity> mList = null;
int count = BlackListService.GetBlackListCount(-1);
PagerInfo pager = new PagerInfo();
pager.PageIndex = p;
pager.PageSize = PAGESIZE;
pager.SumCount = count;
pager.URL = "/BlackList";
mList = BlackListService.GetBlackListInfoByRule(-1, pager);
ViewBag.CarrierModel = BaseDataService.GetBaseDataAll().Where(t => t.PCode == "Carrier00" && t.Status == 1).ToList();
ViewBag.BlackList = mList;
ViewBag.Pager = pager;
return(View());
}
public void ModifyBlack(int blackid, string type, int unionid, string unionname, int status, int subStatus, string cardCode, string Remark)//Type,UnionID,UnionName,Remark,OperatorID,Status
{
BlackListEntity entity = new BlackListEntity();
entity.BlackID = blackid;
entity.BlackType = type;
entity.UnionID = unionid;
entity.UnionName = unionname;
entity.SubStatus = subStatus;
entity.Status = status;
entity.CardCode = cardCode;
entity.Remark = Remark;
if (entity != null)
{
entity.OperatorID = CurrentUser.UserID.ToString().ToInt(0);
}
BlackListService.ModifyBlackList(entity);
}
public async Task ShouldCreateConversationCorrectly()
{
var firedEventsCount = 0;
var conversationRepository = new TestRepository <Conversation>();
var conversationUserRepository = new TestRepository <ConversationUser>();
var blackListRepository = new TestRepository <BlackList>();
var chatActionRepository = new TestRepository <ChatAction>();
var messageRepository = new TestRepository <Message>();
var attachmentRepository = new TestRepository <Attachment>();
var blackListService = new BlackListService(blackListRepository, _mapper);
var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);
var messageService = new MessageService(messageRepository, attachmentRepository, _timeProvider, _attachmentContentProvider, blackListService, conversationUserService, _mapper);
var conversationService = new ConversationService(conversationRepository, conversationUserRepository, chatActionRepository, blackListService, messageService, _timeProvider, _mapper);
conversationService.OnConversationCreated += (conversationService) => firedEventsCount++;
var initiator = new User {
Id = 1, Username = "******"
};
var invited = new List <User>
{
new User
{
Id = 2,
Username = "******"
},
new User
{
Id = 3,
Username = "******"
}
};
var response = await conversationService.CreateConversationAsync(initiator.Id, invited.Select(u => u.Id));
Assert.Contains(conversationRepository.All(), c => c.Id == response.Entity.Id);
Assert.Contains(chatActionRepository.All(), c => c.Type == ChatActionType.NewChat && c.ConversationId == response.Entity.Id);
Assert.Contains(invited.Union(new User[] { initiator }), u => conversationUserRepository.Any(cu => cu.ConversationId == response.Entity.Id && cu.UserId == u.Id));
Assert.Equal(1, firedEventsCount);
}
public void Init()
{
var repo = new BlackListRepositoryFake();
var blockchainApiClientProviderMock = new Mock <IBlockchainApiClientProvider>();
var blockchainApiClient = new Mock <IBlockchainApiClient>();
blockchainApiClient.Setup(x => x.IsAddressValidAsync(BlockedAddressValid)).Returns(Task.FromResult(true));
blockchainApiClient.Setup(x => x.IsAddressValidAsync(BlockedAddressValid.ToLower())).Returns(Task.FromResult(true));
for (int i = 0; i < 9; i++)
{
var z = i;
blockchainApiClient.Setup(x => x.IsAddressValidAsync($"0x{z}...")).Returns(Task.FromResult(true));
}
blockchainApiClientProviderMock.Setup(x => x.Get(It.IsAny <string>())).Returns(blockchainApiClient.Object);
_logic = new BlackListService(repo, blockchainApiClientProviderMock.Object);
}
public async Task ShouldDeleteConversationCorrectly()
{
const long conversationId = 1;
const long messageId = 1;
var firedEventsCount = 0;
var initiator = new User {
Id = 1
};
var invited = new List <User>
{
new User
{
Id = 2
},
new User
{
Id = 3
}
};
var conversationUsers = invited.Union(new List <User> {
initiator
}).Select(u => new ConversationUser()
{
ConversationId = conversationId, UserId = u.Id
}).ToList();
var conversationUserRepository = new TestRepository <ConversationUser>(conversationUsers);
var blackListRepository = new TestRepository <BlackList>();
var chatActionRepository = new TestRepository <ChatAction>(new List <ChatAction>()
{
new ChatAction()
{
ConversationId = conversationId
}
});
var messageRepository = new TestRepository <Message>(new List <Message>()
{
new Message()
{
Id = messageId,
ConversationId = conversationId,
SenderId = initiator.Id,
Text = "test"
}
});;
var attachmentRepository = new TestRepository <Attachment>(new List <Attachment>()
{
new Attachment
{
Id = 1,
MessageId = messageId
}
});
var blackListService = new BlackListService(blackListRepository, _mapper);
var conversationUserService = new ConversationUserService(conversationUserRepository, _mapper);
var messageService = new MessageService(messageRepository, attachmentRepository, _timeProvider, _attachmentContentProvider, blackListService, conversationUserService, _mapper);
var conversation = new Conversation
{
Id = conversationId,
OwnerId = initiator.Id,
Users = conversationUsers
};
var conversationRepository = new TestRepository <Conversation>(new List <Conversation>()
{
conversation
});
var conversationService = new ConversationService(conversationRepository, conversationUserRepository, chatActionRepository, blackListService, messageService, _timeProvider, _mapper);
conversationService.OnConversationDeleted += (c) => firedEventsCount++;
await conversationService.DeleteConversationAsync(initiator.Id, conversation.Id);
Assert.Empty(conversationRepository.All());
Assert.Empty(messageRepository.All());
Assert.Empty(attachmentRepository.All());
Assert.Empty(conversationUserRepository.All());
Assert.Equal(1, firedEventsCount);
}
public BlackListServiceTests()
{
_blackListService = GetRequiredService <BlackListService>();
}
public async Task ShouldNotSendToBlockedUser()
{
var firedEventsCount = 0;
var senderId = 1;
var blockerId = 2;
var conversationId = 1;
var sender = new User()
{
Id = senderId
};
var conversation = new Conversation()
{
Id = conversationId
};
var conversationUsers = new List <ConversationUser>()
{
new ConversationUser()
{
ConversationId = conversationId,
UserId = senderId
},
new ConversationUser()
{
ConversationId = conversationId,
UserId = blockerId
}
};
var blackListRepository = new TestRepository <BlackList>(new List <BlackList>()
{
new BlackList()
{
InitiatorId = blockerId, BlockedId = senderId
}
});
var messageRepository = new TestRepository <Message>();
var attachmentRepository = new TestRepository <Attachment>();
var timeProvider = new TestTimeProvider();
var attachmentContentProvider = new TestAttachmentContentProvider();
var blackListService = new BlackListService(blackListRepository, _mapper);
var conversationUserService = new ConversationUserService(new TestRepository <ConversationUser>(conversationUsers), _mapper);
var messageService = new MessageService(messageRepository,
attachmentRepository,
timeProvider,
attachmentContentProvider,
blackListService,
conversationUserService,
_mapper);
messageService.OnMessageSent += (m) => firedEventsCount++;
await messageService.SendMessageAsync(sender.Id, conversation.Id, "test", new AttachmentDto[] { new AttachmentDto {
Id = 1, MessageId = 1
} });
Assert.Empty(messageRepository.All());
Assert.Empty(attachmentRepository.All());
Assert.Equal(0, firedEventsCount);
}
public void DeleteBlack(int bid)
{
BlackListService.DeleteBlack(bid);
Response.Redirect("/BaseData/BlackList");
}
public BlackList(BlackListService _ser)
{
_service = _ser;
}
