public StoreItemDto Update(StoreItemDto dto)
{
if (string.IsNullOrEmpty(dto.Name))
{
throw new ArgumentNullException("Name");
}
StoreItem storeItem = Db.StoreItems.FirstOrDefault(m => m.Id == dto.Id);
if (storeItem == null)
{
NotFoundException();
}
storeItem.Name = dto.Name;
storeItem.Description = dto.Description;
storeItem.Cost = dto.Cost;
storeItem.InStock = dto.InStock;
storeItem.IsDeleted = dto.IsDeleted;
storeItem.ModifiedDate = dto.ModifiedDate;
Db.SaveChanges();
return(Mapper.Map <StoreItemDto>(storeItem));
}
public async Task <ActionResult> Create(StoreItemDto storeItem, HttpPostedFileBase imageFile)
{
// Checks Name is not Null or Empty
if (string.IsNullOrEmpty(storeItem.Name))
{
ViewBag.ValidationName = "Name field is required.";
return(View(storeItem));
}
StoreItemDto newStoreItem = new StoreItemDto();
newStoreItem.Id = storeItem.Id;
newStoreItem.Name = storeItem.Name;
newStoreItem.Description = storeItem.Description;
newStoreItem.ModifiedDate = storeItem.ModifiedDate;
newStoreItem.InStock = storeItem.InStock;
newStoreItem.Cost = storeItem.Cost;
if (ModelState.IsValid)
{
var request = new HTTPrequest();
storeItem = await request.Post <StoreItemDto>("api/storeItem", storeItem);
return(RedirectToAction("Index", new { recentAction = "Created", recentName = storeItem.Name, recentId = storeItem.Id }));
}
else
{
var request = new HTTPrequest();
return(View());
}
}
public void TestCreate_ShouldSucceed()
{
//Set up dto
StoreItemDto storeItem = new StoreItemDto()
{
Name = "Test",
Description = "Test",
Cost = 9.99,
InStock = true
};
//Make test request
StoreItemDto storeItemResult = _controller.Create(storeItem);
//Assert Values
Assert.IsNotNull(storeItemResult);
Assert.IsNotNull(storeItemResult.Id);
Assert.IsTrue(storeItemResult.Id != 0);
Assert.AreEqual(storeItem.Name, storeItemResult.Name);
Assert.AreEqual(storeItem.Description, storeItemResult.Description);
Assert.AreEqual(storeItem.Cost, storeItemResult.Cost);
Assert.AreEqual(storeItem.InStock, storeItemResult.InStock);
Assert.IsNotNull(storeItemResult.CreatedDate);
Assert.IsNotNull(storeItemResult.ModifiedDate);
}
public async Task <ActionResult> Edit(StoreItemDto storeItem, HttpPostedFileBase imageFile)
{
// Checks Name is not Null or Empty
if (string.IsNullOrEmpty(storeItem.Name))
{
ViewBag.ValidationName = "Name field is required.";
return(View(storeItem));
}
var request = new HTTPrequest();
StoreItemDto storeItem_editted = await request.Get <StoreItemDto>("api/storeItem/" + storeItem.Id);
if (ModelState.IsValid)
{
storeItem_editted.Name = storeItem.Name;
storeItem_editted.Description = storeItem.Description;
storeItem_editted.ModifiedDate = storeItem.ModifiedDate;
storeItem_editted.InStock = storeItem.InStock;
storeItem_editted.Cost = storeItem.Cost;
storeItem_editted.ModifiedDate = DateTime.Now;
await request.Put <StoreItemDto>("api/storeItem", storeItem_editted);
return(RedirectToAction("Index", new { recentAction = "Editted", recentName = storeItem.Name, recentId = storeItem.Id }));
}
return(View(storeItem));
}
public Task <StoreItemDto> ReplaceAsync(StoreItemDto entity)
=> _storeContext.StoreItems.FindOneAndReplaceAsync <StoreItemDto>(
n => n.Key == entity.Key,
entity,
new FindOneAndReplaceOptions <StoreItemDto, StoreItemDto>
{
IsUpsert = true,
ReturnDocument = ReturnDocument.After
});
public static StoreItem FromDto(StoreItemDto dto)
{
return(new StoreItem
{
Id = dto.Id,
Name = dto.Name,
X = dto.X,
Y = dto.Y
});
}
public StoreItemDto Update([FromBody] StoreItemDto dto)
{
try
{
return(new StoreItemHandler(isTest).Update(dto));
}
catch (Exception ex)
{
throw;
}
}
public void TestGetById_ValidId()
{
//Get a valid storeItem
StoreItemDto validStoreItem = GetStoreItem();
//Try to get this storeItem
StoreItemDto storeItemResult = _controller.GetById(validStoreItem.Id);
Assert.IsNotNull(storeItemResult);
Assert.IsNotNull(storeItemResult.Id);
Assert.AreEqual(validStoreItem.Id, storeItemResult.Id);
}
public void TestUpdate_EmptyName()
{
//Get valid storeItem
StoreItemDto storeItem = GetStoreItem();
storeItem.Name = string.Empty;
storeItem.Description = "Test";
storeItem.Cost = 9.99;
storeItem.InStock = true;
_controller.Update(storeItem);
}
public StoreItem(StoreItemDto rec, string _UploadedFileName, string _CreatedFileName)
{
Key = rec.Key;
ArtikelCode = rec.ArtikelCode;
ColorCode = rec.ColorCode;
Description = rec.Description;
Price = rec.Price;
DiscountPrice = rec.DiscountPrice;
DeliveredIn = rec.DeliveredIn;
Q1 = rec.Q1;
Size = rec.Size;
Color = rec.Color;
}
StoreItemDto CreateTestStoreItem()
{
StoreItemDto storeItem = new StoreItemDto()
{
Name = "Test",
Description = "Test",
Cost = 9.99,
InStock = true,
};
storeItem = _storeItemController.Create(storeItem);
return(storeItem);
}
public async Task <StoreItemDto> ReplaceAsync(StoreItemDto entity)
{
using (var store = new DataStore(_settings.DatabaseFilePath))
{
var movieCollection = store.GetCollection <StoreItemDto>();
await movieCollection.ReplaceOneAsync(m => m.Key == entity.Key, entity, true);
return(movieCollection.Find(
i => i.Key.Equals(entity.Key, StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault());
}
}
public void TestCreate_EmptyName()
{
//Set up dto
StoreItemDto storeItem = new StoreItemDto()
{
Name = string.Empty,
Description = "Test",
Cost = 9.99,
InStock = true
};
_controller.Create(storeItem);
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
try {
var request = new HTTPrequest();
StoreItemDto storeItem = await request.Get <StoreItemDto>("api/storeItem/" + id);
await request.Delete("api/storeItem/" + id);
return(RedirectToAction("Index", new { recentAction = "Deleted", recentName = storeItem.Name, recentId = storeItem.Id }));
}
catch (Exception) {
throw;
}
}
public void TestGetFiltered_AllFilters()
{
//Create StoreItem for getfiltered validation
StoreItemDto validStoreItem = CreateTestStoreItem();
var results = _controller.GetFiltered(new ApiFilter()
{
isDeleted = false, numPerPage = 100, pageNumber = 0
});
Assert.IsNotNull(results);
Assert.IsTrue(!results.Any(m => m.IsDeleted));
Assert.IsTrue(results.Count <= 100);
Assert.IsTrue(results.Count == results.Distinct().Count());
}
// GET: Artefacts/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var request = new HTTPrequest();
StoreItemDto storeItem = await request.Get <StoreItemDto>("api/storeItem/" + id);
if (storeItem == null)
{
return(HttpNotFound());
}
return(View(storeItem));
}
public void TestDelete_ValidId()
{
//Get valid storeItem
StoreItemDto validStoreItem = GetStoreItem();
//Delete storeItem
bool result = _controller.Delete(validStoreItem.Id);
Assert.IsTrue(result);
//Get storeItem for comparison
StoreItemDto storeItemResult = _controller.GetById(validStoreItem.Id);
Assert.IsNotNull(storeItemResult);
Assert.IsNotNull(storeItemResult.Id);
Assert.AreEqual(validStoreItem.Id, storeItemResult.Id);
Assert.IsTrue(storeItemResult.IsDeleted);
}
public void TestGetFiltered_IsDeleted()
{
//Create a storeItem to test on
StoreItemDto validStoreItem = CreateTestStoreItem();
//delete for test
_controller.Delete(validStoreItem.Id);
var results = _controller.GetFiltered(new ApiFilter()
{
isDeleted = true, numPerPage = 100, pageNumber = 0
});
Assert.IsNotNull(results);
Assert.IsTrue(!results.Any(m => !m.IsDeleted));
Assert.IsTrue(results.Count <= 100);
Assert.IsTrue(results.Count == results.Distinct().Count());
}
public void TestCreate_NoImage()
{
//Set up dto
StoreItemDto storeItem = new StoreItemDto()
{
Name = "Test",
Description = "Test",
Cost = 9.99,
InStock = true
};
//Make test request
StoreItemDto storeItemResult = _controller.Create(storeItem);
//Assert Values
Assert.IsNotNull(storeItemResult);
Assert.IsNotNull(storeItemResult.Id);
Assert.IsTrue(storeItemResult.Id != 0);
}
public void TestUpdate_NoDescription()
{
//Get valid storeItem
StoreItemDto storeItem = GetStoreItem();
storeItem.Name = "Test";
storeItem.Description = null;
storeItem.Cost = 9.99;
storeItem.InStock = true;
StoreItemDto updatedStoreItem = _controller.Update(storeItem);
Assert.IsNotNull(updatedStoreItem);
Assert.IsNotNull(updatedStoreItem.Id);
Assert.AreEqual(storeItem.Id, updatedStoreItem.Id);
Assert.AreEqual(storeItem.Name, updatedStoreItem.Name);
Assert.AreEqual(storeItem.Description, updatedStoreItem.Description);
Assert.AreEqual(storeItem.Cost, updatedStoreItem.Cost);
Assert.AreEqual(storeItem.InStock, updatedStoreItem.InStock);
}
public StoreItemDto Create(StoreItemDto dto)
{
if (string.IsNullOrEmpty(dto.Name))
{
throw new ArgumentNullException("Name");
}
StoreItem storeItem = new StoreItem()
{
Name = dto.Name,
Description = dto.Description,
Cost = dto.Cost,
InStock = dto.InStock,
CreatedDate = DateTime.UtcNow,
ModifiedDate = DateTime.UtcNow,
IsDeleted = false
};
Db.StoreItems.Add(storeItem);
Db.SaveChanges();
return(Mapper.Map <StoreItemDto>(storeItem));
}
// GET: storeItemImage
public async Task <ActionResult> Index(int?storeItemId, string sortOrder, string currentFilter, string searchString, int?page)
{
var requestStoreItem = new HTTPrequest();
var requestStoreItemImageList = new HTTPrequest();
ViewBag.CurrentSort = sortOrder;
ViewBag.IdSortParm = String.IsNullOrEmpty(sortOrder) ? "id_desc" : "";
ViewBag.NameSortParm = sortOrder == "Name" ? "name_desc" : "Name";
ViewBag.DescriptionSortParm = sortOrder == "Description" ? "description_desc" : "Description";
ViewBag.TypeSortParm = sortOrder == "Type" ? "type_desc" : "Type";
ViewBag.StoreItemID = storeItemId;
// Retrives a list of All Artefacts if user has not navaigated through a particular Artefact Id
List <StoreItemImageDto> storeItemImageMasterList = new List <StoreItemImageDto>();
if (storeItemId == null)
{
storeItemImageMasterList = await requestStoreItemImageList.Get <List <StoreItemImageDto> >("api/storeItemImage?pageNumber=0&numPerPage=500&isDeleted=false");
}
else
{
storeItemImageMasterList = await requestStoreItemImageList.Get <List <StoreItemImageDto> >("api/storeItemImage?storeItemId=" + storeItemId + "&pageNumber=0&numPerPage=500&isDeleted=false");
StoreItemDto storeItem = await requestStoreItem.Get <StoreItemDto>("api/storeItem/" + storeItemId);
ViewBag.StoreItemName = storeItem.Name;
}
IEnumerable <StoreItemImageDto> storeItemImagesFiltered = storeItemImageMasterList.ToList();
if (searchString != null)
{
page = 1;
}
else
{
searchString = currentFilter;
}
ViewBag.CurrentFilter = searchString;
if (!String.IsNullOrEmpty(searchString))
{
storeItemImagesFiltered = storeItemImagesFiltered.Where(a => a.Id.Equals(searchString));
}
var storeItemsContent = storeItemImagesFiltered;
switch (sortOrder)
{
case "id_desc":
storeItemsContent = storeItemsContent.OrderByDescending(a => a.Id);
break;
default:
storeItemsContent = storeItemsContent.OrderBy(a => a.Id);
break;
}
int pageSize = 10;
int pageNumber = (page ?? 1);
return(View(storeItemsContent.ToPagedList(pageNumber, pageSize)));
}
/* Reads file from temp dir and imports to disk and DB */
private async Task ImportAsync(string session, string dir, string fileName)
{
List <StoreItemDto> fileContent = new List <StoreItemDto>();
StoreItemDto item;
string[] line;
try
{
FileStream fileStream = new FileStream(dir + fileName, FileMode.Open);
using (var reader = new StreamReader(fileStream))
{
ImportStateService.SetReading(session);
await reader.ReadLineAsync();
while (reader.Peek() >= 0)
{
line = (await reader.ReadLineAsync()).Split(',');
item = new StoreItemDto
{
Key = line[0],
ArtikelCode = line[1],
ColorCode = line[2],
Description = line[3],
Price = decimal.Parse(line[4]),
DiscountPrice = decimal.Parse(line[5]),
DeliveredIn = line[6],
Q1 = line[7],
Size = line[8],
Color = line[9]
};
fileContent.Add(item);
}
}
// Save data to DB and disk
await _service.SaveData(session, fileContent, fileName);
await _service.SaveFileInfo(session, fileContent.Count, fileName, ImportState.Completed, "save successed");
// delete directory which csv file is in it
DirectoryInfo di = new DirectoryInfo(dir);
foreach (FileInfo file in di.EnumerateFiles())
{
file.Delete();
}
Directory.Delete(dir);
ImportStateService.SetProgress(session, ImportState.Completed, 100);
_logger.LogInfo("File Imported Successfully");
}
catch (Exception ex)
{
_logger.LogError("ERROR! : " + ex.StackTrace);
await _service.SaveFileInfo(session, fileContent.Count, fileName, ImportState.Failed, ex.Message);
ImportStateService.SetFailed(session, ex.Message);
}
}
public void SaveStoreCommand_WhenNew_ShouldInsert()
{
var item = new StoreItemDto
{
Id = Guid.NewGuid(),
Name = "test store item",
X = 1,
Y = 2
};
var rect = new StoreObjectRectDto
{
X = 1,
Y = 2,
Color = "test color",
Height = 3,
Width = 4
};
var circle = new StoreObjectCircleDto
{
Color = "test color 2",
Diameter = 1,
X = 2,
Y = 3
};
var store = new StoreDto
{
Id = Guid.NewGuid(),
Name = "test store",
StoreItems = new List <StoreItemDto> {
item
},
StoreObjects = new List <StoreObjectDto> {
rect, circle
}
};
var result = command.Execute(store).Result;
result.Success.Should().BeTrue();
result.Message.Should().NotBeNullOrEmpty();
result.Data.Should().NotBeNull();
result.Data.Id.Should().Be(store.Id);
result.Data.Name.Should().Be(store.Name);
result.Data.StoreItems.Should().NotBeNullOrEmpty();
result.Data.StoreObjects.Should().NotBeNullOrEmpty();
var resItem = result.Data.StoreItems.First();
resItem.Id.Should().Be(item.Id);
resItem.Name.Should().Be(item.Name);
resItem.X.Should().Be(item.X);
resItem.Y.Should().Be(item.Y);
var resRect = (StoreObjectRectDto)result.Data.StoreObjects.First(x => x is StoreObjectRectDto);
resRect.Color.Should().Be(rect.Color);
resRect.Width.Should().Be(rect.Width);
resRect.Height.Should().Be(rect.Height);
resRect.X.Should().Be(rect.X);
resRect.Y.Should().Be(rect.Y);
var resCircle = (StoreObjectCircleDto)result.Data.StoreObjects.First(x => x is StoreObjectCircleDto);
resCircle.Color.Should().Be(circle.Color);
resCircle.Diameter.Should().Be(circle.Diameter);
resCircle.X.Should().Be(circle.X);
resCircle.Y.Should().Be(circle.Y);
}
