public ListYearOutcomesForCategory(IKey categoryKey, YearModel startYear)
{
Ensure.Condition.NotEmptyKey(categoryKey);
Ensure.NotNull(startYear, "startYear");
CategoryKey = categoryKey;
StartYear = startYear;
}
private void YearsCombobox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (yearsCombobox.SelectedItem == null)
{
termsCombobox.IsHitTestVisible = false;
errorYear.Visibility = Visibility.Visible;
}
else
{
model = (YearModel)yearsCombobox.SelectedItem;
Terms = GlobalConfig.Connection.GetTerm_ValidByYearId(model.Id);
if (model.Id == activeTerm.Year.Id)
{
Terms.Add(activeTerm.Term);
}
termsCombobox.ItemsSource = Terms;
if (!Terms.Any())
{
termsCombobox.IsHitTestVisible = false;
}
else
{
termsCombobox.IsHitTestVisible = true;
}
errorYear.Visibility = Visibility.Hidden;
}
}
//Update Year (async)
public async Task <YearDTO> UpdateYearAsync(YearDTO modelDTO)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
YearModel model = _Mapper_ToModel.Map <YearDTO, YearModel>(modelDTO);
bool result = unitOfWork.YearRepository.Update(model);
YearDTO modelRTN = null;
if (result)
{
await unitOfWork.SaveChangesAsync();
modelRTN = _Mapper_ToDTO.Map <YearModel, YearDTO>(model);
}
return(modelRTN);
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="categoryKey">A key of the category.</param>
/// <param name="year">A year to find outcomes from.</param>
public ListYearOutcomeFromCategory(IKey categoryKey, YearModel year)
{
Ensure.NotNull(categoryKey, "categoryKey");
Ensure.NotNull(year, "year");
CategoryKey = categoryKey;
Year = year;
}
Task IEventHandler <OutcomeWhenChanged> .HandleAsync(OutcomeWhenChanged payload)
{
OutcomeOverviewViewModel viewModel = Items.FirstOrDefault(vm => payload.AggregateKey.Equals(vm.Key));
if (viewModel != null)
{
viewModel.When = payload.When;
if (Period is MonthModel month)
{
MonthModel newValue = payload.When;
if (month != newValue)
{
Items.Remove(viewModel);
}
}
else if (Period is YearModel year)
{
YearModel newValue = new YearModel(payload.When.Year);
if (year != newValue)
{
Items.Remove(viewModel);
}
}
}
return(Task.CompletedTask);
}
/// <summary>
/// Creates a new isntance for displaying a year.
/// </summary>
/// <param name="categoryKey">A category key or empty key.</param>
/// <param name="year">A year to display.</param>
public OverviewParameter(IKey categoryKey, YearModel year)
{
Ensure.NotNull(categoryKey, "categoryKey");
Ensure.NotNull(year, "year");
CategoryKey = categoryKey;
Year = year;
}
public async Task <List <YearWithAmountModel> > HandleAsync(ListYearOutcomesForCategory query)
{
using (ReadModelContext db = dbFactory.Create())
{
var sql = db.Outcomes
.WhereUserKey(query.UserKey)
.Where(o => o.When.Year >= query.StartYear.Year && o.When.Year < (query.StartYear.Year + PageSize));
sql = ApplyCategoryKey(sql, query.CategoryKey);
List <OutcomeEntity> entities = await sql.ToListAsync();
Dictionary <YearModel, Price> totals = new Dictionary <YearModel, Price>();
foreach (OutcomeEntity entity in entities)
{
YearModel month = entity.When;
Price price;
if (totals.TryGetValue(month, out price))
{
price = price + priceConverter.ToDefault(query.UserKey, entity);
}
else
{
price = priceConverter.ToDefault(query.UserKey, entity);
}
totals[month] = price;
}
return(totals
.Select(t => new YearWithAmountModel(t.Key.Year, t.Value))
.ToList());
}
}
public static async Task InitializeAsync(Db context)
{
await context.Database.MigrateAsync();
if (!context.Years.Any())
{
var year = new YearModel {
Year = "2017"
};
context.Years.Add(year);
context.Groups.Add(new GroupModel {
Group = "ÈÓ5-71", Year = year
});
context.Groups.Add(new GroupModel {
Group = "ÈÓ5-72", Year = year
});
context.Groups.Add(new GroupModel {
Group = "ÈÓ5-73", Year = year
});
context.Groups.Add(new GroupModel {
Group = "ÈÓ5-74", Year = year
});
context.Groups.Add(new GroupModel {
Group = "ÐÒ5-71", Year = year
});
await context.SaveChangesAsync();
}
}
public async Task <IEnumerable <YearModel> > GetYearsAsync()
{
List <YearModel> years = new List <YearModel>();
string sql = "select distinct PDP_Year from ResultsData order by PDP_Year desc";
SqlCommand command = new SqlCommand(sql);
command.Connection = _connection;
_connection.Open();
var reader = await command.ExecuteReaderAsync(CommandBehavior.CloseConnection);
DataTable table = new DataTable();
table.Load(reader);
foreach (DataRow row in table.Rows)
{
YearModel year = new YearModel
{
IsChecked = true,
Year = row["PDP_Year"].ToString(),
YearName = row["PDP_Year"].ToString()
};
years.Add(year);
}
return(years);
}
public static void DeleteYear(int year)
{
TrimesterCommentModel.DeleteAll(year);
TrimesterSubjectCommentModel.DeleteAll(year);
SemiTrimesterCommentModel.DeleteAll(year);
PeriodCommentModel.DeleteAll(year);
MarkModel.DeleteAll(year);
TeacherClassModel.DeleteAll(year);
LevelSubjectModel.DeleteAll(year);
SubjectTeacherModel.DeleteAll(year);
SemiTrimesterModel.DeleteAll(year);
PeriodModel.DeleteAll(year);
StudentModel.DeleteAll(year);
ClassModel.DeleteAll(year);
LevelModel.DeleteAll(year);
SubjectModel.DeleteAll(year);
TeacherModel.DeleteAll(year);
YearParametersModel.DeleteAll(year);
YearModel.Delete(year);
MessageBox.Show("Suppresion de l'année réussie.", "Réussite", MessageBoxButton.OK, MessageBoxImage.Information);
MainViewModel.Instance.LoadYears();
MainViewModel.Instance.SelectedYear = year - 1;
}
public ListMonthOutcomesForCategory(IKey categoryKey, YearModel year)
{
Ensure.Condition.NotEmptyKey(categoryKey);
Ensure.NotNull(year, "year");
CategoryKey = categoryKey;
Year = year;
}
public InsuredDeceaseClaimModel()
{
InsurancePolicies = Enumerable.Repeat <Func <InsurancePolicyModel> >(() => new InsurancePolicyModel(), 4)
.Select(x => x())
.ToList();
AdresseAssure = new AddressModel();
AdresseAssure.PhoneNumberShownAndRequired = false;
DateNaissanceAssure = DateModel.CreateBirthDateModel();
DateDecesAssure = DateModel.CreatePastDateModel();
DateUnionFait = DateModel.CreatePastDateModel();
DateJugementDivorce = DateModel.CreatePastDateModel();
DateSeparationFait = DateModel.CreatePastDateModel();
DateSeparationLegale = DateModel.CreatePastDateModel();
AnneePremiersSymptomes = new YearModel();
AnneePremiereConsultation = new YearModel();
MedicalConsultations1 = new List <MedicalConsultationModel> {
new MedicalConsultationModel(true)
};
MedicalConsultations2 = new List <MedicalConsultationModel> {
new MedicalConsultationModel(true)
};
}
public static void CreateYear(int year)
{
YearModel.Create(year);
MainViewModel mainViewModel = new MainViewModel()
{
SelectedYear = year
};
CreatePeriods(mainViewModel, year);
CreateSemiTrimesters(mainViewModel, year);
CreateLevels(mainViewModel, year);
CreateSubjects(mainViewModel, year);
CreateTeachers(mainViewModel, year);
CreateClasses(mainViewModel, year);
CreateStudents(mainViewModel, year);
CreateLevelSubjects(mainViewModel, year);
CreateSubjectTeachers(mainViewModel, year);
CreateTeacherClasses(mainViewModel, year);
CreateYearParameters(mainViewModel, year);
MessageBox.Show("Création de la nouvelle année réussie.", "Réussite", MessageBoxButton.OK, MessageBoxImage.Information);
MainViewModel.Instance.LoadYears();
MainViewModel.Instance.SelectedYear = year;
}
public Task HandleAsync(OutcomeCreated payload)
{
bool isReloadRequired = false;
if (parameter.Month != null)
{
MonthModel other = payload.When;
if (!ViewModel.Items.Any(g => g.Parameter.Equals(other)))
{
isReloadRequired = true;
}
}
else if (parameter.Year != null)
{
YearModel other = new YearModel(payload.When.Year);
if (!ViewModel.Items.Any(g => g.Parameter.Equals(other)))
{
isReloadRequired = true;
}
}
else
{
if (!ViewModel.Items.Any())
{
isReloadRequired = true;
}
}
if (isReloadRequired)
{
ReloadAsync();
}
return(Task.CompletedTask);
}
public static Year Map(YearModel objModel)
{
return(new Year
{
Id = objModel.Id,
LanguageId = objModel.LanguageId,
YearName = objModel.Year
});
}
/// <summary>
/// Creates a new instance.
/// </summary>
/// <param name="categoryKey">A key of the category.</param>
/// <param name="year">A year to find outcomes from.</param>
public ListYearOutcomeFromCategory(IKey categoryKey, YearModel year, SortDescriptor <OutcomeOverviewSortType> sortDescriptor = null, int?pageIndex = null)
{
Ensure.NotNull(categoryKey, "categoryKey");
Ensure.NotNull(year, "year");
CategoryKey = categoryKey;
Year = year;
SortDescriptor = sortDescriptor;
PageIndex = pageIndex;
}
public string UrlOverview(YearModel year, IKey categoryKey)
{
if (categoryKey.IsEmpty)
{
return(UrlOverview(year));
}
else
{
return($"/{year.Year}/overview/{categoryKey.AsGuidKey().Guid}");
}
}
public void Add(YearModel entity)
{
try
{
_dbContext.Entry(entity).State = EntityState.Added;
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
public ActionResult GetYearListJson(int startyear, int year)
{
List <YearModel> ylist = new List <YearModel>();
for (int i = startyear; i <= (DateTime.Now.Year + year); i++)
{
YearModel model = new YearModel();
model.ytext = i.ToString();
model.yvalue = i.ToString();
ylist.Add(model);
}
return(ToJsonResult(ylist));
}
public async Task <YearModel> Save(YearModel wrapper)
{
try
{
await Connection.InsertAsync(wrapper);
return(await Connection.Table <YearModel>().Where(item => item.Year == wrapper.Year).FirstOrDefaultAsync());
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
return(null);
}
}
public void Remove(YearModel entity)
{
try
{
_dbContext.Entry(entity).State = EntityState.Deleted;
//return await (_dbContext.SaveChangesAsync());
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
public void Test1()
{
//arrange
string Name = "John";
int BirthYear = 1989;
string expected = "John is 31 years old";
string actual;
//act
actual = YearModel.AgeThisYear(Name, BirthYear);
//assert
Assert.Equal(expected, actual);
}
public InsuredDisease()
{
MaladieSimilaire_Annee = new YearModel();
ListeMedecin = new List <PhysicianModel> {
new PhysicianModel {
DisplayFirstConsultationDate = true, IsListItem = true
}
};
PeriodeHospitalise = new PeriodModel(DateModel.CreateLastFiveYearsDateModel(), DateModel.CreateLastFiveYearsDateModel());
PeriodeHospitalise.DeleteRequired = false;
DatePremierSymptomes = DateModel.CreatePastDateModel();
List <SliderBracket> brackets = new List <SliderBracket>()
{
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_1), MinValue = 0, MaxValue = 4
},
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_2), MinValue = 5, MaxValue = 7
},
new SliderBracket()
{
BracketResourceManager = UIAccident.ResourceManager, BracketNameResource = nameof(UIAccident.IU39_3_3), MinValue = 8, MaxValue = 10
}
};
IntensiteSymptomes = new SliderModel()
{
Name = nameof(IntensiteSymptomes),
MaxValue = 10,
MinValue = 0,
StepValue = 1,
Value = "0",
BracketResourceManager = UIAccident.ResourceManager,
BracketTitleResource = nameof(UIAccident.IU39_3),
Brackets = brackets
};
InfosMedecinSpecialiste = new SpecialistPhysicianModel(true);
InfosMedecinMaladieSimilaire = new PhysicianModel();
MedicalConsultations = new List <MedicalConsultationModel> {
new MedicalConsultationModel(true)
};
}
protected override async Task OnInitializedAsync()
{
await base.OnInitializedAsync();
StartYear = new YearModel(DateTime.Today.Year - 8);
CategoryKey = GuidKey.Create(CategoryGuid, KeyFactory.Empty(typeof(Category)).Type);
CategoryName = await Queries.QueryAsync(new GetCategoryName(CategoryKey));
CategoryColor = await Queries.QueryAsync(new GetCategoryColor(CategoryKey));
CurrencyFormatter = await CurrencyFormatterFactory.CreateAsync();
await LoadAsync();
}
public static void Custom1()
{
List <EventModel> eventList = JsonConvert.DeserializeObject <List <EventModel> >(System.IO.File.ReadAllText(System.Web.Hosting.HostingEnvironment.MapPath("~/Content/eventData.json")));
var yearModel = new YearModel
{
yearId = 0,
yearName = "2019",
ticketModelList = new List <TicketModel>()
};
var temp = new List <string>();
foreach (var item in eventList)
{
temp.Add(item.ticket1);
temp.Add(item.ticket2);
}
var userList = new List <UserModel>();
var i = 0;
foreach (var item in temp.Distinct())
{
List <UserPaidModel> paidList = JsonConvert.DeserializeObject <List <UserPaidModel> >(System.IO.File.ReadAllText(System.Web.Hosting.HostingEnvironment.MapPath("~/Content/ticketBreakdown.json")));
decimal?amountPaid = paidList.Where(x => x.Name == item).Select(x => x.AmountPaid).FirstOrDefault();
userList.Add(new UserModel
{
userName = item,
userId = i,
totalUserPaid = amountPaid ?? 0m,
userModelPaidList = new List <UserModelPaid>()
{
new UserModelPaid {
amountPaid = amountPaid ?? 0m, yearId = 0
}
}
});;;;;
i++;
}
var newFileString = JsonConvert.SerializeObject(userList);
System.IO.File.WriteAllText(System.Web.Hosting.HostingEnvironment.MapPath("~/Content/userModelList.json"), newFileString);
}
//Find Single Year base on "term" (async)
public async Task <YearDTO> SearchSingleYearByIdAsync(int Id)
{
try
{
using (var unitOfWork = unitOfWorkFactory.Create())
{
YearModel model = await Task.Run(() => unitOfWork.YearRepository.GetSingleOrDefaultYear(x => x.YearId == Id));
return(_Mapper_ToDTO.Map <YearModel, YearDTO>(model));
}
}
catch (Exception ex)
{
LogException(ex);
throw ex;
}
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
OverviewParameter parameter = (OverviewParameter)e.Parameter;
string categoryName = parameter.CategoryKey.IsEmpty
? "All"
: await queryDispatcher.QueryAsync(new GetCategoryName(parameter.CategoryKey));
categoryKey = parameter.CategoryKey;
object period = null;
if (parameter.Month != null)
{
month = parameter.Month;
period = parameter.Month;
}
if (parameter.Year != null)
{
year = parameter.Year;
period = parameter.Year;
}
ViewModel = new OverviewViewModel(navigator, parameter.CategoryKey, categoryName, period);
ViewModel.Reload += OnViewModelReload;
handlers.Add(eventHandlers.AddUiThread <OutcomeCreated>(ViewModel, Dispatcher));
handlers.Add(eventHandlers.AddUiThread <OutcomeAmountChanged>(ViewModel, Dispatcher));
handlers.Add(eventHandlers.AddUiThread <OutcomeDescriptionChanged>(ViewModel, Dispatcher));
handlers.Add(eventHandlers.AddUiThread <OutcomeWhenChanged>(ViewModel, Dispatcher));
if (userPreferences.TryLoad("Overview.SortDescriptor", out SortDescriptor <OverviewSortType> sortDescriptor))
{
SortDescriptor = sortDescriptor;
}
else
{
SortDescriptor = new SortDescriptor <OverviewSortType>(OverviewSortType.ByDate, SortDirection.Ascending);
}
await ReloadAsync();
ContentLoaded?.Invoke(this, EventArgs.Empty);
}
public void LoadYears()
{
SelectedYear = 0;
foreach (int year in Years.Where(y => y != 0).ToList())
{
Years.Remove(year);
}
if (!Years.Contains(0))
{
Years.Add(0);
}
foreach (int year in YearModel.List())
{
Years.Add(year);
}
SelectedYear = YearModel.GetCurrentYear();
}
private void pvtGroups_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
GroupItemViewModel viewModel = (GroupItemViewModel)e.AddedItems.FirstOrDefault();
MonthModel month = viewModel.Parameter as MonthModel;
if (month != null)
{
this.parameter.Month = month;
}
YearModel year = viewModel.Parameter as YearModel;
if (year != null)
{
this.parameter.Year = year;
}
}
private void OnSelectedItemChanged(DependencyPropertyChangedEventArgs e)
{
MonthModel month = SelectedItem as MonthModel;
if (month != null)
{
ViewModel.Month = month;
return;
}
YearModel year = SelectedItem as YearModel;
if (year != null)
{
throw new NotImplementedException();
}
throw Ensure.Exception.NotSupported();
}