public ActionResult DoNewProduct(ProductNew model)
{
try
{
decimal d;
var productPdo = new Domain.Entities.Product();
productPdo.PosId = model.PosId;
productPdo.CategoryId = model.CategoryId;
productPdo.Name = HttpUtility.HtmlEncode(model.ProductName);
productPdo.CreatedAt = DateTime.UtcNow;
productPdo.UserId = "gj";
productPdo.StatusId = (byte)Status.Pending;
productPdo.InternalCode = model.InternalCode.StartsWith(productPdo.UserId, StringComparison.InvariantCultureIgnoreCase) ? model.InternalCode : String.Concat(productPdo.UserId.ToUpper(), "_ES_", model.InternalCode);
productPdo.Uid = string.Concat("GJ_ES_", model.InternalCode);
if (decimal.TryParse(model.PriceStr, out d))
{
productPdo.Price = d;
}
_productRepository.Save(productPdo);
_productRepository.SubmitChanges();
var product = new Product(productPdo);
ViewBag.TotalSizes = model.TotalSizes;
return(PartialView(product));
}
catch (Exception ex)
{
throw;
}
}
public void Post([FromBody] DTO.Product product)
{
Console.WriteLine($"DEBUG: Entering {nameof(Post)}");
Console.WriteLine($"DEBUG: Request body contained: {product}");
// TODO: updatedBy
var updatedBy = "SYSTEM";
using (var db = new TransactionServiceDbContext())
{
var dbProduct = db.Products.FindAsync(product.ProductId).Result;
if (dbProduct == null)
{
// PK is serial, so should be automatically generated
dbProduct = new Domain.Entities.Product
{
CreatedBy = updatedBy,
CreatedOn = DateTime.UtcNow
};
db.Add(dbProduct);
}
dbProduct.Name = product.Name;
dbProduct.Description = product.Description;
dbProduct.UpdatedBy = updatedBy;
dbProduct.UpdatedOn = DateTime.UtcNow;
db.SaveChangesAsync();
}
}
public void CalculateBinWidth_Returns_RequiredBinWidth(int quantity, Domain.Entities.Product product, float expectedBinWidth)
{
// Act
var result = _ruleEngine.CalculateBinWidth(product, quantity);
// Assert
Assert.Equal(expectedBinWidth, result);
}
/// <summary>
/// Конструктор
/// </summary>
/// <param name="product"> <see cref="ProductInfo"/> </param>
public ProductSearchInfoForManager(Domain.Entities.Product product)
{
Guid = product.Guid;
Article = product.Article;
Name = product.Name;
DateTime = product.DateTime;
DeliveryType = product.DeliveryType;
DeliveryStatus = product.DeliveryStatus;
}
public static Dto.Model.Product MapToDto(this Domain.Entities.Product product)
{
return(new Dto.Model.Product()
{
Quantity = product.Quantity,
Price = product.Price,
Name = product.Name,
ID = product.ID,
Description = product.Description
});
}
public void AddProduct(ProductDataContract pdc)
{
// маппинг ProductDataContract на cущность
Domain.Entities.Product p = new Domain.Entities.Product
{
Name = pdc.Name,
Category = pdc.Category,
Price = pdc.Price
};
m_dbe.Add(p);
}
public async Task RegisterNewProductAsync(Domain.Entities.Product product, List <RequestFile> photos, RequestFile profile)
{
const string profilePhotoName = nameof(product.ProfilePhoto);
const string photosName = nameof(product.Photos);
const string bucketName = nameof(profile.Bucket);
const string nameOfPhotosName = nameof(RequestFile.Name);
var productValidation = product.Validate(profilePhotoName, photosName);
var profileValidation = profile.Validate(bucketName, nameOfPhotosName);
var photosValidation = photos?.SelectMany(p => p.Validate(bucketName, nameOfPhotosName));
if (productValidation.IsValid() && profileValidation.IsValid() && photosValidation.IsValid())
{
await _repository.CreateProductAsync(product);
_uploader.FileUploaded += OnPhotoUploaded;
profile.Name = $"{ProductName}-{product.Key}-{ProfileTypeName}-{profile.Key}".ToLower();
profile.Bucket = "store-lab-product-profile";
profile.Metadata = new Dictionary <string, string>
{
{ ProductKeyName, product.Key },
{ FileTypeName, ProfileTypeName }
};
photos?.ForEach(p =>
{
p.Name = $"{ProductName}-{product.Key}-{PhotoTypeName}-{p.Key}".ToLower();
p.Bucket = "store-lab-product-photos";
p.Metadata = new Dictionary <string, string>
{
{ ProductKeyName, product.Key },
{ FileTypeName, PhotoTypeName }
};
});
await _uploader.UploadAsync(profile);
await _uploader.UploadAllAsync(photos);
var args = new RegisterNewProductEventArgs {
Product = product
};
ProductRegisted?.Invoke(this, args);
}
else
{
throw new EntityException(productValidation.Aggregate(profileValidation).Aggregate(photosValidation));
}
}
private ProductsAndSizesViewModel AddNewCategory(Domain.Entities.Product p)
{
var c = new ProductsAndSizesViewModel();
c.CategoryId = p.CategoryId;
c._sizes = new List <ProductSizeQuantity>();
foreach (var s in p.ProductDetails)
{
AddSizeName(c, s.ParameterValue);
}
c.Products = new List <Product>();
c.Products.Add(new Product(p));
return(c);
}
public GetProductResponse Map(Domain.Entities.Product source)
{
if (source == null)
{
return(null);
}
return(new GetProductResponse
{
Key = source.Key,
Code = source.Code,
Name = source.Name,
Properties = source.Properties,
ModifiedOn = source.ModifiedOn,
CreatedOn = source.CreatedOn
});
}
public async Task <BaseDto <ProductInput> > Handle(BaseRequest <ProductInput> request, CancellationToken cancellationToken)
{
var input = request.data.attributes;
var product = new Domain.Entities.Product
{
name = input.name,
price = input.price
};
_context.products.Add(product);
await _context.SaveChangesAsync(cancellationToken);
return(new BaseDto <ProductInput>
{
Message = "Success add product data",
Status = true,
Data = input
});
}
public async Task <Unit> Handle(CreateProductCommand request, CancellationToken cancellationToken)
{
Domain.Entities.Product entity = new Domain.Entities.Product
{
ProductId = Guid.NewGuid(),
UserId = request.UserId,
Name = request.Name,
Desciption = request.Desciption,
Slug = request.Slug,
Count = request.Count,
Price = request.Price,
};
_context.Products.Add(entity);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public static Product AsDbEntity(this Domain.Entities.Product product)
{
if (product is null)
{
return(null);
}
var dbEntity = new Product
{
Id = product.Id,
Name = product.Name,
Description = product.Description,
PriceCurrency = (int)product.Price.Currency,
PriceAmount = product.Price.Amount,
Stock = product.Stock
};
return(dbEntity);
}
private ProductsByCategoryViewModel GetProductsByCategories(int posId)
{
var con = new System.Data.SqlClient.SqlConnection(MySettings.ConnectionStringDefault);
con.Open();
var cmd = new System.Data.SqlClient.SqlCommand(
@"select
-- top 1000
p.id as id, -- 0
p.internal_code,
p.uid,
p.name,
p.price,
c.id as category_id, -- 5
c.name as category_name,
isnull(pd.parameter_value, '') as size_name,
isnull(pd.price_minor, 0) as price_minor,
isnull(pd.price_release_minor, 0) as price_release_minor,
isnull(pd.quantity, 0), -- 10
isnull(pd.id, 0) as price_id,
isnull(pd.data_json, '') as data_json
from product p
join category c on p.category_id = c.id
left join product_detail pd on p.id = pd.product_id
where p.pos_id = " + posId + @"
order by p.id", con);
ProductsByCategoryViewModel productsByCategories = new ProductsByCategoryViewModel();
var products = new List<OnBalance.Domain.Entities.Product>();
decimal priceMinor, priceReleaseMinor;
int priceId;
string dataJson;
Dictionary<int, string> categoryNames = new Dictionary<int, string>();
var r = cmd.ExecuteReader();
while (r.Read())
{
var p = new Product();
p.Id = r.GetInt32(0);
p.InternalCode = r.GetString(1);
p.Uid = r.GetString(2);
p.Name = r.GetString(3);
//p.Price = r.GetDecimal(4);
p.CategoryId = r.GetInt32(5);
p.Price = r.GetDecimal(9);
priceMinor = r.GetDecimal(8);
priceReleaseMinor = r.GetDecimal(9);
var psq = new ProductSizeQuantity();
psq.SizeName = r.GetString(7);
psq.Quantity = r.GetInt32(10);
priceId = r.GetInt32(11);
dataJson = r.GetString(12);
// Store category name
categoryNames[p.CategoryId] = r.GetString(6);
var existing = products.FirstOrDefault(x => x.Id == p.Id);
if (existing == null)
{
var newP = new Domain.Entities.Product
{
Id = p.Id,
InternalCode = p.InternalCode,
Uid = p.Uid,
Name = p.Name,
CategoryId = p.CategoryId
};
newP.ProductDetails.Add(new Domain.Entities.ProductDetail
{
Id = priceId,
ParameterValue = psq.SizeName,
Quantity = psq.Quantity,
PriceMinor = priceMinor,
PriceReleaseMinor = priceReleaseMinor,
DataJson = dataJson,
});
products.Add(newP);
}
else
{
existing.ProductDetails.Add(new Domain.Entities.ProductDetail {
Id = priceId,
ParameterValue = psq.SizeName,
Quantity = psq.Quantity,
PriceMinor = priceMinor,
PriceReleaseMinor = priceReleaseMinor,
DataJson = dataJson
});
}
}
productsByCategories = new ProductsByCategoryViewModel(products);
// Fill category names
foreach (var c in productsByCategories.ProductsByCategories)
{
var firstProduct = c.Products.FirstOrDefault();
if (firstProduct != null)
{
c.CategoryName = categoryNames.Keys.Contains(firstProduct.CategoryId) ? categoryNames[firstProduct.CategoryId] : "";
}
}
return productsByCategories;
}
public ActionResult DoNewProduct(ProductNew model)
{
try
{
decimal d;
var productPdo = new Domain.Entities.Product();
productPdo.PosId = model.PosId;
productPdo.CategoryId = model.CategoryId;
productPdo.Name = HttpUtility.HtmlEncode(model.ProductName);
productPdo.CreatedAt = DateTime.UtcNow;
productPdo.UserId = "gj";
productPdo.StatusId = (byte)Status.Pending;
productPdo.InternalCode = model.InternalCode.StartsWith(productPdo.UserId, StringComparison.InvariantCultureIgnoreCase) ? model.InternalCode : String.Concat(productPdo.UserId.ToUpper(), "_ES_", model.InternalCode);
productPdo.Uid = string.Concat("GJ_ES_", model.InternalCode);
if (decimal.TryParse(model.PriceStr, out d))
{
productPdo.Price = d;
}
_productRepository.Save(productPdo);
_productRepository.SubmitChanges();
var product = new Product(productPdo);
ViewBag.TotalSizes = model.TotalSizes;
return PartialView(product);
}
catch (Exception ex)
{
throw;
}
}
