public int Show(ShowPeriodArgs opts)
{
if (!opts.All && string.IsNullOrEmpty(opts.EzName))
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("You must provide either \"-a\" or the \"-z\" flags");
Console.WriteLine("Ex. [show-period -a -p 1 -l 10] or [show-period -d -z s5]");
Console.ResetColor();
return((int)ExitCodes.MissingArguments);
}
using var periods = new PeriodService();
if (opts.All)
{
return(FindAllPeriods(opts.Pagination, opts.Detailed));
}
try
{
return(FindSpecificPeriod((opts.EzName, opts.Detailed), periods));
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Failed to show period. {e.Message}");
Console.ResetColor();
return((int)ExitCodes.FailedToShowPeriod);
}
}
public int Create(Period period)
{
using (var periods = new PeriodService())
{
if (periods.Exists(period.EzName))
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"A period with the Easy Name: \"{period.EzName}\" already exists!");
Console.WriteLine($"Please run \"trackmat show-period -z {period.EzName}\" to see it");
Console.ResetColor();
return((int)ExitCodes.PeriodExists);
}
try
{
period.Items = new List <TrackItem>();
var created = periods.Create(period);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"Saved [{created.Id} - {created.Name}] Successfully \n{created}");
Console.ResetColor();
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Failed to Create {period.Name}. {e.Message}");
Console.ResetColor();
return((int)ExitCodes.FailedToCreateItem);
}
return((int)ExitCodes.Success);
}
}
public IActionResult Period(int?id, [FromQuery] int dayId)
{
if (dayId == 0)
{
return(BadRequest());
}
PeriodDto periodDto;
if (id != null)
{
periodDto = PeriodService.GetPeriod(id.Value);
if (periodDto == null)
{
return(NotFound());
}
if (periodDto.SchoolDayId != dayId)
{
return(BadRequest());
}
}
else
{
periodDto = new PeriodDto
{
SchoolDayId = dayId,
Number = Shared.Enums.PeriodNumber.First
};
}
var periodBindingModel = Mapper.Map <PeriodBindingModel>(periodDto);
var periodViewModel = new PeriodViewModel(periodBindingModel, id);
return(View(periodViewModel));
}
public IActionResult Period(int?id, [FromForm] PeriodBindingModel period)
{
if (period.SchoolDayId == 0)
{
return(BadRequest());
}
var periodDto = Mapper.Map <PeriodDto>(period);
ServiceResult serviceResult = PeriodService.AddOrUpdatePeriod(periodDto, id);
if (serviceResult.Result == Result.Error)
{
foreach (var error in serviceResult.Errors)
{
ModelState.AddModelError(error.Key, error.Message);
}
if (!ModelState.IsValid)
{
var periodViewModel = new PeriodViewModel(period, id);
return(View(periodViewModel));
}
}
else if (serviceResult.Result == Result.NotFound)
{
return(NotFound());
}
int subjectId = serviceResult.Id;
return(RedirectToSubject(subjectId));
}
private async Task TypeChanged(TaskType type, bool refreshState)
{
Periods = new List <PeriodDto>();
SourceSubjects = new List <SubjectDto>();
switch (type)
{
case TaskType.Period:
Periods = await PeriodService.GetList();
break;
case TaskType.Subject:
Periods = await PeriodService.GetList();
SourceSubjects = await SubjectService.GetList();
break;
}
AddType = type;
if (refreshState)
{
StateHasChanged();
}
}
public void Can_Test_If_A_Given_ReportingPeriod_Is_Current(
int currentYear,
int currentMonth,
int currentDay,
string comparisonPeriodShortFormat,
bool expectedComparisonResult)
{
var comparisonPeriod = Period.ParsePeriodString(comparisonPeriodShortFormat);
var mockDateTimeService = new Mock <IDateTimeService>();
mockDateTimeService
.Setup(
m => m.UtcNow)
.Returns(
DateTime
.SpecifyKind(
new DateTime(currentYear, currentMonth, currentDay),
DateTimeKind.Utc));
var SUT = new PeriodService(mockDateTimeService.Object);
SUT
.PeriodIsCurrent(comparisonPeriod)
.Should()
.Be(expectedComparisonResult);
}
public void Can_Provide_A_Current_Reporting_Period(
int currentYear,
int currentMonth,
int currentDay,
string expectedPeriodShortForm)
{
var mockDateTimeService = new Mock <IDateTimeService>();
mockDateTimeService
.Setup(
m => m.UtcNow)
.Returns(
DateTime
.SpecifyKind(
new DateTime(currentYear, currentMonth, currentDay),
DateTimeKind.Utc));
var SUT = new PeriodService(mockDateTimeService.Object);
SUT
.GetCurrentPeriod()
.PeriodString
.Should()
.Be(expectedPeriodShortForm);
}
public int DeletePeriod(DeletePeriodArgs args)
{
Period found;
using (var periods = new PeriodService())
{
found = periods.FindOne(args.EzName);
if (found == null)
{
return((int)ExitCodes.PeriodNotFound);
}
}
ConsoleKeyInfo key = new ConsoleKeyInfo();
if (args.Dissociate)
{
key = new ConsoleKeyInfo('Y', ConsoleKey.Y, false, false, false);
}
while (key.Key != ConsoleKey.Y && key.Key != ConsoleKey.Enter)
{
Console.WriteLine($"Found Period\n{found}");
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Are you sure you want to dissociate the following items? [Y/n]");
Console.ResetColor();
var joined = found.Items.Aggregate("", (prev, next) => $"{(string.IsNullOrEmpty(prev) ? $"{prev}" : $"{prev}\n")}{next}");
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine($"({joined})");
Console.ResetColor();
key = Console.ReadKey();
if (key.Key == ConsoleKey.N)
{
return((int)ExitCodes.Success);
}
}
public void StartUp()
{
homepath = Path.Combine(Path.GetTempPath(), "trackmat");
Directory.CreateDirectory(homepath);
_db = new LiteDatabase(Path.Combine(homepath, "trackmat.db"));
_items = new TrackItemService(_db);
_periods = new PeriodService(_db);
}
protected async Task HandleSubmit()
{
PeriodVMEditContext = new EditContext(AdminPeriodVM);
if (PeriodVMEditContext.Validate())
{
var period = (await PeriodService.GetAsync(x => x.Year == AdminPeriodVM.PeriodeStartDate.Year)).FirstOrDefault();
if (period != null)
{
period.Description = AdminPeriodVM.Description.Trim();
period.PeriodeStartDate = AdminPeriodVM.PeriodeStartDate;
period.PeriodeEndDate = AdminPeriodVM.PeriodeEndDate;
period.PeriodValue = (decimal)AdminPeriodVM.PeriodValue;
PeriodService.Update(period);
}
else
{
period = new Period
{
Year = AdminPeriodVM.PeriodeStartDate.Year,
Description = AdminPeriodVM.Description.Trim(),
PeriodeStartDate = AdminPeriodVM.PeriodeStartDate,
PeriodeEndDate = AdminPeriodVM.PeriodeEndDate,
PeriodValue = (decimal)AdminPeriodVM.PeriodValue,
BudgetFrames = new List <BudgetFrame>()
};
var regions = await RegionService.GetAsync();
var services = await ServiceService.GetAsync(x =>
x.ServiceTypeDate <= AdminPeriodVM.PeriodeStartDate &&
x.IsActive);
foreach (var region in regions)
{
foreach (var service in services)
{
period.BudgetFrames.Add(
new BudgetFrame
{
RegionId = region.Id,
Year = AdminPeriodVM.PeriodeStartDate.Year,
Service = service,
Head = 0,
Value = 0
});
}
}
await PeriodService.AddAsync(period);
}
await PeriodService.SaveChangesAsync(AppUser.Instance.FullName);
PeriodVMs = Mapper.Map <IEnumerable <PeriodVM> >(await PeriodService.GetAsync());
ToggleView();
}
StateHasChanged();
}
protected override async Task OnInitializedAsync()
{
nfi = (NumberFormatInfo)CultureInfo.InvariantCulture.NumberFormat.Clone();
nfi.NumberGroupSeparator = " ";
PeriodVMs = Mapper.Map <IEnumerable <PeriodVM> >(await PeriodService.GetAsync());
AdminPeriodVM = new AdminPeriodVM();
PeriodVMEditContext = new EditContext(AdminPeriodVM);
}
protected async Task PeriodHandler(MouseEventArgs args, int year)
{
SelectedPeriod = year;
await SessionStorage.SetItemAsync("Period", year);
PageTitle = (await PeriodService.GetAsync(x => x.Year == year)).FirstOrDefault().Description;
SetSelectedPeriod(year);
await ControllInitialization();
await InvokeAsync(StateHasChanged);
}
protected async Task PeriodEditClickHandler(MouseEventArgs e, int year)
{
FormTitle = "Iőszak Módosítása";
IsNew = false;
ToggleView();
AdminPeriodVM = Mapper.Map <AdminPeriodVM>((await PeriodService.GetAsync(x => x.Year == year)).FirstOrDefault());
// AdminPeriodVM.Year = year;
PeriodVMEditContext = new EditContext(AdminPeriodVM);
await InvokeAsync(StateHasChanged);
}
public IActionResult Delete(int id, [FromQuery] int dayId)
{
ServiceResult result = PeriodService.DeletePeriod(id);
if (result.Result == Result.NotFound)
{
return(NotFound());
}
bool dayApproved = SchoolDayService.IsDayApproved(dayId);
return(Ok(new
{
dayApproved
}));
}
public void AddPeriodCorrectly()
{
var dbContext = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString());
var repository = new EfDeletableEntityRepository <Period>(new ApplicationDbContext(dbContext.Options));
repository.SaveChangesAsync().GetAwaiter().GetResult();
var service = new PeriodService(repository);
_ = service.AddAsync(new DateTime(2020, 5, 1), new DateTime(2020, 5, 5));
var list = repository.All().ToList();
Assert.Single(list);
Assert.Equal(new DateTime(2020, 5, 1), list[0].ArrivalDate);
Assert.Equal(new DateTime(2020, 5, 5), list[0].DepartDate);
}
protected override async Task OnInitializedAsync()
{
base.OnInitialized();
SelectedPeriod = Int32.Parse(Period);
Periods = (await PeriodService.GetAsync())
.Select(x => new DropDownData
{
Text = x.Description,
ValueInt = x.Year
})
.OrderBy(x => x.ValueInt)
.ToList();
await TableInitialization();
await FormInitialization();
await InvokeAsync(StateHasChanged);
}
private async Task InitializedAsync()
{
AdminRegionVM = new AdminRegionVM();
SelectedPeriod = Int32.Parse(Period);
RegionFrameVMs = (await BudgetFrameService.GetRegionFrameVM(SelectedPeriod)).RegionFrameVMs;
RegionVMEditContext = new EditContext(AdminRegionVM);
Services = await ServiceService.GetAsync(x =>
x.IsActive,
y => y.OrderBy(z => z.ServiceTypeId),
"ServiceType");
Periods = (await PeriodService.GetAsync())
.Select(x => new DropDownData
{
Text = x.Description,
ValueInt = x.Year
})
.OrderBy(x => x.ValueInt)
.ToList();
}
public CurrentPeriodViewModel(IEventAggregator _eventAggregator)
{
service = new PeriodService();
currentPeriodService = new CurrentPeriodService();
SetCurrentPeriodCommand = new DelegateCommand(OnSetCurrentPeriodCommand, CanSetCurrentPeriod);
IsCurrentPeriodSettable = false;
dispatcher = Deployment.Current.Dispatcher;
eventAggregator = _eventAggregator;
//LoadAllPeriodCompleted();
//service.LoadAll();
//LoadCurrentPeriodCompleted();
//currentPeriodService.GetCurrentPeriod();
//eventAggregator = _eventAggregator;
//_eventAggregator.GetEvent<SetupEvent>().Subscribe(OnInitialise);
OnInitialise("");
}
private async void OpenDeleteDialog()
{
var parameters = new DialogParameters
{
{
"Input",
new ConfirmDialogInput
{
Name = PeriodData.Name,
DeleteFunction = async() => await PeriodService.Remove(PeriodData.Id)
}
}
};
var dialog = DialogService.Show <ConfirmDialog>("Confirm Delete", parameters);
var result = await dialog.Result;
if (!result.Cancelled)
{
NavigationManager.NavigateTo("/periods");
}
}
private async void Save()
{
if (!PeriodContext.Validate())
{
return;
}
if (IsEdit)
{
if (await PeriodService.Update(Period.Id, Model))
{
Dialog.Close(DialogResult.Ok(true));
}
}
else
{
if (await PeriodService.Create(Model))
{
Dialog.Close(DialogResult.Ok(true));
}
}
}
protected int CreateDatabase(string path)
{
try
{
TrackItem itemCreated;
Period periodCreated;
using (var items = new TrackItemService())
{
itemCreated = items.Create(new TrackItem
{
Item = "SMPL-001",
Time = 0.5f,
Date = DateTime.Now
});
}
using (var periods = new PeriodService())
{
periodCreated = periods.Create(new Period
{
Name = "Sample Period",
EzName = "sample",
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddDays(1),
Items = new TrackItem[] { itemCreated }
});
}
Console.WriteLine($"Succesfully Created Item and Period Databases \"{Path.Combine(path, "trackmat.db")}\"");
Console.WriteLine(itemCreated);
Console.WriteLine(periodCreated);
Console.ResetColor();
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Failed to create config database at {path}. {e.Message}");
return((int)ExitCodes.FailedInitAtDatabase);
}
return((int)ExitCodes.Success);
}
public IActionResult Approve(int id, [FromQuery] int dayId)
{
// TODO: maybe return some boolean result
ServiceResult result = PeriodService.ApprovePeriod(id);
if (result.Result == Result.NotFound)
{
return(NotFound());
}
if (result.Result != Result.OK)
{
return(BadRequest());
}
bool dayApproved = SchoolDayService.IsDayApproved(dayId);
return(Ok(new
{
periodApproved = true,
dayApproved,
}));
}
public ImportController(IErrorService errorService, PeriodService periodService) : base(errorService)
{
_periodService = periodService;
}
private async Task GetData()
{
PeriodData = await PeriodService.Get(Id);
StateHasChanged();
}
public int Update(UpdatePeriodArgs args)
{
using (var periods = new PeriodService())
{
Period found;
var toUpdate = new Period();
try
{
found = periods.FindOne(args.EzName);
if (found == null)
{
throw new ArgumentNullException("Period Not Found");
}
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Updating Found Period\n{found}");
Console.ResetColor();
}
catch (ArgumentNullException)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Period with Easy Name [{args.EzName}] could not be found.");
Console.ResetColor();
return((int)ExitCodes.FailedToUpdate);
}
catch (Exception e)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Failed to Update Period with Easy Name [{args.EzName}], {e.Message}");
Console.ResetColor();
return((int)ExitCodes.FailedToUpdate);
}
if (args.StartDate != DateTime.MinValue)
{
found.StartDate = args.StartDate;
}
if (args.EndDate != DateTime.MinValue)
{
found.EndDate = args.EndDate;
}
if (!string.IsNullOrEmpty(args.Name) && !string.IsNullOrWhiteSpace(args.Name))
{
found.Name = args.Name;
}
var updated = periods.UpdateOne(found);
if (!updated)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine($"Failed to Update Period with Easy Name [{args.EzName}]");
Console.ResetColor();
return((int)ExitCodes.FailedToUpdate);
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine($"Period Updated\n{found}");
Console.ResetColor();
return((int)ExitCodes.Success);
}
}
