添加采购订单
在领域共享项目中添加常量
在 Domain.Shared 项目中添加文件夹Purchase，在文件夹下添加类PurchaseConsts.cs，添加以下代码：
public static class PurchaseConsts
{
public const int MaxPoNumLength = 20;
public const int MaxItemNumLength = 50;
/// <summary>
/// 订单已存在异常代码
/// </summary>
public const string PurchaseOrderAlreadyExists = "PurchaseOrder:00001";
/// <summary>
/// 订单不存在异常代码
/// </summary>
public const string PurchaseOrderNotExists = "PurchaseOrder:00002";
/// <summary>
/// 订单明细已存在异常代码
/// </summary>
public const string PurchaseOrderItemAlreadyExists = "PurchaseOrder:00003";
/// <summary>
/// 订单名称不存在异常代码
/// </summary>
public const string PurchaseOrderItemNotExists = "PurchaseOrder:00004";
}
添加领域实体
添加实体
在 Domain 项目中添加文件夹 Purchase，在文件夹中添加实体 PurchaseOrder，添加以下代码：
public class PurchaseOrder : FullAuditedAggregateRoot<Guid>
{
public string PoNum { get; private set; } = string.Empty;
public DateTime IDate { get; set; }
public string Buyer { get; set; } = string.Empty;
public string VenName { get; set; } = string.Empty;
public decimal TotalQty { get; internal set; }
public decimal TotalAmount { get; internal set; }
private PurchaseOrder() { }
internal PurchaseOrder(Guid id, string poNum, DateTime idate, [NotNull] string buyer, [NotNull] string venName) : base(id)
{
SetPoNum(poNum);
IDate = idate;
Buyer = buyer;
VenName = venName;
}
internal void UpdatePoNum(string poNum)
{
SetPoNum(poNum);
}
private void SetPoNum(string poNum)
{
PoNum = Check.NotNullOrEmpty(poNum, nameof(poNum), maxLength: PurchaseConsts.MaxPoNumLength);
}
internal PurchaseOrderItem CreateNewItem(Guid itemId, string itemNum, decimal qty, decimal price)
{
var item = new PurchaseOrderItem(Id, itemId, itemNum, qty, price);
TotalQty += item.Qty;
TotalAmount+= item.Amount;
return item;
}
}
添加实体PurchaseOrderItem，添加以下代码：
public class PurchaseOrderItem : FullAuditedAggregateRoot<Guid>
{
public string ItemNum { get; private set; } = string.Empty;
public decimal Qty { get; private set; }
public decimal Price { get; private set; }
public decimal Amount { get; private set; }
public Guid PurchaseOrderId { get; private set; }
private PurchaseOrderItem() { }
internal PurchaseOrderItem(Guid purchaseOrderId,Guid id,string itemNum,decimal qty,decimal price):base(id)
{
PurchaseOrderId= purchaseOrderId;
SetItemNum(itemNum);
UpdateQty(qty);
UpdatePrice(price);
}
internal void UpdateQty(decimal qty)
{
Qty = qty;
ResetAmount();
}
internal void UpdatePrice(decimal price)
{
Price = price;
ResetAmount();
}
internal void ResetAmount()
{
Amount = Qty * Price;
}
internal void UpdateItemNum([NotNull] string itemNum)
{
SetItemNum(itemNum);
}
private void SetItemNum([NotNull] string itemNum)
{
ItemNum = Check.NotNullOrEmpty(itemNum,nameof(itemNum),maxLength:PurchaseConsts.MaxItemNumLength);
}
}
添加领域服务
在 Domain 项目的文件夹 Purchase下添加类PurchaseOrderManage.cs，并添加以下代码：
public class PurchaseOrderManage : DomainService
{
private readonly IRepository<PurchaseOrder, Guid> _purchaseOrderRepository;
private readonly IRepository<PurchaseOrderItem, Guid> _purchaseOrderItemRepository;
public PurchaseOrderManage(IRepository<PurchaseOrder, Guid> purchaseOrderRepository, IRepository<PurchaseOrderItem, Guid> purchaseOrderItemRepository)
{
_purchaseOrderRepository = purchaseOrderRepository;
_purchaseOrderItemRepository = purchaseOrderItemRepository;
}
public async Task<PurchaseOrder> CreateAsync([NotNull] string poNum, [NotNull] DateTime iDate, [NotNull] string buyer, [NotNull] string venName)
{
Check.NotNullOrWhiteSpace(poNum, nameof(poNum));
Check.NotNull(iDate, nameof(iDate));
Check.NotNullOrWhiteSpace(buyer, nameof(buyer));
Check.NotNullOrWhiteSpace(venName, nameof(venName));
var po = await _purchaseOrderRepository.FindAsync(p => p.PoNum.Equals(poNum));
if (po != null)
{
throw new PurchaseOrderAlreadyExistsException(poNum);
}
return new PurchaseOrder(GuidGenerator.Create(), poNum, iDate, buyer, venName);
}
public async Task UpdatePoNum([NotNull] PurchaseOrder purchaseOrder, [NotNull] string poNum)
{
Check.NotNull(purchaseOrder, nameof(purchaseOrder));
Check.NotNullOrWhiteSpace(poNum, nameof(poNum));
var exstingPurchaseOrder = await _purchaseOrderRepository.FindAsync(p => p.PoNum.Equals(poNum));
if (exstingPurchaseOrder != null && exstingPurchaseOrder.Id != purchaseOrder.Id)
{
throw new PurchaseOrderAlreadyExistsException(poNum);
}
purchaseOrder.UpdatePoNum(poNum);
}
public PurchaseOrderItem AddPurchaseOrderItem([NotNull] PurchaseOrder purchaseOrder, string itemNum, decimal qty, decimal price)
{
Check.NotNull(purchaseOrder, nameof(purchaseOrder));
Check.NotNullOrWhiteSpace(itemNum, nameof(itemNum));
var item = purchaseOrder.CreateNewItem(GuidGenerator.Create(), itemNum, qty, price);
return item;
}
public async Task<PurchaseOrder> UpdatePurchaseOrderItem([NotNull] PurchaseOrderItem purchaseOrderItem, string itemNum, decimal qty, decimal price)
{
Check.NotNull(purchaseOrderItem, nameof(purchaseOrderItem));
var differenceQty = qty - purchaseOrderItem.Qty;
var diferenceAmount = qty * price - purchaseOrderItem.Amount;
purchaseOrderItem.UpdateItemNum(itemNum);
purchaseOrderItem.UpdateQty(qty);
purchaseOrderItem.UpdatePrice(price);
var po = await _purchaseOrderRepository.FindAsync(purchaseOrderItem.PurchaseOrderId);
po.TotalQty += differenceQty;
po.TotalAmount += diferenceAmount;
return po;
}
public async Task<PurchaseOrder> RemovePurchaseOrderItem([NotNull] PurchaseOrderItem purchaseOrderItem)
{
Check.NotNull(purchaseOrderItem, nameof(purchaseOrderItem));
var po = await _purchaseOrderRepository.FindAsync(purchaseOrderItem.PurchaseOrderId);
po.TotalQty -= purchaseOrderItem.Qty;
po.TotalAmount -= purchaseOrderItem.Amount;
return po;
}
public async Task ResetPurchaseOrderTotalQtyTotalAmountAsync([NotNull] PurchaseOrder purchaseOrder)
{
Check.NotNull(purchaseOrder, nameof(purchaseOrder));
await ResetPurchaseOrderTotalQtyAsync(purchaseOrder);
await ResetPurchaseOrderTotalAmountAsync(purchaseOrder);
}
public async Task ResetPurchaseOrderTotalQtyAsync([NotNull] PurchaseOrder purchaseOrder)
{
Check.NotNull(purchaseOrder, nameof(purchaseOrder));
var query = await _purchaseOrderItemRepository.GetQueryableAsync();
var totalQty = query
.Where(p=>p.PurchaseOrderId.Equals(purchaseOrder.Id))
.Sum(p => p.Qty);
purchaseOrder.TotalQty = totalQty;
}
public async Task ResetPurchaseOrderTotalAmountAsync([NotNull] PurchaseOrder purchaseOrder)
{
Check.NotNull(purchaseOrder, nameof(purchaseOrder));
var query = await _purchaseOrderItemRepository.GetQueryableAsync();
var totalAmount = query
.Where(p => p.PurchaseOrderId.Equals(purchaseOrder.Id))
.Sum(p => p.Amount);
purchaseOrder.TotalAmount = totalAmount;
}
}
添加异常类PurchaseOrderAlreadyExistsException.cs、PurchaseOrderNotExistsException.cs，代码如下：
public class PurchaseOrderAlreadyExistsException : BusinessException
{
public PurchaseOrderAlreadyExistsException(string poNum) : base(PurchaseConsts.PurchaseOrderAlreadyExists)
{
WithData("poNum", poNum);
}
}
public class PurchaseOrderNotExistsException: BusinessException
{
public PurchaseOrderNotExistsException(Guid id) : base(PurchaseConsts.PurchaseOrderNotExists)
{
WithData("id", id);
}
}
数据库配置
添加数据库配置常量
在项目EntityFrameworkCore中添加类MyDbContextConsts.cs，添加以下代码：
public static class MyDbContextConsts
{
public const string DbTablePrefix = "Study";
public const string DbSchema = null;
}
添加数据库上下文
在项目EntityFrameworkCore中添加类MyDbContext.cs，添加以下代码：
[ConnectionStringName("Default")]
public class MyDbContext : AbpDbContext<MyDbContext>
{
public MyDbContext(DbContextOptions<MyDbContext> options) : base(options)
{
}
public DbSet<PurchaseOrder> PurchaseOrders { get; set; }
public DbSet<PurchaseOrderItem> PurchaseOrderItems { get; set; }
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<PurchaseOrder>(p =>
{
p.ToTable(MyDbContextConsts.DbTablePrefix + "_PurchaseOrders", MyDbContextConsts.DbSchema);
p.ConfigureByConvention();
p.Property(x => x.PoNum)
.IsRequired()
.HasMaxLength(PurchaseConsts.MaxPoNumLength);
});
modelBuilder.Entity<PurchaseOrderItem>(p =>
{
p.ToTable(MyDbContextConsts.DbTablePrefix+"_PurchaseOrderItems",MyDbContextConsts.DbSchema);
p.ConfigureByConvention();
p.Property(x=>x.ItemNum)
.IsRequired()
.HasMaxLength(PurchaseConsts.MaxItemNumLength);
p.HasOne<PurchaseOrder>()
.WithMany()
.HasForeignKey(x => x.PurchaseOrderId)
.IsRequired();
});
}
}
在EntityFrameworkCoreModule.cs添加以下代码：
// 添加数据库上下文
context.Services.AddAbpDbContext<MyDbContext>(options =>
{
options.AddDefaultRepositories(includeAllEntities: true);
});
完整代码：
[DependsOn(
typeof(AbpEntityFrameworkCoreSqlServerModule)
)]
public class EntityFrameworkCoreModule:AbpModule
{
public override void ConfigureServices(ServiceConfigurationContext context)
{
base.ConfigureServices(context);
// 添加数据库上下文
context.Services.AddAbpDbContext<MyDbContext>(options =>
{
options.AddDefaultRepositories(includeAllEntities: true);
});
// 配置使用 SqlServer
Configure<AbpDbContextOptions>(options =>
{
options.UseSqlServer();
});
}
}
应用层约定
添加数据传输对象
public class CreatePurchaseOrderDto
{
[Required]
[StringLength(PurchaseConsts.MaxPoNumLength)]
public string PoNum { get; set; }
[Required]
public DateTime IDate { get; set; }
[Required]
public string Buyer { get; set; }
[Required]
public string VenName { get; set; }
}
public class CreatePurchaseOrderAndDetailDto: CreatePurchaseOrderDto
{
public IList<DetailItemDto> Details { get; set; }
public class DetailItemDto
{
[Required]
[StringLength(PurchaseConsts.MaxItemNumLength)]
public string ItemNum { get; set; }
[Required]
public decimal Qty { get; set; }
[Required]
public decimal Price { get; set; }
}
}
public class CreatePurchaseOrderDetailDto
{
[Required]
public Guid PurchaseOrderId { get; set; }
[Required]
[StringLength(PurchaseConsts.MaxItemNumLength)]
public string ItemNum { get; set; }
[Required]
public decimal Qty { get; set; }
[Required]
public decimal Price { get; set; }
}
public class GetPurchaseOrderListDto:PagedAndSortedResultRequestDto
{
public DateTime? BeginIDate { get; set; }
public DateTime? EndIDate { get; set;}
public string? VenName { get; set; }
public string? PoNum { get; set; }
public string? Buyer { get;}
}
public class PurchaseOrderDto
{
public Guid Id { get; set; }
public string PoNum { get; set; }
public DateTime IDate { get; set; }
public string Buyer { get; set; }
public string VenName { get; set; }
public decimal TotalQty { get; set; }
public decimal TotalAmount { get; set; }
}
public class PurchaseOrderDetailDto
{
public Guid Id { get; set; }
public string PonNum { get; set; }
public string ItemNum { get; set; }
public decimal Qty { get; set; }
public decimal Price { get; set; }
public decimal Amount { get; set; }
public Guid PurchaseOrderId { get; set; }
}
public class PurchaseOrderAndDetailDto: PurchaseOrderDto
{
public IList<PurchaseOrderDetailDto> Details { get; set; }
}
public class UpdatePurchaseOrderDetailDto
{
[Required]
[StringLength(PurchaseConsts.MaxItemNumLength)]
public string ItemNum { get; set; }
[Required]
public decimal Qty { get; set; }
[Required]
public decimal Price { get; set; }
}
public class UpdatePurchaseOrderDto
{
[Required]
[StringLength(PurchaseConsts.MaxPoNumLength)]
public string PoNum { get; set; }
[Required]
public DateTime IDate { get; set; }
[Required]
public string Buyer { get; set; }
[Required]
public string VenName { get; set; }
}
添加应用服务接口
public interface IPurchaseOrderService:IApplicationService
{
Task<PurchaseOrderAndDetailDto> GetAsync(Guid id);
Task<PurchaseOrderDetailDto> GetDetailAsync(Guid id);
Task<PagedResultDto<PurchaseOrderDto>> GetListAsync(GetPurchaseOrderListDto input);
Task<List<PurchaseOrderDetailDto>> GetDetailListAsync(Guid id);
Task<PurchaseOrderAndDetailDto> CreatePurchaseOrderAndDetailAsync(CreatePurchaseOrderAndDetailDto createPurchaseOrderAndDetail);
Task<PurchaseOrderDto> CreatePurchaseOrderAsync(CreatePurchaseOrderDto createPurchaseOrder);
Task UpdatePurchaseOrderAsync(Guid id,UpdatePurchaseOrderDto updatePurchaseOrder);
Task DeletePurchaseOrderAsync(Guid id);
Task<PurchaseOrderDetailDto> CreatePurchaseOrderDetail(CreatePurchaseOrderDetailDto createPurchaseOrderDetail);
Task UpdatePurchaseOrderDetailAsync(Guid id, UpdatePurchaseOrderDetailDto updatePurchaseOrder);
Task DeletePurchaseOrderDetailAsync(Guid id);
}
应用层
实现应用服务
/// <summary>
/// 应用层服务基类
/// </summary>
public abstract class ApplicationAppService:ApplicationService
{
protected ApplicationAppService()
{
// 配置本地资源
LocalizationResource = typeof(MyLocalizationResource);
}
}
public class PurchaseOrderService : ApplicationAppService, IPurchaseOrderService
{
private readonly IRepository<Domain.Purchase.PurchaseOrder, Guid> _repository;
private readonly IRepository<PurchaseOrderItem, Guid> _itemRepository;
private readonly PurchaseOrderManage _purchaseOrderManage;
public PurchaseOrderService(IRepository<Domain.Purchase.PurchaseOrder, Guid> repository, IRepository<PurchaseOrderItem, Guid> itemRepository, PurchaseOrderManage purchaseOrderManage)
{
_repository = repository;
_itemRepository = itemRepository;
_purchaseOrderManage = purchaseOrderManage;
}
public async Task<PurchaseOrderAndDetailDto> CreatePurchaseOrderAndDetailAsync(CreatePurchaseOrderAndDetailDto createPurchaseOrderAndDetail)
{
Check.NotNull(createPurchaseOrderAndDetail, nameof(createPurchaseOrderAndDetail));
var details = new List<Domain.Purchase.PurchaseOrderItem>();
var po = await _purchaseOrderManage.CreateAsync(createPurchaseOrderAndDetail.PoNum, createPurchaseOrderAndDetail.IDate, createPurchaseOrderAndDetail.Buyer, createPurchaseOrderAndDetail.VenName);
foreach (var item in createPurchaseOrderAndDetail.Details)
{
details.Add(_purchaseOrderManage.AddPurchaseOrderItem(po, item.ItemNum, item.Qty, item.Price));
}
/**
对资源库数据的多次修改是在一个事务中进行的，详情请见
https://docs.abp.io/zh-Hans/abp/latest/Unit-Of-Work
*/
await _repository.InsertAsync(po);
await _itemRepository.InsertManyAsync(details);
await _purchaseOrderManage.ResetPurchaseOrderTotalQtyTotalAmountAsync(po);
await _repository.UpdateAsync(po);
// 在单元工作结束而没有任何异常是，所有的数据库更改都会自动保存，因此无需手动调用 SaveChangesAsync
//await UnitOfWorkManager.Current.SaveChangesAsync();
return await GetAsync(po.Id);
}
public async Task<PurchaseOrderDto> CreatePurchaseOrderAsync(CreatePurchaseOrderDto createPurchaseOrder)
{
Check.NotNull(createPurchaseOrder, nameof(createPurchaseOrder));
var po = await _purchaseOrderManage.CreateAsync(createPurchaseOrder.PoNum, createPurchaseOrder.IDate, createPurchaseOrder.Buyer, createPurchaseOrder.VenName);
po = await _repository.InsertAsync(po);
return ObjectMapper.Map<Domain.Purchase.PurchaseOrder,PurchaseOrderDto>(po);
}
public async Task<PurchaseOrderDetailDto> CreatePurchaseOrderDetail(CreatePurchaseOrderDetailDto createPurchaseOrderDetail)
{
Check.NotNull(createPurchaseOrderDetail, nameof(createPurchaseOrderDetail));
var po = await GetPurchaseOrderAndChecked(createPurchaseOrderDetail.PurchaseOrderId);
var item = _purchaseOrderManage.AddPurchaseOrderItem(po, createPurchaseOrderDetail.ItemNum, createPurchaseOrderDetail.Qty, createPurchaseOrderDetail.Price);
await _itemRepository.InsertAsync(item);
await _purchaseOrderManage.ResetPurchaseOrderTotalQtyTotalAmountAsync(po);
await _repository.UpdateAsync(po);
return ObjectMapper.Map<PurchaseOrderItem, PurchaseOrderDetailDto>(item);
}
public async Task DeletePurchaseOrderAsync(Guid id)
{
await _repository.DeleteAsync(id);
}
public async Task DeletePurchaseOrderDetailAsync(Guid id)
{
var item = await GetPurchaseOrderItemAndChecked(id);
var po = await GetPurchaseOrderAndChecked(item.PurchaseOrderId);
await _itemRepository.DeleteAsync(id);
await _purchaseOrderManage.ResetPurchaseOrderTotalQtyTotalAmountAsync(po);
}
public async Task<PurchaseOrderAndDetailDto> GetAsync(Guid id)
{
var purchaseOrder = await _repository.GetAsync(id);
var dto = ObjectMapper.Map<Domain.Purchase.PurchaseOrder, PurchaseOrderAndDetailDto>(purchaseOrder);
dto.Details = await GetDetailListAsync(dto.Id);
return dto;
}
public async Task<PurchaseOrderDetailDto> GetDetailAsync(Guid id)
{
var detail = await _itemRepository.FindAsync(id);
return ObjectMapper.Map<PurchaseOrderItem, PurchaseOrderDetailDto>(detail);
}
public async Task<List<PurchaseOrderDetailDto>> GetDetailListAsync(Guid id)
{
var query = await _itemRepository.GetQueryableAsync();
var details = query.Where(x => x.PurchaseOrderId == id).ToList();
return ObjectMapper.Map<List<PurchaseOrderItem>, List<PurchaseOrderDetailDto>>(details);
}
public async Task<PagedResultDto<PurchaseOrderDto>> GetListAsync(GetPurchaseOrderListDto input)
{
if (input.Sorting.IsNullOrWhiteSpace())
{
input.Sorting = nameof(Domain.Purchase.PurchaseOrder.PoNum);
}
var query = await _repository.GetQueryableAsync();
query = query.WhereIf(input.BeginIDate.HasValue, p => p.IDate >= input.BeginIDate)
.WhereIf(input.EndIDate.HasValue, p => p.IDate <= input.EndIDate)
.WhereIf(!string.IsNullOrWhiteSpace(input.VenName), p => p.VenName.Contains(input.VenName == null ? string.Empty : input.VenName))
.WhereIf(!string.IsNullOrWhiteSpace(input.PoNum), p => p.PoNum.Contains(input.PoNum == null ? string.Empty : input.PoNum))
.WhereIf(!string.IsNullOrWhiteSpace(input.Buyer), p => p.PoNum.Contains(input.Buyer == null ? string.Empty : input.Buyer))
.OrderBy(input.Sorting)
.Skip(input.SkipCount)
.Take(input.MaxResultCount);
var queryResult = await AsyncExecuter.ToListAsync(query);
var totalCount = await _repository.GetCountAsync();
return new PagedResultDto<PurchaseOrderDto>(totalCount, ObjectMapper.Map<List<Domain.Purchase.PurchaseOrder>, List<PurchaseOrderDto>>(queryResult));
}
public async Task UpdatePurchaseOrderAsync(Guid id, UpdatePurchaseOrderDto updatePurchaseOrder)
{
var po = await GetPurchaseOrderAndChecked(id);
po.Buyer = updatePurchaseOrder.Buyer;
po.VenName = updatePurchaseOrder.VenName;
po.IDate = updatePurchaseOrder.IDate;
await _purchaseOrderManage.UpdatePoNum(po, updatePurchaseOrder.PoNum);
_ = await _repository.UpdateAsync(po);
}
public async Task UpdatePurchaseOrderDetailAsync(Guid id, UpdatePurchaseOrderDetailDto updatePurchaseOrder)
{
var item = await GetPurchaseOrderItemAndChecked(id);
var po = await GetPurchaseOrderAndChecked(item.PurchaseOrderId);
await _purchaseOrderManage.UpdatePurchaseOrderItem(item, updatePurchaseOrder.ItemNum, updatePurchaseOrder.Qty, updatePurchaseOrder.Price);
await _itemRepository.UpdateAsync(item);
await _purchaseOrderManage.ResetPurchaseOrderTotalQtyTotalAmountAsync(po);
await _repository.UpdateAsync(po);
}
private async Task<Domain.Purchase.PurchaseOrder> GetPurchaseOrderAndChecked(Guid id)
{
var po = await _repository.FindAsync(id);
if (po == null)
{
throw new PurchaseOrderNotExistsException(id);
}
return po;
}
private async Task<Domain.Purchase.PurchaseOrderItem> GetPurchaseOrderItemAndChecked(Guid id)
{
var item = await _itemRepository.FindAsync(id);
if (item == null)
{
var ex = new BusinessException(PurchaseConsts.PurchaseOrderItemNotExists);
ex.WithData("id", id);
throw ex;
}
return item;
}
}