364 lines
14 KiB
C#
364 lines
14 KiB
C#
///
|
|
/// Copyright (c) 2015-2020 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
|
|
namespace Results.Entities
|
|
{
|
|
public class Batch
|
|
{
|
|
public virtual int Id { get; protected set; }
|
|
public virtual int BatchNr { get; set; }
|
|
public virtual string ProgramVersion { get; set; }
|
|
public virtual int TestBenchId { get; set; }
|
|
public virtual string TestBenchName { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual string Address1 { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual string Address2 { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual string Address3 { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual string Address4 { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual string Address5 { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual string UserName { get; set; }
|
|
public virtual int UserNumber { get; set; }
|
|
public virtual string ProcedureName { get; set; }
|
|
public virtual bool IsRemoteProcedure { get; set; } /// Stara Tura, not mapped to DB
|
|
public virtual string ProcedureDescription { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual int ProcedureRevision { get; set; }
|
|
public virtual string WatermetersStr { get; set; } /// CEVAK, not mapped to DB
|
|
public virtual string ProtocolTitle { get; set; }
|
|
public virtual string Remark { get; set; }
|
|
public virtual float DensityCorr { get; set; } /// Density correction in [kg/m3]
|
|
public virtual float Custom2 { get; set; }
|
|
public virtual float Custom3 { get; set; }
|
|
public virtual int Counter6 { get; set; }
|
|
public virtual int Counter7 { get; set; }
|
|
public virtual int Counter8 { get; set; }
|
|
public virtual int Counter9 { get; set; }
|
|
public virtual int Counter10 { get; set; }
|
|
public virtual DateTime StartTime { get; set; }
|
|
public virtual DateTime EndTime { get; set; }
|
|
public virtual bool Dirty { get; set; }
|
|
public virtual bool RsltsSent { get; set; }
|
|
public virtual bool RsltsPrinted { get; set; }
|
|
public virtual IList<TestData> Tests { get; set; }
|
|
public virtual IList<WaterMeter> WaterMeters { get; set; }
|
|
public virtual IList<TestRslt> TestRslts { get; set; }
|
|
public virtual bool Compound { get; set; } /// Not mapped to DB now
|
|
public virtual bool HeatMeter { get; set; } /// Not mapped to DB now ///
|
|
|
|
public Batch()
|
|
{
|
|
Tests = new List<TestData>();
|
|
WaterMeters = new List<WaterMeter>();
|
|
TestRslts = new List<TestRslt>();
|
|
|
|
ProgramVersion = string.Empty;
|
|
TestBenchName = string.Empty;
|
|
Address1 = string.Empty;
|
|
Address2 = string.Empty;
|
|
Address3 = string.Empty;
|
|
Address4 = string.Empty;
|
|
Address5 = string.Empty;
|
|
UserName = string.Empty;
|
|
ProcedureName = string.Empty;
|
|
IsRemoteProcedure = false;
|
|
ProcedureDescription = string.Empty;
|
|
WatermetersStr = string.Empty;
|
|
ProtocolTitle = string.Empty;
|
|
ProtocolTitle = string.Empty;
|
|
Remark = string.Empty;
|
|
}
|
|
|
|
public virtual int PassedMetersCount()
|
|
{
|
|
int count = 0;
|
|
foreach (var mtr in WaterMeters) if (mtr.PassedFromTests()) count++;
|
|
return count;
|
|
}
|
|
|
|
public virtual int FailedMetersCount()
|
|
{
|
|
return WaterMeters.Count - PassedMetersCount();
|
|
}
|
|
|
|
public virtual double AmbTempMean()
|
|
{
|
|
double timeSum = 0;
|
|
double sum = 0;
|
|
|
|
foreach (var tr in TestRslts)
|
|
{
|
|
if (tr.TestDone)
|
|
{
|
|
double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
|
|
timeSum += duration;
|
|
sum += (tr.AmbTempMean * duration);
|
|
}
|
|
}
|
|
|
|
return (timeSum == 0) ? 0 : (sum / timeSum);
|
|
}
|
|
|
|
public virtual double AmbPressMean()
|
|
{
|
|
double timeSum = 0;
|
|
double sum = 0;
|
|
|
|
foreach (var tr in TestRslts)
|
|
{
|
|
if (tr.TestDone)
|
|
{
|
|
double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
|
|
timeSum += duration;
|
|
sum += (tr.AmbPressMean * duration);
|
|
}
|
|
}
|
|
|
|
return (timeSum == 0) ? 0 : (sum / timeSum);
|
|
}
|
|
|
|
public virtual double AmbHumiMean()
|
|
{
|
|
double timeSum = 0;
|
|
double sum = 0;
|
|
|
|
foreach (var tr in TestRslts)
|
|
{
|
|
if (tr.TestDone)
|
|
{
|
|
double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
|
|
timeSum += duration;
|
|
sum += (tr.AmbHumiMean * duration);
|
|
}
|
|
}
|
|
|
|
return (timeSum == 0) ? 0 : (sum / timeSum);
|
|
}
|
|
|
|
public virtual double AmbTempStart()
|
|
{
|
|
for (int i = 0; i < TestRslts.Count; i++)
|
|
{
|
|
if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
|
|
return TestRslts[i].AmbTempStart;
|
|
}
|
|
return 0;
|
|
}
|
|
public virtual double AmbPressStart()
|
|
{
|
|
for (int i = 0; i < TestRslts.Count; i++)
|
|
{
|
|
if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
|
|
return TestRslts[i].AmbPressStart;
|
|
}
|
|
return 0;
|
|
}
|
|
public virtual double AmbHumiStart()
|
|
{
|
|
for (int i = 0; i < TestRslts.Count; i++)
|
|
{
|
|
if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
|
|
return TestRslts[i].AmbHumiStart;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public virtual double AmbTempEnd()
|
|
{
|
|
for (int i = TestRslts.Count - 1; i >= 0; i++)
|
|
{
|
|
if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
|
|
return TestRslts[i].AmbTempEnd;
|
|
}
|
|
return 0;
|
|
}
|
|
public virtual double AmbPressEnd()
|
|
{
|
|
for (int i = TestRslts.Count - 1; i >= 0; i++)
|
|
{
|
|
if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
|
|
return TestRslts[i].AmbPressEnd;
|
|
}
|
|
return 0;
|
|
}
|
|
public virtual double AmbHumiEnd()
|
|
{
|
|
for (int i = TestRslts.Count - 1; i >= 0; i++)
|
|
{
|
|
if (TestRslts[i].Publish() == Config.Entities.Publish.Always)
|
|
return TestRslts[i].AmbHumiEnd;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
public virtual double Buoyancy()
|
|
{
|
|
double timeSum = 0;
|
|
double sum = 0;
|
|
|
|
foreach (var tr in TestRslts)
|
|
{
|
|
if (tr.TestData.Evaluate && tr.TestDone)
|
|
{
|
|
double duration = (tr.EndTime - tr.StartTime).TotalSeconds;
|
|
timeSum += duration;
|
|
sum += (tr.Buoyancy * duration);
|
|
}
|
|
}
|
|
|
|
return (timeSum == 0) ? 0 : (sum / timeSum);
|
|
}
|
|
|
|
public virtual TestRslt GetTestRslt(string name, int part)
|
|
{
|
|
foreach (var tr in TestRslts)
|
|
{
|
|
if (part == tr.Part && name.Equals(tr.Name())) return tr;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Format("Batch #{0}, Start:{1}, End:{2}, Procedure:{3}", BatchNr, StartTime, EndTime, ProcedureName);
|
|
}
|
|
|
|
public virtual string ToString(int i)
|
|
{
|
|
return string.Format("Batch: BatchNr={0} ProgramVersion={1} TestBenchId={2} UserName={3} UserNumber={4} ProcedureName={5}{6} ProcRev={7} ProtocolTitle={8} Remark={9} DensityCorr={10} Custom2={11} Custom3={12} StartTime={13} EndTime={14} Dirty={15} RsltsSent={16} RsltsPrinted={17}",
|
|
BatchNr, ProgramVersion, TestBenchId, UserName, UserNumber,
|
|
ProcedureName, (IsRemoteProcedure ? "(R)" : ""), ProcedureRevision,
|
|
ProtocolTitle, Remark, DensityCorr, Custom2, Custom3,
|
|
StartTime, EndTime, Dirty, RsltsSent, RsltsPrinted);
|
|
}
|
|
|
|
public virtual void WriteBinary(BinaryWriter writer)
|
|
{
|
|
writer.Write(BatchNr);
|
|
writer.Write((ProgramVersion != null) ? ProgramVersion : string.Empty);
|
|
writer.Write((ProcedureName != null) ? ProcedureName : string.Empty);
|
|
writer.Write(IsRemoteProcedure);
|
|
writer.Write(Id);
|
|
writer.Write(TestBenchId);
|
|
writer.Write((TestBenchName != null) ? TestBenchName : string.Empty);
|
|
writer.Write((Address1 != null) ? Address1 : string.Empty);
|
|
writer.Write((Address2 != null) ? Address2 : string.Empty);
|
|
writer.Write((Address3 != null) ? Address3 : string.Empty);
|
|
writer.Write((Address4 != null) ? Address4 : string.Empty);
|
|
writer.Write((Address5 != null) ? Address5 : string.Empty);
|
|
writer.Write((UserName != null) ? UserName : string.Empty);
|
|
writer.Write(UserNumber);
|
|
writer.Write((ProcedureDescription != null) ? ProcedureDescription : string.Empty);
|
|
writer.Write(ProcedureRevision);
|
|
writer.Write((WatermetersStr != null) ? WatermetersStr : string.Empty);
|
|
writer.Write((ProtocolTitle != null) ? ProtocolTitle : string.Empty);
|
|
writer.Write((Remark != null) ? Remark : string.Empty);
|
|
writer.Write(DensityCorr);
|
|
writer.Write(Custom2);
|
|
writer.Write(Custom3);
|
|
writer.Write(Counter6);
|
|
writer.Write(Counter7);
|
|
writer.Write(Counter8);
|
|
writer.Write(Counter9);
|
|
writer.Write(Counter10);
|
|
writer.Write(StartTime.ToString());
|
|
writer.Write(EndTime.ToString());
|
|
writer.Write(Dirty);
|
|
writer.Write(RsltsSent);
|
|
writer.Write(RsltsPrinted);
|
|
writer.Write(Compound);
|
|
writer.Write(HeatMeter);
|
|
|
|
IList<TestData> savedTestDatas = new List<TestData>(); /// Initially empty
|
|
writer.Write(TestRslts.Count);
|
|
for (int i = 0; i < TestRslts.Count; i++)
|
|
{
|
|
TestRslts[i].WriteBinary(writer, savedTestDatas);
|
|
}
|
|
|
|
IList<WaterMeterData> savedWMDatas = new List<WaterMeterData>(); /// Initially empty
|
|
writer.Write(WaterMeters.Count);
|
|
for (int i = 0; i < WaterMeters.Count; i++)
|
|
{
|
|
WaterMeters[i].WriteBinary(writer, savedWMDatas);
|
|
}
|
|
}
|
|
|
|
public static void ReadStart(BinaryReader reader, out int batchNr, out string programVersion, out string procedureName, out bool isRemoteProcedure)
|
|
{
|
|
batchNr = reader.ReadInt32();
|
|
programVersion = reader.ReadString();
|
|
procedureName = reader.ReadString();
|
|
isRemoteProcedure = reader.ReadBoolean();
|
|
}
|
|
|
|
public virtual void ReadBinary(BinaryReader reader)
|
|
{
|
|
/// ReadStart() is used to avoid code repetition
|
|
int batchNr;
|
|
string programVersion;
|
|
string procedureName;
|
|
bool isRemoteProcedure;
|
|
ReadStart(reader, out batchNr, out programVersion, out procedureName, out isRemoteProcedure);
|
|
|
|
BatchNr = batchNr;
|
|
ProgramVersion = programVersion;
|
|
ProcedureName = procedureName;
|
|
IsRemoteProcedure = isRemoteProcedure;
|
|
Id = reader.ReadInt32();
|
|
TestBenchId = reader.ReadInt32();
|
|
TestBenchName = reader.ReadString();
|
|
Address1 = reader.ReadString();
|
|
Address2 = reader.ReadString();
|
|
Address3 = reader.ReadString();
|
|
Address4 = reader.ReadString();
|
|
Address5 = reader.ReadString();
|
|
UserName = reader.ReadString();
|
|
UserNumber = reader.ReadInt32();
|
|
ProcedureDescription = reader.ReadString();
|
|
ProcedureRevision = reader.ReadInt32();
|
|
WatermetersStr = reader.ReadString();
|
|
ProtocolTitle = reader.ReadString();
|
|
Remark = reader.ReadString();
|
|
DensityCorr = reader.ReadInt32();
|
|
Custom2 = reader.ReadInt32();
|
|
Custom3 = reader.ReadInt32();
|
|
Counter6 = reader.ReadInt32();
|
|
Counter7 = reader.ReadInt32();
|
|
Counter8 = reader.ReadInt32();
|
|
Counter9 = reader.ReadInt32();
|
|
Counter10 = reader.ReadInt32();
|
|
StartTime = DateTime.Parse(reader.ReadString());
|
|
EndTime = DateTime.Parse(reader.ReadString());
|
|
Dirty = reader.ReadBoolean();
|
|
RsltsSent = reader.ReadBoolean();
|
|
RsltsPrinted = reader.ReadBoolean();
|
|
Compound = reader.ReadBoolean();
|
|
HeatMeter = reader.ReadBoolean();
|
|
|
|
Tests = new List<TestData>(); /// Initially empty
|
|
|
|
int testRsltsCount = reader.ReadInt32();
|
|
TestRslts = new List<TestRslt>();
|
|
for (int i = 0; i < testRsltsCount; i++)
|
|
{
|
|
TestRslts.Add(new TestRslt());
|
|
TestRslts[i].ReadBinary(reader, Tests);
|
|
TestRslts[i].Batch = this;
|
|
}
|
|
|
|
IList<WaterMeterData> wmDatasRetirevedSoFar = new List<WaterMeterData>(); /// Initially empty
|
|
|
|
int waterMetersCount = reader.ReadInt32();
|
|
WaterMeters = new List<WaterMeter>();
|
|
for (int i = 0; i < waterMetersCount; i++)
|
|
{
|
|
WaterMeters.Add(new WaterMeter());
|
|
WaterMeters[i].ReadBinary(reader, wmDatasRetirevedSoFar, TestRslts);
|
|
WaterMeters[i].Batch = this;
|
|
}
|
|
}
|
|
}
|
|
}
|