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(); }