private void CreateTredDescription(UpdateTrendViewModel model, DateTime start, DateTime stop,
Category cat, Cube cub, CategoryOption option, int limit)
{
StringBuilder sb = new StringBuilder();
sb.Append("Chart: ");
sb.Append("From: " + start.ToString() + " ");
sb.Append("To: " + stop.ToString() + ", ");
if (cat != null || cub != null || option != null)
{
sb.Append("For: ");
if (cat != null)
{
sb.Append("category " + cat.Name + ", ");
}
if (cub != null)
{
sb.Append("cube: " + cub.Manufacturer.Name + " " + cub.ModelName + " " + cub.PlasticColor.Name + ", ");
}
if (option != null)
{
sb.Append("option: " + option.Name + ", ");
}
}
if (limit > 0)
{
sb.Append("Last " + limit + " series, ");
}
model.TrendDescription = sb.ToString()[0..^ 2];
public AddCommandBuilder(CommandLineApplication application)
{
_application = application;
_yearOption = YearOption.Create(application);
_monthOption = MonthOption.Create(application);
_currencyOption = CurrencyOption.Create(application);
_amountOption = AmountOption.Create(application);
_categoryOption = CategoryOption.Create(application);
_descriptionOption = DescriptionOption.Create(application);
}
public IActionResult Category([FromRoute] string category)
{
ProjectOption projOpt = new ProjectOption
{
Category = category
};
CategoryOption catOpt = new CategoryOption
{
Category = category,
Projects = projManager.FindProjectByCategory(projOpt)
};
return(View(catOpt));
}
public async Task <Serie> GetBestSerieOfCubeAsync(Cube cube, CategoryOption option = null)
{
if (cube == null)
{
return(null);
}
if (option == null)
{
return(await GetBestSerieAsync(s => s.Cube == cube));
}
else
{
return(await GetBestSerieAsync(s => s.Cube == cube && s.SerieOption == option));
}
}
public async Task <Serie> GetBestSerieOfCategoryAsync(Category category, CategoryOption option = null)
{
if (category == null)
{
return(null);
}
if (option == null)
{
return(await GetBestSerieAsync(s => s.Cube.Category == category));
}
else
{
return(await GetBestSerieAsync(s => s.Cube.Category == category && s.SerieOption == option));
}
}
public async Task <Result> CreateNewSeriesAsync(string userId, Cube cube, CategoryOption option, DateTime startTime)
{
var canBeCreated = await CheckCreateSerieConditionsAsync(userId, cube, option);
if (!canBeCreated.IsFaulted)
{
var serie = new Serie()
{
UserIdentity = userId,
Cube = cube,
StartTimeStamp = startTime,
LongestResult = TimeSpan.FromMilliseconds(0),
ShortestResult = TimeSpan.FromMilliseconds(0),
AtLeastOneDNF = false,
SerieOption = option,
SerieFinished = false,
SolvesAmount = 0,
};
_dbContext.Series.Add(serie);
var result = await _dbContext.SaveChangesAsync();
if (result > 0)
{
return(new Result(string.Empty, false)
{
JsonData = serie.Identity
});
}
else
{
return(new Result(ApplicationResources.TimerDB.Messages.SerieCreatingError));
}
}
else
{
return(canBeCreated);
}
}
public static CategoryTypes GetCategoryType(this CategoryOption categoryOption)
{
switch (categoryOption)
{
case CategoryOption.Condition:
return(CategoryTypes.Condition);
case CategoryOption.StockType:
return(CategoryTypes.StockType);
case CategoryOption.Organization:
return(CategoryTypes.Organization);
case CategoryOption.Usage:
return(CategoryTypes.Usage);
case CategoryOption.NotSelected:
return(CategoryTypes.InvalidType);
default:
return(CategoryTypes.InvalidType);
}
}
private static int Run(string[] args)
{
var app = new CommandLineApplication();
var budget = app.Command("budget", config =>
{
config.HelpOption(HelpFlagTemplate.Value);
});
budget.Command("create", config =>
{
config.Name = "create";
config.Description = "create budget providing year, month and currency";
config.HelpOption(HelpFlagTemplate.Value);
var yearOption = YearOption.Create(config);
var monthOption = MonthOption.Create(config);
var currencyOption = CurrencyOption.Create(config);
config.OnExecute(() =>
{
if (yearOption.NotExists || monthOption.NotExists || currencyOption.NotExists)
{
config.ShowHelp();
return(ErrorCode.Value);
}
var budgetFilesFactory = new BudgetFilesFactory();
var(plannedBudgetFile, realBudgetFile) = budgetFilesFactory.Create(yearOption, monthOption, currencyOption);
if (plannedBudgetFile.NotExists || realBudgetFile.NotExists)
{
plannedBudgetFile.Save();
realBudgetFile.Save();
Console.WriteLine($"Budget {plannedBudgetFile.Budget} has been created.");
return(OkCode.Value);
}
Console.WriteLine($"Budget {plannedBudgetFile.Budget} already exists.");
return(OkCode.Value);
});
});
budget.Command("add", config =>
{
config.Name = "add";
config.Description = "add revenue or expense to budget";
config.HelpOption(HelpFlagTemplate.Value);
var yearOption = YearOption.Create(config);
var monthOption = MonthOption.Create(config);
var currencyOption = CurrencyOption.Create(config);
var amountOption = AmountOption.Create(config);
var categoryOption = CategoryOption.Create(config);
var descriptionOption = DescriptionOption.Create(config);
config.OnExecute(() =>
{
if (yearOption.NotExists ||
monthOption.NotExists ||
currencyOption.NotExists ||
amountOption.NotExists ||
categoryOption.NotExists ||
descriptionOption.NotExists)
{
config.ShowHelp();
return(ErrorCode.Value);
}
var budgetFilesFactory = new BudgetFilesFactory();
var(plannedBudgetFile, realBudgetFile) = budgetFilesFactory.Create(yearOption, monthOption, currencyOption);
if (realBudgetFile.NotExists)
{
Console.WriteLine($"Budget {realBudgetFile.Budget} does not exit. Created new budget first.");
return(ErrorCode.Value);
}
var budgetFile = realBudgetFile.Load();
var category = Category.Create(categoryOption.Value);
var description = new Description(descriptionOption.Value);
var currency = Currency.Create(currencyOption.Value);
var amount = Amount.Create(amountOption.Value, currency);
var newBudget = budgetFile.Budget.WithExpense(new Money(amount, category, DateTimeOffset.UtcNow, description));
var newBudgetFile = new BudgetFile(newBudget, budgetFile.FileName);
newBudgetFile.Save();
Console.WriteLine("Expense added.");
return(OkCode.Value);
});
});
// var budget = new BudgetCommandBuilder(app).Build();
//
// new CreateBudgetCommandBuilder(budget).Build();
// new BudgetsListCommandBuilder(budget).Build();
// new AddCommandBuilder(budget).Build();
return(app.Execute(args));
}
private async Task CreateSeriesModel(TimerViewModel model, Cube cube, UserModel user,
CategoryOption categoryOption, long serieId)
{
model.Username = user.UserName;
model.UserId = user.Id;
model.CategoryID = cube.Category.Identity;
model.CubeID = cube.Identity;
model.OptionID = categoryOption.Identity;
model.SeriesId = serieId;
model.CategoryName = cube.Category.Name;
model.CategoryOptionName = categoryOption.Name;
model.CubeDescription = string.Format("{0} {1} {2}", cube.Manufacturer.Name, cube.ModelName, cube.PlasticColor.Name);
model.CurrentScramble = await _scrambleService.GetDefaultCompleteScrambleAsync(cube.Category);
if (model.CurrentScramble?.Scramble?.MovesAmount > 0)
{
var allScrambles = (await _scrambleService.GetAllDefinedScramblesForCategoryAsync(cube.Category.Identity))
.Where(s => s.Disabled == false && s.MovesAmount > 0)
.OrderBy(s => s.Name)
.ToList();
foreach (var scramble in allScrambles)
{
model.ScrambleNames.Add(scramble.Identity, scramble.Name);
}
}
var serie = await _seriesService.GetSpecificSerieAsync(serieId);
var solves = (await _seriesService.GetAllSolvesOfSerieAsync(serieId))
.OrderBy(s => s.Identity)
.ToList();
if (serieId > 0 && serie != null && solves != null)
{
model.StartTime = serie.StartTimeStamp;
model.SerieFinished = serie.SerieFinished;
model.AtLeastOneDNF = serie.AtLeastOneDNF;
model.LongestResult = serie.LongestResult;
model.ShortestResult = serie.ShortestResult;
model.AverageTime = serie.AverageTime;
model.MeanOf3 = serie.MeanOf3;
model.AverageOf5 = serie.AverageOf5;
foreach (var solve in solves)
{
model.Solves.Add(new TimerViewModel.SingleTimeViewModel()
{
Number = solves.IndexOf(solve) + 1,
Duration = solve.Duration,
TimeSpan = solve.FinishTimeSpan,
DNF = solve.DNF,
Penalty = solve.PenaltyTwoSeconds,
});
}
}
else
{
model.SerieFinished = false;
model.AtLeastOneDNF = false;
model.LongestResult = TimeSpan.FromMilliseconds(0);
model.ShortestResult = TimeSpan.FromMilliseconds(0);
model.AverageTime = TimeSpan.FromMilliseconds(0);
model.MeanOf3 = TimeSpan.FromMilliseconds(0);
model.AverageOf5 = TimeSpan.FromMilliseconds(0);
}
}
private async Task <Result> CheckCreateSerieConditionsAsync(string userId, Cube cube, CategoryOption option)
{
if (string.IsNullOrEmpty(userId) || cube == null || option == null)
{
return(new Result(ApplicationResources.TimerDB.Messages.NullArgument));
}
if (!await _dbContext.CubesCollections.Where(c => c.UserIdentity == userId).AnyAsync(c => c.Cube == cube))
{
return(new Result(ApplicationResources.TimerDB.Messages.CubeNotInCollection));
}
if (!await _dbContext.CategoryoptionsSets.Where(co => co.Category == cube.Category).AnyAsync(co => co.Option == option))
{
return(new Result(ApplicationResources.TimerDB.Messages.CategoryOptionNotInCategory));
}
return(new Result(string.Empty, false));
}
public async Task <IEnumerable <Serie> > GetSeriesOfUserFilteredAsync(string userId,
int limit = 0, DateTime?startDate = null, DateTime?endDate = null,
Category category = null, Cube cube = null, CategoryOption option = null)
{
var seriesCollection = await GetUserSeriesAsync(userId);
if (seriesCollection.Any())
{
if (startDate.HasValue)
{
seriesCollection = seriesCollection.Where(s => s.StartTimeStamp >= startDate).ToList();
}
if (endDate.HasValue)
{
seriesCollection = seriesCollection.Where(s => s.StartTimeStamp <= endDate).ToList();
}
if (category != null)
{
seriesCollection = seriesCollection.Where(s => s.Cube.Category == category).ToList();
}
if (cube != null)
{
seriesCollection = seriesCollection.Where(s => s.Cube == cube).ToList();
}
if (option != null)
{
seriesCollection = seriesCollection.Where(s => s.SerieOption == option).ToList();
}
if (limit > 0 && seriesCollection.Count() > limit)
{
seriesCollection = seriesCollection.Take(limit).ToList();
}
}
return(seriesCollection);
}
public async Task <Result> CheckIfSerieCanBeCreatedAsync(string userId, Cube cube, CategoryOption option)
{
return(await CheckCreateSerieConditionsAsync(userId, cube, option));
}
