public async Task <IActionResult> Broadcasts(bool upcoming = true, int page = 1)
{
var filter = new BroadcastFilter(page)
{
Upcoming = upcoming
};
var broadcastList = await _mailService.PageBroadcastsAsync(filter);
var paginateModel = new PaginateViewModel
{
ItemCount = broadcastList.Count,
CurrentPage = page,
ItemsPerPage = filter.Take.Value
};
if (paginateModel.PastMaxPage)
{
return(RedirectToRoute(
new
{
page = paginateModel.LastPage ?? 1
}));
}
var viewModel = new BroadcastListViewModel
{
Broadcasts = broadcastList.Data,
PaginateModel = paginateModel,
Upcoming = upcoming
};
return(View(viewModel));
}
/// <summary>
/// Sends a reliable command to all open connections (optionally filtered).
/// </summary>
public int SendReliableCommandToAll(BroadcastFilter filter, byte flags, string opcode, string[] fields)
{
int i;
Connection[] cons;
//Don't send anything.
if (filter == BroadcastFilter.None)
{
return(UdpConsts.UDP_OK);
}
//We are sending to servers?
if ((filter & BroadcastFilter.Servers) > BroadcastFilter.None)
{
this.GetConnections(true, out cons);
if (cons != null)
{
for (i = 0; i < cons.Length; i++)
{
//Does the connection need to be authed?
if ((filter & BroadcastFilter.AuthedOnly) > BroadcastFilter.None)
{
if (!cons[i].Authed)
{
continue;
}
}
cons[i].SendReliableCommand(flags, opcode, fields);
}
}
}
//We are sending to clients?
if ((filter & BroadcastFilter.Clients) > BroadcastFilter.None)
{
this.GetConnections(false, out cons);
if (cons != null)
{
for (i = 0; i < cons.Length; i++)
{
if ((filter & BroadcastFilter.AuthedOnly) > BroadcastFilter.None)
{
if (!cons[i].Authed)
{
continue;
}
}
cons[i].SendReliableCommand(flags, opcode, fields);
}
}
}
return(UdpConsts.UDP_OK);
}
/// <summary>
/// 广播localmsg
/// </summary>
/// <param name="lmsg"></param>
/// <param name="filter"></param>
public void BroadcastLocalMessage(ILocalMessage msg, BroadcastFilter filter = null)
{
foreach (var item in m_playerSid2CtxDic)
{
// 使用过滤器
if (filter != null && !filter(item.Value))
{
continue;
}
item.Value.PostLocalMessage(msg);
}
}
private IQueryable <Model.Broadcast> ApplyFilters(BroadcastFilter filter)
{
var broadcasts = DbSet.AsNoTracking()
.Where(_ => _.SiteId == filter.SiteId);
if (filter.Upcoming == true)
{
broadcasts = broadcasts.Where(_ => _.SendAt >= _dateTimeProvider.Now);
}
else if (filter.Upcoming == false)
{
broadcasts = broadcasts.Where(_ => _.SendAt < _dateTimeProvider.Now);
}
return(broadcasts);
}
public async Task <ICollection <Broadcast> > PageAsync(BroadcastFilter filter)
{
var broadcasts = ApplyFilters(filter);
if (filter.Upcoming == false)
{
broadcasts = broadcasts.OrderByDescending(_ => _.SendAt);
}
else
{
broadcasts = broadcasts.OrderBy(_ => _.SendAt);
}
return(await broadcasts
.ApplyPagination(filter)
.ProjectTo <Broadcast>()
.ToListAsync());
}
public void FilterBroadcastTest()
{
broadcastFilter = new BroadcastFilter();
// Check for new videos to process.
var files = Directory.GetFiles(TestHelper.twitchVodsPath);
List <string> videosToProcess = new List <string>();
// Filter out non video files.
foreach (var file in files)
{
if (file.EndsWith(".mp4"))
{
videosToProcess.Add(file);
}
}
// Filter broadcast.
filteredMatches = broadcastFilter.FilterBroadcasts(videosToProcess, testConfiguration: true);
// Assert that filteredMatches has correct information.
Assert.True(filteredMatches.Count == 1);
Assert.True(filteredMatches[0].Broadcast.Id == 317396487);
Assert.True(filteredMatches[0].Broadcast.StartTime.Ticks == 636740622290000000);
Assert.True(filteredMatches[0].Matches.Count == 1);
Assert.True(filteredMatches[0].Matches[0].Id == 1);
Assert.True(!filteredMatches[0].Matches[0].IsInstantReplay);
Assert.True(filteredMatches[0].Matches[0].Segments.Count == 6);
Assert.True(filteredMatches[0].Matches[0].Segments[0].StartTime == 6071.9441215822417);
Assert.True(filteredMatches[0].Matches[0].Segments[0].EndTime == 6232.6195459037581);
var processedFileLocation = Helper.TwitchVodsPath + "processed\\" + videosToProcess[0].Split("\\").Last();
// Assert that the Twitch VOD video got moved to processed.
Assert.True(File.Exists(processedFileLocation));
// Assert that the right matches, highlights and csv files were created.
Assert.True(Directory.Exists(filteredMatches[0].GetDirectoryPath()));
Assert.True(File.Exists(filteredMatches[0].GetDirectoryPath() + "match1.mp4"));
Assert.True(File.Exists(filteredMatches[0].GetDirectoryPath() + "match1.csv"));
// Move the Twitch VOD video back to its original location.
File.Move(processedFileLocation, videosToProcess[0]);
}
public int SendReliableCommandToAll(BroadcastFilter filter, byte flags, string opcode, string[] fields)
{
if (filter == BroadcastFilter.None)
{
return(UdpConsts.UDP_OK);
}
if ((filter & BroadcastFilter.Servers) > BroadcastFilter.None)
{
Connection[] array;
this.GetConnections(true, out array);
if (array != null)
{
for (int i = 0; i < array.Length; i++)
{
if ((filter & BroadcastFilter.AuthedOnly) <= BroadcastFilter.None || array[i].Authed)
{
array[i].SendReliableCommand(flags, opcode, fields);
}
}
}
}
if ((filter & BroadcastFilter.Clients) > BroadcastFilter.None)
{
Connection[] array;
this.GetConnections(false, out array);
if (array != null)
{
for (int i = 0; i < array.Length; i++)
{
if ((filter & BroadcastFilter.AuthedOnly) <= BroadcastFilter.None || array[i].Authed)
{
array[i].SendReliableCommand(flags, opcode, fields);
}
}
}
}
return(UdpConsts.UDP_OK);
}
public async Task <DataWithCount <ICollection <Broadcast> > > PageBroadcastsAsync(BroadcastFilter filter)
{
var authId = GetClaimId(ClaimType.UserId);
if (HasPermission(Permission.SendBroadcastMail))
{
filter.SiteId = GetClaimId(ClaimType.SiteId);
return(new DataWithCount <ICollection <Broadcast> >
{
Data = await _broadcastRepository.PageAsync(filter),
Count = await _broadcastRepository.CountAsync(filter)
});
}
else
{
_logger.LogError($"User {authId} doesn't have permission to view broadcasts.");
throw new GraException("Permission denied");
}
}
public static void SyncLatestPlatform(byte type, byte[] content, ObjectId senderId, BroadcastFilter filter)
{
dealerListener.SyncLatestPlatform(type, content, senderId, filter);
}
public async Task <int> CountAsync(BroadcastFilter filter)
{
return(await ApplyFilters(filter)
.CountAsync());
}
private void SyncPrivate(RelayCode relayCode, byte contentCode, byte[] content, ObjectId senderOid, BroadcastFilter filter)
{
if (!_roomJoined)
{
OrLog(LogLevel.VeryVerbose, "Couldnt send Sync");
return;
}
if (filter.DestCode == DestinationCode.MasterOnly)
{
OrLog(LogLevel.VeryVerbose, "send receivers type master client " + filter.DestCode + " master client id is :" + MasterClient.ID.ToString());
}
else if (filter.DestCode == DestinationCode.Include && filter.Destinations.Length > 0)
{
OrLog(LogLevel.VeryVerbose, "send receivers type include " + filter.DestCode);
foreach (var t in filter.Destinations)
{
OrLog(LogLevel.VeryVerbose, "send target id " + t.ToString());
}
}
else if (filter.DestCode == DestinationCode.Exclude && filter.Destinations.Length > 0)
{
OrLog(LogLevel.VeryVerbose, "send receivers type exclude " + filter.DestCode);
foreach (var t in filter.Destinations)
{
OrLog(LogLevel.VeryVerbose, "send target id " + t.ToString());
}
}
//else if(options.DestCode == DestinationCode.All)
//else if (options.DestCode == DestinationCode.Broadcast)
else
{
OrLog(LogLevel.VeryVerbose, "send receivers type all " + filter.DestCode);
}
var headerBytes = Header.CreateHeader(
Definitions.FrameVersion,
relayCode,
(byte)contentCode,
0,
(byte)filter.DestCode,
(PlayerId)LoginId,
(ObjectId)senderOid,
(UInt16)filter.Destinations.Length,
(UInt16)content.Length
);
var destPidsSize = sizeof(UInt16) * filter.Destinations.Length;
var contentSize = content.Length;
var messageBytes = new byte[headerBytes.Length + destPidsSize + contentSize];
var stream = new MemoryStream(messageBytes);
var message = new EndiannessBinaryWriter(stream);
try
{
message.Write(headerBytes);
if (destPidsSize > 0)
{
message.Write(new byte[destPidsSize]);
Buffer.BlockCopy(filter.Destinations, 0, messageBytes, headerBytes.Length, destPidsSize);
}
message.Write(content);
OrLog(LogLevel.VeryVerbose, "prepare Sync: " + BitConverter.ToString(messageBytes));
statefullQueue.Enqueue(messageBytes);
}
catch (Exception e)
{
OrLogError(LogLevel.Info, "error: " + e.Message);
OrLogError(LogLevel.Verbose, "stacktrace: " + e.StackTrace);
}
message.Close();
stream.Close();
}
public void SyncLatestPlatform(byte contentCode, byte[] content, ObjectId senderOid, BroadcastFilter filter)
{
OrLog(LogLevel.VeryVerbose, "MessageSend RelayCode.UNITY_CDK_RELAY_LATEST");
SyncPrivate(RelayCode.UNITY_CDK_RELAY_LATEST, contentCode, content, senderOid, filter);
}
public void SyncStream(byte contentCode, byte[] content, ObjectId senderOid, BroadcastFilter filter)
{
OrLog(LogLevel.VeryVerbose, "MessageSend RelayCode.RELAY_STREAM");
SyncPrivate(RelayCode.RELAY_STREAM, contentCode, content, senderOid, filter);
}
/// <summary>
/// Sends a reliable command to all open connections (optionally filtered).
/// </summary>
public int SendReliableCommandToAll(BroadcastFilter filter, byte flags, string opcode, string[] fields)
{
int i;
Connection[] cons;
//Don't send anything.
if(filter == BroadcastFilter.None)
return UdpConsts.UDP_OK;
//We are sending to servers?
if((filter & BroadcastFilter.Servers) > BroadcastFilter.None)
{
this.GetConnections(true, out cons);
if(cons != null)
{
for(i = 0; i < cons.Length; i++)
{
//Does the connection need to be authed?
if((filter & BroadcastFilter.AuthedOnly) > BroadcastFilter.None)
if(!cons[i].Authed)
continue;
cons[i].SendReliableCommand(flags, opcode, fields);
}
}
}
//We are sending to clients?
if((filter & BroadcastFilter.Clients) > BroadcastFilter.None)
{
this.GetConnections(false, out cons);
if(cons != null)
{
for(i = 0; i < cons.Length; i++)
{
if((filter & BroadcastFilter.AuthedOnly) > BroadcastFilter.None)
if(!cons[i].Authed)
continue;
cons[i].SendReliableCommand(flags, opcode, fields);
}
}
}
return UdpConsts.UDP_OK;
}
