public ActionResult Show(int semester)
{
TempData["semester"] = semester;
var subjects = DB.GetSubjects();
var schedule = ScheduleRepository.GetSchedule(semester, this.CurrentUser.Class_id);
int[,] sch = new int[6, 8];
foreach (var period in schedule)
{
sch[period.Day, period.Period] = period.Subject.Id;
}
int[] periods = new int[35];
ScheduleViewModel vm = new ScheduleViewModel()
{
ScheduleList = sch,
Items = subjects,
Periods = periods,
Semester = semester
};
return(View("Show", vm));
}
public UnitOfWork(ApplicationDBContext context)
{
_context = context;
FitnessClass = new FitnessClassRepository(_context);
Schedule = new ScheduleRepository(_context);
Register = new RegistrationRepository(_context);
}
public ActionResult CreateSchedule(ScheduleViewModel scheduleViewModel)
{
var repository = new ScheduleRepository();
repository.Save(scheduleViewModel);
return(RedirectToAction("Index", "Example"));
}
public void Delete_Schedule_By_Schedule()
{
Pier pier = new Pier { Name = "Pier Test" };
Route route = new Route { Name = "Route Test", TimeTable = new TimeTable { Name = "TimeTable" } };
// Add to database
using (ThamesClipperContext ctx = new ThamesClipperContext())
{
ScheduleRepository scheduleRepository = new ScheduleRepository(ctx);
scheduleRepository.Add(new Schedule { Pier = pier, Route = route, Time = new TimeSpan(1, 0, 0) });
scheduleRepository.SaveChanges();
}
// Find and delete it
using (ThamesClipperContext ctx = new ThamesClipperContext())
{
List<Schedule> schedules = ctx.Schedules.Where(schedule => schedule.Pier.Id == pier.Id && schedule.Route.Id == route.Id).ToList();
Assert.AreEqual(1, schedules.Count());
ScheduleRepository scheduleRepository = new ScheduleRepository(ctx);
scheduleRepository.Delete(schedules[0]);
scheduleRepository.SaveChanges();
}
// Check that nothing is there
using (ThamesClipperContext ctx = new ThamesClipperContext())
{
List<Schedule> schedules = ctx.Schedules.Where(schedule => schedule.Pier.Id == pier.Id && schedule.Route.Id == route.Id).ToList();
Assert.AreEqual(0, schedules.Count());
}
}
public ScheduleManager(HospitalContext db, DpApi client)
{
_db = db;
_client = client;
_visitRepository = new VisitRepository(_db);
_scheduleRepository = new ScheduleRepository(_db);
}
public ScheduledExecution(
ILoggerFactory loggerFactory,
ScheduleRepository scheduleRepo)
{
logger = loggerFactory.CreateLogger(ConstLogging.JobFacCategorySchedulerService);
scheduleRepository = scheduleRepo;
}
public static Schedule GetSchedule(int idSchedule)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
return scheduleRepository.Single<Schedule>(s => s.IdSchedule == idSchedule);
}
}
public Context(FlightManageBookDBContext context)
{
db = context;
AddressRepo = new AddressRepository(context);
ScheduleRepo = new ScheduleRepository(context);
flightRepo = new FlightQueryRepository(context);
}
public async Task <ActionResult> Index(Destination?destination, int count = 50)
{
if (destination.HasValue)
{
DestinationImageRepository imageRepository = await DestinationImageRepository.Create();
DestinationImage destinationImage = imageRepository.Find(destination.Value);
ViewBag.Title = $"{destination} Schedule";
ViewBag.ImageUrl = destinationImage?.ImageURL;
string SAStoken = ConfigurationHelper.GetConfigValue("SAStoken");
if ((ViewBag.ImageUrl) != null)
{
ViewBag.ImageUrl += SAStoken;
}
}
else
{
ViewBag.Title = "All Schedules";
ViewBag.ImageUrl = null;
}
ScheduleRepository scheduleRepository = new ScheduleRepository();
IList <Schedule> schedules = await scheduleRepository.GetCategoryAsync(destination, count);
return(View(schedules));
}
public MainForm()
{
InitializeComponent();
_repo = new SessionRepository("data source=tcp:" + "127.0.0.1" + ",1433;Database=Session-S-13-14-1;User ID = sa;Password = ghjuhfvvf;multipleactiveresultsets=True");
_sRepo = new ScheduleRepository("data source=tcp:" + "127.0.0.1" + ",1433;Database=S-13-14-1;User ID = sa;Password = ghjuhfvvf;multipleactiveresultsets=True");
}
public ActionResult Show(int?semester, int?id)
{
if (semester == null)
{
var subjects = ScheduleRepository.GetAllSchedule(this.CurrentUser.Class_id);
var s1 = SubjectsRepository.GetSubjectsByClassAndSemester(this.CurrentUser.Class_id, 1);
var s2 = SubjectsRepository.GetSubjectsByClassAndSemester(this.CurrentUser.Class_id, 2);
var allSubjects = SubjectsRepository.GetAllSubjects();
var vm = new GradesViewModel()
{
Semester1 = s1,
Semester2 = s2,
AllSubjects = allSubjects
};
return(View(vm));
}
else if (semester == 1)
{
return(ShowFirstSemesterGrades(1, id));
}
else
{
return(ShowSecondSemesterGrades(2, id));
}
return(View());
}
public Article ShowAndCloseSchedule(int scheduleId)
{
Article article = null;
using (var transaction = new TransactionScope(TransactionScopeOption.Required, new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
}))
{
QPContext.CurrentDbConnectionInfo = new QpConnectionInfo(_connectionString, _dbType);
using (new QPConnectionScope())
{
var schedule = ScheduleRepository.GetScheduleById(scheduleId);
if (schedule != null)
{
article = ShowArticle(schedule.ArticleId);
schedule.Article = article;
ScheduleRepository.Delete(schedule);
}
}
transaction.Complete();
}
return(article);
}
public IEnumerable <ArticleScheduleTask> GetScheduleTaskList()
{
using (new QPConnectionScope(_connectionString))
{
return(ScheduleRepository.GetScheduleTaskList());
}
}
public ActionResult View(int course = 1)
{
using (ApplicationDbContext context = new ApplicationDbContext())
{
int semesterId = ScheduleHelper.GetCurrentSemesterId();
ScheduleViewModel vm = ScheduleRepository.GetScheduleViewModel(semesterId, course);
//If user is admin then load access mode
string userName = HttpContext.User.Identity.GetUserName();
ViewBag.AccessMode = ScheduleAccessMode.View.ToString();
if (HttpContext.User.IsInRole("Admin"))
{
var roleStore = new RoleStore <IdentityRole>(context);
var roleManager = new RoleManager <IdentityRole>(roleStore);
var userStore = new UserStore <ApplicationUser>(context);
var userManager = new UserManager <ApplicationUser>(userStore);
var adminUser = userManager.FindByName(userName);
// var adminUser2 = context.Users.Single(i => i.UserName.ToString() == userName);
ViewBag.AccessMode = adminUser.ScheduleAccessMode.ToString();
}
return(View("Index", vm));
}
}
public ActionResult Show(DateTime?d)
{
DateTime date = DateTime.Today;
if (d != null)
{
date = d.Value;
}
string dateStr = date.ToString("dd-MM-yyyy");
var attendance = AttendanceRepository.GetAttendance(date, this.CurrentUser.Class_id);
int day = (int)date.DayOfWeek;
List <Schedule> schedule = new List <Schedule>();
if (date.Month >= 2 && date.Month <= 6)
{
schedule = ScheduleRepository.GetSchedule(2, this.CurrentUser.Class_id).Where(s => s.Day == day).ToList();
}
else if ((date.Month >= 9 && date.Month <= 12) || date.Month == 1)
{
schedule = ScheduleRepository.GetSchedule(1, this.CurrentUser.Class_id).Where(s => s.Day == day).ToList();
}
AttendanceViewModel vm = new AttendanceViewModel()
{
AllAttendances = attendance,
AllSchedule = schedule,
Date = dateStr,
Date2 = date,
Periods = new PeriodAttendance[7]
};
return(View(vm));
}
public void ScheduleTestsAllInOneMethod()
{
using (TransactionScope scope = new TransactionScope())
{
var fixture = new Fixture();
IVehicleRepository vRep = new VehicleRepository();
var autoVehicle = fixture.Create <Vehicle>();
vRep.Save(autoVehicle);
ITaskRepository tRep = new TaskRepository();
var autoTask = fixture.Create <DAL.Models.Task>();
tRep.Save(autoTask);
IScheduleRepository sRep = new ScheduleRepository();
var autoSchedule = fixture.Create <Schedule>();
autoSchedule.Vehicle = autoVehicle;
autoSchedule.Task = autoTask;
autoSchedule.VehicleId = autoVehicle.VehicleId;
autoSchedule.TaskId = autoTask.TaskId;
sRep.Save(autoSchedule);
var insertedSchedule = sRep.GetById(autoSchedule.ScheduleId);
Assert.AreEqual(insertedSchedule.Vehicle.Make, autoSchedule.Vehicle.Make);
Assert.AreEqual(insertedSchedule.Vehicle.VehicleType.VehicleTypeName, autoSchedule.Vehicle.VehicleType.VehicleTypeName);
Assert.AreEqual(insertedSchedule.Task.TaskName, autoSchedule.Task.TaskName);
IEnumerable <Schedule> sList = sRep.GetAll().Where(sc => sc.ScheduleId == autoSchedule.ScheduleId);;
Assert.AreEqual(sList.Count(), 1);
sRep.Delete(autoSchedule);
var deletedSchedule = sRep.GetById(autoSchedule.ScheduleId);
Assert.IsNull(deletedSchedule);
}
}
public List <Exam> GetGroupActiveExams(ScheduleRepository _sRepo, int groupId, bool limitToExactGroup = true)
{
List <int> discIds;
if (limitToExactGroup)
{
discIds = _sRepo
.GetFiltredDisciplines(d => d.StudentGroup.StudentGroupId == groupId && (d.Attestation == 2 || d.Attestation == 3))
.Select(d => d.DisciplineId)
.Distinct()
.ToList();
}
else
{
var studentIds = _sRepo.GetFiltredStudentsInGroups(sig => sig.StudentGroup.StudentGroupId == groupId)
.ToList()
.Select(stig => stig.Student.StudentId);
var groupsListIds = _sRepo.GetFiltredStudentsInGroups(sig => studentIds.Contains(sig.Student.StudentId))
.ToList()
.Select(stig => stig.StudentGroup.StudentGroupId);
discIds = _sRepo
.GetFiltredDisciplines(d => groupsListIds.Contains(d.StudentGroup.StudentGroupId) && (d.Attestation == 2 || d.Attestation == 3))
.Select(d => d.DisciplineId)
.Distinct()
.ToList();
}
return(GetFiltredExams(e => discIds.Contains(e.DisciplineId) && e.IsActive)
.OrderBy(e => e.ConsultationDateTime)
.ToList());
}
//protected override async Task OnInitializedAsync()
//{
// var state = await Context;
// _User = state.User;
// this.MyScheduleState.ScheduleId = _User.GetClaimValueAsInt(UserInfo.Claims.SCHEDULEID).Value;
// this.ResetScheduleItem();
// this.MySchedule = await ScheduleRepository.GetAvailability(MyScheduleState.ScheduleId);
// this.MyScheduleState.SelectDate(SelectedDate);
// this.MyScheduleState.Schedule = MySchedule;
// await ExpandSchedule();
// StateHasChanged();
//}
private async Task ExpandSchedule()
{
var fetchedTimeslots = await ScheduleRepository.FetchTimeSlots(MySchedule.Id);
Console.WriteLine($"Fetched {fetchedTimeslots.Length} timeslots");
MyScheduleState.TimeSlots.AddRange(fetchedTimeslots);
Console.WriteLine($"MyScheduleState: {MyScheduleState.GetHashCode()}");
}
public EnrollmentsController()
{
_termRepository = new TermRepository();
_enrollmentRepository = new EnrollmentRepository();
_evaluationRepository = new EvaluationRepository();
_offeringRepository = new OfferingRepository();
_scheduleRepository = new ScheduleRepository();
}
public async Task <IActionResult> GetScheduleForTeacher(int teacherId)
{
var periodTimeslots = await ScheduleRepository.GetScheduleForTeacherAsync(teacherId);
var weeks = ScheduleConverter.Convert(periodTimeslots);
return(new OkObjectResult(weeks));
}
public OfferingEnrollmentsController()
{
_offeringRepository = new OfferingRepository();
_termRepository = new TermRepository();
_scheduleRepository = new ScheduleRepository();
_enrollmentRepository = new EnrollmentRepository();
_studentRepository = new StudentRepository();
}
public override void Init()
{
EventManager = new EventRepository(Settings.EventsPath);
ScheduleManager = new ScheduleRepository(Settings.CrontabPath);
CommandManager = new CommandRepository(Settings.CommandsDirectory, runtime);
LoadCommands();
}
public IEnumerable <ArticleScheduleTask> GetScheduleTaskList()
{
QPContext.CurrentDbConnectionInfo = new QpConnectionInfo(_connectionString, _dbType);
using (new QPConnectionScope())
{
return(ScheduleRepository.GetScheduleTaskList());
}
}
public BookingController()
{
dbContext = new CaremeDBContext();
scheduleRepo = new ScheduleRepository(dbContext);
hospitalRepo = new HospitalRepository(dbContext);
doctorRepo = new DoctorRepository(dbContext);
appointmentRepo = new AppointmentRepository(dbContext);
}
//[TearDown]
public void TearDown()
{
DeviceRepository.Clear();
AccessKeyRepository.Clear();
WorkflowRepository.Clear();
RulesRepository.Clear();
ScheduleRepository.Clear();
}
public OfferingsController()
{
_termRepository = new TermRepository();
_offeringRepository = new OfferingRepository();
_courseRepository = new CourseRepository();
_professorRepository = new ProfessorRepository();
_scheduleRepository = new ScheduleRepository();
}
public ScheduleController(IScheduleService iScheduleService, IScheduleDelService iScheduleDelService)
{
this.iScheduleDelService = iScheduleDelService;
this.iScheduleService = iScheduleService;
dbContext = new CaremeDBContext();
scheduleRepo = new ScheduleRepository(dbContext);
hospitalRepo = new HospitalRepository(dbContext);
scheduleDataRepo = new ScheduleDataRepository(dbContext);
}
public SchedulerQueue(
ILoggerFactory loggerFactory,
ConfigCacheService configCache,
ScheduleRepository scheduleRepository)
{
logger = loggerFactory.CreateLogger(ConstLogging.JobFacCategorySchedulerQueue);
this.scheduleRepository = scheduleRepository;
this.configCache = configCache;
}
public void TestGetStation()
{
ScheduleRepository sr = new ScheduleRepository(config);
Schedule s = sr.GetSchedule(PlayerColor.Y, 2);
Assert.AreEqual(1, s.GetStation(0));
Assert.AreEqual(9, s.GetStation(4));
Assert.AreEqual(-1, s.GetStation(5));
}
public ScheduleController()
{
this._repo = new ScheduleRepository();
this._jsonSettings = new JsonSerializerSettings()
{
ContractResolver = new CamelCasePropertyNamesContractResolver(),
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
};
}
public PartialViewResult _LessonForm(int semesterId, string dayOfWeek, int lessonNumber, int groupId, LessonFrequency lessonFrequency = LessonFrequency.Constant)
{
ApplicationDbContext context = new ApplicationDbContext();
Models.ScheduleItem scheduleItem = new ScheduleItem()
{
SemesterId = semesterId,
DayOfWeek = dayOfWeek,
LessonNumber = lessonNumber,
GroupId = groupId,
LessonFrequency = lessonFrequency
};
scheduleItem.Group = context.Groups.Single(i => i.Id == groupId);
//Отбираем значения числ/знам по загруж
ScheduleViewModel vm = ScheduleRepository.GetScheduleViewModel(semesterId, scheduleItem.Group.Course);
IEnumerable <SelectListItem> freqList = GetLessonFrequenciesSelectList();
Hashtable freqLimitReached = new Hashtable();
foreach (var value in EnumHelper.GetValues <LessonFrequency>())
{
freqLimitReached.Add(value.ToString(), vm.StudLessonsLimitReached(dayOfWeek, groupId, value));
}
freqList = freqList.Where(i => (bool)freqLimitReached[i.Value] == false);
//проверка на другие занятия
List <SelectListItem> freqList2 = new List <SelectListItem>();
var scheduleItemsForConcreteLessonNumber = vm.GetScheduleItems(semesterId, dayOfWeek, lessonNumber, groupId).Select(i => i.LessonFrequency);
if (scheduleItemsForConcreteLessonNumber.Contains(LessonFrequency.Constant))
{
freqList2.Clear();
}
else if (scheduleItemsForConcreteLessonNumber.Contains(LessonFrequency.Nominator))
{
freqList2.Add(freqList.SingleOrDefault(i => i.Value == LessonFrequency.Denominator.ToString()));
}
else if (scheduleItemsForConcreteLessonNumber.Contains(LessonFrequency.Denominator))
{
freqList2.Add(freqList.SingleOrDefault(i => i.Value == LessonFrequency.Nominator.ToString()));
}
else
{
freqList2.AddRange(freqList);
}
freqList = freqList2;
ViewBag.LessonId = GetLessonsSelectList();
ViewBag.LessonType = GetLessonTypesSelectList();
ViewBag.LessonFrequency = freqList;
ViewBag.TeacherId = GetTeachersSelectList();
ViewBag.ClassroomId = GetClassroomsSelectList(context.Classrooms.Where(i => i.Capacity >= scheduleItem.Group.StudentsAmount).ToList());
return(PartialView("_LessonFormPartial", scheduleItem));
}
public void SetUp()
{
var configuration = new ScheduleRepositoryConfiguration
{
ConnectionString = "Data Source=localhost;Initial Catalog=EasyNetQ.Scheduler;Integrated Security=SSPI;",
PurgeBatchSize = 100
};
scheduleRepository = new ScheduleRepository(configuration, () => DateTime.UtcNow);
}
public HomeController(IScheduleService iScheduleService)
{
this.iScheduleService = iScheduleService;
dbContext = new CaremeDBContext();
scheduleRepo = new ScheduleRepository(dbContext);
hospitalRepo = new HospitalRepository(dbContext);
doctorRepo = new DoctorRepository(dbContext);
appointmentRepo = new AppointmentRepository(dbContext);
}
public static IList<Schedule> ListAllSchedules()
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
IQueryable<Schedule> listAllSchedules = scheduleRepository.GetAll<Schedule>();
listAllSchedules = scheduleRepository.IncludeAllRelations(listAllSchedules);
return listAllSchedules.ToList();
}
}
public DoctorService(DoctorRepository doctorRepository, UserRepository userRepository, AddressRepository addressRepository, ScheduleRepository scheduleRepository, AppointmentRepository appointmentRepository, WaitingRepository waitingRepository)
{
_doctorRepository = doctorRepository;
_userRepository = userRepository;
_addressRepository = addressRepository;
_scheduleRepository = scheduleRepository;
_appointmentRepository = appointmentRepository;
_waitingRepository = waitingRepository;
}
public void SetUp()
{
var log = MockRepository.GenerateStub<IEasyNetQLogger>();
var configuration = new ScheduleRepositoryConfiguration
{
ProviderName = "System.Data.SqlClient",
ConnectionString = "Data Source=localhost;Initial Catalog=EasyNetQ.Scheduler;Integrated Security=SSPI;",
PurgeBatchSize = 100
};
scheduleRepository = new ScheduleRepository(configuration, log, () => DateTime.UtcNow);
}
public SchedulerInstance(ILog log,
RecurrencyController recurrencyController,
ScheduleRepository repo, int workers = 5)
{
if (Instance != null) throw new InvalidOperationException("Scheduler already initialized");
workersAmount = workers;
this.log = log;
this.recurrencyController = recurrencyController;
this.repo = repo;
Instance = this;
}
public static Schedule SaveSchedule(Schedule schedule)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
scheduleRepository.AttachEntityIfChangeTrackingDisabled(scheduleRepository.ObjectContext.Schedules, schedule);
scheduleRepository.ApplyChanges(scheduleRepository.ObjectContext.Schedules, schedule);
scheduleRepository.UnitOfWork.SaveChanges();
schedule.AcceptChanges();
}
ProgramManagement.SynchProgramStates(new ScheduleBLL(schedule));
return schedule;
}
public static Schedule RetrieveSpawnedSchedule(int parentScheduleId, DateTime startTime)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
Schedule schedule =
scheduleRepository.First<Schedule>(s => s.IdParentSchedule == parentScheduleId && s.StartTime == startTime);
if (schedule == null)
{
schedule = scheduleRepository.First<Schedule>(s => s.IdParentSchedule == parentScheduleId);
}
return schedule;
}
}
public static bool IsScheduleRecording(int idSchedule)
{
bool isScheduleRecording = false;
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
Schedule schedule = scheduleRepository.First<Schedule>(s => s.IdSchedule == idSchedule);
if (schedule != null)
{
Schedule spawnedSchedule = RetrieveSpawnedSchedule(idSchedule, schedule.StartTime);
if (spawnedSchedule != null)
{
schedule = spawnedSchedule;
}
isScheduleRecording = (RecordingManagement.GetActiveRecording(schedule.IdSchedule) != null);
}
}
return isScheduleRecording;
}
/// <summary>
/// Retreives the first found instance of a 'Series' typed schedule given its Channel,Title,Start and End Times
/// </summary>
/// <param name="idChannel">Channel id to look for</param>
/// <param name="startTime">StartTime</param>
/// <param name="endTime">EndTime</param>
/// <returns>schedule instance or null</returns>
public static Schedule RetrieveSeries(int idChannel, DateTime startTime, DateTime endTime)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
var retrieveSeries = scheduleRepository.First<Schedule>(
s => s.ScheduleType != 0 && s.IdChannel == idChannel && s.StartTime == startTime && s.EndTime == endTime);
return retrieveSeries;
}
}
public void Add_Or_Update_Schedule()
{
Pier pier = new Pier { Name = "Pier" };
TimeTable timeTable = new TimeTable { Name = "TimeTable" };
Route routeExisting = new Route { Name = "Route1", TimeTable = timeTable };
Route routeAdd = new Route { Name = "Route2", TimeTable = timeTable };
TimeSpan timeExisting = new TimeSpan(13, 0, 0);
TimeSpan timeAdd = new TimeSpan(14, 0, 0);
TimeSpan timeUpdated = new TimeSpan(15, 0, 0);
Schedule existing = new Schedule { Pier = pier, Route = routeExisting, Time = timeExisting };
Schedule add = new Schedule { Pier = pier, Route = routeAdd, Time = timeAdd };
// Add the existing one to database
using (ThamesClipperContext ctx = new ThamesClipperContext())
{
ScheduleRepository scheduleRepository = new ScheduleRepository(ctx);
scheduleRepository.Add(existing);
scheduleRepository.SaveChanges();
}
// Find and update it
using (ThamesClipperContext ctx = new ThamesClipperContext())
{
ScheduleRepository scheduleRepository = new ScheduleRepository(ctx);
existing.Time = timeUpdated;
scheduleRepository.AddOrUpate(existing);
scheduleRepository.AddOrUpate(add);
scheduleRepository.SaveChanges();
}
// Check that the new name is there
using (ThamesClipperContext ctx = new ThamesClipperContext())
{
var schedulesExisting = ctx.Schedules.Where(schedule => schedule.Pier.Id == pier.Id && schedule.Route.Id == routeExisting.Id).ToList();
Assert.AreEqual(1, schedulesExisting.Count());
Assert.AreEqual(timeUpdated, schedulesExisting[0].Time);
var schedulesAdd = ctx.Schedules.Where(schedule => schedule.Pier.Id == pier.Id && schedule.Route.Id == routeAdd.Id).ToList();
Assert.AreEqual(1, schedulesAdd.Count());
}
}
public static void DeleteSchedule(int idSchedule)
{
Schedule scheduleToDelete;
using (IScheduleRepository scheduleRepository = new ScheduleRepository(true))
{
SetRelatedRecordingsToNull(idSchedule, scheduleRepository);
scheduleToDelete = scheduleRepository.First<Schedule>(schedule => schedule.IdSchedule == idSchedule);
if (scheduleToDelete == null)
return;
scheduleRepository.Delete(scheduleToDelete);
scheduleRepository.UnitOfWork.SaveChanges();
}
ProgramManagement.SynchProgramStates(new ScheduleBLL(scheduleToDelete));
}
public CommonFunctions(ScheduleRepository repo)
{
_repo = repo;
}
public static bool IsScheduleRecording(int idSchedule, int idProgram)
{
bool isScheduleRecording = false;
Program prg = ProgramManagement.GetProgram(idProgram);
if (prg != null)
{
var programBll = new ProgramBLL(prg);
if (programBll.IsRecording)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
Schedule schedule = scheduleRepository.FindOne<Schedule>(s => s.IdSchedule == idSchedule);
if (schedule != null)
{
Schedule spawnedSchedule = RetrieveSpawnedSchedule(idSchedule, prg.StartTime);
if (spawnedSchedule != null)
{
schedule = spawnedSchedule;
}
}
if (schedule != null)
{
isScheduleRecording = (RecordingManagement.GetActiveRecording(schedule.IdSchedule) != null);
}
}
}
}
return isScheduleRecording;
}
public static RuleBasedSchedule SaveRuleBasedSchedule(RuleBasedSchedule schedule)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
scheduleRepository.AttachEntityIfChangeTrackingDisabled(scheduleRepository.ObjectContext.RuleBasedSchedules, schedule);
scheduleRepository.ApplyChanges(scheduleRepository.ObjectContext.RuleBasedSchedules, schedule);
scheduleRepository.UnitOfWork.SaveChanges();
schedule.AcceptChanges();
return schedule;
}
}
/// <summary>
/// Retreives the first found instance of a 'Series' typed schedule given its Channel,Title
/// </summary>
/// <param name="idChannel">Channel id to look for</param>
/// <param name="programName">Title we wanna look for</param>
/// <returns>schedule instance or null</returns>
public static Schedule RetrieveSeries(int idChannel, string programName)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
var retrieveSeries = scheduleRepository.First<Schedule>(
s => s.ScheduleType != 0 && s.IdChannel == idChannel && s.ProgramName == programName);
return retrieveSeries;
}
}
public static Schedule GetScheduleWithNoEPG(int idChannel)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
var scheduleWithNoEpg = scheduleRepository.FindOne<Schedule>(
s => s.ScheduleType == 0 && s.IdChannel == idChannel && s.IdParentSchedule <= 0 && !s.Series);
return scheduleWithNoEpg;
}
}
public static void DeleteOrphanedOnceSchedules()
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository(true))
{
IList<Schedule> schedules =
scheduleRepository.GetQuery<Schedule>(
s => s.ScheduleType == (int) ScheduleRecordingType.Once && s.EndTime < DateTime.Now).ToList();
if (schedules.Count > 0)
{
Log.Debug("DeleteOrphanedOnceSchedules: Orphaned once schedule(s) found - removing");
foreach (var schedule in schedules)
{
SetRelatedRecordingsToNull(schedule.IdSchedule, scheduleRepository);
}
scheduleRepository.DeleteList(schedules);
scheduleRepository.UnitOfWork.SaveChanges();
}
}
}
public static IList<Schedule> GeneralSqlQuery(string command)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository(true))
{
IEnumerable<Mediaportal.TV.Server.TVDatabase.Entities.Schedule> allqueryschedules = scheduleRepository.ObjectContext.ExecuteStoreQuery<Mediaportal.TV.Server.TVDatabase.Entities.Schedule>(command);
scheduleRepository.UnitOfWork.SaveChanges();
IList<Schedule> myschedules = new List<Schedule>();
foreach (Mediaportal.TV.Server.TVDatabase.Entities.Schedule rawschedule in allqueryschedules)
{
//public Schedule(int idSchedule, int idChannel, int scheduleType, string programName, DateTime startTime, DateTime endTime, int maxAirings, int priority, string directory, int quality, int keepMethod, DateTime keepDate, int preRecordInterval, int postRecordInterval, DateTime canceled)
DateTime keepDate;
if (rawschedule.KeepDate != null)
{
keepDate = (DateTime)rawschedule.KeepDate;
}
else
{
keepDate = DateTime.ParseExact("2999-01-30_00:00", "yyyy-MM-dd_HH:mm", System.Globalization.CultureInfo.InvariantCulture);
}
Schedule myschedule = new Schedule(rawschedule.IdSchedule, rawschedule.IdChannel, rawschedule.ScheduleType, rawschedule.ProgramName,
rawschedule.StartTime, rawschedule.EndTime, rawschedule.MaxAirings, rawschedule.Priority, rawschedule.Directory, rawschedule.Quality,
rawschedule.KeepMethod, keepDate, rawschedule.PreRecordInterval, rawschedule.PostRecordInterval, rawschedule.Canceled);
myschedules.Add(myschedule);
}
return myschedules;
}
}
public static void UnCancelSerie(Schedule schedule, DateTime startTime, int idChannel)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository(true))
{
foreach (CanceledSchedule canceledSchedule in schedule.CanceledSchedules)
{
if (canceledSchedule.CancelDateTime == startTime && canceledSchedule.IdChannel == idChannel)
{
scheduleRepository.Delete(canceledSchedule);
ProgramManagement.SetSingleStateSeriesPending(canceledSchedule.CancelDateTime,
canceledSchedule.IdChannel,
canceledSchedule.Schedule.ProgramName);
}
}
scheduleRepository.UnitOfWork.SaveChanges();
}
}
public static Schedule RetrieveOnce(int idChannel, string title, DateTime startTime, DateTime endTime)
{
using (IScheduleRepository scheduleRepository = new ScheduleRepository())
{
Schedule onceSchedule =
scheduleRepository.FindOne<Schedule>(s=>s.ScheduleType == (int)ScheduleRecordingType.Once
&& s.IdChannel == idChannel && s.ProgramName == title && s.EndTime == endTime);
return onceSchedule;
}
}
public void SetUp()
{
scheduleRepository = new ScheduleRepository(
"Data Source=localhost;Initial Catalog=EasyNetQ.Scheduler;Integrated Security=SSPI;");
}
