public async Task <ActionResult <EpisodeModel> > PostEpisode(EpisodeModel episode)
{
_context.Episodes.Add(episode);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetEpisode", new { id = episode.Id }, episode));
}
public IActionResult Episode(string title, int id)
{
EpisodeModel em = null;
using (var connObject = new SqlConnection(configuration.GetConnectionString("MsSQL")))
{
string episodeQuery = @"SELECT v.ID,v.Name, l.Url4 as VideoUrl,v.Description,
s.ID as ShowID,s.Name as ShowName,s.ImageUrl as ShowImageUrl,
c.ID as CommunityID, c.Name as CommunityName
FROM VideoTable v JOIN LinkTable l ON v.LinkID=l.ID
JOIN ShowTable s ON v.ShowID=s.ID
JOIN CommunityTable c ON s.CommunityID=c.ID
WHERE v.ID=" + id;
connObject.Open();
em = connObject.Query <EpisodeModel>(episodeQuery).FirstOrDefault();
string otherEpisodesQuery = @"SELECT ID as EpisodeID,Name as EpisodeName FROM VideoTable WHERE ShowID=" + em.ShowID + " AND ID !=" + em.ID + " ORDER BY Date DESC";
em.OtherEpisodes = connObject.Query <OtherEpisode>(otherEpisodesQuery);
connObject.Close();
}
return(View(em));
}
public async Task <IActionResult> Edit(Guid id, [Bind("Num_ep,Name_ep,Description,SaisonId,ID,UpdatedAt,DeletedAt,Deleted")] EpisodeModel episodeModel)
{
if (id != episodeModel.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(episodeModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EpisodeModelExists(episodeModel.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["SaisonId"] = new SelectList(_context.Serie, "ID", "Description", episodeModel.SaisonId);
return(View(episodeModel));
}
public async Task <IActionResult> PutEpisode(int id, EpisodeModel episode)
{
if (id != episode.Id)
{
return(BadRequest());
}
_context.Entry(episode).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!EpisodeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public int AddEpisode(EpisodeModel episode)
{
//add episode model to db
var newEpisodeEntity = _fallGuysContext.Episodes.Add(episode);
_fallGuysContext.SaveChanges();
//after the episode has been commited to the db, get the new episode id
return(_fallGuysContext.Episodes.SingleOrDefault(e => e.Timestamp == episode.Timestamp).Id);
}
// Check to see if there are any new eps and adds it to db
public void CheckPlayerLog()
{
var newEpisodes = LogParserV2.GetEpisodesFromLog();
if (newEpisodes == null)
{
return;
}
foreach (var newEpisode in newEpisodes)
{
//check timestamps against db to determine if it is actually a new episode
if (_episodeRepository.EpisodeExists(newEpisode.Timestamp))
{
continue;
}
//convert entity to model
var episodeModel = new EpisodeModel
{
Crowns = newEpisode.Crowns,
Fame = newEpisode.Fame,
Kudos = newEpisode.Kudos,
Timestamp = newEpisode.Timestamp,
Season = 1,
EpisodeFinished = newEpisode.EpisodeFinished,
Created = DateTime.UtcNow
};
var id = _episodeRepository.AddEpisode(episodeModel);
//add round models to db
var rounds = new List <RoundModel>();
foreach (var round in newEpisode.RoundEntities)
{
var roundModel = new RoundModel()
{
Kudos = round.Kudos,
Fame = round.Fame,
RoundType = round.RoundType,
Badge = round.Badge,
BonusFame = round.BonusFame,
BonusKudos = round.BonusKudos,
BonusTier = round.BonusTier,
EpisodeId = id,
Position = round.Position,
Qualified = round.Qualified
};
rounds.Add(roundModel);
}
_episodeRepository.AddRounds(rounds);
_logger.LogInformation($"Saved {newEpisode.Timestamp} to db");
}
}
public ActionResult Edit(EpisodeModel model)
{
try
{
// TODO: Add update logic here
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public async Task <IActionResult> Create([Bind("Num_ep,Name_ep,Description,SaisonId,ID,UpdatedAt,DeletedAt,Deleted")] EpisodeModel episodeModel)
{
if (ModelState.IsValid)
{
episodeModel.ID = Guid.NewGuid();
_context.Add(episodeModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["SaisonId"] = new SelectList(_context.Serie, "ID", "Description", episodeModel.SaisonId);
return(View(episodeModel));
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
EpisodeModel = await context.Episodes.FirstOrDefaultAsync(m => m.Id == id);
if (EpisodeModel == null)
{
return(NotFound());
}
return(Page());
}
private async Task IndexEpisodeAsync(int showId, Episode episode)
{
if (!await _episodeService.EpisodeExistsAsync(showId, episode.Season, episode.Number))
{
var episodeModel = new EpisodeModel()
{
TvShowId = showId,
SeasonNumber = episode.Season,
EpisodeNumber = episode.Number,
Summary = episode.Summary
};
await _episodeService.InsertEpisodeAsync(showId, episodeModel);
}
}
public ActionResult Play(string episode)
{
var fullEpisode = MPEServices.MAS.GetTVEpisodeDetailedById(Settings.ActiveSettings.TVShowProvider, episode);
if (fullEpisode != null)
{
EpisodeModel model = new EpisodeModel()
{
Episode = fullEpisode,
Show = MPEServices.MAS.GetTVShowDetailedById(fullEpisode.PID, fullEpisode.ShowId),
Season = MPEServices.MAS.GetTVSeasonDetailedById(fullEpisode.PID, fullEpisode.SeasonId)
};
return(View(model));
}
return(null);
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
EpisodeModel = await context.Episodes.FindAsync(id);
if (EpisodeModel != null)
{
context.Episodes.Remove(EpisodeModel);
await context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public IActionResult GetEpisode(long episodeId)
{
var episode = _episodeService.GetEpisode(episodeId);
var model = new EpisodeModel
{
EpisodeId = episode.Episode_Id,
Title = episode.Title,
OpeningCrawl = episode.Opening_Crawl,
Director = episode.Director,
Producer = episode.Producer,
ReleaseDate = episode.Release_Date,
Rating = episode.Rating
};
var json = JsonHelper <EpisodeModel> .JsonConverter(model);
return(Ok(json));
}
private void AddNewEpisode(EpisodeModel spreakerEpisode, EpisodesFolder cmsEpisodesFolder)
{
var cmsEpisode = _contentService.Create(spreakerEpisode.Title, cmsEpisodesFolder.Id, Episode.ModelTypeAlias, -1);
cmsEpisode.SetValue("spreakerId", spreakerEpisode.Id);
cmsEpisode.SetValue("podcastTitle", spreakerEpisode.Title);
cmsEpisode.SetValue("podcastLink", spreakerEpisode.PlaybackUrl);
cmsEpisode.SetValue("showNotes", spreakerEpisode.Description);
cmsEpisode.SetValue("publishedDate", spreakerEpisode.PublishedDate);
cmsEpisode.SetValue("listensCount", spreakerEpisode.GetListens());
// try and set the correct title for displaying on web page
// format should be either Episode X: title, or SX EpY: Episode
if (spreakerEpisode.Title.Contains(":"))
{
cmsEpisode.SetValue("displayTitle", spreakerEpisode.Title.Split(':')[1].Trim());
}
_contentService.SaveAndPublish(cmsEpisode);
}
public ActionResult Create(EpisodeModel model)
{
try
{
if (ModelState.IsValid)
{
Season season = Service.GetSeason(model.ShowName, model.SeasonNumber);
if (season == null)
{
ModelState.AddModelError("ShowName", "Show or Season does not exist");
return(View(model));
}
Service.AddEpisodeToSeason(model.ShowName, model.SeasonNumber, model.ToEpisodeDomainEntity());
return(RedirectToAction("Index"));
}
}
catch
{
// TODO: LOG
return(new HttpStatusCodeResult(( int )HttpStatusCode.InternalServerError));
}
return(View(model));
}
public static Episode ToEpisodeDomainEntity(this EpisodeModel model)
{
return(new Episode {
Title = model.Name, Number = model.Number, Synopsis = model.Synopsis, Score = model.Score, Duration = model.Duration
});
}
private static List <EpisodeModel> TransformEpisodeModel(List <EpisodeSqlModel> episodeSqlList)
{
List <EpisodeModel> episodeList = new List <EpisodeModel>();
if (episodeSqlList.Count == 0)
{
return(episodeList);
}
EpisodeModel newFirstEpisode = new EpisodeModel();
newFirstEpisode.SeasonNumber = episodeSqlList[0].SeasonNumber;
newFirstEpisode.EpisodeID = episodeSqlList[0].EpisodeID;
newFirstEpisode.EpisodeNumberSeries = episodeSqlList[0].EpisodeNumberSeries;
newFirstEpisode.EpisodeNumberSeason = episodeSqlList[0].EpisodeNumberSeason;
newFirstEpisode.OriginalAirDate = episodeSqlList[0].OriginalAirDate;
switch (episodeSqlList[0].LanguageCode)
{
case "ENG":
newFirstEpisode.TitleEnglish = episodeSqlList[0].Title;
break;
case "RMJ":
newFirstEpisode.TitleRomaji = episodeSqlList[0].Title;
break;
case "JPN":
newFirstEpisode.TitleJapanese = episodeSqlList[0].Title;
break;
}
episodeList.Add(newFirstEpisode);
int currentEpisodeID = episodeSqlList[0].EpisodeID;
int processingEpisodeNumber = 0;
for (int i = 0; i < episodeSqlList.Count; i++)
{
if (episodeSqlList[i].EpisodeID != currentEpisodeID)
{
EpisodeModel newEpisode = new EpisodeModel();
newEpisode.SeasonNumber = episodeSqlList[i].SeasonNumber;
newEpisode.EpisodeID = episodeSqlList[i].EpisodeID;
newEpisode.EpisodeNumberSeries = episodeSqlList[i].EpisodeNumberSeries;
newEpisode.EpisodeNumberSeason = episodeSqlList[i].EpisodeNumberSeason;
newEpisode.OriginalAirDate = episodeSqlList[i].OriginalAirDate;
switch (episodeSqlList[i].LanguageCode)
{
case "ENG":
newEpisode.TitleEnglish = episodeSqlList[i].Title;
break;
case "RMJ":
newEpisode.TitleRomaji = episodeSqlList[i].Title;
break;
case "JPN":
newEpisode.TitleJapanese = episodeSqlList[i].Title;
break;
}
episodeList.Add(newEpisode);
currentEpisodeID = episodeSqlList[i].EpisodeID;
processingEpisodeNumber++;
}
else
{
switch (episodeSqlList[i].LanguageCode)
{
case "ENG":
episodeList[processingEpisodeNumber].TitleEnglish = episodeSqlList[i].Title;
break;
case "RMJ":
episodeList[processingEpisodeNumber].TitleRomaji = episodeSqlList[i].Title;
break;
case "JPN":
episodeList[processingEpisodeNumber].TitleJapanese = episodeSqlList[i].Title;
break;
}
}
}
return(episodeList);
}
public EpisodePage(EpisodeModel episode)
{
InitializeComponent();
BindingContext = episode;
}
