public async Task <ActionResult> GetWasteChartData(MonthEnum month) { var model = new GetMonthWasteChartData.Query(); model.Month = month; return(Ok(await _mediator.Send(model))); }
/// <summary> /// Converts a MonthEnum value to a corresponding string value /// </summary> /// <param name="enumValue">The MonthEnum value to convert</param> /// <returns>The representative string value</returns> public static string ToValue(MonthEnum enumValue) { switch (enumValue) { //only valid enum elements can be used //this is necessary to avoid errors case MonthEnum.JANUARY: case MonthEnum.FEBRUARY: case MonthEnum.MARCH: case MonthEnum.APRIL: case MonthEnum.MAY: case MonthEnum.JUNE: case MonthEnum.JULY: case MonthEnum.AUGUST: case MonthEnum.SEPTEMBER: case MonthEnum.OCTOBER: case MonthEnum.NOVEMBER: case MonthEnum.DECEMBER: return(StringValues[(int)enumValue]); //an invalid enum value was requested default: return(null); } }
public async Task <ActionResult> GetChartsData(MonthEnum month) { var model = new GetUtilityBillChartsData.Query(); model.Month = month; return(Ok(await _mediator.Send(model))); }
public static DateTime GetDate(int day, MonthEnum mes) { DateTime date; date = new DateTime(DateTime.Now.Year, (int)mes, day); return(DiaUtil(date)); }
public PayPattern(IPaymentInterval interval, MonthEnum startsInMonth) : base() { Interval = new SaveableXmlElement <IPaymentInterval>(interval); StartsInMonth = startsInMonth; UpdateAffectedMonths(); }
public IPayPattern Create(IPaymentInterval interval, MonthEnum startsInMonth) { var payPattern = new PayPattern(interval, startsInMonth); Project.CurrentProject.Elements.AddElement(payPattern); return(payPattern); }
public void RemoveAffectedMonth(MonthEnum month) { if (!AffectedMonths.Contains(month)) { return; } var newAffectedMonths = new List <MonthEnum>(AffectedMonths); newAffectedMonths.Remove(month); AffectedMonths = newAffectedMonths; }
public void AddAffectedMonth(MonthEnum month) { if (AffectedMonths.Contains(month)) { return; } var newAffectedMonths = new List <MonthEnum>(); newAffectedMonths.AddRange(AffectedMonths); newAffectedMonths.Add(month); AffectedMonths = newAffectedMonths; }
static void Main(string[] args) { // Monday is day #1. DayEnum someDay = DayEnum.Wed; int dayNumber = (int)someDay; Console.WriteLine("{0} is day # {1}.", someDay, dayNumber); // Mar is the 3rd month in the year! MonthEnum someMonth = MonthEnum.Mar; int monthNumber = (int)someMonth; Console.WriteLine("{0} is the {1}rd month in the year!", someMonth, monthNumber); // Monday: 1 Friday: 5 int weekDayStart = (int)DayEnum.Mon; int weekDayEnd = (int)DayEnum.Fri; Console.WriteLine("Monday: {0}", weekDayStart); Console.WriteLine("Friday: {0}", weekDayEnd); // getname string day = Enum.GetName(typeof(DayEnum), 3); Console.WriteLine(day); // string days = Enum.GetNames(typeof(DayEnum)); // Console.WriteLine(string.Join(" ", days)); // Switch switch (someDay) { case DayEnum.Sun: Console.WriteLine("Sunday!"); break; case DayEnum.Mon: Console.WriteLine("Monday:("); break; case DayEnum.Tue: Console.WriteLine("Tuesday"); break; default: Console.WriteLine("Unknown day"); break; } }
public static string MonthName(MonthEnum month) { string monthName = null; switch (month) { case MonthEnum.January: return(januaryName); case MonthEnum.February: return(februaryName); case MonthEnum.March: return(marchName); case MonthEnum.April: return(aprilName); case MonthEnum.May: return(mayName); case MonthEnum.June: return(juneName); case MonthEnum.July: return(julyName); case MonthEnum.August: return(augustName); case MonthEnum.September: return(septemberName); case MonthEnum.October: return(octoberName); case MonthEnum.November: return(novemberName); case MonthEnum.December: return(decemberName); default: break; } return(monthName); }
public IMonth Create(MonthEnum monthType, IYear year, bool addOneTimePayments) { var transactionFactory = new TransactionFactory() { Project = Project }; var newMonth = new Month(monthType, year); Project.CurrentProject.Elements.AddElement(newMonth); var paymentsForMonth = Project.CurrentProject.Payments.GetPaymentsForMonth(monthType, addOneTimePayments); transactionFactory.AddTransactions(newMonth, paymentsForMonth); return(newMonth); }
public IList <DeliveryServiceViewModel> Calculate(MonthEnum month, IList <DeliveryService> deliveryServices) { var result = new List <DeliveryServiceViewModel>(); if (deliveryServices.IsNullOrEmpty()) { return(result); } if (deliveryServices.Any(ds => ds.Seasons.IsNullOrEmpty())) { return(result); } foreach (var deliveryService in deliveryServices) { var defaultSeason = deliveryService.Seasons.SingleOrDefault(s => !s.From.HasValue && !s.To.HasValue); if (defaultSeason == null) { continue; //invalid data } var matchingSeason = deliveryService.Seasons.Where(s => !s.From.HasValue && !s.To.HasValue && s.From <= month && month <= s.To) .SingleOrDefault(); var factor = matchingSeason != null ? matchingSeason.Factor : defaultSeason.Factor; var price = deliveryService.BaseCost * factor; result.Add(new DeliveryServiceViewModel { Id = deliveryService.Id, Name = deliveryService.Name, Price = price, DeliveryInfo = deliveryService.DeliveryInfo }); } return(result); }
public static string ConvertToText(this MonthEnum month) { switch (month) { case (MonthEnum.Jan): return("Jan"); case (MonthEnum.Feb): return("Feb"); case (MonthEnum.Mar): return("Mar"); case (MonthEnum.Apr): return("Apr"); case (MonthEnum.Mai): return("Mai"); case (MonthEnum.Jun): return("Jun"); case (MonthEnum.Jul): return("Jul"); case (MonthEnum.Aug): return("Aug"); case (MonthEnum.Sep): return("Sep"); case (MonthEnum.Oct): return("Oct"); case (MonthEnum.Nov): return("Nov"); default: return("Dez"); } }
public static IEnumerable<DateTime> DayInYear(MonthEnum month, DayEnum day) { foreach (var year in EveryYear()) { if (HaveDay(year, month, day)) yield return GetDayInYear(year, month, day); } }
public static IEnumerable<DateTime> DayInChineseYear(MonthEnum month, DayEnum day) { foreach (var dt in EveryYear()) { var year = dt.Year -1; var monthIndex = (int)month; //如果有闰月,则只返回第一个 var leapMonth = chineseCalendar.GetLeapMonth(year);//返回的是闰月加1 if (leapMonth != 0 && leapMonth <= monthIndex) monthIndex++; if (Chinese_HaveMoreDaysThan(year, monthIndex, day)) yield return GetDayInChineseYear(year, monthIndex, day); } }
/// <summary> /// Get the spending insights grouped by counter party /// </summary> /// <param name="accountUid">Required parameter: Account uid</param> /// <param name="year">Required parameter: Year</param> /// <param name="month">Required parameter: Month</param> /// <return>Returns the Models.SpendingCounterPartySummary response from the API call</return> public async Task <SpendingCounterPartySummary> GetQuerySpendingInsightsByCounterpartyAsync(Guid accountUid, string year, MonthEnum month) { //validating required parameters if (null == year) { throw new ArgumentNullException(nameof(year), "The parameter \"year\" is a required parameter and cannot be null."); } //the base uri for api requests var baseUri = Configuration.GetBaseURI(); //prepare query string for API call var queryBuilder = new StringBuilder(baseUri); queryBuilder.Append("/api/v2/accounts/{accountUid}/spending-insights/counter-party"); //process optional template parameters APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object> { { "accountUid", accountUid } }); //process optional query parameters APIHelper.AppendUrlWithQueryParameters(queryBuilder, new Dictionary <string, object> { { "year", year }, { "month", MonthEnumHelper.ToValue(month) } }, ArrayDeserializationFormat, ParameterSeparator); //validate and preprocess url var queryUrl = APIHelper.CleanUrl(queryBuilder); //append request with appropriate headers and parameters var headers = APIHelper.GetRequestHeaders(); //prepare the API call request to fetch the response var request = ClientInstance.Get(queryUrl, headers); //invoke request and get response var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false); var context = new HTTPContext(request, response); //handle errors ValidateResponse(response, context); try { return(APIHelper.JsonDeserialize <SpendingCounterPartySummary>(response.Body)); } catch (Exception ex) { throw new APIException("Failed to parse the response: " + ex.Message, context); } }
/// <summary> /// Return all Yakus find in a collection of cards. /// </summary> /// <param name="cards">Cards</param> /// <param name="currentMonth">Current month</param> /// <returns>Enumerable of YakuEnum</returns> public static IEnumerable <YakuEnum> GetYakus(this IEnumerable <Card> cards, MonthEnum currentMonth) { var cardArray = cards as Card[] ?? cards.ToArray(); var yakus = new List <YakuEnum>(); //SANKO if (cardArray.Count(YakuLambda.NoRainMan) == 3) { yakus.Add(YakuEnum.Sanko); } //SHIKO if (cardArray.Count(YakuLambda.NoRainMan) == 4) { yakus.Remove(YakuEnum.Sanko); yakus.Add(YakuEnum.Shiko); } //AME_SHIKO if (cardArray.Count(YakuLambda.NoRainMan) == 3 && cardArray.Any(YakuLambda.RainMan)) { yakus.Remove(YakuEnum.Sanko); yakus.Add(YakuEnum.AmeShiko); } //GOKO if (cardArray.Count(YakuLambda.Special) == 5) { yakus.Remove(YakuEnum.Shiko); yakus.Add(YakuEnum.Goko); } //INOSHIKACHO if (cardArray.Count(YakuLambda.Inoshikacho) == 3) { yakus.Add(YakuEnum.Inoshikacho); } //TANE if (cardArray.Count(YakuLambda.Animal) >= 5) { yakus.Add(YakuEnum.Tane); } //AKATAN if (cardArray.Count(YakuLambda.Poem) == 3) { yakus.Add(YakuEnum.Akatan); } //AOTAN if (cardArray.Count(YakuLambda.Blue) == 3) { yakus.Add(YakuEnum.Aotan); } //AKATAN_AOTAN_NO_CHOFUKU if (yakus.Contains(YakuEnum.Akatan) && yakus.Contains(YakuEnum.Aotan)) { yakus.Add(YakuEnum.AkatanAotanNoChofuku); } //TAN if (cardArray.Count(YakuLambda.Ribbon) >= 5) { yakus.Add(YakuEnum.Tan); } //TSUKIMI if (cardArray.Any(YakuLambda.Moon) && cardArray.Any(YakuLambda.SakeCup)) { yakus.Add(YakuEnum.TsukimiZake); } //HANAMI if (cardArray.Any(YakuLambda.Curtain) && cardArray.Any(YakuLambda.SakeCup)) { yakus.Add(YakuEnum.HanamiZake); } //KASU if (cardArray.Count(YakuLambda.Normal) >= 10) { yakus.Add(YakuEnum.Kasu); } //BAKE_FUDA if (cardArray.Count(YakuLambda.Normal) == 9 && cardArray.Any(YakuLambda.SakeCup)) { yakus.Add(YakuEnum.BakeFuda); } //TSUKI_FUDA if (cardArray.Count(x => x.Month == currentMonth) == 4) { yakus.Add(YakuEnum.TsukiFuda); } return(yakus); }
public async Task <decimal> GetTotalTransactionByTypeAndMonth(MonthEnum month, TransactionType type) { return(await _dbContext.Transactions.Where(t => t.CreatedDate.Value.Month == (int)month && t.TransactionType == (int)type).Select(t => t.Amout).SumAsync()); }
/// <summary> /// Create a new instance of a normal Card /// </summary> /// <param name="id">Identity of the card</param> /// <param name="family">Card family</param> /// <param name="month">Card month</param> public Card(int id, FamilyEnum family, MonthEnum month) { Id = id; Family = family; Month = month; }
private static bool HaveDay(DateTime year, MonthEnum month, DayEnum day) { return DateTime.DaysInMonth(year.Year, (int)month) >= (int)day; }
public IPayment Create(string name, ICategory category, double amount, PaymentIntervalType intervalType, MonthEnum startingMonth, ICategory subCategory = null) { var interval = Project.CurrentProject.Intervals.Single(i => i.Type == intervalType); var factory = new PayPatternFactory() { Project = Project }; var pattern = factory.Create(interval, startingMonth); var payment = new Payment(name, category, amount, pattern, subCategory); Project.CurrentProject.Elements.AddElement(payment); return(payment); }
public MonthEnum Get(MonthEnum month) { return(month); }
public static IEnumerable <IPayment> GetPaymentsForMonth(this IEnumerable <IPayment> payments, MonthEnum currentMonth, bool addOneTimePayments = false) { return(payments.Where(t => (!t.IsOneTimePayment || addOneTimePayments) && t.PayPattern.Element.AffectedMonths.Any(p => p == currentMonth)) .OrderBy(p => p.Category.Element.SortOrder) .ThenBy(p => p.SubCategory.Element?.SortOrder)); }
public Month(MonthEnum monthType, IYear year) : this() { MonthType = monthType; Name = MonthType.ConvertToText(); Year.Element = year; }
public AffectedMonthViewModel(MonthEnum monthType, bool isSelected, PaymentViewModel payment) { MonthType = monthType; IsSelected = isSelected; Payment = payment; }
public static IEnumerable<DateTime> WeekDayInMonth(MonthEnum month, int weekIndex, WeekDayEnum weekDay) { foreach (var year in EveryYear()) { var dt = year.AddMonths((int)month - 1); var firstDayOfMonth = dt.WeekDay(); var days = weekIndex * 7 + weekDay - firstDayOfMonth; if (weekDay >= firstDayOfMonth) days -= 7; yield return dt.AddDays(days); } }
/// <summary> /// This is a sumary. /// </summary> /// <remarks> /// This is a test: /// /// POST /Todo /// { /// "id": 1, /// "name": "Item1", /// "isComplete": true /// } /// /// </remarks> public MonthEnum Post(MonthEnum month = MonthEnum.July) { return(month); }
private static DateTime GetDayInYear(DateTime year, MonthEnum month, DayEnum day) { return new DateTime(year.Year, (int)month, (int)day); }
public MonthEnum Put(MonthEnum month) { return(month); }
private Month(MonthEnum month, string mmm) { _month = month; _mmm = mmm; Name = _month.ToString(); }
public MonthEnum Delete(MonthEnum month) { return(month); }
/// <summary> /// Create a new instance of a special Card /// </summary> /// <param name="id">Identity of the card</param> /// <param name="month">Card month</param> /// <param name="special">Special type</param> public Card(int id, MonthEnum month, SpecialEnum special) : this(id, FamilyEnum.Special, month) { Special = special; }
/// <summary> /// Get the spending insights grouped by counter party /// </summary> /// <param name="accountUid">Required parameter: Account uid</param> /// <param name="year">Required parameter: Year</param> /// <param name="month">Required parameter: Month</param> /// <return>Returns the Models.SpendingCounterPartySummary response from the API call</return> public SpendingCounterPartySummary GetQuerySpendingInsightsByCounterparty(Guid accountUid, string year, MonthEnum month) { var t = GetQuerySpendingInsightsByCounterpartyAsync(accountUid, year, month); APIHelper.RunTaskSynchronously(t); return(t.GetAwaiter().GetResult()); }
/// <summary> /// Initializes a new instance of the <see cref="Body10" /> class. /// </summary> /// <param name="day">day (required).</param> /// <param name="email">email (required).</param> /// <param name="month">month (required).</param> /// <param name="year">year (required).</param> public Body10(DayEnum day = default(DayEnum), string email = default(string), MonthEnum month = default(MonthEnum), YearEnum year = default(YearEnum)) { // to ensure "day" is required (not null) if (day == null) { throw new InvalidDataException("day is a required property for Body10 and cannot be null"); } else { this.Day = day; } // to ensure "email" is required (not null) if (email == null) { throw new InvalidDataException("email is a required property for Body10 and cannot be null"); } else { this.Email = email; } // to ensure "month" is required (not null) if (month == null) { throw new InvalidDataException("month is a required property for Body10 and cannot be null"); } else { this.Month = month; } // to ensure "year" is required (not null) if (year == null) { throw new InvalidDataException("year is a required property for Body10 and cannot be null"); } else { this.Year = year; } }
/// <summary> /// True if a card enumeration has a Teshi, otherwise false /// </summary> /// <param name="cards">IEnumarable extends</param> /// <param name="month">Month</param> /// <returns>True if a card enumeration has a Teshi, otherwise false</returns> public static bool HasTeshi(this IEnumerable <Card> cards, MonthEnum month) { return(cards.Count(x => x.Month == month) == 4); }