public async Task <ActionResult <MonitoredItem> > AddMonitoredItemToCurrUser([FromBody] CreateItemModel model)
{
// only allow users show myDevices
var currentUserId = Guid.Parse(User.Identity.Name);
if (currentUserId == null)
{
return(Forbid());
}
// map model to entity
var item = _mapper.Map <MonitoredItem>(model);
try
{
await _itemsService.Create(currentUserId, item).ConfigureAwait(false);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public int CreateItem(CreateItemModel createItem)
{
using (var context = new INVENTORYEntities())
{
CreateItemTable createItemTable = new CreateItemTable();
createItemTable.id = createItem.id;
createItemTable.ItemCode = createItem.ItemCode;
createItemTable.locationzone = createItem.Location;
createItemTable.ItemType = createItem.ItemType;
createItemTable.Category = createItem.Category;
createItemTable.ItemName = createItem.ItemName;
createItemTable.Make = createItem.Make;
createItemTable.Quantity = createItem.Quantity;
createItemTable.UOM = createItem.UOM;
createItemTable.descript = createItem.Description;
createItemTable.Status = createItem.Status;
context.CreateItemTable.Add(createItemTable);
context.SaveChanges();
return(createItemTable.id);
}
}
public async Task <CreateItemResult> CreateAsync(CreateItemModel createItemModel)
{
var authResult = await authenticatorsStore.CreateItemModelAuthenticator.AuthenticateAsync(createItemModel);
if (!authResult.Succeed)
{
return(new CreateItemResult(authResult));
}
var validResult = await validatorsStore.CreateItemModelValidator.ValidateAsync(createItemModel);
if (!validResult.Succeed)
{
return(new CreateItemResult(validResult));
}
var itemModel = mapper.Map <ItemModel>(createItemModel);
await itemsCrudService.CreateAsync(itemModel);
await collectionsManager.AttachItemToCollection(itemModel.Id, createItemModel.CollectionId);
await tagsManager.AttachTagsToItemAsync(createItemModel.Tags, itemModel.Id);
var result = new CreateItemResult
{
CreatedItemId = itemModel.Id
};
return(result);
}
// POST: api/ItemsAPI
//[ResponseType(typeof(CreateItemModel))]
public async Task <IActionResult> PostItem(CreateItemModel createItemModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//createItemModel.VMEntity.WorldId = createItemModel.WorldId;
db.Entities.Add(createItemModel.VMEntity);
createItemModel.VMItem.Entity = createItemModel.VMEntity;
db.Items.Add(createItemModel.VMItem);
await db.SaveChangesAsync();
return(CreatedAtRoute("DefaultApi", new { id = createItemModel.VMItem.ItemId }, createItemModel.VMItem));
}
public async Task <CustomResponse> Create(CreateItemModel request)
{
ItemDto item = _mapper.Map <ItemDto>(request);
//Check for category
CategoryDto category = _unitOfWork.CategoryRepository.Find(item.CategoryId);
if (category == null)
{
return(_responsMessages.CategoryNotFound);
}
_unitOfWork.ItemRepository.Add(item);
await _unitOfWork.SaveChangesAsync();
return(new OkResponse(item.Id));
}
public async Task <IActionResult> CreateItem([FromBody] CreateItemModel createItemModel)
{
Item item = new Item();
item.OwnerAccount = await _userManager.FindByIdAsync(createItemModel.UserId);
item.Category = await _context.ItemCategories.SingleAsync(x => x.Id == createItemModel.CategoryId);
item.PointValue = createItemModel.PointValue;
await _pointManager.AddToUserAsync(item.OwnerAccount, item.PointValue);
_context.Items.Add(item);
await _context.SaveChangesAsync();
dynamic response = new
{
itemId = item.Id
};
return(Ok(response));
}
public ActionResult Create(CreateItemModel cm)
{
Item item = new Item();
item.ItemName = cm.ItemName;
item.Price = cm.Price;
item.Quantity = cm.Quantity;
item.SupplierID = cm.SupplierID;
HttpResponseMessage response = client.PostAsJsonAsync("Items", item).Result;
if (response.IsSuccessStatusCode)
{
return(RedirectToAction("Index"));
}
else
{
RedirectToAction("../Suppliers/Failed", new { sc = (int)response.StatusCode });
}
//return View();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> CreateItem(CreateItemViewModel itemViewModel)
{
CreateItemModel itemModel = new CreateItemModel();
var user = await _userManager.FindByNameAsync(itemViewModel.Username);
if (user == null)
{
itemViewModel.Error = "Username does not exist";
itemViewModel.Username = null;
return(RedirectToAction("Create", itemViewModel));
}
itemModel.CategoryId = Int32.Parse(itemViewModel.SelectedValue);
itemModel.UserId = user.Id;
itemModel.PointValue = itemViewModel.PointValue;
HttpResponseMessage responseMesssage = await client.PostAsJsonAsync("api/Item/createItem", itemModel);
responseMesssage.EnsureSuccessStatusCode();
return(RedirectToAction("Items"));
}
public async Task <ActionResult> Create([FromBody] CreateItemModel request)
{
return(await IItemService.Create(request));
}