internal Item(Helper aHelper, Tree aTree, Device aDevice, EventServerUpnp aEventServer, bool aIsProxy)
{
iLock = new object();
iHelper = aHelper;
iTree = aTree;
iEventServer = aEventServer;
iIsProxy = aIsProxy;
iBasicSetup = new BasicSetup(aDevice, aEventServer);
iPlayback = new Playback(aHelper, aDevice, aEventServer);
if (aIsProxy)
{
iServiceProxy = new ServiceProxy(aDevice);
}
else
{
iServiceVolkano = new ServiceVolkano(aDevice);
}
if (Box.IsFallBack(aDevice.Udn) && !aIsProxy)
{
iBox = iTree.AddFallbackBox(iBasicSetup, aDevice, aEventServer, iProductId, iBoardId.ToArray(), iBoardType.ToArray(), iBoardDescription.ToArray(), iBoardNumber.ToArray(), iSoftwareVersion);
GetVersionInfo();
}
else
{
//wait for service product to collect box data before turning on Box
iServiceProduct = new ServiceProduct(aDevice, iEventServer);
iServiceProduct.EventInitial += EventHandlerProductInitial;
}
}
protected override async Task OnInitializedAsync()
{
await base.OnInitializedAsync();
CategoriesIEnum = await ServiceCategory.ListAllAsync();
if (CategoriesIEnum.Count() > 0)
{
CategoriesItems = CategoriesIEnum.ToDictionary(item => item.Id, item => item.Name);
}
if (ProductId != Guid.Empty)
{
IsEdit = true;
}
if (IsEdit)
{
ProductObj = await ServiceProduct.FindByIdAsync(ProductId);
if (ProductObj.Removed)
{
NavManager.NavigateTo(_pageList);
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("ServiceProductId,Summary,DurationDays,ID,Price")] ServiceProduct serviceProduct)
{
if (id != serviceProduct.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(serviceProduct);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ServiceProductExists(serviceProduct.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(serviceProduct));
}
public ActionResult List()
{
ServiceProduct service = new ServiceProduct();
List <CompanyProduct> model = service.GetAllProducts();
return(View(model));
}
public ServiceProduct GetProductById(int productId)
{
using (SqlConnection connection = new SqlConnection(_connectionString))
{
connection.Open();
using (SqlCommand cmdGetProductById = connection.CreateCommand())
{
ServiceProduct product = new ServiceProduct();
cmdGetProductById.CommandText = "SELECT productId, name, price, description, amountOnStock, brandId, categoryId, rowID FROM Product WHERE productId = @productId";
cmdGetProductById.Parameters.AddWithValue("productId", productId);
SqlDataReader productReader = cmdGetProductById.ExecuteReader();
while (productReader.Read())
{
product.Name = productReader.GetString(productReader.GetOrdinal("name"));
product.Description = productReader.GetString(productReader.GetOrdinal("description"));
product.Price = productReader.GetDecimal(productReader.GetOrdinal("price"));
product.ProductId = productReader.GetInt32(productReader.GetOrdinal("productId"));
product.AmountOnStock = productReader.GetInt32(productReader.GetOrdinal("amountOnStock"));
product.BrandId = productReader.GetInt32(productReader.GetOrdinal("brandId"));
product.CategoryId = productReader.GetInt32(productReader.GetOrdinal("categoryId"));
product.rowId = (byte[])productReader["rowId"];
}
return(product);
}
}
}
private void Page_Loaded(object sender, RoutedEventArgs e)
{
serviceProduct = new ServiceProduct();
productsToRestock = new ObservableCollection <Product>(serviceProduct.AllToRestock());
ListViewProductsToRestock.ItemsSource = productsToRestock;
}
public string AddProduct(string token, string data)
{
AddProductResult result = new AddProductResult();
try
{
if (!_controlService.ValidateManagementToken(token))
{
result.WasOperationSuccessful = false;
return(_controlService.EncryptSymmetricResponse(_serializationProvider.Serialize(result)));
}
result.WasRequestValid = true;
ServiceProduct product = _controlService.DeserializeAndDencryptMgmtInboundData <ServiceProduct>(data);
_productManagementService.SaveServiceProduct(product);
result.WasOperationSuccessful = true;
}
catch (Exception ex)
{
result.WasException = true;
result.ExceptionMessage = ex.ToString();
}
return(_controlService.SerializeAndEncryptMgmtOutboundData(result));
}
public ViewResult PostMethodName()
{
ServiceProduct ServiceProducts = new ServiceProduct();
var products = ServiceProducts.getProducts();
return(View(products));
}
public bool AddProductToService(License license, List <LicenseSet> licenseSets, Service service)
{
ServiceProduct sp = new ServiceProduct();
sp.LicenseId = license.LicenseId;
sp.LicenseName = license.Name;
sp.LicenseSets = new List <ServiceLicenseSet>();
foreach (var ls in licenseSets)
{
ServiceLicenseSet set = new ServiceLicenseSet();
set.LicenseId = license.LicenseId;
set.LicenseSetId = ls.LicenseSetId;
set.LicenseSetName = ls.Name;
set.LicenseType = ls.SupportedLicenseTypes;
set.MaxUsers = ls.MaxUsers;
sp.LicenseSets.Add(set);
}
string mgmtToken = _packingService.PackToken(service.GetManagementToken());
AddProductResult result = _productsProvider.AddProduct(service.ManagementUrl, mgmtToken,
GetManagementStandardEncryptionInfo(service),
service.GetManagementServiceKeyPair(), sp);
if (IsResultValid(result))
{
return(true);
}
return(false);
}
public void InsertProduct(ServiceProduct product)
{
using (ProductLineServiceClient productProxy = new ProductLineServiceClient())
{
productProxy.InsertProduct(product);
}
}
public IEnumerable <ServiceProduct> GetAllProducts()
{
List <ServiceProduct> products = new List <ServiceProduct>();
using (SqlConnection connection = new SqlConnection(_connectionString))
{
connection.Open();
using (SqlCommand cmdGetAllProducts = connection.CreateCommand())
{
cmdGetAllProducts.CommandText = "SELECT productId, name, price, description, amountOnStock, brandId, categoryId, rowId FROM Product";
SqlDataReader productsReader = cmdGetAllProducts.ExecuteReader();
while (productsReader.Read())
{
ServiceProduct product = new ServiceProduct();
product.Name = productsReader.GetString(productsReader.GetOrdinal("name"));
product.Description = productsReader.GetString(productsReader.GetOrdinal("description"));
product.Price = productsReader.GetDecimal(productsReader.GetOrdinal("price"));
product.ProductId = productsReader.GetInt32(productsReader.GetOrdinal("productId"));
product.AmountOnStock = productsReader.GetInt32(productsReader.GetOrdinal("amountOnStock"));
product.BrandId = productsReader.GetInt32(productsReader.GetOrdinal("brandId"));
product.CategoryId = productsReader.GetInt32(productsReader.GetOrdinal("categoryId"));
product.rowId = (byte[])productsReader["rowId"];
products.Add(product);
}
}
}
return(products);
}
//Editing service product
public CreateProduct(ServiceProduct prod, StorageController storageController, bool adminEdit, bool deactivated = false)
{
Initialize(storageController);
UpdateServiceProductSec = true;
output_ProductID.Text = Product.GetNextID().ToString();
output_ServiceProductID.Text = prod.ID.ToString();
UpdateProductID = prod.ID;
FillBoxesWithExistingServiceProduct(prod);
tabControl.SelectedIndex = 1;
tabControl.Items.RemoveAt(0);
if (prod.Image != null)
{
image_ServiceProduct.Source = prod.Image.Source;
}
_isAdmin = adminEdit;
HideIfNotAdmin();
this.Title = "Rediger Service Produkt";
if (deactivated)
{
_deactivatedProd = true;
btn_disableServiceProduct.Click -= btn_disableServiceProduct_Click;
btn_disableServiceProduct.Click += btn_EnableServiceProduct_click;
btn_disableServiceProduct.Content = "Aktiver produkt";
}
}
public void UpdateProduct(ServiceProduct product)
{
using (ProductLineServiceClient productProxy = new ProductLineServiceClient())
{
productProxy.UpdateProduct(product);
}
}
public void TestInsertProduct()
{
//Arrange
DataProduct dataProduct = new DataProduct();
ServiceProduct product = new ServiceProduct();
product.Name = "Grafikkort";
product.Price = 1998;
product.Description = "For at få den bedste spiloplevelse er det vigtigt med et godt grafikkort";
product.AmountOnStock = 20;
bool check = false;
//Act
try
{
dataProduct.InsertProduct(product);
check = true;
}
catch
{
check = false;
}
//Assert
Assert.IsTrue(check);
}
/*Returning Json */
/*when you use Get method, it generates a error like below*/
public JsonResult GetJsonError()
{
ServiceProduct serviceProduct = new ServiceProduct();
var Products = serviceProduct.getProducts();
return(Json(Products));
}
public ActionResult Index()
{
ServiceProduct service = new ServiceProduct();
CompanyProduct model = service.GetProductById(3);
return(View(model));
}
public IActionResult Buy(string id)
{
ServiceProduct serviceProduct = new ServiceProduct();
if (SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart") == null)
{
List <Item> cart = new List <Item>();
cart.Add(new Item {
Product = serviceProduct.FindProduct(id), Quantity = 1
});
SessionHelper.setObjectAsJson(HttpContext.Session, "cart", cart);
}
else
{
List <Item> cart = SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "cart");
int index = isExist(id);
if (index != -1)
{
cart[index].Quantity++;
}
else
{
cart.Add(new Item {
Product = serviceProduct.FindProduct(id), Quantity = 1
});
}
SessionHelper.setObjectAsJson(HttpContext.Session, "cart", cart);
}
return(RedirectToAction("Index"));
}
public ServiceProduct CreateTestProduct(string licenseKey)
{
DeleteTestServiceProduct();
ServiceProduct prod = new ServiceProduct();
prod.LicenseId = int.MaxValue;
prod.LicenseName = "Test Product License";
prod.LicenseSets = new List <ServiceLicenseSet>();
ServiceLicenseSet ls = new ServiceLicenseSet();
ls.LicenseSetId = int.MaxValue;
ls.LicenseId = int.MaxValue;
ls.Keys = new List <ServiceLicenseKey>();
ls.LicenseSetName = "Test Product License Set";
ls.LicenseType = LicenseKeyTypeFlag.MultiUser;
ls.MaxUsers = 2;
ServiceLicenseKey key = new ServiceLicenseKey();
key.CreatedOn = DateTime.Now;
key.Key = _hashingProvider.ComputeHash(licenseKey, "SHA256");
key.LicenseSetId = int.MaxValue;
key.ActivationCount = 0;
ls.Keys.Add(key);
prod.LicenseSets.Add(ls);
_serviceProductsRepository.SaveServiceProduct(prod);
return(_serviceProductsRepository.GetProduct(int.MaxValue));
}
public bool FinishCheckout(ServiceCustomerOrder order)
{
bool success = false;
using (SqlConnection connection = new SqlConnection(_connectionString))
{
connection.Open();
try
{
using (TransactionScope scope = new TransactionScope())
{
int orderID = InsertOrder(order);
order.OrderId = orderID;
if (order.DiscountCode != null)
{
InsertDiscountOrder(orderID, order.DiscountCode);
}
decimal totalPrice = -1;
foreach (var item in order.ShoppingCart)
{
item.OrderId = orderID;
totalPrice += item.SubTotal;
dataProductLine.InsertProductLine(item);
for (int i = 0; i < 5; i++)
{
ServiceProduct productFromDB = dataProduct.GetProductById(item.Product.ProductId);
int remainingAmountOnStock = productFromDB.AmountOnStock - item.Amount;
if (remainingAmountOnStock < 0)
{
throw new TransactionAbortedException();
}
else
{
productFromDB.AmountOnStock = remainingAmountOnStock;
int affectedRows = dataProduct.UpdateProduct(productFromDB);
if (affectedRows != 0)
{
break;
}
}
}
}
order.FinalPrice = totalPrice;
UpdateOrder(order);
scope.Complete();
success = true;
}
}
catch (TransactionAbortedException ex)
{
success = false;
}
}
return(success);
}
public ViewResult Display()
{
ServiceProduct ServiceProducts = new ServiceProduct();
var product = ServiceProducts.getProduct();
ViewBag.Properties = product;
return(View());
}
/* Normally you have to get the json information with Post method*/
/* but if you want to get with Get method you have to allow*/
public JsonResult GetJson()
{
ServiceProduct serviceProduct = new ServiceProduct();
var Products = serviceProduct.getProducts();
return(Json(Products, JsonRequestBehavior.AllowGet /*Get Method Allowed*/));
}
public ViewResult Products()
{
ServiceProduct serviceProduct = new ServiceProduct();
ViewBag.Products = serviceProduct.getProducts();
return(View(serviceProduct.getProduct()));
}
public ViewResult Products(Practice08.Models.Product Product)
{
ServiceProduct serviceProduct = new ServiceProduct();
ViewBag.Products = serviceProduct.getProducts();
return(View(serviceProduct.getProduct()));
}
public ViewResult PostMethodName(string Name)
{
ServiceProduct ServiceProducts = new ServiceProduct();
var products = ServiceProducts.getProducts();
ViewBag.Name = Name;
return(View(products));
}
private void AddServiceProduct()
{
_storageController.CreateServiceProduct(ServiceProduct.GetNextID(),
Decimal.Parse(textbox_ServiceSalePrice.Text),
Decimal.Parse(textbox_ServiceGroupPrice.Text),
Int32.Parse(textbox_ServiceGroupLimit.Text),
textbox_ServiceName.Text,
_storageController.GroupDictionary.First(X => X.Value.Name == comboBox_ServiceGroup.Text).Key);
}
//Creating new product
public CreateProduct(StorageController storageController)
{
Initialize(storageController);
output_ProductID.Text = Product.GetNextID().ToString();
output_ServiceProductID.Text = ServiceProduct.GetNextID().ToString();
btn_disableProduct.Visibility = Visibility.Hidden;
btn_disableServiceProduct.Visibility = Visibility.Hidden;
this.Title = "Opret Produkt";
}
public IResult AddwithCustomer(ServiceProduct serviceProduct, Customer customer)
{
var result = _customerService.AddOutId(customer);
serviceProduct.CustomerId = result.Data.Id;
serviceProduct.SpecialCode = UniqCodeHelper.GenereteUniq();
_serviceProduct.Add(serviceProduct);
return(new SuccessResult());
}
public ActionResult Index(CompanyProduct product, FormCollection form)
{
if (Session["ShoppingCart"] == null)
{
ShoppingCart = new List <SalesLineItem>();
Session["ShoppingCart"] = ShoppingCart;
}
// add productversions to product
ServiceProduct service = new ServiceProduct();
product = service.GetProductById(product.StyleNumber);
var selectedColor = form.Get("colors");
var selectedSize = form.Get("sizes");
int selectedAmount = Int32.Parse(form.Get("amount"));
CompanyProductVersion prodVer = product.GetProductVersion(selectedSize, selectedColor);
ConvertDataModel converter = new ConvertDataModel();
if (prodVer != null)
{
SalesLineItem lineitem = new SalesLineItem()
{
amount = selectedAmount,
Product = converter.ConvertFromCompanyProduct(product),
ProductVersion = converter.ConvertFromCompanyProductVersion(prodVer),
Price = (selectedAmount * product.Price)
};
ShoppingCart = (List <SalesLineItem>)Session["ShoppingCart"];
// check if item is already in cart
if (ItemAlreadyExists(lineitem))
{
foreach (var item in ShoppingCart)
{
if (item.Product.StyleNumber == lineitem.Product.StyleNumber && item.ProductVersion.SizeCode.Equals(lineitem.ProductVersion.SizeCode) && item.ProductVersion.ColorCode.Equals(lineitem.ProductVersion.ColorCode))
{
item.amount += lineitem.amount;
}
}
}
else
{
ShoppingCart.Add(lineitem);
}
}
else
{
return(RedirectToAction("NotInStock", "Product", new { id = product.StyleNumber }));
}
Session["ShoppingCart"] = ShoppingCart;
return(RedirectToAction("index", "Cart"));
}
public void CreateServiceProductTest1()
{
int old_id = ServiceProduct.GetNextID();
ServiceProduct TestProd = new ServiceProduct(0, 20m, 20m, 20, "TestServiceProd", 1);
TestProd.UploadToDatabase();
int new_id = ServiceProduct.GetNextID();
Assert.IsTrue(new_id > old_id);
}
public void GetServiceProductNextIDTest()
{
int old_id = ServiceProduct.GetNextID();
Product TestProd = new Product(11);
TestProd.UploadToDatabase();
int new_id = ServiceProduct.GetNextID();
Assert.IsTrue(new_id > old_id);
}
internal static GenericTypeDto? vidalToDto(ServiceProduct.GenericType? wsGenericType)
{
switch (wsGenericType)
{
case ServiceProduct.GenericType.GENERIC: return GenericTypeDto.GENERIC;
case ServiceProduct.GenericType.NULL: return GenericTypeDto.NULL;
case ServiceProduct.GenericType.REFERENT: return GenericTypeDto.REFERENT;
}
return null;
}
internal static VigilanceDto? vidalToDto(ServiceProduct.Vigilance? wsVigilance)
{
switch (wsVigilance)
{
case ServiceProduct.Vigilance.UNSPECIFIED: return VigilanceDto.UNSPECIFIED;
case ServiceProduct.Vigilance.VIGILANCE_0: return VigilanceDto.VIGILANCE_0;
case ServiceProduct.Vigilance.VIGILANCE_1: return VigilanceDto.VIGILANCE_1;
case ServiceProduct.Vigilance.VIGILANCE_2: return VigilanceDto.VIGILANCE_2;
case ServiceProduct.Vigilance.VIGILANCE_3: return VigilanceDto.VIGILANCE_3;
case ServiceProduct.Vigilance.VIGILANCE_5: return VigilanceDto.VIGILANCE_5;
}
return null;
}
public static void Insert(ServiceProduct.product sp)
{
sProduct.AddProduct(sp);
}
public static void Update(ServiceProduct.product sp)
{
sProduct.UpdateProduct(sp);
}
private static Product ConvertProduct(ServiceProduct.product myProduct)
{
Product p = new Product();
p.id = myProduct.id;
p.id_manufacturer = myProduct.id_manufacturer;
p.id_save = myProduct.id_save;
p.manufacturer = sManu.GetManufacturerById(myProduct.id_manufacturer).name;
var s = sSave.GetSaveWithId(myProduct.id_save);
p.save = s.percent_save;
p.name_save = s.name;
p.name = myProduct.name;
p.product_info = myProduct.product_info;
p.sale_price = myProduct.sale_price;
p.number = myProduct.number;
p.image = myProduct.image;
return p;
}
internal static ProductDto vidalToDto(ServiceProduct.product wsProduct)
{
ProductDto dto = new ProductDto();
dto.Id = wsProduct.id;
dto.Cis = wsProduct.cis;
dto.CommonNameGroupId = wsProduct.commonNameGroupId;
dto.DrugInSport = wsProduct.drugInSport;
dto.Exceptional = wsProduct.exceptional;
dto.Flavor = wsProduct.flavor;
dto.ListValue = wsProduct.listValue;
dto.MaxUcdRangePrice = wsProduct.maxUcdRangePrice;
dto.Midwife = wsProduct.midwife;
dto.MinUcdRangePrice = wsProduct.minUcdRangePrice;
dto.Name = wsProduct.name;
dto.PerVolume = wsProduct.perVolume;
dto.PerVolumeUnit = wsProduct.perVolumeUnit;
dto.RefundingRateValue = wsProduct.refundingRateValue;
dto.SafetyAlert = wsProduct.safetyAlert;
dto.Vigilance = VigilanceDtoHelper.vidalToDto(wsProduct.vigilance);
dto.GenericType = GenericTypeDtoHelper.vidalToDto(wsProduct.genericType);
return dto;
}
internal static List<ProductDto> vidalToDtoList(ServiceProduct.ArrayOfProduct wsProducts)
{
List<ProductDto> products = new List<ProductDto>();
foreach (ServiceProduct.product product in wsProducts)
{
products.Add(vidalToDto(product));
}
return products;
}
