bcc6976bd0
Some checks are pending
CI / POS (WPF, Windows) (push) Waiting to run
CI / Backend (.NET 8) (push) Successful in 46s
CI / Web (React + Vite) (push) Successful in 34s
Docker API / Build + push API (push) Successful in 40s
Docker Web / Build + push Web (push) Successful in 27s
Docker API / Deploy API on stage (push) Successful in 17s
Docker Web / Deploy Web on stage (push) Successful in 11s
PriceType: убран флаг IsDefault — он семантически дублировал IsSystem
(защищённая запись «по умолчанию»). Остаются IsSystem / IsRequired /
IsRetail.
- Domain.Catalog.PriceType: удалено поле IsDefault.
- Миграция Phase3b_DropPriceTypeIsDefault: DROP COLUMN.
- DTO/Input (PriceTypeDto, PriceTypeInput) — без IsDefault.
- PriceTypesController:
• убрана логика uniqueness IsDefault на Create/Update,
• IsRetail теперь enforce'ит уникальность: при установке IsRetail=true
у других записей сбрасывается,
• при удалении единственной IsRetail записи (если она не системная)
IsRetail автоматически переезжает на IsSystem-запись — у организации
всегда остаётся один POS-кандидат.
- ProductsController.RecalcRetail и SuppliesController.SetDefaultRetail —
поиск дефолтной розничной идёт по IsSystem → IsRetail → SortOrder → Name
(ранее ThenByDescending(IsDefault) — выпилено).
- DevDataSeeder: поле IsDefault убрано.
- web types.ts: убрано isDefault из PriceType.
- PriceTypesPage:
• убран чекбокс «По умолчанию»,
• лейбл «Розничная (используется на кассе)» → «Используется на кассе»,
• Form/blankForm/onRowClick без isDefault.
- ProductsPage / ProductEditPage: фоллбэк дефолтной цены теперь
IsSystem → IsRetail → первая.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
412 lines
18 KiB
C#
412 lines
18 KiB
C#
using System.ComponentModel.DataAnnotations;
|
||
using foodmarket.Application.Common;
|
||
using foodmarket.Application.Inventory;
|
||
using foodmarket.Domain.Inventory;
|
||
using foodmarket.Domain.Purchases;
|
||
using foodmarket.Infrastructure.Persistence;
|
||
using Microsoft.AspNetCore.Authorization;
|
||
using Microsoft.AspNetCore.Mvc;
|
||
using Microsoft.EntityFrameworkCore;
|
||
|
||
namespace foodmarket.Api.Controllers.Purchases;
|
||
|
||
[ApiController]
|
||
[Authorize]
|
||
[Route("api/purchases/supplies")]
|
||
public class SuppliesController : ControllerBase
|
||
{
|
||
private readonly AppDbContext _db;
|
||
private readonly IStockService _stock;
|
||
|
||
public SuppliesController(AppDbContext db, IStockService stock)
|
||
{
|
||
_db = db;
|
||
_stock = stock;
|
||
}
|
||
|
||
public record SupplyListRow(
|
||
Guid Id, string Number, DateTime Date, SupplyStatus Status,
|
||
Guid SupplierId, string SupplierName,
|
||
Guid StoreId, string StoreName,
|
||
Guid CurrencyId, string CurrencyCode,
|
||
decimal Total, int LineCount,
|
||
DateTime? PostedAt);
|
||
|
||
public record SupplyLineDto(
|
||
Guid? Id, Guid ProductId, string? ProductName, string? ProductArticle,
|
||
string? UnitSymbol,
|
||
decimal Quantity, decimal UnitPrice, decimal LineTotal, int SortOrder,
|
||
bool RetailPriceManuallyOverridden, decimal? RetailPriceOverride,
|
||
decimal? CurrentRetailPrice);
|
||
|
||
public record SupplyDto(
|
||
Guid Id, string Number, DateTime Date, SupplyStatus Status,
|
||
Guid SupplierId, string SupplierName,
|
||
Guid StoreId, string StoreName,
|
||
Guid CurrencyId, string CurrencyCode,
|
||
string? SupplierInvoiceNumber, DateTime? SupplierInvoiceDate,
|
||
string? Notes,
|
||
decimal Total, DateTime? PostedAt,
|
||
IReadOnlyList<SupplyLineDto> Lines);
|
||
|
||
public record SupplyLineInput(
|
||
Guid ProductId,
|
||
[Range(0, 1e10)] decimal Quantity,
|
||
[Range(0, 1e10)] decimal UnitPrice,
|
||
bool RetailPriceManuallyOverridden = false,
|
||
[Range(0, 1e10)] decimal? RetailPriceOverride = null);
|
||
public record SupplyInput(
|
||
DateTime Date, Guid SupplierId, Guid StoreId, Guid CurrencyId,
|
||
string? SupplierInvoiceNumber, DateTime? SupplierInvoiceDate,
|
||
string? Notes,
|
||
IReadOnlyList<SupplyLineInput> Lines);
|
||
|
||
[HttpGet]
|
||
public async Task<ActionResult<PagedResult<SupplyListRow>>> List(
|
||
[FromQuery] PagedRequest req,
|
||
[FromQuery] SupplyStatus? status,
|
||
[FromQuery] Guid? storeId,
|
||
[FromQuery] Guid? supplierId,
|
||
CancellationToken ct)
|
||
{
|
||
var q = from s in _db.Supplies.AsNoTracking()
|
||
join cp in _db.Counterparties on s.SupplierId equals cp.Id
|
||
join st in _db.Stores on s.StoreId equals st.Id
|
||
join cu in _db.Currencies on s.CurrencyId equals cu.Id
|
||
select new { s, cp, st, cu };
|
||
|
||
if (status is not null) q = q.Where(x => x.s.Status == status);
|
||
if (storeId is not null) q = q.Where(x => x.s.StoreId == storeId);
|
||
if (supplierId is not null) q = q.Where(x => x.s.SupplierId == supplierId);
|
||
if (!string.IsNullOrWhiteSpace(req.Search))
|
||
{
|
||
var s = req.Search.Trim().ToLower();
|
||
q = q.Where(x => x.s.Number.ToLower().Contains(s) || x.cp.Name.ToLower().Contains(s));
|
||
}
|
||
|
||
var total = await q.CountAsync(ct);
|
||
q = (req.Sort, req.Desc) switch
|
||
{
|
||
("number", false) => q.OrderBy(x => x.s.Number),
|
||
("number", true) => q.OrderByDescending(x => x.s.Number),
|
||
("supplier", false) => q.OrderBy(x => x.cp.Name).ThenByDescending(x => x.s.Date),
|
||
("supplier", true) => q.OrderByDescending(x => x.cp.Name).ThenByDescending(x => x.s.Date),
|
||
("store", false) => q.OrderBy(x => x.st.Name).ThenByDescending(x => x.s.Date),
|
||
("store", true) => q.OrderByDescending(x => x.st.Name).ThenByDescending(x => x.s.Date),
|
||
("status", false) => q.OrderBy(x => x.s.Status).ThenByDescending(x => x.s.Date),
|
||
("status", true) => q.OrderByDescending(x => x.s.Status).ThenByDescending(x => x.s.Date),
|
||
("total", false) => q.OrderBy(x => x.s.Total).ThenByDescending(x => x.s.Date),
|
||
("total", true) => q.OrderByDescending(x => x.s.Total).ThenByDescending(x => x.s.Date),
|
||
("date", false) => q.OrderBy(x => x.s.Date).ThenBy(x => x.s.Number),
|
||
_ => q.OrderByDescending(x => x.s.Date).ThenByDescending(x => x.s.Number),
|
||
};
|
||
var items = await q
|
||
.Skip(req.Skip).Take(req.Take)
|
||
.Select(x => new SupplyListRow(
|
||
x.s.Id, x.s.Number, x.s.Date, x.s.Status,
|
||
x.cp.Id, x.cp.Name,
|
||
x.st.Id, x.st.Name,
|
||
x.cu.Id, x.cu.Code,
|
||
x.s.Total,
|
||
x.s.Lines.Count,
|
||
x.s.PostedAt))
|
||
.ToListAsync(ct);
|
||
|
||
return new PagedResult<SupplyListRow> { Items = items, Total = total, Page = req.Page, PageSize = req.Take };
|
||
}
|
||
|
||
[HttpGet("{id:guid}")]
|
||
public async Task<ActionResult<SupplyDto>> Get(Guid id, CancellationToken ct)
|
||
{
|
||
var dto = await GetInternal(id, ct);
|
||
return dto is null ? NotFound() : Ok(dto);
|
||
}
|
||
|
||
[HttpPost, Authorize(Roles = "Admin,Manager,Storekeeper")]
|
||
public async Task<ActionResult<SupplyDto>> Create([FromBody] SupplyInput input, CancellationToken ct)
|
||
{
|
||
var number = await GenerateNumberAsync(input.Date, ct);
|
||
var allowFractional = await _db.Organizations.Select(o => o.AllowFractionalPrices).FirstOrDefaultAsync(ct);
|
||
var supply = new Supply
|
||
{
|
||
Number = number,
|
||
Date = input.Date,
|
||
Status = SupplyStatus.Draft,
|
||
SupplierId = input.SupplierId,
|
||
StoreId = input.StoreId,
|
||
CurrencyId = input.CurrencyId,
|
||
SupplierInvoiceNumber = input.SupplierInvoiceNumber,
|
||
SupplierInvoiceDate = input.SupplierInvoiceDate,
|
||
Notes = input.Notes,
|
||
};
|
||
|
||
var order = 0;
|
||
foreach (var l in input.Lines)
|
||
{
|
||
var unitPrice = allowFractional ? l.UnitPrice : Math.Round(l.UnitPrice, 0, MidpointRounding.AwayFromZero);
|
||
supply.Lines.Add(new SupplyLine
|
||
{
|
||
ProductId = l.ProductId,
|
||
Quantity = l.Quantity,
|
||
UnitPrice = unitPrice,
|
||
LineTotal = l.Quantity * unitPrice,
|
||
SortOrder = order++,
|
||
RetailPriceManuallyOverridden = l.RetailPriceManuallyOverridden,
|
||
RetailPriceOverride = l.RetailPriceOverride.HasValue
|
||
? (allowFractional ? l.RetailPriceOverride : Math.Round(l.RetailPriceOverride.Value, 0, MidpointRounding.AwayFromZero))
|
||
: null,
|
||
});
|
||
}
|
||
supply.Total = supply.Lines.Sum(x => x.LineTotal);
|
||
|
||
_db.Supplies.Add(supply);
|
||
await _db.SaveChangesAsync(ct);
|
||
var dto = await GetInternal(supply.Id, ct);
|
||
return CreatedAtAction(nameof(Get), new { id = supply.Id }, dto);
|
||
}
|
||
|
||
[HttpPut("{id:guid}"), Authorize(Roles = "Admin,Manager,Storekeeper")]
|
||
public async Task<IActionResult> Update(Guid id, [FromBody] SupplyInput input, CancellationToken ct)
|
||
{
|
||
var supply = await _db.Supplies.Include(s => s.Lines).FirstOrDefaultAsync(s => s.Id == id, ct);
|
||
if (supply is null) return NotFound();
|
||
if (supply.Status != SupplyStatus.Draft)
|
||
return Conflict(new { error = "Только черновик может быть изменён. Сначала отмени проведение." });
|
||
|
||
supply.Date = input.Date;
|
||
supply.SupplierId = input.SupplierId;
|
||
supply.StoreId = input.StoreId;
|
||
supply.CurrencyId = input.CurrencyId;
|
||
supply.SupplierInvoiceNumber = input.SupplierInvoiceNumber;
|
||
supply.SupplierInvoiceDate = input.SupplierInvoiceDate;
|
||
supply.Notes = input.Notes;
|
||
|
||
// Replace lines wholesale (simple, idempotent).
|
||
_db.SupplyLines.RemoveRange(supply.Lines);
|
||
supply.Lines.Clear();
|
||
var allowFractional = await _db.Organizations.Select(o => o.AllowFractionalPrices).FirstOrDefaultAsync(ct);
|
||
var order = 0;
|
||
foreach (var l in input.Lines)
|
||
{
|
||
var unitPrice = allowFractional ? l.UnitPrice : Math.Round(l.UnitPrice, 0, MidpointRounding.AwayFromZero);
|
||
supply.Lines.Add(new SupplyLine
|
||
{
|
||
SupplyId = supply.Id,
|
||
ProductId = l.ProductId,
|
||
Quantity = l.Quantity,
|
||
UnitPrice = unitPrice,
|
||
LineTotal = l.Quantity * unitPrice,
|
||
SortOrder = order++,
|
||
RetailPriceManuallyOverridden = l.RetailPriceManuallyOverridden,
|
||
RetailPriceOverride = l.RetailPriceOverride.HasValue
|
||
? (allowFractional ? l.RetailPriceOverride : Math.Round(l.RetailPriceOverride.Value, 0, MidpointRounding.AwayFromZero))
|
||
: null,
|
||
});
|
||
}
|
||
supply.Total = supply.Lines.Sum(x => x.LineTotal);
|
||
|
||
await _db.SaveChangesAsync(ct);
|
||
return NoContent();
|
||
}
|
||
|
||
[HttpDelete("{id:guid}"), Authorize(Roles = "Admin,Manager,Storekeeper")]
|
||
public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
|
||
{
|
||
var supply = await _db.Supplies.FirstOrDefaultAsync(s => s.Id == id, ct);
|
||
if (supply is null) return NotFound();
|
||
if (supply.Status != SupplyStatus.Draft)
|
||
return Conflict(new { error = "Нельзя удалить проведённый документ. Сначала отмени проведение." });
|
||
_db.Supplies.Remove(supply);
|
||
await _db.SaveChangesAsync(ct);
|
||
return NoContent();
|
||
}
|
||
|
||
[HttpPost("{id:guid}/post"), Authorize(Roles = "Admin,Manager,Storekeeper")]
|
||
public async Task<IActionResult> Post(Guid id, CancellationToken ct)
|
||
{
|
||
var supply = await _db.Supplies.Include(s => s.Lines).FirstOrDefaultAsync(s => s.Id == id, ct);
|
||
if (supply is null) return NotFound();
|
||
if (supply.Status == SupplyStatus.Posted) return Conflict(new { error = "Документ уже проведён." });
|
||
if (supply.Lines.Count == 0) return BadRequest(new { error = "Нельзя провести документ без строк." });
|
||
|
||
var allowFractional = await _db.Organizations.Select(o => o.AllowFractionalPrices).FirstOrDefaultAsync(ct);
|
||
|
||
await using var tx = await _db.Database.BeginTransactionAsync(ct);
|
||
var now = DateTime.UtcNow;
|
||
|
||
foreach (var line in supply.Lines)
|
||
{
|
||
var product = await _db.Products
|
||
.Include(p => p.ProductGroup)
|
||
.Include(p => p.Prices)
|
||
.FirstAsync(p => p.Id == line.ProductId, ct);
|
||
|
||
// Текущее общее количество по всем складам (до этой приёмки).
|
||
var currentQty = await _db.Stocks
|
||
.Where(s => s.ProductId == line.ProductId)
|
||
.SumAsync(s => (decimal?)s.Quantity, ct) ?? 0m;
|
||
|
||
// 1. Cost — скользящее среднее.
|
||
var totalQty = currentQty + line.Quantity;
|
||
var newCost = totalQty == 0m || product.Cost == 0m && currentQty == 0m
|
||
? line.UnitPrice
|
||
: (currentQty * product.Cost + line.Quantity * line.UnitPrice) / totalQty;
|
||
product.Cost = Math.Round(newCost, 4, MidpointRounding.AwayFromZero);
|
||
|
||
// 2. ReferencePrice — автозаполнение при первой приёмке.
|
||
if (product.ReferencePrice is null)
|
||
{
|
||
product.ReferencePrice = line.UnitPrice;
|
||
product.ReferencePriceUpdatedAt = now;
|
||
}
|
||
product.LastSupplyAt = now;
|
||
|
||
// 3. Розничная: либо явный override строки, либо автонаценка по группе.
|
||
if (line.RetailPriceManuallyOverridden && line.RetailPriceOverride.HasValue)
|
||
{
|
||
SetDefaultRetail(product, line.RetailPriceOverride.Value, supply.CurrencyId);
|
||
}
|
||
else if (product.ProductGroup?.MarkupPercent is decimal pct)
|
||
{
|
||
var raw = product.Cost * (1m + pct / 100m);
|
||
var newRetail = allowFractional
|
||
? Math.Ceiling(raw * 100m) / 100m
|
||
: Math.Ceiling(raw);
|
||
SetDefaultRetail(product, newRetail, supply.CurrencyId);
|
||
}
|
||
|
||
await _stock.ApplyMovementAsync(new StockMovementDraft(
|
||
ProductId: line.ProductId,
|
||
StoreId: supply.StoreId,
|
||
Quantity: line.Quantity,
|
||
Type: MovementType.Supply,
|
||
DocumentType: "supply",
|
||
DocumentId: supply.Id,
|
||
DocumentNumber: supply.Number,
|
||
UnitCost: line.UnitPrice,
|
||
OccurredAt: supply.Date), ct);
|
||
}
|
||
|
||
supply.Status = SupplyStatus.Posted;
|
||
supply.PostedAt = now;
|
||
await _db.SaveChangesAsync(ct);
|
||
await tx.CommitAsync(ct);
|
||
return NoContent();
|
||
}
|
||
|
||
/// <summary>Записывает значение в дефолтный розничный PriceType. Если в списке
|
||
/// цен у товара такой записи нет — создаёт её. Дефолтным считается PriceType
|
||
/// с IsSystem=true; если такого нет — первый IsRetail; иначе — первый
|
||
/// PriceType в списке. Currency берётся из приёмки (или из существующей записи).</summary>
|
||
private void SetDefaultRetail(foodmarket.Domain.Catalog.Product p, decimal value, Guid fallbackCurrencyId)
|
||
{
|
||
var defaultType = _db.PriceTypes
|
||
.OrderByDescending(pt => pt.IsSystem)
|
||
.ThenByDescending(pt => pt.IsRetail)
|
||
.ThenBy(pt => pt.SortOrder)
|
||
.ThenBy(pt => pt.Name)
|
||
.FirstOrDefault();
|
||
if (defaultType is null) return;
|
||
var existing = p.Prices.FirstOrDefault(x => x.PriceTypeId == defaultType.Id);
|
||
if (existing is null)
|
||
{
|
||
p.Prices.Add(new foodmarket.Domain.Catalog.ProductPrice
|
||
{
|
||
PriceTypeId = defaultType.Id,
|
||
Amount = value,
|
||
CurrencyId = fallbackCurrencyId,
|
||
});
|
||
}
|
||
else
|
||
{
|
||
existing.Amount = value;
|
||
}
|
||
}
|
||
|
||
[HttpPost("{id:guid}/unpost"), Authorize(Roles = "Admin,Manager,Storekeeper")]
|
||
public async Task<IActionResult> Unpost(Guid id, CancellationToken ct)
|
||
{
|
||
var supply = await _db.Supplies.Include(s => s.Lines).FirstOrDefaultAsync(s => s.Id == id, ct);
|
||
if (supply is null) return NotFound();
|
||
if (supply.Status != SupplyStatus.Posted) return Conflict(new { error = "Документ не проведён." });
|
||
|
||
// Reverse: negative movements with same document reference
|
||
foreach (var line in supply.Lines)
|
||
{
|
||
await _stock.ApplyMovementAsync(new StockMovementDraft(
|
||
ProductId: line.ProductId,
|
||
StoreId: supply.StoreId,
|
||
Quantity: -line.Quantity,
|
||
Type: MovementType.Supply,
|
||
DocumentType: "supply-reversal",
|
||
DocumentId: supply.Id,
|
||
DocumentNumber: supply.Number,
|
||
UnitCost: line.UnitPrice,
|
||
OccurredAt: DateTime.UtcNow,
|
||
Notes: $"Отмена проведения документа {supply.Number}"), ct);
|
||
}
|
||
|
||
supply.Status = SupplyStatus.Draft;
|
||
supply.PostedAt = null;
|
||
await _db.SaveChangesAsync(ct);
|
||
return NoContent();
|
||
}
|
||
|
||
private async Task<string> GenerateNumberAsync(DateTime date, CancellationToken ct)
|
||
{
|
||
var year = date.Year;
|
||
var prefix = $"П-{year}-";
|
||
var lastNumber = await _db.Supplies
|
||
.Where(s => s.Number.StartsWith(prefix))
|
||
.OrderByDescending(s => s.Number)
|
||
.Select(s => s.Number)
|
||
.FirstOrDefaultAsync(ct);
|
||
|
||
var seq = 1;
|
||
if (lastNumber is not null && int.TryParse(lastNumber[prefix.Length..], out var last))
|
||
seq = last + 1;
|
||
return $"{prefix}{seq:D6}";
|
||
}
|
||
|
||
private async Task<SupplyDto?> GetInternal(Guid id, CancellationToken ct)
|
||
{
|
||
var row = await (from s in _db.Supplies.AsNoTracking()
|
||
join cp in _db.Counterparties on s.SupplierId equals cp.Id
|
||
join st in _db.Stores on s.StoreId equals st.Id
|
||
join cu in _db.Currencies on s.CurrencyId equals cu.Id
|
||
where s.Id == id
|
||
select new { s, cp, st, cu }).FirstOrDefaultAsync(ct);
|
||
if (row is null) return null;
|
||
|
||
// CurrentRetailPrice — текущая розничная цена товара (дефолтный PriceType),
|
||
// отображается в строке приёмки как «Розничная (из карточки)».
|
||
var lines = await (from l in _db.SupplyLines.AsNoTracking()
|
||
join p in _db.Products on l.ProductId equals p.Id
|
||
join u in _db.UnitsOfMeasure on p.UnitOfMeasureId equals u.Id
|
||
where l.SupplyId == id
|
||
orderby l.SortOrder
|
||
select new SupplyLineDto(
|
||
l.Id, l.ProductId, p.Name, p.Article, u.Name,
|
||
l.Quantity, l.UnitPrice, l.LineTotal, l.SortOrder,
|
||
l.RetailPriceManuallyOverridden, l.RetailPriceOverride,
|
||
p.Prices
|
||
.OrderByDescending(pr => pr.PriceType!.IsSystem)
|
||
.ThenByDescending(pr => pr.PriceType!.IsRetail)
|
||
.ThenBy(pr => pr.PriceType!.SortOrder)
|
||
.ThenBy(pr => pr.PriceType!.Name)
|
||
.Select(pr => (decimal?)pr.Amount)
|
||
.FirstOrDefault()))
|
||
.ToListAsync(ct);
|
||
|
||
return new SupplyDto(
|
||
row.s.Id, row.s.Number, row.s.Date, row.s.Status,
|
||
row.cp.Id, row.cp.Name,
|
||
row.st.Id, row.st.Name,
|
||
row.cu.Id, row.cu.Code,
|
||
row.s.SupplierInvoiceNumber, row.s.SupplierInvoiceDate,
|
||
row.s.Notes,
|
||
row.s.Total, row.s.PostedAt,
|
||
lines);
|
||
}
|
||
}
|