316 lines
12 KiB
C#
316 lines
12 KiB
C#
///
|
|
/// Copyright (c) 2016-2021 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using NHibernate;
|
|
using NHibernate.Criterion;
|
|
using SharedDatabase.Entities;
|
|
using ProductionTracing.Resources;
|
|
|
|
namespace ProductionTracing
|
|
{
|
|
public enum ItemSpecID
|
|
{
|
|
RefRecordId,
|
|
|
|
POrder,
|
|
Workflow,
|
|
Timestamp,
|
|
Name1,
|
|
Code1,
|
|
Name2,
|
|
Code2,
|
|
Code3,
|
|
Code4,
|
|
|
|
PartName,
|
|
PartCode,
|
|
|
|
Workstep,
|
|
Workplace,
|
|
UserName,
|
|
WstepTstamp,
|
|
Result,
|
|
}
|
|
|
|
public enum ItemCaps
|
|
{
|
|
None = 0,
|
|
RefRecord = 1,
|
|
StepRecord = 2,
|
|
Record = 4,
|
|
}
|
|
|
|
public class ItemSpec
|
|
{
|
|
///
|
|
/// Function delegate to pick a reference record and convert it to a string
|
|
///
|
|
public delegate string PrintDlgt(object x, string format, string precision, int width);
|
|
|
|
///
|
|
/// Public fields
|
|
///
|
|
public readonly ItemSpecID Uid; /// Unique Uid used to distinguish items
|
|
public readonly string Name; /// Name that can be localized to identify the item in a list
|
|
public readonly PrintDlgt PrintFn; /// Function used to convert the result to a text
|
|
|
|
public string Caption; /// User defined text printed in the column header
|
|
public string Format; /// Specifies the text generation
|
|
public string Precision; /// Specifies the text generation
|
|
public int Width; /// Specifies the text generation
|
|
|
|
readonly ItemCaps itemSpecCaps;
|
|
|
|
/// <summary> Public parameterless constructor </summary>
|
|
public ItemSpec()
|
|
{
|
|
}
|
|
|
|
/// <summary> Constructor to specify all items </summary>
|
|
public ItemSpec(ItemSpecID uid, string name, ItemCaps itemSpecCaps, PrintDlgt printFn)
|
|
{
|
|
Uid = uid;
|
|
Name = name;
|
|
PrintFn = printFn;
|
|
this.itemSpecCaps = itemSpecCaps;
|
|
///
|
|
Caption = name;
|
|
Format = "{0}";
|
|
Precision = string.Empty;
|
|
Width = 0;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Format("uid={0}, name={1}, caption={2}", Uid, Name, Caption);
|
|
}
|
|
|
|
/// <summary> Copy constructor </summary>
|
|
public ItemSpec Clone()
|
|
{
|
|
ItemSpec newItem = new ItemSpec(Uid, Name, itemSpecCaps, PrintFn);
|
|
newItem.Caption = Caption;
|
|
newItem.Format = Format;
|
|
newItem.Precision = Precision;
|
|
newItem.Width = Width;
|
|
return newItem;
|
|
}
|
|
|
|
|
|
/// <summary> Safe wrapper which replaces null-s by empty strings </summary>
|
|
public string Print(object x)
|
|
{
|
|
string str = PrintFn(x, Format, Precision, Width);
|
|
return (str == null) ? string.Empty : str;
|
|
}
|
|
|
|
|
|
/// <summary> Similar to Print(), in addition embeds text into "" </summary>
|
|
public string Export(object x)
|
|
{
|
|
string str = PrintFn(x, Format, Precision, Width);
|
|
if (str == null) str = string.Empty;
|
|
|
|
if (Uid == ItemSpecID.POrder || (Uid >= ItemSpecID.Name1 && Uid == ItemSpecID.PartCode))
|
|
{
|
|
return string.Format("=\"{0}\"", str);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
|
|
/// Static list of all available items
|
|
public static readonly IList<ItemSpec> AllItems;
|
|
|
|
///
|
|
/// Static constructor that initializes the list of all items
|
|
///
|
|
static ItemSpec()
|
|
{
|
|
AllItems = new List<ItemSpec>();
|
|
|
|
AllItems.Add(new ItemSpec(ItemSpecID.RefRecordId, Strings.RefRecordId, ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, ((int)x).ToString())));
|
|
|
|
AllItems.Add(new ItemSpec(ItemSpecID.POrder, Strings.Order, ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Workflow, Strings.Workflow, ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Timestamp, Strings.Time_stamp, ItemCaps.RefRecord, (x, f, p, w) => string.IsNullOrEmpty(f) ? ((DateTime)x).ToString() : string.Format(f, (DateTime)x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Name1, "Name1", ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Code1, "Code1", ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Name2, "Name2", ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Code2, "Code2", ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Code3, "Code3", ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
AllItems.Add(new ItemSpec(ItemSpecID.Code4, "Code4", ItemCaps.RefRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
|
|
//AllItems.Add(new ItemSpec(ItemSpecID.PartName, Strings.Part_name, ItemCaps.RefRecord | ItemCaps.Record, (x, f, p, w) => FormatStr(f, ((Part)x).Name)));
|
|
//AllItems.Add(new ItemSpec(ItemSpecID.PartCode, Strings.Part_barcode, ItemCaps.RefRecord | ItemCaps.Record, (x, f, p, w) => FormatStr(f, x)));
|
|
|
|
//AllItems.Add(new ItemSpec(ItemSpecID.Workstep, Strings.Workstep, ItemCaps.RefRecord | ItemCaps.StepRecord, (x, f, p, w) => FormatStr(f, x is Workstep ? (x as Workstep).Name : "<null>")));
|
|
//AllItems.Add(new ItemSpec(ItemSpecID.Workplace, Strings.Workplace, ItemCaps.RefRecord | ItemCaps.StepRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
//AllItems.Add(new ItemSpec(ItemSpecID.UserName, Strings.User_name, ItemCaps.RefRecord | ItemCaps.StepRecord, (x, f, p, w) => FormatStr(f, x)));
|
|
//AllItems.Add(new ItemSpec(ItemSpecID.WstepTstamp, Strings.Workstep + " " + Strings.Time_stamp,
|
|
// ItemCaps.RefRecord | ItemCaps.StepRecord, (x, f, p, w) => string.IsNullOrEmpty(f) ? ((DateTime)x).ToString() : string.Format(f, (DateTime)x)));
|
|
//AllItems.Add(new ItemSpec(ItemSpecID.Result, Strings.Result, ItemCaps.RefRecord | ItemCaps.StepRecord, (x, f, p, w) => FormatStr(f, ((int)x).ToString())));
|
|
}
|
|
|
|
|
|
public static string FormatStr(string format, object value)
|
|
{
|
|
int len;
|
|
|
|
if (string.IsNullOrEmpty(format))
|
|
{
|
|
return (string)value;
|
|
}
|
|
else if (int.TryParse(format, out len) && len > 0)
|
|
{
|
|
if (((string)value).Length >= len)
|
|
{
|
|
return ((string)value).Substring(0, len);
|
|
}
|
|
else
|
|
{
|
|
return (string)value;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return string.Format(format, value);
|
|
}
|
|
}
|
|
|
|
public PropertyProjection GetProperty(ReferenceRecord refRecord, StepRecord stepRecord, Record record)
|
|
{
|
|
switch (Uid)
|
|
{
|
|
default:
|
|
case ItemSpecID.RefRecordId: return Projections.Property(() => refRecord.Id);
|
|
case ItemSpecID.POrder: return Projections.Property(() => refRecord.POName);
|
|
case ItemSpecID.Workflow: return Projections.Property(() => refRecord.Workflow);
|
|
case ItemSpecID.Timestamp: return Projections.Property(() => refRecord.Timestamp);
|
|
case ItemSpecID.Name1: return Projections.Property(() => refRecord.Name1);
|
|
case ItemSpecID.Code1: return Projections.Property(() => refRecord.Code1);
|
|
case ItemSpecID.Name2: return Projections.Property(() => refRecord.Name2);
|
|
case ItemSpecID.Code2: return Projections.Property(() => refRecord.Code2);
|
|
case ItemSpecID.Code3: return Projections.Property(() => refRecord.Code3);
|
|
case ItemSpecID.Code4: return Projections.Property(() => refRecord.Code4);
|
|
|
|
case ItemSpecID.PartName: return Projections.Property(() => record.Name);
|
|
case ItemSpecID.PartCode: return Projections.Property(() => record.Code);
|
|
|
|
case ItemSpecID.Workstep: return Projections.Property(() => stepRecord.Workstep);
|
|
case ItemSpecID.Workplace: return Projections.Property(() => stepRecord.Workplace);
|
|
case ItemSpecID.UserName: return Projections.Property(() => stepRecord.User);
|
|
case ItemSpecID.Result: return Projections.Property(() => stepRecord.Result);
|
|
}
|
|
}
|
|
|
|
public ItemCaps GetCaps()
|
|
{
|
|
return itemSpecCaps;
|
|
}
|
|
|
|
|
|
public static ItemSpec GetItem(ItemSpecID id)
|
|
{
|
|
foreach (var item in AllItems)
|
|
if (item.Uid == id)
|
|
return item.Clone();
|
|
|
|
return null;
|
|
}
|
|
|
|
public static ItemSpec GetItem(string uidName)
|
|
{
|
|
foreach (var item in AllItems)
|
|
if (item.Uid.ToString() == uidName)
|
|
return item.Clone();
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
public static ProjectionList GetProjections(IList<ItemSpec> items, ReferenceRecord refRecord, StepRecord stepRecord, Record record)
|
|
{
|
|
ProjectionList projections = Projections.ProjectionList();
|
|
foreach (var item in items)
|
|
{
|
|
PropertyProjection projection = item.GetProperty(refRecord, stepRecord, record);
|
|
if (projection != null)
|
|
projections.Add(projection);
|
|
}
|
|
|
|
return projections;
|
|
}
|
|
|
|
public static IList<object[]> Expand(IList<object[]> data, IList<ItemSpec> items)
|
|
{
|
|
if (data.Count == 0) return data;
|
|
|
|
int iSize = data[0].Length;
|
|
int oSize = items.Count;
|
|
for (int i = 0; i < data.Count; i++)
|
|
{
|
|
object[] inArr = data[i];
|
|
|
|
object[] outArr = new object[oSize];
|
|
int srcIx = 0;
|
|
for (int dstIx = 0; dstIx < oSize; dstIx++)
|
|
{
|
|
outArr[dstIx] = inArr[srcIx++];
|
|
}
|
|
|
|
data[i] = outArr;
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
public static string[] ToStrArray(IList<ItemSpec> items)
|
|
{
|
|
int count = (items != null) ? items.Count : 0;
|
|
string[] result = new string[count];
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
result[i] = string.Format("{0}~{1}~{2}~{3}~{4}",
|
|
items[i].Uid,
|
|
items[i].Caption,
|
|
items[i].Format,
|
|
items[i].Precision,
|
|
items[i].Width);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
public static IList<ItemSpec> FromStrArray(string[] strArray)
|
|
{
|
|
IList<ItemSpec> result = new List<ItemSpec>();
|
|
if (strArray != null)
|
|
{
|
|
for (int i = 0; i < strArray.Length; i++)
|
|
{
|
|
string[] field = strArray[i].Split(new char[] { '~' });
|
|
try
|
|
{
|
|
ItemSpec item = GetItem(field[0]);
|
|
item.Caption = field[1];
|
|
item.Format = field[2];
|
|
item.Precision = field[3];
|
|
item.Width = int.Parse(field[4]);
|
|
|
|
result.Add(item);
|
|
}
|
|
catch
|
|
{
|
|
ItemSpec item = GetItem(ItemSpecID.RefRecordId);
|
|
item.Format = string.Format("Parse error: {0}", strArray[i]);
|
|
result.Add(item);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
}
|