public IActionResult PutInvertorys(int sellerid, int seedid, [FromBody] InventoryDto inventoryDto)
{
if (inventoryDto == null || sellerid < 0 || seedid < 0)
{
return(BadRequest());
}
var model = _productRepository.GetInventory(sellerid, seedid);
if (model == null)
{
return(StatusCode(500, "没有该数据"));
}
Inventory put = new Inventory
{
Count = inventoryDto.Count,
SeedID = inventoryDto.SeedID,
SellerID = inventoryDto.SellerID,
SumCount = inventoryDto.SumCount
};
model.Count = put.Count;
model.SeedID = put.SeedID;
model.SellerID = put.SellerID;
model.SumCount = put.SumCount;
if (!_productRepository.Save())
{
return(StatusCode(500, "存储失败"));
}
return(NoContent());
}
public async Task <IActionResult> PutInventory(string ID, [FromBody] InventoryDto inventoryDto)
{
int id = int.Parse(ID);
if (inventoryDto == null)
{
return(BadRequest());
}
try
{
var update = await _inventoryRepository.UpdateInventory(id, inventoryDto);
if (update != null)
{
return(Ok(update));
}
}
catch (DbUpdateConcurrencyException)
{
if (!InventoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public SimpleResponse <InventoryDto> Create(InventoryDto dto)
{
var response = new SimpleResponse <InventoryDto>();
try
{
var model = SimpleMapper.Map <InventoryDto, InventoryViewModel>(dto);
var resp = iInventoryBusiness.Create(model);
response = new SimpleResponse <InventoryDto>()
{
ResponseCode = resp.ResponseCode,
ResponseMessage = resp.ResponseMessage,
RCode = resp.RCode
};
response.Data = SimpleMapper.Map <InventoryViewModel, InventoryDto>(resp.Data);
}
catch (Exception ex)
{
response.ResponseCode = BusinessResponseValues.InternalError;
response.ResponseMessage = "Okuma iþleminde hata oluþtu.";
SimpleFileLogger.Instance.Error(ex);
}
return(response);
}
public void DeleteItemFromDb_Test()
{
// Arrange
HttpPostedFileBase httpPostedFile = Mock.Of <HttpPostedFileBase>();
var mock = Mock.Get(httpPostedFile);
mock.Setup(_ => _.FileName).Returns("images.jpg");
var memoryStream = new MemoryStream();
//...populate fake stream
//setup mock to return stream
mock.Setup(_ => _.InputStream).Returns(memoryStream);
InventoryDto inventoryDto = new InventoryDto
{
Name = "TestItem",
Discription = "TestDiscription",
Price = 100,
Image = httpPostedFile
};
DbWriteRepository writeRepo = new DbWriteRepository();
int i = writeRepo.InsertInDataBase(inventoryDto);
DbReadRepository readRepo = new DbReadRepository();
List <Inventory> items = (List <Inventory>)readRepo.ReadAllItemsFromDB();
writeRepo.DeleteItemFromDb(items[0].Id);
DbReadRepository readRepos = new DbReadRepository();
Inventory inventory = readRepos.ReadItemFromDb(items[0].Id);
Assert.IsNull(inventory);
}
private static InventoryDto CreateInventoryDto(CookieInventory inventory)
{
var dto = new InventoryDto
{
Id = inventory.Id,
Balance = inventory.Balance,
CookieSlots = inventory.Stacks.Select(s => new CookieSlotDto
{
Position = s.Position,
CookieQuantity = new CookieQuantityDto
{
Quantity = s.CookieQuantity.Quantity,
Cookie = new CookieDto
{
CookieVariety = s.CookieQuantity.Cookie.Variety.ToString(),
Price = s.CookieQuantity.Cookie.Price
}
}
}).ToList(),
Transactions = inventory.Transactions
.Select(CookieTransactionDtoFactory.CreateCookieTransaction).ToList()
};
return(dto);
}
public async Task <Guid> CreateAsync(CharacterCreateDto entityDto)
{
using (var uow = UnitOfWorkProvider.Create())
{
//attributes, inventory, equipment
var inv = new InventoryDto()
{
Id = Guid.NewGuid(), MaxSize = 12
};
var attr = GenerateAttributesAccordingToCharacter(entityDto);
var eq = new EquipmentDto()
{
Id = Guid.NewGuid()
};
entityDto.CurrentHp = 10 * attr.Hp;
entityDto.Inventory = inv;
entityDto.Equipment = eq;
entityDto.Attributes = attr;
entityDto.Id = _characterService.Create(entityDto);
await uow.Commit();
return(entityDto.Id);
}
}
public InventoryDto UpdateItem(InventoryDto item)
{
item.AddedDate = DateTime.Parse(item.AddedDate.ToString());
item.UpdatedDate = DateTime.Parse(item.UpdatedDate.ToString());
var response = _inventoryRepository.UpdateItem(mapper.Map<Inventory>(item));
item.Id = response.Id;
return item;
}
protected virtual async Task Create(InventoryDto input)
{
Inventory inventory = MappingProfile.MappingConfigurationSetups().Map <Inventory>(input);
inventory.DateCreated = DateTime.Now;
inventory.Status = "Active";
_context.Inventory.Add(inventory);
await _context.SaveChangesAsync();
}
public async Task<IEnumerable<ItemDto>> GetInventories()
{
var get = await (from i in context.Inventories
join c in context.ItemCatogaries on i.ItemCatogaryId equals c.Id
join l in context.ItemLocations on i.ItemLocationId equals l.Id
join m in context.Unitmesurements on i.UnitmesurementId equals m.Id
select new ItemDto { Id= i.Id, ItemName=i.ItemName, ExpireDate=i.ExpireDate, QTY=i.QTY, Brand=i.Brand, ItemCost= i.ItemCost, RetailPrice=i.RetailPrice, CatogaryName=c.CatogaryName, LocationName=l.LocationName, Position=l.Position, mesurementName= m.mesurementName, CatogaryID=c.Id, LocationID=l.Id, mesurementID=m.Id }).ToListAsync(); ;
InventoryDto dto = new InventoryDto();
return get;
}
/// <summary>
/// 查询借用详情
/// 这个函数就是根据资产记录表里面的序号值来查询资产借出概要信息和资产借出详情里面的资产项
/// 涉及到两张表：assets_borrow资产概要信息表和assets_borrow_detail资产详情
/// </summary>
/// <param name="inventoryId">这个参数是资产借出记录表里面的序号</param>
/// <returns></returns>
public InventoryDto QueryInventory(int inventoryId) // BorrowDto是自定义的一个类，这个类包含了前端要显示的所有数据，前端要提取概要信息和资产借出详情里面的资产项，所以打开BorrowDto
{
var result = new InventoryDto(); // 创建一个对象，这个对象包含了前台要的所有信息
result.InventoryInfo = _inventoryRep.Find(inventoryId); // 前台的资产概要信息可以直接调用仓储_borrowRep中的Find来实现，这里你可以直接照着写
if (null != result.InventoryInfo)
{
result.Details = _inventoryDetailRep.QueryDto(inventoryId); // 这个就是用来找出资产详情里面的资产项，你也可以照着写
}
return(result);
}
protected virtual async Task Update(InventoryDto input)
{
var tags = await _context.Inventory.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (tags != null)
{
Inventory tagDto = MappingProfile.MappingConfigurationSetups().Map <Inventory>(input);
_context.Inventory.Update(tagDto);
await _context.SaveChangesAsync();
}
}
public async Task CreateOrEditInventory(InventoryDto input)
{
if (input.Id == null || input.Id == 0)
{
await Create(input);
}
else
{
await Update(input);
}
}
public async Task <bool> DeleteFromInventoryAsync(InventoryDto inventory, ItemDto item)
{
using (var uow = UnitOfWorkProvider.Create())
{
var invItem = await _inventoryItemsService.GetAsync(inventory.Id, item.Id);
_inventoryItemsService.Delete(invItem.Id);
await uow.Commit();
return(true);
}
}
private InventoryDto MapFromForm()
{
var inventory = new InventoryDto()
{
Errors = MapErrors(),
Name = name.Text,
Price = price.Text.ToDouble(),
BandId = AccountHelper.GetInstance().Id
};
return(inventory);
}
public static Inventory FromDto(InventoryDto dto)
{
return(new Inventory
{
Description = dto.Description,
EndDate = dto.EndDate,
StartDate = dto.StartDate,
Id = dto.Id,
InventorySatus = new InventoryStatus().GetById(dto.StatusId),
ZoneId = dto.ZoneId
});
}
public void InventoryServiceUpdate_UnitOfWorkUpdateAndComplete_ReturnsUnitOfWorkUpdateAndComplete()
{
var inventoryDto = new InventoryDto()
{
Name = "Test"
};
var entity = Mapper.Map <InventoryDto, Inventory>(inventoryDto);
_inventoryService.Update(inventoryDto);
_uow.Received().Inventories.Update(entity);
_uow.Received().Complete();
}
public async Task <Result <InventoryDto> > CreateInventoryAsync(InventoryPostDto inventory)
{
var result = await _inventoryRepository.CreateInventoryAsync(inventory);
var mappedResult = new InventoryDto
{
Id = result.Value.Id,
CompanyId = result.Value.CompanyId,
Name = result.Value.Name
};
return(Result.Ok(mappedResult));
}
public async Task <IActionResult> GetInventory(Guid id)
{
Inventory inventoryFromRepo = await _inventoryRepository.GetInventory(id);
if (inventoryFromRepo == null)
{
return(BadRequest());
}
InventoryDto inventory = _mapper.Map <InventoryDto>(inventoryFromRepo);
return(Ok(inventory));
}
public async Task <InventoryDto> GetInventoryForEdit(InventoryDto input)
{
var users = await _context.Inventory.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (users != null)
{
Inventory tagDto = MappingProfile.MappingConfigurationSetups().Map <Inventory>(input);
_context.Inventory.Update(tagDto);
await _context.SaveChangesAsync();
return(MappingProfile.MappingConfigurationSetups().Map <InventoryDto>(tagDto));
}
return(new InventoryDto());
}
/// <summary>
/// Initialize the Inventory with a saved inventory.
/// </summary>
/// <param name="inventoryDto">The saved inventory to load.</param>
public void Initialize(InventoryDto inventoryDto)
{
for (int i = 0; i < Items.Length; i++)
{
if (inventoryDto.ItemDtos[i].ID != "-1")
{
Items[i] = new Item(ItemManager.Instance.GetItemData(inventoryDto.ItemDtos[i].ID), inventoryDto.ItemDtos[i].Amount);
}
else
{
Items[i] = null;
}
}
}
public ErrorDto AddInventory(InventoryDto inventory)
{
using (var db = new MusicBandAppEntities())
{
db.PopisOpreme.Add(new PopisOpreme()
{
naziv = inventory.Name,
cijena = inventory.Price,
id_bend = inventory.BandId
});
db.SaveChanges();
return(new ErrorDto());
}
}
public void Update(InventoryDto entityDto)
{
try
{
var entity = Mapper.Map <InventoryDto, Inventory>(entityDto);
_unitOfWork.Inventories.Update(entity);
_unitOfWork.Complete();
}
catch (Exception)
{
// TODO lav exception
throw;
}
}
public static string UpdateInventory(InventoryDto inventory)
{
var sql = $@"UPDATE INVENTORY SET END_DATE = ";
if (inventory.EndDate == null)
{
sql += " NULL ";
}
else
{
sql += $" '{inventory.EndDate?.ToString("yyyy-MM-dd hh:mm:ss")}' ";
}
sql += $", DESCRIPTION = '{inventory.Description}', STATUS_ID = {inventory.StatusId},ZONE_ID = {inventory.ZoneId} WHERE ID = {inventory.Id}";
return(sql);
}
public SimpleResponse Delete(InventoryDto dto)
{
var response = new SimpleResponse();
try
{
var model = SimpleMapper.Map <InventoryDto, InventoryViewModel>(dto);
response = iInventoryBusiness.Delete(model);
}
catch (Exception ex)
{
response.ResponseCode = BusinessResponseValues.InternalError;
response.ResponseMessage = "Silme iþleminde hata oluþtu.";
SimpleFileLogger.Instance.Error(ex);
}
return(response);
}
public async Task<Inventory> PostInventory(InventoryDto inventoryDto)
{
var finalitem = mapper.Map<Inventory>(inventoryDto);
try
{
await context.Inventories.AddAsync(finalitem);
await context.SaveChangesAsync();
var item = await GetInventoryById(finalitem.Id);
return item;
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void SaveInventory_test()
{
Inventory inventory = new Inventory(3);
List <Item> initial = new List <Item> {
new Item(GetItemDataFixture(1), 20),
new Item(GetItemDataFixture(3), 1),
new Item(GetItemDataFixture(3), 1)
};
inventory.AddItemsToInventory(initial, out _);
InventoryDto inventoryDto = new InventoryDto(inventory);
Assert.That(inventoryDto.ItemDtos[0].Amount, Is.EqualTo(20));
Assert.That(inventoryDto.ItemDtos[1].Amount, Is.EqualTo(1));
Assert.That(inventoryDto.ItemDtos[2].Amount, Is.EqualTo(1));
}
public async Task <IActionResult> Post([FromBody] InventoryBindingModel inventoryBindingModel)
{
_logger.LogInformation($"Posting a new inventory.");
var inventoryDto = new InventoryDto
{
Location = inventoryBindingModel.Location,
DateOfInventory = inventoryBindingModel.DateOfInventory,
Identifier = inventoryBindingModel.Identifier,
Tags = inventoryBindingModel.Tags
};
await _inventoryService.InsertInventoryAsync(inventoryDto);
_logger.LogInformation($"Posting of the new inventory finished.");
return(Ok());
}
public IHttpActionResult GetInventory(int id)
{
Inventory i = db.Inventories.Include(mbox => mbox.Category).Include(m => m.Location)
.Include(m => m.Files).FirstOrDefault(m => m.Id == id);
InventoryDto InvDto = new InventoryDto
{
Id = i.Id,
Name = i.Name,
CategoryName = i.Category.Name,
LocationName = i.Location.Name,
Date = i.Date,
DetailStatus = i.DetailStatus,
Latit = i.Latit,
Long = i.Long,
LongDetail = i.LongDetail,
MadeBy = i.MadeBy,
Material = i.Material,
ObjectCode = i.ObjectCode,
OriginOf = i.OriginOf,
ShortDetail = i.ShortDetail,
size = i.size,
UpdatedAt = i.UpdatedAt,
UpdatedBy = i.UpdatedBy,
Thumbnail = "ninc.gov.np/meseum/Admin/Images/Inventories/Thumb/" + i.Id.ToString() + ".jpg",
Files = (from f in i.Files
select new Files
{
Name = f.Name,
path = f.path.Replace("~", "ninc.gov.np/meseum"),
Id = f.Id,
Size = f.Size,
Type = f.Type
}).AsEnumerable()
};
if (i == null)
{
return(NotFound());
}
return(Ok(InvDto));
}
public async Task <bool> AddToInventoryAsync(InventoryDto inventory, ItemDto item)
{
if (inventory.IsFull)
{
return(false);
}
using (var uow = UnitOfWorkProvider.Create())
{
var invItem = new InventoryItemsDto()
{
InventoryId = inventory.Id, ItemId = item.Id
};
invItem.Id = _inventoryItemsService.Create(invItem);
await uow.Commit();
return(true);
}
}
private InventoryDto ParseInventory()
{
var playerName = _logParser.ParsePlayerName();
var playerInventory = _logParser.ParsePlayerInventory();
var dto = new InventoryDto
{
PlayerName = playerName,
WildcardCommon = playerInventory.WcCommon,
WildcardUncommon = playerInventory.WcUncommon,
WildcardRare = playerInventory.WcRare,
WildcardMythic = playerInventory.WcMythic,
Gold = playerInventory.Gold,
Gems = playerInventory.Gems,
VaultProgress = playerInventory.VaultProgress,
};
return(dto);
}