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