849 lines
37 KiB
C#
849 lines
37 KiB
C#
using LinqToDB;
|
|
using LinqToDB.SqlQuery;
|
|
using log4net;
|
|
using log4net.Util;
|
|
using MasaBlazorApp3.DataAccess.Dao;
|
|
using MasaBlazorApp3.Pages;
|
|
using MasaBlazorApp3.Pojo;
|
|
using MasaBlazorApp3.Pojo.Config;
|
|
using MasaBlazorApp3.Pojo.Vo;
|
|
using MasaBlazorApp3.Port;
|
|
using Microsoft.Extensions.Options;
|
|
using Mysqlx.Crud;
|
|
using Radzen.Blazor.Rendering;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace MasaBlazorApp3.DataAccess.Impl
|
|
{
|
|
public class OrderInfoDao : IOrderInfoDao
|
|
{
|
|
|
|
private readonly SettingConfig _setting;
|
|
private AppDataConnection _connection;
|
|
private GlobalStateService _globalStateService;
|
|
private readonly ILog logger = LogManager.GetLogger(typeof(OrderInfoDao));
|
|
private readonly PortUtil _portUtil;
|
|
|
|
public OrderInfoDao(AppDataConnection connection, IOptions<SettingConfig> setting, GlobalStateService globalStateService, PortUtil portUtil)
|
|
{
|
|
_connection = connection;
|
|
_setting = setting.Value;
|
|
_globalStateService = globalStateService;
|
|
_portUtil = portUtil;
|
|
}
|
|
|
|
public async Task<PageData<OrderInfo>> GetAllOrderInfo(string OrderrNo, DateTime OrderDate, int? take, int? skip)
|
|
{
|
|
//var query = _connection.OrderInfo.AsQueryable();
|
|
|
|
//query.InnerJoin<OrderDetail>((oi, od) => oi.OrderNo == od.OrderNo);
|
|
|
|
var query2 = from od in _connection.OrderDetail
|
|
from cl in _connection.ChannelStock.Where(c => c.MachineId == _setting.machineId).InnerJoin(c => c.DrugId == od.DrugId)
|
|
group od by od.OrderNo into temp
|
|
select new { temp.Key };
|
|
var query = from oi in _connection.OrderInfo
|
|
from od in query2.InnerJoin(od => od.Key == oi.OrderNo)
|
|
select oi;
|
|
|
|
if (!String.IsNullOrEmpty(OrderrNo))
|
|
{
|
|
query = query.Where(oi => oi.OrderNo.Equals(OrderrNo));
|
|
}
|
|
if (OrderDate != null && OrderDate != DateTime.MinValue)
|
|
{
|
|
query = query.Where(oi => oi.OrderDate.Date.Equals(OrderDate.Date));
|
|
}
|
|
|
|
query = query.Where(oi => oi.Status == 0);
|
|
query = query.Where(oi => oi.HisDispFlag == 0);
|
|
query = query.Where(oi => oi.CancelFlag == 0);
|
|
|
|
|
|
int pagedData = await query.CountAsync();
|
|
|
|
List<OrderInfo> list = await query
|
|
//.LoadWith(oi => oi.Detail)
|
|
//.LoadWith(oi => oi.Detail.Drug)
|
|
.OrderBy((oi) => oi.RecvDate)
|
|
.ThenBy((oi => oi.OrderNo))
|
|
.Skip((int)skip)
|
|
.Take((int)take)
|
|
.ToListAsync();
|
|
|
|
|
|
return new PageData<OrderInfo>()
|
|
{
|
|
TotalDesserts = pagedData,
|
|
Desserts = list
|
|
};
|
|
}
|
|
|
|
public async Task<List<OrderDetail>> getDetailByOrderNo(string OrderrNo)
|
|
{
|
|
var query2 = from cl in _connection.ChannelStock
|
|
where cl.MachineId == _setting.machineId
|
|
group cl by cl.DrugId into temp
|
|
select new { temp.Key };
|
|
;
|
|
|
|
|
|
var query = from od in _connection.OrderDetail.Where(od => od.OrderNo == OrderrNo)
|
|
from cl in query2.InnerJoin(c => c.Key == od.DrugId)
|
|
orderby od.DrugId
|
|
select od;
|
|
|
|
query = query.LoadWith(od => od.Drug);
|
|
|
|
return await query.ToListAsync();
|
|
}
|
|
|
|
public async Task<List<ChannelStock>> GetChannelStockByDrugId(string DrugId, String ManuNo, int quantity = 0)
|
|
{
|
|
var query = _connection.ChannelStock.AsQueryable();
|
|
|
|
|
|
query = query.Where(cs => cs.MachineId.Equals(_setting.machineId)).Where(cs => cs.DrawerType == 1)
|
|
.Where(cs => cs.Quantity > 0)
|
|
.Where(cs => cs.DrugId.Equals(DrugId));
|
|
|
|
if (quantity > 0)
|
|
{
|
|
if (!String.IsNullOrEmpty(ManuNo))
|
|
{
|
|
query = query.Where(cs => cs.ManuNo.Equals(ManuNo));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!String.IsNullOrEmpty(ManuNo))
|
|
{
|
|
query = query.Where(cs => cs.ManuNo.Equals(ManuNo) || cs.Quantity == 0);
|
|
}
|
|
}
|
|
|
|
|
|
return await query.OrderBy((cs) => cs.EffDate)
|
|
.ThenBy((cs) => cs.DrawerNo)
|
|
.ThenBy((cs) => cs.ColNo)
|
|
.ToListAsync();
|
|
}
|
|
|
|
public async Task<List<OrderTakeVo>> getTakeInfoByOrderNo(string OrderrNo)
|
|
{
|
|
List<OrderTakeVo> tempData = new();
|
|
List<OrderTakeVo> tempData2 = new();
|
|
List<OrderDetail> details = await this.getDetailByOrderNo(OrderrNo);
|
|
var flag = true;
|
|
for (var i = 0; i < details.Count; i++)
|
|
{
|
|
//List<IDictionary<string, object>> tempData = new();
|
|
OrderDetail detail = details[i];
|
|
// 当前detail取药数量
|
|
var Quantity = detail.Quantity;
|
|
List<ChannelStock> stockList = await this.GetChannelStockByDrugId(detail.DrugId, detail.SetManuNo, Quantity);
|
|
|
|
// 当前药品的库存总量
|
|
var total = stockList.Sum(current => current.Quantity);
|
|
|
|
tempData2.Add(new OrderTakeVo()
|
|
{
|
|
Drug = detail.Drug,
|
|
OrderDetail = detail,
|
|
StockQuantity = total,
|
|
Quantity = Quantity
|
|
});
|
|
|
|
if (flag)
|
|
{
|
|
// 盘点库存是否足够
|
|
if (total > Quantity)
|
|
{
|
|
|
|
for (var j = 0; Quantity > 0; j++)
|
|
{
|
|
ChannelStock stock = stockList[j];
|
|
if (Quantity > stock.Quantity)
|
|
{
|
|
// 取药数量大于库存
|
|
tempData.Add(new OrderTakeVo()
|
|
{
|
|
Drug = detail.Drug,
|
|
OrderDetail = detail,
|
|
ChannelStock = stock,
|
|
StockQuantity = total,
|
|
Quantity = stock.Quantity,
|
|
});
|
|
Quantity -= stock.Quantity;
|
|
}
|
|
else
|
|
{
|
|
//取药数量小于库存
|
|
tempData.Add(new OrderTakeVo()
|
|
{
|
|
Drug = detail.Drug,
|
|
OrderDetail = detail,
|
|
ChannelStock = stock,
|
|
StockQuantity = total,
|
|
Quantity = Quantity,
|
|
});
|
|
Quantity = 0;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 库存不足
|
|
flag = false;
|
|
}
|
|
}
|
|
|
|
}
|
|
if (flag)
|
|
{
|
|
return tempData;
|
|
}
|
|
else
|
|
{
|
|
return tempData2;
|
|
}
|
|
}
|
|
|
|
public async Task<bool> OrderTakeFinish(List<OrderTakeVo> datas)
|
|
{
|
|
|
|
try
|
|
{
|
|
_connection.BeginTransaction();
|
|
var flag = true;
|
|
// 更新处方状态
|
|
int r1 = _connection.OrderInfo.Where(oi => oi.OrderNo == datas.First().OrderDetail.OrderNo)
|
|
.Set(oi => oi.Status, 1)
|
|
.Update();
|
|
if (!(r1 > 0))
|
|
{
|
|
flag = false;
|
|
logger.Error("处方取药完成更新处方状态失败");
|
|
_connection.RollbackTransaction();
|
|
return flag;
|
|
}
|
|
for (var i = 0; i < datas.Count; i++)
|
|
{
|
|
var orderTakeVo = datas[i];
|
|
var EffDate = orderTakeVo.ChannelStock.EffDate;
|
|
if (!DateTime.TryParse(orderTakeVo.ChannelStock.EffDate, out DateTime dEffDate))
|
|
{
|
|
//效期转换出错
|
|
if (orderTakeVo.ChannelStock.EffDate != null)
|
|
{
|
|
string[] idate = orderTakeVo.ChannelStock.EffDate.Split('/');
|
|
foreach (string iS in idate)
|
|
{
|
|
if (!string.IsNullOrEmpty(iS.Trim()))
|
|
{
|
|
switch (iS.Trim().Length)
|
|
{
|
|
case 4:
|
|
EffDate = iS.Trim();
|
|
break;
|
|
case 2:
|
|
EffDate += "-" + iS.Trim();
|
|
break;
|
|
case 1:
|
|
EffDate += "-0" + iS.Trim();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
EffDate = dEffDate.ToString("yyyy-MM-dd");
|
|
}
|
|
// 出库记录
|
|
int mid = _connection.InsertWithInt32Identity(new MachineRecord()
|
|
{
|
|
MachineId = _setting.machineId,
|
|
DrawerNo = orderTakeVo.ChannelStock.DrawerNo,
|
|
ColNo = orderTakeVo.ChannelStock.ColNo,
|
|
DrugId = orderTakeVo.ChannelStock.DrugId,
|
|
ManuNo = orderTakeVo.ChannelStock.ManuNo,
|
|
EffDate = !String.IsNullOrEmpty(EffDate) ? DateTime.ParseExact(EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
|
|
OperationTime = DateTime.Now,
|
|
Type = 2,
|
|
Quantity = orderTakeVo.GetQuantity,
|
|
Operator = _globalStateService.Operator.Id,
|
|
Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
|
|
InvoiceId = orderTakeVo.OrderDetail.Id.ToString(),
|
|
});
|
|
// 更新库存
|
|
int r = _connection.ChannelStock.Where(cs => cs.Id == orderTakeVo.ChannelStock.Id)
|
|
.Set(cs => cs.Quantity, orderTakeVo.ChannelStock.Quantity - orderTakeVo.GetQuantity)
|
|
.Update();
|
|
// 获取更新完库存之后的药品库存
|
|
List<ChannelStock> list = await _connection.ChannelStock.AsQueryable()
|
|
.InnerJoin(
|
|
_connection.ChannelList.Where(cl => cl.MachineId.Equals(_setting.machineId)).Where(cl => cl.DrawerType == 1),
|
|
(cs, cl) => cs.ListId == cl.Id,
|
|
(cs, cl) => cs
|
|
)
|
|
.Where(cs => cs.DrugId.Equals(orderTakeVo.ChannelStock.DrugId))
|
|
.ToListAsync();
|
|
// 保存账册
|
|
int acid = _connection.InsertWithInt32Identity(new AccountBook()
|
|
{
|
|
MachineId = _setting.machineId,
|
|
DrugId = orderTakeVo.ChannelStock.DrugId,
|
|
ManuNo = orderTakeVo.ChannelStock.ManuNo,
|
|
EffDate = !String.IsNullOrEmpty(EffDate) ? DateTime.ParseExact(EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
|
|
OperationTime = DateTime.Now,
|
|
Type = 2,
|
|
OutQuantity = orderTakeVo.GetQuantity,
|
|
AddQuantity = 0,
|
|
Operator = _globalStateService.Operator.Id,
|
|
Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
|
|
ManuStock = list.Where(it => it.ManuNo == orderTakeVo.ChannelStock.ManuNo).Sum(it => it.Quantity),
|
|
TotalStock = list.Sum(it => it.Quantity),
|
|
InvoiceId = orderTakeVo.OrderDetail.Id.ToString()
|
|
});
|
|
if (mid > 0 && r > 0 && acid > 0)
|
|
{
|
|
if (orderTakeVo.ChannelStock.BoardType.ToString().Contains("5"))
|
|
{
|
|
await _portUtil.WriteQuantityMethod(orderTakeVo.ChannelStock.Quantity - orderTakeVo.GetQuantity, orderTakeVo.ChannelStock.DrawerNo, orderTakeVo.ChannelStock.ColNo);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
flag = false;
|
|
break;
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
_connection.CommitTransaction();
|
|
}
|
|
else
|
|
{
|
|
_connection.RollbackTransaction();
|
|
}
|
|
return flag;
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error("处方取药完成保存数据库失败，错误：" + ex.Message);
|
|
_connection.RollbackTransaction();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public async Task<PageData<OrderInfo>> GetAllCanReturnOrderInfo(string OrderrNo, DateTime OrderDate, int? take, int? skip)
|
|
{
|
|
var query2 = from od in _connection.OrderDetail
|
|
from cl in _connection.ChannelStock.Where(c => c.MachineId == _setting.machineId).InnerJoin(c => c.DrugId == od.DrugId)
|
|
group od by od.OrderNo into temp
|
|
select new { temp.Key };
|
|
var query = from oi in _connection.OrderInfo
|
|
from od in query2.InnerJoin(od => od.Key == oi.OrderNo)
|
|
select oi;
|
|
|
|
if (!String.IsNullOrEmpty(OrderrNo))
|
|
{
|
|
query = query.Where(oi => oi.OrderNo.Equals(OrderrNo));
|
|
}
|
|
if (OrderDate != null && OrderDate != DateTime.MinValue)
|
|
{
|
|
query = query.Where(oi => oi.OrderDate.Date.Equals(OrderDate.Date));
|
|
}
|
|
|
|
query = query.Where(oi => oi.Status == 1);
|
|
query = query.Where(oi => oi.CancelFlag == 1);
|
|
|
|
|
|
int pagedData = await query.CountAsync();
|
|
|
|
List<OrderInfo> list = await query
|
|
.OrderBy((oi) => oi.RecvDate)
|
|
.ThenBy((oi => oi.OrderNo))
|
|
.Skip((int)skip)
|
|
.Take((int)take)
|
|
.ToListAsync();
|
|
|
|
|
|
return new PageData<OrderInfo>()
|
|
{
|
|
TotalDesserts = pagedData,
|
|
Desserts = list
|
|
};
|
|
}
|
|
|
|
public async Task<List<MachineRecord>> GetMachineRecordByOrderNo(string OrderrNo)
|
|
{
|
|
var query = _connection.MachineRecord.AsQueryable();
|
|
query = query.InnerJoin(
|
|
_connection.OrderDetail.Where(od => od.OrderNo.Equals(OrderrNo)),
|
|
(mr, od) => mr.InvoiceId.Equals(od.Id),
|
|
(mr, od) => mr
|
|
)
|
|
.Where(md => md.Type == 2)
|
|
.LoadWith(md => md.Drug)
|
|
;
|
|
return await query.ToListAsync();
|
|
}
|
|
|
|
public async Task<List<OperationVo<MachineRecord>>> getReturnInfoByOrderNo(string OrderrNo)
|
|
{
|
|
List<OperationVo<MachineRecord>> tempData = new();
|
|
List<MachineRecord> details = await this.GetMachineRecordByOrderNo(OrderrNo);
|
|
for (var i = 0; i < details.Count; i++)
|
|
{
|
|
//List<IDictionary<string, object>> tempData = new();
|
|
MachineRecord detail = details[i];
|
|
List<ChannelStock> stockList = await this.GetChannelStockByDrugId(detail.DrugId, detail.ManuNo);
|
|
|
|
|
|
// 当前药品的库存总量
|
|
var total = stockList.Sum(current => current.Quantity);
|
|
// 当前detail出库数量
|
|
var Quantity = detail.Quantity;
|
|
|
|
stockList.First().AddQuantity = Quantity;
|
|
|
|
tempData.Add(new OperationVo<MachineRecord>()
|
|
{
|
|
Drug = detail.Drug,
|
|
data = detail,
|
|
StockQuantity = total,
|
|
Quantity = Quantity,
|
|
ChannelStocks = stockList,
|
|
});
|
|
|
|
}
|
|
return tempData;
|
|
}
|
|
|
|
public async Task<DrugManuNo> GetDrugManuNo(string drugId, string manuNo)
|
|
{
|
|
var query = _connection.DrugManuNo.AsQueryable();
|
|
|
|
return await query.Where(m => m.DrugId.Equals(drugId))
|
|
.Where(m => m.ManuNo.Equals(manuNo))
|
|
.FirstAsync();
|
|
}
|
|
|
|
public async Task<bool> OrderReturnFinish(List<OperationVo<MachineRecord>> datas, string OrderNo)
|
|
{
|
|
try
|
|
{
|
|
_connection.BeginTransaction();
|
|
var flag = true;
|
|
// 更新处方状态
|
|
int r1 = _connection.OrderInfo.Where(oi => oi.OrderNo == OrderNo)
|
|
.Set(oi => oi.Status, 0)
|
|
.Update();
|
|
if (!(r1 > 0))
|
|
{
|
|
flag = false;
|
|
logger.Error("处方取药完成更新处方状态失败");
|
|
_connection.RollbackTransaction();
|
|
return flag;
|
|
}
|
|
for (var i = 0; i < datas.Count; i++)
|
|
{
|
|
var operationVo = datas[i];
|
|
|
|
List<ChannelStock> stocks = operationVo.ChannelStocks.Where(cs => cs.ReturnQuantity > 0).ToList();
|
|
|
|
// 更新取出记录状态
|
|
var r2 = _connection.MachineRecord.Where(cs => cs.Id == operationVo.data.Id)
|
|
.Set(cs => cs.Status, 2)
|
|
.Set(cs => cs.ReturnQuantity1, operationVo.data.Quantity).Update();
|
|
|
|
if (r2 > 0)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
flag = false;
|
|
break;
|
|
}
|
|
|
|
for (var j = 0; j < stocks.Count; j++)
|
|
{
|
|
var channelStock = stocks[j];
|
|
|
|
// 更新库存
|
|
var q = _connection.ChannelStock.Where(cs => cs.Id == channelStock.Id)
|
|
.Set(cs => cs.Quantity, channelStock.Quantity + channelStock.ReturnQuantity);
|
|
if (String.IsNullOrEmpty(channelStock.ManuNo) || (channelStock.Quantity == 0 && !channelStock.ManuNo.Equals(operationVo.data.ManuNo)))
|
|
{
|
|
DrugManuNo drugManuNo = await GetDrugManuNo(channelStock.DrugId, operationVo.data.ManuNo);
|
|
|
|
channelStock.Dmnguid = drugManuNo.Id;
|
|
channelStock.ManuNo = drugManuNo.ManuNo;
|
|
channelStock.EffDate = drugManuNo.EffDate.ToString();
|
|
|
|
q = q.Set(cs => cs.Dmnguid, drugManuNo.Id)
|
|
.Set(cs => cs.ManuNo, drugManuNo.ManuNo)
|
|
.Set(cs => cs.EffDate, drugManuNo.EffDate.ToString());
|
|
}
|
|
int r = q.Update();
|
|
// 退回记录
|
|
int mid = _connection.InsertWithInt32Identity(new MachineRecord()
|
|
{
|
|
MachineId = _setting.machineId,
|
|
DrawerNo = channelStock.DrawerNo,
|
|
ColNo = channelStock.ColNo,
|
|
DrugId = channelStock.DrugId,
|
|
ManuNo = channelStock.ManuNo,
|
|
EffDate = !String.IsNullOrEmpty(channelStock.EffDate) ? DateTime.ParseExact(channelStock.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
|
|
OperationTime = DateTime.Now,
|
|
Type = 31,
|
|
Quantity = channelStock.ReturnQuantity,
|
|
Operator = _globalStateService.Operator.Id,
|
|
Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
|
|
InvoiceId = operationVo.data.InvoiceId.ToString(),
|
|
GetId = operationVo.data.Id
|
|
});
|
|
|
|
// 获取更新完库存之后的药品库存
|
|
List<ChannelStock> list = await _connection.ChannelStock.AsQueryable()
|
|
.InnerJoin(
|
|
_connection.ChannelList.Where(cl => cl.MachineId.Equals(_setting.machineId)).Where(cl => cl.DrawerType == 1),
|
|
(cs, cl) => cs.ListId == cl.Id,
|
|
(cs, cl) => cs
|
|
)
|
|
.Where(cs => cs.DrugId.Equals(channelStock.DrugId))
|
|
.ToListAsync();
|
|
// 保存账册
|
|
int acid = _connection.InsertWithInt32Identity(new AccountBook()
|
|
{
|
|
MachineId = _setting.machineId,
|
|
DrugId = channelStock.DrugId,
|
|
ManuNo = channelStock.ManuNo,
|
|
EffDate = !String.IsNullOrEmpty(channelStock.EffDate) ? DateTime.ParseExact(channelStock.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
|
|
OperationTime = DateTime.Now,
|
|
Type = 2,
|
|
OutQuantity = channelStock.ReturnQuantity,
|
|
AddQuantity = 0,
|
|
Operator = _globalStateService.Operator.Id,
|
|
Reviewer = _globalStateService.Reviewer?.Id ?? _globalStateService.Operator.Id,
|
|
ManuStock = list.Where(it => it.ManuNo == channelStock.ManuNo).Sum(it => it.Quantity),
|
|
TotalStock = list.Sum(it => it.Quantity),
|
|
InvoiceId = operationVo.data.InvoiceId
|
|
});
|
|
if (mid > 0 && r > 0 && acid > 0)
|
|
{
|
|
if (channelStock.BoardType.ToString().Contains("5"))
|
|
{
|
|
await _portUtil.WriteQuantityMethod(channelStock.Quantity - channelStock.ReturnQuantity, channelStock.DrawerNo, channelStock.ColNo);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
flag = false;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
}
|
|
if (flag)
|
|
{
|
|
_connection.CommitTransaction();
|
|
}
|
|
else
|
|
{
|
|
_connection.RollbackTransaction();
|
|
}
|
|
return flag;
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
logger.Error("处方取药完成保存数据库失败，错误：" + ex.Message);
|
|
_connection.RollbackTransaction();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取药箱中的用药信息
|
|
/// </summary>
|
|
/// <param name="OrderrNo"></param>
|
|
/// <param name="OrderDate"></param>
|
|
/// <param name="take"></param>
|
|
/// <param name="skip"></param>
|
|
/// <returns></returns>
|
|
public async Task<PageData<OrderInfo>> GetAllOrderInfoByBox(int box, string OrderrNo, DateTime OrderDate, int? take, int? skip)
|
|
{
|
|
//var query = _connection.OrderInfo.AsQueryable();
|
|
|
|
//query.InnerJoin<OrderDetail>((oi, od) => oi.OrderNo == od.OrderNo);
|
|
|
|
var query2 = from od in _connection.OrderDetail
|
|
from cl in _connection.ChannelStock.Where(c => c.MachineId == _setting.machineId).InnerJoin(c => c.DrugId == od.DrugId)
|
|
group od by od.OrderNo into temp
|
|
select new { temp.Key };
|
|
var query = from oi in _connection.OrderInfo
|
|
from od in query2.InnerJoin(od => od.Key == oi.OrderNo)
|
|
select oi;
|
|
|
|
if (!String.IsNullOrEmpty(OrderrNo))
|
|
{
|
|
query = query.Where(oi => oi.OrderNo.Equals(OrderrNo));
|
|
}
|
|
if (OrderDate != null && OrderDate != DateTime.MinValue)
|
|
{
|
|
query = query.Where(oi => oi.OrderDate.Date.Equals(OrderDate.Date));
|
|
}
|
|
|
|
query = query.Where(oi => oi.Status == 0);
|
|
query = query.Where(oi => oi.HisDispFlag == 0);
|
|
query = query.Where(oi => oi.CancelFlag == 0);
|
|
//query = query.Where(oi => oi.DoctorCode == box);
|
|
|
|
int pagedData = await query.CountAsync();
|
|
|
|
List<OrderInfo> list = await query
|
|
.LoadWith(oi => oi.Detail)
|
|
.LoadWith(oi => oi.Detail.Drug)
|
|
.OrderBy((oi) => oi.RecvDate)
|
|
.ThenBy((oi => oi.OrderNo))
|
|
.Skip((int)skip)
|
|
.Take((int)take)
|
|
.ToListAsync();
|
|
if (list != null && list.Count > 0)
|
|
{
|
|
for (int i = 0; i < list.Count; i++)
|
|
{
|
|
//list[i].Detail = await _connection.OrderDetail.AsQueryable()
|
|
// .Where(od => od.OrderNo == list[i].OrderNo)
|
|
// .LoadWith(od => od.Drug)
|
|
// .ToListAsync();
|
|
}
|
|
}
|
|
|
|
return new PageData<OrderInfo>()
|
|
{
|
|
TotalDesserts = pagedData,
|
|
Desserts = list
|
|
};
|
|
}
|
|
/// <summary>
|
|
/// 获取所有药箱号
|
|
/// </summary>
|
|
/// <param name="machineId"></param>
|
|
/// <returns></returns>
|
|
public async Task<int[]> GetDrawerNum(string machineId)
|
|
{
|
|
int[] ints = _connection.ChannelStock.Where(cs => cs.MachineId == machineId).GroupBy(cs => cs.DrawerNo).Select(cs => cs.Key).ToArray();
|
|
return ints;
|
|
}
|
|
//核对处方
|
|
public async Task<bool> CheckOrderInfo(IList<OrderInfo> selectedOrderInfos,int DrawerNo)
|
|
{
|
|
try
|
|
{
|
|
_connection.BeginTransaction();
|
|
bool bFlag = true;
|
|
logger.Info($"管理员{_globalStateService.Operator.NickName}开始确认手麻单");
|
|
|
|
|
|
string empChannelStock = string.Empty;
|
|
|
|
for (int i = 0; i < selectedOrderInfos.Count; i++)
|
|
{
|
|
OrderInfo oi = selectedOrderInfos[i];
|
|
|
|
//更新处方状态
|
|
if (oi.state == 1)
|
|
{
|
|
int iUpdate= _connection.OrderInfo.Where(o=>o.OrderNo==oi.OrderNo).Set(o=>o.state,2).Update();
|
|
_connection.Insert(new OrderFinish()
|
|
{
|
|
OrderNo = oi.OrderNo,
|
|
PatientId = oi.PatientId,
|
|
Pharmacy = oi.Pharmacy,
|
|
State = 2,
|
|
//WinNo = DrawerNo + 1 + "号手术间",
|
|
Operator = _globalStateService.Operator.NickName,
|
|
});
|
|
}
|
|
int drawerNo = DrawerNo + 1;
|
|
ChannelStock cs =_connection.ChannelStock.AsQueryable()
|
|
.Where(cs => cs.DrugId == oi.Detail.DrugId
|
|
&& cs.ManuNo == oi.Detail.SetManuNo
|
|
// && cs.EffDate == oi._OrderDetail.SetEffDate
|
|
&& cs.MachineId.Equals(_setting.boxMachineId)
|
|
&& cs.DrawerNo == drawerNo
|
|
&& cs.Quantity >= oi.Detail.Quantity).First();
|
|
if (cs == null)
|
|
{
|
|
logger.Info($"手麻单{oi.OrderNo}对药品批次{oi.Detail.DrugId}-{oi.Detail.SetManuNo}在{drawerNo}药箱无库存");
|
|
continue;
|
|
}
|
|
cs.Quantity = cs.Quantity - oi.Detail.Quantity;
|
|
//cs.NeedNum = cs.NeedNum > 0 ? cs.NeedNum + oi._OrderDetail.Quantity : oi._OrderDetail.Quantity;
|
|
logger.Info($"更新手术间{cs.DrawerNo}药品{cs.DrugId}批次{cs.ManuNo}库存为{cs.Quantity}，需补药数量为{oi.Detail.Quantity}");
|
|
// 更新数据 库存信息
|
|
_connection.Update(cs);
|
|
|
|
// 获取更新完库存后的药品库存
|
|
List<ChannelStock> nowChannels = _connection.ChannelStock.AsQueryable()
|
|
.Where(it => it.MachineId.Equals(cs.MachineId) || it.MachineId.Equals(_setting.machineId))
|
|
.Where(it => it.DrugId.Equals(cs.DrugId))
|
|
.Where(it => it.ManuNo.Equals(cs.ManuNo))
|
|
.Where(it => it.DrawerType == 1)
|
|
.ToList();
|
|
if (cs != null)
|
|
{
|
|
_connection.Insert(new MachineRecord()
|
|
{
|
|
MachineId = _setting.machineId,
|
|
DrawerNo = cs.DrawerNo,
|
|
ColNo = cs.ColNo,
|
|
DrugId = cs.DrugId,
|
|
ManuNo = cs.ManuNo,
|
|
EffDate = !String.IsNullOrEmpty(cs.EffDate) ? DateTime.ParseExact(cs.EffDate, "yyyy-MM-dd", System.Globalization.CultureInfo.CurrentCulture) : null,
|
|
Operator = _globalStateService.Operator?.Id,
|
|
Reviewer = _globalStateService.Reviewer?.Id,
|
|
OperationTime = DateTime.Now,
|
|
Quantity = oi.Detail.Quantity,
|
|
Type = 2,
|
|
InvoiceId = oi.OrderNo
|
|
//, StockQuantity = nowChannels.Sum(it => it.Quantity)
|
|
});
|
|
|
|
|
|
//查询上一条账册中的空瓶数
|
|
AccountBookG2 accountBookEmpty =_connection.AccountBookG2.AsQueryable()
|
|
.Where(ab => ab.MachineId.Equals(_setting.machineId))
|
|
.Where(ab => ab.Type == 1 || ab.Type == 2)
|
|
.Where(ab => ab.DrugId == oi.Detail.DrugId)
|
|
.Where(ab => ab.ManuNo == cs.ManuNo).OrderByDescending(ab => ab.Id).First();
|
|
//保存账册
|
|
int iInsertResult = _connection.Insert(new AccountBookG2()
|
|
{
|
|
DrugId = oi.Detail.DrugId,
|
|
Type = 2,
|
|
Department = oi.DeptName,
|
|
OrderNo = oi.OrderNo,
|
|
ManuNo = cs.ManuNo,
|
|
EffDate = cs.EffDate,
|
|
OutQuantity = oi.Detail.Quantity,
|
|
UserId1 = _globalStateService.Operator?.Id,
|
|
UserId2 = _globalStateService.Reviewer?.Id,
|
|
MachineId = _setting.machineId,
|
|
CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
CreateTime = DateTime.Now,
|
|
InvoiceNo = oi.OrderNo,
|
|
ManuStock = nowChannels.Sum(it => it.Quantity),
|
|
TotalStock = (accountBookEmpty != null ? (accountBookEmpty.TotalStock > 0 ? accountBookEmpty.TotalStock : 0) : 0) + oi.Detail.Quantity,
|
|
ShoushuJian = drawerNo.ToString()
|
|
});
|
|
//修改凌晨生成的日结存与总结存数据
|
|
AccountBookG2 accountBookG2Day = _connection.AccountBookG2.AsQueryable()
|
|
.Where(ab => ab.MachineId.Equals(_setting.machineId))
|
|
.Where(ab => ab.Type == 3)
|
|
.Where(ab => ab.DrugId == oi.Detail.DrugId)
|
|
.Where(ab => ab.ManuNo == cs.ManuNo)
|
|
.Where(ab => ab.CreateDate == DateTime.Now.ToString("yyyy-MM-dd")).First();
|
|
if (accountBookG2Day != null)
|
|
{
|
|
accountBookG2Day.ManuStock = accountBookG2Day.ManuStock - oi.Detail.Quantity;
|
|
_connection.Update(accountBookG2Day);
|
|
}
|
|
else
|
|
{
|
|
//生成日结存时可能没有该库位的绑定信息，需要写入日结存
|
|
int iDayResult =_connection.Insert(new AccountBookG2()
|
|
{
|
|
DrugId = oi.Detail.DrugId,
|
|
Type = 3,
|
|
ManuNo = cs.ManuNo,
|
|
EffDate = cs.EffDate,
|
|
YQuantity = 0,
|
|
ManuStock = oi.Detail.Quantity,
|
|
TotalStock = oi.Detail.Quantity,
|
|
UserId1 = _globalStateService.Operator?.Id,
|
|
UserId2 = _globalStateService.Reviewer?.Id,
|
|
MachineId = _setting.machineId,
|
|
CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
InvoiceNo = "日结存"
|
|
});
|
|
if (iDayResult <= 0)
|
|
{
|
|
logger.Info($"未写入日结存数据{oi.Detail.DrugId}-{cs.ManuNo}-{cs.EffDate}-{cs.Quantity}");
|
|
}
|
|
}
|
|
//修改凌晨生成的日结存与总结存数据
|
|
AccountBookG2 accountBookG2Total = _connection.AccountBookG2.AsQueryable()
|
|
.Where(ab => ab.MachineId.Equals(_setting.machineId))
|
|
.Where(ab => ab.Type == 4)
|
|
.Where(ab => ab.DrugId == oi.Detail.DrugId)
|
|
.Where(ab => ab.CreateDate == DateTime.Now.ToString("yyyy-MM-dd")).First();
|
|
if (accountBookG2Total != null)
|
|
{
|
|
accountBookG2Total.TotalStock = accountBookG2Total.TotalStock - oi.Detail.Quantity;
|
|
_connection.Update(accountBookG2Total);
|
|
}
|
|
else
|
|
{
|
|
//生成总结存时可能没有该库位的绑定信息，需要写入总结存
|
|
int iTotalResult = _connection.Insert(new AccountBookG2()
|
|
{
|
|
DrugId = oi.Detail.DrugId,
|
|
Type = 4,
|
|
YQuantity = 0,
|
|
ManuStock = oi.Detail.Quantity,
|
|
TotalStock = oi.Detail.Quantity,
|
|
UserId1 = _globalStateService.Operator?.Id,
|
|
UserId2 = _globalStateService.Reviewer?.Id,
|
|
MachineId = _setting.machineId,
|
|
CreateDate = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
InvoiceNo = "总结存"
|
|
});
|
|
if (iTotalResult <= 0)
|
|
{
|
|
logger.Info($"未写入总结存数据{oi.Detail.DrugId}-{oi.Detail.Quantity}");
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return true;
|
|
|
|
logger.Info($"管理员{_globalStateService.Operator.NickName}结束确认手麻单");
|
|
|
|
if (bFlag)
|
|
{
|
|
_connection.CommitTransaction();
|
|
return true;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_connection.RollbackTransaction();
|
|
logger.Info($"核对处方异常{ex.Message}");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|