public ItemRequestFormModel GetItemRequestFormById(int id)
{
ItemRequestFormModel result = new ItemRequestFormModel();
result.RequestFormItems = new List <ItemList>();
result.RequestFormQuotations = new List <QuotationList>();
QuotationList singleQuote = new QuotationList();
CodeHeader ticketStatus = new CodeHeader();
ItemList singleItem = new ItemList();
var query = _itemRequestFormDataAccess.GetItemRequestFormById(id);
result.Id = query.Id;
result.Title = query.Title;
result.DateCreated = query.CreateDttm;
result.FollowupDttm = query.FollowupStartDttm.Value;
result.StatusCd = query.StatusCd;
result.Notes = query.Notes;
for (int i = 0; i < query.Quotations.Count; i++)
{
singleQuote.Id = query.Quotations.ToList()[i].Id;
singleQuote.Status = ticketStatus.CodeDetails.Where(x => x.Id == query.Quotations.ToList()[i].StatusCd)
.Select(x => x.CodeValue).FirstOrDefault();
singleQuote.Notes = query.Quotations.ToList()[i].Notes;
singleQuote.Title = query.Quotations.ToList()[i].Title;
singleQuote.SupplierName = query.Quotations.ToList()[i].Supplier.SupplierName;
result.RequestFormQuotations.Add(singleQuote);
singleQuote = new QuotationList();
}
for (int i = 0; i < query.ItemRequestFormMappings.Count; i++)
{
singleItem.Id = query.ItemRequestFormMappings.ToList()[i].ItemID;
singleItem.ItemName = query.ItemRequestFormMappings.ToList()[i].Item.ItemName;
singleItem.StocksLeft = query.ItemRequestFormMappings.ToList()[i].Item.Quantity.Value;
singleItem.BrandName = query.ItemRequestFormMappings.ToList()[i].Item.Brand.BrandName;
singleItem.Notes = query.ItemRequestFormMappings.ToList()[i].Item.Notes;
result.RequestFormItems.Add(singleItem);
singleItem = new ItemList();
}
return(result);
}
/// <summary>
/// Write a parsed G/M/T code in binary format to a memory span
/// </summary>
/// <param name="to">Destination</param>
/// <param name="code">Code to write</param>
/// <returns>Number of bytes written</returns>
/// <exception cref="ArgumentException">Unsupported data type</exception>
public static int WriteCode(Span <byte> to, Code code)
{
int bytesWritten = 0;
// Write code header
CodeHeader header = new CodeHeader
{
Channel = code.Channel,
FilePosition = (uint)(code.FilePosition ?? 0xFFFFFFFF),
Letter = (byte)code.Type,
MajorCode = (code.Type == CodeType.Comment) ? 0 : (code.MajorNumber ?? -1),
MinorCode = code.MinorNumber ?? -1,
NumParameters = (byte)((code.Type == CodeType.Comment) ? 1 : code.Parameters.Count)
};
if (code.Type == CodeType.Comment || code.MajorNumber != null)
{
header.Flags |= CodeFlags.HasMajorCommandNumber;
}
if (code.MinorNumber != null)
{
header.Flags |= CodeFlags.HasMinorCommandNumber;
}
if (code.FilePosition != null)
{
header.Flags |= CodeFlags.HasFilePosition;
}
if (code.Flags.HasFlag(DuetAPI.Commands.CodeFlags.EnforceAbsolutePosition))
{
header.Flags |= CodeFlags.EnforceAbsolutePosition;
}
MemoryMarshal.Write(to, ref header);
bytesWritten += Marshal.SizeOf <CodeHeader>();
// Write line number
if (DataTransfer.ProtocolVersion >= 2)
{
int lineNumber = (int)(code.LineNumber ?? 0);
MemoryMarshal.Write(to[bytesWritten..], ref lineNumber);
/// <summary>
/// Write a parsed G/M/T code in binary format to a memory span
/// </summary>
/// <param name="to">Destination</param>
/// <param name="code">Code to write</param>
/// <returns>Number of bytes written</returns>
/// <exception cref="ArgumentException">Unsupported data type</exception>
public static int WriteCode(Span <byte> to, Code code)
{
int bytesWritten = 0;
// Write code header
CodeHeader header = new CodeHeader
{
Channel = code.Channel,
FilePosition = (uint)(code.FilePosition ?? 0xFFFFFFFF),
Letter = (byte)code.Type,
MajorCode = code.MajorNumber ?? -1,
MinorCode = code.MinorNumber ?? -1,
NumParameters = (byte)code.Parameters.Count
};
if (code.MajorNumber.HasValue)
{
header.Flags |= SpiCodeFlags.HasMajorCommandNumber;
}
if (code.MinorNumber.HasValue)
{
header.Flags |= SpiCodeFlags.HasMinorCommandNumber;
}
if (code.FilePosition.HasValue)
{
header.Flags |= SpiCodeFlags.HasFilePosition;
}
if (code.Flags.HasFlag(DuetAPI.Commands.CodeFlags.EnforceAbsolutePosition))
{
header.Flags |= SpiCodeFlags.EnforceAbsolutePosition;
}
MemoryMarshal.Write(to, ref header);
bytesWritten += Marshal.SizeOf(header);
// Write parameters
List <object> extraParameters = new List <object>();
foreach (var parameter in code.Parameters)
{
CodeParameter binaryParam = new CodeParameter
{
Letter = (byte)parameter.Letter
};
if (parameter.Type == typeof(int))
{
binaryParam.Type = DataType.Int;
binaryParam.IntValue = parameter;
}
else if (parameter.Type == typeof(uint))
{
binaryParam.Type = parameter.IsDriverId ? DataType.DriverId : DataType.UInt;
binaryParam.UIntValue = parameter;
}
else if (parameter.Type == typeof(float))
{
binaryParam.Type = DataType.Float;
binaryParam.FloatValue = parameter;
}
else if (parameter.Type == typeof(int[]))
{
binaryParam.Type = DataType.IntArray;
int[] array = parameter;
binaryParam.IntValue = array.Length;
extraParameters.Add(array);
}
else if (parameter.Type == typeof(uint[]))
{
binaryParam.Type = parameter.IsDriverId ? DataType.DriverIdArray : DataType.UIntArray;
uint[] array = parameter;
binaryParam.IntValue = array.Length;
extraParameters.Add(array);
}
else if (parameter.Type == typeof(float[]))
{
binaryParam.Type = DataType.FloatArray;
float[] array = parameter;
binaryParam.IntValue = array.Length;
extraParameters.Add(array);
}
else if (parameter.Type == typeof(string))
{
string value = parameter;
binaryParam.Type = parameter.IsExpression ? DataType.Expression : DataType.String;
binaryParam.IntValue = value.Length;
extraParameters.Add(value);
}
else
{
throw new ArgumentException("Unsupported type", parameter.Type.Name);
}
MemoryMarshal.Write(to.Slice(bytesWritten), ref binaryParam);
bytesWritten += Marshal.SizeOf(binaryParam);
}
// Write extra parameters
foreach (object parameter in extraParameters)
{
if (parameter is int[] intArray)
{
foreach (int val in intArray)
{
int value = val;
MemoryMarshal.Write(to.Slice(bytesWritten), ref value);
bytesWritten += Marshal.SizeOf(value);
}
}
else if (parameter is uint[] uintArray)
{
foreach (uint val in uintArray)
{
uint value = val;
MemoryMarshal.Write(to.Slice(bytesWritten), ref value);
bytesWritten += Marshal.SizeOf(value);
}
}
else if (parameter is float[] floatArray)
{
foreach (float val in floatArray)
{
float value = val;
MemoryMarshal.Write(to.Slice(bytesWritten), ref value);
bytesWritten += Marshal.SizeOf(value);
}
}
else if (parameter is string value)
{
Span <byte> asUnicode = Encoding.UTF8.GetBytes(value);
asUnicode.CopyTo(to.Slice(bytesWritten));
bytesWritten += asUnicode.Length;
bytesWritten = AddPadding(to, bytesWritten);
}
else
{
throw new ArgumentException("Unsupported type", parameter.GetType().Name);
}
}
return(bytesWritten);
}
/// <summary>
/// Write a parsed G/M/T code in binary format to a memory span
/// </summary>
/// <param name="to">Destination</param>
/// <param name="code">Code to write</param>
/// <returns>Number of bytes written</returns>
/// <exception cref="ArgumentException">Unsupported data type</exception>
public static int WriteCode(Span <byte> to, Code code)
{
int bytesWritten = 0;
// Write code header
CodeHeader header = new CodeHeader
{
Channel = code.Channel,
FilePosition = (uint)(code.FilePosition ?? 0xFFFFFFFF),
Letter = (byte)code.Type,
MajorCode = (code.Type == CodeType.Comment) ? 0 : (code.MajorNumber ?? -1),
MinorCode = code.MinorNumber ?? -1,
NumParameters = (byte)((code.Type == CodeType.Comment) ? 1 : code.Parameters.Count)
};
if (code.Type == CodeType.Comment || code.MajorNumber != null)
{
header.Flags |= CodeFlags.HasMajorCommandNumber;
}
if (code.MinorNumber != null)
{
header.Flags |= CodeFlags.HasMinorCommandNumber;
}
if (code.FilePosition != null)
{
header.Flags |= CodeFlags.HasFilePosition;
}
if (code.Flags.HasFlag(DuetAPI.Commands.CodeFlags.EnforceAbsolutePosition))
{
header.Flags |= CodeFlags.EnforceAbsolutePosition;
}
MemoryMarshal.Write(to, ref header);
bytesWritten += Marshal.SizeOf(header);
// Write line number
if (DataTransfer.ProtocolVersion >= 2)
{
int lineNumber = (int)(code.LineNumber ?? 0);
MemoryMarshal.Write(to.Slice(bytesWritten), ref lineNumber);
bytesWritten += Marshal.SizeOf <int>();
}
// Write parameters
if (code.Type == CodeType.Comment)
{
// Write comment as an unprecedented parameter
string comment = (code.Comment ?? string.Empty).Trim();
int commentLength = Math.Min(comment.Length, Consts.MaxCommentLength);
CodeParameter binaryParam = new CodeParameter
{
Letter = (byte)'@',
IntValue = commentLength,
Type = DataType.String
};
MemoryMarshal.Write(to.Slice(bytesWritten), ref binaryParam);
bytesWritten += Marshal.SizeOf(binaryParam);
Span <byte> asUnicode = Encoding.UTF8.GetBytes(comment.Substring(0, commentLength));
asUnicode.CopyTo(to.Slice(bytesWritten));
bytesWritten += asUnicode.Length;
bytesWritten = AddPadding(to, bytesWritten);
}
else
{
// Write code parameters
List <object> extraParameters = new List <object>();
foreach (var parameter in code.Parameters)
{
CodeParameter binaryParam = new CodeParameter
{
Letter = (byte)parameter.Letter
};
if (parameter.Type == typeof(int))
{
binaryParam.Type = DataType.Int;
binaryParam.IntValue = parameter;
}
else if (parameter.Type == typeof(uint))
{
binaryParam.Type = DataType.UInt;
binaryParam.UIntValue = parameter;
}
else if (parameter.Type == typeof(DriverId))
{
binaryParam.Type = DataType.DriverId;
binaryParam.UIntValue = parameter;
}
else if (parameter.Type == typeof(float))
{
binaryParam.Type = DataType.Float;
binaryParam.FloatValue = parameter;
}
else if (parameter.Type == typeof(int[]))
{
binaryParam.Type = DataType.IntArray;
int[] array = parameter;
binaryParam.IntValue = array.Length;
extraParameters.Add(array);
}
else if (parameter.Type == typeof(uint[]))
{
binaryParam.Type = DataType.UIntArray;
uint[] array = parameter;
binaryParam.IntValue = array.Length;
extraParameters.Add(array);
}
else if (parameter.Type == typeof(DriverId[]))
{
binaryParam.Type = DataType.DriverIdArray;
DriverId[] array = parameter;
binaryParam.IntValue = array.Length;
extraParameters.Add(array);
}
else if (parameter.Type == typeof(float[]))
{
binaryParam.Type = DataType.FloatArray;
float[] array = parameter;
binaryParam.IntValue = array.Length;
extraParameters.Add(array);
}
else if (parameter.Type == typeof(string))
{
string value = parameter;
binaryParam.Type = parameter.IsExpression ? DataType.Expression : DataType.String;
binaryParam.IntValue = value.Length;
extraParameters.Add(value);
}
// Boolean values are not supported for codes. Use integers instead
else
{
throw new ArgumentException("Unsupported type", parameter.Type.Name);
}
MemoryMarshal.Write(to.Slice(bytesWritten), ref binaryParam);
bytesWritten += Marshal.SizeOf(binaryParam);
}
// Write extra parameters
foreach (object parameter in extraParameters)
{
if (parameter is int[] intArray)
{
foreach (int val in intArray)
{
int value = val;
MemoryMarshal.Write(to.Slice(bytesWritten), ref value);
bytesWritten += Marshal.SizeOf(value);
}
}
else if (parameter is uint[] uintArray)
{
foreach (uint val in uintArray)
{
uint value = val;
MemoryMarshal.Write(to.Slice(bytesWritten), ref value);
bytesWritten += Marshal.SizeOf(value);
}
}
else if (parameter is DriverId[] driverIdArray)
{
foreach (DriverId val in driverIdArray)
{
uint value = val;
MemoryMarshal.Write(to.Slice(bytesWritten), ref value);
bytesWritten += Marshal.SizeOf(value);
}
}
else if (parameter is float[] floatArray)
{
foreach (float val in floatArray)
{
float value = val;
MemoryMarshal.Write(to.Slice(bytesWritten), ref value);
bytesWritten += Marshal.SizeOf(value);
}
}
else if (parameter is string value)
{
Span <byte> asUnicode = Encoding.UTF8.GetBytes(value);
asUnicode.CopyTo(to.Slice(bytesWritten));
bytesWritten += asUnicode.Length;
bytesWritten = AddPadding(to, bytesWritten);
}
else
{
throw new ArgumentException("Unsupported type", parameter.GetType().Name);
}
}
}
return(bytesWritten);
}
