protected static async Task <Either <BaseError, ProgramSchedule> > FillerConfigurationMustBeValid(
TvContext dbContext,
IProgramScheduleItemRequest item,
ProgramSchedule programSchedule)
{
var allFillerIds = Optional(item.PreRollFillerId)
.Append(Optional(item.MidRollFillerId))
.Append(Optional(item.PostRollFillerId))
.ToList();
List <FillerPreset> allFiller = await dbContext.FillerPresets
.Filter(fp => allFillerIds.Contains(fp.Id))
.ToListAsync();
if (allFiller.Count(f => f.PadToNearestMinute.HasValue) > 1)
{
return(BaseError.New("Schedule may only contain one filler preset that is configured to pad"));
}
if (allFiller.Any(fp => fp.PadToNearestMinute.HasValue) && !item.FallbackFillerId.HasValue)
{
return(BaseError.New("Fallback filler is required when padding"));
}
return(programSchedule);
}
protected Validation <BaseError, ProgramSchedule> CollectionTypeMustBeValid(
IProgramScheduleItemRequest item,
ProgramSchedule programSchedule)
{
switch (item.CollectionType)
{
case ProgramScheduleItemCollectionType.Collection:
if (item.CollectionId is null)
{
return(BaseError.New("[Collection] is required for collection type 'Collection'"));
}
break;
case ProgramScheduleItemCollectionType.TelevisionShow:
if (item.MediaItemId is null)
{
return(BaseError.New("[MediaItem] is required for collection type 'TelevisionShow'"));
}
break;
case ProgramScheduleItemCollectionType.TelevisionSeason:
if (item.MediaItemId is null)
{
return(BaseError.New("[MediaItem] is required for collection type 'TelevisionSeason'"));
}
break;
case ProgramScheduleItemCollectionType.Artist:
if (item.MediaItemId is null)
{
return(BaseError.New("[MediaItem] is required for collection type 'Artist'"));
}
break;
case ProgramScheduleItemCollectionType.MultiCollection:
if (item.MultiCollectionId is null)
{
return(BaseError.New("[MultiCollection] is required for collection type 'MultiCollection'"));
}
break;
case ProgramScheduleItemCollectionType.SmartCollection:
if (item.SmartCollectionId is null)
{
return(BaseError.New("[SmartCollection] is required for collection type 'SmartCollection'"));
}
break;
default:
return(BaseError.New("[CollectionType] is invalid"));
}
return(programSchedule);
}
public ProgramSchedule PartialUpdate(int id, UpdateProgramScheduleDto dto)
{
ProgramSchedule programSchedule = _programScheduleRepository.Find(id);
if (programSchedule == null)
{
return(null);
}
if (!string.IsNullOrWhiteSpace(dto.FitnessProgramName))
{
programSchedule.FitnessProgramName = dto.FitnessProgramName;
}
programSchedule.ProgramTypeId = dto.ProgramTypeId;
if (!string.IsNullOrWhiteSpace(dto.NutritionProgramName))
{
programSchedule.NutritionProgramName = dto.NutritionProgramName;
}
_programScheduleRepository.Save();
return(programSchedule);
}
public void AddNewUserProgramSchedule(User user, ProgramSchedule schedule)
{
var userSchedule = _context.UsersPrograms.SingleOrDefault(u => u.UserId == user.Id && u.ProgramScheduleId == schedule.Id);
if (userSchedule == null)
{
var result = new UserSchedule
{
User = user,
ProgramSchedule = schedule,
UserId = user.Id,
ProgramScheduleId = schedule.Id
};
_context.UsersPrograms.Add(result);
_context.SaveChanges();
}
else
{
_context.UsersPrograms.Remove(userSchedule);
_context.UsersPrograms.Add(new UserSchedule
{
User = user,
ProgramSchedule = schedule,
UserId = user.Id,
ProgramScheduleId = schedule.Id
}
);
_context.SaveChanges();
}
}
public ProgramSchedule AddNewProgramSchedule(CreateProgramScheduleDto dto)
{
var type = new CreateProgramTypeDto
{
Name = dto.TypeName,
};
_programTypeService.AddNewProgramType(type);
var program = new ProgramSchedule
{
ProgramTypeId = _programTypeService.GetProgramByName(type.Name).Id,
FitnessProgramName = dto.FitnessProgramName,
NutritionProgramName = dto.NutritionProgramName,
FitnessProgramDescription = dto.FitnessProgramDescription,
NutritionProgramDescription = dto.NutritionProgramDescription
};
_programScheduleRepository.Add(program);
_programScheduleRepository.Save();
_programTypeService.UpdateProgramTypeDetails(program.ProgramTypeId, new UpdateProgramTypeDto
{
ScheduleId = program.Id
});
return(program);
}
private static Validation <BaseError, ProgramSchedule> PlaybackOrdersMustBeValid(
ReplaceProgramScheduleItems request,
ProgramSchedule programSchedule)
{
var keyOrders = new Dictionary <CollectionKey, System.Collections.Generic.HashSet <PlaybackOrder> >();
foreach (ReplaceProgramScheduleItem item in request.Items)
{
var key = new CollectionKey(
item.CollectionType,
item.CollectionId,
item.MediaItemId,
item.MultiCollectionId,
item.SmartCollectionId);
if (keyOrders.TryGetValue(key, out System.Collections.Generic.HashSet <PlaybackOrder> playbackOrders))
{
playbackOrders.Add(item.PlaybackOrder);
keyOrders[key] = playbackOrders;
}
else
{
keyOrders.Add(key, new System.Collections.Generic.HashSet <PlaybackOrder> {
item.PlaybackOrder
});
}
}
return(Optional(keyOrders.Values.Count(set => set.Count != 1))
.Filter(count => count == 0)
.Map(_ => programSchedule)
.ToValidation <BaseError>("A collection must not use multiple playback orders"));
}
private async Task <UpdateProgramScheduleResult> ApplyUpdateRequest(
TvContext dbContext,
ProgramSchedule programSchedule,
UpdateProgramSchedule request)
{
// we need to refresh playouts if the playback order or keep multi-episodes has been modified
bool needToRefreshPlayout =
programSchedule.KeepMultiPartEpisodesTogether != request.KeepMultiPartEpisodesTogether ||
programSchedule.TreatCollectionsAsShows != request.TreatCollectionsAsShows ||
programSchedule.ShuffleScheduleItems != request.ShuffleScheduleItems;
programSchedule.Name = request.Name;
programSchedule.KeepMultiPartEpisodesTogether = request.KeepMultiPartEpisodesTogether;
programSchedule.TreatCollectionsAsShows = programSchedule.KeepMultiPartEpisodesTogether &&
request.TreatCollectionsAsShows;
programSchedule.ShuffleScheduleItems = request.ShuffleScheduleItems;
await dbContext.SaveChangesAsync();
if (needToRefreshPlayout)
{
List <int> playoutIds = await dbContext.Playouts
.Filter(p => p.ProgramScheduleId == programSchedule.Id)
.Map(p => p.Id)
.ToListAsync();
foreach (int playoutId in playoutIds)
{
await _channel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Refresh));
}
}
return(new UpdateProgramScheduleResult(programSchedule.Id));
}
/// <summary>
/// 联合查询，得出复合对象信息
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ProgramSchedule GetCompositeById(int id)
{
ProgramSchedule schedule = this.QueryableToEntity(x => x.id == id);
if (schedule != null)
{
List <ProgramScheduleTime> list = _sqlSugarClient.Queryable <ProgramScheduleTime>()
.Where(x => x.schedule_id == schedule.id).ToList();
if (list != null && list.Count > 0)
{
foreach (var scheduleTimeItem in list)
{
scheduleTimeItem.scheduleDay = _sqlSugarClient.Queryable <ScheduleDay>()
.First(x => x.id == scheduleTimeItem.schedule_day_id);
if (scheduleTimeItem.scheduleDay != null)
{
var dayList = _sqlSugarClient.Queryable <ScheduleDayProgram>()
.Where(x => x.schedule_id == scheduleTimeItem.scheduleDay.id).ToList();
scheduleTimeItem.scheduleDay.ProgramList = dayList;
}
}
}
schedule.TimeList = list;
}
return(schedule);
}
public bool Update(ProgramSchedule obj)
{
if (_programScheduleService.UpdateEntity(obj))
{
return(true);
}
return(false);
}
//新增
public static int Insert(ProgramSchedule obj)
{
string urls = url_program_schedule + "/insert";
var objJson = JsonConvert.SerializeObject(obj);
int result = Convert.ToInt32(HttpHelper.HttpPost(urls, objJson));
return(result);
}
//更新
public static bool Update(ProgramSchedule obj)
{
string urls = url_program_schedule + "/update";
var objJson = JsonConvert.SerializeObject(obj);
bool result = Convert.ToBoolean(HttpHelper.HttpPut(urls, objJson));
return(result);
}
//加载一个排程
public void LoadSchedule()
{
var item = _programScheduleService.QueryableToEntity(x => x.id > 0);
if (item != null)
{
schedule = _programScheduleService.GetCompositeById(item.id);//加载完整信息
}
}
protected static Validation <BaseError, ProgramSchedule> PlayoutModeMustBeValid(
IProgramScheduleItemRequest item,
ProgramSchedule programSchedule)
{
if (item.MultiCollectionId.HasValue)
{
switch (item.PlaybackOrder)
{
case PlaybackOrder.Chronological:
case PlaybackOrder.Random:
return(BaseError.New($"Invalid playback order for multi collection: '{item.PlaybackOrder}'"));
case PlaybackOrder.Shuffle:
case PlaybackOrder.ShuffleInOrder:
break;
}
}
switch (item.PlayoutMode)
{
case PlayoutMode.Flood:
case PlayoutMode.One:
break;
case PlayoutMode.Multiple:
if (item.MultipleCount.GetValueOrDefault() < 0)
{
return(BaseError.New(
"[MultipleCount] must be greater than or equal to 0 for playout mode 'multiple'"));
}
break;
case PlayoutMode.Duration:
if (item.PlayoutDuration is null)
{
return(BaseError.New("[PlayoutDuration] is required for playout mode 'duration'"));
}
if (item.TailMode == TailMode.Filler && item.TailFillerId == null)
{
return(BaseError.New("Tail Filler is required with tail mode Filler"));
}
if (item.TailFillerId != null && item.TailMode != TailMode.Filler)
{
return(BaseError.New("Tail Filler will not be used unless tail mode is set to Filler"));
}
break;
default:
return(BaseError.New("[PlayoutMode] is invalid"));
}
return(programSchedule);
}
public static void ImportData(this ProgramScheduleContent target, ProgramSchedule source)
{
target.SelectedQuarter = source.SelectedQuarter;
target.ApplySettingsForAll = source.ApplySettingsForAll;
foreach (var oldScheduleSection in source.Sections)
{
var targetSection = target.CreateSection();
targetSection.ImportData(oldScheduleSection);
target.Sections.Add(targetSection);
}
}
public void InsertOrUpdate(ProgramSchedule programSchedule)
{
if (programSchedule.Id == default(int))
{
// New entity
_context.ProgramSchedules.Add(programSchedule);
}
else
{
// Existing entity
_context.Entry(programSchedule).State = EntityState.Modified;
}
}
// GET: ProgramSchedules/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProgramSchedule programSchedule = _programScheduleRepository.Find(id.Value);
if (programSchedule == null)
{
return(HttpNotFound());
}
return(PartialView(programSchedule));
}
public ActionResult Edit([Bind(Include = "Id,VideoCategoryId,DayOfWeek,Time,IsNew")] ProgramSchedule programSchedule)
{
if (ModelState.IsValid)
{
_programScheduleRepository.InsertOrUpdate(programSchedule);
_programScheduleRepository.Save();
return(RedirectToAction("Index", new { dayOfWeek = programSchedule.DayOfWeek }));
}
ViewBag.VideoCategoryId = new SelectList(
_videoCategoryRepository.GetMany(cat => cat.Children.Count == 0, cat => cat.Name),
"Id",
"Name",
programSchedule.VideoCategoryId);
return(View(programSchedule));
}
public ProgramSchedule UpdateProgramSchedule(int id, UpdateProgramDto dto)
{
ProgramSchedule programSchedule = _programScheduleRepository.Find(id);
if (programSchedule == null)
{
return(null);
}
programSchedule.FitnessProgramName = dto.FitnessProgramName;
programSchedule.NutritionProgramName = dto.NutritionProgramName;
programSchedule.FitnessProgramDescription = dto.FitnessProgramDescription;
programSchedule.NutritionProgramDescription = dto.NutritionProgramDescription;
_programScheduleRepository.Save();
return(programSchedule);
}
private async Task <IEnumerable <ProgramScheduleItemViewModel> > PersistItems(
ReplaceProgramScheduleItems request,
ProgramSchedule programSchedule)
{
programSchedule.Items = request.Items.Map(i => BuildItem(programSchedule, i.Index, i)).ToList();
await _programScheduleRepository.Update(programSchedule);
// rebuild any playouts that use this schedule
foreach (Playout playout in programSchedule.Playouts)
{
await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
}
return(programSchedule.Items.Map(ProjectToViewModel));
}
private async Task <IEnumerable <ProgramScheduleItemViewModel> > PersistItems(
TvContext dbContext,
ReplaceProgramScheduleItems request,
ProgramSchedule programSchedule)
{
dbContext.RemoveRange(programSchedule.Items);
programSchedule.Items = request.Items.Map(i => BuildItem(programSchedule, i.Index, i)).ToList();
await dbContext.SaveChangesAsync();
// refresh any playouts that use this schedule
foreach (Playout playout in programSchedule.Playouts)
{
await _channel.WriteAsync(new BuildPlayout(playout.Id, PlayoutBuildMode.Refresh));
}
return(programSchedule.Items.Map(ProjectToViewModel));
}
/// <summary>
/// 加载排程信息到本地
/// </summary>
/// <param name="schedule_id"></param>
/// <returns></returns>
private bool LoadSchedule(int schedule_id)
{
string response = _httpRequest.HttpGet(ServerCfg.DataServerAddr + $"/program/ProgramSchedule/get/{schedule_id}");
ProgramSchedule programSchedule = JsonConvert.DeserializeObject <ProgramSchedule>(response);
if (programSchedule != null)
{
_programScheduleService.ClearAll();//清除本地所有信息
if (_programScheduleService.Insert(programSchedule) == false)
{
_log.WriteLog($"排程{programSchedule.id}存储失败");
return(false);
}
foreach (var schduleTime in programSchedule.TimeList)
{
if (_programScheduleTimeService.Insert(schduleTime) == false)
{
_log.WriteLog($"排程{programSchedule.id}播放时刻{schduleTime.id}存储失败");
return(false);
}
if (_scheduleDayService.Insert(schduleTime.scheduleDay) == false)
{
_log.WriteLog($"排程{programSchedule.id}播放时刻{schduleTime.id}单日时刻{schduleTime.scheduleDay.id}存储失败");
return(false);
}
foreach (ScheduleDayProgram dayProg in schduleTime.scheduleDay.ProgramList)
{
if (_scheduleDayProgramService.Insert(dayProg) == false)
{
_log.WriteLog($"排程{programSchedule.id}播放时刻{schduleTime.id}单日时刻{schduleTime.scheduleDay.id}节目{dayProg.id}存储失败");
return(false);
}
if (LoadProgrammeInfo(dayProg.program_id) == false)
{
return(false);
}
}
}
}
return(true);
}
// GET: ProgramSchedules/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ProgramSchedule programSchedule = _programScheduleRepository.Find(id.Value);
if (programSchedule == null)
{
return(HttpNotFound());
}
ViewBag.VideoCategoryId = new SelectList(
_videoCategoryRepository.GetMany(cat => cat.Children.Count == 0, cat => cat.Name),
"Id",
"Name",
programSchedule.VideoCategoryId);
return(View(programSchedule));
}
private async Task <ProgramScheduleItemViewModel> PersistItem(
AddProgramScheduleItem request,
ProgramSchedule programSchedule)
{
int nextIndex = programSchedule.Items.Select(i => i.Index).DefaultIfEmpty(0).Max() + 1;
ProgramScheduleItem item = BuildItem(programSchedule, nextIndex, request);
programSchedule.Items.Add(item);
await _programScheduleRepository.Update(programSchedule);
// rebuild any playouts that use this schedule
foreach (Playout playout in programSchedule.Playouts)
{
await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
}
return(ProjectToViewModel(item));
}
private static async Task <Validation <BaseError, ProgramSchedule> > FillerConfigurationsMustBeValid(
TvContext dbContext,
ReplaceProgramScheduleItems request,
ProgramSchedule programSchedule)
{
foreach (ReplaceProgramScheduleItem item in request.Items)
{
Either <BaseError, ProgramSchedule> result = await FillerConfigurationMustBeValid(
dbContext,
item,
programSchedule);
if (result.IsLeft)
{
return(result.ToValidation());
}
}
return(programSchedule);
}
private async Task <ProgramScheduleItemViewModel> PersistItem(
TvContext dbContext,
AddProgramScheduleItem request,
ProgramSchedule programSchedule)
{
int nextIndex = programSchedule.Items.Select(i => i.Index).DefaultIfEmpty(0).Max() + 1;
ProgramScheduleItem item = BuildItem(programSchedule, nextIndex, request);
programSchedule.Items.Add(item);
await dbContext.SaveChangesAsync();
// refresh any playouts that use this schedule
foreach (Playout playout in programSchedule.Playouts)
{
await _channel.WriteAsync(new BuildPlayout(playout.Id, PlayoutBuildMode.Refresh));
}
return(ProjectToViewModel(item));
}
private async Task <ProgramScheduleViewModel> ApplyUpdateRequest(
ProgramSchedule programSchedule,
UpdateProgramSchedule update)
{
// we only need to rebuild playouts if the playback order has been modified
bool needToRebuildPlayout =
programSchedule.MediaCollectionPlaybackOrder != update.MediaCollectionPlaybackOrder;
programSchedule.Name = update.Name;
programSchedule.MediaCollectionPlaybackOrder = update.MediaCollectionPlaybackOrder;
await _programScheduleRepository.Update(programSchedule);
if (needToRebuildPlayout)
{
foreach (Playout playout in programSchedule.Playouts)
{
await _channel.WriteAsync(new BuildPlayout(playout.Id, true));
}
}
return(ProjectToViewModel(programSchedule));
}
internal static ProgramScheduleViewModel ProjectToViewModel(ProgramSchedule programSchedule) =>
private Validation <BaseError, ProgramSchedule> CollectionTypesMustBeValid(
ReplaceProgramScheduleItems request,
ProgramSchedule programSchedule) =>
request.Items.Map(item => CollectionTypeMustBeValid(item, programSchedule)).Sequence()
.Map(_ => programSchedule);
private static Validation <BaseError, ProgramSchedule> PlayoutModesMustBeValid(
ReplaceProgramScheduleItems request,
ProgramSchedule programSchedule) =>
request.Items.Map(item => PlayoutModeMustBeValid(item, programSchedule)).Sequence()
.Map(_ => programSchedule);
public override void Deserialize(XmlNode rootNode)
{
base.Deserialize(rootNode);
var node = rootNode.SelectSingleNode(@"ProgramSchedule");
if (node != null)
{
InitProgramSchedule();
ProgramSchedule.Deserialize(node);
}
node = rootNode.SelectSingleNode(@"WeeklySection");
if (node != null && SelectedSpotType == SpotType.Week)
{
InitProgramSchedule();
ProgramSchedule.DeserializeSection(node);
}
node = rootNode.SelectSingleNode(@"MonthlySection");
if (node != null && SelectedSpotType == SpotType.Month)
{
InitProgramSchedule();
ProgramSchedule.DeserializeSection(node);
}
node = rootNode.SelectSingleNode(@"DigitalProducts");
if (node != null)
{
foreach (XmlNode productNode in node.ChildNodes)
{
var product = new DigitalProduct();
product.Deserialize(productNode);
DigitalProducts.Add(product);
}
}
node = rootNode.SelectSingleNode(@"DigitalProductSummary");
if (node != null)
{
DigitalProductSummary.Deserialize(node);
}
node = rootNode.SelectSingleNode(@"Snapshots");
if (node != null)
{
foreach (XmlNode snapshotNode in node.ChildNodes)
{
var snapshot = new Snapshot.Snapshot(this);
snapshot.Deserialize(snapshotNode);
Snapshots.Add(snapshot);
}
}
node = rootNode.SelectSingleNode(@"SnapshotSummary");
if (node != null)
{
SnapshotSummary.Deserialize(node);
}
node = rootNode.SelectSingleNode(@"Options");
if (node != null)
{
foreach (XmlNode optionSetNode in node.ChildNodes)
{
var optionSet = new OptionSet(this);
optionSet.Deserialize(optionSetNode);
Options.Add(optionSet);
}
}
node = rootNode.SelectSingleNode(@"OptionsSummary");
if (node != null)
{
OptionsSummary.Deserialize(node);
}
}
