/// <summary>
/// Get specific chat
/// </summary>
/// <param name="id"></param>
/// <returns>ChatDTO</returns>
public ChatDTO GetChatById(int id)
{
Logger.log.Debug("at WCFService.ChatService.GetChatById");
var chat = ChatProvider.GetChatById(id);
return(_chatConverter.ToDataTransferEntity(chat));
}
/// <inheritdoc />
public string SetProviderInfo(ChatSetupInfo info)
{
info.AdminList.RemoveAll(x => String.IsNullOrWhiteSpace(x));
info.AdminChannels.RemoveAll(x => String.IsNullOrWhiteSpace(x));
info.GameChannels.RemoveAll(x => String.IsNullOrWhiteSpace(x));
info.DevChannels.RemoveAll(x => String.IsNullOrWhiteSpace(x));
info.WatchdogChannels.RemoveAll(x => String.IsNullOrWhiteSpace(x));
try
{
lock (ChatLock)
{
foreach (var ChatProvider in ChatProviders)
{
if (info.Provider == ChatProvider.ProviderInfo().Provider)
{
return(ChatProvider.SetProviderInfo(info));
}
}
return("Error: Invalid provider: " + info.Provider.ToString());
}
}
catch (Exception e)
{
return(e.ToString());
}
}
private static void LoadProvider()
{
// if we do not have initiated the provider
if (_provider == null)
{
lock (_lock)
{
// Do this again to make sure _provider is still null
if (_provider == null)
{
// Get a reference to the <requestService> section
ChatServiceSection section = (ChatServiceSection)WebConfigurationManager.GetSection("LCSK/chatService");
// Load the default provider
if (section.Providers.Count > 0 && !string.IsNullOrEmpty(section.DefaultProvider) && section.Providers[section.DefaultProvider] != null)
{
_provider = (ChatProvider)ProvidersHelper.InstantiateProvider(section.Providers[section.DefaultProvider], typeof(ChatProvider));
}
if (_provider == null)
{
throw new ProviderException("Unable to load the ChatProvider");
}
}
}
}
}
/// <summary>
/// Add chat to db
/// </summary>
/// <param name="newChat"></param>
/// <returns>Created chat id</returns>
public int AddChat(ChatDTO newChat)
{
Logger.log.Debug("at WCFService.ChatService.AddChat");
var chat = _chatConverter.ToBusinessEntity(newChat);
return(ChatProvider.AddChat(chat));
}
/// <summary>
/// Constructs a <see cref="ChatSetupInfo"/> from optional <paramref name="baseInfo"/>
/// </summary>
/// <param name="provider">The <see cref="ChatProvider"/> that this <see cref="ChatSetupInfo"/> is for</param>
/// <param name="baseInfo">Optional past data</param>
/// <param name="numFields">The number of fields in this chat provider</param>
protected internal ChatSetupInfo(ChatProvider provider, ChatSetupInfo baseInfo, int numFields)
{
numFields += BaseIndex;
InitializeFields = baseInfo == null || baseInfo.DataFields.Count != numFields;
if (InitializeFields)
{
DataFields = new List <string>(numFields);
for (var I = 0; I < numFields; ++I)
{
DataFields.Add(null);
}
AdminList = new List <string>();
AdminChannels = new List <string>();
DevChannels = new List <string>();
GameChannels = new List <string>();
WatchdogChannels = new List <string>();
AdminsAreSpecial = false;
Enabled = false;
}
else
{
DataFields = baseInfo.DataFields;
}
Provider = provider;
Specialize(true); //to check we have a valid provider
}
private void IRCProviderSwitch_CheckedChanged(object sender, EventArgs e)
{
if (!updatingChat && IRCProviderSwitch.Checked)
{
ModifyingProvider = ChatProvider.IRC;
LoadChatPage();
}
}
public ChatService()
{
ChatProvider = new ChatProvider();
MessageProvider = new MessageProvider();
_userConverter = new UserConverter();
_chatConverter = new ChatConverter();
_messageConverter = new MessageConverter();
}
/// <summary>
/// Get all users from this chat
/// </summary>
/// <param name="id"></param>
/// <returns>List of users</returns>
public IList <UserInfoDTO> GetAllUsersFromChat(int id)
{
Logger.log.Debug("at WCFService.ChatService.GetAllUsersFromChat");
var chat = ChatProvider.GetChatById(id);
var users = ChatProvider.GetUsersOfChat(chat);
return(_userConverter.ToDataTransferEntityList(users.ToList()));
}
/// <summary>
/// Get all messages from this chat
/// </summary>
/// <param name="id"></param>
/// <returns>List of messages</returns>
public IList <MessageDTO> GetAllMessagesFromChat(int id)
{
Logger.log.Debug("at WCFService.ChatService.GetAllMessagesFromChat");
var chat = ChatProvider.GetChatById(id);
var messages = ChatProvider.GetMessagesFromChat(chat);
return(_messageConverter.ToDataTransferEntityList(messages.ToList()));
}
public void AddUserToChat(User user, Chat chat)
{
chat.UserChats.Add(new UserChat {
Chat = chat
});
// var userChat = new UserChat { User = user, Chat = chat };
// UserChatProvider.Add(userChat);
// UserChatProvider.SaveChanges();
ChatProvider.SaveChanges();
}
/// <inheritdoc />
public string Reconnect(ChatProvider providerType)
{
foreach (var I in ChatProviders)
{
if (I.ProviderInfo().Provider == providerType)
{
return(I.Reconnect());
}
}
return("Could not find specified provider!");
}
/// <inheritdoc />
public bool Connected(ChatProvider providerType)
{
foreach (var I in ChatProviders)
{
if (I.ProviderInfo().Provider == providerType)
{
return(I.Connected());
}
}
return(false);
}
/// <summary>
/// Add user to chat
/// </summary>
/// <param name="chatId"></param>
/// <param name="userId"></param>
/// <returns>Result of opreation</returns>
public bool AddUser(int chatId, int userId)
{
Logger.log.Debug("at WCFService.ChatService.AddUser");
var user = new User()
{
Id = userId
};
var chat = ChatProvider.GetChatById(chatId);
return(ChatProvider.AddUserToChat(user, chat));
}
public Chat GetChatById(int chatId, Include <Chat> include = null)
{
var chat = ChatProvider.All(include).FirstOrDefault(c => c.ChatId == chatId);
if (chat == null)
{
throw new ServiceException {
Code = StatusCode.ChatNotFoundError
};
}
return(chat);
}
/// <summary>
/// Properly shuts down all <see cref="ChatProviders"/>
/// </summary>
void DisposeChat()
{
var infosList = new List <IList <string> >();
foreach (var ChatProvider in ChatProviders)
{
infosList.Add(ChatProvider.ProviderInfo().DataFields);
ChatProvider.Dispose();
}
ChatProviders = null;
var rawdata = JsonConvert.SerializeObject(infosList, Formatting.Indented);
Config.ChatProviderData = Interface.Helpers.EncryptData(rawdata, out string entrp);
Config.ChatProviderEntropy = entrp;
}
/// <summary>
/// Broadcast a message to appropriate channels based on the message type
/// </summary>
/// <param name="msg">The message to send</param>
/// <param name="mt">The message type</param>
public void SendMessage(string msg, MessageType mt)
{
lock (ChatLock)
{
foreach (var ChatProvider in ChatProviders)
{
try
{
ChatProvider.SendMessage(msg, mt);
}
catch (Exception e)
{
WriteWarning(String.Format("Chat broadcast failed (Provider: {3}) (Flags: {0}) (Message: {1}): {2}", mt, msg, e.ToString(), ChatProvider.ProviderInfo().Provider), EventID.ChatBroadcastFail);
}
}
}
}
static void Main(string[] args)
{
//UserProvider usrPrv = new UserProvider();
//var user = usrPrv.GetUserById(1);
//var user2 = usrPrv.GetUserById(5);
//var way = usrPrv.GetWayBetweenFriends(user, user2);
//Console.WriteLine("{0},{1},{2}",way[0].FirstName,
// way[1].FirstName,
// way[2].FirstName);
ChatProvider c = new ChatProvider();
UserProvider u = new UserProvider();
var user = u.GetUserById(2);
var chat = c.GetChatById(3);
c.AddUserToChat(user, chat);
Console.ReadLine();
}
public Chat GetOrCreateChatWithUser(User sender, User receiver, Include <Chat> include = null)
{
var chat = ChatProvider.All(include)
.Include(c => c.UserChats)
.ThenInclude(uc => uc.User)
.FirstOrDefault(c => c.UserChats.Select(uc => uc.User.UserId).Contains(receiver.UserId));
if (chat == null)
{
chat = new Chat {
Type = ChatType.Personal
};
ChatProvider.Add(chat);
AddUserToChat(sender, chat);
AddUserToChat(receiver, chat);
}
return(chat);
}
public ChatStatusCommand(ChatProvider pI)
{
Keyword = "status";
providerIndex = (int)pI;
}
public IQueryable <Chat> GetUserChats(User user)
{
return(ChatProvider.All().Include(c => c.UserChats)
.Where(c => c.UserChats.Any(uc => uc.UserId == user.UserId)));
}
public ChatPartCommand(ChatProvider pI)
{
Keyword = "part";
RequiredParameters = 2;
providerIndex = (int)pI;
}
public virtual void Dispose()
{
ChatProvider.Dispose();
MessageProvider.Dispose();
}
/// <summary>
/// Update this chat
/// </summary>
/// <param name="chat"></param>
/// <returns>Result</returns>
public bool UpdateChat(ChatDTO chat)
{
Logger.log.Debug("at WCFService.ChatService.UpdateChat");
return(ChatProvider.UpdateChat(_chatConverter.ToBusinessEntity(chat)));
}
public ChatListAdminsCommand(ChatProvider pI)
{
Keyword = "list-admins";
providerIndex = (int)pI;
}
public ChatReconnectCommand(ChatProvider pI)
{
Keyword = "reconnect";
providerIndex = pI;
}
public ChatServiceTests()
{
_chatClient = new ChatServiceReference.ChatServiceClient();
_userClient = new UserServiceReference.UserServiceClient();
ChatProvider = new ChatProvider();
}
public ChatJoinCommand(ChatProvider pI)
{
Keyword = "join";
RequiredParameters = 2;
providerIndex = (int)pI;
}
public ChatDeadminCommand(ChatProvider pI)
{
Keyword = "deadmin";
RequiredParameters = 1;
providerIndex = (int)pI;
}
public ChatDisableCommand(ChatProvider pI)
{
Keyword = "disable";
providerIndex = (int)pI;
}
