Skip to content

K
Kivii.Lac.Lims.V4.5
Commit 1d3c42c8 by Neo Turing
Options

init

parents
Showing with 5982 additions and 0 deletions
.gitignore 0 → 100644
################################################################################
# 此 .gitignore 文件已由 Microsoft(R) Visual Studio 自动创建。
################################################################################
/Src/bin
/Src/obj
Src/Configs.cs 0 → 100644
using Kivii.Logging;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims
{
internal class Configs
{
//------------数据库表名称
public const string TableNameReport = "LIMS_Reports";
public const string TableNameReportFile = "LIMS_ReportFiles";
public const string TableNameReportHistory = "LIMS_Reports_History";
public const string TableNameReportItem = "LIMS_ReportItems";
public const string TableNameReportItemHistory = "LIMS_ReportItems_History";
public const string TableNameReportJudgement = "LIMS_ReportJudgements";
public const string TableNameTest = "LIMS_Tests";
public const string TableNameTestHistory = "LIMS_Tests_History";
public const string TableNameSample = "LIMS_Samples";
public const string TableNameTemplate = "LIMS_Templates";
public const string TableNameTemplateFile = "LIMS_TemplateFiles";
public const string TableNameSampleSource = "LIMS_SampleSources";
public const string TableNameTemplateDetail = "LIMS_TemplateDetails";
public const string TableNameReportNote = "LIMS_ReportNotes";
public const string TableNameReportChange = "LIMS_ReportChanges";
public const string TableNameThirdReportOrder = "LIMS_ThirdReportOrders";
public const string TableNameThirdReportOrderDetail = "LIMS_ThirdReportOrderDetails";
public const string TableNameB2bLink = "LIMS_B2bLinks";
//public const string TableNameSampleSource = "LIMS_SampleSource";
public const string RouteLimsReportRead = "/Lims/ReportRead";
public const string RouteReportPdf = "/Lims/Report/{Code}/{ReportId}";
public const string RouteReportGenerateSourcePath = "/Report/Excel";
public const string RouteReportGenerateCombineSourcePath = "/Report/Excel01";
public const string RouteReportSampleFilePath = "/Samples/Images";
public static List<string> JudgementNoPassResults = new List<string> { "不合格", "不符合", "抗沾湿性能较差", "抗沾湿性能差", "不具有抗沾湿性能", "抗勾丝性能差", "抗静水压性能差", "抗静电性能差" };
public static ILog Logger { get; } = LogManager.GetLogger("Kivii.Lac.Lims");
}
}
Src/Entities/B2bLink.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
[Alias(Configs.TableNameB2bLink)]
[Api(Description = "电商客户关系表")]
public class B2bLink: EntityWithMetadata, IEntityInAssemblyDb,
IEntityHasCreator,IEntityHasUpdater
{
[ApiMember(Description = "所属客户Kvid")]
[IgnoreUpdate]
[Required]
public Guid OwnerKvid { get; set; }
[ApiMember(Description = "所属客户名称")]
[Default("")]
[StringLength(500)]
public string OwnerName { get; set; }
[ApiMember(Description = "关联类型")]
[StringLength(100)]
public LinkType LinkType { get; set; }
[ApiMember(Description = "关联客户Kvid")]
[IgnoreUpdate]
[Required]
public Guid LinkKvid { get; set; }
[ApiMember(Description = "关联客户名称")]
[Default("")]
[StringLength(500)]
public string LinkName { get; set; }
[ApiMember(Description = "配置参数")]
[StringLength(int.MaxValue)]//必须要配置StringLength,因为序列化的文本比较大
//Default(""), 不能赋空值,在mySql中会报错
public string Parameters { get; set; }
[ApiMember(Description = "配置查询")]
[StringLength(int.MaxValue)]//必须要配置StringLength,因为序列化的文本比较大
public string Filters { get; set; }
[ApiMember(Description = "备注")]
[StringLength(2000)]
public string Remark { get; set; }
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
public enum LinkType
{
Unsupported = 0,// 不支持的类型
/// <summary>
/// 委托单位
/// </summary>
Demander,
/// <summary>
/// 生产单位
/// </summary>
Manufacturer,
/// <summary>
/// 付款单位
/// </summary>
Payer
}
}
Src/Entities/Report.cs 0 → 100644
using Kivii.DataAnnotations;
using Kivii.Lac.Lims.Interfaces;
using Kivii.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
public enum ReportStatusType
{
Unsupported = 0,
/// <summary>
/// 委托受理
/// </summary>
CommissionAccept = 100,
/// <summary>
/// 合同评审
/// </summary>
ContractReview = 200,
/// <summary>
/// 任务分派
/// </summary>
TaskAssign = 300,
/// <summary>
/// 数据录入
/// </summary>
DataEntry = 400,
/// <summary>
/// 报告编制
/// </summary>
ReportPreparation = 500,
/// <summary>
/// 报告审核
/// </summary>
ReportReview = 600,
/// <summary>
/// 报告签发
/// </summary>
ReportIssue = 700,
/// <summary>
/// 报告打印
/// </summary>
ReportPrint = 800,
/// <summary>
/// 报告归档
/// </summary>
ReportCollected = int.MaxValue
}
public abstract class ReportBase : EntityWithMetadata
{
#region 报告编号组成要素
[DefaultEmptyGuid]
public Guid BizKvid { get; set; }
[ApiMember(Description = "业务流水号")]
[StringLength(200)]
[Default("")]
public string BizId { get; set; }
[ApiMember(Description = "业务类型")]
[StringLength(100)]
[Default("")]
public string BizType { get; set; }
/// <summary>
/// 报告编号,全系统唯一
/// </summary>
[ApiMember(Description = "报告编号")]
//[Unique, IgnoreUpdate]//流水号本身就是支持Unique的，不需要重复写，并且报告号是允许更新的，万一他们写错了
[StringLength(50),Default(""),SerialNumber(NumberField = nameof(ReportIdNumber))]
public string ReportId { get; set; }
/// <summary>
/// 报告编号的流水号数字部分
/// </summary>
[ApiMember(Description ="流水号")]
[Default(0)]
public int ReportIdNumber { get; set; }
/// <summary>
/// 报告类型
/// 纺织品报告(F),子部门报告(A、B、C、D)
/// </summary>
[ApiMember(Description = "报告类型")]
[StringLength(20), Default("")]
public string Type { get; set; }
/// <summary>
/// 报告类型后缀
/// 委托报告(W),监督报告(J)
/// </summary>
[ApiMember(Description = "报告类型扩展")]
[StringLength(20), Default("")]
public string TypeEx { get; set; }
/// <summary>
/// 报告类型名称中文显示
/// 委托送样，委托抽样
/// </summary>
[ApiMember(Description = "报告类型名称")]
[StringLength(20), Default("")]
public string TypeName { get; set; }
/// <summary>
/// 报告分类，现记录客户编码（报告后缀）UR......
/// </summary>
[ApiMember(Description = "报告分类")]
[StringLength(20), Default("")]
public string Category { get; set; }
#endregion
#region 供需双方信息
//供方可以是组织，也可以是部门
[ApiMember(Description = "供方Kvid")]
[DefaultEmptyGuid]
public Guid SupplierKvid { get; set; }
[ApiMember(Description = "供方名称,即检测单位")]
[StringLength(100), Required]
public string SupplierName { get; set; }
[ApiMember(Description = "供方联系人Kvid")]
[DefaultEmptyGuid]
public Guid SupplierContactKvid { get; set; }
[ApiMember(Description = "供方联系人")]
[StringLength(100), Default("")]
public string SupplierContactName { get; set; }
[ApiMember(Description = "供方联系电话")]
[StringLength(50), Default("")]
public string SupplierContactNumber { get; set; }
[ApiMember(Description = "供方联系地址")]
public string SupplierContactAddress { get; set; }
[ApiMember(Description = "需方Kvid")]
[DefaultEmptyGuid]
public Guid DemanderKvid { get; set; }
[ApiMember(Description = "需方名称,即委托单位")]
[StringLength(100), Required]
public string DemanderName { get; set; }
[DefaultEmptyGuid]
public Guid DemanderContactKvid { get; set; }
[ApiMember(Description = "需方联系人")]
[StringLength(100), Default("")]
public string DemanderContactName { get; set; }
[ApiMember(Description = "需方联系电话")]
[StringLength(50), Default("")]
public string DemanderContactNumber { get; set; }
[ApiMember(Description = "需方联系地址")]
public string DemanderContactAddress { get; set; }
#endregion
#region 收付双方 Payer付款单位,贷方 Payee收款单位,借方
[DefaultEmptyGuid]
public Guid PayerKvid { get; set; }
[ApiMember(Description = "付款单位,贷方")]
[StringLength(100)]
public string PayerName { get; set; }
[IgnoreUpdate]
[DefaultEmptyGuid]
public Guid PayeeKvid { get; set; }
[ApiMember(Description = "收款单位,借方")]
[IgnoreUpdate]
[StringLength(100), Required]
public string PayeeName { get; set; }
#endregion
#region 样品相关，和sample冗余
[ApiMember(Description = "样品Kvid")]
[IgnoreUpdate]
[Required]
public Guid SampleKvid { get; set; }
/// <summary>
/// 样品名称
/// </summary>
[ApiMember(Description = "样品名称")]
[StringLength(200), Required]
public string SampleName { get; set; }
/// <summary>
/// 样品名称
/// </summary>
[ApiMember(Description = "样品编号")]
//[SerialNumber]
[StringLength(50), Default("")]
public string SampleSerialNumber { get; set; }
/// <summary>
/// 样品批次号
/// </summary>
[ApiMember(Description = "样品批次号")]
[StringLength(200), Default("")]
public string SampleBatchNumber{ get; set; }
/// <summary>
/// 样品品牌
/// </summary>
[ApiMember(Description = "样品品牌")]
[StringLength(200), Default("")]
public string SampleBrand { get; set; }
/// <summary>
/// 样品规格型号
/// </summary>
[ApiMember(Description = "样品规格型号")]
[StringLength(200), Default("")]
public string SampleModel { get; set; }
/// <summary>
/// 样品数量
/// </summary>
[ApiMember(Description = "样品数量")]
[DecimalLength(10,2),Default(0)]
public decimal SampleQuantity { get; set; }
/// <summary>
/// 数量单位，老数据的样品数量和单位记到metadata中了
/// </summary>
[ApiMember(Description = "样品数量单位")]
[StringLength(50),Default("")]
public string SampleQuantityUnit { get; set; }
/// <summary>
/// 样品品级
/// </summary>
[ApiMember(Description = "样品品级")]
[StringLength(200), Default("")]
public string SampleGrade { get; set; }
/// <summary>
/// 安全类别
/// </summary>
[ApiMember(Description = "安全类别")]
[StringLength(200), Default("")]
public string SampleGradeSafety { get; set; }
/// <summary>
/// 功能等级
/// </summary>
[ApiMember(Description = "功能等级")]
[StringLength(200), Default("")]
public string SampleGradeFunction { get; set; }
[ApiMember(Description = "生产单位Kvid")]
[DefaultEmptyGuid]
public Guid SampleManufacturerKvid { get; set; }
[ApiMember(Description = "生产单位")]
[StringLength(100), Default("")]
public string SampleManufacturerName { get; set; }
[ApiMember(Description = "生产单位联系人Kvid")]
[DefaultEmptyGuid]
[IgnoreUpdate]
public Guid SampleManufacturerContactKvid { get; set; }
[ApiMember(Description = "生产单位联系人姓名")]
[StringLength(50), Default("")]
public string SampleManufacturerContactName { get; set; }
[ApiMember(Description = "生产单位联系人电话")]
[StringLength(50), Default("")]
//正则表达式验证：(^(\d{3,4}-)?\d{7,8})$|(13[0-9]{9})
public string SampleManufacturerContactNumber { get; set; }
[ApiMember(Description = "生产单位地址")]
[StringLength(200), Default("")]
public string SampleManufacturerAddress { get; set; }
#endregion
#region 样品来源相关，和SampleSource冗余
[DefaultEmptyGuid]
public Guid SampleSourceKvid { get; set; }
/// <summary>
/// 样品来源编号，计划编号，快递号等
/// </summary>
[ApiMember(Description = "来源编号")]
[StringLength(200), Default("")]
public string SampleSourceBatchNumber { get; set; }
#endregion
#region 检验相关
/// <summary>
/// 检验依据
/// </summary>
[ApiMember(Description = "检验依据")]
[StringLength(1000), Default("")]
public string TestStandards { get; set; }
/// <summary>
/// 检测项目
/// </summary>
[ApiMember(Description = "检测项目")]
[StringLength(3000), Default("")]
public string TestDetections { get; set; }
/// <summary>
/// 检验要求：判定、数据
/// </summary>
[ApiMember(Description ="检验要求，是否需要判定")]
[Required]
public bool TestNeedJudge { get; set; }
/// <summary>
/// 产品质量综合判定
/// </summary>
[ApiMember(Description = "产品质量综合判定")]
[StringLength(200), Default("")]
public string TestJudgement { get; set; }
#endregion
#region 日期相关
/// <summary>
/// 委托日期:默认为当天日期
/// </summary>
[ApiMember(Description ="委托日期")]
[DateOnly]
[NonClusteredIndex]
public DateTime? DealDate { get; set; }
/// <summary>
/// 完成日期(前台选择)
/// </summary>
[ApiMember(Description = "要求完成日期")]
[DateOnly]
[NonClusteredIndex]
public DateTime? DeadDate { get; set; }
/// <summary>
/// 评审日期
/// </summary>
[ApiMember(Description = "评审日期")]
[DateOnly]
public DateTime? ContractReviewDate { get; set; }
/// <summary>
/// 分派日期
/// </summary>
[ApiMember(Description = "分派日期")]
[DateOnly]
public DateTime? TaskAssignDate { get; set; }
/// <summary>
/// 检验开始日期(为委托的下达日期)
/// </summary>
[ApiMember(Description = "检验开始日期")]
public DateTime? TestStartDate { get; set; }
/// <summary>
/// 检验结束日期
/// 默认为编制时的当天日期
/// </summary>
[ApiMember(Description = "检验结束日期")]
public DateTime? TestFinishDate { get; set; }
/// <summary>
/// 编制日期
/// </summary>
[ApiMember(Description = "编制日期")]
public DateTime? PreparationDate { get; set; }
/// <summary>
/// 审核日期
/// </summary>
[ApiMember(Description = "审核日期")]
[DateOnly]
public DateTime? ReviewDate { get; set; }
/// <summary>
/// 签发日期
/// </summary>
[ApiMember(Description = "签发日期")]
[InternalSetter]
[DateOnly]
[NonClusteredIndex]
public DateTime? IssueDate { get; set; }
#endregion
#region 报告受理，编制，审核，签发人员信息
/// <summary>
/// 受理人Kvid
/// </summary>
[DefaultEmptyGuid]
public Guid OperatorKvid { get; set; }
/// <summary>
/// 受理人姓名，不一定是Creator（从第三方系统进来的报告）
/// </summary>
[ApiMember(Description = "受理人")]
[StringLength(20), Default("")]
public string OperatorName { get; set; }
/// <summary>
/// 主检人
/// </summary>
[ApiMember(Description ="主检人")]
[StringLength(50),Default("")]
public string ManagerName { get; set; }
/// <summary>
/// 主检人Kvid
/// </summary>
[DefaultEmptyGuid]
public Guid ManagerKvid { get; set; }
/// <summary>
/// 编制人Kvid
/// </summary>
[DefaultEmptyGuid]
public Guid PreparerKvid { get; set; }
/// <summary>
/// 编制人姓名
/// </summary>
[ApiMember(Description ="编制人")]
[StringLength(50),Default("")]
public string PreparerName { get; set; }
/// <summary>
/// 审核人Kvid
/// </summary>
[DefaultEmptyGuid]
public Guid ReviewerKvid { get; set; }
/// <summary>
/// 审核人姓名
/// </summary>
[ApiMember(Description = "审核人")]
[StringLength(50), Default("")]
public string ReviewerName { get; set; }
/// <summary>
/// 签发人Kvid
/// </summary>
[DefaultEmptyGuid]
public Guid IssuerKvid { get; set; }
/// <summary>
/// 签发人姓名
/// </summary>
[ApiMember(Description = "签发人")]
[StringLength(50), Default("")]
public string IssuerName { get; set; }
#endregion
#region 报告模板及格式份数
[DefaultEmptyGuid]
public Guid TemplateKvid { get; set; }
/// <summary>
/// 报告格式
/// </summary>
[ApiMember(Description ="报告格式")]
[StringLength(200),Default("")]
public string TemplateName { get; set; }
/// <summary>
/// 报告份数
/// </summary>
[ApiMember(Description ="报告份数")]
[DecimalLength(4,2),Default(0)]
public decimal Quantity { get; set; }
[ApiMember(Description ="数量单位")]
[Ignore]
public string QuantityUnit {
get
{
return "份";
}
}
/// <summary>
/// 加急系数
/// </summary>
[ApiMember(Description = "加急系数")]
[DecimalLength(4, 2), Default(1)]
public decimal UrgentRate { get; set; } = 1;
/// <summary>
/// 报告是否显示生产单位
/// </summary>
//[ApiMember(Description = "报告是否显示生产单位")]
//public bool ShowProductOrg { get; set; }
#endregion
#region 费用相关信息
/// <summary>
/// 单价,仅指报告打印的单价
/// </summary>
[ApiMember(Description = "单价")]
[DecimalLength(10,2),Default(0)]
public decimal QuantityUnitPrice { get; set; }
/// <summary>
/// 理论单价
/// </summary>
[ApiMember(Description = "理论单价")]
[DecimalLength(10, 2), Default(0)]
public decimal QuantityUnitPricePlan { get; set; }
/// <summary>
/// 检验费，ReportItem中的Amount总和
/// </summary>
[ApiMember(Description = "检验费")]
[InternalSetter]
[DecimalLength(10, 2), Default(0)]
public decimal AmountTest { get; set; }
/// <summary>
/// 理论检验费，ReportItem中的AmountPlan总和
/// </summary>
[ApiMember(Description = "理论检验费")]
[InternalSetter]
[DecimalLength(10, 2), Default(0)]
public decimal AmountTestPlan { get; set; }
/// <summary>
/// 报告的费用,N份报告的打印费用
/// </summary>
[ApiMember(Description = "报告费")]
[DecimalLength(10, 2), Default(0)]
public decimal Amount { get; set; }
/// <summary>
/// 理论报告的费用
/// </summary>
[ApiMember(Description = "理论报告费")]
[DecimalLength(10, 2), Default(0)]
public decimal AmountPlan { get; set; }
[ApiMember(Description = "货币单位")]
[IgnoreUpdate]
[StringLength(50), Required]
public CurrencyUnit Currency { get; set; }
/// <summary>
/// 结算总费用：即实际费用结算的费用
/// </summary>
[ApiMember(Description = "结算总费用")]
[DecimalLength(10, 2), Default(0)]
[InternalSetter]
public decimal AmountSettlement { get; set; }
/// <summary>
/// 已缴总费用：即费用结算后所缴纳的实际费用
/// </summary>
[ApiMember(Description = "已缴总费用")]
[DecimalLength(10, 2), Default(0)]
[InternalSetter]
public decimal AmountPayment { get; set; }
/// <summary>
/// 执行的协议Kvid
/// </summary>
[ApiMember(Description = "执行协议Kvid")]
[DefaultEmptyGuid]
[IgnoreUpdate]
public Guid QuotationKvid { get; set; }
/// <summary>
/// 执行的协议名称
/// </summary>
[ApiMember(Description = "执行协议名称")]
[StringLength(200),Default("")]
[IgnoreUpdate]
public string QuotationName { get; set; }
/// <summary>
/// 执行的协议的价格，若价格大于0，则以此价格为准
/// </summary>
[ApiMember(Description = "执行协议价格")]
[DecimalLength(10, 2), Default(0)]
[IgnoreUpdate]
public decimal QuotationAmount { get; set; }
/// <summary>
/// 协议的折扣，0-1之间
/// </summary>
[ApiMember(Description = "协议折扣率")]
[DecimalLength(4,2),Default(1)]
[IgnoreUpdate]
public decimal? QuotationDiscountRate { get; set; }
#endregion
/// <summary>
/// 检验结论，报告的结论
/// </summary>
[ApiMember(Description = "检验结论")]
[StringLength(2000), Default("")]
public string Conclusion { get; set; }
/// <summary>
/// 备注
/// </summary>
[ApiMember(Description = "备注")]
[StringLength(2000), Default("")]
public string Remark { get; set; }
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
[Ignore]
public ReportStatusType StatusType
{
get
{
return (ReportStatusType)Status;
}
set
{
Status = (int)value;
}
}
#region use cache
private List<ReportItem> _reportItems;
private List<ReportItem> _platReportItems;
public void SetReportItems(List<ReportItem> reportItems)
{
_reportItems = reportItems;
}
public List<ReportItem> GetOriginalReportItems(IDbConnection conn = null)
{
if (_reportItems != null) return _reportItems;
if (conn == null) conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
var query = conn.From<ReportItem>();
query.Where(o => o.ReportKvid == Kvid);
var rtnReportItems = conn.Select(query);
if (rtnReportItems.IsNullOrEmpty()) return null;
_reportItems = rtnReportItems;
return _reportItems;
}
#region 调试优化
//生成检测报告的项目模版调用
public List<ReportItem> GetPlatReportItems(IDbConnection conn = null)
{
if (_platReportItems != null) return _platReportItems;
var reportItems = GetOriginalReportItems(conn);
if (reportItems.IsNullOrEmpty()) return null;
var treeItems = getTreeItems(reportItems, Guid.Empty);
var rtns = new List<ReportItem>();
getPlatItems(treeItems, rtns);
_platReportItems = rtns;
return rtns;
}
#endregion
public List<ReportItem> GetReportItems()
{
var conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
var query = conn.From<ReportItem>();
query.Where(o => o.ReportKvid == Kvid);
query.OrderBy(o => o.SortId).ThenBy(o => o.SortIdEx).ThenBy(o=>o.Title);
var reportItems = conn.Select(query);
//var reportItems = GetOriginalReportItems(null);
if (reportItems.IsNullOrEmpty()) return null;
var treeItems = getTreeItems(reportItems, Guid.Empty);
var rtns = new List<ReportItem>();
getPlatItems(treeItems, rtns);
conn.Dispose();
return rtns;
}
private List<ReportItem> getTreeItems(List<ReportItem> datasource, Guid kvid)
{
var rtns = datasource.Where(o => o.ParentKvid == kvid).OrderBy(o=>o.SortId).ThenBy(o=>o.SortIdEx).ThenBy(o=>o.Title).ToList();
if (rtns.IsNullOrEmpty()) return null;
foreach (var rtn in rtns)
{
rtn.SubItems = getTreeItems(datasource, rtn.Kvid);
}
return rtns;
}
private void getPlatItems(List<ReportItem> treeItems, List<ReportItem> rtns)
{
if (treeItems.IsNullOrEmpty()) return;
foreach (var item in treeItems)
{
rtns.Add(item);
getPlatItems(item.SubItems, rtns);
item.SubItems = null;
}
}
//获取该报告所需要的资源文件，如报告首页扫描图片，报告底页图片
public List<EntityDbFile<Sample>> GetSources(IDbConnection conn = null)
{
if(conn == null) conn = KiviiContext.GetOpenedDbConnection<EntityDbFile<Sample>>();
var query = conn.From<EntityDbFile<Sample>>();
query.Where(o => o.OwnerKvid == this.SampleKvid && o.ParentKvid == Guid.Empty && o.Tags != null && o.Tags != "");
query.Select(o => new { o.Tags, o.Kvid,o.Name,o.DbFolderPath });
query.OrderBy(o => o.Tags);
query.ThenBy(o => o.CreateTime);
var sampleFiles = conn.Select(query);
foreach(var en in sampleFiles)
{
en.Path = $"/Storages{en.DbFolderPath}/{en.Kvid}/{en.Name}";
}
return sampleFiles;
}
#endregion
}
[Alias(Configs.TableNameReport)]
[Api(Description = "检验报告")]
public class Report : ReportBase, IEntityHasPayer, IEntityHasPayee, IEntityHasSettlement,
IEntityHasPayment, IEntityHasDemander, IEntityHasSupplier, IEntityInAssemblyDb
{
#region 反射方法
public bool IsCertificated(string typeName,string certificateType)
{
var remoteType = Kivii.Text.AssemblyUtils.FindType(typeName);
if (remoteType == null) return false;
var remoteInstance = (IReportInterface)Activator.CreateInstance(remoteType);
return (bool)remoteInstance.Execute(this, certificateType);
}
#endregion
}
[Alias(Configs.TableNameReportHistory)]
[Api(Description = "归档报告")]
public class ReportHistory : ReportBase, IEntityHasPayer, IEntityHasPayee, IEntityHasSettlement,
IEntityHasPayment, IEntityHasDemander, IEntityHasSupplier, IEntityInAssemblyDb
{
}
[Alias(Configs.TableNameReport)]
[Api(Description = "删除报告")]
public class ReportDeleted : ReportBase, IEntityHasPayer, IEntityHasPayee, IEntityHasSettlement,
IEntityHasPayment, IEntityHasDemander, IEntityHasSupplier, IEntityInAssemblyDb
{
[GlobalFilter("<0")]
public new int Status { get; set; }
}
/// <summary>
/// 此实体只用于更新协议相关信息
/// </summary>
[Alias(Configs.TableNameReport)]
public class ReportQuotation : EntityWithMetadata
{
/// <summary>
/// 加急系数
/// </summary>
[ApiMember(Description = "加急系数")]
[DecimalLength(4, 2), Default(1)]
[IgnoreUpdate]
public decimal UrgentRate { get; set; } = 1;
/// <summary>
/// 检验费，ReportItem中的Amount总和*加急系数
/// </summary>
[ApiMember(Description = "检验费")]
[InternalSetter]
[DecimalLength(10, 2), Default(0)]
public decimal AmountTest { get; set; }
/// <summary>
/// 理论检验费，ReportItem中的AmountPlan总和*加急系数
/// </summary>
[ApiMember(Description = "理论检验费")]
[InternalSetter]
[DecimalLength(10, 2), Default(0)]
public decimal AmountTestPlan { get; set; }
/// <summary>
/// 执行的协议Kvid
/// </summary>
[ApiMember(Description = "执行协议Kvid")]
[DefaultEmptyGuid]
public Guid QuotationKvid { get; set; }
/// <summary>
/// 执行的协议名称
/// </summary>
[ApiMember(Description = "执行协议名称")]
[StringLength(200), Default("")]
public string QuotationName { get; set; }
/// <summary>
/// 执行的协议的价格，若价格大于0，则以此价格为准
/// </summary>
[ApiMember(Description = "执行协议价格")]
[DecimalLength(10, 2), Default(0)]
public decimal QuotationAmount { get; set; }
/// <summary>
/// 协议的折扣，0-1之间
/// </summary>
[ApiMember(Description = "协议折扣率")]
[DecimalLength(4, 2), Default(1)]
public decimal QuotationDiscountRate { get; set; }
}
}
Src/Entities/ReportChange.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
/// <summary>
/// Status约束：100（草稿状态），150（审批中），200（审批通过）
/// </summary>
[Alias(Configs.TableNameReportChange)]
[Api(Description = "报告更改")]
public class ReportChange: EntityWithMetadata
{
#region 第三方关联
[ApiMember(Description = "业务Kvid")]
[IgnoreUpdate]
[DefaultEmptyGuid]
public Guid BizKvid { get; set; }
[ApiMember(Description = "业务流水号")]
[IgnoreUpdate]
[StringLength(200), Default("")]
public string BizId { get; set; }
[ApiMember(Description = "业务类型,指实体类型全名称")]
[IgnoreUpdate]
[StringLength(200), Default("")]
public string BizType { get; set; }
#endregion
#region 关联信息
/// <summary>
/// 关联报告Kvid
/// </summary>
[ApiMember(Description = "报告Kvid")]
[DefaultEmptyGuid]
public Guid ReportKvid { get; set; }
#endregion
#region 原报告信息，冗余信息
/// <summary>
/// 报告编号
/// </summary>
[ApiMember(Description = "报告编号")]
[StringLength(50), Default("")]
public string ReportId { get; set; }
/// <summary>
/// 委托单位
/// </summary>
[ApiMember(Description = "需方Kvid")]
[DefaultEmptyGuid]
public Guid ReportDemanderKvid { get; set; }
[ApiMember(Description = "需方名称,即检测单位")]
[StringLength(100), Required]
public string ReportDemanderName { get; set; }
[DefaultEmptyGuid]
public Guid ReportDemanderContactKvid { get; set; }
[ApiMember(Description = "需方联系人")]
[StringLength(100), Default("")]
public string ReportDemanderContactName { get; set; }
/// <summary>
/// 生产单位
/// </summary>
[ApiMember(Description = "生产单位Kvid")]
[DefaultEmptyGuid]
public Guid ReportSampleManufacturerKvid { get; set; }
[ApiMember(Description = "生产单位")]
[StringLength(100), Default("")]
public string ReportSampleManufacturerName { get; set; }
/// <summary>
/// 样品名称
/// </summary>
[ApiMember(Description = "样品名称")]
[StringLength(200), Required]
public string ReportSampleName { get; set; }
/// <summary>
/// 样品批次号
/// </summary>
[ApiMember(Description = "样品批次号")]
[StringLength(200), Default("")]
public string ReportSampleBatchNumber { get; set; }
/// <summary>
/// 检验依据
/// </summary>
[ApiMember(Description = "检验依据")]
[StringLength(1000), Default("")]
public string ReportTestStandards { get; set; }
/// <summary>
/// 原报告付款单位Kvid
/// </summary>
[DefaultEmptyGuid]
public Guid ReportPayerKvid { get; set; }
/// <summary>
/// 原报告付款单位
/// </summary>
[ApiMember(Description = "付款单位,贷方")]
[StringLength(100)]
public string ReportPayerName { get; set; }
/// <summary>
/// 报告受理人Kvid
/// </summary>
[ApiMember(Description = "原报告受理人Kvid")]
[DefaultEmptyGuid]
public Guid ReportOperatorKvid { get; set; }
/// <summary>
/// 报告接待人(受理人)
/// </summary>
[ApiMember(Description = "受理人姓名")]
[StringLength(50), Default("")]
public string ReportOperatorName { get; set; }
/// <summary>
/// 报告签发人Kvid
/// </summary>
[ApiMember(Description = "原报告签发人Kvid")]
[DefaultEmptyGuid]
public Guid ReportIssuerKvid { get; set; }
/// <summary>
/// 报告签发人
/// </summary>
[ApiMember(Description = "签发人姓名")]
[StringLength(50), Default("")]
public string ReportIssuerName { get; set; }
/// <summary>
/// 原报告委托日期
/// </summary>
[ApiMember(Description = "委托日期")]
public DateTime? ReportDealDate { get; set; }
/// <summary>
/// 原报告要求完成日期
/// </summary>
[ApiMember(Description = "完成日期")]
public DateTime? ReportDeadDate { get; set; }
/// <summary>
/// 原报告备注
/// </summary>
[ApiMember(Description = "报告备注")]
[StringLength(2000), Default("")]
public string ReportRemark { get; set; }
#endregion
#region 基本信息
[ApiMember(Description = "编号")]
[SerialNumber]
[StringLength(100), Default("")]
public string SerialNumber { get; set; }
/// <summary>
/// 报告份数
/// </summary>
[ApiMember(Description = "报告份数")]
[DecimalLength(4, 2), Default(0)]
public decimal Quantity { get; set; }
[ApiMember(Description = "数量单位")]
[Ignore]
public string QuantityUnit
{
get
{
return "份";
}
}
/// <summary>
/// 更改类型
/// </summary>
[ApiMember(Description = "更改类型")]
[StringLength(200)]
[Default("")]
public string Type { get; set; }
/// <summary>
/// 更改报告内容
/// </summary>
[ApiMember(Description = "更改内容")]
[StringLength(2000)]
public string Content { get; set; }
/// <summary>
/// 费用信息
/// </summary>
[ApiMember(Description = "货币单位")]
[IgnoreUpdate]
[StringLength(50), Required]
public CurrencyUnit Currency { get; set; }
[ApiMember(Description = "更改费")]
[DecimalLength(10, 2), Default(0)]
public decimal Amount { get; set; }
/// <summary>
/// 经办人Kvid
/// </summary>
[DefaultEmptyGuid]
public Guid OperatorKvid { get; set; }
/// <summary>
/// 更改报告受理人(经办人)
/// </summary>
[ApiMember(Description = "经办人姓名")]
[StringLength(20), Default("")]
public string OperatorName { get; set; }
/// <summary>
/// 责任人
/// </summary>
[ApiMember(Description = "责任人Kvid")]
[DefaultEmptyGuid]
public Guid PersonLiableKvid { get; set; }
[ApiMember(Description = "责任人姓名")]
[StringLength(50), Default("")]
public string PersonLiableName { get; set; }
/// <summary>
/// 审批人
/// </summary>
[ApiMember(Description = "审批人Kvid")]
[DefaultEmptyGuid]
public Guid ApproverKvid { get; set; }
[ApiMember(Description = "审批人姓名")]
[StringLength(50), Default("")]
public string ApproverName { get; set; }
/// <summary>
/// 受理日期:默认为当天日期
/// </summary>
[ApiMember(Description = "受理日期")]
public DateTime? OperateDate { get; set; }
/// <summary>
/// 要求完成日期
/// </summary>
[ApiMember(Description = "完成日期")]
public DateTime? DeadDate { get; set; }
/// <summary>
/// 备注
/// </summary>
[ApiMember(Description = "备注")]
[StringLength(2000), Default("")]
public string Remark { get; set; }
#endregion
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
}
Src/Entities/ReportFile.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
[Api(Description = "报告文件")]
[Alias(Configs.TableNameReportFile)]
public class ReportFile: EntityWithMetadata, IEntityInAssemblyDb
{
/// <summary>
/// 报告号
/// </summary>
[Required]
[ApiMember(Description = "所属报告Kvid")]
public Guid ReportKvid { get; set; }
/// <summary>
/// 使用到的模板的Kvid,避免更新Report中的Template后，重新生成ReportFile
/// </summary>
[Required]
[ApiMember(Description = "所属模板Kvid")]
public Guid TemplateKvid { get; set; }
/// <summary>
/// 文件Kvid
/// </summary>
//[DefaultEmptyGuid]
//[ApiMember(Description = "存储Kvid")]
//public Guid DbFileKvid { get; set; }
/// <summary>
/// 模板Kvid
/// </summary>
[Required]
[ApiMember(Description = "模板Kvid")]
public Guid TemplateFileKvid { get; set; }
/// <summary>
/// 文件名称
/// </summary>
[StringLength(200),Required]
[ApiMember(Description = "文件名称")]
public string Name { get; set; }
/// <summary>
/// 文件标签,
/// 设计规则：
/// 在某一状态需要重新生成，则在状态值前加G
/// 如：G100,代表Status为100时，重新生成文件；
/// 200，代表Status为200时根据已经生成的文件基础上执行生成程序
/// </summary>
[Default("")]
[StringLength(200)]
[ApiMember(Description = "文件标签")]
public string Tags { get; set; }
/// <summary>
/// 模板路径
/// </summary>
[StringLength(500),Required]
[ApiMember(Description = "模板路径")]
public string TemplateFilePath { get; set; }
/// <summary>
/// 排序号，一定要正确，合成报告时用到
/// </summary>
[Default(0)]
[ApiMember(Description = "排序号")]
public int SortID { get; set; }
/// <summary>
/// 生成的报告路径
/// </summary>
[StringLength(500)]
[Default("")]
[ApiMember(Description = "生成路径")]
public string Path { get; set; }
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
}
Src/Entities/ReportItem.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
/// <summary>
/// 检验项目类型
/// </summary>
public enum ReportItemType
{
/// <summary>
/// 不支持的
/// </summary>
Unsupported = 0,
/// <summary>
/// 目录类型
/// </summary>
Folder=1,
/// <summary>
/// 检测项目录,有子项的大项
/// </summary>
TestFolder=2,
/// <summary>
/// 检测项，子项或者无子项的大项
/// </summary>
Test=3,
/// <summary>
/// 样品自身属性，如色号
/// </summary>
SampleSelf=4,
/// <summary>
/// 样品的部分属性,如部位
/// </summary>
SamplePart=5
}
public enum ReportItemStatusType
{
Unsupported = 0,
//待检测
BeforeTest = 100,
//分派中
Asigning = 150,
/// <summary>
/// 正在测试？
/// </summary>
//检测中
Testing = 200,
//待复核
BeforeReview = 250,
//已复核
TestFinished = 300,
/// <summary>
/// 检测结束
/// </summary>
TestCollected = int.MaxValue
}
public abstract class ReportItemBase : EntityWithMetadata
{
#region 第三方关联，关联业务
[ApiMember(Description = "业务Kvid")]
[IgnoreUpdate]
[DefaultEmptyGuid]
public Guid BizKvid { get; set; }
[ApiMember(Description = "业务流水号")]
[IgnoreUpdate]
[StringLength(200), Default("")]
public string BizId { get; set; }
[ApiMember(Description = "业务类型,指实体类型全名称")]
[IgnoreUpdate]
[StringLength(200), Default("")]
public string BizType { get; set; }
#endregion
#region 关联信息，关联报告，关联样品
/// <summary>
/// 当RootKvid为空，说明是原生的ReportItem
/// 否则则说明该ReportItem是引用生成的记录
/// 便于验证部分字段读写权限
/// 只有产品标准、标准值可修改，其他字段不可修改
/// </summary>
[ApiMember(Description = "根Kvid")]
[InternalSetter]
[DefaultEmptyGuid]
public Guid RootKvid { get; set; }
/// <summary>
/// 叛逆的报告Kvid
/// </summary>
[ApiMember(Description = "报告Kvid")]
[Required]
[IgnoreUpdate]
[NonClusteredIndex]
public Guid ReportKvid { get; set; }
/// <summary>
/// 样品编号，可以是子样品编号
/// </summary>
[ApiMember(Description = "样品Kvid")]
[Required]
[IgnoreUpdate]
public Guid SampleKvid { get; set; }
/// <summary>
/// 样品根Kvid
/// </summary>
[ApiMember(Description = "样品根Kvid")]
[DefaultEmptyGuid]
public Guid SampleRootKvid { get; set; }
#endregion
#region 关联标准，检验项目，引用的方法标准中的项目
/// <summary>
/// 引用标准Kvid
/// </summary>
[ApiMember(Description = "引用标准Kvid")]
[DefaultEmptyGuid]
public Guid StandardKvid { get; set; }
/// <summary>
/// 标准代码
/// </summary>
[ApiMember(Description = "标准代码")]
[Default("")]
[StringLength(200)]
public string StandardCode { get; set; }
/// <summary>
/// 标准名称
/// </summary>
[ApiMember(Description = "标准名称")]
[Default("")]
[StringLength(200)]
public string StandardTitle { get; set; }
/// <summary>
/// 引用检测项目Kvid
/// </summary>
[ApiMember(Description = "引用检测项目Kvid")]
[DefaultEmptyGuid]
public Guid DetectionKvid { get; set; }
/// <summary>
/// 引用检测项目名称
/// </summary>
[ApiMember(Description = "引用检测项目名称")]
[Default("")]
[StringLength(200)]
public string DetectionTitle { get; set; }
/// <summary>
/// 引用方法标准检测项目Kvid
/// </summary>
[ApiMember(Description = "引用方法标准检测项目Kvid")]
[DefaultEmptyGuid]
public Guid DetectionReferenceKvid { get; set; }
/// <summary>
/// 测试方法
/// </summary>
[ApiMember(Description = "测试方法")]
[Default("")]
[StringLength(500)]
public string DetectionCodeActual { get; set; }
/// <summary>
/// 标准值数值单位
/// </summary>
[Default("")]
[ApiMember(Description = "数值单位")]
[StringLength(100)]
public string DetectionUnit { get; set; }
/// <summary>
/// 标准值
/// </summary>
[ApiMember(Description = "标准值")]
[StringLength(2000)]
public string DetectionValueQualified { get; set; }
#endregion
#region 金额相关
/// <summary>
/// 货币单位
/// </summary>
[ApiMember(Description = "货币单位")]
[IgnoreUpdate]
[Default("")]
[StringLength(20)]
public CurrencyUnit Currency { get; set; }
/// <summary>
/// 服务Kvid
/// </summary>
[ApiMember(Description = "服务Kvid")]
[DefaultEmptyGuid]
public Guid GoodsKvid { get; set; }
/// <summary>
/// 包装Kvid
/// </summary>
[ApiMember(Description = "包装Kvid")]
[DefaultEmptyGuid]
public Guid PackageKvid { get; set; }
/// <summary>
/// 价格类型
/// </summary>
[ApiMember(Description = "价格类型")]
[Default("")]
public string PackageUnit { get; set; }
/// <summary>
/// 理论收费
/// </summary>
[ApiMember(Description = "理论收费")]
[DecimalLength(10, 2), Default(0)]
public decimal AmountPlan { get; set; }
/// <summary>
/// 实际收费
/// </summary>
[ApiMember(Description = "实际收费")]
[DecimalLength(10, 2), Default(0)]
public decimal Amount { get; set; }
#endregion
#region 检测Test相关
/// <summary>
/// 关联Test
/// </summary>
[ApiMember(Description = "关联Test")]
[DefaultEmptyGuid]
[InternalSetter]
public Guid TestKvid { get; set; }
/// <summary>
/// 关联TestRoot
/// </summary>
[ApiMember(Description = "关联TestRoot")]
[DefaultEmptyGuid]
[InternalSetter]
public Guid TestRootKvid { get; set; }
/// <summary>
/// 实测值
/// </summary>
[ApiMember(Description = "实测值")]
[StringLength(500), Default("")]
[InternalSetter]
public string TestValue { get; set; }
/// <summary>
/// 原始记录路径
/// </summary>
[ApiMember(Description = "原始记录路径")]
[StringLength(200), Default("")]
[InternalSetter]
public string TestOriginalFilePath { get; set; }
/// <summary>
/// 录入人员Kvid
/// </summary>
[ApiMember(Description = "录入人员Kvid")]
[DefaultEmptyGuid]
[InternalSetter]
public Guid TestCreatorKvid { get; set; }
/// <summary>
/// 录入人员
/// </summary>
[ApiMember(Description = "录入人员")]
[StringLength(50), Default("")]
[InternalSetter]
public string TestCreatorName { get; set; }
/// <summary>
/// 审核人员Kvid
/// </summary>
[ApiMember(Description = "审核人员Kvid")]
[DefaultEmptyGuid]
[InternalSetter]
public Guid TestReviewerKvid { get; set; }
/// <summary>
/// 审核人员
/// </summary>
[ApiMember(Description = "审核人员")]
[StringLength(50), Default("")]
//[InternalSetter]
public string TestReviewerName { get; set; }
/// <summary>
/// 当Test创建时，代表该次检验结束
/// </summary>
[ApiMember(Description = "检测结束时间")]
public DateTime? TestCreateTime { get; set; }
/// <summary>
/// 复核时间
/// </summary>
[ApiMember(Description = "复核时间")]
public DateTime? TestReviewTime { get; set; }
#endregion
#region 基本信息
/// <summary>
/// 关联父级检Kvid
/// </summary>
[ApiMember(Description = "关联父级检Kvid")]
[DefaultEmptyGuid]
public Guid ParentKvid { get; set; }
/// <summary>
/// 检验项目类型
/// </summary>
[ApiMember(Description = "检验项目类型")]
[StringLength(50)]
public ReportItemType Type { get; set; }
/// <summary>
/// 项目名称
/// </summary>
[ApiMember(Description = "项目名称", IsRequired = true)]
[Required]
[StringLength(500)]
public string Title { get; set; }
/// <summary>
/// 首要排序号
/// </summary>
[ApiMember(Description = "首要排序号")]
[Default(0)]
public int SortId { get; set; }
/// <summary>
/// 次要排序号
/// </summary>
[ApiMember(Description = "次要排序号")]
[Default(0)]
public int SortIdEx { get; set; }
/// <summary>
/// 判定结果
/// </summary>
[ApiMember(Description = "判定")]
[StringLength(200), Default("")]
public string Judgement { get; set; }
/// <summary>
/// 备注
/// </summary>
[ApiMember(Description = "备注")]
[StringLength(2000)]
public string Remark { get; set; }
#endregion
#region 检测人员信息
/// <summary>
/// 录入人员与检测人员的区别：
/// 录入人员指实际录数据的人员
/// 检测人员指实验还未开始，由相关部门将该检验分配给的指定检测人员
/// </summary>
[ApiMember(Description = "检测小组Kvid")]
[DefaultEmptyGuid]
public Guid WorkGroupKvid { get; set; }
/// <summary>
/// 检测小组名称
/// </summary>
[ApiMember(Description = "检测小组")]
[StringLength(50)]
public string WorkGroupName { get; set; }
/// <summary>
/// 检测人员Kvid
/// </summary>
[ApiMember(Description = "检测人员Kvid")]
[DefaultEmptyGuid]
public Guid WorkerKvid { get; set; }
/// <summary>
/// 检测人员名称
/// </summary>
[ApiMember(Description = "检测人员")]
[StringLength(50), Default("")]
public string WorkerName { get; set; }
#endregion
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
#region 其它不在数据库中的信息
/// <summary>
/// 用于查询 接口需要合并部位数据到大项中 返回使用，不记录在数据库中
/// </summary>
[Ignore]
public string TitlePart { get; set; }
/// <summary>
/// 用于查询 接口需要合并色号数据到大项中 返回使用，不记录在数据库中
/// </summary>
[Ignore]
public string TitleSelf { get; set; }
/// <summary>
/// 用于查询 接口需要合并部位数据到大项中 返回使用，不记录在数据库中
/// </summary>
[Ignore]
public Guid PartKvid { get; set; }
[Ignore]
public ReportItemStatusType StatusType
{
get
{
return (ReportItemStatusType)Status;
}
set
{
Status = (int)value;
}
}
/// <summary>
/// 子项，不在数据库中
/// </summary>
[Ignore]
public List<ReportItem> SubItems { get; set; }
#endregion
}
[Alias(Configs.TableNameReportItem)]
[Api(Description = "检验项目")]
public class ReportItem : ReportItemBase, IEntityInAssemblyDb
{
}
[Alias(Configs.TableNameReportItemHistory)]
[Api(Description = "归档报告")]
public class ReportItemHistory : ReportItemBase, IEntityInAssemblyDb
{
}
public class ReportItemEx : ReportItem
{
public string ReportId { get; set; }
public int ReportStatus { get; set; }
public string ReportDemanderName { get; set; }
public string ReportSampleManufacturerName { get; set; }
public string ReportTestDetections { get; set; }
public decimal? ReportAmountTestPlan { get; set; }
public decimal? ReportAmountTest { get; set; }
public decimal? ReportAmount { get; set; }
//以下用于委托报告不合格项目导出
public string ReportSampleName { get; set; }
public string ReportSampleBatchNumber { get; set; }
//工艺参数，是metadata字段
//
public string ReportTestStandards { get; set; }
public string ReportRemark { get; set; }
public DateTime? ReportDealDate { get; set; }
public DateTime? ReportDeadDate { get; set; }
public string ReportSampleBrand { get; set; }
public string ReportPayerName { get; set; }
public string ReportMetadataString { get; set; }
//以下用于监督报告统计
public string SamplingOrderID { get; set; }
public List<ReportItemEx> SubItemExs { get; set; }
}
}
Src/Entities/ReportNote.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
[Alias(Configs.TableNameReportNote)]
[Api(Description = "报告流转")]
public class ReportNote : EntityWithMetadata
{
#region 关联相关
/// <summary>
/// 报告Kvid
/// </summary>
[ApiMember(Description = "报告Kvid")]
[DefaultEmptyGuid]
public Guid ReportKvid { get; set; }
#endregion
/// <summary>
/// 流转标题
/// </summary>
[ApiMember(Description = "流转标题")]
[StringLength(100), Required]
public string Title { get; set; }
/// <summary>
/// 流转类型
/// </summary>
[ApiMember(Description = "流转类型")]
[StringLength(100), Default("")]
public string Type { get; set; }
/// <summary>
/// 当前流程
/// </summary>
[ApiMember(Description = "当前流程")]
[StringLength(100), Required]
public string From { get; set; }
/// <summary>
/// 目标流程
/// </summary>
[ApiMember(Description = "目标流程")]
[StringLength(100), Required]
public string To { get; set; }
/// <summary>
/// 操作人
/// </summary>
[ApiMember(Description = "操作人")]
[StringLength(100), Default("")]
public string OperatorName { get; set; }
/// <summary>
/// 操作人Kvid
/// </summary>
[ApiMember(Description = "操作人Kvid")]
public Guid OperatorKvid { get; set; }
/// <summary>
/// 操作日期
/// </summary>
[ApiMember(Description = "操作日期")]
public DateTime OperateTime { get; set; }
/// <summary>
/// 摘要
/// </summary>
[ApiMember(Description = "摘要")]
[StringLength(1000), Default("")]
public string Summary { get; set; }
/// <summary>
/// IP地址
/// </summary>
[ApiMember(Description = "IP地址")]
[StringLength(100), Default(""),IgnoreUpdate]
[CurrentIpAddress]
public string IP { get; set; }
}
public class ReportNoteEx : ReportNote
{
public string ReportId { get; set; }
public string ReportOperatorName { get; set; }
public string ReportPreparerName { get; set; }
}
}
Src/Entities/Sample.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
[Alias(Configs.TableNameSample)]
[Api(Description = "样品信息")]
public class Sample: EntityWithMetadata, IEntityInAssemblyDb,IEntityHasRemark,IEntityHasCreator, IEntityHasUpdater
{
#region 关联信息
[ApiMember(Description = "样品来源Kvid")]
[DefaultEmptyGuid]
public Guid SourceKvid { get; set; }
[InternalSetter]
[DefaultEmptyGuid]
public Guid RootKvid { get; set; }
[ApiMember(Description ="父级样品Kvid")]
[DefaultEmptyGuid]
public Guid ParentKvid { get; set; }
#endregion
#region 样品来源信息（冗余字段）
/// <summary>
/// 来源编号，若为抽样，则记录计划编号，若为邮寄到样，则记录快递单号
/// </summary>
[ApiMember(Description = "来源编号")]
[StringLength(200), Default("")]
public string SourceBatchNumber { get; set; }
[ApiMember(Description = "来样方式")]
[StringLength(50), Default("")]
public string SourceType { get; set; }
#endregion
#region 基本信息
[ApiMember(Description = "样品名称")]
[Required]
[StringLength(200)]
public string Name { get; set; }
[ApiMember(Description ="样品类型")]
[StringLength(50),Default("")]
public string Type { get; set; }
[ApiMember(Description = "样品批次编号")]
[StringLength(200), Default("")]
public string BatchNumber { get; set; }
[ApiMember(Description = "样品编号")]
[SerialNumber]
[StringLength(100), Default("")]
public string SerialNumber { get; set; }
[ApiMember(Description = "样品品牌")]
[StringLength(200),Default("")]
public string Brand { get; set; }
[ApiMember(Description = "样品规格")]
[StringLength(200), Default("")]
public string Specification { get; set; }
[ApiMember(Description = "样品型号")]
[StringLength(200), Default("")]
public string Model { get; set; }
[ApiMember(Description = "样品材质")]
[StringLength(200), Default("")]
public string Material { get; set; }
/// <summary>
/// 样品品级
/// </summary>
public string Grade { get; set; }
/// <summary>
/// 安全类别
/// </summary>
public string GradeSafety { get; set; }
[ApiMember(Description = "样品状况")]
[StringLength(200), Default("")]
public string Condition { get; set; }
#endregion
#region 数量相关
[ApiMember(Description = "样品数量")]
[DecimalLength(10, 2),Default(0)]
public decimal Quantity { get; set; }
[ApiMember(Description = "数量单位")]
[StringLength(50), Default("")]
public string QuantityUnit { get; set; }
#endregion
#region 生产单位信息及生产日期
[ApiMember(Description = "生产单位Kvid")]
[DefaultEmptyGuid]
[IgnoreUpdate]
public Guid ManufacturerKvid { get; set; }
[ApiMember(Description = "生产单位")]
[StringLength(100), Default("")]
public string ManufacturerName { get; set; }
[ApiMember(Description = "生产单位联系人Kvid")]
[DefaultEmptyGuid]
[IgnoreUpdate]
public Guid ManufacturerContactKvid { get; set; }
[ApiMember(Description = "生产单位联系人姓名")]
[StringLength(50), Default("")]
public string ManufacturerContactName { get; set; }
[ApiMember(Description = "生产单位联系人电话")]
[StringLength(50), Default("")]
//正则表达式验证：(^(\d{3,4}-)?\d{7,8})$|(13[0-9]{9})
public string ManufacturerContactNumber { get; set; }
[ApiMember(Description = "生产单位地址")]
[StringLength(200), Default("")]
public string ManufacturerAddress { get; set; }
[ApiMember(Description = "生产日期")]
public DateTime? ProductionDate { get; set; }
#endregion
#region 文本 备注
[ApiMember(Description = "备注")]
[StringLength(1000), Default("")]
public string Remark { get; set; }
#endregion
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
}
Src/Entities/SampleSource.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
[Alias(Configs.TableNameSampleSource)]
[Api(Description = "样品来源信息")]
public class SampleSource: EntityWithMetadata,IEntityHasBiz, IEntityInAssemblyDb, IEntityHasRemark, IEntityHasCreator, IEntityHasUpdater
{
#region 第三方关联V1.0
//可关联快递+省局抽样任务等信息
[ApiMember(Description = "业务Kvid")]
[IgnoreUpdate]
[DefaultEmptyGuid]
public Guid BizKvid { get; set; }
[ApiMember(Description = "业务流水号")]
[IgnoreUpdate]
[StringLength(200), Default("")]
public string BizId { get; set; }
[ApiMember(Description = "业务类型,指实体类型全名称")]
[IgnoreUpdate]
[StringLength(200), Default("")]
public string BizType { get; set; }
#endregion
#region 基本信息
/// <summary>
/// 送样，快递等
/// </summary>
[ApiMember(Description = "来源类型")]
[StringLength(100), Required]
public string Type { get; set; }
/// <summary>
/// 来源编号:若为邮寄到样，则记录快递单号
/// </summary>
[ApiMember(Description = "来源编号")]
[StringLength(200), Default("")]
public string BatchNumber { get; set; }
#endregion
#region 日期单位
/// <summary>
/// 快递或送样默认为到样时间
/// </summary>
[ApiMember(Description = "到样日期")]
public DateTime EffectiveDate { get; set; }
#endregion
#region 文本描述和 备注
[ApiMember(Description = "备注")]
[StringLength(1000)]
public string Remark { get; set; }
#endregion
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
}
Src/Entities/Template.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
public enum TemplateType
{
Unsupported = 0,
Common = 1,
EnterPrise = 2,
Supervise = 3
}
public enum TemplateCategoryType
{
Unsupported = 0,
Report = 1,//报告模板
SDMS = 2,//原始记录模板
ReportItem = 3//检验项目模板
}
/// <summary>
/// 模板的流程状态设置，暂定6个状态
/// </summary>
public enum StatusType
{
Unsupported = 0,
First = 100,
Second = 200,
Third = 300,
Fourth = 400,
Fifth = 500,
Sixth = 600
}
/// <summary>
/// 可管理报告模板、原始记录模板、检验项目模板
/// </summary>
[Api(Description = "模版管理")]
[Alias(Configs.TableNameTemplate)]
public class Template:EntityWithMetadata, IEntityInAssemblyDb
{
//2021/01/15因项目模板需要树形结构显示，新增树形结构
[DefaultEmptyGuid]
public Guid RootKvid { get; set; }
[DefaultEmptyGuid]
public Guid ParentKvid { get; set; }
[Required]
[ApiMember(Description = "模版名称")]
public string Name { get; set; }
/// <summary>
/// 用于记录通用模板、企业模板等
/// 在Type为Report时使用,枚举类型
/// </summary>
[Required]
[ApiMember(Description = "模板类型")]
public TemplateType Type { get; set; }
/// <summary>
/// 用于记录报告模板，还是原始记录模板，还是检验项目模板
/// 枚举类型
/// </summary>
[Required]
[ApiMember(Description = "模板类别")]
public TemplateCategoryType Category { get; set; }
[Default(0)]
[ApiMember(Description = "排序号")]
public int SortId { get; set; }
[ApiMember(Description = "生效日期")]
public DateTime? EffectiveTime { get; set; }
[ApiMember(Description = "失效日期")]
public DateTime? ExpiredTime { get; set; }
[ApiMember(Description = "是否受控")]
[Default(0)]
public bool IsUnderController { get; set; }
/// <summary>
/// 一个受控号可能存在多个模板，所以不能唯一
/// </summary>
[Default("")]
[ApiMember(Description = "受控号")]
public string UnderControllerId { get; set; }
[Default("")]
[ApiMember(Description ="备注")]
public string Remark { get; set; }
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
}
Src/Entities/TemplateDetail.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
public enum TemplateDetailType
{
Unsupported = 0,
/// <summary>
/// 检测项目录,有子项的大项
/// </summary>
TestFolder,
/// <summary>
/// 检测项，子项或者无子项的大项
/// </summary>
Test
}
[Alias(Configs.TableNameTemplateDetail)]
[Api(Description = "项目模版明细")]
public class TemplateDetail : EntityWithMetadata, IEntityInAssemblyDb
{
[DefaultEmptyGuid]
public Guid OwnerKvid { get; set; }
#region 检验项目信息
[DefaultEmptyGuid]
public Guid RootKvid { get; set; }
[ApiMember(Description = "关联父级Kvid")]
[DefaultEmptyGuid]
public Guid ParentKvid { get; set; }
[ApiMember(Description = "引用标准Kvid")]
[DefaultEmptyGuid]
public Guid StandardKvid { get; set; }
[ApiMember(Description = "标准代码")]
[Default("")]
[StringLength(200)]
public string StandardCode { get; set; }
[ApiMember(Description = "标准名称")]
[Default("")]
[StringLength(200)]
public string StandardTitle { get; set; }
[ApiMember(Description = "引用检测项目Kvid")]
[DefaultEmptyGuid]
public Guid DetectionKvid { get; set; }
[ApiMember(Description = "引用检测项目名称")]
[Default("")]
[StringLength(200)]
public string DetectionTitle { get; set; }
[ApiMember(Description = "测试方法")]
[Default("")]
[StringLength(200)]
public string DetectionCodeActual { get; set; }
[Default("")]
[ApiMember(Description = "数值单位")]
[StringLength(100)]
public string DetectionUnit { get; set; }
[ApiMember(Description = "标准值")]
[StringLength(500)]
public string DetectionValueQualified { get; set; }
[ApiMember(Description = "引用原生检测项目Kvid")]
[DefaultEmptyGuid]
public Guid DetectionReferenceKvid { get; set; }
#endregion
#region 金额相关
[ApiMember(Description = "货币单位")]
[IgnoreUpdate]
[Default("")]
[StringLength(20)]
public CurrencyUnit Currency { get; set; }
[ApiMember(Description = "条目Kvid")]
[DefaultEmptyGuid]
public Guid GoodsKvid { get; set; }
[ApiMember(Description = "包装Kvid")]
[DefaultEmptyGuid]
public Guid PackageKvid { get; set; }
[ApiMember(Description = "价格类型")]
[Default("")]
public string PackageUnit { get; set; }
[ApiMember(Description = "价格")]
[DecimalLength(10, 2), Default(0)]
public decimal Amount { get; set; }
#endregion
#region 基本信息
[ApiMember(Description = "检验项目类型")]
public TemplateDetailType Type { get; set; }
[ApiMember(Description = "项目名称", IsRequired = true)]
[Required]
[StringLength(500)]
public string Title { get; set; }
[ApiMember(Description = "首要排序号")]
[Default(0)]
public int SortId { get; set; }
[ApiMember(Description = "次要排序号")]
[Default(0)]
public int SortIdEx { get; set; }
[ApiMember(Description = "备注")]
[StringLength(2000)]
public string Remark { get; set; }
#endregion
#region 检测人员信息
/// <summary>
/// 录入人员与检测人员的区别：
/// 录入人员指实际录数据的人员
/// 检测人员指实验还未开始，由相关部门将该检验分配给的指定检测人员
/// </summary>
[ApiMember(Description = "检测小组Kvid")]
[DefaultEmptyGuid]
public Guid WorkGroupKvid { get; set; }
[ApiMember(Description = "检测小组")]
[StringLength(50)]
public string WorkGroupName { get; set; }
[ApiMember(Description = "检测人员Kvid")]
[DefaultEmptyGuid]
public Guid WorkerKvid { get; set; }
[ApiMember(Description = "检测人员")]
[StringLength(50), Default("")]
public string WorkerName { get; set; }
#endregion
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
}
Src/Entities/TemplateFile.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
/// <summary>
/// 记录模板和文件的关系及标签
/// </summary>
[Api(Description = "模版文件")]
[Alias(Configs.TableNameTemplateFile)]
public class TemplateFile:EntityWithMetadata, IEntityInAssemblyDb
{
[Required]
public Guid TemplateKvid { get; set; }
[StringLength(200), Required]
[ApiMember(Description = "文件名称")]
public string Name { get; set; }
/// <summary>
/// 记录文件的物理路径
/// </summary>
[StringLength(200), Required]
[IgnoreUpdate]
[ApiMember(Description ="文件路径")]
public string Path { get; set; }
/// <summary>
/// 用来记录当前模板在指定状态生成
/// 设计规则：
/// 1、记录Report的Status，字母+数字，用逗号分隔，如U100,G200,300
/// 2、G+Status 重新生成
/// 3、U+Status 在已有的文件上生成
/// 若无字母前缀，默认在已有文件上生成
/// </summary>
[StringLength(200), Default("")]
[ApiMember(Description = "文件标签")]
public string Tags { get; set; }
[Default(0)]
[ApiMember(Description = "排序号")]
public int SortId { get; set; }
#region 创建/更新人V1.0
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "更新人Kvid ")]
[CurrentMemberKvid]
public Guid UpdaterKvid { get; set; }
[ApiMember(Description = "更新人")]
[StringLength(50), CurrentMemberName]
public string UpdaterName { get; set; }
#endregion
}
}
Src/Entities/Test.cs 0 → 100644
using Kivii.DataAnnotations;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lims.Entities
{
[Alias(Configs.TableNameTest)]
[Api(Description = "检验信息")]
public class Test : EntityWithMetadata, IEntityInAssemblyDb, IEntityHasCreator,IEntityHasRemark,IEntityHasRole
{
/// <summary>
/// 聚合同一项目下的所有检测记录
/// </summary>
[ApiMember(Description = "RootKvid")]
[DefaultEmptyGuid]
[IgnoreUpdate]
public Guid RootKvid { get; set; }
#region 关联信息
[ApiMember(Description = "样品Kvid")]
[DefaultEmptyGuid]
[IgnoreUpdate]
public Guid SampleKvid { get; set; }
[ApiMember(Description = "样品根Kvid")]
[DefaultEmptyGuid]
public Guid SampleRootKvid { get; set; }
[ApiMember(Description ="关联方法标准Kvid")]
[Required]
public Guid StandardKvid { get; set; }
[ApiMember(Description = "关联方法标准的检验项目Kvid")]
[Required]
public Guid DetectionKvid { get; set; }
#endregion
[ApiMember(Description = "实测值")]
[StringLength(500)]
public string Value { get; set; }
[ApiMember(Description = "原始记录路径")]
[StringLength(200),Default("")]
public string OriginalFilePath { get; set; }
#region 人员相关
[ApiMember(Description = "创建人Kvid ")]
[IgnoreUpdate]
[CurrentMemberKvid]
public Guid CreatorKvid { get; set; }
[ApiMember(Description = "创建人")]
[IgnoreUpdate]
[StringLength(50), CurrentMemberName]
public string CreatorName { get; set; }
[ApiMember(Description = "审核人员Kvid")]
[DefaultEmptyGuid]
public Guid ReviewerKvid { get; set; }
[ApiMember(Description = "审核人员")]
[StringLength(50), Default("")]
public string ReviewerName { get; set; }
#endregion
[ApiMember(Description = "备注信息")]
[StringLength(200),Default("")]
public string Remark { get; set; }
#region 时间相关
[ApiMember(Description = "审核时间")]
public DateTime? ReviewTime { get; set; }
#endregion
}
}
Src/Extensions/ReportExtension.cs 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
Src/Extensions/ReportItemExtension.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Extensions
{
public static class ReportItemExtension
{
/// <summary>
/// 用于生成色号时 更新Test的RootKvid
/// </summary>
/// <param name="targetTest">要被更改的目标Test</param>
/// <param name="parentTest">指定的父级Test</param>
/// <param name="conn"></param>
/// <returns></returns>
public static ReportItem ModifyRoot(this ReportItem targetTest, ReportItem parentTest, IDbConnection conn = null)
{
targetTest.ThrowIfNull("请传入要被更改的目标Test!");
targetTest.Kvid.ThrowIfEmpty("要被更改的目标TestKvid不能为空!");
parentTest.ThrowIfNull("请传入指定的父级Test!");
parentTest.Kvid.ThrowIfEmpty("指定的父级TestKvid不能为空!");
bool useTransaction = conn == null;//是否启用事务，如果外部未传入conn,启用内部事务
if (conn == null)
{
conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
}
//targetTest = conn.SingleById<ReportItem>(targetTest.Kvid);
targetTest.ThrowIfNull("未找到要被更改的目标Test!");
//parentTest = conn.SingleById<ReportItem>(parentTest.Kvid);
parentTest.ThrowIfNull("未找到指定的父级Test!");
parentTest.SampleKvid.ThrowIfEmpty("指定的父级Test的样品来源SampleKvid不能为空!");
var nodesTargetTests = conn.Select<ReportItem>(o => o.ParentKvid == targetTest.Kvid);
var rtns = new ReportItem();
IDbTransaction trans = null;//事务，如果外部来了Connection，不生成事务
if (useTransaction) trans = conn.OpenTransaction(IsolationLevel.ReadUncommitted);
try
{
var newReportItem = new ReportItem();
newReportItem.PopulateWith(targetTest);
newReportItem.Kvid = Guid.NewGuid();
newReportItem.ParentKvid = parentTest.Kvid;
newReportItem.SampleKvid = parentTest.SampleKvid;
newReportItem.SampleRootKvid = parentTest.SampleRootKvid;
conn.Insert(newReportItem);
if (!nodesTargetTests.IsNullOrEmpty())
{
foreach (var node in nodesTargetTests)
{
node.ModifyRoot(newReportItem, conn);
}
}
newReportItem.RemoveAllOnlyProperties();
rtns = newReportItem;
trans?.Commit();
}
catch (Exception ex)
{
trans?.Rollback();
throw ex;
}
return rtns;
}
/// <summary>
/// 从字符串中提取数字
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string IsNumber(this string str)
{
string result = "";
for (int i = 0; i < str.Length; i++)
{
if (Char.IsNumber(str, i) == true)
{
result += str.Substring(i, 1);
}
else if (char.IsPunctuation(str, i) == true)
{
result += str.Substring(i, 1) == "." ? "." : null;
}
else
{
result += " ";
}
}
return result;
}
/// <summary>
/// Test和TestFolder类型检测项目结果判定
/// 通过对比标准值和实测值,计算当前的项目是否合格，
/// 条件一：根据传入的ReportItem查report，获取字段TestNeedJudge，若为判定，则；若为数据，则；
/// </summary>
/// <param name="reportItem"></param>
/// <param name="conn"></param>
/// <returns></returns>
[Obsolete("该方法不再使用")]
public static bool CalculateJudgement(this ReportItem reportItem, IDbConnection conn = null)
{
reportItem.ThrowIfNull("未传入ReportItem对象!");
reportItem.Kvid.ThrowIfEmpty("ReportItem的Kvid不能为空");
if (conn == null) conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
Report report = conn.SingleById<Report>(reportItem.ReportKvid);
report.ThrowIfNull("未查询到对应的检测报告！");
bool rtns = false;
try
{
if (reportItem.Type == ReportItemType.Test)
{
string left = reportItem.DetectionValueQualified.IsNullOrEmpty() ? "" : reportItem.DetectionValueQualified.Replace(" ", "");
string right = reportItem.TestValue.IsNullOrEmpty() ? "" : reportItem.TestValue.Replace(" ", "");
//判断实测值是不是类似于：3-4等
if (right.Contains("-") && !right.StartsWith("-"))
{
try
{
string[] array = right.Split('-');
right = ((decimal.Parse(array[0]) + decimal.Parse(array[1])) / 2).ToString();
}
catch { }
}
if (right.IsNullOrEmpty())
{
reportItem.Judgement = "";
return true;
}
else if (right == "+" || right == "未检出" || right == "未检出#not detected" || (right.Contains("符合") && !right.Contains("不符合")) || left == right)
{
reportItem.Judgement = "合格";
return true;
}
else if (right == "/")
{
reportItem.Judgement = "/";
return true;
}
//else if ((parentTest == null || (parentTest != null && parentTest.Type != TestType.TestFolder)) && (right.Contains("不符合") || (test.Title.Contains("标志标识") && right != "")))
else if (right.Contains("不符合") || (reportItem.Title.Contains("标志标识") && right != ""))
{
reportItem.Judgement = "不合格";
return true;
}
//else if (parentTest != null && parentTest.Type == TestType.TestFolder && (right.Contains("不符合") || (parentTest.Title.Contains("标志标识") && right != "")))
else if (right.Contains("不符合") || (reportItem.Title.Contains("标志标识") && right != ""))
{
reportItem.Judgement = "不合格";
return true;
}
decimal l1 = 0, l2 = 0, r = 0;
if (right.Contains("≥")) r = decimal.Parse(right.Substring(1));
else if (right.Contains(">")) r = decimal.Parse(right.Substring(1)) + 1;
else if (right.Contains("≤")) r = decimal.Parse(right.Substring(1));
else if (right.Contains("<")) r = decimal.Parse(right.Substring(1)) - 1;
else if (!decimal.TryParse(right, out r))
{
reportItem.Judgement = "";
return true;
}
Expression expRight = Expression.Constant(r);
char[] split = new char[] { '≥', '>', '≤', '<', '±', '～'};
string[] args = left.Split(split);
if (args.Length != 2) return false;
if (left.Contains("±"))
{
if (args[0] == "") args[0] = "0";
l1 = decimal.Parse(args[0]) - decimal.Parse(args[1]);
l2 = decimal.Parse(args[0]) + decimal.Parse(args[1]);
Expression expLeft1 = Expression.Constant(l1);
Expression exp1 = Expression.LessThanOrEqual(expLeft1, expRight);
Expression expLeft2 = Expression.Constant(l2);
Expression exp2 = Expression.GreaterThanOrEqual(expLeft2, expRight);
reportItem.Judgement = (bool)Expression.Lambda(Expression.And(exp1, exp2)).Compile().DynamicInvoke() ? "合格" : "不合格";
return true;
}
else if (left.Contains("～"))
{
l1 = decimal.Parse(args[0]);
l2 = decimal.Parse(args[1]);
Expression expLeft1 = Expression.Constant(l1);
Expression exp1 = Expression.LessThanOrEqual(expLeft1, expRight);
Expression expLeft2 = Expression.Constant(l2);
Expression exp2 = Expression.GreaterThanOrEqual(expLeft2, expRight);
reportItem.Judgement = (bool)Expression.Lambda(Expression.And(exp1, exp2)).Compile().DynamicInvoke() ? "合格" : "不合格";
return true;
}
else
{
if(left.Contains("×") && left.Contains("%"))
{
Match match = Regex.Match(left, @"(\d+)×(\d+)%");
if (match.Success)
{
// 提取数字部分并转换为整数
int num1 = int.Parse(match.Groups[1].Value);
int num2 = int.Parse(match.Groups[2].Value);
// 将百分比转换为小数（除以100）
decimal percentage = (decimal)(num2 / 100.0);
// 计算结果
decimal result = (decimal)(num1 * percentage);
l1 = result;
}
}
//此处要添加个条件：args[1]包含“-”并且不是以“-”开始的
else if (args[1].Contains("-") && !args[1].StartsWith("-"))
{
string[] vs = args[1].Split('-');
if (decimal.Parse(vs[0]) > decimal.Parse(vs[1]))
{
l1 = (decimal.Parse(vs[0]) - decimal.Parse(vs[1]));
}
else
{
l1 = (decimal.Parse(vs[0]) + decimal.Parse(vs[1])) / 2;
}
}
else
{
l1 = decimal.Parse(args[1]);
}
Expression expLeft = Expression.Constant(l1);
if (left.Contains("≥")) reportItem.Judgement = (bool)Expression.Lambda(Expression.LessThanOrEqual(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains(">")) reportItem.Judgement = (bool)Expression.Lambda(Expression.LessThan(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains("≤")) reportItem.Judgement = (bool)Expression.Lambda(Expression.GreaterThanOrEqual(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains("<")) reportItem.Judgement = (bool)Expression.Lambda(Expression.GreaterThan(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
}
//若报告中的检验要求为判定，则处理
if (!report.TestNeedJudge) reportItem.Judgement = string.Empty;
rtns = true;
}
if (reportItem.Type == ReportItemType.TestFolder)
{
var nodeTests = conn.Select<ReportItem>(o => o.ParentKvid == reportItem.Kvid && o.Type == ReportItemType.Test);
if (nodeTests.IsNullOrEmpty()) return false;
//已经完成判定项的个数
var judgedTasksCount = nodeTests.Count(o => !o.Judgement.IsNullOrEmpty());
//当前小项合格项的个数
var qualifiedTasksCount = nodeTests.Count(o => o.Judgement == "合格" || o.Judgement == "/");
//已经录入实测值的个数
var testValuesCount = nodeTests.Count(o => !o.TestValue.IsNullOrEmpty());
if (nodeTests.Count != judgedTasksCount)
{
reportItem.Judgement = "";
rtns = false;
}
else if (judgedTasksCount > qualifiedTasksCount)
{
reportItem.Judgement = "不合格";
rtns = true;
}
else
{
reportItem.Judgement = "合格";
rtns = true;
}
//若报告中的检验要求为判定，则处理
if (!report.TestNeedJudge) reportItem.Judgement = string.Empty;
//说明子项全部录入实测值了 大项不管有没有判定需要更新检测人信息
if (nodeTests.Count == testValuesCount)
{
reportItem.TestCreateTime = nodeTests.Min(o => o.TestCreateTime);
reportItem.TestCreatorName = nodeTests.FirstOrDefault().TestCreatorName;
reportItem.TestCreatorKvid = nodeTests.FirstOrDefault().TestCreatorKvid;
rtns = true;
}
}
}
catch
{
rtns = false;
}
return rtns;
}
public static bool CalculateJudgement2(this ReportItem reportItem, Report report, List<ReportItem> nodeTests = null)
{
reportItem.ThrowIfNull("未传入ReportItem对象!");
reportItem.Kvid.ThrowIfEmpty("ReportItem的Kvid不能为空");
report.ThrowIfNull("未传入报告信息！");
bool rtns = false;
var originalDetectionValueQualified = reportItem.DetectionValueQualified;
if (reportItem.Metadata.ContainsKey("DetectionValueCustomer") && reportItem.Metadata["DetectionValueCustomer"] != "")
{
reportItem.DetectionValueQualified = reportItem.Metadata["DetectionValueCustomer"];
}
try
{
if (reportItem.Type == ReportItemType.Test)
{
string right = reportItem.TestValue.IsNullOrEmpty() ? "" : reportItem.TestValue.Replace(" ", "");
//如果实测值为“/”，不管标准值是什么，都判定为“/”
if(right == "/")
{
reportItem.Judgement = "/";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
//如果实测值为“-”，不管标准值是什么，都判定为“-”
if (right == "—"|| right == "-")
{
reportItem.Judgement = "—";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
string left = reportItem.DetectionValueQualified.IsNullOrEmpty() ? "" : reportItem.DetectionValueQualified.Replace(" ", "").Replace("＞",">").Replace("＜","<");
//如果标准值为空，不管实测值是什么都不判定
if (left.IsNullOrEmpty())
{
reportItem.Judgement = "";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
//判断实测值是不是类似于：3-4等
if (right.Contains("-") && !right.StartsWith("-"))
{
try
{
string[] array = right.Split('-');
right = ((decimal.Parse(array[0]) + decimal.Parse(array[1])) / 2).ToString();
}
catch { }
}
//判断实测值是不是指数表示，如2.1×10^(3)
if (right.Contains("^"))
{
try
{
string[] array = right.Split('×');
//a×10^(b)
//获取a
var aValue = double.Parse(array[0]);
//获取b
var bValue = double.Parse(Regex.Replace(array[1].Split('^')[1], @"[^0-9]+", ""));
right = (aValue * Math.Pow(10, bValue)).ToString();
}
catch { }
}
//判断实测值为带斜杠的实测值，如100/2
if (right.Contains("/")&&right.Length>1)
{
try
{
string[] array = right.Split('/');
right = array[0];
}
catch { }
}
if (right.IsNullOrEmpty())
{
reportItem.Judgement = "";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
else if (right == "+" || right == "未检出" || right == "未检出#not detected" || right == "经向沿纬向断裂" || right == "纬向沿经向断裂" || (right.Contains("符合") && !right.Contains("不符合")) || left == right)
{
reportItem.Judgement = "合格";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
else if (right == "/")
{
reportItem.Judgement = "/";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
//else if ((parentTest == null || (parentTest != null && parentTest.Type != TestType.TestFolder)) && (right.Contains("不符合") || (test.Title.Contains("标志标识") && right != "")))
else if (right.Contains("不符合") || (reportItem.Title.Contains("标志标识") && right != ""))
{
reportItem.Judgement = "不合格";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
//else if (parentTest != null && parentTest.Type == TestType.TestFolder && (right.Contains("不符合") || (parentTest.Title.Contains("标志标识") && right != "")))
else if (right.Contains("不符合") || (reportItem.Title.Contains("标志标识") && right != ""))
{
reportItem.Judgement = "不合格";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
else if (right == "无绳带" || right == "无绳圈")//31701的项目
{
reportItem.Judgement = "合格";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
decimal l1 = 0, l2 = 0, r = 0;
if (right.Contains("≥")) r = decimal.Parse(right.Substring(1));
else if (right.Contains(">")) r = decimal.Parse(right.Substring(1)) + 1;
else if (right.Contains("≤")) r = decimal.Parse(right.Substring(1));
else if (right.Contains("<")) r = decimal.Parse(right.Substring(1)) - 1;
else if (!decimal.TryParse(right, out r))
{
reportItem.Judgement = "";
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return true;
}
Expression expRight = Expression.Constant(r);
char[] split = new char[] { '≥', '>', '≤', '<', '±', '～' ,'~'};
string[] args = left.Split(split);
if (args.Length != 2)
{
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return false;
}
if (left.Contains("±"))
{
if (args[0] == "") args[0] = "0";
if (args[0].Contains("/"))
{
args[0] = args[0].Split('/')[0];
}
if (args[0].Contains('.'))
{
args[0] = Regex.Replace(args[0], @"[^\d.\d]", "");
}
else
{
args[0] = Regex.Replace(args[0], @"[^0-9]+", "");
}
//处理args[1]为百分比的情况
if (args[1].Contains("%"))
{
args[1] = (decimal.Parse(new Regex(@"\d+\.\d+|\d+").Matches(args[1])[0].Value) / 100 * decimal.Parse(args[0])).ToString();
}
l1 = decimal.Parse(args[0]) - decimal.Parse(args[1]);
l2 = decimal.Parse(args[0]) + decimal.Parse(args[1]);
Expression expLeft1 = Expression.Constant(l1);
Expression exp1 = Expression.LessThanOrEqual(expLeft1, expRight);
Expression expLeft2 = Expression.Constant(l2);
Expression exp2 = Expression.GreaterThanOrEqual(expLeft2, expRight);
reportItem.Judgement = (bool)Expression.Lambda(Expression.And(exp1, exp2)).Compile().DynamicInvoke() ? "合格" : "不合格";
return true;
}
else if (left.Contains("～")|| left.Contains("~"))
{
l1 = decimal.Parse(args[0]);
l2 = decimal.Parse(args[1]);
if (l1 > l2)
{
var tmp = l1;
l1 = l2;
l2 = tmp;
}
Expression expLeft1 = Expression.Constant(l1);
Expression exp1 = Expression.LessThanOrEqual(expLeft1, expRight);
Expression expLeft2 = Expression.Constant(l2);
Expression exp2 = Expression.GreaterThanOrEqual(expLeft2, expRight);
reportItem.Judgement = (bool)Expression.Lambda(Expression.And(exp1, exp2)).Compile().DynamicInvoke() ? "合格" : "不合格";
return true;
}
else
{
if (left.Contains("×") && left.Contains("%")&&!left.Contains("标称值"))
{
//Match match = Regex.Match(left, @"(\d+)×(\d+)%");
Match match = Regex.Match(left, @"(\d+(?:\.\d+)?)(?:[×%]*)(\d+(?:\.\d+)?)(?:%)");
if (match.Success)
{
// 提取数字部分并转换为整数
decimal num1 = decimal.Parse(match.Groups[1].Value);
decimal num2 = decimal.Parse(match.Groups[2].Value);
// 将百分比转换为小数（除以100）
decimal percentage = (decimal)(num2 / 100);
// 计算结果
decimal result = (decimal)(num1 * percentage);
l1 = result;
}
}
//处理百分比
else if (args[1].Contains("%"))
{
if (args[1].Contains("-"))
{
string[] vs = args[1].Split('-');
if (vs.Length != 2) return false;
if (vs[0].Contains("/"))
{
vs[0] = args[0].Split('/')[0];
}
l1 = decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) - decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) * decimal.Parse(Regex.Replace(vs[1], @"[^\d.\d]", "")) / 100;
}
else if (args[1].Contains("+"))
{
string[] vs = args[1].Split('+');
if (vs.Length != 2) return false;
if (vs[0].Contains("/"))
{
vs[0] = args[0].Split('/')[0];
}
l1 = decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) + decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) * decimal.Parse(Regex.Replace(vs[1], @"[^0-9]+", "")) / 100;
}
else
{
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return false;
}
}
//此处要添加个条件：args[1]包含“-”并且不是以“-”开始的
else if (args[1].Contains("-") && !args[1].StartsWith("-"))
{
string[] vs = args[1].Split('-');
if (decimal.Parse(vs[0]) > decimal.Parse(vs[1]))
{
l1 = (decimal.Parse(vs[0]) - decimal.Parse(vs[1]));
}
else
{
l1 = (decimal.Parse(vs[0]) + decimal.Parse(vs[1])) / 2;
}
}
else if (args[1].Contains("/"))
{
l1 = decimal.Parse(args[1].Split('/')[0]);
}
else
{
l1 = decimal.Parse(args[1]);
}
Expression expLeft = Expression.Constant(l1);
if (left.Contains("≥")) reportItem.Judgement = (bool)Expression.Lambda(Expression.LessThanOrEqual(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains(">")) reportItem.Judgement = (bool)Expression.Lambda(Expression.LessThan(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains("≤")) reportItem.Judgement = (bool)Expression.Lambda(Expression.GreaterThanOrEqual(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains("<")) reportItem.Judgement = (bool)Expression.Lambda(Expression.GreaterThan(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
}
//若报告中的检验要求为判定，则处理
if (!report.TestNeedJudge) reportItem.Judgement = string.Empty;
rtns = true;
}
if (reportItem.Type == ReportItemType.TestFolder)
{
//var nodeTests = conn.Select<ReportItem>(o => o.ParentKvid == reportItem.Kvid & o.Type == ReportItemType.Test);
nodeTests.ThrowIfNullOrEmpty("父级项目判定请传入子项列表");
//过滤一遍传入参数，至处理当前大项的子项
nodeTests = nodeTests.Where(o => o.ParentKvid == reportItem.Kvid).ToList();
//已经完成判定项的个数
var judgedTasksCount = nodeTests.Count(o => !o.Judgement.IsNullOrEmpty());
//当前小项合格项的个数
var qualifiedTasksCount1 = nodeTests.Count(o => o.Judgement == "合格");
//记斜杠和横杠数
var qualifiedTasksCount2 = nodeTests.Count(o=>o.Judgement == "/");
var qualifiedTasksCount3 = nodeTests.Count(o=>o.Judgement == "—");
//已经录入实测值的个数
var testValuesCount = nodeTests.Count(o => !o.TestValue.IsNullOrEmpty());
if (nodeTests.Count != judgedTasksCount)
{
reportItem.Judgement = "";
rtns = false;
}
else if (judgedTasksCount > (qualifiedTasksCount1+ qualifiedTasksCount2+ qualifiedTasksCount3))
{
reportItem.Judgement = "不合格";
rtns = true;
}
else if(judgedTasksCount == qualifiedTasksCount2)
{
reportItem.Judgement = "/";
rtns = true;
}
else if (judgedTasksCount == qualifiedTasksCount3)
{
reportItem.Judgement = "—";
rtns = true;
}
else
{
reportItem.Judgement = "合格";
rtns = true;
}
//若报告中的检验要求为判定，则处理
if (!report.TestNeedJudge) reportItem.Judgement = string.Empty;
//说明子项全部录入实测值了 大项不管有没有判定需要更新检测人信息
if (nodeTests.Count == testValuesCount)
{
//reportItem.TestCreateTime = nodeTests.Min(o => o.TestCreateTime);
//reportItem.TestCreatorName = nodeTests.FirstOrDefault().TestCreatorName;
//reportItem.TestCreatorKvid = nodeTests.FirstOrDefault().TestCreatorKvid;
rtns = true;
}
}
}
catch
{
reportItem.DetectionValueQualified = originalDetectionValueQualified;
rtns = false;
}
reportItem.DetectionValueQualified = originalDetectionValueQualified;
return rtns;
}
public static bool CalculateJudgementBackup(this ReportItem reportItem, Report report, List<ReportItem> nodeTests = null)
{
reportItem.ThrowIfNull("未传入ReportItem对象!");
reportItem.Kvid.ThrowIfEmpty("ReportItem的Kvid不能为空");
report.ThrowIfNull("未传入报告信息！");
bool rtns = false;
try
{
if (reportItem.Type == ReportItemType.Test)
{
string right = reportItem.TestValue.IsNullOrEmpty() ? "" : reportItem.TestValue.Replace(" ", "");
//如果实测值为“/”，不管标准值是什么，都判定为“/”
if (right == "/")
{
reportItem.Judgement = "/";
return true;
}
//如果实测值为“-”，不管标准值是什么，都判定为“-”
if (right == "—" || right == "-")
{
reportItem.Judgement = "—";
return true;
}
string left = reportItem.DetectionValueQualified.IsNullOrEmpty() ? "" : reportItem.DetectionValueQualified.Replace(" ", "");
//如果标准值为空，不管实测值是什么都不判定
if (left.IsNullOrEmpty())
{
reportItem.Judgement = "";
return true;
}
//判断实测值是不是类似于：3-4等
if (right.Contains("-") && !right.StartsWith("-"))
{
try
{
string[] array = right.Split('-');
right = ((decimal.Parse(array[0]) + decimal.Parse(array[1])) / 2).ToString();
}
catch { }
}
//判断实测值是不是指数表示，如2.1×10^(3)
if (right.Contains("^"))
{
try
{
string[] array = right.Split('×');
//a×10^(b)
//获取a
var aValue = double.Parse(array[0]);
//获取b
var bValue = double.Parse(Regex.Replace(array[1].Split('^')[1], @"[^0-9]+", ""));
right = (aValue * Math.Pow(10, bValue)).ToString();
}
catch { }
}
//判断实测值为带斜杠的实测值，如100/2
if (right.Contains("/") && right.Length > 1)
{
try
{
string[] array = right.Split('/');
right = array[0];
}
catch { }
}
if (right.IsNullOrEmpty())
{
reportItem.Judgement = "";
return true;
}
else if (right == "+" || right == "未检出" || right == "未检出#not detected" || right == "经向沿纬向断裂" || right == "纬向沿经向断裂" || (right.Contains("符合") && !right.Contains("不符合")) || left == right)
{
reportItem.Judgement = "合格";
return true;
}
else if (right == "/")
{
reportItem.Judgement = "/";
return true;
}
//else if ((parentTest == null || (parentTest != null && parentTest.Type != TestType.TestFolder)) && (right.Contains("不符合") || (test.Title.Contains("标志标识") && right != "")))
else if (right.Contains("不符合") || (reportItem.Title.Contains("标志标识") && right != ""))
{
reportItem.Judgement = "不合格";
return true;
}
//else if (parentTest != null && parentTest.Type == TestType.TestFolder && (right.Contains("不符合") || (parentTest.Title.Contains("标志标识") && right != "")))
else if (right.Contains("不符合") || (reportItem.Title.Contains("标志标识") && right != ""))
{
reportItem.Judgement = "不合格";
return true;
}
else if (right == "无绳带" || right == "无绳圈")//31701的项目
{
reportItem.Judgement = "合格";
return true;
}
decimal l1 = 0, l2 = 0, r = 0;
if (right.Contains("≥")) r = decimal.Parse(right.Substring(1));
else if (right.Contains(">")) r = decimal.Parse(right.Substring(1)) + 1;
else if (right.Contains("≤")) r = decimal.Parse(right.Substring(1));
else if (right.Contains("<")) r = decimal.Parse(right.Substring(1)) - 1;
else if (!decimal.TryParse(right, out r))
{
reportItem.Judgement = "";
return true;
}
Expression expRight = Expression.Constant(r);
char[] split = new char[] { '≥', '>', '≤', '<', '±', '～', '~' };
string[] args = left.Split(split);
if (args.Length != 2) return false;
if (left.Contains("±"))
{
if (args[0] == "") args[0] = "0";
if (args[0].Contains("/"))
{
args[0] = args[0].Split('/')[0];
}
if (args[0].Contains('.'))
{
args[0] = Regex.Replace(args[0], @"[^\d.\d]", "");
}
else
{
args[0] = Regex.Replace(args[0], @"[^0-9]+", "");
}
//处理args[1]为百分比的情况
if (args[1].Contains("%"))
{
args[1] = (decimal.Parse(new Regex(@"\d+\.\d+|\d+").Matches(args[1])[0].Value) / 100 * decimal.Parse(args[0])).ToString();
}
l1 = decimal.Parse(args[0]) - decimal.Parse(args[1]);
l2 = decimal.Parse(args[0]) + decimal.Parse(args[1]);
Expression expLeft1 = Expression.Constant(l1);
Expression exp1 = Expression.LessThanOrEqual(expLeft1, expRight);
Expression expLeft2 = Expression.Constant(l2);
Expression exp2 = Expression.GreaterThanOrEqual(expLeft2, expRight);
reportItem.Judgement = (bool)Expression.Lambda(Expression.And(exp1, exp2)).Compile().DynamicInvoke() ? "合格" : "不合格";
return true;
}
else if (left.Contains("～") || left.Contains("~"))
{
l1 = decimal.Parse(args[0]);
l2 = decimal.Parse(args[1]);
if (l1 > l2)
{
var tmp = l1;
l1 = l2;
l2 = tmp;
}
Expression expLeft1 = Expression.Constant(l1);
Expression exp1 = Expression.LessThanOrEqual(expLeft1, expRight);
Expression expLeft2 = Expression.Constant(l2);
Expression exp2 = Expression.GreaterThanOrEqual(expLeft2, expRight);
reportItem.Judgement = (bool)Expression.Lambda(Expression.And(exp1, exp2)).Compile().DynamicInvoke() ? "合格" : "不合格";
return true;
}
else
{
if (left.Contains("×") && left.Contains("%") && !left.Contains("标称值"))
{
Match match = Regex.Match(left, @"(\d+)×(\d+)%");
if (match.Success)
{
// 提取数字部分并转换为整数
int num1 = int.Parse(match.Groups[1].Value);
int num2 = int.Parse(match.Groups[2].Value);
// 将百分比转换为小数（除以100）
decimal percentage = (decimal)(num2 / 100.0);
// 计算结果
decimal result = (decimal)(num1 * percentage);
l1 = result;
}
}
//处理百分比
else if (args[1].Contains("%"))
{
if (args[1].Contains("-"))
{
string[] vs = args[1].Split('-');
if (vs.Length != 2) return false;
if (vs[0].Contains("/"))
{
vs[0] = args[0].Split('/')[0];
}
l1 = decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) - decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) * decimal.Parse(Regex.Replace(vs[1], @"[^\d.\d]", "")) / 100;
}
else if (args[1].Contains("+"))
{
string[] vs = args[1].Split('+');
if (vs.Length != 2) return false;
if (vs[0].Contains("/"))
{
vs[0] = args[0].Split('/')[0];
}
l1 = decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) + decimal.Parse(Regex.Replace(vs[0], @"[^0-9]+", "")) * decimal.Parse(Regex.Replace(vs[1], @"[^0-9]+", "")) / 100;
}
else return false;
}
//此处要添加个条件：args[1]包含“-”并且不是以“-”开始的
else if (args[1].Contains("-") && !args[1].StartsWith("-"))
{
string[] vs = args[1].Split('-');
if (decimal.Parse(vs[0]) > decimal.Parse(vs[1]))
{
l1 = (decimal.Parse(vs[0]) - decimal.Parse(vs[1]));
}
else
{
l1 = (decimal.Parse(vs[0]) + decimal.Parse(vs[1])) / 2;
}
}
else if (args[1].Contains("/"))
{
l1 = decimal.Parse(args[1].Split('/')[0]);
}
else
{
l1 = decimal.Parse(args[1]);
}
Expression expLeft = Expression.Constant(l1);
if (left.Contains("≥")) reportItem.Judgement = (bool)Expression.Lambda(Expression.LessThanOrEqual(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains(">")) reportItem.Judgement = (bool)Expression.Lambda(Expression.LessThan(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains("≤")) reportItem.Judgement = (bool)Expression.Lambda(Expression.GreaterThanOrEqual(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
else if (left.Contains("<")) reportItem.Judgement = (bool)Expression.Lambda(Expression.GreaterThan(expLeft, expRight)).Compile().DynamicInvoke() ? "合格" : "不合格";
}
//若报告中的检验要求为判定，则处理
if (!report.TestNeedJudge) reportItem.Judgement = string.Empty;
rtns = true;
}
if (reportItem.Type == ReportItemType.TestFolder)
{
//var nodeTests = conn.Select<ReportItem>(o => o.ParentKvid == reportItem.Kvid & o.Type == ReportItemType.Test);
nodeTests.ThrowIfNullOrEmpty("父级项目判定请传入子项列表");
//过滤一遍传入参数，至处理当前大项的子项
nodeTests = nodeTests.Where(o => o.ParentKvid == reportItem.Kvid).ToList();
//已经完成判定项的个数
var judgedTasksCount = nodeTests.Count(o => !o.Judgement.IsNullOrEmpty());
//当前小项合格项的个数
var qualifiedTasksCount1 = nodeTests.Count(o => o.Judgement == "合格");
//记斜杠和横杠数
var qualifiedTasksCount2 = nodeTests.Count(o => o.Judgement == "/");
var qualifiedTasksCount3 = nodeTests.Count(o => o.Judgement == "—");
//已经录入实测值的个数
var testValuesCount = nodeTests.Count(o => !o.TestValue.IsNullOrEmpty());
if (nodeTests.Count != judgedTasksCount)
{
reportItem.Judgement = "";
rtns = false;
}
else if (judgedTasksCount > (qualifiedTasksCount1 + qualifiedTasksCount2 + qualifiedTasksCount3))
{
reportItem.Judgement = "不合格";
rtns = true;
}
else if (judgedTasksCount == qualifiedTasksCount2)
{
reportItem.Judgement = "/";
rtns = true;
}
else if (judgedTasksCount == qualifiedTasksCount3)
{
reportItem.Judgement = "—";
rtns = true;
}
else
{
reportItem.Judgement = "合格";
rtns = true;
}
//若报告中的检验要求为判定，则处理
if (!report.TestNeedJudge) reportItem.Judgement = string.Empty;
//说明子项全部录入实测值了 大项不管有没有判定需要更新检测人信息
if (nodeTests.Count == testValuesCount)
{
//reportItem.TestCreateTime = nodeTests.Min(o => o.TestCreateTime);
//reportItem.TestCreatorName = nodeTests.FirstOrDefault().TestCreatorName;
//reportItem.TestCreatorKvid = nodeTests.FirstOrDefault().TestCreatorKvid;
rtns = true;
}
}
}
catch
{
rtns = false;
}
return rtns;
}
public static List<ReportItem> UpdateChildrenSortId(this List<ReportItem> reportItems, int originalSortId, int newSortId, IDbConnection conn = null)
{
if (conn == null)
{
conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
}
var rtns = new List<ReportItem>();
foreach (var reportItem in reportItems)
{
reportItem.SortIdEx = reportItem.SortIdEx - originalSortId * 100 + newSortId * 100;
reportItem.AddOnlyProperties(o => o.SortIdEx);
conn.UpdateOnly(reportItem);
rtns.Add(reportItem);
}
return rtns;
}
///// <summary>
///// 本方法筛选出类型为Test的大项检测项目，或类型为TestFolder的大项
///// </summary>
///// <param name="reportItems"></param>
///// <returns></returns>
//public static List<ReportItem> filterReportItem(this List<ReportItem> reportItems)
//{
// var rtnReportItems = new List<ReportItem>();
// foreach (var en in reportItems)
// {
// if (en.Type == ReportItemType.TestFolder)
// {
// rtnReportItems.Add(en);
// continue;
// }
// if (en.Type == ReportItemType.Test)
// {
// if (en.ParentKvid == Guid.Empty)
// {
// rtnReportItems.Add(en);
// continue;
// }
// var parentTest = reportItems.Where(o => o.Kvid == en.ParentKvid).FirstOrDefault();
// if (parentTest == null) continue;
// if (parentTest.Type != ReportItemType.TestFolder)
// {
// rtnReportItems.Add(en);
// continue;
// }
// }
// }
// return rtnReportItems;
//}
/// <summary>
/// 本方法筛选出类型为Test的大项检测项目，或类型为TestFolder的大项
/// </summary>
/// <param name="reportItems"></param>
/// <returns></returns>
public static List<ReportItem> filterReportItem(this List<ReportItem> reportItems)
{
var rtns = new List<ReportItem>();
if (reportItems.IsNullOrEmpty()) return rtns;
IDbConnection conn = null;
try
{
foreach (var item in reportItems)
{
if (item.Type == ReportItemType.TestFolder)
{
rtns.Add(item);
continue;
}
if (item.Type == ReportItemType.Test)
{
if (item.ParentKvid == Guid.Empty)
{
rtns.Add(item);
continue;
}
var parentTest = reportItems.FirstOrDefault(o => o.Kvid == item.ParentKvid);
////如果原列表里未找到父级，需要去数据库里找到
if (parentTest == null)
{
if (conn == null) conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
parentTest = conn.Single<ReportItem>(o => o.Kvid == item.ParentKvid);
}
//要是仍然为空再跳过
if (parentTest == null) continue;
if (parentTest.Type != ReportItemType.TestFolder)
{
rtns.Add(item);
continue;
}
}
}
}
finally
{
conn?.Close();
}
return rtns;
}
/// <summary>
/// 本方法用作删除检验项目验证，只验证数据结构方面是否允许删除
/// 只处理同一报告下的数据删除，不支持跨报告删除
/// </summary>
/// <param name="reportItems"></param>
/// <param name="conn"></param>
/// <returns></returns>
public static bool ValidReportItemDelete_Stract(this List<ReportItem> reportItems, List<ReportItem> allReportItems)
{
reportItems.ThrowIfNullOrEmpty("空数据，无法处理");
if (reportItems.Select(o => o.ReportKvid).Distinct().ToList().Count > 1) throw new Exception("验证不通过！暂不支持跨报告数据删除！");
//待删除的项目 与所有项目对比，验证是否存在待删除项目的子项未在待删除中
foreach(var en in reportItems)
{
var subReportItems = reportItems.Where(o => o.ParentKvid == en.Kvid);
//2021-10-17升级，由于删除带部位的项目不会删除部位记录，所以验证这边需要处理此类脏数据
var subAllReportItems = allReportItems.Where(o => o.ParentKvid == en.Kvid&&o.Type != ReportItemType.SamplePart);
if (subReportItems.Count() < subAllReportItems.Count()) throw new Exception("验证不通过！此次删除会导致无父节点的子项存在！");
}
return true;
}
//2021-08-24 review replaced by up code
//public static bool ValidReportItemDelete_Stract(this List<ReportItem> reportItems, IDbConnection conn = null)
//{
// if (conn == null)
// {
// conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
// }
// reportItems.ThrowIfNullOrEmpty("空数据，无法处理");
// if (reportItems.Select(o => o.ReportKvid).Distinct().ToList().Count > 1) throw new Exception("验证不通过！暂不支持跨报告数据删除！");
// //查出当前报告下的所有的检验项目
// var queryAllReportItems = conn.From<ReportItem>();
// queryAllReportItems.Where(o => o.ReportKvid == reportItems.FirstOrDefault().ReportKvid);
// var allReportItems = conn.Select(queryAllReportItems);
// //待删除的项目 与所有项目对比，验证是否存在待删除项目的子项未在待删除中
// foreach (var en in reportItems)
// {
// var subReportItems = reportItems.Where(o => o.ParentKvid == en.Kvid);
// var subAllReportItems = allReportItems.Where(o => o.ParentKvid == en.Kvid);
// if (subReportItems.Count() != subAllReportItems.Count()) throw new Exception("验证不通过！此次删除会导致无父节点的子项存在！");
// }
// return true;
//}
/// <summary>
/// 本方法用作删除检验项目验证，验证业务逻辑是否允许删除
/// </summary>
/// <param name="reportItems"></param>
/// <param name="conn"></param>
/// <returns></returns>
public static bool ValidReportItemDelete_Biz(this Report report , List<ReportItem> reportItems)
{
reportItems.ThrowIfNullOrEmpty("空数据，无法处理");
report.ThrowIfNull("报告为空无法处理！");
//验证项目状态
//if (reportItems.Exists(o => o.Type == ReportItemType.SampleSelf || o.Type == ReportItemType.SamplePart)) throw new Exception("验证不通过，请先删除色号或部位后，再删除项目！");
//不验证色号项目或者部位项目的数据
reportItems = reportItems.Where(o => o.Type != ReportItemType.SamplePart && o.Type != ReportItemType.SampleSelf).ToList();
if (reportItems.Exists(o => o.StatusType != ReportItemStatusType.BeforeTest && o.StatusType != ReportItemStatusType.TestCollected)) throw new Exception("验证不通过！待删除项目存在非委托状态项目，禁止删除！");
if(reportItems.Exists(o=>o.StatusType == ReportItemStatusType.TestCollected))
{
//处理删除X报告，不验证项目是否归档
//处理引用报告逻辑，引用的项目，要支持自由删除项目，无论归档与否（）
if (report.BizType != "H" && report.BizType != "X") throw new Exception("验证不通过！待删除项目中存在归档项目，禁止删除！");
}
foreach(var en in reportItems)
{
if (en.StatusType == ReportItemStatusType.BeforeTest && en.TestKvid != Guid.Empty) throw new Exception($"验证不通过！待删除的项目《{en.Title}》存在检测记录！");
}
return true;
}
//2021-08-24 review replaced by up code
//public static bool ValidReportItemDelete_Biz(this List<ReportItem> reportItems, IDbConnection conn = null)
//{
// if (conn == null)
// {
// conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
// }
// reportItems.ThrowIfNullOrEmpty("空数据，无法处理");
// //验证项目状态
// //if (reportItems.Exists(o => o.Type == ReportItemType.SampleSelf || o.Type == ReportItemType.SamplePart)) throw new Exception("验证不通过，请先删除色号或部位后，再删除项目！");
// if (reportItems.Exists(o => o.StatusType != ReportItemStatusType.BeforeTest && o.StatusType != ReportItemStatusType.TestCollected)) throw new Exception("验证不通过！待删除项目存在非委托状态项目，禁止删除！");
// if (reportItems.Exists(o => o.StatusType == ReportItemStatusType.TestCollected))
// {
// var report = conn.SingleById<Report>(reportItems.FirstOrDefault().ReportKvid);
// if (report.TestStartDate != null) throw new Exception("验证不通过！待删除项目中存在归档项目，禁止删除！");
// }
// foreach (var en in reportItems)
// {
// if (en.StatusType == ReportItemStatusType.BeforeTest && en.TestKvid != Guid.Empty) throw new Exception($"验证不通过！待删除的项目《{en.Title}》存在检测记录！");
// }
// return true;
//}
/// <summary>
/// 报告项目流程进度描述
/// </summary>
/// <param name="report"></param>
/// <returns></returns>
public static string StatusDescription(int Status)
{
string description = "";
switch (Status)
{
case 100:
description = "委托受理";
break;
case 150:
description = "任务分派";
break;
case 200:
description = "项目检验";
break;
case 250:
description = "待复核";
break;
case 300:
description = "检验完成";
break;
case int.MaxValue:
description = "项目归档";
break;
default:
description = "项目流程异常，请与管理员联系";
break;
}
return description;
}
#region 对ReportItems进行一些处理的方法，update by leo
/// <summary>
/// 对ReportItems进行合并，把SamplePart合并至TitlePart中
/// </summary>
/// <param name="reportItems"></param>
/// <returns>返回新的集合，必须再赋值给调用方</returns>
internal static List<ReportItem> CombinSamplePart(this List<ReportItem> reportItems)
{
List<ReportItem> rtns = reportItems.ToList();//先复制，不影响原来的数据集
//所有的部位信息
var sampleParts = rtns.Where(o => o.Type == ReportItemType.SamplePart);
if (sampleParts.Count() < 1) return rtns;//如果没找到部位信息，直接返回原对象
foreach (var samplePart in sampleParts)
{
var tests = rtns.Where(o => o.ParentKvid == samplePart.Kvid);//找到所有部位下的子对象集合
//把所有的子对象的属性值进行重新连接
tests.Each(o => {
o.TitlePart = samplePart.Title;
o.ParentKvid = samplePart.ParentKvid;
o.PartKvid = samplePart.Kvid;
});
}
//把所有的样品信息从集合中删除
sampleParts.Each(o=>rtns.Remove(o));
return rtns;
}
/// <summary>
/// 移除目录中没有实际检测项的样品或样品部位
/// </summary>
/// <param name="reportItems"></param>
/// <returns>返回新的集合，必须再赋值给调用方</returns>
internal static List<ReportItem> RemoveEmptyFolder(this List<ReportItem> reportItems)
{
List<ReportItem> rtns = reportItems.ToList();//先复制，不影响原来的数据集
//样品或样品部位都是树型的根（目录节点），当这些目录节点下没有检测项，就不需要显示
//根据RootKvid进行分组，再查这些分组下有没有检测项，如果没有，直接可以从集合中移除
var groups = rtns.GroupBy(o => o.RootKvid);
foreach (var kv in groups)
{
//如果这个组中存在Test或TestFolder,说明就有检测项，跳过
if (kv.Any(o => o.Type == ReportItemType.Test || o.Type == ReportItemType.TestFolder)) continue;
//没有检测项的情况，把整个根都移除了，即RootKvid相同的都移除了
rtns.RemoveAll(o => o.RootKvid == kv.Key);
}
return rtns;
}
/// <summary>
/// 验证树形结构的数据有严谨性，如果数据上下级结构不正确，可能会引起客户端显示有问题
/// </summary>
/// <param name="reportItems"></param>
/// <returns></returns>
internal static bool ValidIsTreeStruct(this List<ReportItem> reportItems)
{
bool rtns = false;
var kvids = reportItems.Select(o => o.ParentKvid);//先找到所有的上级Kvid
if (kvids.Count() != kvids.Distinct().Count()) return rtns;//如果kvids集合的长度不等于Distince的长度，说明数据集中有重复的Kvid
var parentKvids = reportItems.Select(o => o.ParentKvid).Distinct();//先找到所有的上级Kvid
rtns=!parentKvids.Any(o => !kvids.Contains(o));//只要Kvids中不存在任何一个ParentKvid的数据，就说明找不到上级的对象，
return rtns;
}
/// <summary>
/// 返回所有的大项，Test单项，或包含Test的TestFolder
/// </summary>
/// <param name="reportItems"></param>
/// <returns></returns>
internal static List<ReportItem> GetMainTest(this List<ReportItem> reportItems)
{
List<ReportItem> rtns = new List<ReportItem>();
//对所有项目循环
foreach (var reportItem in reportItems)
{
//如果是TestFolder,直接加入返回数据集中
if (reportItem.Type == ReportItemType.TestFolder)
{
rtns.Add(reportItem);
continue;
}
//如果不是Test,直接继续，因为只判断TestFolder和Test,
if (reportItem.Type!= ReportItemType.Test) continue;
//如果上级ParentKvid为空，根项目，加入返回集，继续
if (reportItem.ParentKvid == Guid.Empty)
{
rtns.Add(reportItem);
continue;
}
//如果ParentKvid为不空，有可能是Sample或SamplePart的上级，这种也是需要加入数据集的，只要不是TestFolder就可以
var parentTest = reportItems.FirstOrDefault(o => o.Kvid == reportItem.ParentKvid);
parentTest.ThrowIfNull("传入的数据集不完整或数据结构错误");//不做额外的处理，需要在传入的数据集上传完整。
if (parentTest.Type== ReportItemType.SampleSelf|| parentTest.Type == ReportItemType.SamplePart)
{
rtns.Add(reportItem);
continue;
}
}
//下面可以对TitlePart进行赋值，合成SampleSelf和SamplePart的信息
//可以对ParentKvid进行集中清空，建立一个完整的数据结构
rtns.Each(o => o.ParentKvid = Guid.Empty);
return rtns;
}
#endregion
#region 对ReportItem的检验组相关处理的一些方法，update by rty
internal static List<ReportItem> SyncWorkGroup(this List<ReportItem> reportItems)
{
List<ReportItem> rtns = new List<ReportItem>();
//遍历所有项目
foreach(var kv in reportItems)
{
//只需要处理带子项的大项
if (kv.Type != ReportItemType.TestFolder) continue;
var subItems = new List<ReportItem>();
subItems = reportItems.Where(o => o.ParentKvid == kv.Kvid).ToList();
if (subItems == null) continue;
if (subItems.Exists(o => o.WorkGroupName != kv.WorkGroupName && o.WorkGroupName != null && o.WorkGroupName != string.Empty))
{
foreach (var en in subItems)
{
if (en.WorkGroupName == kv.WorkGroupName) continue;
en.WorkGroupName = kv.WorkGroupName;
en.WorkGroupKvid = kv.WorkGroupKvid;
en.AddOnlyProperties(o => o.WorkGroupName);
en.AddOnlyProperties(o => o.WorkGroupKvid);
rtns.Add(en);
}
}
}
return rtns;
}
#endregion
#region 对检验项目的Amount字段更新，添加日志记录的方法
public static void SetAmountLog(this ReportItem reportItem,Report report,string type,decimal originalAmount,decimal finalAmount, IDbConnection conn = null)
{
if (conn == null)
{
conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
}
var _log = new EntityLog<ReportItem>();
try
{
_log.BizId = report.ReportId;
}
catch { }
try
{
_log.BizKvid = report.Kvid;
}
catch { }
try
{
_log.OwnerKvid = reportItem.Kvid;
}
catch { }
try
{
_log.Source = reportItem.Title.Substring(0,49);
}
catch { }
_log.BizType = "Kivii.Lac.Lims.Entities.Report";
_log.Title = "收费更新日志";
_log.Type = type;
_log.Summary = $"检验费由{originalAmount}修改为{finalAmount}";
conn.Insert(_log);
}
#endregion
#region 标准值更新，添加日志记录的方法
//标准值更新,创建日志记录
public static void SetDetectionValueQualifiedLog(this ReportItem reportItem,string oldValue,string newValue, IDbConnection conn = null)
{
if (conn == null)
{
conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
}
var _log = new EntityLog<ReportItem>();
try
{
_log.OwnerKvid = reportItem.Kvid;
_log.BizId = reportItem.Title;
_log.BizKvid = reportItem.Kvid;
_log.BizType = "Kivii.Lac.Lims.Entities.ReportItem";
}
catch { }
_log.Title = "标准值操作日志";
_log.Type = "OperateDetectionValueQualified";
_log.Summary = $"标准值由“{oldValue}”修改为“{newValue}”";
if(_log.Summary.Length>500)_log.Summary= _log.Summary.Substring(0, 450) + "···";
conn.Insert(_log);
}
//客户要求标准值更新,创建日志记录
public static void SetDetectionValueQualifiedCustomerRequiredLog(this ReportItem reportItem, string type, string updateContent, IDbConnection conn = null)
{
if (reportItem.Metadata == null) return;
if (conn == null)
{
conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
}
var _log = new EntityLog<ReportItem>();
try
{
_log.OwnerKvid = reportItem.Kvid;
_log.BizId = reportItem.Title;
_log.BizKvid = reportItem.Kvid;
_log.BizType = "Kivii.Lac.Lims.Entities.ReportItem";
}
catch { }
_log.Title = "客户要求标准值操作日志";
_log.Type = "OperateDetectionValueQualifiedCustomerRequired";
if (type == "create")
{
updateContent = string.Empty;
if (reportItem.Metadata.ContainsKey("DetectionValueCustomer") || !reportItem.Metadata["DetectionValueCustomer"].IsNullOrEmpty()) updateContent= reportItem.Metadata["DetectionValueCustomer"];
updateContent = "标准值初始值：" + updateContent;
_log.Summary = updateContent;
}
if (type == "update") _log.Summary = updateContent;
if (_log.Summary.Length > 500) _log.Summary = _log.Summary.Substring(0, 450) + "···";
conn.Insert(_log);
}
#endregion
#region 取消标准值更新标记
/// <summary>
/// 数据录入下达时,取消标准值更新标记
/// </summary>
/// <param name="report"></param>
/// <param name="conn"></param>
public static void ResetTagUpdateDetectionValueQualified(this Report report, IDbConnection conn = null)
{
report.ThrowIfNull("未获取报告信息!");
if (conn == null)
{
conn = KiviiContext.GetOpenedDbConnection<Report>();
}
var allReportItems = report.GetOriginalReportItems(conn);
var queryTestRoles = conn.From<EntityDuty<Test>>();
queryTestRoles.Where(o => o.OwnerKvid == KiviiContext.CurrentMember.Kvid);
queryTestRoles.Select(o => o.RoleName);
var testRoleNames = conn.Select(queryTestRoles).ConvertAll(o => o.RoleName);
//所在组的全部项
var ownerPrimaryItems = allReportItems.Where(o => o.WorkGroupKvid == KiviiContext.CurrentMember.DepartmentKvid || Sql.In(o.WorkGroupName, testRoleNames)).ToList();
//获取修改过标准值的数据
ownerPrimaryItems = ownerPrimaryItems.Where(o=>o.Metadata!=null&&o.Metadata.ContainsKey("IsUpdateDetectionValueQualified")&&o.Metadata["IsUpdateDetectionValueQualified"]=="true").ToList();
foreach (var reportItem in ownerPrimaryItems)
{
reportItem.RemoveAllOnlyProperties();
reportItem.Metadata["IsUpdateDetectionValueQualified"]=null;
reportItem.AddOnlyProperties(o=>o.Metadata);
conn.UpdateOnly(reportItem);
}
}
#endregion
}
}
Src/Extensions/ReportItemExtensions.Formatter.cs 0 → 100644
using Kivii.Lims.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Extensions
{
/// <summary>
/// 报告明细格式化筛选扩展类，使用internal 类型，说明这些扩展方法只能在本动态库中使用
/// </summary>
internal static class ReportItemFormatterExtensions
{
/// <summary>
/// 获取检验大项集合,不包含树形结构。
/// </summary>
/// <param name="allReportItems">必须是一个报告的全项</param>
/// <returns></returns>
public static List<ReportItem> GetMainTest(this List<ReportItem> allReportItems)
{
var rtns = new List<ReportItem>();
if (allReportItems.IsNullOrEmpty()) return rtns;
foreach (var item in allReportItems)
{
if (item.Type == ReportItemType.TestFolder)
{
rtns.Add(item);
continue;
}
if (item.Type == ReportItemType.Test)
{
if (item.ParentKvid == Guid.Empty)
{
rtns.Add(item);
continue;
}
var parentTest = allReportItems.FirstOrDefault(o => o.Kvid == item.ParentKvid);
////如果原列表里未找到父级，需要去数据库里找到
if (parentTest == null)
{
}
//要是仍然为空再跳过
if (parentTest == null) continue;
if (parentTest.Type != ReportItemType.TestFolder)
{
rtns.Add(item);
continue;
}
}
}
return rtns;
}
public static List<ReportItemEx> getTreeItemsEx(this List<ReportItemEx> datasource, Guid kvid)
{
var rtns = datasource.Where(o => o.ParentKvid == kvid).OrderBy(o => o.ReportKvid).OrderBy(o => o.SortId).ThenBy(o => o.SortIdEx).ThenBy(o => o.Title).ToList();
if (rtns.IsNullOrEmpty()) return null;
foreach (var rtn in rtns)
{
rtn.SubItemExs = getTreeItemsEx(datasource, rtn.Kvid);
}
return rtns;
}
public static void getPlatItemsEx(this List<ReportItemEx> treeItems, List<ReportItemEx> rtns)
{
if (treeItems.IsNullOrEmpty()) return;
foreach (var item in treeItems)
{
rtns.Add(item);
getPlatItemsEx(item.SubItemExs, rtns);
item.SubItemExs = null;
}
}
}
}
Src/Extensions/SampleExtension.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Linq;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims
{
public static class SampleExtension
{
/// <summary>
/// 获取子样品的流水号
/// </summary>
/// <param name="sample"></param>
/// <param name="conn"></param>
/// <returns></returns>
[Obsolete("此方法过期")]
public static string GetSubSerialNumber(this Sample sample, IDbConnection conn = null)
{
sample.RootKvid.ThrowIfEmpty("RootKvid不能为空");
if (conn == null) conn = KiviiContext.GetOpenedDbConnection<Sample>();
var rootSample = conn.SingleById<Sample>(sample.RootKvid);
rootSample.ThrowIfNull("主样品不存在");
var allcount = conn.Count<Sample>(o => o.RootKvid == rootSample.Kvid);
//allcount不需要加1，因为Root的也统计进去了
return $"{rootSample.SerialNumber}-{allcount}";
}
}
}
Src/Features/ReportFeature.cs 0 → 100644
using Kivii.Lac.Lims.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims
{
public class ReportFeature : IPlugin
{
public void Register(IAppHost appHost)
{
appHost.RegisterService<ReportService>();
}
}
}
Src/Interfaces/IReportInterface.cs 0 → 100644
using Kivii.Lims.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Interfaces
{
public interface IReportInterface
{
object Execute(Report report, string certificateType);
}
}
Src/Kivii.Lac.Lims.V4.5.csproj 0 → 100644
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{C95B0C60-754F-4248-A65A-B1918D533983}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Kivii.Lac.Lims</RootNamespace>
<AssemblyName>Kivii.Lac.Lims.V4.5</AssemblyName>
<TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<Deterministic>true</Deterministic>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include="Kivii.Common.V4.5, Version=5.6.2024.11000, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\packages\Kivii.Common.5.6.2024.11000\lib\net45\Kivii.Common.V4.5.dll</HintPath>
</Reference>
<Reference Include="Kivii.Core.V4.5, Version=5.6.2024.11000, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\packages\Kivii.Core.5.6.2024.11000\lib\net45\Kivii.Core.V4.5.dll</HintPath>
</Reference>
<Reference Include="Kivii.Linq.V4.5, Version=5.6.2024.11000, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\packages\Kivii.Linq.5.6.2024.11000\lib\net45\Kivii.Linq.V4.5.dll</HintPath>
</Reference>
<Reference Include="Kivii.Office.OpenXml.V4.5, Version=5.6.2025.3220, Culture=neutral, processorArchitecture=MSIL">
<HintPath>..\packages\Kivii.Office.OpenXml.5.6.2025.3220\lib\net45\Kivii.Office.OpenXml.V4.5.dll</HintPath>
</Reference>
<Reference Include="System" />
<Reference Include="System.Core" />
<Reference Include="System.Xml.Linq" />
<Reference Include="System.Data.DataSetExtensions" />
<Reference Include="Microsoft.CSharp" />
<Reference Include="System.Data" />
<Reference Include="System.Net.Http" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="Configs.cs" />
<Compile Include="Entities\B2bLink.cs" />
<Compile Include="Entities\Report.cs" />
<Compile Include="Entities\ReportChange.cs" />
<Compile Include="Entities\ReportFile.cs" />
<Compile Include="Entities\ReportItem.cs" />
<Compile Include="Entities\ReportNote.cs" />
<Compile Include="Entities\Sample.cs" />
<Compile Include="Entities\SampleSource.cs" />
<Compile Include="Entities\Template.cs" />
<Compile Include="Entities\TemplateDetail.cs" />
<Compile Include="Entities\TemplateFile.cs" />
<Compile Include="Entities\Test.cs" />
<Compile Include="Extensions\ReportExtension.cs" />
<Compile Include="Extensions\ReportItemExtension.cs" />
<Compile Include="Extensions\ReportItemExtensions.Formatter.cs" />
<Compile Include="Extensions\SampleExtension.cs" />
<Compile Include="Features\ReportFeature.cs" />
<Compile Include="Interfaces\IReportInterface.cs" />
<Compile Include="LimsRole.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Services\ReportService.cs" />
<Compile Include="Transforms\ReportRequest.cs" />
<Compile Include="Transforms\RestfulB2bLink.cs" />
<Compile Include="Transforms\RestfulReport.cs" />
<Compile Include="Transforms\RestfulReport.Statistic.cs" />
<Compile Include="Transforms\RestfulReportChange.cs" />
<Compile Include="Transforms\RestfulReportFile.cs" />
<Compile Include="Transforms\RestfulReportItem.cs" />
<Compile Include="Transforms\RestfulReportItem.Query.cs" />
<Compile Include="Transforms\RestfulReportNote.cs" />
<Compile Include="Transforms\RestfulSample.cs" />
<Compile Include="Transforms\RestfulSampleSource.cs" />
<Compile Include="Transforms\RestfulTemplate.cs" />
<Compile Include="Transforms\RestfulTemplateDetail.cs" />
<Compile Include="Transforms\RestfulTemplateFile.cs" />
<Compile Include="Transforms\RestfulTest.cs" />
</ItemGroup>
<ItemGroup>
<None Include="packages.config" />
</ItemGroup>
<ItemGroup />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>
\ No newline at end of file
Src/LimsRole.cs 0 → 100644
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims
{
public class LimsRoles:IMemberRoleProvider
{
[RoleMember("实验室管理员","对实验室所有业务均具有管理权限",0)]
public const string Manager = "126D20A0-C426-437C-B808-BBA8DB269079";
[RoleMember("业务员", "负责业务受理", 0)]
public const string LimsBusinesser = "99526FD4-7F9D-4814-938C-82F9343946E7";
[RoleMember("合同评审员", "对业务受理数据进行评审", 0)]
public const string ContractReviewer = "326FAB64-AD05-4971-B9B7-0644D4DDFEE5";
[RoleMember("分派员", "对报告中所有的检测项目进行分组，安排任务至各检测组", 0)]
public const string Assigner = "9B56C205-04F9-42C1-87DD-F07E4DC28860";
[RoleMember("检验管理员", "管理当前报告内所有的检测项目信息", 0)]
public const string InspectAdministrator = "0097112F-474A-4B16-A060-2ABE3DF4BE4D";
[RoleMember("检验员", "对报告中的检测项目进行数据录入和数据复核", 0)]
public const string Inspector = "101A88A8-7EBF-47F4-974B-CB8E6F616DA6";
[RoleMember("编制人", "对报告内容及检测数据进行编制，生成电子文档，调整数据格式", 0)]
public const string Preparer = "6F62FE01-E0D5-4A27-8ABF-F118BFEA807C";
[RoleMember("审核人", "对报告内容进行审核", 0)]
public const string Reviewer = "1CF93FBE-F553-4A8E-ADF9-F0C364E40790";
[RoleMember("签发人", "负责对最终的报告进行签发", 0)]
public const string Issuer = "BD00C812-B4B0-4A7A-88FE-3878505F5346";
[RoleMember("打印员", "系统内置打印员", 0)]
public const string Printor = "6AF0FD59-D9A2-40D6-9954-A27CB2C19E2D";
}
}
Src/Properties/AssemblyInfo.cs 0 → 100644
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
// 有关程序集的一般信息由以下
// 控制。更改这些特性值可修改
// 与程序集关联的信息。
[assembly: AssemblyTitle("Kivii.Lac.Lims.V4.5")]
[assembly: AssemblyDescription("实验室资质认证Lims")]//Lac:Laboratory Accreditation/Certification 实验室认可/认证
[assembly: AssemblyDefaultAlias("Kivii.Lac.Lims")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Kivii.Lac.Lims.V4.5")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCulture("")]
// 将 ComVisible 设置为 false 会使此程序集中的类型
//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型
//请将此类型的 ComVisible 特性设置为 true。
[assembly: ComVisible(false)]
// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID
[assembly: Guid("c95b0c60-754f-4248-a65a-b1918d533983")]
// 程序集的版本信息由下列四个值组成:
//
// 主版本
// 次版本
// 生成号
// 修订号
//
//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值
//通过使用 "*"，如下所示:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("5.4.2025.5160")]
[assembly: AssemblyFileVersion("5.4.2025.5160")]
Src/Services/ReportService.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Lac.Lims.Transforms;
using Kivii.Linq;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Services
{
public class ReportService : Service
{
public object Any(ReportPdf request)
{
request.Code.ThrowIfNullOrEmpty("请传入验证码{Code}");
request.ReportId.ThrowIfNullOrEmpty("请传入报告号{ReportId}.Pdf");
var conn = KiviiContext.GetOpenedDbConnection<Report>();
var queryReportKvid = conn.From<Report>();
queryReportKvid.Where(o => o.ReportId == request.ReportId);
queryReportKvid.Select(o => o.Kvid);
var reportKvid = conn.Single<Guid>(queryReportKvid);
reportKvid.ThrowIfEmpty($"未找到此报告{request.ReportId}");
(!reportKvid.ToString().ToLower().StartsWith(request.Code.ToLower())).ThrowIfTrue("验证码Code 不正确!");
var queryPdfEntityFile = conn.From<EntityDbFile<Report>>();
queryPdfEntityFile.Where(o => o.OwnerKvid == reportKvid && o.ParentKvid == Guid.Empty && o.Extension.ToLower() == ".pdf"&&o.DbFolderPath == "/Reports/Pdf");
var pdfEntityFile = conn.Single(queryPdfEntityFile);
(pdfEntityFile == null).ThrowIfTrue("未找到文件");
if (request.View.IsNullOrEmpty())
{
var physicalFilePath = pdfEntityFile.GetPhysicalPath();
var fileInfo = new FileInfo(physicalFilePath);
return new HttpResult(fileInfo, asAttachment: request.Download, fileName: pdfEntityFile.Name);//asAttachment是否直接下载,fileName文件名称
}
var virtualFilePath = pdfEntityFile.GetVirtualPath();
pdfEntityFile.Path = virtualFilePath;
return new HttpResult
{
Response = pdfEntityFile,
View = request.View
};
}
}
}
Src/Transforms/ReportRequest.cs 0 → 100644
using Kivii.Lims;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
[Route(Configs.RouteReportPdf)]
public class ReportPdf
{
public string Code { get; set; }
public string ReportId { get; set; }
public string View { get; set; }
public bool Download { get; set; } = false;
}
}
Src/Transforms/RestfulB2bLink.cs 0 → 100644
using Kivii.Lims.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
#region CUDQR
[RequiresAnyRole(SystemRoles.Everyone)]
public class B2bLinkCreate : RestfulCreate<B2bLink> { }
[RequiresAnyRole(SystemRoles.Everyone)]
public class B2bLinkUpdate : RestfulUpdate<B2bLink> { }
[RequiresAnyRole(SystemRoles.Everyone)]
public class B2bLinkDelete : RestfulDelete<B2bLink> { }
[RequiresAnyRole(SystemRoles.Everyone)]
public class B2bLinkQuery : RestfulQuery<B2bLink> { }
[RequiresAnyRole(SystemRoles.Everyone)]
public class B2bLinkRead : RestfulRead<B2bLink> { }
#endregion
}
Src/Transforms/RestfulReport.Statistic.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Lac.Lims.Extensions;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
public class ReportStatisticResponse : RestfulQueryResponse<Report>
{
public DateTime BeginTime { get; set; }
public DateTime EndTime { get; set; }
/// <summary>
/// 付款金额
/// </summary>
public decimal AmountPayment { get; set; }
/// <summary>
/// 结算金额
/// </summary>
public decimal AmountSettlement { get; set; }
/// <summary>
/// 报告费 (ServiceFee)
/// </summary>
public decimal AmountReport { get; set; }
/// <summary>
/// 更改报告费 (ChangeFee)
/// </summary>
public decimal AmountReportChange { get; set; }
/// <summary>
/// 检验费(Task表统计来,区别与TaskFee)
/// </summary>
public decimal AmountTask { get; set; }
public decimal AmountUrgent { get; set; }
/// <summary>
/// 检验折后费(Task表统计来,区别与TasksDisCountFee)
/// </summary>
public decimal AmountTaskDiscount { get; set; }
/// <summary>
/// 套餐费(PackageFee)
/// </summary>
public decimal AmountPackage { get; set; }
/// <summary>
/// 应收检测费 AmountTask*UrgentRate
/// </summary>
public decimal AmountTaskTotal { get; set; }
/// <summary>
/// 实收检测费 AmountTaskDiscount*UrgentRate
/// </summary>
public decimal AmountTaskDiscountTotal { get; set; }
/// <summary>
/// 报告批次(不包含X报告)
/// </summary>
public int Quantity { get; set; }
/// <summary>
/// X报告批次
/// </summary>
public int XQuantity { get; set; }
public object GetReportItems()
{
var reportKvids = new List<Guid>();
var rtns = new List<ReportItem>();
if (!Results.IsNullOrEmpty())
{
reportKvids.AddRange(Results.Select(o => o.Kvid));
var conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
rtns = conn.Select<ReportItem>(o => Sql.In(o.ReportKvid, reportKvids));
}
foreach (var item in Results)
{
var details = rtns.Where(o => o.ReportKvid == item.Kvid).ToList();
item.Tag = details.filterReportItem();
}
return rtns;
}
}
[Api(Description = "报告合同统计")]
[RequiresAnyRole(SystemRoles.Everyone)]
public class ReportGroupQuotation : RestfulExecution<Report>
{
public Guid QuotationKvid { get; set; }
public DateTime BeginTime { get; set; }
public DateTime EndTime { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
QuotationKvid.ThrowIfEmpty("请传入要统计的合同信息!");
int monthDay = DateTime.DaysInMonth(DateTime.Now.Year, DateTime.Now.Month);
if (BeginTime == DateTime.MinValue) BeginTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
if (EndTime == DateTime.MinValue) EndTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, monthDay);
BeginTime = DateTime.Parse(BeginTime.ToString("yyyy-MM-dd"));
EndTime = DateTime.Parse(EndTime.ToString("yyyy-MM-dd"));
if (EndTime < BeginTime) throw new Exception("查询结束日期不可小于开始日期!");
var conn = KiviiContext.GetOpenedDbConnection<Report>();
var query = conn.From<Report>();
query.Where(o => o.QuotationKvid == QuotationKvid && o.DealDate >= BeginTime && o.DealDate < EndTime);
query.Select(o => new { o.QuotationName, o.DealDate, o.Amount, o.AmountPlan, o.AmountTest, o.AmountTestPlan, o.AmountSettlement, o.AmountPayment, o.QuotationAmount });
query.OrderBy(o => o.DealDate);
var reports = conn.Select(query);
var rtns = new ReportStatisticResponse();
rtns.Results = new List<Report>();
rtns.BeginTime = BeginTime;
rtns.EndTime = EndTime;
if (reports.IsNullOrEmpty()) return rtns;
reports.ForEach(o =>//处理如果有协议费,那就把折后的检测费清除,方便最终统计
{
if (o.QuotationAmount > 0) o.AmountTest = 0;
});
var group = reports.GroupBy(o => new { o.QuotationName, Category = o.DealDate.Value.ToString("yyyy-MM") });
foreach (var key in group)
{
var item = new Report();
item.QuotationName = key.Key.QuotationName;
item.Category = key.Key.Category;
item.Quantity = key.Count();
item.Amount = key.Sum(o => o.Amount);
item.AmountPlan = key.Sum(o => o.AmountPlan);
item.AmountTest = key.Sum(o => o.AmountTest);
item.AmountTestPlan = key.Sum(o => o.AmountTestPlan);
item.AmountSettlement = key.Sum(o => o.AmountSettlement);
item.AmountPayment = key.Sum(o => o.AmountPayment);
item.QuotationAmount = key.Sum(o => o.QuotationAmount);
rtns.Results.Add(item);
}
rtns.Total = rtns.Results.Count;
return rtns;
}
}
}
Src/Transforms/RestfulReport.cs 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
Src/Transforms/RestfulReportChange.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
#region CDUQD
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class ReportChangeCreate : RestfulCreate<ReportChange>
{
public override bool OnPreRestfulCreate(IRequest req, IResponse res, IDbConnection dbConnection, IRestfulCreateResponse<ReportChange> rtns)
{
Item.Status = 100;
Item.AddOnlyProperties(o => o.Status);
return base.OnPreRestfulCreate(req, res, dbConnection, rtns);
}
}
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class ReportChangeDelete : RestfulDelete<ReportChange>
{
public override bool OnPreRestfulDelete(IRequest req, IResponse res, IDbConnection dbConnection, IRestfulDeleteResponse<ReportChange> rtns)
{
var queryReportChanges = dbConnection.From<ReportChange>();
queryReportChanges.Where(o => Sql.In(o.Kvid, Kvids));
var reportChanges = dbConnection.Select(queryReportChanges);
if (reportChanges.Exists(o => o.Status > 100)) throw new Exception("待删除的更改报告存在非草稿状态的数据，无法删除，请检查后操作！");
return base.OnPreRestfulDelete(req, res, dbConnection, rtns);
}
}
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class ReportChangeUpdate : RestfulUpdate<ReportChange>
{
public override bool OnPreRestfulUpdate(IRequest req, IResponse res, IDbConnection dbConnection, IRestfulUpdateResponse<ReportChange> rtns)
{
var reportChange = dbConnection.SingleById<ReportChange>(Item.Kvid);
if (reportChange.Status > 100) throw new Exception("当前更改报告非草稿状态无法更改！");
return base.OnPreRestfulUpdate(req, res, dbConnection, rtns);
}
}
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class ReportChangeQuery : RestfulQuery<ReportChange> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class ReportChangeRead : RestfulRead<ReportChange> { }
#endregion
#region 统计信息
[RequiresAnyRole(SystemRoles.Everyone)]
public class ReportChangeStatisticsQuery : RestfulExecution<ReportChange>
{
#region QueryArgs
public virtual int? Skip { get; set; }
public virtual int? Take { get; set; }
public virtual string OrderBy { get; set; }
public string OrderByDesc { get; set; }
public virtual string Include { get; set; }
public virtual string Fields { get; set; }
public string QueryKeys { get; set; }
public string QueryValues { get; set; }
#endregion
public override object OnExecution(IRequest req, IResponse res)
{
var conn = KiviiContext.GetOpenedDbConnection<ReportChange>();
var dynamicParams = Request.GetRequestParams();
var autoQuery = Request.TryResolve<IAutoQueryDb>();
autoQuery.IncludeTotal = true;
var request = new RestfulQuery<ReportChange>();
request = request.PopulateWith(this);
var sqlExpress = autoQuery.CreateQuery(Request, conn, request, dynamicParams);
var rtns = autoQuery.Execute(Request, conn, request, sqlExpress);
var reportChangeStatisticalInfo = new ReportStatisticalInfo();
reportChangeStatisticalInfo.Total = rtns.Total;
reportChangeStatisticalInfo.Amount = 0;
foreach (var reportChange in rtns.Results)
{
reportChangeStatisticalInfo.Amount += reportChange.Amount;
}
return reportChangeStatisticalInfo;
}
}
#endregion
#region 手动建立更改报告的审批流程
//申请审批 Status->150
[RequiresAnyRole(MemberRoles.Administrator,MemberRoles.Manager,MemberRoles.Configuration)]
[Api(Description = "申请审批")]
public class ReportChangeApply : RestfulExecution<ReportChange>
{
public Guid Kvid { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
var conn = KiviiContext.GetOpenedDbConnection<ReportChange>();
var reportChange = conn.SingleById<ReportChange>(Kvid);
var rtns = new RestfulUpdateResponse<ReportChange>();
rtns.Results = new List<ReportChange>();
reportChange.ThrowIfNull("未查到该更改报告申请！");
if (reportChange.Status > 100) throw new Exception("当前更改报告申请非待审批状态，无法申请审批！");
//重新申请，清空打回标记
if (reportChange.Metadata != null && reportChange.Metadata.ContainsKey("CallBackTo") && reportChange.Metadata["CallBackTo"] == "100")
{
reportChange.Metadata["CallBackTo"] = null;
reportChange.AddOnlyProperties(o => o.Metadata);
}
reportChange.Status = 150;
reportChange.AddOnlyProperties(o => o.Status);
conn.UpdateOnly(reportChange);
reportChange.RemoveAllOnlyProperties();
rtns.Results.Add(reportChange);
#region 创建操作日志
var _log = new EntityLog<ReportChange>();
_log.OwnerKvid = Kvid;
_log.Title = "更改报告";
_log.Type = "流转";
_log.Summary = "提交了更改报告申请";
conn.Insert(_log);
#endregion
return rtns;
}
}
//申请驳回 Status->150
[RequiresAnyRole(MemberRoles.Administrator, MemberRoles.Manager, MemberRoles.Configuration)]
[Api(Description = "驳回审批")]
public class ReportChangeRefuse : RestfulExecution<ReportChange>
{
public Guid Kvid { get; set; }
public string Remark { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
var conn = KiviiContext.GetOpenedDbConnection<ReportChange>();
var reportChange = conn.SingleById<ReportChange>(Kvid);
var rtns = new RestfulUpdateResponse<ReportChange>();
rtns.Results = new List<ReportChange>();
reportChange.ThrowIfNull("未查到该更改报告申请");
if (reportChange.Status != 150) throw new Exception("当前更改报告申请非审批状态，无法驳回审批！");
if (reportChange.Metadata == null) reportChange.Metadata = new Dictionary<string, string>();
reportChange.Metadata["CallBackFrom"] = "150";
reportChange.Metadata["CallBackTo"] = "100";
reportChange.AddOnlyProperties(o => o.Metadata);
reportChange.Status = 100;
reportChange.AddOnlyProperties(o => o.Status);
conn.UpdateOnly(reportChange);
reportChange.RemoveAllOnlyProperties();
rtns.Results.Add(reportChange);
#region 创建操作日志
var _log = new EntityLog<ReportChange>();
_log.OwnerKvid = Kvid;
_log.Title = "更改报告";
_log.Type = "流转";
_log.Summary = "驳回了更改报告申请审批";
_log.Remark = Remark;
conn.Insert(_log);
#endregion
return rtns;
}
}
//更改报告申请同意
[RequiresAnyRole(MemberRoles.Administrator, MemberRoles.Manager, MemberRoles.Configuration)]
[Api(Description = "同意")]
public class ReportChangeFinish : RestfulExecution<ReportChange>
{
public Guid Kvid { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
var conn = KiviiContext.GetOpenedDbConnection<ReportChange>();
var reportChange = conn.SingleById<ReportChange>(Kvid);
var rtns = new RestfulUpdateResponse<ReportChange>();
rtns.Results = new List<ReportChange>();
reportChange.ThrowIfNull("未查到该更改报告申请单");
//验证报告是否归档，报告未归档，不允许更改
var queryOriginalReport = conn.From<Report>();
queryOriginalReport.Where(o => o.ReportId == reportChange.ReportId);
var originalReport = conn.Select(queryOriginalReport).FirstOrDefault();
originalReport.ThrowIfNull("未查询到原报告！");
if (originalReport.StatusType != ReportStatusType.ReportCollected) throw new Exception("原报告未归档，无法更改！");
if (reportChange.Status != 150 ) throw new Exception("当前更改报告申请单非审批状态，无法启用！");
reportChange.Status = 200;
reportChange.AddOnlyProperties(o => o.Status);
conn.UpdateOnly(reportChange);
reportChange.RemoveAllOnlyProperties();
rtns.Results.Add(reportChange);
#region 创建操作日志
var _log = new EntityLog<ReportChange>();
_log.OwnerKvid = Kvid;
_log.Title = "更改报告";
_log.Type = "流转";
_log.Summary = "同意了更改报告申请";
conn.Insert(_log);
#endregion
return rtns;
}
}
[RequiresAnyRole(MemberRoles.Administrator, MemberRoles.Manager, MemberRoles.Configuration)]
[Api(Description = "初始化")]
public class ReportChangeInit : RestfulExecution<ReportChange>
{
public Guid Kvid { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
var conn = KiviiContext.GetOpenedDbConnection<ReportChange>();
var reportChange = conn.SingleById<ReportChange>(Kvid);
var rtns = new RestfulUpdateResponse<ReportChange>();
rtns.Results = new List<ReportChange>();
reportChange.ThrowIfNull("未查到该更改报告申请");
if (reportChange.Status == 100) throw new Exception("当前更改报告申请单已是草稿状态，无需初始化！");
reportChange.Status = 100;
reportChange.AddOnlyProperties(o => o.Status);
conn.UpdateOnly(reportChange);
reportChange.RemoveAllOnlyProperties();
rtns.Results.Add(reportChange);
#region 创建操作日志
var _log = new EntityLog<ReportChange>();
_log.OwnerKvid = Kvid;
_log.Title = "更改报告";
_log.Type = "流转";
_log.Summary = "初始化至草稿状态";
conn.Insert(_log);
#endregion
return rtns;
}
}
//审批中未审核通过的报告进行召回
[RequiresAnyRole(MemberRoles.Administrator, MemberRoles.Manager, MemberRoles.Configuration)]
[Api(Description = "召回")]
public class ReportChangeBack : RestfulExecution<ReportChange>
{
public Guid Kvid { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
var conn = KiviiContext.GetOpenedDbConnection<ReportChange>();
var reportChange = conn.SingleById<ReportChange>(Kvid);
var rtns = new RestfulUpdateResponse<ReportChange>();
rtns.Results = new List<ReportChange>();
reportChange.ThrowIfNull("未查到该更改报告申请");
if (reportChange.Status != 150) throw new Exception("当前更改报告申请单状态禁止召回！");
reportChange.Status = 100;
reportChange.AddOnlyProperties(o => o.Status);
conn.UpdateOnly(reportChange);
reportChange.RemoveAllOnlyProperties();
rtns.Results.Add(reportChange);
#region 创建操作日志
var _log = new EntityLog<ReportChange>();
_log.OwnerKvid = Kvid;
_log.Title = "更改报告";
_log.Type = "流转";
_log.Summary = "召回至草稿状态";
conn.Insert(_log);
#endregion
return rtns;
}
}
#endregion
}
Src/Transforms/RestfulReportFile.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
[RequiresAnyRole(SystemRoles.Everyone)]
public class ReportFileQuery:RestfulQuery<ReportFile>
{
}
[RequiresAnyRole(SystemRoles.Everyone)]
public class ReportFileUpdate : RestfulUpdate<ReportFile>
{
}
[RequiresAnyRole(SystemRoles.Everyone)]
public class ReportFileDelete : RestfulDelete<ReportFile>
{
}
[RequiresAnyRole(SystemRoles.Everyone)]
public class ReportFileUpdateSortId : RestfulExecution<ReportFile>
{
public List<ReportFile> reportFiles { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
#region 数据验证
(reportFiles.Count == 0).ThrowIfTrue("未传入操作数据!");
#endregion
var conn = KiviiContext.GetOpenedDbConnection<ReportFile>();
var rtns = new RestfulQueryResponse<ReportFile>();
rtns.Results = new List<ReportFile>();
foreach (var reportFile in reportFiles)
{
reportFile.AddOnlyProperties(o=>o.SortID);
conn.UpdateOnly(reportFile);
rtns.Results.Add(reportFile);
}
rtns.Total = rtns.Results.Count;
return rtns;
}
}
}
Src/Transforms/RestfulReportItem.Query.cs 0 → 100644

using Kivii.DataAnnotations;
using Kivii.Lims.Entities;
using Kivii.Lac.Lims.Extensions;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Linq;
using Kivii.Lims;
namespace Kivii.Lac.Lims.Transforms
{
[RequiresAnyRole(SystemRoles.Everyone)]
[Api(Description = "展示报告的检测项目（大项）")]
public class ReportItemMain: RestfulExecution<ReportItem>
{
/// <summary>
/// 要查看的项目报告Kvid,有部位信息则合并到大项中PartKvid和TitlePart
/// </summary>
[ApiMember(Description ="报告主键"),Required]
public Guid ReportKvid { get; set; }
/// <summary>
/// 是否仅筛选传入的检验小组的检验项目,默认筛选全部项目
/// </summary>
public Guid WorkGroupKvid { get; set; }
/// <summary>
/// 是否是登录人所在组,默认false全部组
/// </summary>
public bool Owned { get; set; }
/// <summary>
/// 是否已经分组,默认不筛选
/// </summary>
public bool? Grouped { get; set; }
/// <summary>
/// 是否已经判定,默认不筛选
/// </summary>
public bool? Judged { get; set; }
/// <summary>
/// 仅显示主项,默认false,注:true时 上述分类无效
/// 目前在报告结算时 明细清单使用到
/// </summary>
public bool OnlyMainItem { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
ReportKvid.ThrowIfEmpty("请指定要查看项目的报告Kvid!");
var rtns = new RestfulQueryResponse<ReportItem>();
rtns.Results = new List<ReportItem>();
if (ReportKvid == Guid.Empty) return rtns;//为什么????
var conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
//整个报告的全部项目
var allReportItems = conn.Select<ReportItem>(o => o.ReportKvid == ReportKvid);
if (allReportItems.IsNullOrEmpty()) return rtns;
//全项中的大项
var primaryAllReportItems = allReportItems.filterReportItem();
List<ReportItem> finalResults = new List<ReportItem>();
finalResults.AddRange(allReportItems);
//只筛选主项出来
if (OnlyMainItem)
{
finalResults = new List<ReportItem>();
finalResults.AddRange(primaryAllReportItems);
}
else
{
//只查看登录人所在组
if (Owned || WorkGroupKvid != Guid.Empty)
{
finalResults = new List<ReportItem>();
//所在组的全部大项
List<ReportItem> ownerPrimaryItems = null;
if (WorkGroupKvid != Guid.Empty) ownerPrimaryItems = primaryAllReportItems.Where(o => o.WorkGroupKvid == WorkGroupKvid).ToList();
else if (Owned)
{
//获取duty表中对应的角色
var queryTestRoles = conn.From<EntityDuty<Test>>();
queryTestRoles.Where(o => o.OwnerKvid == KiviiContext.CurrentMember.Kvid);
queryTestRoles.Select(o => o.RoleName);
var testRoleNames = conn.Select(queryTestRoles).ConvertAll(o => o.RoleName);
ownerPrimaryItems = primaryAllReportItems.Where(o => o.WorkGroupKvid == KiviiContext.CurrentMember.DepartmentKvid || testRoleNames.Contains(o.WorkGroupName)).ToList();
}
//没找到直接返回了
if (ownerPrimaryItems.IsNullOrEmpty()) return rtns;
//ownerPrimaryItems.ForEach(o =>
//{
//if (!finalResults.Exists(p => p.Kvid == o.Kvid)) finalResults.Add(o);
//});
finalResults.AddRange(ownerPrimaryItems);
var ownerNodeItems = allReportItems.Where(o => ownerPrimaryItems.ConvertAll(p => p.Kvid).Contains(o.ParentKvid)).ToList();
if (!ownerNodeItems.IsNullOrEmpty()) finalResults.AddRange(ownerNodeItems);
var ownerPartItems = allReportItems.Where(o => o.Type == ReportItemType.SamplePart && ownerPrimaryItems.ConvertAll(p => p.ParentKvid).Contains(o.Kvid)).ToList();
if (!ownerPartItems.IsNullOrEmpty())
{
finalResults.AddRange(ownerPartItems);
var ownerRootItems = allReportItems.Where(o => o.Type == ReportItemType.SampleSelf && (ownerPartItems.ConvertAll(p => p.ParentKvid).Contains(o.Kvid) || ownerPrimaryItems.ConvertAll(p => p.ParentKvid).Contains(o.Kvid))).ToList();
if (!ownerRootItems.IsNullOrEmpty()) finalResults.AddRange(ownerRootItems);
}
else
{
var ownerRootItems = allReportItems.Where(o => o.Type == ReportItemType.SampleSelf && ownerPrimaryItems.ConvertAll(p => p.ParentKvid).Contains(o.Kvid)).ToList();
if (!ownerRootItems.IsNullOrEmpty()) finalResults.AddRange(ownerRootItems);
}
}
//筛选是否已分组
if (Grouped != null)
{
var primaryItems = finalResults.filterReportItem();
if (!primaryItems.IsNullOrEmpty())
{
//只查已分组
if (Grouped.Value)
{
//只留下未分组的项目
primaryItems.RemoveAll(o => o.WorkGroupKvid != Guid.Empty);
}
//只查未分组
else
{
//只留下已分组的项目
primaryItems.RemoveAll(o => o.WorkGroupKvid == Guid.Empty);
}
//待移除的大项
var preRemoveKvids = primaryItems.ConvertAll(p => p.Kvid);
finalResults.RemoveAll(o => preRemoveKvids.Contains(o.Kvid));
//也移除下面的子项
finalResults.RemoveAll(o => preRemoveKvids.Contains(o.ParentKvid));
}
}
//筛选是否已判定
if (Judged != null)
{
var primaryItems = finalResults.filterReportItem();
if (!primaryItems.IsNullOrEmpty())
{
//只查已判定
if (Judged.Value)
{
//只留下未判定的项目
primaryItems.RemoveAll(o => !o.Judgement.IsNullOrEmpty());
}
//只查未判定
else
{
//只留下已判定的项目
primaryItems.RemoveAll(o => o.Judgement.IsNullOrEmpty());
}
//待移除的大项
var preRemoveKvids = primaryItems.ConvertAll(p => p.Kvid);
finalResults.RemoveAll(o => preRemoveKvids.Contains(o.Kvid));
//也移除下面的子项
finalResults.RemoveAll(o => preRemoveKvids.Contains(o.ParentKvid));
}
}
}
#region 清理只有色号或部位的项
//要是都没有检验项目 则清除当前Root下面的项目
var group = finalResults.GroupBy(o => o.RootKvid);
foreach (var kv in group)
{
if (!kv.ToList().Exists(o => o.Type == ReportItemType.Test || o.Type == ReportItemType.TestFolder)) finalResults.RemoveAll(o => o.RootKvid == kv.Key);
}
#endregion
#region 合并部位信息
rtns.Results.AddRange(finalResults);
var sampleParts = rtns.Results.Where(o => o.Type == ReportItemType.SamplePart).ToList();
if (sampleParts.IsNullOrEmpty())
{
//要是最后都没有检验项目返回了 则清除全部项目
if (!rtns.Results.Exists(o => o.Type == ReportItemType.Test || o.Type == ReportItemType.TestFolder)) rtns.Results.Clear();
//var newList2 = new List<ReportItem>();
//foreach (var item in rtns.Results)
//{
// if (newList2.Exists(o => o.Kvid == item.Kvid)) continue;
// newList2.Add(item);
//}
//rtns.Results = newList2;
rtns.Total = rtns.Results.Count;
return rtns;
}
foreach (var samplePart in sampleParts)
{
var tests = rtns.Results.Where(o => o.ParentKvid == samplePart.Kvid).ToList();
foreach (var test in tests)
{
test.TitlePart = samplePart.Title;
test.ParentKvid = samplePart.ParentKvid;
test.PartKvid = samplePart.Kvid;
}
}
rtns.Results.RemoveAll(o => sampleParts.ConvertAll(p => p.Kvid).Contains(o.Kvid));
#endregion
//要是最后都没有检验项目返回了 则清除全部项目
if (!rtns.Results.Exists(o => o.Type == ReportItemType.Test || o.Type == ReportItemType.TestFolder)) rtns.Results.Clear();
rtns.Total = rtns.Results.Count;
return rtns;
}
}
#region 不合格项目统计[使用模板方式]
public class ReportItemUnqualifiedQuery : RestfulExecution<ReportItem>
{
#region 报告查询参数
public DateTime? DealDateFrom { get; set; }
public DateTime? DealDateTo { get; set; }
public string DemanderName { get; set; }
public string SampleManufacturerName { get; set; }
public string PayerName { get; set; }
public string ReportIdNumber { get; set; }
public string SampleName { get; set; }
public string ReportItemTitle { get; set; }
public bool JudgementNoPass { get; set; }//筛选判定不合格的项目
#endregion
#region QueryArgs
public virtual int? Skip { get; set; }
public virtual int? Take { get; set; }
public virtual string OrderBy { get; set; }
public string OrderByDesc { get; set; }
public virtual string Include { get; set; }
public virtual string Fields { get; set; }
public string QueryKeys { get; set; }
public string QueryValues { get; set; }
#endregion
public override object OnExecution(IRequest req, IResponse res)
{
if (DealDateFrom == null || DealDateTo == null) throw new Exception("参数委托日期范围不能为空！");
var conn = KiviiContext.GetOpenedDbConnection<ReportItem>();
var dynamicParams = Request.GetRequestParams();
var autoQuery = Request.TryResolve<IAutoQueryDb>();
autoQuery.IncludeTotal = true;
var request = new RestfulQuery<ReportItemEx>();
request.PopulateWith(this);
var sqlExpress = autoQuery.CreateQuery(Request, conn, request, dynamicParams);
sqlExpress.Rows = null;
sqlExpress
.LeftJoin<Report>((reportItemEx, report) => reportItemEx.ReportKvid == report.Kvid)
.Select<ReportItemEx, Report>((reportItemEx, report) => new
{
T = Sql.AllFields(reportItemEx),
report.ReportId,
ReportDemanderName = report.DemanderName,
ReportDealDate = report.DealDate,
ReportDeadDate = report.DeadDate,
ReportSampleName = report.SampleName,
ReportSampleBatchNumber = report.SampleBatchNumber,
ReportSampleBrand = report.SampleBrand,
ReportPayerName = report.PayerName,
ReportMetadataString = report.Metadata
//ReportAttachDocument = report.Metadata.ContainsKey("DescriptionSpecial") ? report.Metadata["DescriptionSpecial"] : "",
});
if (DealDateFrom != null)
{
sqlExpress.And<Report>(o => o.DealDate >= DealDateFrom);
}
if (DealDateTo != null)
{
sqlExpress.And<Report>(o => o.DealDate <= DealDateTo);
}
if (!DemanderName.IsNullOrEmpty())
{
sqlExpress.And<Report>(o => o.DemanderName.Contains(DemanderName));
}
if (!SampleManufacturerName.IsNullOrEmpty())
{
sqlExpress.And<Report>(o => o.SampleManufacturerName.Contains(SampleManufacturerName));
}
if (!PayerName.IsNullOrEmpty())
{
sqlExpress.And<Report>(o => o.PayerName.Contains(PayerName));
}
if (!ReportIdNumber.IsNullOrEmpty())
{
sqlExpress.And<Report>(o => o.ReportId.Contains(ReportIdNumber));
}
if (!SampleName.IsNullOrEmpty())
{
sqlExpress.And<Report>(o => o.SampleName.Contains(SampleName));
}
if (!ReportItemTitle.IsNullOrEmpty())
{
sqlExpress.And<ReportItemEx>(o => o.Title.Contains(ReportItemTitle));
}
//sqlExpress.And<ReportItemEx>(o => o.Judgement == "不合格" || o.Judgement == "不符合");
if (JudgementNoPass) sqlExpress.And<ReportItemEx>(o => Sql.In(o.Judgement, Configs.JudgementNoPassResults));
var rtns = autoQuery.Execute(Request, conn, request, sqlExpress);
//根据查询结果中的大项，找出子项
var nodeParentKvid = rtns.Results.Where(o => o.Type == ReportItemType.TestFolder).ToList().ConvertAll(o => o.Kvid).Distinct().ToList();
var queryNode = conn.From<ReportItem>();
queryNode.Where(o => o.Type == ReportItemType.Test && Sql.In(o.ParentKvid, nodeParentKvid));
if (JudgementNoPass) queryNode.And<ReportItem>(o => Sql.In(o.Judgement, Configs.JudgementNoPassResults));
var nodeList = conn.Select(queryNode);
//根据查询结果中的parentKvid找出检验项目色号或部位数据//增加大项的，避免检索出结果无大项
var uniqueParentKvid = rtns.Results.ConvertAll(o => o.ParentKvid).Distinct().ToList();
var queryParent = conn.From<ReportItem>();
queryParent.Where(o => (o.Type == ReportItemType.SampleSelf || o.Type == ReportItemType.SamplePart || o.Type == ReportItemType.TestFolder) && Sql.In(o.Kvid, uniqueParentKvid));
var parentList = conn.Select(queryParent);
//可能存在大项的父项，需要再查一次
var uniqueGrandParentKvid = parentList.ConvertAll(o => o.ParentKvid).Distinct().ToList();
var queryGrandParent = conn.From<ReportItem>();
queryGrandParent.Where(o => (o.Type == ReportItemType.SampleSelf || o.Type == ReportItemType.SamplePart) & Sql.In(o.Kvid, uniqueGrandParentKvid));
var grandParentList = conn.Select(queryGrandParent);
//可能存在部位的父项，需要再查一次
var uniqueGrandGrandParentKvid = grandParentList.ConvertAll(o => o.ParentKvid).Distinct().ToList();
var queryGrandGrandParent = conn.From<ReportItem>();
queryGrandGrandParent.Where(o => (o.Type == ReportItemType.SampleSelf) & Sql.In(o.Kvid, uniqueGrandGrandParentKvid));
var grandGrandParentList = conn.Select(queryGrandGrandParent);
//合并
var allParent = new List<ReportItem>();
allParent.AddRange(parentList);
allParent.AddRange(grandParentList);
allParent.AddRange(grandGrandParentList);
allParent = allParent.Distinct().ToList();
//sqlExpress.OrderBy(o => o.ReportKvid);
var rtnResults = new List<ReportItemEx>();
rtnResults.AddRange(rtns.Results);
//遍历返回的检验项目，从合并的父项中匹配色号或部位信息
foreach (var item in rtns.Results)
{
var parent = allParent.FirstOrDefault(o => o.Kvid == item.ParentKvid);
if (parent != null)
{
if (parent.Type == ReportItemType.TestFolder)
{
if (rtnResults.Exists(o => o.Kvid == parent.Kvid))
{
item.DetectionCodeActual = parent.DetectionCodeActual;
item.StandardCode = parent.StandardCode;
continue;
}
var addItem = new ReportItemEx();
addItem.PopulateWith(parent);
var grandParent = allParent.FirstOrDefault(o => o.Kvid == parent.ParentKvid);
if (grandParent != null)
{
if (grandParent.Type == ReportItemType.SamplePart)
{
var grandgrandParent = allParent.FirstOrDefault(o => o.Kvid == grandParent.ParentKvid);//色号
if (grandgrandParent != null)
{
addItem.TitlePart = grandParent.Title;
addItem.TitleSelf = grandgrandParent.Title;
//addItem.Title = $"{addItem.Title}[{grandgrandParent.Title}]({grandParent.Title})";
}
else
{
addItem.TitlePart = grandParent.Title;
//addItem.Title = $"{addItem.Title}({grandParent.Title})";
}
}
else
{
addItem.TitleSelf = grandParent.Title;
//addItem.Title = $"{addItem.Title}[{grandParent.Title}]";
}
}
addItem.ParentKvid = Guid.Empty;
addItem.RootKvid = Guid.Empty;
addItem.ReportId = item.ReportId;
addItem.ReportDemanderName = item.ReportDemanderName;
addItem.ReportDealDate = item.ReportDealDate;
addItem.ReportDeadDate = item.ReportDeadDate;
addItem.ReportSampleName = item.ReportSampleName;
addItem.ReportSampleBatchNumber = item.ReportSampleBatchNumber;
addItem.ReportSampleBrand = item.ReportSampleBrand;
addItem.ReportPayerName = item.ReportPayerName;
addItem.ReportMetadataString = item.ReportMetadataString;
item.DetectionCodeActual = addItem.DetectionCodeActual;
item.StandardCode = addItem.StandardCode;
item.TitlePart = addItem.TitlePart;
item.TitleSelf = addItem.TitleSelf;
rtnResults.Add(addItem);
}
else if (parent.Type == ReportItemType.SamplePart)
{
var grandParent = allParent.FirstOrDefault(o => o.Kvid == parent.ParentKvid);//色号
if (grandParent != null)
{
item.TitlePart = parent.Title;
item.TitleSelf = grandParent.Title;
//item.Title = $"{item.Title}[{grandParent.Title}]({parent.Title})";
}
else
{
item.TitlePart = parent.Title;
//item.Title = $"{item.Title}({parent.Title})";
}
item.ParentKvid = Guid.Empty;
item.RootKvid = Guid.Empty;
}
else
{
item.TitleSelf = parent.Title;
//item.Title = $"{item.Title}[{parent.Title}]";
item.ParentKvid = Guid.Empty;
item.RootKvid = Guid.Empty;
}
}
var nodes = nodeList.Where(o => o.ParentKvid == item.Kvid).ToList();
if (!nodes.IsNullOrEmpty())
{
foreach (var node in nodes)
{
if (rtnResults.Exists(o => o.Kvid == node.Kvid)) continue;
var addItem = new ReportItemEx();
addItem.PopulateWith(node);
addItem.ReportId = item.ReportId;
addItem.ReportDemanderName = item.ReportDemanderName;
addItem.ReportDealDate = item.ReportDealDate;
addItem.ReportDeadDate = item.ReportDeadDate;
addItem.ReportSampleName = item.ReportSampleName;
addItem.ReportSampleBatchNumber = item.ReportSampleBatchNumber;
addItem.ReportSampleBrand = item.ReportSampleBrand;
addItem.ReportPayerName = item.ReportPayerName;
addItem.ReportMetadataString = item.ReportMetadataString;
addItem.TitlePart = item.TitlePart;
addItem.TitleSelf = item.TitleSelf;
addItem.DetectionCodeActual = item.DetectionCodeActual;
addItem.StandardCode = item.StandardCode;
rtnResults.Add(addItem);
}
}
}
rtnResults = rtnResults.Distinct().OrderBy(o => o.ReportId).ToList();
var treeItems = rtnResults.getTreeItemsEx(Guid.Empty);
var resPlatResults = new List<ReportItemEx>();
treeItems.getPlatItemsEx(resPlatResults);
resPlatResults = resPlatResults.OrderBy(o => o.ReportId).ToList();
return resPlatResults;
}
}
#endregion
}
Src/Transforms/RestfulReportItem.cs 0 → 100644
This source diff could not be displayed because it is too large. You can view the blob instead.
Src/Transforms/RestfulReportNote.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
#region CUDQR
[RequiresAnyRole(SystemRoles.Everyone)]
public class ReportNoteQuery:RestfulQuery<ReportNote> { }
#endregion
#region 报告打回及返工任务查询
[Api(Description = "报告打回及返工任务查询")]
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class ReportNoteQueryEx : RestfulExecution<ReportNote>
{
//参数名不能与返回的字段同名
public string ReportIdFilter { get; set; }
public string ReportOperatorNameFilter { get; set; }
public DateTime? DeadDateGreaterThanOrEqualTo { get; set; }
public DateTime? DeadDateLessThanOrEqualTo { get; set; }
#region QueryArgs
public virtual int? Skip { get; set; }
public virtual int? Take { get; set; }
public virtual string OrderBy { get; set; }
public string OrderByDesc { get; set; }
public virtual string Include { get; set; }
public virtual string Fields { get; set; }
public string QueryKeys { get; set; }
public string QueryValues { get; set; }
#endregion
public override object OnExecution(IRequest req, IResponse res)
{
//返工的title要提前组织好
List<string> titles = new List<string>();
titles.Add("任务打回");
titles.Add("项目打回");
titles.Add("回收");
titles.Add("报告召回");
var conn = KiviiContext.GetOpenedDbConnection<ReportNote>();
var dynamicParams = Request.GetRequestParams();
var autoQuery = Request.TryResolve<IAutoQueryDb>();
autoQuery.IncludeTotal = true;
var request = new RestfulQuery<ReportNoteEx>();
request.PopulateWith(this);
var sqlExpress = autoQuery.CreateQuery(Request, conn, request, dynamicParams);
sqlExpress
.LeftJoin<Report>((reportNoteEx, report) => reportNoteEx.ReportKvid == report.Kvid)
.Select<ReportNote, Report>((reportNote, report) => new
{
T = Sql.AllFields(reportNote),
report.ReportId,
ReportOperatorName = report.OperatorName,
ReportPreparerName = report.PreparerName
});
sqlExpress.And<ReportNote>(o => Sql.In(o.Title, titles));
if (!ReportIdFilter.IsNullOrEmpty())
{
sqlExpress.And<Report>(o => o.ReportId.Contains(ReportIdFilter));
}
if (!ReportOperatorNameFilter.IsNullOrEmpty())
{
sqlExpress.And<Report>(o => o.OperatorName.Contains(ReportOperatorNameFilter));
}
if (DeadDateGreaterThanOrEqualTo != null)
{
sqlExpress.And<Report>(o => o.DeadDate >= DeadDateGreaterThanOrEqualTo);
}
if (DeadDateLessThanOrEqualTo != null)
{
sqlExpress.And<Report>(o => o.DeadDate <= DeadDateLessThanOrEqualTo);
}
var rtns = autoQuery.Execute(Request, conn, request, sqlExpress);
return rtns;
}
}
#endregion
}
Src/Transforms/RestfulSample.cs 0 → 100644
using Kivii.Lims;
using Kivii.Lims.Entities;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
#region CDUQD
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleCreate : RestfulCreate<Sample> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleDelete : RestfulDelete<Sample> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleUpdate : RestfulUpdate<Sample> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleQuery : RestfulQuery<Sample> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleRead : RestfulRead<Sample> { }
#endregion
[RequiresAnyRole(SystemRoles.Everyone)]
public class SampleBindImages : RestfulExecution<Sample>
{
public Guid DbFileKvid { get; set; }
public List<Guid> DbFileKvids { get; set; }
public Guid ReportKvid { get; set; }
public bool AutoDelete { get; set; } = true;
public override object OnExecution(IRequest req, IResponse res)
{
(DbFileKvid == Guid.Empty && DbFileKvids.IsNullOrEmpty()).ThrowIfTrue("Need DbFileKvid Or DbFileKvids!");
if (DbFileKvids.IsNullOrEmpty()) DbFileKvids = new List<Guid>();
if (DbFileKvid != Guid.Empty) DbFileKvids.Add(DbFileKvid);
if (ReportKvid == Guid.Empty) throw new Exception("缺少关联报告信息");
var conn = KiviiContext.GetOpenedDbConnection<Report>();
var report = conn.SingleById<Report>(ReportKvid);
if (report == null) throw new Exception("未找到此报告信息！");
conn.InitEntityType<EntityDbFile<Sample>>();
var dbFiles = conn.SelectByIds<EntityDbFile<Sample>>(DbFileKvids);
if (dbFiles.IsNullOrEmpty()) throw new Exception("未找到要关联的图片");
var rtns = new RestfulExecutionResponse<EntityDbFile<Sample>>();
rtns.Results = new List<EntityDbFile<Sample>>();
foreach (var item in dbFiles)
{
var filePath = item.GetPhysicalPath();
Stream mStream = File.OpenRead(filePath);
var sPath = $"/Storages{Configs.RouteReportSampleFilePath}/{report.SampleKvid}/{item.Name}";
var virtualFile = KiviiContext.VirtualFiles.WriteFile(sPath, mStream);
mStream.Close();
mStream.Dispose();
if (AutoDelete) conn.DeleteById<EntityDbFile<Sample>>(item.Kvid);
rtns.Results.Add(item);
}
return rtns;
}
}
#region 新建报告绑定Sample功能
//[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
//[Api(Description = "样品绑定")]
//public class SampleBind : RestfulExecution<Sample>
//{
// public Guid SampleKvid { get; set; }
// public Report Report { get; set; }
// public override object OnExecution(IRequest req, IResponse res)
// {
// //验证数据有效性
// var conn = KiviiContext.GetOpenedDbConnection<Report>();
// var sample = conn.SingleById<Sample>(SampleKvid);
// sample.ThrowIfNull("未查询到绑定的样品信息！");
// if (Report.Kvid != Guid.Empty) throw new Exception("当前报告已关联了样品，无法绑定新的样品！");
// var rtns = new RestfulCreateResponse<Report>();
// var trans = conn.OpenTransaction();
// try
// {
// //创建report
// var report = new Report();
// report.PopulateWith(Report);
// report.Kvid = Guid.NewGuid();
// report.ReportId = string.Empty;
// report.SampleBatchNumber = sample.BatchNumber;
// report.SampleBrand = sample.Brand;
// report.SampleGrade = sample.Grade;
// report.SampleGradeSafety = sample.GradeSafety;
// report.SampleKvid = sample.Kvid;
// report.SampleManufacturerAddress = sample.ManufacturerAddress;
// report.SampleManufacturerContactKvid = sample.ManufacturerContactKvid;
// report.SampleManufacturerContactName = sample.ManufacturerContactName;
// report.SampleManufacturerContactNumber = sample.ManufacturerContactNumber;
// report.SampleManufacturerKvid = sample.ManufacturerKvid;
// report.SampleManufacturerName = sample.ManufacturerName;
// report.SampleModel = sample.Model;
// report.SampleName = sample.Name;
// report.SampleQuantity = sample.Quantity;
// report.SampleQuantityUnit = sample.QuantityUnit;
// conn.Insert(report);
// report.RemoveAllOnlyProperties();
// rtns.Results = new List<Report>();
// rtns.Results.Add(report);
// //查询Test
// var queryTests = conn.From<Test>();
// queryTests.Where(o => o.SampleKvid == SampleKvid);
// var tests = conn.Select(queryTests);
// //创建ReportJudgement
// foreach (var test in tests)
// {
// var reportJudgement = new ReportJudgement();
// reportJudgement.ReportKvid = report.Kvid;
// reportJudgement.TestKvid = test.Kvid;
// reportJudgement.ValueUnit = test.ValueUnit;
// reportJudgement.ValueQualified = test.ValueQualified;
// conn.Insert(reportJudgement);
// }
// trans?.Commit();
// }
// catch(Exception ex)
// {
// trans?.Rollback();
// throw ex;
// }
// return rtns;
// }
//}
#endregion
}
Src/Transforms/RestfulSampleSource.cs 0 → 100644
using Kivii.Lims.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
#region CDUQD
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleSourceCreate : RestfulCreate<SampleSource> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleSourceDelete : RestfulDelete<SampleSource> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleSourceUpdate : RestfulUpdate<SampleSource> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleSourceQuery : RestfulQuery<SampleSource> { }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class SampleSourceRead : RestfulRead<SampleSource> { }
#endregion
}
Src/Transforms/RestfulTemplate.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateCreate : RestfulCreate<Template>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateRead : RestfulRead<Template>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateUpdate : RestfulUpdate<Template>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateDelete : RestfulDelete<Template>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateQuery : RestfulQuery<Template>
{ }
[RequiresAnyRole(SystemRoles.Everyone)]
public class TemplateQueryByCustomer : RestfulExecution<Template>
{
public List<Guid> CustomerKvids { get; set; }
public override object OnExecution(IRequest req, IResponse res)
{
var rtns = new RestfulQueryResponse<Template>();
rtns.Results = new List<Template>();
var conn = KiviiContext.GetOpenedDbConnection<Template>();
var queryRelatedTemplateKvid = conn.From<EntityRelation<Template>>();
queryRelatedTemplateKvid.Where(o => o.RelationType == "Kivii.Customers.Entities.Customer" && Sql.In(o.RelationKvid, CustomerKvids));
queryRelatedTemplateKvid.SelectDistinct(o => o.EntityKvid);
var queryTemplate = conn.From<Template>();
queryTemplate.Where(o => o.EffectiveTime <= DateTime.Now && (o.ExpiredTime >= DateTime.Now||o.ExpiredTime == null));
queryTemplate.Where(o => o.Type == TemplateType.Common || Sql.In(o.Kvid, queryRelatedTemplateKvid));
queryTemplate.OrderBy(o => o.SortId);
rtns.Results = conn.Select(queryTemplate);
rtns.Total = rtns.Results.Count;
return rtns;
}
}
}
Src/Transforms/RestfulTemplateDetail.cs 0 → 100644
using Kivii.Lims.Entities;
using Kivii.Linq;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateDetailCreate : RestfulCreate<TemplateDetail>
{
public override bool OnPreRestfulCreate(IRequest req, IResponse res, IDbConnection dbConnection, IRestfulCreateResponse<TemplateDetail> rtns)
{
#region 项目类型判断
if (Item.ParentKvid != Guid.Empty)
{
var parentNode = dbConnection.SingleById<TemplateDetail>(Item.ParentKvid);
if (parentNode != null)
{
(parentNode.Type == TemplateDetailType.Unsupported).ThrowIfTrue("未知项下不可建立子项!");
if (parentNode.Type == TemplateDetailType.Test)
{
(Item.Type != TemplateDetailType.Test).ThrowIfTrue($"此项下不可建立当前类型{Item.Type}!");
parentNode.Type = TemplateDetailType.TestFolder;
parentNode.AddOnlyProperties(o => o.Type);
dbConnection.UpdateOnly(parentNode);
}
}
else Item.ParentKvid = Guid.Empty;
}
#endregion
Item.AddOnlyProperties(o => o.Status);
return base.OnPreRestfulCreate(req, res, dbConnection, rtns);
}
}
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateDetailRead : RestfulRead<TemplateDetail>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateDetailUpdate : RestfulUpdate<TemplateDetail>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateDetailDelete : RestfulDelete<TemplateDetail>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateDetailQuery : RestfulQuery<TemplateDetail>
{ }
}
Src/Transforms/RestfulTemplateFile.cs 0 → 100644
using Kivii.Lims.Entities;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateFileCreate : RestfulCreate<TemplateFile>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateFileRead : RestfulRead<TemplateFile>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateFileUpdate : RestfulUpdate<TemplateFile>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateFileDelete : RestfulDelete<TemplateFile>
{ }
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
public class TemplateFileQuery : RestfulQuery<TemplateFile>
{ }
}
Src/Transforms/RestfulTest.cs 0 → 100644
using Kivii;
using Kivii.Lims.Entities;
using Kivii.Lac.Lims.Extensions;
using Kivii.Linq;
using Kivii.Linq.Legacy;
using Kivii.Web;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
namespace Kivii.Lac.Lims.Transforms
{
#region CQ
[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
[Api(Description = "查询")]
public class TestQuery : RestfulQuery<Test>
{ }
/// <summary>
/// 创建Test时更新对应Report中的实测值字段
/// </summary>
//[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
//[Api(Description = "创建")]
//public class TestCreate : RestfulCreate<Test>
//{
// public Guid ReportItemKvid { get; set; }
// public override bool OnPreRestfulCreate(IRequest req, IResponse res, IDbConnection dbConnection, IRestfulCreateResponse<Test> rtns)
// {
// var reportItem = dbConnection.SingleById<ReportItem>(ReportItemKvid);
// reportItem.ThrowIfNull("未找到检测项！");
// Item.Kvid = Guid.NewGuid();
// Item.AddOnlyProperties(o => o.Kvid);
// Item.RootKvid = Item.Kvid;
// if (reportItem.TestKvid != Guid.Empty)
// {
// var originalTest = dbConnection.SingleById<Test>(reportItem.TestKvid);
// if (originalTest == null) throw new Exception("数据异常，未找到源检验数据！");
// Item.RootKvid = originalTest.RootKvid;
// }
// Item.AddOnlyProperties(o => o.RootKvid);
// Item.SampleKvid = reportItem.SampleKvid;
// Item.AddOnlyProperties(o => o.SampleKvid);
// Item.SampleRootKvid = reportItem.SampleRootKvid;
// Item.AddOnlyProperties(o => o.SampleRootKvid);
// return base.OnPreRestfulCreate(req, res, dbConnection, rtns);
// }
// public override bool OnPostRestfulCreate(IRequest req, IResponse res, IDbConnection dbConnection, IRestfulCreateResponse<Test> rtns)
// {
// var reportItem = dbConnection.SingleById<ReportItem>(ReportItemKvid);
// var currentTest = rtns.Results.FirstOrDefault();
// reportItem.TestKvid = currentTest.Kvid;
// reportItem.TestRootKvid = currentTest.RootKvid;
// reportItem.TestCreateTime = currentTest.CreateTime;
// reportItem.TestCreatorKvid = currentTest.CreatorKvid;
// reportItem.TestCreatorName = currentTest.CreatorName;
// reportItem.TestValue = currentTest.Value;
// reportItem.StatusType = ReportItemStatusType.BeforeReview;
// reportItem.AddOnlyProperties(o => new { o.TestKvid, o.TestRootKvid, o.TestCreateTime, o.TestCreatorKvid, o.TestCreatorName, o.TestValue, o.Status });
// dbConnection.UpdateOnly(reportItem);
// return base.OnPostRestfulCreate(req, res, dbConnection, rtns);
// }
//}
#endregion
#region <待重写，99>根据某一条Test生成复测记录
//[RequiresAnyRole(SystemRoles.Administrator, SystemRoles.Manager, SystemRoles.Configuration)]
//[Api(Description = "生成复测")]
//public class TestRepeat : RestfulExecution<Test>
//{
// private IDbTransaction _trans;
// public List<Guid> TestKvids { get; set; }
// public Guid ReportKvid { get; set; }
// public override object OnExecution(IRequest req, IResponse res)
// {
// var conn = KiviiContext.GetOpenedDbConnection<Test>();
// var queryTest = conn.From<Test>();
// queryTest.Where(o => Sql.In(o.Kvid, TestKvids));
// var reTests = conn.Select(queryTest);
// if (reTests.Exists(o => o.Type != TestType.Test)) throw new Exception("待复测项存在类型为非检验项类型，无法复测！");
// if (reTests.Exists(o => o.ValueTested == null || o.ValueTested == string.Empty)) throw new Exception("存在无实测值的待复测项，无法复测！");
// _trans = conn.OpenTransaction();
// var response = new RestfulCreateResponse<Test>();
// response.Results = new List<Test>();
// foreach (var reTest in reTests)
// {
// //生成复测项目
// var newTest = new Test();
// newTest.PopulateWith(reTest);
// newTest.Kvid = Guid.NewGuid();
// newTest.ValueTested = string.Empty;
// newTest.Type = TestType.ReTest;
// conn.Insert(newTest);
// response.Results.Add(newTest);
// //在ReportJudgement中创建对应关系
// var reportJudgement = new ReportJudgement();
// reportJudgement.ReportKvid = ReportKvid;
// reportJudgement.TestKvid = newTest.Kvid;
// reportJudgement.ValueUnit = newTest.ValueUnit;
// reportJudgement.ValueQualified = newTest.ValueQualified;
// conn.Insert(reportJudgement);
// }
// _trans?.Commit();
// return response;
// }
//}
#endregion
}
Src/packages.config 0 → 100644
<?xml version="1.0" encoding="utf-8"?>
<packages>
<package id="Kivii.Common" version="5.6.2024.11000" targetFramework="net45" />
<package id="Kivii.Core" version="5.6.2024.11000" targetFramework="net45" />
<package id="Kivii.Linq" version="5.6.2024.11000" targetFramework="net45" />
<package id="Kivii.Office.OpenXml" version="5.6.2025.3220" targetFramework="net45" />
</packages>
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment