/// <inheritdoc />
public void AddItemToShoppingCart(string customerName, ProductTypeEnum productType, int count)
{
var cart = GetCustomerShoppingCart(customerName);
var shoppingCartItem = GetCustomerShoppingCartItem(productType, cart);
shoppingCartItem = shoppingCartItem ?? CreateCustomerShoppingCartItem(productType, cart);
var product = _catalog.GetProductByType(productType);
shoppingCartItem.Count += count;
shoppingCartItem.Cost = shoppingCartItem.Count * product.Cost;
_catalog.ModifyProductInventory(productType, -count);
}
public static IProduct CreateProduct(ProductTypeEnum productType)
{
switch (productType)
{
case ProductTypeEnum.A:
return(new ProductA());
case ProductTypeEnum.B:
return(new ProductB());
default:
throw new Exception("传输类型不存在");
}
}
public void TypicalSuccessTest()
{
// Arrange
const ProductTypeEnum productType = ProductTypeEnum.Chile;
MockInventoryService.Setup(m => m.GetInventory(It.IsAny <FilterInventoryParameters>()))
.Returns(new SuccessResult <IInventoryReturn>(Fixture.Create <IInventoryReturn>()));
// Act
var result = SystemUnderTest.Get(productType);
// Assert
Assert.IsNotNull(result);
Assert.IsNotEmpty(result);
}
/// <summary>
/// Converts a ProductTypeEnum value to a corresponding string value
/// </summary>
/// <param name="enumValue">The ProductTypeEnum value to convert</param>
/// <returns>The representative string value</returns>
public static string ToValue(ProductTypeEnum enumValue)
{
switch (enumValue)
{
//only valid enum elements can be used
//this is necessary to avoid errors
case ProductTypeEnum.BASE:
case ProductTypeEnum.ADD_ON:
return(StringValues[(int)enumValue]);
//an invalid enum value was requested
default:
return(null);
}
}
public static Image GetProductImageHighRes(ProductTypeEnum productType)
{
switch (productType)
{
case ProductTypeEnum.Weapon:
case ProductTypeEnum.Hospital:
case ProductTypeEnum.House:
case ProductTypeEnum.Hotel:
case ProductTypeEnum.ConstructionMaterials:
return(new Image(string.Format("/Content/Images/Product/Highres-{0}.png", productType.ToString())));
default:
return(new Image(string.Format("/Content/Images/Product/{0}.png", productType.ToString())));
}
}
public static string ToString(ProductTypeEnum val)
{
switch (val)
{
case ProductTypeEnum.PersonalThing:
{
return("Личные вещи");
}
default:
{
return(null);
}
}
}
/// <inheritdoc />
public void ModifyProductInventory(ProductTypeEnum productType, int count)
{
lock (_products)
{
var product = _products.First(a => a.ProductType == productType);
if (count < 0)
{
product?.RemoveInventory(Math.Abs(count));
}
else
{
product?.AddInventory(Math.Abs(count));
}
}
}
public TradeDummyCreator AddProduct(ProductTypeEnum productType, int quality, int amount, bool isSource)
{
var tp = new TradeProduct()
{
Amount = amount,
Quality = quality,
ProductID = (int)productType,
Entity = isSource ? trade.Source : trade.Destination,
EntityID = isSource ? trade.SourceEntityID.Value : trade.DestinationEntityID.Value,
Trade = trade,
TradeID = trade.ID
};
trade.TradeProducts.Add(tp);
return(this);
}
public void RemoveItem(HouseChest chest, ProductTypeEnum productType, int quality, int quantity = 1)
{
var item = GetChestItem(chest, productType, quality);
item.Quantity -= quantity;
if (item.Quantity < 0)
{
throw new Exception($"Quantity in chest({chest.FurnitureID}) is less than 0!");
}
if (item.Quantity == 0)
{
houseChestItemRepository.Remove(item);
}
ConditionalSaveChanges(houseChestItemRepository);
}
private RedemptionRequest GetRequest(ProductTypeEnum type)
{
var request = new RedemptionRequest();
request.ProductType = type;
request.MemberCode = UserSessionInfo == null ? string.Empty : UserSessionInfo.MemberCode;
request.ProductId = ProductIdField.Value;
request.CategoryId = string.IsNullOrEmpty(ProductDetails.CategoryId) ? "0" : ProductDetails.CategoryId;
request.RiskId = MemberSession == null ? "0" : MemberSession.RiskId;
request.Currency = MemberSession == null ? "0" : MemberSession.CurrencyCode;
request.PointRequired = string.IsNullOrEmpty(ProductDetails.PointsRequired) ? string.Empty : ProductDetails.PointsRequired;
request.IsMobile = true;
if (!string.IsNullOrEmpty(ProductDetails.DiscountPoints))
{
request.PointRequired = ProductDetails.DiscountPoints;
}
request.Quantity = int.Parse(tbQuantity.Text.Trim());
request.CountryCode = UserSessionInfo == null ? RewardsHelper.CountryCode : UserSessionInfo.CountryCode;
switch (type)
{
case ProductTypeEnum.Freebet:
request.CreditAmount = string.IsNullOrEmpty(ProductDetails.AmountLimit) ? string.Empty : ProductDetails.AmountLimit;
break;
case ProductTypeEnum.Online:
request.AimId = tbAccount.Text.Trim();
break;
default:
if (type == ProductTypeEnum.Normal || type == ProductTypeEnum.Wishlist)
{
request.Name = tbRName.Text.Trim();
request.ContactNumber = tbContact.Text.Trim();
request.Address = tbAddress.Value.Trim();
request.PostalCode = tbPostal.Text.Trim();
request.City = tbCity.Text.Trim();
request.Country = tbCountry.Text.Trim();
if (type == ProductTypeEnum.Wishlist)
{
request.Remarks = txtBoxRemarks.Value.Trim();
}
}
break;
}
return(request);
}
public IEnumerable <IProductReturn> Get(ProductTypeEnum productType, LotTypeEnum?lotType = null, bool includeInactive = false, bool filterProductsWithInventory = false)
{
IQueryable <IProductReturn> data;
switch (productType)
{
case ProductTypeEnum.Chile:
var chileLotType = lotType ?? LotTypeEnum.FinishedGood;
var chileState = chileLotType.ToChileState();
IResult <IQueryable <IChileProductReturn> > result;
if (chileState == ChileStateEnum.OtherRaw && chileLotType == LotTypeEnum.GRP)
{
result = _productsService.GetChileProducts(null, includeInactive, filterProductsWithInventory);
result.EnsureSuccessWithHttpResponseException();
data = result.ResultingObject.Where(c => c.ChileTypeDescription == "GRP");
}
else
{
result = _productsService.GetChileProducts(chileState, includeInactive, filterProductsWithInventory);
result.EnsureSuccessWithHttpResponseException();
data = result.ResultingObject;
}
break;
case ProductTypeEnum.Packaging:
var packagingResult = _productsService.GetPackagingProducts(includeInactive, filterProductsWithInventory);
packagingResult.EnsureSuccessWithHttpResponseException();
data = packagingResult.ResultingObject;
break;
case ProductTypeEnum.Additive:
var additiveResult = _productsService.GetAdditiveProducts(includeInactive, filterProductsWithInventory);
additiveResult.EnsureSuccessWithHttpResponseException();
data = additiveResult.ResultingObject;
break;
default:
var productsResult = _productsService.GetProducts(productType, includeInactive);
productsResult.EnsureSuccessWithHttpResponseException();
data = productsResult.ResultingObject;
break;
}
return(data
.Where(p => includeInactive || p.IsActive)
.OrderBy(p => p.ProductName));
}
internal static Product GetProduct(string productTitle, ProductTypeEnum productTypeEnum, Category category)
{
switch (productTypeEnum)
{
case ProductTypeEnum.ProductPrice10:
return(new Product(productTitle, 10, category));
case ProductTypeEnum.ProductPrice50:
return(new Product(productTitle, 50, category));
case ProductTypeEnum.ProductPrice250:
return(new Product(productTitle, 250, category));
default:
throw new Exception("ProductType not found!");
}
}
public static LotTypeEnum FromProductType(ProductTypeEnum productType)
{
switch (productType)
{
case ProductTypeEnum.Chile:
return(LotTypeEnum.FinishedGood);
case ProductTypeEnum.Packaging:
return(LotTypeEnum.Packaging);
case ProductTypeEnum.Additive:
return(LotTypeEnum.Additive);
default:
throw new NotImplementedException(string.Format("The ProductTypeEnum '{0}' is not supported.", productType));
}
}
/// <summary>
/// Converts a ProductTypeEnum value to a corresponding string value
/// </summary>
/// <param name="enumValue">The ProductTypeEnum value to convert</param>
/// <returns>The representative string value</returns>
public static string ToValue(ProductTypeEnum enumValue)
{
switch (enumValue)
{
//only valid enum elements can be used
//this is necessary to avoid errors
case ProductTypeEnum.WINE:
case ProductTypeEnum.FOOD:
case ProductTypeEnum.MERCHANDISE:
case ProductTypeEnum.COLLATERAL:
return(stringValues[(int)enumValue]);
//an invalid enum value was requested
default:
return(null);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Product" /> class.
/// </summary>
/// <param name="catalogItemId">Unique catalog Item id.</param>
/// <param name="isArchived">Returns true if the item is archived.</param>
/// <param name="groups">Collection of groups associated with this item.</param>
/// <param name="metafields">Collection of metafields.</param>
/// <param name="productType">Type of item (Product, Modifier, etc) (required).</param>
/// <param name="sku">Stock Keeping Unit (SKU) (required).</param>
/// <param name="name">Product name (required).</param>
/// <param name="description">Product description.</param>
/// <param name="price">Product price (required).</param>
/// <param name="imageFileName">Image File Name.</param>
/// <param name="alcohol">Product contains alcohol.</param>
public Product(string catalogItemId = default(string), bool?isArchived = default(bool?), List <GroupReference> groups = default(List <GroupReference>), List <Metafield> metafields = default(List <Metafield>), ProductTypeEnum productType = default(ProductTypeEnum), string sku = default(string), string name = default(string), string description = default(string), double?price = default(double?), string imageFileName = default(string), bool?alcohol = default(bool?))
{
// to ensure "productType" is required (not null)
if (productType == null)
{
throw new InvalidDataException("productType is a required property for Product and cannot be null");
}
else
{
this.ProductType = productType;
}
// to ensure "sku" is required (not null)
if (sku == null)
{
throw new InvalidDataException("sku is a required property for Product and cannot be null");
}
else
{
this.Sku = sku;
}
// to ensure "name" is required (not null)
if (name == null)
{
throw new InvalidDataException("name is a required property for Product and cannot be null");
}
else
{
this.Name = name;
}
// to ensure "price" is required (not null)
if (price == null)
{
throw new InvalidDataException("price is a required property for Product and cannot be null");
}
else
{
this.Price = price;
}
this.CatalogItemId = catalogItemId;
this.IsArchived = isArchived;
this.Groups = groups;
this.Metafields = metafields;
this.Description = description;
this.ImageFileName = imageFileName;
this.Alcohol = alcohol;
}
private static ShoppingCartItem GetCustomerShoppingCartItem(ProductTypeEnum productType,
ShoppingCart.ShoppingCart cart)
{
ShoppingCartItem shoppingCartItem = null;
for (var i = 0; i < cart.Items.Count; ++i)
{
var item = cart.Items[i];
if (item.ProductId == (int)productType)
{
shoppingCartItem = item;
break;
}
}
return(shoppingCartItem);
}
private void createGiftTransaction(Entity source, Entity destination, ProductTypeEnum productType, int quality, int amount, int?fuelUsed)
{
var transaction = new GiftTransaction()
{
Amount = amount,
Day = GameHelper.CurrentDay,
Destination = destination,
Source = source,
ProductID = (int)productType,
Quality = quality,
Time = DateTime.Now,
FuelUsed = fuelUsed
};
giftTransactionRepository.Add(transaction);
ConditionalSaveChanges(giftTransactionRepository);
}
public Company CreateCompany(string name, ProductTypeEnum productType, int regionID, int ownerID)
{
using (var scope = transactionScopeProvider.CreateTransactionScope())
{
Entity entity = entityService.CreateEntity(name, EntityTypeEnum.Company);
entity.Equipment.ItemCapacity = 5000;
var company = new Company()
{
ID = entity.EntityID,
OwnerID = ownerID,
ProductID = (int)productType,
Quality = 1,
RegionID = regionID,
WorkTypeID = (int)getWorkTypeForProduct(productType),
CompanyTypeID = (int)getCompanyTypeForProduct(productType)
};
switch (productType)
{
case ProductTypeEnum.MedicalSupplies:
createHospitalForCompany(company);
break;
}
if (productType.HasEnumAttribute <ConstructionAttribute>())
{
createConstructionForCompany(company);
}
companyRepository.Add(company);
companyRepository.SaveChanges();
var equipment = entity;
equipmentService.GiveItem(ProductTypeEnum.Fuel, 50, 1, entity.Equipment);
if (productType == ProductTypeEnum.SellingPower)
{
equipmentService.GiveItem(ProductTypeEnum.SellingPower, 10, 1, entity.Equipment);
}
scope?.Complete();
return(company);
}
}
public int GetProgressNeededToBuild(ProductTypeEnum constructionType, int quality)
{
double modifier = 0.01;
switch (constructionType)
{
case ProductTypeEnum.DefenseSystem:
return((int)(defenseSystemService.GetNeededConstructionPoints(quality) * modifier));
case ProductTypeEnum.Hotel:
return((int)(50_000 * modifier));
case ProductTypeEnum.House:
return((int)(5_000 * modifier));
}
throw new NotImplementedException();
}
public bool IsAllowedItemFor(Entity entity, ProductTypeEnum productType)
{
var allowed = GetAllowedProductsForEntity(entity.GetEntityType());
if (allowed.Contains(productType) == false)
{
return(false);
}
if (entity.GetEntityType() == EntityTypeEnum.Company)
{
allowed = GetAllowedProductsForCompany(entity.Company);
if (allowed.Contains(productType) == false)
{
return(false);
}
}
return(true);
}
public ProductBase Get(ProductTypeEnum productType)
{
IModelPortfolio modelPortfolio;
switch (productType)
{
case ProductTypeEnum.Payout:
modelPortfolio = _modelPortfolioRepository.Get(ProductTypeEnum.Investment, RiskCategoryEnum.Income);
return(new PayoutProduct(_dateTimeNow)
{
ModelPortfolio = modelPortfolio,
AnnualDerisking = true,
Investment = 100_000.0D,
Balance = 100_000.0D,
PayoutFreequency = PayoutFreequencyEnum.Month,
Payout = 150.50D,
InvestmentLength = 20,
});
public static void BuyOneCoffeOkTest()
{
var machine = new VendingMachine();
machine.InitMachine();
var coffeCupsCountBefore = machine.CoffeePort.ProductCount;
var userBug = new BugModel();
userBug.InitUserBug();
var twoRuble = new CoinModel()
{
Value = CoinValueEnum.Two, CoinType = CoinTypeEnum.Ruble
};
var tenRuble = new CoinModel()
{
Value = CoinValueEnum.Ten, CoinType = CoinTypeEnum.Ruble
};
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, twoRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
userBug.InsertCoinToMachine(machine, tenRuble);
var machineUserBugSumBefore = machine.UserSumRur;
const ProductTypeEnum itemType = ProductTypeEnum.Coffee;
var success = machine.BuyProduct(itemType);
Assert.IsTrue(success.Result);
var coffeCupsCountAfter = machine.CoffeePort.ProductCount;
Assert.AreEqual(coffeCupsCountAfter, coffeCupsCountBefore - 1);
var userBugSumAfter = machine.UserSumRur;
Assert.AreEqual(userBugSumAfter, machineUserBugSumBefore - machine.CoffeePort.ItemPrice);
}
private double getFuelMultiplier(ProductTypeEnum productType, int quality)
{
switch (productType)
{
case ProductTypeEnum.Grain:
case ProductTypeEnum.Iron:
case ProductTypeEnum.Oil:
case ProductTypeEnum.TeaLeaf:
case ProductTypeEnum.Wood:
return(0.15);
case ProductTypeEnum.Fuel:
return(0.15);
case ProductTypeEnum.Weapon:
return(Math.Sqrt(Math.Min(1, quality / 1.5)));
}
return(1.0);
}
public static WorkTypeEnum GetWorkType(this ProductTypeEnum productType)
{
switch (productType)
{
case ProductTypeEnum.Grain:
case ProductTypeEnum.Oil:
case ProductTypeEnum.Iron:
case ProductTypeEnum.TeaLeaf:
case ProductTypeEnum.Wood:
{
return(WorkTypeEnum.Raw);
}
case ProductTypeEnum.MedicalSupplies:
case ProductTypeEnum.Weapon:
case ProductTypeEnum.MovingTicket:
case ProductTypeEnum.Bread:
case ProductTypeEnum.Fuel:
case ProductTypeEnum.Tea:
case ProductTypeEnum.Paper:
case ProductTypeEnum.UpgradePoints:
{
return(WorkTypeEnum.Manufacturing);
}
case ProductTypeEnum.Development:
case ProductTypeEnum.ConstructionMaterials:
case ProductTypeEnum.Hotel:
case ProductTypeEnum.House:
case ProductTypeEnum.DefenseSystem:
case ProductTypeEnum.Hospital:
{
return(WorkTypeEnum.Construction);
}
case ProductTypeEnum.SellingPower:
{
return(WorkTypeEnum.Selling);
}
}
throw new NotImplementedException();
}
public double GetProductionPoints(ProductTypeEnum producedProduct, int hitPoints, double skill, double distance, int quality, int resourceQuality, double regionDevelopment, int peopleCount)
{
var factory = new ProductionPointsCalculatorFactory()
.SetProductType(producedProduct);
var calculator = factory.Create();
var args = new ProductionPointsCalculateArgs()
{
Development = regionDevelopment,
Distance = distance,
PeopleCount = peopleCount,
ProducedProduct = producedProduct,
Quality = quality,
ResourceQuality = resourceQuality,
Skill = skill,
HitPoints = hitPoints
};
return(calculator.Calculate(args));
}
public MethodResult HaveItem(Equipment equipment, ProductTypeEnum productType, int quality, int amount)
{
if (equipment == null)
{
return(new MethodResult("Equipment does not exist!"));
}
if (productType.IsDefined() == false)
{
return(new MethodResult("Wrong product type!"));
}
var item = equipmentRepository.GetEquipmentItem(equipment.ID, productType.ToInt(), quality);
if (item == null || item.Amount < amount)
{
return(new MethodResult("You does not have this item!"));
}
return(MethodResult.Success);
}
public IProductReturn Get(ProductTypeEnum productType, string id)
{
switch (productType)
{
case ProductTypeEnum.Chile:
var chileProductResult = _productsService.GetChileProductDetail(id);
chileProductResult.EnsureSuccessWithHttpResponseException();
return(chileProductResult.ResultingObject);
case ProductTypeEnum.Additive:
var additiveProductResult = _productsService.GetAdditiveProducts(includeInactive: true);
additiveProductResult.EnsureSuccessWithHttpResponseException();
var additiveProduct = additiveProductResult.ResultingObject.ToList().FirstOrDefault(p => p.ProductKey == id);
if (additiveProduct == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(additiveProduct);
case ProductTypeEnum.Packaging:
var packagingProductResults = _productsService.GetPackagingProducts(includeInactive: true);
packagingProductResults.EnsureSuccessWithHttpResponseException();
var packagingProduct = packagingProductResults.ResultingObject.ToList().FirstOrDefault(p => p.ProductKey == id);
if (packagingProduct == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(packagingProduct);
default:
var productResults = _productsService.GetProducts(productType, true);
productResults.EnsureSuccessWithHttpResponseException();
var product = productResults.ResultingObject.ToList().FirstOrDefault(p => p.ProductKey == id);
if (product == null)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return(product);
}
}
private double getDistanceAmountMultiplier(ProductTypeEnum productType, int quality)
{
double mult;
switch (productType)
{
case ProductTypeEnum.Bread:
case ProductTypeEnum.Iron:
case ProductTypeEnum.Oil:
case ProductTypeEnum.TeaLeaf:
case ProductTypeEnum.Wood:
mult = 0.0005; break;
case ProductTypeEnum.Fuel:
mult = 0.001; break;
default:
mult = 0.01; break;
}
return(mult + (1.0 + quality * 0.01));
}
/// <summary>
/// Initializes a new instance of the <see cref="CreateProductReference" /> class.
/// </summary>
/// <param name="catalogItemId">Identifier of the CatalogItemId to use as SubProduct (required).</param>
/// <param name="productType">Type of the SupProduct (required).</param>
/// <param name="preselectedQuantity">Quantity of the modifier that will be set when the parent product is placed in the basket.</param>
public CreateProductReference(string catalogItemId = default(string), ProductTypeEnum productType = default(ProductTypeEnum), int?preselectedQuantity = default(int?))
{
// to ensure "catalogItemId" is required (not null)
if (catalogItemId == null)
{
throw new InvalidDataException("catalogItemId is a required property for CreateProductReference and cannot be null");
}
else
{
this.CatalogItemId = catalogItemId;
}
// to ensure "productType" is required (not null)
if (productType == null)
{
throw new InvalidDataException("productType is a required property for CreateProductReference and cannot be null");
}
else
{
this.ProductType = productType;
}
this.PreselectedQuantity = preselectedQuantity;
}
public void GiveItem(HouseChest chest, ProductTypeEnum productType, int quality, int quantity = 1)
{
var item = GetChestItem(chest, productType, quality);
if (item != null)
{
item.Quantity += quantity;
}
else
{
item = new HouseChestItem()
{
ChestID = chest.FurnitureID,
ProductID = (int)productType,
Quality = quality,
Quantity = quantity
};
houseChestItemRepository.Add(item);
}
ConditionalSaveChanges(houseChestItemRepository);
}
public void registerEmittedCouponForVente(CalculResultBean calculBean, Transaction transaction, AvoirTypeEnum transactionSpecificity, ProductTypeEnum onlyOn)
{
using (var context = new bourseContainer())
{
EmittedCoupon emittedCoupon = new EmittedCoupon
{
datetime = DateTime.Now,
value = calculBean.ARendreAvoir,
Transaction = transaction,
onlyOn = onlyOn.ToString(),
transactionSpecificity = transactionSpecificity.ToString()
};
context.Entry(emittedCoupon).State = EntityState.Added;
context.SaveChanges();
context.Entry(emittedCoupon).State = EntityState.Detached;
}
}
