private IAsset CreateAndConfigureAsset(ZetronMstIncidents zetronMstIncidents, out ILocator originLocator)
{
//Create asset
IAsset asset = null;
try
{
asset = _mediaContext.Assets.Create("Asset_" + zetronMstIncidents.IncidentId.ToString(), AssetCreationOptions.None);
// Create a 30 - day readonly access policy.
IAccessPolicy accessPolicy = _mediaContext.AccessPolicies.Create("Streaming policy",
TimeSpan.FromDays(30),
AccessPermissions.Read);
// Create a locator to the streaming content on an origin.
originLocator = _mediaContext.Locators.CreateLocator(LocatorType.OnDemandOrigin, asset,
accessPolicy,
DateTime.UtcNow.AddMinutes(-5));
}
catch (Exception ex)
{
Log(ex.Message);
throw;
}
return(asset);
}
public async void StartAzureProcess(ZetronMstIncidents zetronMstIncidents)
{
try
{
await Task.Run(() =>
{
StartChannel();
if (_channel != null)
{
ILocator originLocator;
//Create asset for storage
IAsset asset = CreateAndConfigureAsset(zetronMstIncidents, out originLocator);
if (asset != null)
{
//Create and start live program and configure storage for it
CreateAndStartProgram(asset, originLocator, zetronMstIncidents);
}
}
});
}
catch (Exception ex)
{
Log(ex.Message);
throw;
}
}
public IActionResult Index()
{
incidents = new ZetronMstIncidents();
using (HttpClientHandler httpClientHandler = new HttpClientHandler())
{
httpClientHandler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => { return(true); };
using (var client = new HttpClient(httpClientHandler))
{
try
{
var response = client.GetAsync($"{_api}incidents/Active").Result;
if (!response.IsSuccessStatusCode)
{
return(View(incidents));
}
var allIncidents = JsonConvert.DeserializeObject <ZetronMstIncidents>(response.Content.ReadAsStringAsync().Result);
//var activeIncidents = allIncidents.Where(i => (i.Status != (int)IncidentStatus.Deactivated));
if (allIncidents != null)
{
incidents = allIncidents;
}
}
catch (Exception ex)
{
incidents.liveData = new Models.Live();
return(View(incidents));
}
}
}
incidents.liveData = new Models.Live();
return(View(incidents));
}
public async Task <IActionResult> PutZetronMstIncidents([FromRoute] int id, [FromBody] ZetronMstIncidents zetronMstIncidents)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != zetronMstIncidents.IncidentId)
{
return(BadRequest());
}
try
{
var recordtoUpdate = _context.ZetronMstIncidents.Single(i => i.IncidentId == id);
if (recordtoUpdate.Status != zetronMstIncidents.Status)
{
recordtoUpdate.Status = zetronMstIncidents.Status;
Task incidentUpdate = _context.SaveChangesAsync();
switch (zetronMstIncidents.Status)
{
case (int)IncidentStatus.Processing:
//trigger job
incidentUpdate.Wait();
_mediaContext.TriggerJob(id);
break;
case (int)IncidentStatus.Stopped:
_mediaContext.StopAzureProcess(id, IncidentStatus.Stopped);
break;
case (int)IncidentStatus.Deactivated:
_mediaContext.StopAzureProcess(id, IncidentStatus.Deactivated);
break;
default:
break;
}
}
}
catch (DbUpdateConcurrencyException)
{
if (!ZetronMstIncidentsExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(CreatedAtAction("GetZetronMstIncidents", new { id = zetronMstIncidents.IncidentId }, zetronMstIncidents));
}
private async Task UpdateStreamingUrl(IAsset asset, ILocator originLocator, ZetronMstIncidents zetronMstIncidents)
{
try
{
//Get manifest file to create streaming url
IAssetFile manifestFile = asset.AssetFiles.Where(f => f.Name.ToLower().EndsWith(".ism")).FirstOrDefault();
string streamUrl = originLocator.Path + manifestFile.Name + "/manifest(format=m3u8-aapl)";
//var droneDetail = _drone.GetCurrentLocationDetail();
ZetronTrnMediaDetails mediaDetails = new ZetronTrnMediaDetails()
{
IncidentId = zetronMstIncidents.IncidentId,
MediaUrl = streamUrl,
Name = asset.Name,
MediaType = 1,
PostedIon = DateTime.Now.ToUniversalTime(),
PostedBy = "Admin",
Status = true
};
using (var _dbContext = new ZetronContext(options.Options))
{
//var mediaId = _dbContext.ZetronTrnMediaDetails.Max(m => m.MediaId) + 1;
_dbContext.ZetronTrnMediaDetails.Add(mediaDetails);
ZetronMstIncidents recordtoUpdate = null;
if (zetronMstIncidents.Status == (int)IncidentStatus.Started)
{
recordtoUpdate = _dbContext.ZetronMstIncidents.Single(i => i.IncidentId == zetronMstIncidents.IncidentId);
recordtoUpdate.Status = (int)IncidentStatus.Processing;
}
//_dbContext.ZetronTrnDroneLocations.Add(new ZetronTrnDroneLocations()
//{
// MediaID = mediaId,
// DewPoint = droneDetail.DewPoint,
// Humidity = droneDetail.Humidity,
// Temperature = droneDetail.Temperature,
// WindSpeed = droneDetail.WindSpeed,
// Summary = droneDetail.Summary,
// WindDirection = droneDetail.WindDirection,
// Longitude = droneDetail.Longitude,
// Latitude = droneDetail.Latitude
//});
await _dbContext.SaveChangesAsync();
}
}
catch (Exception ex)
{
Log(ex.Message);
throw;
}
}
public async Task <IActionResult> PostZetronMstIncidents([FromBody] ZetronMstIncidents zetronMstIncidents)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.ZetronMstIncidents.Add(zetronMstIncidents);
await _context.SaveChangesAsync();
_mediaContext.StartAzureProcess(zetronMstIncidents);
return(CreatedAtAction("GetZetronMstIncidents", new { id = zetronMstIncidents.IncidentId }, zetronMstIncidents));
}
private async void CreateAndStartProgram(IAsset asset, ILocator originLocator, ZetronMstIncidents zetronMstIncidents)
{
try
{
//Create a new program and allocate asset for it.
//To Do: Check the amount of time the asset will be maintained
IProgram program = await _channel.Programs.CreateAsync("Program-" + zetronMstIncidents.IncidentId.ToString(), TimeSpan.FromHours(8), asset.Id);
if (channelstart != null)
{
Task.WaitAll(channelstart);
}
if (_channel.State == ChannelState.Running)
{
//Start the program
Task prog = program.StartAsync();
Task stream = UpdateStreamingUrl(asset, originLocator, zetronMstIncidents);
Task.WaitAll(prog, stream);
if ((zetronMstIncidents.Status == (int)IncidentStatus.Started) || (zetronMstIncidents.Status == (int)IncidentStatus.Processing))
{
TriggerJob(zetronMstIncidents.IncidentId);
}
}
}
catch (Exception ex)
{
Log(ex.Message);
throw;
}
}
