public ActionResult GetProduct(int id, string format = "json", string instanceId = null)
{
var locator = new ProductLocator()
{
QueryFormat = format, InstanceId = instanceId
};
ApplyOptions(locator);
var data = DpcService.GetProductData(locator, id);
if (data == null)
{
_logger.Error()
.Message("Product {productId} is not found", id)
.Property("locator", locator)
.Write();
return(BadRequest($"Product {id} is not found"));
}
ControllerContext.HttpContext.Response.Headers.Add("Last-Modified", data.Updated.ToUniversalTime().ToString("R"));
return((locator.Format == "json")
? Content(data.Product, JsonHeader)
: Content(data.Product, XmlHeader));
}
public ActionResult GetProductIds(
DateTime?filterDate = null,
string format = "json",
string instanceId = null,
int page = 0,
int pageSize = Int32.MaxValue
)
{
var locator = new ProductLocator()
{
QueryFormat = format, InstanceId = instanceId
};
ApplyOptions(locator);
var ints = (filterDate == null)
? DpcService.GetAllProductId(locator, page, pageSize)
: DpcService.GetLastProductId(locator, page, pageSize, filterDate.Value);
if (locator.Format == "json")
{
return(Json(ints));
}
var ints2 = String.Join("", ints.Select(n => $"<id>{n}</id>").ToList());
return(Content($"<ids>{ints2}</ids>", XmlHeader));
}
public ActionResult GetProductVersion(int id, DateTime filterDate, string format = "json", string instanceId = null)
{
var locator = new ProductLocator()
{
QueryFormat = format, InstanceId = instanceId
};
ApplyOptions(locator);
var data = DpcService.GetProductVersionData(locator, id, filterDate);
if (data == null)
{
_logger.Error()
.Message("Product version {versionId} is not found", id)
.Property("locator", locator)
.Write();
return(BadRequest($"Product version {id} is not found"));
}
return((locator.Format == "json")
? Content(data.Product, JsonHeader)
: Content(data.Product, XmlHeader));
}
public ActionResult DeleteProduct([FromBody] string data, string format = "json", string instanceId = null)
{
var locator = new ProductLocator()
{
QueryFormat = format, InstanceId = instanceId
};
ApplyOptions(locator);
if (!ValidateInstanceInternal(locator.InstanceId, Options.InstanceId))
{
return(InstanceError(locator.InstanceId, Options.InstanceId));
}
// ReSharper disable once InconsistentlySynchronizedField
var res1 = ProductService.Parse(locator, data);
if (res1.IsSucceeded && res1.Result?.Products != null)
{
_logger.Info("Message parsed, deleting products... ");
try
{
foreach (var p in res1.Result.Products)
{
_logger.Info()
.Message("Deleting product {productId}...", p.Id)
.Property("locator", locator)
.Write();
var res2 = ProductService.DeleteProduct(locator, p.Id, data);
if (!res2.IsSucceeded)
{
throw new ProductException(
"Error while deleting product", res2.Error.Message, p.Id, locator
);
}
_logger.Info()
.Message("Product {productId} successfully deleted", p.Id)
.Property("locator", locator)
.Write();
}
}
catch (ProductException pex)
{
return(ProcessProductException(pex));
}
catch (Exception e)
{
_logger.Error().Exception(e).Write();
return(BadRequest(e.Message));
}
return(Ok());
}
return(ProceedParseError(data, res1));
}
public void FillProduct(ProductLocator locator, Product product)
{
product.Format = locator.Format;
product.IsLive = locator.IsLive;
product.Language = locator.Language;
product.Slug = !string.IsNullOrEmpty(locator.Slug) ? locator.Slug : null;
product.Version = locator.Version;
}
public bool ValidateInstance(string format = "json", string instanceId = null)
{
var locator = new ProductLocator()
{
QueryFormat = format, InstanceId = instanceId
};
ApplyOptions(locator);
return(ValidateInstanceInternal(locator.InstanceId, Options.InstanceId));
}
public Product GetProduct(ProductLocator locator, int id)
{
var p = GetProducts(locator).FirstOrDefault(m => id == m.DpcId);
if (p != null)
{
p.ProductRegions = GetProductRegions(p).ToList();
}
return(p);
}
public IQueryable <Product> GetProducts(ProductLocator locator)
{
var products = Products.Where(m =>
m.IsLive == locator.IsLive &&
m.Language == locator.Language &&
m.Format == locator.Format &&
m.Version == locator.Version
);
return((string.IsNullOrEmpty(locator.Slug))
? products.Where(m => String.IsNullOrEmpty(m.Slug))
: products.Where(m => m.Slug == locator.Slug));
}
public static void Initialize(TestContext context)
{
var config = new TestConfig
{
ResetHttpContext = true
};
var ProductLocator = new BaseIntegrationTest <ProductLocator, ProductLocatorResponse>(config);
var ProductLocatorRequest = RequestBuilder.GetProductLocatorRequest();
_result = (Response <ProductLocatorResponse>)ProductLocator.TestObject.Execute(ProductLocatorRequest);
_testObject = ProductLocator.TestObject;
}
public IQueryable <ProductVersion> GetProductVersions(ProductLocator locator, DateTime date)
{
var productVersions = ProductVersions.Where(m =>
m.IsLive == locator.IsLive &&
m.Language == locator.Language &&
m.Format == locator.Format &&
m.Version == locator.Version &&
m.Modification <= date
);
return((string.IsNullOrEmpty(locator.Slug))
? productVersions.Where(m => String.IsNullOrEmpty(m.Slug))
: productVersions.Where(m => m.Slug == locator.Slug));
}
public ProductVersion GetProductVersion(ProductLocator locator, int id, DateTime date)
{
var productVersion = GetProductVersions(locator, date).OrderByDescending(m => m.Id).FirstOrDefault(m => id == m.DpcId);
if (productVersion == null)
{
return(null);
}
if (productVersion.Deleted)
{
return(null);
}
else
{
return(productVersion);
}
}
private void ApplyOptions(ProductLocator locator)
{
locator.UseProductVersions = Options.UseProductVersions;
var language = ControllerContext.RouteData.Values["language"];
var state = ControllerContext.RouteData.Values["state"];
string customerCode = ControllerContext.RouteData.Values.ContainsKey("customerCode")
? ControllerContext.RouteData.Values["customerCode"].ToString()
: HttpContext.Request.Query["customerCode"].FirstOrDefault();
locator.HeaderFormat = GetHeaderFormat(HttpContext.Request.ContentType);
if (state != null)
{
locator.State = state.ToString();
}
if (language != null)
{
locator.Language = language.ToString();
}
var fixedConnectionString = Options.FixedConnectionString;
if (String.IsNullOrEmpty(fixedConnectionString))
{
if (customerCode != null && customerCode != SingleCustomerCoreProvider.Key)
{
locator.CustomerCode = customerCode;
fixedConnectionString = DBConnector.GetConnectionString(customerCode);
}
}
if (String.IsNullOrEmpty(fixedConnectionString))
{
throw new Exception("Customer code or connection string is not defined");
}
}
public ActionResult PutProduct([FromBody] string data,
[FromQuery(Name = "UserId")] int userId, [FromQuery(Name = "UserName")] string userName,
string format = "json", string instanceId = null
)
{
var locator = new ProductLocator {
QueryFormat = format, InstanceId = instanceId
};
if (!ValidateInstanceInternal(locator.InstanceId, Options.InstanceId))
{
return(InstanceError(locator.InstanceId, Options.InstanceId));
}
ApplyOptions(locator);
// ReSharper disable once InconsistentlySynchronizedField
var res1 = ProductService.Parse(locator, data);
if (res1.IsSucceeded && res1.Result?.Products?.Any() == true)
{
_logger.Info("Message parsed, creating or updating products... ");
try
{
foreach (var p in res1.Result.Products)
{
_logger.Info()
.Message("Check for creating or updating product {productId}", p.Id)
.Property("locator", locator)
.Write();
// ReSharper disable once InconsistentlySynchronizedField
var res2 = ProductService.HasProductChanged(locator, p.Id, data);
if (!res2.IsSucceeded)
{
throw new ProductException(
"Error while checking product", res2.Error.Message, p.Id, locator
);
}
if (!res2.Result)
{
_logger.Info()
.Message("Product {productId} doesn't require updating", p.Id)
.Property("locator", locator)
.Write();
}
else
{
_logger.Info()
.Message("Creating or updating product {productId}", p.Id)
.Property("locator", locator)
.Write();
var res3 = ProductService.UpdateProduct(locator, p, data, userName, userId);
if (!res3.IsSucceeded)
{
throw new ProductException(
"Error while creating/updating product", res3.Error.Message, p.Id, locator
);
}
_logger.Info()
.Message("Product {productId} successfully created/updated", p.Id)
.Property("locator", locator)
.Write();
}
}
}
catch (ProductException pex)
{
return(ProcessProductException(pex));
}
catch (Exception e)
{
_logger.Error().Exception(e).Write();
return(BadRequest(e.Message));
}
return(Ok());
}
return(ProceedParseError(data, res1));
}
public ProductException(string message, string result, int productId, ProductLocator locator) : base(message)
{
ProductId = productId;
Result = result;
Locator = locator;
}
