public async void WhenItemIsPostedResponseShouldBe201AndLocationHeaderShouldBeSet()
{
var item = new Item
{
Id = 1,
Name = "Filip"
};
var service = new Mock<IItemService>().Object;
var controller = new ItemsController(service)
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("http://localhost/items")
}
};
controller.Configuration.MapHttpAttributeRoutes();
controller.Configuration.EnsureInitialized();
controller.RequestContext.RouteData = new HttpRouteData(
new HttpRoute(), new HttpRouteValueDictionary { { "controller", "Items" } });
var result = await controller.Post(item);
Assert.Equal(HttpStatusCode.Created, result.StatusCode);
Assert.Equal("http://localhost/items/1", result.Headers.Location.AbsoluteUri);
}
public void WhenIdCalledByGetByIdIsNotFound404IsThrown()
{
var service = new Mock<IItemService>();
service.Setup(x => x.GetById(1)).Returns(Task.FromResult<Item>(null));
var controller = new ItemsController(service.Object);
var ex = AssertEx.TaskThrows<HttpResponseException>(async () => await controller.Get(1));
Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
}
public async void WhenGetByIdIsCalledUnderlyingServiceIsCalled()
{
var item = new Item {Id = 1, Name = "Filip"};
var service = new Mock<IItemService>();
service.Setup(x => x.GetById(1)).Returns(Task.FromResult(item));
var controller = new ItemsController(service.Object);
var result = await controller.Get(1);
Assert.Equal(item, result);
}
private async void MainPage_Loaded(object sender, RoutedEventArgs e)
{
if (this.itemsController == null)
{
this.itemsController = new ItemsController(((App)Application.Current).OneDriveClient);
}
var last = ((App)Application.Current).NavigationStack.Last();
((App)Application.Current).Items = await this.itemsController.GetImagesAndFolders(last.Id);
this.DataContext = ((App)Application.Current).Items;
wait.IsActive = false;
}
public async Task ItemsController_CreateItem()
{
// Arrange
var item = new ItemModel()
{
Id = 1, ItemName = "name"
};
var mockRepo = new Mock <IItemsBLL>();
var httpServiceMock = new Mock <IHttpServices>();
mockRepo.Setup(x => x.GetItemById(It.IsAny <int>()))
.ReturnsAsync(item);
var controller = new ItemsController(mockRepo.Object, httpServiceMock.Object);
// Act
var result = await controller.Create(item);
// Assert
Assert.Equal(400, ((StatusCodeResult)result.Result).StatusCode);
}
public void Mock_PostViewResultCreate_ViewResult()
{
// Arrange
Item testItem = new Item
{
ItemId = 1,
Description = "Wash the dog",
CategoryId = 1
};
DbSetup();
ItemsController controller = new ItemsController(mock.Object);
// Act
var resultView = controller.Create(testItem) as RedirectToActionResult;
// Assert
Assert.IsInstanceOfType(resultView, typeof(RedirectToActionResult));
}
public ItemsTest()
{
var mockRepo = new Mock <IItemsRepository>();
var myProfile = new AutomapperProfiles();
var configuration = new MapperConfiguration(cfg => cfg.AddProfile(myProfile));
IMapper mapper = new Mapper(configuration);
controller = new ItemsController(mockRepo.Object, mapper);
var response = new Mock <HttpResponse>();
response.Setup(r => r.AddPagination(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <int>()));
var httpContext = new Mock <HttpContext>();
httpContext.Setup(a => a.Response).Returns(response.Object);
controller.ControllerContext.HttpContext = httpContext.Object;
}
public async Task GetAllItems_ReturnWithAListOfItemResources_WhenSuccess()
{
//Arrange
var expectedObject = GetTestItemResources();
// setup GetAllWithUser method to return test items
_mockItemService.Setup(service => service.GetAllWithUser())
.ReturnsAsync(GetTestItems());
// inject mocked IItemService and _mapper in controller
var controller = new ItemsController(_mockItemService.Object, _mapper);
//Act
var actionResult = await controller.GetAllItems() as OkObjectResult;
var resultObject = GetObjectResultContent <IEnumerable <ItemResource> >(actionResult);
//Assert
Assert.IsType <OkObjectResult>(actionResult);
Assert.Equal(serializeObject(expectedObject), serializeObject(resultObject));
}
public void Mock_GetDetails_ReturnsView()
{
// Arrange
Item testItem = new Item
{
ItemId = 1,
Description = "Wash the dog"
};
DbSetup();
ItemsController controller = new ItemsController(mock.Object);
// Act
var resultView = controller.Details(testItem.ItemId) as ViewResult;
var model = resultView.ViewData.Model as Item;
// Assert
Assert.IsInstanceOfType(resultView, typeof(ViewResult));
Assert.IsInstanceOfType(model, typeof(Item));
}
public void SetItem(Item item, bool isSelected)
{
ItemInSlot = item;
IsSelected = isSelected;
if (ItemInSlot == null)
{
button.interactable = false;
icon.gameObject.SetActive(false);
equipedMarker.gameObject.SetActive(false);
selected.gameObject.SetActive(false);
}
else
{
button.interactable = IsSelected == false;
icon.gameObject.SetActive(true);
icon.sprite = item.icon;
equipedMarker.gameObject.SetActive(ItemsController.IsEquiped(item));
selected.gameObject.SetActive(IsSelected);
}
}
public void DB_CreateNewEntry_Test()
{
// Arrange
ItemsController controller = new ItemsController(db);
Item testItem = new Item();
Category testCategory = new Category();
testCategory.Name = "home";
testItem.Description = "TestDb Item";
testItem.CategoryId = 1;
db.SaveCategory(testCategory);
db.Save(testItem);
// Act
controller.Create(testItem);
var collection = (controller.Index() as ViewResult).ViewData.Model as IEnumerable <Item>;
// Assert
Assert.Contains <Item>(testItem, collection);
}
public void WarehouseReturnsPagedResults()
{
var items = TestData.CreateLargeTestDataSet();
var cntItems = items.Count();
var c = new ItemsController(new Repository(items));
setupItemsController(c);
IHttpActionResult actionResult = c.GetAllItems();
var contentResult = actionResult as OkNegotiatedContentResult <IEnumerable <Item> >;
var resultItems = contentResult.Content;
Assert.AreEqual(10, resultItems.Count());
Assert.IsTrue(resultItems.All(
s => items.Take(10).First(
t => s.Name == t.Name &&
s.Description == t.Description &&
s.Price == t.Price) != null));
}
public async Task ItemsController_Get_ItemPresent()
{
// Arrange
var item = new ItemModel()
{
Id = 1, ItemName = "name"
};
var mockRepo = new Mock <IItemsBLL>();
var httpServiceMock = new Mock <IHttpServices>();
mockRepo.Setup(x => x.GetItemById(It.IsAny <int>()))
.Returns(Task.FromResult(item));
var controller = new ItemsController(mockRepo.Object, httpServiceMock.Object);
// Act
var result = await controller.Get(1);
// Assert
Assert.Equal(item, result.Value);
}
public void LoadGame()
{
ResetGame();
SaveGameData data = SaveLoadController.LoadGame();
if (data == null)
{
return;
}
locationsStates = data.locationsStates;
Values = data.globalValues;
foreach (string id in data.itemsId)
{
InventoryController.Instance.AddItem(id);
}
foreach (string id in data.notesId)
{
JournalController.Instance.AddNote(id, false);
}
foreach (string id in data.tasksId)
{
JournalController.Instance.AddTask(id);
}
foreach (string id in data.completeTasksId)
{
JournalController.Instance.AddTask(id);
JournalController.Instance.CompleteTask(id);
}
LoadLevel(data.locationName, false, () =>
{
PlayerController.Instance.MoveToPoint(data.playerPosition.GetVector3(), data.playerRotation.GetQuaternion());
PlayerController.Instance.Health = data.playerHealth;
if (data.equipedWearId != "")
{
ItemsController.UseItem(ItemsManager.Instance.GetItemById(data.equipedWearId));
}
});
}
public async Task PostItemAsync_ValidItem_ReturnsCreatedItem()
{
var creationTime = new DateTime(2018, 9, 27);
var expectedItem = ItemFactory.CreateItem("5694207A-697C-449B-BA49-05AC6683C5E5", "Write dummier controller", creationTime, creationTime);
var newItem = ItemFactory.CreateItem(Guid.Empty, expectedItem.Text);
var headerLocation = new Uri("http://localhost/");
ItemCreatingService.CreateAsync(newItem).Returns(expectedItem);
UrlService.GetItemUrl(expectedItem.Id).Returns(headerLocation);
var message = await ItemsController.ExecuteAsyncAction(controller => controller.PostItemAsync(newItem));
message.TryGetContentValue(out Item actualItem);
Assert.Multiple(() =>
{
Assert.That(message.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(message.Headers.Location, Is.EqualTo(headerLocation));
Assert.That(actualItem, Is.EqualTo(expectedItem));
});
}
public void Can_add_tag()
{
using (var context = new ItemsContext(ContextOptions))
{
var controller = new ItemsController(context);
var tag = controller.PostTag("ItemTwo", "Tag21").Value;
Assert.Equal("Tag21", tag.Label);
Assert.Equal(1, tag.Count);
}
using (var context = new ItemsContext(ContextOptions))
{
var item = context.Set <Item>().Include(e => e.Tags).Single(e => e.Name == "ItemTwo");
Assert.Equal(1, item.Tags.Count);
Assert.Equal("Tag21", item.Tags[0].Label);
Assert.Equal(1, item.Tags[0].Count);
}
}
public async Task ItemsController_UpdateItem_IdMismatch()
{
// Arrange
int id = 2;
var item = new ItemModel()
{
Id = 1, ItemName = "name"
};
var mockRepo = new Mock <IItemsBLL>();
var httpServiceMock = new Mock <IHttpServices>();
mockRepo.Setup(x => x.UpdateItem(It.IsAny <ItemModel>()))
.ReturnsAsync(false);
var controller = new ItemsController(mockRepo.Object, httpServiceMock.Object);
// Act
var result = await controller.Update(id, item);
// Assert
Assert.Equal(400, ((StatusCodeResult)result.Result).StatusCode);
}
public async Task ItemsController_UpdateItem_ItemNotFound()
{
// Arrange
int id = 1;
var item = new ItemModel()
{
Id = 1, ItemName = "name"
};
var mockRepo = new Mock <IItemsBLL>();
var httpServiceMock = new Mock <IHttpServices>();
mockRepo.Setup(x => x.UpdateItem(It.IsAny <ItemModel>()))
.Throws(new NotFoundException());
var controller = new ItemsController(mockRepo.Object, httpServiceMock.Object);
// Act
var result = await controller.Update(id, item);
// Assert
Assert.Equal(404, ((StatusCodeResult)result.Result).StatusCode);
}
public async Task Put_ShouldNoContent_WhenValidItemPassed()
{
var expectedGuid = Guid.NewGuid();
var mediatr = new Mock <IMediator>();
mediatr
.Setup(m => m.Send(It.IsAny <IRequest <Item> >(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new Item()
{
Id = expectedGuid
}));
var itemController = new ItemsController(mediatr.Object);
var actionResults = await itemController.Put(Guid.NewGuid(), Guid.NewGuid(), new Models.Request.PutItem());
var noContentResult = actionResults as NoContentResult;
Assert.NotNull(noContentResult);
}
public void Should_return_an_item()
{
// Arrange
var controller = new ItemsController();
const int itemId = 5;
const string itemValue = "foo";
controller.Put(itemId, new Item {
Value = itemValue
});
// Act
var actionResult = controller.Get(itemId);
// Assert
var result = (actionResult.Result as ObjectResult)?.Value as Item;
Assert.NotNull(result);
Assert.Equal(itemId, result.Id);
Assert.Equal(itemValue, result.Value);
}
public void InsertANewItemToDB_FromPostNewItem()
{
//Arrange
var itemToAdd = new Items
{
Label = "Add Me",
Expiration = DateTime.Now.AddYears(1),
ItemType = 1
};
var loggerFactory = new LoggerFactory();
var mockContext = SetUpContext(null);
var itemsController = new ItemsController(mockContext, new ItemMonitor(mockContext, new TimerFactory(), loggerFactory), loggerFactory);
//Action
var result = itemsController.Post(itemToAdd);
//Assert
Assert.Equal(1, mockContext.Items.Count());
Assert.Equal(itemToAdd, mockContext.Items.Last());
}
public void AddItemSuccessPosttoMockDb()
{
var item = new Item {
item_id = Guid.NewGuid(), name = "item4", price = 40.00M, quantity = 15
};
var mockItem = new Mock <DbSet <Item> >();
mockItem.Setup(m => m.Find(item.item_id)).Returns(item);
var mockContext = new Mock <StoreDbContext>();
mockContext.Setup(i => i.Items).Returns(mockItem.Object);
var controller = new ItemsController(mockContext.Object);
var vm = new ItemViewModel(item);
controller.AddItem(vm);
mockItem.Verify(m => m.Add(It.IsAny <Item>()), Times.Once());
}
public async Task ItemsController_DeleteItem_ItemDoesntExist()
{
// Arrange
int id = 2;
var item = new ItemModel()
{
Id = 1, ItemName = "name"
};
var mockRepo = new Mock <IItemsBLL>();
var httpServiceMock = new Mock <IHttpServices>();
mockRepo.Setup(x => x.GetItemById(It.IsAny <int>()))
.ReturnsAsync(null as ItemModel);
var controller = new ItemsController(mockRepo.Object, httpServiceMock.Object);
// Act
var result = await controller.Delete(id);
// Assert
Assert.Equal(404, ((StatusCodeResult)result).StatusCode);
}
public void WhenGet_Returns_Item()
{
var fakeId = 1;
// Arrange
IEnumerable <BudgetItem> fakeItems = GetFakeItems();
// setup
_itemRepository.Setup(x => x.GetItem(fakeId)).Returns(fakeItems.FirstOrDefault(p => p.Id == fakeId));
ItemsController controller = new ItemsController(_itemRepository.Object);
// Act
var response = controller.Get(fakeId);
var item = response as OkNegotiatedContentResult <BudgetItem>;
// Assert
Assert.IsNotNull(item, "Result is null");
Assert.IsInstanceOf(typeof(BudgetItem), item.Content, "Wrong Model");
Assert.AreEqual(fakeId, item.Content.Id, "Got wrong item.");
}
public async Task Edit_ReturnsViewResultWithItemModel()
{
// Arrange
var Item = new Item()
{
Id = 1
};
var mockRepo = new Mock <IInvoicesRepository>();
mockRepo.Setup(repo => repo.GetItemAsync(Item.Id)).ReturnsAsync(Item);
var controller = new ItemsController(mockRepo.Object);
// Act
var result = await controller.Edit(1);
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <Item>(viewResult.ViewData.Model);
Assert.Equal(Item.Id, model.Id);
}
public void WhenItemIsPostedAndIsInvalidThrowsBadRequest()
{
var item = new Item
{
Id = 1
};
var service = new Mock<IItemService>().Object;
var controller = new ItemsController(service)
{
Configuration = new HttpConfiguration(),
Request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("http://localhost/items")
}
};
controller.ModelState.AddModelError("Name", "Name is required");
var ex = AssertEx.TaskThrows<HttpResponseException>(async () => await controller.Post(item));
Assert.Equal(HttpStatusCode.BadRequest, ex.Response.StatusCode);
}
public void SetUp()
{
_jsonFieldsSerializer = new Mock <IJsonFieldsSerializer>();
_aclService = new Mock <IAclService>();
_userService = new Mock <IUserService>();
_tenantMappingService = new Mock <ITenantMappingService>();
_tenantService = new Mock <ITenantService>();
_userActivityService = new Mock <IUserActivityService>();
_itemApiService = new Mock <IItemApiService>();
_itemRepository = new Mock <IRepository <Item> >();
_itemsController = new ItemsController(
_jsonFieldsSerializer.Object,
_aclService.Object,
_userService.Object,
_tenantMappingService.Object,
_tenantService.Object,
_userActivityService.Object,
_itemApiService.Object,
_itemRepository.Object);
}
public void GetItems_ReturnsOk_ForFoundItems()
{
// Arrange
List <Item> items = new List <Item>()
{
new Item()
{
Id = 1, Name = "Shoes", Price = 100, Discount = 10
},
new Item()
{
Id = 2, Name = "T-Shirt", Price = 240.5, Discount = 0
},
new Item()
{
Id = 3, Name = "Pants", Price = 200, Discount = 10
},
};
var mock = new Mock <IItemRepository>();
var mock_mapper = new Mock <IMapper>();
mock.Setup(repo => repo.GetAllItems()).Returns(items);
mock_mapper.Setup(mapper => mapper.Map <IEnumerable <ItemDto> >(items))
.Returns(new List <ItemDto>()
{
new ItemDto(),
new ItemDto(),
new ItemDto()
});
var controller = new ItemsController(itemRepository: mock.Object, cartService: null, mock_mapper.Object);
// Act
var result = controller.GetItems();
// Assert
var okResult = Assert.IsType <OkObjectResult>(result.Result);
var resItems = Assert.IsType <List <ItemDto> >(okResult.Value);
Assert.Equal(items.Count(), resItems.Count());
}
public async Task Post_Edit_Item_Fails_User_Admin_Returns_Item_Approved_AndActionResult()
{
//Arrange
var httpContextMock = new Mock <HttpContextBase>();
var mockPrincipal = new Mock <IPrincipal>();
mockPrincipal.Setup(x => x.Identity.IsAuthenticated).Returns(true);
mockPrincipal.Setup(x => x.IsInRole(It.IsAny <string>())).Returns(true);
httpContextMock.Setup(m => m.User).Returns(mockPrincipal.Object);
//Mock a file download
var request = new Mock <HttpPostedFileBase>();
var postedfilesKeyCollection = new Mock <HttpFileCollectionBase>();
httpContextMock.SetupGet(x => x.Request.Files[It.IsAny <string>()]).Returns(request.Object);
Item item = new Item {
ID = 1, UserID = "john123",
};
var repository = new Mock <IItemsRepository>();
var controller = new ItemsController(repository.Object)
{
ControllerContext = new ControllerContext
{
HttpContext = httpContextMock.Object
}
};
controller.ModelState.AddModelError("title", "title is required");
//Act
var result = await controller.Edit(item, "", "");
//Assert
Assert.True(item.Approved);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <Item>(viewResult.ViewData.Model);
}
internal static async Task <PhotoSorter> Create(bool runSampleRequest = false)
{
var config = AuthenticationConfig.ReadFromJsonFile("appsettings.json");
string[] scopes = new string[]
{
"https://graph.microsoft.com/files.readwrite"
};
IPublicClientApplication PublicClientApp;
PublicClientApp = PublicClientApplicationBuilder.Create(config.ClientId)
.WithRedirectUri("http://localhost")
.WithAuthority(AzureCloudInstance.AzurePublic, config.Tenant)
.Build();
InteractiveAuthenticationProvider authenticationProvider = new InteractiveAuthenticationProvider(PublicClientApp, scopes);
GraphServiceClient graphServiceClient = new GraphServiceClient(authenticationProvider);
// Verify
if (runSampleRequest)
{
var me = await graphServiceClient.Me.Request().WithForceRefresh(true).GetAsync();
Console.WriteLine("Me==>");
Console.WriteLine(JsonConvert.SerializeObject(me));
Console.WriteLine("<==");
var drive = await graphServiceClient.Me.Drive.Root.Request().WithForceRefresh(true).GetAsync();
Console.WriteLine("Drive==>");
Console.WriteLine(JsonConvert.SerializeObject(drive));
Console.WriteLine("<==");
}
var controller = new ItemsController(graphServiceClient);
return(new PhotoSorter(controller));
}
public void EdittemInvalidIdThrowException()
{
var id = Guid.NewGuid();
var existing_item = new Item {
item_id = id, name = "item4", price = 40.00M, quantity = 50
};
//var updated_item = new Item { item_id = id , name = "item4", price = 50.00M };
var mockItem = new Mock <DbSet <Item> >();
mockItem.Setup(m => m.Find(id)).Returns(existing_item);
var mockContext = new Mock <StoreDbContext>();
mockContext.Setup(m => m.Items).Returns(mockItem.Object);
var controller = new ItemsController(mockContext.Object);
var result = controller.Edit(Guid.NewGuid());
Assert.IsAssignableFrom(typeof(HttpNotFoundResult), result);
}
public async Task Get_Delete_Item_ReturnsActionResult()
{
//Arrange
var mock = new Mock <IItemsRepository>();
Item item = new Item {
ID = 1, UserID = "john123", Title = "New Title"
};
mock.Setup(x => x.GetItem(It.IsAny <int>())).ReturnsAsync(item);
var controller = new ItemsController(mock.Object);
//Act
ActionResult result = await controller.Delete(item.ID);
//Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsType <Item>(viewResult.ViewData.Model);
Assert.Equal(item.ID, model.ID);
Assert.Equal(item.UserID, model.UserID);
Assert.Equal(item.Title, model.Title);
}
public void DeleteItemSuccessRemovedFromDb()
{
var id = new Guid();
var del_item = new Item {
item_id = id, name = "Test Delete", price = 20.00M, quantity = 10
};
var mockItem = new Mock <DbSet <Item> >();
mockItem.Setup(m => m.Find(id)).Returns(del_item);
var mockContext = new Mock <StoreDbContext>();
mockContext.Setup(m => m.Items).Returns(mockItem.Object);
var controller = new ItemsController(mockContext.Object);
var result = controller.DeleteItem(id);
mockContext.Verify(x => x.SaveChanges());
Assert.IsAssignableFrom(typeof(RedirectToRouteResult), result);
}
public async Task Create_RedirectsToInvoicesDetails()
{
var item = new Item()
{
Id = 1
};
// Arrange
var mockRepo = new Mock <IInvoicesRepository>();
mockRepo.Setup(repo => repo.AddItemAsync(item))
.ReturnsAsync(item);
var controller = new ItemsController(mockRepo.Object);
// Act
var result = await controller.Create(item);
// Assert
var redirect = Assert.IsType <RedirectToActionResult>(result);
Assert.Equal("Details", redirect.ActionName);
Assert.Equal("Invoices", redirect.ControllerName);
}
public void EdittemSuccessViewRenders()
{
var id = Guid.NewGuid();
var existing_item = new Item {
item_id = id, name = "item4", price = 40.00M, quantity = 30
};
//var updated_item = new Item { item_id = id , name = "item4", price = 50.00M };
var mockItem = new Mock <DbSet <Item> >();
mockItem.Setup(m => m.Find(id)).Returns(existing_item);
var mockContext = new Mock <StoreDbContext>();
mockContext.Setup(m => m.Items).Returns(mockItem.Object);
var controller = new ItemsController(mockContext.Object);
var result = controller.Edit(id);
Assert.IsAssignableFrom(typeof(ViewResult), result);
}
public void SaveItemAndAttributes(int itemID, int itemTypeID, int attributeSetID, int storeID, int portalID, string userName, string culture, int taxRuleID, string categoriesIds, string relatedItemsIds, string upSellItemsIds, string crossSellItemsIds, string downloadItemsValue, string sourceFileCol, string dataCollection, AspxNameValue[] formVars)
{
try
{
string uplodedDownlodableFormValue = string.Empty;
if (itemTypeID == 2 && downloadItemsValue != "")
{
FileHelperController downLoadableObj = new FileHelperController();
string tempFolder = @"Upload\temp";
uplodedDownlodableFormValue = downLoadableObj.MoveFileToDownlodableItemFolder(tempFolder,
downloadItemsValue,
@"Modules/AspxCommerce/AspxItemsManagement/DownloadableItems/",
itemID, "item_");
}
ItemsController itemController = new ItemsController();
itemID = itemController.SaveUpdateItemAndAttributes(itemID, itemTypeID, attributeSetID, storeID, portalID,
userName, culture, taxRuleID,
categoriesIds, relatedItemsIds, upSellItemsIds,
crossSellItemsIds, uplodedDownlodableFormValue,
formVars);
//return "({\"returnStatus\":1,\"Message\":'Item saved successfully.'})";
if (itemID > 0 && sourceFileCol != "" && dataCollection != "")
{
StoreSettingConfig ssc = new StoreSettingConfig();
int itemLargeThumbNailSize = Convert.ToInt32(ssc.GetStoreSettingsByKey(StoreSetting.ItemLargeThumbnailImageSize, storeID,
portalID, culture));
int itemMediumThumbNailSize = Convert.ToInt32(ssc.GetStoreSettingsByKey(StoreSetting.ItemMediumThumbnailImageSize,
storeID, portalID, culture));
int itemSmallThumbNailSize = Convert.ToInt32(ssc.GetStoreSettingsByKey(StoreSetting.ItemSmallThumbnailImageSize, storeID,
portalID, culture));
dataCollection = dataCollection.Replace("../", "");
SaveImageContents(itemID, @"Modules/AspxCommerce/AspxItemsManagement/uploads/", sourceFileCol,
dataCollection, itemLargeThumbNailSize, itemMediumThumbNailSize,
itemSmallThumbNailSize, "item_");
}
else if (itemID > 0 && sourceFileCol == "" && dataCollection == "")
{
DeleteImageContents(itemID);
}
//if (itemID==0)
//{
// //SaveImageContents(itemID, @"Modules/AspxCommerce/AspxItemsManagement/uploads/", sourceFileCol, dataCollection, "item_");
// //TODO:: DELTE UPLOADED FILE FROM DOWNLOAD FOLDER
//}
}
catch (Exception ex)
{
throw ex;
//ErrorHandler errHandler = new ErrorHandler();
//if (errHandler.LogWCFException(ex))
//{
// return "({\"returnStatus\":-1,\"errorMessage\":'" + ex.Message + "'})";
//}
//else
//{
// return "({\"returnStatus\":-1,\"errorMessage\":'Error while saving item!'})";
//}
}
}
