public XDMessagingClient()
{
var container = SimpleIocContainerBootstrapper.GetInstance();
Listeners = new Listeners(this, container);
Broadcasters = new Broadcasters(this, container);
}
public async Task <NotificationResultDto> Handle(CreateBroadcastersCommand command, CancellationToken cancellationToken)
{
try
{
if (!command.Valid())
{
return(_handlerResponse.Response(command.IsValid, command.Notifications));
}
var broadcasterEntities = await _broadcastersRepository.GetByNameAsync(command.BrodcastersName);
var broadcaster = new Broadcasters(command.BrodcastersName);
if (broadcasterEntities != null)
{
broadcaster.NameUnavailable();
}
if (broadcaster.IsValid)
{
await _broadcastersRepository.InsertAsync(broadcaster);
}
AddNotifications(broadcaster);
}
catch (Exception ex)
{
AddNotification("500", ex.Message);
}
return(_handlerResponse.Response(IsValid, Notifications));
}
public async Task <IActionResult> Get([FromRoute] int twitchId, [FromQuery] string username = "")
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Broadcasters broadcaster = new Broadcasters();
if (!string.IsNullOrEmpty(username))
{
broadcaster = await _context.Broadcasters.SingleOrDefaultAsync(m => m.Username == username && m.TwitchId == twitchId);
}
else
{
broadcaster = await _context.Broadcasters.SingleOrDefaultAsync(m => m.TwitchId == twitchId);
}
if (broadcaster == null)
{
return(NotFound());
}
return(Ok(broadcaster));
}
public async Task UpdateBroadcaster(string twitchBotApiLink)
{
Broadcasters updatedBroadcaster = new Broadcasters
{
Username = Username,
TwitchId = int.Parse(TwitchId)
};
await ApiBotRequest.PutExecuteTaskAsync(twitchBotApiLink + $"broadcasters/update/{TwitchId}", updatedBroadcaster);
}
public async Task AddBroadcaster(string twitchBotApiLink)
{
Broadcasters freshBroadcaster = new Broadcasters
{
Username = Username,
TwitchId = int.Parse(TwitchId)
};
await ApiBotRequest.PostExecuteTaskAsync(twitchBotApiLink + $"broadcasters/create", freshBroadcaster);
}
public async Task <IActionResult> Create([FromBody] Broadcasters broadcaster)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Broadcasters.Add(broadcaster);
await _context.SaveChangesAsync();
return(CreatedAtAction("Get", new { twitchId = broadcaster.TwitchId }, broadcaster));
}
public async Task <NotificationResultDto> Handle(UpdateBroadcastersCommand command, CancellationToken cancellationToken)
{
try
{
if (!command.Valid())
{
return(_handlerResponse.Response(command.IsValid, command.Notifications));
}
var broadcasterEntities = await _broadcastersRepository.GetByIdAsync(command.Id);
if (broadcasterEntities != null)
{
var broadcaster = await _broadcastersRepository.GetByNameAsync(command.BrodcastersName);
if (broadcaster != null)
{
broadcasterEntities.NameUnavailable();
}
if (broadcasterEntities.IsValid)
{
broadcasterEntities.Update(command.BrodcastersName);
if (broadcasterEntities.IsValid)
{
await _broadcastersRepository.UpdateAsync(broadcasterEntities);
}
}
AddNotifications(broadcasterEntities);
}
else
{
var broadcasters = new Broadcasters();
broadcasters.NotBrodcastersForUpdate();
AddNotifications(broadcasters);
}
}
catch (Exception ex)
{
AddNotification("500", ex.Message);
}
return(_handlerResponse.Response(IsValid, Notifications));
}
public async Task <NotificationResultDto> DeleteAsync(string id)
{
var broadcasters = await _broadcastersRepository.GetByIdAsync(id);
if (broadcasters != null)
{
await _broadcastersRepository.DeleteAsync(broadcasters);
return(new NotificationResultDto(true, null));
}
else
{
var brodcastersNotification = new Broadcasters();
brodcastersNotification.BrodcastersUnavailable();
return(new NotificationResultDto(false, brodcastersNotification.Notifications));
}
}
public async Task FindBroadcaster(string twitchId, string twitchBotApiLink, string username = "")
{
Broadcasters broadcaster = null;
if (!string.IsNullOrEmpty(username))
{
broadcaster = await ApiBotRequest.GetExecuteTaskAsync <Broadcasters>(twitchBotApiLink + $"broadcasters/get/{twitchId}?username={username}");
}
else
{
broadcaster = await ApiBotRequest.GetExecuteTaskAsync <Broadcasters>(twitchBotApiLink + $"broadcasters/get/{twitchId}");
}
if (broadcaster != null)
{
Username = broadcaster.Username;
TwitchId = twitchId;
DatabaseId = broadcaster.Id;
}
}
public async Task <IActionResult> Update([FromRoute] int twitchId, [FromBody] Broadcasters broadcaster)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (twitchId != broadcaster.TwitchId)
{
return(BadRequest());
}
Broadcasters updatedbroadcaster = await _context.Broadcasters.FirstOrDefaultAsync(m => m.TwitchId == twitchId);
if (updatedbroadcaster == null)
{
return(NotFound());
}
updatedbroadcaster.Username = broadcaster.Username;
_context.Broadcasters.Update(updatedbroadcaster);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BroadcasterExists(twitchId))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
IQueueBroadcaster Broadcaster <M>()
where M : new()
=> Broadcasters.GetOrAdd(
QueueConnector.Define <M>(C.Host),
connector => QueueBroadcaster.Define <M>(C, connector));
IQueueBroadcaster Broadcaster(Type MessageType)
=> Broadcasters.GetOrAdd(
QueueConnector.Define(C.Host, MessageType),
connector => QueueBroadcaster.Define(C, MessageType, connector));
public static IXDBroadcaster GetWindowsMessagingBroadcaster(this Broadcasters client)
{
return(client.GetBroadcasterForMode(XDTransportMode.HighPerformanceUI));
}
public static IXDBroadcaster GetIoStreamBroadcaster(this Broadcasters client)
{
return(client.Container.Resolve <XDIOStreamBroadcaster>());
}
public static IXDBroadcaster GetAmazonBroadcaster(this Broadcasters client)
{
return(client.Container.Resolve <XDAmazonBroadcaster>());
}
// ReSharper disable once InconsistentNaming
public static IXDBroadcaster GetIOStreamBroadcaster(this Broadcasters client)
{
return(client.GetBroadcasterForMode(XDTransportMode.Compatibility));
}
public static IXDBroadcaster GetMulticastBroadcaster(this Broadcasters client,
params IXDBroadcaster[] broadcasters)
{
return(new MulticastBroadcaster(broadcasters));
}
public async Task LogError(Exception ex, string className, string methodName, bool hasToExit, string botCmd = "N/A", string userMsg = "N/A")
{
Console.WriteLine("Error: " + ex.Message);
try
{
/* If username not available, grab default user to show local error after db connection */
if (_broadcasterId == 0)
{
Broadcasters broadcaster = await ApiBotRequest.GetExecuteTaskAsync <Broadcasters>(_botConfig.TwitchBotApiLink + $"broadcasters/get/-1");
_broadcasterId = broadcaster.Id;
}
/* Get line number from error message */
int lineNumber = 0;
const string lineSearch = ":line ";
int index = ex.StackTrace.LastIndexOf(lineSearch);
if (index != -1)
{
string lineNumberText = ex.StackTrace.Substring(index + lineSearch.Length);
if (!int.TryParse(lineNumberText, out lineNumber))
{
lineNumber = -1; // couldn't parse line number
}
}
ErrorLog error = new ErrorLog
{
ErrorTime = DateTime.UtcNow,
ErrorLine = lineNumber,
ErrorClass = className,
ErrorMethod = methodName,
ErrorMsg = ex.Message,
Broadcaster = _broadcasterId,
Command = botCmd,
UserMsg = userMsg
};
await ApiBotRequest.PostExecuteTaskAsync(_botConfig.TwitchBotApiLink + $"errorlogs/create", error);
string publicErrMsg = "I ran into an unexpected internal error! "
+ "@" + _botConfig.Broadcaster + " please look into the error log when you have time";
if (hasToExit)
{
publicErrMsg += " I am leaving as well. Have a great time with this stream everyone KonCha";
}
if (_irc != null)
{
_irc.SendPublicChatMessage(publicErrMsg);
}
if (hasToExit)
{
Console.WriteLine();
Console.WriteLine("Shutting down now...");
Thread.Sleep(3000);
Environment.Exit(1);
}
}
catch (Exception e)
{
Console.WriteLine();
Console.WriteLine("Logging error found: " + e.Message);
Console.WriteLine("Please inform author of this error!");
Thread.Sleep(5000);
}
}
public static IXDBroadcaster GetMulticastBroadcaster(this Broadcasters client,
IEnumerable <IXDBroadcaster> broadcasters)
{
return(new MulticastBroadcaster(broadcasters));
}
public static IXDBroadcaster GetAmazonBroadcaster(this Broadcasters client)
{
return(client.GetBroadcasterForMode(XDTransportMode.RemoteNetwork));
}
public static IXDBroadcaster GetWindowsMessagingBroadcaster(this Broadcasters client)
{
return(client.Container.Resolve <XDWinMsgBroadcaster>());
}
public XDMessagingClient()
{
Listeners = new Listeners(this, Serializer);
Broadcasters = new Broadcasters(this, Serializer);
}
