private void SetNewOwnerCommand(IDictionary <string, object> command)
{
var character = command.Get(Constants.Arguments.Character);
var channelId = command.Get(Constants.Arguments.Channel);
GeneralChannelModel channel;
lock (chatStateLocker)
channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null)
{
return;
}
var mods = channel.CharacterManager.GetNames(ListKind.Moderator, false).ToList();
mods[0] = character;
channel.CharacterManager.Set(mods, ListKind.Moderator);
var update = new ChannelUpdateModel(channel, new ChannelOwnerChangedEventArgs {
NewOwner = character
});
Events.NewUpdate(update);
}
public BaseResponseDto Update(ChannelUpdateModel channelUpdateModel)
{
BaseResponseDto responseDto = null;
if (channelUpdateModel == null)
{
responseDto = new BaseResponseDto
{
Status = 1,
Message = "Faulthy channel info"
};
return(responseDto);
}
Channel existingChannel = null;
try
{
existingChannel = _uow.GetRepository <Channel>()
.GetAll()
.FirstOrDefault(s => s.ChannelId == channelUpdateModel.ChannelId);
}
catch (Exception e)
{
throw e;
}
if (existingChannel == null)
{
responseDto = new BaseResponseDto
{
Status = 2,
Message = "No existing channel with specified id found"
};
return(responseDto);
}
existingChannel.MentorId = channelUpdateModel.MentorId;
existingChannel.TopicId = channelUpdateModel.TopicId;
existingChannel.IsDisable = channelUpdateModel.IsDisable;
try
{
_uow.GetRepository <Channel>().Update(existingChannel);
_uow.Commit();
}
catch (Exception e)
{
throw e;
}
responseDto = new BaseResponseDto
{
Status = 0,
Message = "Success"
};
return(responseDto);
}
public async Task UpdateV5Channel(V5API.Channel.ChannelModel channel, string status = null, GameModel game = null)
{
ChannelUpdateModel update = new ChannelUpdateModel()
{
status = (!string.IsNullOrEmpty(status)) ? status : null,
game = (game != null) ? game.name : null
};
await AsyncRunner.RunAsync(this.Connection.V5API.Channels.UpdateChannel(channel, update));
}
private void ChannelBanListCommand(IDictionary <string, object> command)
{
lock (chatStateLocker)
{
var channelId = command.Get(Constants.Arguments.Channel);
var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null)
{
RequeueCommand(command);
return;
}
var @event = new ChannelUpdateModel(channel, new ChannelTypeBannedListEventArgs());
if (command.ContainsKey(Constants.Arguments.Message))
{
var msg = command.Get(Constants.Arguments.Message);
var banlist = msg.Split(new[] { ",", ":", "has been" }, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (msg.ContainsOrdinal("has been"))
{
var character = banlist[0];
channel.CharacterManager.Remove(character, ListKind.Banned);
Events.NewUpdate(@event);
return;
}
channel.CharacterManager.Set(banlist.Skip(1).Where(x => !string.IsNullOrWhiteSpace(x)),
ListKind.Banned);
Events.NewUpdate(@event);
return;
}
var message = channelId.Split(':');
var banned = message[1].Trim();
if (banned.IndexOf(',') == -1)
{
channel.CharacterManager.Add(banned, ListKind.Banned);
}
else
{
channel.CharacterManager.Set(banned.Split(','), ListKind.Banned);
}
Events.NewUpdate(@event);
}
}
private void SetNewOwnerCommand(IDictionary<string, object> command)
{
var character = command.Get(Constants.Arguments.Character);
var channelId = command.Get(Constants.Arguments.Channel);
var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null) return;
var mods = channel.CharacterManager.GetNames(ListKind.Moderator, false).ToList();
mods[0] = character;
channel.CharacterManager.Set(mods, ListKind.Moderator);
var update = new ChannelUpdateModel(channel, new ChannelOwnerChangedEventArgs {NewOwner = character});
Events.NewUpdate(update);
}
private void ChannelBanListCommand(IDictionary<string, object> command)
{
lock (chatStateLocker)
{
var channelId = command.Get(Constants.Arguments.Channel);
var channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null)
{
RequeueCommand(command);
return;
}
var @event = new ChannelUpdateModel(channel, new ChannelTypeBannedListEventArgs());
if (command.ContainsKey(Constants.Arguments.Message))
{
var msg = command.Get(Constants.Arguments.Message);
var banlist = msg.Split(new[] {",", ":", "has been"}, StringSplitOptions.RemoveEmptyEntries)
.Select(x => x.Trim())
.ToList();
if (msg.ContainsOrdinal("has been"))
{
var character = banlist[0];
channel.CharacterManager.Remove(character, ListKind.Banned);
Events.NewUpdate(@event);
return;
}
channel.CharacterManager.Set(banlist.Skip(1).Where(x => !string.IsNullOrWhiteSpace(x)),
ListKind.Banned);
Events.NewUpdate(@event);
return;
}
var message = channelId.Split(':');
var banned = message[1].Trim();
if (banned.IndexOf(',') == -1)
channel.CharacterManager.Add(banned, ListKind.Banned);
else
channel.CharacterManager.Set(banned.Split(','), ListKind.Banned);
Events.NewUpdate(@event);
}
}
private void KickCommand(IDictionary <string, object> command)
{
var kicker = command.Get("operator");
var channelId = command.Get(Constants.Arguments.Channel);
var kicked = command.Get(Constants.Arguments.Character);
var isBan = command.Get(Constants.Arguments.Command) == Constants.ServerCommands.ChannelBan;
GeneralChannelModel channel;
lock (chatStateLocker)
channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null)
{
RequeueCommand(command);
return;
}
if (ChatModel.CurrentCharacter.NameEquals(kicked))
{
kicked = "you";
}
var args = new ChannelDisciplineEventArgs
{
IsBan = isBan,
Kicked = kicked,
Kicker = kicker
};
var update = new ChannelUpdateModel(channel, args);
if (kicked == "you")
{
channels.RemoveChannel(channelId);
}
else
{
channel.CharacterManager.SignOff(kicked);
}
if (isBan)
{
channel.CharacterManager.Add(kicked, ListKind.Banned);
}
Events.NewUpdate(update);
}
public void UpdateChannel()
{
TestWrapper(async(TwitchConnection connection) =>
{
ChannelModel channel = await ChannelsServiceUnitTests.GetCurrentChannel(connection);
ChannelUpdateModel update = new ChannelUpdateModel()
{
status = "Test Status - " + DateTimeOffset.Now.ToString()
};
ChannelModel result = await connection.V5API.Channels.UpdateChannel(channel, update);
Assert.IsNotNull(result);
Assert.IsNotNull(result.id);
Assert.AreEqual(result.status, update.status);
});
}
public IActionResult Update(ChannelUpdateModel channelUpdateModel)
{
BaseResponseDto responseDto = null;
if (channelUpdateModel == null)
{
return(BadRequest("Sharing info must not be null"));
}
try
{
responseDto = _channel.Update(channelUpdateModel);
}
catch (Exception e)
{
return(StatusCode(500, e));
}
return(Ok(responseDto.Message));
}
private void KickCommand(IDictionary<string, object> command)
{
var kicker = command.Get("operator");
var channelId = command.Get(Constants.Arguments.Channel);
var kicked = command.Get(Constants.Arguments.Character);
var isBan = command.Get(Constants.Arguments.Command) == Constants.ServerCommands.ChannelBan;
GeneralChannelModel channel;
lock (chatStateLocker)
channel = ChatModel.CurrentChannels.FirstByIdOrNull(channelId);
if (channel == null)
{
RequeueCommand(command);
return;
}
if (ChatModel.CurrentCharacter.NameEquals(kicked))
kicked = "you";
var args = new ChannelDisciplineEventArgs
{
IsBan = isBan,
Kicked = kicked,
Kicker = kicker
};
var update = new ChannelUpdateModel(channel, args);
if (kicked == "you")
channels.RemoveChannel(channelId);
else
channel.CharacterManager.SignOff(kicked);
if (isBan)
{
channel.CharacterManager.Add(kicked, ListKind.Banned);
}
Events.NewUpdate(update);
}
private void KickCommand(IDictionary<string, object> command)
{
var kicker = command.Get("operator");
var channelId = command.Get(Constants.Arguments.Channel);
var kicked = command.Get(Constants.Arguments.Character);
var isBan = command.Get(Constants.Arguments.Command) == Commands.ChannelBan;
var channel = ChatModel.FindChannel(channelId) as GeneralChannelModel;
if (kicked.Equals(ChatModel.CurrentCharacter.Name, StringComparison.OrdinalIgnoreCase))
kicked = "you";
var args = new ChannelUpdateModel.ChannelDisciplineEventArgs
{
IsBan = isBan,
Kicked = kicked,
Kicker = kicker
};
var update = new ChannelUpdateModel(channel, args);
if (kicked == "you")
manager.RemoveChannel(channelId);
else
channel.CharacterManager.SignOff(kicked);
Events.GetEvent<NewUpdateEvent>().Publish(update);
}
/// <summary>
/// Updates the channel with the specified metadata.
/// </summary>
/// <param name="channel">The channel to update</param>
/// <param name="update">The metadata to update</param>
/// <returns>The updated channel</returns>
public async Task <PrivateChannelModel> UpdateChannel(ChannelModel channel, ChannelUpdateModel update)
{
Validator.ValidateVariable(update, "update");
return(await this.PutAsync <PrivateChannelModel>("channels/" + channel.id, AdvancedHttpClient.CreateContentFromObject(new { channel = update })));
}
/// <summary>
/// Conversion method for received data
/// </summary>
/// <param name="data"></param>
/// <returns></returns>
public DataPointImpl[] ParseData(string data, DateTime occured)
{
//Check if this is legacy data
if (_datafeedversion == 1)
{
return(ParseDataV1(data));
}
//Parse data
SocketMethodModel <OrderBookParamsModel> orderbooksnapshot = null;
SocketMethodModel <OrderBookParamsModel> orderbookupdate = null;
SocketMethodModel <TradesParamsModel> tradeupdate = null;
ChannelUpdateModel channelupdate = null;
if (data.Contains("updateOrderbook"))
{
orderbookupdate = JSON.Deserialize <SocketMethodModel <OrderBookParamsModel> >(data);
}
else if (data.Contains("snapshotOrderbook"))
{
orderbooksnapshot = JSON.Deserialize <SocketMethodModel <OrderBookParamsModel> >(data);
}
else if (data.Contains("updateTrades"))
{
tradeupdate = JSON.Deserialize <SocketMethodModel <TradesParamsModel> >(data);
}
else if (data.Contains("channel"))
{
return(new DataPointImpl[0]);
}
else if (data.Contains("result"))
{
//Process method request
var request = JSON.Deserialize <SocketMethodModel <SymbolRequestModel> >(data);
if (request.Result)
{
_symbolRequests.RemoveAll(x => x.Id == request.Id);
}
else
{
var found = _symbolRequests.FirstOrDefault(x => x.Id == request.Id);
if (found != null)
{
_log.Debug($"Request for HitBTC failed, retrying. Request body: {JSON.Serialize(request)}");
SendRequest(found);
}
}
//Return nothing
return(new DataPointImpl[0]);
}
else
{
return(new DataPointImpl[0]);
}
//Set return object
var toreturn = new List <DataPointImpl>();
//Check orderbook snapshot
if (orderbooksnapshot != null)
{
//Reset orderbook and recreate
var snapshot = orderbooksnapshot.Params;
//Check sequence number
var fullseqno = snapshot.Sequence + snapshot.Symbol + "snapshot";
if (_seqnomemory.Contains(fullseqno))
{
return(toreturn.ToArray());
}
else
{
_seqnomemory.Enqueue(fullseqno);
}
//Check order book and data
if (!_orderbook.TryGetValue(snapshot.Symbol, out var fullOrderBook))
{
fullOrderBook = new OrderBook(snapshot.Symbol);
_orderbook[snapshot.Symbol] = fullOrderBook;
}
//Reset order book
fullOrderBook.Clear();
snapshot.Bid.ForEach(b => fullOrderBook.AddQuote(true, b.DoublePrice, b.DoubleSize));
snapshot.Ask.ForEach(a => fullOrderBook.AddQuote(false, a.DoublePrice, a.DoubleSize));
}
//Check orderbook update
if (orderbookupdate != null)
{
var seqno = orderbookupdate.Params.Symbol + orderbookupdate.Params.Sequence;
if (_seqnomemory.Contains(seqno))
{
return(null);
}
else
{
_seqnomemory.Enqueue(seqno);
}
//Check order book and data
if (!_orderbook.TryGetValue(orderbookupdate.Params.Symbol, out var orderbook))
{
orderbook = new OrderBook(orderbookupdate.Params.Symbol);
_orderbook[orderbookupdate.Params.Symbol] = orderbook;
}
//Check for quote updates in the order book (size == 0 = remove from order book)
bool update = orderbookupdate.Params.Ask.Count(x => orderbook.AddQuote(false, x.DoublePrice, x.DoubleSize)) > 0;
update = orderbookupdate.Params.Bid.Count(x => orderbook.AddQuote(true, x.DoublePrice, x.DoubleSize)) > 0 | update;
//Check if we need to update level 0 quote
if (update)
{
//Deserialize tick
toreturn.Add(new Tick(GetQuantlerTicker(orderbookupdate.Params.Symbol), DataSource)
{
AskPrice = Convert.ToDecimal(orderbook.BestAsk),
BidPrice = Convert.ToDecimal(orderbook.BestBid),
AskSize = Convert.ToDecimal(orderbook.AskSize),
BidSize = Convert.ToDecimal(orderbook.BidSize),
Depth = 0,
Occured = occured,
TimeZone = TimeZone.Utc
});
}
}
//Check for trade updates
if (tradeupdate != null)
{
tradeupdate.Params.Data.ForEach(trade =>
{
toreturn.Add(new Tick(GetQuantlerTicker(tradeupdate.Params.Symbol), DataSource)
{
Occured = occured,
TimeZone = TimeZone.Utc,
TradePrice = Convert.ToDecimal(trade.Price),
Size = Convert.ToDecimal(trade.Quantity) * (trade.Side == "sell" ? -1 : 1)
});
});
}
//Return what we have
return(toreturn.ToArray());
}
