private WishModel ConvertWishModel(WishList m)
{
return(new WishModel
{
UserId = m.UserId,
DateCreate = m.DateCreate,
ProductId = m.ProductId,
Id = m.Id,
Product = new ProductBaseModel
{
BrandName = m.Product?.Name,
DiscountPercent = m.Product.Discount,
Id = m.Product.Id,
KeyUrl = m.Product?.KeyUrl,
Price = m.Product.Price,
PhotoUrl = m.Product?.PhotoUrl,
Name = m.Product?.Name,
DiscountPrice = CalculationService.GetDiscountPrice(m.Product.Price, m.Product.Discount)
}
});
}
static void Main(string[] args)
{
List <Product> list = new List <Product>();
Console.Write("Enter N: ");
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
string[] vect = Console.ReadLine().Split(',');
string name = vect[0];
double price = double.Parse(vect[1]);
list.Add(new Product(name, price));
}
CalculationService calculationService = new CalculationService();
Product max = calculationService.max(list);
Console.WriteLine("Max is " + max);
}
private void SyncNewBrands(List<string> syncList){
var builder = new StringBuilder();
var accountData = AccountService.Instance(_filesystem).Get(AppSettings.SelectedAccount);
var suffix = accountData.IsFemale ? "female" : "male";
var dataFolder = $"DataBase/Brands/BrandData_{suffix}.json";
var brandData = JsonValue.Parse(_filesystem.ReadFile(dataFolder));
CalculationService.Instance(_filesystem).SetGeneralItem(new KeyValuePair<string, JsonValue>("0", brandData["0"]));
foreach (var key in syncList)
{
var itemData = new KeyValuePair<string, JsonValue>(key, brandData[key]);
CalculationService.Instance(_filesystem).BuldElement(builder, itemData, accountData);
}
builder.AppendLine("}");
var file = _filesystem.ReadFile(AccountDataPath);
file = file.Remove(file.LastIndexOf('}'), 1) + builder;
_filesystem.SaveFile(AccountDataPath, file);
}
static void Main(string[] args)
{
List <Product> list = new List <Product>();
Console.Write("Entre com o número de Produtos: ");
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
Console.WriteLine("Exemplo > (produto, 23.90): ");
string[] vect = Console.ReadLine().Split(',');
double price = double.Parse(vect[1], CultureInfo.InvariantCulture);
list.Add(new Product(vect[0], price));
}
CalculationService calculationService = new CalculationService();
Product p = calculationService.Max(list); // <Product> is optional
Console.WriteLine("Mais caro:");
Console.WriteLine(p);
}
static void Main(string[] args)
{
List <Product> list = new List <Product>();
Console.Write("How many values? ");
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
string[] vect = Console.ReadLine().Split(',');
string name = vect[0];
double price = double.Parse(vect[1], CultureInfo.InvariantCulture);
list.Add(new Product(name, price));
}
CalculationService calculationService = new CalculationService();
Product max = calculationService.Max(list);
Console.WriteLine("Max: " + max);
}
static void Main(string[] args)
{
List <Product> list = new List <Product>();
Console.Write("Enter the number of products: ");
int n = int.Parse(Console.ReadLine());
for (int i = 0; i < n; i++)
{
string[] vect = Console.ReadLine().Split(',');
double price = double.Parse(vect[1], CultureInfo.InvariantCulture);
list.Add(new Product(vect[0], price));
}
CalculationService calculationService = new CalculationService();
Product p = calculationService.Max(list); // <Product> is optional
Console.WriteLine("Most expensive:");
Console.WriteLine(p);
}
public async Task IsCalculationNameValid_WhenSpecificationDoesNotExist_ThenReturnsNotFoundResult()
{
// Arrange
string specificationId = "spec1";
ISpecificationRepository specificationRepository = CreateSpecificationRepository();
specificationRepository
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns((SpecificationSummary)null);
CalculationService service = CreateCalculationService(specificationRepository: specificationRepository);
// Act
IActionResult result = await service.IsCalculationNameValid(specificationId, "calc1", null);
// Assert
result
.Should()
.BeOfType <NotFoundResult>();
}
static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure();
var service = new CalculationService();
service.CalculateTaxes(22);
service.Transfer("Jonas", "AC1", 2);
//
//service.Transfer("Hana", "AC2", 1);
var store = new Store();
((ICountable)store).Inc();
Console.WriteLine(((ICountable)store).GetCount());
store.GetModifiedState(3);
store.GetModifiedState(3);
Console.ReadKey();
}
public async Task IsCalculationNameValid_WhenSpecificationDoesNotExist_ThenReturnsNotFoundResult()
{
// Arrange
string specificationId = "spec1";
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(specificationId))
.Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, null));
CalculationService service = CreateCalculationService(specificationsApiClient: specificationsApiClient);
// Act
IActionResult result = await service.IsCalculationNameValid(specificationId, "calc1", null);
// Assert
result
.Should()
.BeOfType <NotFoundResult>();
}
public async Task GetCalculationByName_GivenModelDoesNotContainASpecificationId_ReturnsBadRequest()
{
//Arrange
CalculationGetModel model = new CalculationGetModel();
ILogger logger = CreateLogger();
CalculationService service = CreateCalculationService(logger: logger);
//Act
IActionResult result = await service.GetCalculationByName(model);
//Assert
result
.Should()
.BeOfType <BadRequestObjectResult>();
logger
.Received(1)
.Error(Arg.Is("No specification id was provided to GetCalculationByName"));
}
async public Task GetCalculationById_GivenNoCalculationIdWasprovided_ReturnsBadRequest()
{
//Arrange
HttpRequest request = Substitute.For<HttpRequest>();
ILogger logger = CreateLogger();
CalculationService service = CreateCalculationService(logger: logger);
//Act
IActionResult result = await service.GetCalculationById(request);
//Assert
result
.Should()
.BeOfType<BadRequestObjectResult>();
logger
.Received(1)
.Error(Arg.Is("No calculation Id was provided to GetCalculationById"));
}
static void Main(string[] args)
{
ICalculationService calculationService = new CalculationService();
bool repeat = true;
while (repeat)
{
Console.Write("Enter a number equal or smaller than {0} (Enter 'q' to quit): ", ConfigurationManager.AppSettings["UpperLimit"]);
string input = Console.ReadLine().ToLower();
if (input.Equals("q"))
{
Environment.Exit(0);
}
Result result = calculationService.Calculate(input);
Console.WriteLine(result.ToString());
}
}
public void Caclulate_TaxRatePassed_ProductWithAppliedTax(decimal taxRate, float expectedPriceInt)
{
// Arrange
CalculationService calculationService = new CalculationService(taxRate);
decimal expectedPrice = (decimal)expectedPriceInt;
Product testProduct = new Product
(
PRODUCT_NAME,
UPC,
new Money(PRICE)
);
// Act
Receipt result = calculationService.Calculate(testProduct);
// Assert
Assert.Equal(PRODUCT_NAME, result.Product.Name);
Assert.Equal(UPC, result.Product.UPC);
Assert.Equal(expectedPrice, result.Product.Price.Amount);
}
public async Task GetCalculationsMetadataForSpecification_GivenItemsFoundInCache_ReturnsItemsFromCache()
{
//Arrange
List <CalculationMetadata> calculations = new List <CalculationMetadata>
{
new CalculationMetadata(),
new CalculationMetadata()
};
string cacheKey = $"{CacheKeys.CalculationsMetadataForSpecification}{SpecificationId}";
ICacheProvider cacheProvider = CreateCacheProvider();
cacheProvider
.GetAsync <List <CalculationMetadata> >(Arg.Is(cacheKey))
.Returns(calculations);
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
CalculationService calculationService = CreateCalculationService(
cacheProvider: cacheProvider,
calculationsRepository: calculationsRepository);
//Act
IActionResult actionResult = await calculationService.GetCalculationsMetadataForSpecification(SpecificationId);
//Assert
actionResult
.Should()
.BeAssignableTo <OkObjectResult>()
.Which
.Value
.Should()
.BeSameAs(calculations);
await
calculationsRepository
.DidNotReceive()
.GetCalculationsMetatadataBySpecificationId(Arg.Any <string>());
}
public async Task EditCalculationStatus_GivenNewStatusButNoSpecSummaryFound_ReturnsPreConditionFailed()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
ISpecificationsApiClient specificationsApiClient = CreateSpecificationsApiClient();
specificationsApiClient
.GetSpecificationSummaryById(Arg.Is(calculation.SpecificationId))
.Returns(new Common.ApiClient.Models.ApiResponse <SpecModel.SpecificationSummary>(HttpStatusCode.OK, null));
CalculationService service = CreateCalculationService(
logger: logger, calculationsRepository: CalculationsRepository, specificationsApiClient: specificationsApiClient);
//Act
IActionResult result = await service.UpdateCalculationStatus(CalculationId, CalculationEditStatusModel);
//Arrange
result
.Should()
.BeAssignableTo <PreconditionFailedResult>()
.Which
.Value
.Should()
.Be("Specification not found");
}
public async Task EditCalculationStatus_GivenStatusHasNoChanges_DoesNotUpdateReturnsOkResult()
{
//Arrange
EditStatusModel CalculationEditStatusModel = new EditStatusModel
{
PublishStatus = PublishStatus.Approved
};
ILogger logger = CreateLogger();
Calculation calculation = CreateCalculation();
calculation.Current.PublishStatus = PublishStatus.Approved;
ICalculationsRepository CalculationsRepository = CreateCalculationsRepository();
CalculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: CalculationsRepository);
//Act
IActionResult result = await service.UpdateCalculationStatus(CalculationId, CalculationEditStatusModel);
//Arrange
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.Be(calculation.Current);
await
CalculationsRepository
.DidNotReceive()
.UpdateCalculation(Arg.Any <Calculation>());
}
public async Task CheckHasAllApprovedTemplateCalculationsForSpecificationId_GivenResult_ReturnsExpectedResponseValue(int result, bool expected)
{
//Arrange
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCountOfNonApprovedTemplateCalculations(Arg.Is(SpecificationId))
.Returns(result);
CalculationService calculationService = CreateCalculationService(calculationsRepository: calculationsRepository);
//Act
IActionResult actionResult = await calculationService.CheckHasAllApprovedTemplateCalculationsForSpecificationId(SpecificationId);
//Assert
BooleanResponseModel responseModel = (actionResult as OkObjectResult).Value as BooleanResponseModel;
responseModel
.Value
.Should()
.Be(expected);
}
public async Task Calc_InvalidOperationException()
{
var inputService = new Mock <IInputFormatService>();
var outputService = new Mock <IOutputService>();
var context = new CalculationContext();
inputService.Setup(s => s.GetInput()).ReturnsInOrderAsync(new List <InputDto>()
{
new InputDto("5", 1),
new InputDto("2", 3),
new InputDto("-", 5),
new InputDto("abc", 7),
}, null);
var service = new CalculationService(inputService.Object, outputService.Object);
await service.Calc(context);
context.CalculationData.Count.Should().Be(1);
context.CalculationData.Pop().Should().Be(3);
outputService.Verify(s => s.Output("'abc' is not a valid display name in CalculatorDemo.Application.Domain.CalculationOperationType"), Times.Once);
}
static void Main(string[] args)
{
List <Product> list = new List <Product>();
Console.Write("Enter N: ");
int quantity = int.Parse(Console.ReadLine());
for (int i = 0; i < quantity; i++)
{
string[] vect = Console.ReadLine().Split(',');
string name = vect[0];
double price = double.Parse(vect[1], CultureInfo.InvariantCulture);
list.Add(new Product(name, price));
}
CalculationService cs = new CalculationService();
Product max = cs.Max(list);
Console.WriteLine("Most Expensive: ");
Console.WriteLine(max);
}
public ActionResult Delete(int id)
{
if (ModelState.IsValid)
{
bool status = ExecuteActionWithValidation(() =>
{
new CalculationService().Delete(id);
SetSuccessMessage("The calculation will be deleted.");
});
if (status)
{
ModelState.Clear();
return(View("New"));
}
}
var calculation = new CalculationService().GetViewById(id);
return(View("Details", GetViewModelFromCalculation(calculation)));
}
public async Task GetCalculationsMetadataForSpecification_GivenItemsNotFoundInCacheAndNotInDatabase_ReturnsEmptyList()
{
//Arrange
string cacheKey = $"{CacheKeys.CalculationsMetadataForSpecification}{SpecificationId}";
ICacheProvider cacheProvider = CreateCacheProvider();
cacheProvider
.GetAsync <List <CalculationMetadata> >(Arg.Is(cacheKey))
.Returns((List <CalculationMetadata>)null);
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationsMetatadataBySpecificationId(Arg.Is(SpecificationId))
.Returns((IEnumerable <CalculationMetadata>)null);
CalculationService calculationService = CreateCalculationService(
cacheProvider: cacheProvider,
calculationsRepository: calculationsRepository);
//Act
IActionResult actionResult = await calculationService.GetCalculationsMetadataForSpecification(SpecificationId);
//Assert
actionResult
.Should()
.BeAssignableTo <OkObjectResult>()
.Which
.Value
.Should()
.BeSameAs(Enumerable.Empty <CalculationMetadata>());
await
cacheProvider
.DidNotReceive()
.SetAsync(Arg.Any <string>(), Arg.Any <List <CalculationMetadata> >());
}
async public Task GetCalculationCurrentVersion_GivencalculationWasFoundWithNoCurrent_ReturnsNotFound()
{
//Arrange
Calculation calculation = new Calculation();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "calculationId", new StringValues(CalculationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationById(Arg.Is(CalculationId))
.Returns(calculation);
CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: calculationsRepository);
//Act
IActionResult result = await service.GetCalculationCurrentVersion(request);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"A current calculation was not found for calculation id {CalculationId}"));
}
async public Task GetCalculationHistory_GivenCalculationIdWasProvided_ReturnsOK()
{
//Arrange
IEnumerable <CalculationVersion> versions = new List <CalculationVersion>
{
new CalculationVersion(),
new CalculationVersion()
};
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "calculationId", new StringValues(CalculationId) }
});
HttpRequest request = Substitute.For <HttpRequest>();
request
.Query
.Returns(queryStringValues);
ILogger logger = CreateLogger();
IVersionRepository <CalculationVersion> versionsRepository = CreateCalculationVersionRepository();
versionsRepository
.GetVersions(Arg.Is(CalculationId))
.Returns(versions);
CalculationService service = CreateCalculationService(logger: logger, calculationVersionRepository: versionsRepository);
//Act
IActionResult result = await service.GetCalculationHistory(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
}
async public Task GetCurrentCalculationsForSpecification_WhenEmptyListOfCalculationsFoundInCache_ThenCalculationsReturned()
{
//Arrange
const string specificationId = "specid";
List <CalculationResponseModel> calculations = new List <CalculationResponseModel>();
ILogger logger = CreateLogger();
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
ICacheProvider cacheProvider = CreateCacheProvider();
cacheProvider
.GetAsync <List <CalculationResponseModel> >($"{CacheKeys.CurrentCalculationsForSpecification}{specificationId}")
.Returns(calculations);
CalculationService service = CreateCalculationService(logger: logger, calculationsRepository: calculationsRepository, cacheProvider: cacheProvider);
//Act
IActionResult result = await service.GetCurrentCalculationsForSpecification(CalculationId);
//Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeAssignableTo <IEnumerable <CalculationResponseModel> >()
.Which
.Should()
.HaveCount(calculations.Count);
await calculationsRepository
.Received(0)
.GetCalculationsBySpecificationId(Arg.Is(specificationId));
}
public async Task <ActionResult> Index(CancellationToken ctk)
{
DateTime startDate = DateTime.UtcNow;
HomePageViewModel viewModel = new HomePageViewModel();
viewModel.AddMessage(string.Concat("Starting Action on thread id ", Thread.CurrentThread.ManagedThreadId));
Task <string> calculationResultTask = CalculationService.GetResultAsync(ctk);
Task <string> databaseResultTask = DatabaseService.GetDataAsync(ctk);
await Task.WhenAll(calculationResultTask, databaseResultTask);
viewModel.AddMessage(calculationResultTask.GetAwaiter().GetResult());
viewModel.AddMessage(databaseResultTask.GetAwaiter().GetResult());
DateTime endDate = DateTime.UtcNow;
TimeSpan diff = endDate - startDate;
viewModel.AddMessage(string.Concat("Finishing Action on thread id ", Thread.CurrentThread.ManagedThreadId));
viewModel.AddMessage(string.Concat("Action processing time: ", diff.TotalSeconds));
return(View(viewModel));
}
public async Task ItReturnsExpectedResult()
{
var instructionSet = new InstructionSet()
{
ApplyNumber = 3,
Instructions = new List <Instruction>()
{
new Instruction("add", 3),
new Instruction("add", 3)
}
};
_mockInstructionSetService.Setup <InstructionSet>(v => v.GetInstructionSet(It.IsAny <IEnumerable <string> >()))
.Returns(instructionSet);
var calculationService = new CalculationService(
_mockReadFileService.Object,
_mockInstructionSetService.Object);
var result = await calculationService.Run("filePath");
Assert.Equal(9, result);
}
public async Task EditCalculationStatus_GivenNullEditModelWasProvided_ReturnsBadRequest()
{
//Arrange
ILogger logger = CreateLogger();
CalculationService service = CreateCalculationService(logger: logger);
//Act
IActionResult result = await service.UpdateCalculationStatus(CalculationId, null);
//Arrange
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null status model provided");
logger
.Received(1)
.Error(Arg.Is("A null status model was provided"));
}
public async Task GetCurrentCalculationsForSpecification_GivenNoCalculationIdWasProvided_ReturnsBadRequest()
{
//Arrange
ILogger logger = CreateLogger();
CalculationService service = CreateCalculationService(logger: logger);
//Act
IActionResult result = await service.GetCurrentCalculationsForSpecification(null);
//Assert
result
.Should()
.BeOfType <BadRequestObjectResult>()
.Which
.Value
.Should()
.Be("Null or empty specificationId provided");
logger
.Received(1)
.Warning(Arg.Is("No specificationId was provided to GetCalculationsForSpecification"));
}
public async Task ResetCalculationForFieldDefinitionChanges_GivenNoCalculationsRequiredResetting_LogsAndDoesNotContinue()
{
//Arrange
const string specificationId = "spec-id";
IEnumerable <DatasetSpecificationRelationshipViewModel> relationships = Enumerable.Empty <DatasetSpecificationRelationshipViewModel>();
IEnumerable <string> currentFieldDefinitionNames = Enumerable.Empty <string>();
ILogger logger = CreateLogger();
IEnumerable <Calculation> calculations = new[]
{
new Calculation
{
Current = new CalculationVersion
{
SourceCode = "source"
}
}
};
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationsBySpecificationId(Arg.Is(specificationId))
.Returns(calculations);
CalculationService calculationService = CreateCalculationService(logger: logger, calculationsRepository: calculationsRepository);
//Act
await calculationService.ResetCalculationForFieldDefinitionChanges(relationships, specificationId, currentFieldDefinitionNames);
//Assert
logger
.Received(1)
.Information(Arg.Is($"No calculations required resetting for specification id '{specificationId}'"));
}
public async Task GetCalculationByName_GivenSpecificationExistsAndCalculationDoesNotExist_ReturnsNotFound()
{
//Arrange
Calculation calc = new Calculation {
Current = new CalculationVersion {
Name = CalculationName
}
};
CalculationGetModel model = new CalculationGetModel
{
SpecificationId = SpecificationId,
Name = CalculationName
};
ILogger logger = CreateLogger();
ICalculationsRepository calculationsRepository = CreateCalculationsRepository();
calculationsRepository
.GetCalculationsBySpecificationIdAndCalculationName(Arg.Is(SpecificationId), Arg.Is(CalculationName))
.Returns((Calculation)null);
CalculationService service = CreateCalculationService(calculationsRepository: calculationsRepository, logger: logger);
//Act
IActionResult result = await service.GetCalculationByName(model);
//Assert
result
.Should()
.BeOfType <NotFoundResult>();
logger
.Received(1)
.Information(Arg.Is($"A calculation was not found for specification id {SpecificationId} and name {CalculationName}"));
}
public void TestInit()
{
context = new TestRules();
service = new CalculationService();
}
