public static ProductVersionDto ToDto(this ProductVersion version)
{
version.Lines?.ForEach(v => v.VersionId = version.Id);
var dto = new ProductVersionDto
{
SuiteId = version.SuiteId,
UniqueId = version.UniqueId,
StartDate = version.StartDate,
EndDate = version.EndDate,
SalesChannels = version.SalesChannels,
MinAgeOfOldesPersion = version.MinAgeOfOldesPersion,
IsApproved = version.IsApproved,
IsDelete = version.IsDelete,
StateCoverge = version.StateCoverge,
Scale = version.Scale,
ScaleQuoteMap = version.ScaleQuoteMap,
CoPayment = version.CoPayment,
AccidentWaiver = version.AccidentWaiver,
DaySurgeryWaiver = version.DaySurgeryWaiver,
ChildrenWaiver = version.ChildrenWaiver,
Description = version.Description,
StaffSubsidy = version.StaffSubsidy,
PerEpisodic = version.PerEpisodic,
ProductLines = version.Lines?.Select(v => v.ToDto()).ToList()
};
((IData)version).ToDto((IDataDto)dto);
return(dto);
}
public void ProductVersionDtoProperlyReversedToProductVersion()
{
ProductVersionDto pDto1 = new ProductVersionDto
{
Id = 1,
Product = "Great Product",
Release = "V1",
EndOfSupport = DateTime.Today
};
ProductVersion p1 = new ProductVersion
{
Id = 1,
Product = new Product
{
FullName = "Great Product"
},
Release = "V1",
EndOfSupport = DateTime.Today
};
ProductVersion p2 = _mapper.Map <ProductVersion>(pDto1);
Assert.NotNull(p2);
Assert.True(p1.Equals(p2));
Assert.True(p1.Equals(p2, true));
}
public static bool DialogShow(VersionNumber currentVersion, ProductVersionDto latestProductVersion, bool skipNewVersion)
{
using (var form = new FormProductUpdate())
{
form.Initialize(currentVersion, latestProductVersion, skipNewVersion);
form.ShowDialog();
return(form.chDoNotShow.Checked);// && isOk;
}
}
private ProductVersionDto[] GetProductVersionDtoArray()
{
ProductVersionDto[] ProductVersionDtoArray = new ProductVersionDto[10];
for (int i = 0; i < 10; i++)
{
ProductVersionDtoArray[i] = GetTestProductVersionDto(i + 11);
}
return(ProductVersionDtoArray);
}
public async void PostProductVersionModelStateErrorReturnsBadRequest()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new ProductsController(context, _mapper))
{
controller.ModelState.AddModelError("an error", "some error");
ProductVersionDto p11 = GetTestProductVersionDto(11);
var result = await controller.PostProductVersion(1, p11);
Assert.IsType <BadRequestObjectResult>(result);
}
}
public async void PostProductVersionCorrectDataCreatesProductVersion()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new ProductsController(context, _mapper))
{
ProductVersionDto p11 = GetTestProductVersionDto(11, 9);
var result = await controller.PostProductVersion(1, p11);
Assert.NotNull(result);
var resultValue = Assert.IsType <CreatedAtActionResult>(result);
}
}
private void GetLatestVersion(HttpContext context, string currentversion, bool isDebug)
{
context.Response.ContentType = "text/plain";
string result = string.Empty;
if (string.IsNullOrEmpty(currentversion))
{
result = isDebug ? "Unknown current version" : string.Empty;
}
else
{
string localFile = context.Server.MapPath("~/Versions/doemd-versions.xml");
if (File.Exists(localFile))
{
try
{
VersionNumber currentVersionNumber = new VersionNumber(currentversion);
ProductVersionsDto allProductVersions = GetAllProductVersions(localFile);
ProductVersionDto foundProductVersion =
(from productVersion in allProductVersions
let versionNumber = new VersionNumber(productVersion.Version)
where versionNumber.CompareTo(currentVersionNumber) == 1
orderby versionNumber descending
select productVersion).FirstOrDefault();
if (foundProductVersion == null)
{
result = isDebug ? "Current version is actual latest version." : string.Empty;
}
else
{
result = foundProductVersion.ToXml();
context.Response.ContentType = "text/xml";
}
}
catch (Exception e)
{
result = isDebug ? string.Format("Error: {0}", e.Message) : string.Empty;
}
}
else
{
result = isDebug ? "Error processing request #003" : string.Empty;
}
}
context.Response.Write(result);
}
public async void DeleteProductVersionIdDeletesProductVersion()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new ProductsController(context, _mapper))
{
var result = await controller.DeleteProductVersion(1, 3);
ProductVersionDto p3 = GetTestProductVersionDto(3);
Assert.NotNull(result);
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var resultValue = okObjectResult.Value;
Assert.Equal(p3, resultValue);
}
}
public static FullProductDto ToCombinedProduct(this ProductVersionDto version, ProductDto product)
{
FullProductDto newProduct = new FullProductDto();
newProduct.ProductVersionId = version.Id;
newProduct.Cost = version.Cost;
newProduct.ProductVersionCreated = version.Created;
newProduct.Description = version.Description;
newProduct.IsInStore = product.IsInStore;
newProduct.ProductCreated = product.Created;
newProduct.Name = version.Name;
newProduct.UrlImg = version.UrlImg;
newProduct.IsOrderable = product.IsOrderable;
newProduct.Quantity = product.Quantity;
newProduct.SoftDelete = version.SoftDelete;
newProduct.ProductId = version.ProductId;
return(newProduct);
}
public async void GetProductVersionByIdReturnsSingleProductVersion()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new ProductsController(context, _mapper))
{
var result = await controller.GetProductVersion(1, 3);
var okObjectResult = Assert.IsType <OkObjectResult>(result);
var resultValue = okObjectResult.Value;
ProductVersionDto p3 = GetTestProductVersionDto(3);
Assert.NotNull(resultValue);
Assert.IsType <ProductVersionDto>(resultValue);
ProductVersionDto p = (ProductVersionDto)resultValue;
Assert.True(p.Equals(p3));
Assert.True(p.Equals(p3, true));
}
}
public async void GetProductVersionsReturnsListOfAuthors()
{
using (var context = DbTestContext.GenerateContextWithData())
using (var controller = new ProductsController(context, _mapper))
{
var result = await controller.GetProductVersions(1);
ProductVersionDto p3 = GetTestProductVersionDto(3);
Assert.NotNull(result);
var okObjectResult = Assert.IsType <OkObjectResult>(result);
Assert.IsAssignableFrom <IEnumerable <ProductVersionDto> >(okObjectResult.Value);
IEnumerable <ProductVersionDto> resultValue = (IEnumerable <ProductVersionDto>)okObjectResult.Value;
Assert.Equal(10, resultValue.Count());
ProductVersionDto p = (ProductVersionDto)resultValue.Where(r => r.Id == 3).FirstOrDefault();
Assert.True(p.Equals(p3));
Assert.True(p.Equals(p3, true));
}
}
public void Post()
{
try
{
using (var server = TestServer.Create <MyStartup>())
{
var dto = new ProductVersionDto
{
Id = 0,
SuiteId = 3,
StartDate = DateTime.Now,
EndDate = DateTime.Now.AddYears(1)
};
HttpResponseMessage response;
response = server.HttpClient.PostAsJsonAsync("api/ProductVersion", dto).Result;
}
}
catch (Exception ex)
{
}
}
public void ProductVersionDtoEqualsReturnsCorrectValues()
{
ProductVersionDto p1 = new ProductVersionDto
{
Id = 1,
Product = "Great Product",
Release = "V1",
EndOfSupport = DateTime.Today
};
ProductVersionDto p2 = new ProductVersionDto
{
Id = 1,
Product = "Great Product",
Release = "V1",
EndOfSupport = DateTime.Today
};
ProductVersionDto p3 = new ProductVersionDto
{
Id = 3,
Product = "Great Product",
Release = "V1",
EndOfSupport = DateTime.Today
};
ProductVersionDto p4 = new ProductVersionDto
{
Id = 1,
Product = "Great Product",
Release = "V2",
EndOfSupport = DateTime.Today
};
Assert.True(p1.Equals(p2));
Assert.True(p1.Equals(p2, true));
Assert.False(p1.Equals(p3));
Assert.False(p1.Equals(p3, true));
Assert.True(p1.Equals(p4));
Assert.False(p1.Equals(p4, true));
}
public static ProductVersion ToDomain(this ProductVersionDto version, ProductVersion originalVersion = null)
{
version.ProductLines?.ForEach(v => v.VersionId = version.Id);
if (originalVersion != null && originalVersion.UniqueId == version.UniqueId)
{
originalVersion.SuiteId = version.SuiteId;
originalVersion.StartDate = version.StartDate;
originalVersion.EndDate = version.EndDate;
originalVersion.SalesChannels = version.SalesChannels;
originalVersion.MinAgeOfOldesPersion = version.MinAgeOfOldesPersion;
originalVersion.IsApproved = version.IsApproved;
originalVersion.IsDelete = version.IsDelete;
originalVersion.StateCoverge = version.StateCoverge;
originalVersion.Scale = version.Scale;
originalVersion.ScaleQuoteMap = version.ScaleQuoteMap;
originalVersion.CoPayment = version.CoPayment;
originalVersion.AccidentWaiver = version.AccidentWaiver;
originalVersion.DaySurgeryWaiver = version.DaySurgeryWaiver;
originalVersion.ChildrenWaiver = version.ChildrenWaiver;
originalVersion.Description = version.Description;
originalVersion.StaffSubsidy = version.StaffSubsidy;
originalVersion.PerEpisodic = version.PerEpisodic;
foreach (var line in version.ProductLines ?? Enumerable.Empty <ProductLineDto>())
{
var original = originalVersion.Lines.SingleOrDefault(l => l.UniqueId == line.UniqueId);
if (original != null)
{
var updatedOriginal = line.ToDomain(original);
var index = originalVersion.Lines.IndexOf(original);
originalVersion.Lines[index] = updatedOriginal;
}
else
{
var Domainlayout = line.ToDomain();
originalVersion.Lines.Add(Domainlayout);
}
}
((IDataDto)version).ToDomain((IData)originalVersion);
return(originalVersion);
}
var data = new ProductVersion
{
SuiteId = version.SuiteId,
UniqueId = version.UniqueId,
StartDate = version.StartDate,
EndDate = version.EndDate,
SalesChannels = version.SalesChannels,
MinAgeOfOldesPersion = version.MinAgeOfOldesPersion,
IsApproved = version.IsApproved,
IsDelete = version.IsDelete,
StateCoverge = version.StateCoverge,
Scale = version.Scale,
ScaleQuoteMap = version.ScaleQuoteMap,
CoPayment = version.CoPayment,
AccidentWaiver = version.AccidentWaiver,
DaySurgeryWaiver = version.DaySurgeryWaiver,
ChildrenWaiver = version.ChildrenWaiver,
Description = version.Description,
StaffSubsidy = version.StaffSubsidy,
PerEpisodic = version.PerEpisodic,
Lines = version.ProductLines?.Select(v => v.ToDomain()).ToList(),
};
((IDataDto)version).ToDomain((IData)data);
return(data);
}
public async Task <IActionResult> PostProductVersion([FromRoute] int productId, [FromBody] ProductVersionDto productVersion)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (!ProductExists(productId))
{
ModelState.AddModelError("Invalid Product", "The product does not exist.");
return(BadRequest(ModelState));
}
Product product = _context.Products.SingleOrDefault(p => p.Id == productId);
var productVersionReversed = _mapper.Map <ProductVersion>(productVersion);
productVersionReversed.Product = product;
_context.ProductVersions.Add(productVersionReversed);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetProductVersion", new { productId = productId, versionId = productVersionReversed.Id }, _mapper.Map <ProductVersionDto>(productVersionReversed)));
}
public async Task <IActionResult> PutProductVersion([FromRoute] int productId, [FromRoute] int versionId, [FromBody] ProductVersionDto productVersion)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (versionId != productVersion.Id)
{
ModelState.AddModelError("Invalid Version ID", "The Version ID supplied in the query and the body of the request do not match.");
return(BadRequest(ModelState));
}
if (!ProductExists(productId))
{
ModelState.AddModelError("Invalid Product", "The product does not exist.");
return(BadRequest(ModelState));
}
var productVersionReversed = _mapper.Map <ProductVersion>(productVersion);
productVersionReversed.ProductId = productId;
_context.Entry(productVersionReversed).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException xcp)
{
if (!ProductVersionExists(versionId))
{
return(NotFound());
}
else
{
ModelState.AddModelError("Error", xcp.ToString());
return(BadRequest(ModelState));
}
}
return(NoContent());
}
private void Initialize(VersionNumber currentVersion, ProductVersionDto latestProductVersion, bool skipNewVersion)
{
this.currentVersion = currentVersion;
this.latestProductVersion = latestProductVersion;
this.chDoNotShow.Checked = skipNewVersion;
bool sameVersions = currentVersion.Equals(new VersionNumber(latestProductVersion.Version));
if (sameVersions)
{
htmlCurrentVersion.Text = string.Format(HTML_CURRENT_VERSION_NO_UPD_NEEDED, currentVersion);
htmlNewVersion.Text = string.Format(HTML_NEW_VERSION_SAME, latestProductVersion.Version);
htmlReleaseDate.Visible = false;
htmlChanges.Visible = false;
btnOk.Visible = false;
chDoNotShow.Visible = false;
}
else
{
htmlCurrentVersion.Text = string.Format(HTML_CURRENT_VERSION, currentVersion);
htmlNewVersion.Text = string.Format(HTML_NEW_VERSION, latestProductVersion.Version);
DateTimeOffset offset = new DateTimeOffset(latestProductVersion.Published, latestProductVersion.PublishedOffset);
htmlReleaseDate.Text = string.Format(HTML_RELEASE_DATE, offset);
StringBuilder changesHtml = new StringBuilder(HTML_CHANGES_HEADER);
var changes = latestProductVersion.Changes;
var changesFeatures = changes.Where(change => change.Type == ProductVersionChangeType.Feature).OrderBy(change => change.Order);
var changesIssues = changes.Where(change => change.Type == ProductVersionChangeType.Issue).OrderBy(change => change.Order);
var changesOthers = changes.Where(change => change.Type == ProductVersionChangeType.Other).OrderBy(change => change.Order);
if (changesFeatures.Any())
{
changesHtml.AppendFormat(HTML_CHANGES_CATEGORY, CHANGE_COLORS[ProductVersionChangeType.Feature],
"Features", changesFeatures.Count());
foreach (var change in changesFeatures)
{
changesHtml.AppendFormat(HTML_CHANGES_CHANGE_ROW, CHANGE_COLORS[change.Type], change.WorkItemId,
change.Title);
}
}
if (changesIssues.Any())
{
changesHtml.AppendFormat(HTML_CHANGES_CATEGORY, CHANGE_COLORS[ProductVersionChangeType.Issue],
"Issues", changesIssues.Count());
foreach (var change in changesIssues)
{
changesHtml.AppendFormat(HTML_CHANGES_CHANGE_ROW, CHANGE_COLORS[change.Type], change.WorkItemId,
change.Title);
}
}
if (changesOthers.Any())
{
changesHtml.AppendFormat(HTML_CHANGES_CATEGORY, CHANGE_COLORS[ProductVersionChangeType.Other],
"Other", changesOthers.Count());
foreach (var change in changesOthers)
{
changesHtml.AppendFormat(HTML_CHANGES_CHANGE_ROW, CHANGE_COLORS[change.Type], change.WorkItemId,
change.Title);
}
}
changesHtml.Append(HTML_CHANGES_FOOTER);
htmlChanges.Text = changesHtml.ToString();
}
}
