From f272d741e2c3ec820b1a39e7797ac46986ab62c9 Mon Sep 17 00:00:00 2001 From: Roy Ben Shabat Date: Mon, 8 Sep 2025 17:08:54 +0300 Subject: New Extra Inks DB, PMR, BL. --- Software/DB/Tango.mdf | Bin 75497472 -> 75497472 bytes Software/DB/Tango_log.ldf | Bin 22675456 -> 22675456 bytes Software/PMR/Messages/ColorLab/LiquidType.proto | 74 + .../Messages/Printing/DispenserLiquidType.proto | 74 + .../Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs | 296 ++++ .../Tango.BL/DTO/LiquidTypeDTOBase.cs | 8 + Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs | 8 + .../Visual_Studio/Tango.BL/Entities/JobRunBase.cs | 1506 +++++++++++++++++++- .../Tango.BL/Entities/LiquidTypeBase.cs | 38 + .../Visual_Studio/Tango.BL/Entities/RmlBase.cs | 38 + .../Tango.BL/Enumerations/LiquidTypes.cs | 222 +++ .../Visual_Studio/Tango.DAL.Remote/DB/JOB_RUNS.cs | 37 + .../Tango.DAL.Remote/DB/LIQUID_TYPES.cs | 1 + Software/Visual_Studio/Tango.DAL.Remote/DB/RML.cs | 1 + .../Tango.DAL.Remote/DB/RemoteADO.edmx | 117 ++ .../Tango.DAL.Remote/DB/RemoteADO.edmx.diagram | 194 +-- .../Visual_Studio/Tango.PMR/ColorLab/LiquidType.cs | 57 +- .../Tango.PMR/Printing/DispenserLiquidType.cs | 55 +- .../Tango.Telemetry.Tester.IOT.CLI/Program.cs | 14 +- 19 files changed, 2581 insertions(+), 159 deletions(-) diff --git a/Software/DB/Tango.mdf b/Software/DB/Tango.mdf index a3960adaa..ab8481ff0 100644 Binary files a/Software/DB/Tango.mdf and b/Software/DB/Tango.mdf differ diff --git a/Software/DB/Tango_log.ldf b/Software/DB/Tango_log.ldf index a1d816439..f2c19da8c 100644 Binary files a/Software/DB/Tango_log.ldf and b/Software/DB/Tango_log.ldf differ diff --git a/Software/PMR/Messages/ColorLab/LiquidType.proto b/Software/PMR/Messages/ColorLab/LiquidType.proto index ba57de125..b2a206659 100644 --- a/Software/PMR/Messages/ColorLab/LiquidType.proto +++ b/Software/PMR/Messages/ColorLab/LiquidType.proto @@ -52,4 +52,78 @@ enum LiquidType Navy = 17; + TWTransparentInk = 100; + + C1TI = 105; + + TWCyan = 110; + + TWLightCyan = 111; + + TWMagenta = 120; + + TWLightMagenta = 121; + + TWYellow = 130; + + TWLightYellow = 131; + + C1Yellow = 135; + + C1LightYellow = 136; + + TWBlack = 140; + + TWViolet = 150; + + TWLightViolet = 151; + + CTBlue = 210; + + CTLightBlue = 211; + + CTRubine = 220; + + CTLightRubine = 221; + + CTOrange = 230; + + CTLightOrange = 231; + + CTNavy = 240; + + HDBlue = 310; + + HDLightBlue = 311; + + HDRubine = 320; + + HDLightRubine = 321; + + HDOrange = 330; + + HDLightOrange = 331; + + HDNavy = 340; + + HDLightNavy = 341; + + AMBlue = 410; + + AMLightBlue = 411; + + AMRed = 420; + + AMLightRed = 421; + + AMOrange = 430; + + AMLightOrange = 431; + + AMYellow = 440; + + AMLightYellow = 441; + + AMBlack = 450; + } diff --git a/Software/PMR/Messages/Printing/DispenserLiquidType.proto b/Software/PMR/Messages/Printing/DispenserLiquidType.proto index 5472f18e0..5b2911732 100644 --- a/Software/PMR/Messages/Printing/DispenserLiquidType.proto +++ b/Software/PMR/Messages/Printing/DispenserLiquidType.proto @@ -52,4 +52,78 @@ enum DispenserLiquidType Navy = 17; + TWTransparentInk = 100; + + C1TI = 105; + + TWCyan = 110; + + TWLightCyan = 111; + + TWMagenta = 120; + + TWLightMagenta = 121; + + TWYellow = 130; + + TWLightYellow = 131; + + C1Yellow = 135; + + C1LightYellow = 136; + + TWBlack = 140; + + TWViolet = 150; + + TWLightViolet = 151; + + CTBlue = 210; + + CTLightBlue = 211; + + CTRubine = 220; + + CTLightRubine = 221; + + CTOrange = 230; + + CTLightOrange = 231; + + CTNavy = 240; + + HDBlue = 310; + + HDLightBlue = 311; + + HDRubine = 320; + + HDLightRubine = 321; + + HDOrange = 330; + + HDLightOrange = 331; + + HDNavy = 340; + + HDLightNavy = 341; + + AMBlue = 410; + + AMLightBlue = 411; + + AMRed = 420; + + AMLightRed = 421; + + AMOrange = 430; + + AMLightOrange = 431; + + AMYellow = 440; + + AMLightYellow = 441; + + AMBlack = 450; + } diff --git a/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs b/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs index 08e8d7337..6543ce97b 100644 --- a/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs +++ b/Software/Visual_Studio/Tango.BL/DTO/JobRunDTOBase.cs @@ -421,5 +421,301 @@ namespace Tango.BL.DTO get; set; } + /// + /// tw transparent ink quantity + /// + public Int64 TwTransparentInkQuantity + { + get; set; + } + + /// + /// c1 ti quantity + /// + public Int64 C1TiQuantity + { + get; set; + } + + /// + /// tw cyan quantity + /// + public Int64 TwCyanQuantity + { + get; set; + } + + /// + /// tw light cyan quantity + /// + public Int64 TwLightCyanQuantity + { + get; set; + } + + /// + /// tw magenta quantity + /// + public Int64 TwMagentaQuantity + { + get; set; + } + + /// + /// tw light magenta quantity + /// + public Int64 TwLightMagentaQuantity + { + get; set; + } + + /// + /// tw yellow quantity + /// + public Int64 TwYellowQuantity + { + get; set; + } + + /// + /// tw light yellow quantity + /// + public Int64 TwLightYellowQuantity + { + get; set; + } + + /// + /// c1 yellow quantity + /// + public Int64 C1YellowQuantity + { + get; set; + } + + /// + /// c1 light yellow quantity + /// + public Int64 C1LightYellowQuantity + { + get; set; + } + + /// + /// tw black quantity + /// + public Int64 TwBlackQuantity + { + get; set; + } + + /// + /// tw violet quantity + /// + public Int64 TwVioletQuantity + { + get; set; + } + + /// + /// tw light violet quantity + /// + public Int64 TwLightVioletQuantity + { + get; set; + } + + /// + /// ct blue quantity + /// + public Int64 CtBlueQuantity + { + get; set; + } + + /// + /// ct light blue quantity + /// + public Int64 CtLightBlueQuantity + { + get; set; + } + + /// + /// ct rubine quantity + /// + public Int64 CtRubineQuantity + { + get; set; + } + + /// + /// ct light rubine quantity + /// + public Int64 CtLightRubineQuantity + { + get; set; + } + + /// + /// ct orange quantity + /// + public Int64 CtOrangeQuantity + { + get; set; + } + + /// + /// ct light orange quantity + /// + public Int64 CtLightOrangeQuantity + { + get; set; + } + + /// + /// ct navy quantity + /// + public Int64 CtNavyQuantity + { + get; set; + } + + /// + /// hd blue quantity + /// + public Int64 HdBlueQuantity + { + get; set; + } + + /// + /// hd light blue quantity + /// + public Int64 HdLightBlueQuantity + { + get; set; + } + + /// + /// hd rubine quantity + /// + public Int64 HdRubineQuantity + { + get; set; + } + + /// + /// hd light rubine quantity + /// + public Int64 HdLightRubineQuantity + { + get; set; + } + + /// + /// hd orange quantity + /// + public Int64 HdOrangeQuantity + { + get; set; + } + + /// + /// hd light orange quantity + /// + public Int64 HdLightOrangeQuantity + { + get; set; + } + + /// + /// hd navy quantity + /// + public Int64 HdNavyQuantity + { + get; set; + } + + /// + /// hd light navy quantity + /// + public Int64 HdLightNavyQuantity + { + get; set; + } + + /// + /// am blue quantity + /// + public Int64 AmBlueQuantity + { + get; set; + } + + /// + /// am light blue quantity + /// + public Int64 AmLightBlueQuantity + { + get; set; + } + + /// + /// am red quantity + /// + public Int64 AmRedQuantity + { + get; set; + } + + /// + /// am light red quantity + /// + public Int64 AmLightRedQuantity + { + get; set; + } + + /// + /// am orange quantity + /// + public Int64 AmOrangeQuantity + { + get; set; + } + + /// + /// am light orange quantity + /// + public Int64 AmLightOrangeQuantity + { + get; set; + } + + /// + /// am yellow quantity + /// + public Int64 AmYellowQuantity + { + get; set; + } + + /// + /// am light yellow quantity + /// + public Int64 AmLightYellowQuantity + { + get; set; + } + + /// + /// am black quantity + /// + public Int64 AmBlackQuantity + { + get; set; + } + } } diff --git a/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs b/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs index eba35dbd6..5d860f0ae 100644 --- a/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs +++ b/Software/Visual_Studio/Tango.BL/DTO/LiquidTypeDTOBase.cs @@ -109,5 +109,13 @@ namespace Tango.BL.DTO get; set; } + /// + /// display name + /// + public String DisplayName + { + get; set; + } + } } diff --git a/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs b/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs index e3b9f676c..460d1f193 100644 --- a/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs +++ b/Software/Visual_Studio/Tango.BL/DTO/RmlDTOBase.cs @@ -437,5 +437,13 @@ namespace Tango.BL.DTO get; set; } + /// + /// default liquid factor + /// + public Double DefaultLiquidFactor + { + get; set; + } + } } diff --git a/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs b/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs index 54685f7ee..327d8ac85 100644 --- a/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs +++ b/Software/Visual_Studio/Tango.BL/Entities/JobRunBase.cs @@ -117,6 +117,80 @@ namespace Tango.BL.Entities public event EventHandler VioletQuantityChanged; + public event EventHandler TwTransparentInkQuantityChanged; + + public event EventHandler C1TiQuantityChanged; + + public event EventHandler TwCyanQuantityChanged; + + public event EventHandler TwLightCyanQuantityChanged; + + public event EventHandler TwMagentaQuantityChanged; + + public event EventHandler TwLightMagentaQuantityChanged; + + public event EventHandler TwYellowQuantityChanged; + + public event EventHandler TwLightYellowQuantityChanged; + + public event EventHandler C1YellowQuantityChanged; + + public event EventHandler C1LightYellowQuantityChanged; + + public event EventHandler TwBlackQuantityChanged; + + public event EventHandler TwVioletQuantityChanged; + + public event EventHandler TwLightVioletQuantityChanged; + + public event EventHandler CtBlueQuantityChanged; + + public event EventHandler CtLightBlueQuantityChanged; + + public event EventHandler CtRubineQuantityChanged; + + public event EventHandler CtLightRubineQuantityChanged; + + public event EventHandler CtOrangeQuantityChanged; + + public event EventHandler CtLightOrangeQuantityChanged; + + public event EventHandler CtNavyQuantityChanged; + + public event EventHandler HdBlueQuantityChanged; + + public event EventHandler HdLightBlueQuantityChanged; + + public event EventHandler HdRubineQuantityChanged; + + public event EventHandler HdLightRubineQuantityChanged; + + public event EventHandler HdOrangeQuantityChanged; + + public event EventHandler HdLightOrangeQuantityChanged; + + public event EventHandler HdNavyQuantityChanged; + + public event EventHandler HdLightNavyQuantityChanged; + + public event EventHandler AmBlueQuantityChanged; + + public event EventHandler AmLightBlueQuantityChanged; + + public event EventHandler AmRedQuantityChanged; + + public event EventHandler AmLightRedQuantityChanged; + + public event EventHandler AmOrangeQuantityChanged; + + public event EventHandler AmLightOrangeQuantityChanged; + + public event EventHandler AmYellowQuantityChanged; + + public event EventHandler AmLightYellowQuantityChanged; + + public event EventHandler AmBlackQuantityChanged; + protected String _machineguid; /// @@ -1459,118 +1533,1117 @@ namespace Tango.BL.Entities } } + protected Int64 _twtransparentinkquantity; + /// - /// Called when the JobName has changed. + /// Gets or sets the jobrunbase tw transparent ink quantity. /// - protected virtual void OnJobNameChanged(String jobname) + + [Column("TW_TRANSPARENT_INK_QUANTITY")] + + public Int64 TwTransparentInkQuantity { - JobNameChanged?.Invoke(this, jobname); - RaisePropertyChanged(nameof(JobName)); + get + { + return _twtransparentinkquantity; + } + + set + { + if (_twtransparentinkquantity != value) + { + _twtransparentinkquantity = value; + + OnTwTransparentInkQuantityChanged(value); + + } + } } + protected Int64 _c1tiquantity; + /// - /// Called when the JobDesignation has changed. + /// Gets or sets the jobrunbase c1 ti quantity. /// - protected virtual void OnJobDesignationChanged(Int32 jobdesignation) + + [Column("C1_TI_QUANTITY")] + + public Int64 C1TiQuantity { - JobDesignationChanged?.Invoke(this, jobdesignation); - RaisePropertyChanged(nameof(JobDesignation)); + get + { + return _c1tiquantity; + } + + set + { + if (_c1tiquantity != value) + { + _c1tiquantity = value; + + OnC1TiQuantityChanged(value); + + } + } } + protected Int64 _twcyanquantity; + /// - /// Called when the JobSource has changed. + /// Gets or sets the jobrunbase tw cyan quantity. /// - protected virtual void OnJobSourceChanged(Int32 jobsource) + + [Column("TW_CYAN_QUANTITY")] + + public Int64 TwCyanQuantity { - JobSourceChanged?.Invoke(this, jobsource); - RaisePropertyChanged(nameof(JobSource)); + get + { + return _twcyanquantity; + } + + set + { + if (_twcyanquantity != value) + { + _twcyanquantity = value; + + OnTwCyanQuantityChanged(value); + + } + } } + protected Int64 _twlightcyanquantity; + /// - /// Called when the JobString has changed. + /// Gets or sets the jobrunbase tw light cyan quantity. /// - protected virtual void OnJobStringChanged(String jobstring) + + [Column("TW_LIGHT_CYAN_QUANTITY")] + + public Int64 TwLightCyanQuantity { - JobStringChanged?.Invoke(this, jobstring); - RaisePropertyChanged(nameof(JobString)); + get + { + return _twlightcyanquantity; + } + + set + { + if (_twlightcyanquantity != value) + { + _twlightcyanquantity = value; + + OnTwLightCyanQuantityChanged(value); + + } + } } + protected Int64 _twmagentaquantity; + /// - /// Called when the StartDate has changed. + /// Gets or sets the jobrunbase tw magenta quantity. /// - protected virtual void OnStartDateChanged(DateTime startdate) + + [Column("TW_MAGENTA_QUANTITY")] + + public Int64 TwMagentaQuantity { - StartDateChanged?.Invoke(this, startdate); - RaisePropertyChanged(nameof(StartDate)); + get + { + return _twmagentaquantity; + } + + set + { + if (_twmagentaquantity != value) + { + _twmagentaquantity = value; + + OnTwMagentaQuantityChanged(value); + + } + } } + protected Int64 _twlightmagentaquantity; + /// - /// Called when the UploadingStartDate has changed. + /// Gets or sets the jobrunbase tw light magenta quantity. /// - protected virtual void OnUploadingStartDateChanged(Nullable uploadingstartdate) + + [Column("TW_LIGHT_MAGENTA_QUANTITY")] + + public Int64 TwLightMagentaQuantity { - UploadingStartDateChanged?.Invoke(this, uploadingstartdate); - RaisePropertyChanged(nameof(UploadingStartDate)); + get + { + return _twlightmagentaquantity; + } + + set + { + if (_twlightmagentaquantity != value) + { + _twlightmagentaquantity = value; + + OnTwLightMagentaQuantityChanged(value); + + } + } } + protected Int64 _twyellowquantity; + /// - /// Called when the HeatingStartDate has changed. + /// Gets or sets the jobrunbase tw yellow quantity. /// - protected virtual void OnHeatingStartDateChanged(Nullable heatingstartdate) + + [Column("TW_YELLOW_QUANTITY")] + + public Int64 TwYellowQuantity { - HeatingStartDateChanged?.Invoke(this, heatingstartdate); - RaisePropertyChanged(nameof(HeatingStartDate)); + get + { + return _twyellowquantity; + } + + set + { + if (_twyellowquantity != value) + { + _twyellowquantity = value; + + OnTwYellowQuantityChanged(value); + + } + } } + protected Int64 _twlightyellowquantity; + /// - /// Called when the ActualStartDate has changed. + /// Gets or sets the jobrunbase tw light yellow quantity. /// - protected virtual void OnActualStartDateChanged(Nullable actualstartdate) + + [Column("TW_LIGHT_YELLOW_QUANTITY")] + + public Int64 TwLightYellowQuantity { - ActualStartDateChanged?.Invoke(this, actualstartdate); - RaisePropertyChanged(nameof(ActualStartDate)); + get + { + return _twlightyellowquantity; + } + + set + { + if (_twlightyellowquantity != value) + { + _twlightyellowquantity = value; + + OnTwLightYellowQuantityChanged(value); + + } + } } + protected Int64 _c1yellowquantity; + /// - /// Called when the EndDate has changed. + /// Gets or sets the jobrunbase c1 yellow quantity. /// - protected virtual void OnEndDateChanged(DateTime enddate) + + [Column("C1_YELLOW_QUANTITY")] + + public Int64 C1YellowQuantity { - EndDateChanged?.Invoke(this, enddate); - RaisePropertyChanged(nameof(EndDate)); + get + { + return _c1yellowquantity; + } + + set + { + if (_c1yellowquantity != value) + { + _c1yellowquantity = value; + + OnC1YellowQuantityChanged(value); + + } + } } + protected Int64 _c1lightyellowquantity; + /// - /// Called when the Status has changed. + /// Gets or sets the jobrunbase c1 light yellow quantity. /// - protected virtual void OnStatusChanged(Int32 status) + + [Column("C1_LIGHT_YELLOW_QUANTITY")] + + public Int64 C1LightYellowQuantity { - StatusChanged?.Invoke(this, status); - RaisePropertyChanged(nameof(Status)); + get + { + return _c1lightyellowquantity; + } + + set + { + if (_c1lightyellowquantity != value) + { + _c1lightyellowquantity = value; + + OnC1LightYellowQuantityChanged(value); + + } + } } + protected Int64 _twblackquantity; + /// - /// Called when the JobLength has changed. + /// Gets or sets the jobrunbase tw black quantity. /// - protected virtual void OnJobLengthChanged(Double joblength) + + [Column("TW_BLACK_QUANTITY")] + + public Int64 TwBlackQuantity { - JobLengthChanged?.Invoke(this, joblength); - RaisePropertyChanged(nameof(JobLength)); + get + { + return _twblackquantity; + } + + set + { + if (_twblackquantity != value) + { + _twblackquantity = value; + + OnTwBlackQuantityChanged(value); + + } + } } + protected Int64 _twvioletquantity; + /// - /// Called when the IsGradient has changed. + /// Gets or sets the jobrunbase tw violet quantity. /// - protected virtual void OnIsGradientChanged(Boolean isgradient) + + [Column("TW_VIOLET_QUANTITY")] + + public Int64 TwVioletQuantity { - IsGradientChanged?.Invoke(this, isgradient); - RaisePropertyChanged(nameof(IsGradient)); + get + { + return _twvioletquantity; + } + + set + { + if (_twvioletquantity != value) + { + _twvioletquantity = value; + + OnTwVioletQuantityChanged(value); + + } + } } + protected Int64 _twlightvioletquantity; + /// - /// Called when the GradientResolutionCm has changed. + /// Gets or sets the jobrunbase tw light violet quantity. /// - protected virtual void OnGradientResolutionCmChanged(Int32 gradientresolutioncm) + + [Column("TW_LIGHT_VIOLET_QUANTITY")] + + public Int64 TwLightVioletQuantity + { + get + { + return _twlightvioletquantity; + } + + set + { + if (_twlightvioletquantity != value) + { + _twlightvioletquantity = value; + + OnTwLightVioletQuantityChanged(value); + + } + } + } + + protected Int64 _ctbluequantity; + + /// + /// Gets or sets the jobrunbase ct blue quantity. + /// + + [Column("CT_BLUE_QUANTITY")] + + public Int64 CtBlueQuantity + { + get + { + return _ctbluequantity; + } + + set + { + if (_ctbluequantity != value) + { + _ctbluequantity = value; + + OnCtBlueQuantityChanged(value); + + } + } + } + + protected Int64 _ctlightbluequantity; + + /// + /// Gets or sets the jobrunbase ct light blue quantity. + /// + + [Column("CT_LIGHT_BLUE_QUANTITY")] + + public Int64 CtLightBlueQuantity + { + get + { + return _ctlightbluequantity; + } + + set + { + if (_ctlightbluequantity != value) + { + _ctlightbluequantity = value; + + OnCtLightBlueQuantityChanged(value); + + } + } + } + + protected Int64 _ctrubinequantity; + + /// + /// Gets or sets the jobrunbase ct rubine quantity. + /// + + [Column("CT_RUBINE_QUANTITY")] + + public Int64 CtRubineQuantity + { + get + { + return _ctrubinequantity; + } + + set + { + if (_ctrubinequantity != value) + { + _ctrubinequantity = value; + + OnCtRubineQuantityChanged(value); + + } + } + } + + protected Int64 _ctlightrubinequantity; + + /// + /// Gets or sets the jobrunbase ct light rubine quantity. + /// + + [Column("CT_LIGHT_RUBINE_QUANTITY")] + + public Int64 CtLightRubineQuantity + { + get + { + return _ctlightrubinequantity; + } + + set + { + if (_ctlightrubinequantity != value) + { + _ctlightrubinequantity = value; + + OnCtLightRubineQuantityChanged(value); + + } + } + } + + protected Int64 _ctorangequantity; + + /// + /// Gets or sets the jobrunbase ct orange quantity. + /// + + [Column("CT_ORANGE_QUANTITY")] + + public Int64 CtOrangeQuantity + { + get + { + return _ctorangequantity; + } + + set + { + if (_ctorangequantity != value) + { + _ctorangequantity = value; + + OnCtOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _ctlightorangequantity; + + /// + /// Gets or sets the jobrunbase ct light orange quantity. + /// + + [Column("CT_LIGHT_ORANGE_QUANTITY")] + + public Int64 CtLightOrangeQuantity + { + get + { + return _ctlightorangequantity; + } + + set + { + if (_ctlightorangequantity != value) + { + _ctlightorangequantity = value; + + OnCtLightOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _ctnavyquantity; + + /// + /// Gets or sets the jobrunbase ct navy quantity. + /// + + [Column("CT_NAVY_QUANTITY")] + + public Int64 CtNavyQuantity + { + get + { + return _ctnavyquantity; + } + + set + { + if (_ctnavyquantity != value) + { + _ctnavyquantity = value; + + OnCtNavyQuantityChanged(value); + + } + } + } + + protected Int64 _hdbluequantity; + + /// + /// Gets or sets the jobrunbase hd blue quantity. + /// + + [Column("HD_BLUE_QUANTITY")] + + public Int64 HdBlueQuantity + { + get + { + return _hdbluequantity; + } + + set + { + if (_hdbluequantity != value) + { + _hdbluequantity = value; + + OnHdBlueQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightbluequantity; + + /// + /// Gets or sets the jobrunbase hd light blue quantity. + /// + + [Column("HD_LIGHT_BLUE_QUANTITY")] + + public Int64 HdLightBlueQuantity + { + get + { + return _hdlightbluequantity; + } + + set + { + if (_hdlightbluequantity != value) + { + _hdlightbluequantity = value; + + OnHdLightBlueQuantityChanged(value); + + } + } + } + + protected Int64 _hdrubinequantity; + + /// + /// Gets or sets the jobrunbase hd rubine quantity. + /// + + [Column("HD_RUBINE_QUANTITY")] + + public Int64 HdRubineQuantity + { + get + { + return _hdrubinequantity; + } + + set + { + if (_hdrubinequantity != value) + { + _hdrubinequantity = value; + + OnHdRubineQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightrubinequantity; + + /// + /// Gets or sets the jobrunbase hd light rubine quantity. + /// + + [Column("HD_LIGHT_RUBINE_QUANTITY")] + + public Int64 HdLightRubineQuantity + { + get + { + return _hdlightrubinequantity; + } + + set + { + if (_hdlightrubinequantity != value) + { + _hdlightrubinequantity = value; + + OnHdLightRubineQuantityChanged(value); + + } + } + } + + protected Int64 _hdorangequantity; + + /// + /// Gets or sets the jobrunbase hd orange quantity. + /// + + [Column("HD_ORANGE_QUANTITY")] + + public Int64 HdOrangeQuantity + { + get + { + return _hdorangequantity; + } + + set + { + if (_hdorangequantity != value) + { + _hdorangequantity = value; + + OnHdOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightorangequantity; + + /// + /// Gets or sets the jobrunbase hd light orange quantity. + /// + + [Column("HD_LIGHT_ORANGE_QUANTITY")] + + public Int64 HdLightOrangeQuantity + { + get + { + return _hdlightorangequantity; + } + + set + { + if (_hdlightorangequantity != value) + { + _hdlightorangequantity = value; + + OnHdLightOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _hdnavyquantity; + + /// + /// Gets or sets the jobrunbase hd navy quantity. + /// + + [Column("HD_NAVY_QUANTITY")] + + public Int64 HdNavyQuantity + { + get + { + return _hdnavyquantity; + } + + set + { + if (_hdnavyquantity != value) + { + _hdnavyquantity = value; + + OnHdNavyQuantityChanged(value); + + } + } + } + + protected Int64 _hdlightnavyquantity; + + /// + /// Gets or sets the jobrunbase hd light navy quantity. + /// + + [Column("HD_LIGHT_NAVY_QUANTITY")] + + public Int64 HdLightNavyQuantity + { + get + { + return _hdlightnavyquantity; + } + + set + { + if (_hdlightnavyquantity != value) + { + _hdlightnavyquantity = value; + + OnHdLightNavyQuantityChanged(value); + + } + } + } + + protected Int64 _ambluequantity; + + /// + /// Gets or sets the jobrunbase am blue quantity. + /// + + [Column("AM_BLUE_QUANTITY")] + + public Int64 AmBlueQuantity + { + get + { + return _ambluequantity; + } + + set + { + if (_ambluequantity != value) + { + _ambluequantity = value; + + OnAmBlueQuantityChanged(value); + + } + } + } + + protected Int64 _amlightbluequantity; + + /// + /// Gets or sets the jobrunbase am light blue quantity. + /// + + [Column("AM_LIGHT_BLUE_QUANTITY")] + + public Int64 AmLightBlueQuantity + { + get + { + return _amlightbluequantity; + } + + set + { + if (_amlightbluequantity != value) + { + _amlightbluequantity = value; + + OnAmLightBlueQuantityChanged(value); + + } + } + } + + protected Int64 _amredquantity; + + /// + /// Gets or sets the jobrunbase am red quantity. + /// + + [Column("AM_RED_QUANTITY")] + + public Int64 AmRedQuantity + { + get + { + return _amredquantity; + } + + set + { + if (_amredquantity != value) + { + _amredquantity = value; + + OnAmRedQuantityChanged(value); + + } + } + } + + protected Int64 _amlightredquantity; + + /// + /// Gets or sets the jobrunbase am light red quantity. + /// + + [Column("AM_LIGHT_RED_QUANTITY")] + + public Int64 AmLightRedQuantity + { + get + { + return _amlightredquantity; + } + + set + { + if (_amlightredquantity != value) + { + _amlightredquantity = value; + + OnAmLightRedQuantityChanged(value); + + } + } + } + + protected Int64 _amorangequantity; + + /// + /// Gets or sets the jobrunbase am orange quantity. + /// + + [Column("AM_ORANGE_QUANTITY")] + + public Int64 AmOrangeQuantity + { + get + { + return _amorangequantity; + } + + set + { + if (_amorangequantity != value) + { + _amorangequantity = value; + + OnAmOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _amlightorangequantity; + + /// + /// Gets or sets the jobrunbase am light orange quantity. + /// + + [Column("AM_LIGHT_ORANGE_QUANTITY")] + + public Int64 AmLightOrangeQuantity + { + get + { + return _amlightorangequantity; + } + + set + { + if (_amlightorangequantity != value) + { + _amlightorangequantity = value; + + OnAmLightOrangeQuantityChanged(value); + + } + } + } + + protected Int64 _amyellowquantity; + + /// + /// Gets or sets the jobrunbase am yellow quantity. + /// + + [Column("AM_YELLOW_QUANTITY")] + + public Int64 AmYellowQuantity + { + get + { + return _amyellowquantity; + } + + set + { + if (_amyellowquantity != value) + { + _amyellowquantity = value; + + OnAmYellowQuantityChanged(value); + + } + } + } + + protected Int64 _amlightyellowquantity; + + /// + /// Gets or sets the jobrunbase am light yellow quantity. + /// + + [Column("AM_LIGHT_YELLOW_QUANTITY")] + + public Int64 AmLightYellowQuantity + { + get + { + return _amlightyellowquantity; + } + + set + { + if (_amlightyellowquantity != value) + { + _amlightyellowquantity = value; + + OnAmLightYellowQuantityChanged(value); + + } + } + } + + protected Int64 _amblackquantity; + + /// + /// Gets or sets the jobrunbase am black quantity. + /// + + [Column("AM_BLACK_QUANTITY")] + + public Int64 AmBlackQuantity + { + get + { + return _amblackquantity; + } + + set + { + if (_amblackquantity != value) + { + _amblackquantity = value; + + OnAmBlackQuantityChanged(value); + + } + } + } + + /// + /// Called when the JobName has changed. + /// + protected virtual void OnJobNameChanged(String jobname) + { + JobNameChanged?.Invoke(this, jobname); + RaisePropertyChanged(nameof(JobName)); + } + + /// + /// Called when the JobDesignation has changed. + /// + protected virtual void OnJobDesignationChanged(Int32 jobdesignation) + { + JobDesignationChanged?.Invoke(this, jobdesignation); + RaisePropertyChanged(nameof(JobDesignation)); + } + + /// + /// Called when the JobSource has changed. + /// + protected virtual void OnJobSourceChanged(Int32 jobsource) + { + JobSourceChanged?.Invoke(this, jobsource); + RaisePropertyChanged(nameof(JobSource)); + } + + /// + /// Called when the JobString has changed. + /// + protected virtual void OnJobStringChanged(String jobstring) + { + JobStringChanged?.Invoke(this, jobstring); + RaisePropertyChanged(nameof(JobString)); + } + + /// + /// Called when the StartDate has changed. + /// + protected virtual void OnStartDateChanged(DateTime startdate) + { + StartDateChanged?.Invoke(this, startdate); + RaisePropertyChanged(nameof(StartDate)); + } + + /// + /// Called when the UploadingStartDate has changed. + /// + protected virtual void OnUploadingStartDateChanged(Nullable uploadingstartdate) + { + UploadingStartDateChanged?.Invoke(this, uploadingstartdate); + RaisePropertyChanged(nameof(UploadingStartDate)); + } + + /// + /// Called when the HeatingStartDate has changed. + /// + protected virtual void OnHeatingStartDateChanged(Nullable heatingstartdate) + { + HeatingStartDateChanged?.Invoke(this, heatingstartdate); + RaisePropertyChanged(nameof(HeatingStartDate)); + } + + /// + /// Called when the ActualStartDate has changed. + /// + protected virtual void OnActualStartDateChanged(Nullable actualstartdate) + { + ActualStartDateChanged?.Invoke(this, actualstartdate); + RaisePropertyChanged(nameof(ActualStartDate)); + } + + /// + /// Called when the EndDate has changed. + /// + protected virtual void OnEndDateChanged(DateTime enddate) + { + EndDateChanged?.Invoke(this, enddate); + RaisePropertyChanged(nameof(EndDate)); + } + + /// + /// Called when the Status has changed. + /// + protected virtual void OnStatusChanged(Int32 status) + { + StatusChanged?.Invoke(this, status); + RaisePropertyChanged(nameof(Status)); + } + + /// + /// Called when the JobLength has changed. + /// + protected virtual void OnJobLengthChanged(Double joblength) + { + JobLengthChanged?.Invoke(this, joblength); + RaisePropertyChanged(nameof(JobLength)); + } + + /// + /// Called when the IsGradient has changed. + /// + protected virtual void OnIsGradientChanged(Boolean isgradient) + { + IsGradientChanged?.Invoke(this, isgradient); + RaisePropertyChanged(nameof(IsGradient)); + } + + /// + /// Called when the GradientResolutionCm has changed. + /// + protected virtual void OnGradientResolutionCmChanged(Int32 gradientresolutioncm) { GradientResolutionCmChanged?.Invoke(this, gradientresolutioncm); RaisePropertyChanged(nameof(GradientResolutionCm)); @@ -1864,6 +2937,339 @@ namespace Tango.BL.Entities RaisePropertyChanged(nameof(VioletQuantity)); } + /// + /// Called when the TwTransparentInkQuantity has changed. + /// + protected virtual void OnTwTransparentInkQuantityChanged(Int64 twtransparentinkquantity) + { + TwTransparentInkQuantityChanged?.Invoke(this, twtransparentinkquantity); + RaisePropertyChanged(nameof(TwTransparentInkQuantity)); + } + + /// + /// Called when the C1TiQuantity has changed. + /// + protected virtual void OnC1TiQuantityChanged(Int64 c1tiquantity) + { + C1TiQuantityChanged?.Invoke(this, c1tiquantity); + RaisePropertyChanged(nameof(C1TiQuantity)); + } + + /// + /// Called when the TwCyanQuantity has changed. + /// + protected virtual void OnTwCyanQuantityChanged(Int64 twcyanquantity) + { + TwCyanQuantityChanged?.Invoke(this, twcyanquantity); + RaisePropertyChanged(nameof(TwCyanQuantity)); + } + + /// + /// Called when the TwLightCyanQuantity has changed. + /// + protected virtual void OnTwLightCyanQuantityChanged(Int64 twlightcyanquantity) + { + TwLightCyanQuantityChanged?.Invoke(this, twlightcyanquantity); + RaisePropertyChanged(nameof(TwLightCyanQuantity)); + } + + /// + /// Called when the TwMagentaQuantity has changed. + /// + protected virtual void OnTwMagentaQuantityChanged(Int64 twmagentaquantity) + { + TwMagentaQuantityChanged?.Invoke(this, twmagentaquantity); + RaisePropertyChanged(nameof(TwMagentaQuantity)); + } + + /// + /// Called when the TwLightMagentaQuantity has changed. + /// + protected virtual void OnTwLightMagentaQuantityChanged(Int64 twlightmagentaquantity) + { + TwLightMagentaQuantityChanged?.Invoke(this, twlightmagentaquantity); + RaisePropertyChanged(nameof(TwLightMagentaQuantity)); + } + + /// + /// Called when the TwYellowQuantity has changed. + /// + protected virtual void OnTwYellowQuantityChanged(Int64 twyellowquantity) + { + TwYellowQuantityChanged?.Invoke(this, twyellowquantity); + RaisePropertyChanged(nameof(TwYellowQuantity)); + } + + /// + /// Called when the TwLightYellowQuantity has changed. + /// + protected virtual void OnTwLightYellowQuantityChanged(Int64 twlightyellowquantity) + { + TwLightYellowQuantityChanged?.Invoke(this, twlightyellowquantity); + RaisePropertyChanged(nameof(TwLightYellowQuantity)); + } + + /// + /// Called when the C1YellowQuantity has changed. + /// + protected virtual void OnC1YellowQuantityChanged(Int64 c1yellowquantity) + { + C1YellowQuantityChanged?.Invoke(this, c1yellowquantity); + RaisePropertyChanged(nameof(C1YellowQuantity)); + } + + /// + /// Called when the C1LightYellowQuantity has changed. + /// + protected virtual void OnC1LightYellowQuantityChanged(Int64 c1lightyellowquantity) + { + C1LightYellowQuantityChanged?.Invoke(this, c1lightyellowquantity); + RaisePropertyChanged(nameof(C1LightYellowQuantity)); + } + + /// + /// Called when the TwBlackQuantity has changed. + /// + protected virtual void OnTwBlackQuantityChanged(Int64 twblackquantity) + { + TwBlackQuantityChanged?.Invoke(this, twblackquantity); + RaisePropertyChanged(nameof(TwBlackQuantity)); + } + + /// + /// Called when the TwVioletQuantity has changed. + /// + protected virtual void OnTwVioletQuantityChanged(Int64 twvioletquantity) + { + TwVioletQuantityChanged?.Invoke(this, twvioletquantity); + RaisePropertyChanged(nameof(TwVioletQuantity)); + } + + /// + /// Called when the TwLightVioletQuantity has changed. + /// + protected virtual void OnTwLightVioletQuantityChanged(Int64 twlightvioletquantity) + { + TwLightVioletQuantityChanged?.Invoke(this, twlightvioletquantity); + RaisePropertyChanged(nameof(TwLightVioletQuantity)); + } + + /// + /// Called when the CtBlueQuantity has changed. + /// + protected virtual void OnCtBlueQuantityChanged(Int64 ctbluequantity) + { + CtBlueQuantityChanged?.Invoke(this, ctbluequantity); + RaisePropertyChanged(nameof(CtBlueQuantity)); + } + + /// + /// Called when the CtLightBlueQuantity has changed. + /// + protected virtual void OnCtLightBlueQuantityChanged(Int64 ctlightbluequantity) + { + CtLightBlueQuantityChanged?.Invoke(this, ctlightbluequantity); + RaisePropertyChanged(nameof(CtLightBlueQuantity)); + } + + /// + /// Called when the CtRubineQuantity has changed. + /// + protected virtual void OnCtRubineQuantityChanged(Int64 ctrubinequantity) + { + CtRubineQuantityChanged?.Invoke(this, ctrubinequantity); + RaisePropertyChanged(nameof(CtRubineQuantity)); + } + + /// + /// Called when the CtLightRubineQuantity has changed. + /// + protected virtual void OnCtLightRubineQuantityChanged(Int64 ctlightrubinequantity) + { + CtLightRubineQuantityChanged?.Invoke(this, ctlightrubinequantity); + RaisePropertyChanged(nameof(CtLightRubineQuantity)); + } + + /// + /// Called when the CtOrangeQuantity has changed. + /// + protected virtual void OnCtOrangeQuantityChanged(Int64 ctorangequantity) + { + CtOrangeQuantityChanged?.Invoke(this, ctorangequantity); + RaisePropertyChanged(nameof(CtOrangeQuantity)); + } + + /// + /// Called when the CtLightOrangeQuantity has changed. + /// + protected virtual void OnCtLightOrangeQuantityChanged(Int64 ctlightorangequantity) + { + CtLightOrangeQuantityChanged?.Invoke(this, ctlightorangequantity); + RaisePropertyChanged(nameof(CtLightOrangeQuantity)); + } + + /// + /// Called when the CtNavyQuantity has changed. + /// + protected virtual void OnCtNavyQuantityChanged(Int64 ctnavyquantity) + { + CtNavyQuantityChanged?.Invoke(this, ctnavyquantity); + RaisePropertyChanged(nameof(CtNavyQuantity)); + } + + /// + /// Called when the HdBlueQuantity has changed. + /// + protected virtual void OnHdBlueQuantityChanged(Int64 hdbluequantity) + { + HdBlueQuantityChanged?.Invoke(this, hdbluequantity); + RaisePropertyChanged(nameof(HdBlueQuantity)); + } + + /// + /// Called when the HdLightBlueQuantity has changed. + /// + protected virtual void OnHdLightBlueQuantityChanged(Int64 hdlightbluequantity) + { + HdLightBlueQuantityChanged?.Invoke(this, hdlightbluequantity); + RaisePropertyChanged(nameof(HdLightBlueQuantity)); + } + + /// + /// Called when the HdRubineQuantity has changed. + /// + protected virtual void OnHdRubineQuantityChanged(Int64 hdrubinequantity) + { + HdRubineQuantityChanged?.Invoke(this, hdrubinequantity); + RaisePropertyChanged(nameof(HdRubineQuantity)); + } + + /// + /// Called when the HdLightRubineQuantity has changed. + /// + protected virtual void OnHdLightRubineQuantityChanged(Int64 hdlightrubinequantity) + { + HdLightRubineQuantityChanged?.Invoke(this, hdlightrubinequantity); + RaisePropertyChanged(nameof(HdLightRubineQuantity)); + } + + /// + /// Called when the HdOrangeQuantity has changed. + /// + protected virtual void OnHdOrangeQuantityChanged(Int64 hdorangequantity) + { + HdOrangeQuantityChanged?.Invoke(this, hdorangequantity); + RaisePropertyChanged(nameof(HdOrangeQuantity)); + } + + /// + /// Called when the HdLightOrangeQuantity has changed. + /// + protected virtual void OnHdLightOrangeQuantityChanged(Int64 hdlightorangequantity) + { + HdLightOrangeQuantityChanged?.Invoke(this, hdlightorangequantity); + RaisePropertyChanged(nameof(HdLightOrangeQuantity)); + } + + /// + /// Called when the HdNavyQuantity has changed. + /// + protected virtual void OnHdNavyQuantityChanged(Int64 hdnavyquantity) + { + HdNavyQuantityChanged?.Invoke(this, hdnavyquantity); + RaisePropertyChanged(nameof(HdNavyQuantity)); + } + + /// + /// Called when the HdLightNavyQuantity has changed. + /// + protected virtual void OnHdLightNavyQuantityChanged(Int64 hdlightnavyquantity) + { + HdLightNavyQuantityChanged?.Invoke(this, hdlightnavyquantity); + RaisePropertyChanged(nameof(HdLightNavyQuantity)); + } + + /// + /// Called when the AmBlueQuantity has changed. + /// + protected virtual void OnAmBlueQuantityChanged(Int64 ambluequantity) + { + AmBlueQuantityChanged?.Invoke(this, ambluequantity); + RaisePropertyChanged(nameof(AmBlueQuantity)); + } + + /// + /// Called when the AmLightBlueQuantity has changed. + /// + protected virtual void OnAmLightBlueQuantityChanged(Int64 amlightbluequantity) + { + AmLightBlueQuantityChanged?.Invoke(this, amlightbluequantity); + RaisePropertyChanged(nameof(AmLightBlueQuantity)); + } + + /// + /// Called when the AmRedQuantity has changed. + /// + protected virtual void OnAmRedQuantityChanged(Int64 amredquantity) + { + AmRedQuantityChanged?.Invoke(this, amredquantity); + RaisePropertyChanged(nameof(AmRedQuantity)); + } + + /// + /// Called when the AmLightRedQuantity has changed. + /// + protected virtual void OnAmLightRedQuantityChanged(Int64 amlightredquantity) + { + AmLightRedQuantityChanged?.Invoke(this, amlightredquantity); + RaisePropertyChanged(nameof(AmLightRedQuantity)); + } + + /// + /// Called when the AmOrangeQuantity has changed. + /// + protected virtual void OnAmOrangeQuantityChanged(Int64 amorangequantity) + { + AmOrangeQuantityChanged?.Invoke(this, amorangequantity); + RaisePropertyChanged(nameof(AmOrangeQuantity)); + } + + /// + /// Called when the AmLightOrangeQuantity has changed. + /// + protected virtual void OnAmLightOrangeQuantityChanged(Int64 amlightorangequantity) + { + AmLightOrangeQuantityChanged?.Invoke(this, amlightorangequantity); + RaisePropertyChanged(nameof(AmLightOrangeQuantity)); + } + + /// + /// Called when the AmYellowQuantity has changed. + /// + protected virtual void OnAmYellowQuantityChanged(Int64 amyellowquantity) + { + AmYellowQuantityChanged?.Invoke(this, amyellowquantity); + RaisePropertyChanged(nameof(AmYellowQuantity)); + } + + /// + /// Called when the AmLightYellowQuantity has changed. + /// + protected virtual void OnAmLightYellowQuantityChanged(Int64 amlightyellowquantity) + { + AmLightYellowQuantityChanged?.Invoke(this, amlightyellowquantity); + RaisePropertyChanged(nameof(AmLightYellowQuantity)); + } + + /// + /// Called when the AmBlackQuantity has changed. + /// + protected virtual void OnAmBlackQuantityChanged(Int64 amblackquantity) + { + AmBlackQuantityChanged?.Invoke(this, amblackquantity); + RaisePropertyChanged(nameof(AmBlackQuantity)); + } + /// /// Initializes a new instance of the class. /// diff --git a/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs b/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs index 82403a11b..fbd32967f 100644 --- a/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs +++ b/Software/Visual_Studio/Tango.BL/Entities/LiquidTypeBase.cs @@ -49,6 +49,8 @@ namespace Tango.BL.Entities public event EventHandler DarkInkCodeChanged; + public event EventHandler DisplayNameChanged; + public event EventHandler> CatsChanged; public event EventHandler> IdsPacksChanged; @@ -354,6 +356,33 @@ namespace Tango.BL.Entities } } + protected String _displayname; + + /// + /// Gets or sets the liquidtypebase display name. + /// + + [Column("DISPLAY_NAME")] + + public String DisplayName + { + get + { + return _displayname; + } + + set + { + if (_displayname != value) + { + _displayname = value; + + OnDisplayNameChanged(value); + + } + } + } + protected SynchronizedObservableCollection _cats; /// @@ -553,6 +582,15 @@ namespace Tango.BL.Entities RaisePropertyChanged(nameof(DarkInkCode)); } + /// + /// Called when the DisplayName has changed. + /// + protected virtual void OnDisplayNameChanged(String displayname) + { + DisplayNameChanged?.Invoke(this, displayname); + RaisePropertyChanged(nameof(DisplayName)); + } + /// /// Called when the Cats has changed. /// diff --git a/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs b/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs index 17b29d691..357be1666 100644 --- a/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs +++ b/Software/Visual_Studio/Tango.BL/Entities/RmlBase.cs @@ -109,6 +109,8 @@ namespace Tango.BL.Entities public event EventHandler BtsrTensionErrorChanged; + public event EventHandler DefaultLiquidFactorChanged; + public event EventHandler BtsrApplicationTypeChanged; public event EventHandler BtsrYarnTypeChanged; @@ -1540,6 +1542,33 @@ namespace Tango.BL.Entities } } + protected Double _defaultliquidfactor; + + /// + /// Gets or sets the rmlbase default liquid factor. + /// + + [Column("DEFAULT_LIQUID_FACTOR")] + + public Double DefaultLiquidFactor + { + get + { + return _defaultliquidfactor; + } + + set + { + if (_defaultliquidfactor != value) + { + _defaultliquidfactor = value; + + OnDefaultLiquidFactorChanged(value); + + } + } + } + protected BtsrApplicationType _btsrapplicationtype; /// @@ -2461,6 +2490,15 @@ namespace Tango.BL.Entities RaisePropertyChanged(nameof(BtsrTensionError)); } + /// + /// Called when the DefaultLiquidFactor has changed. + /// + protected virtual void OnDefaultLiquidFactorChanged(Double defaultliquidfactor) + { + DefaultLiquidFactorChanged?.Invoke(this, defaultliquidfactor); + RaisePropertyChanged(nameof(DefaultLiquidFactor)); + } + /// /// Called when the BtsrApplicationType has changed. /// diff --git a/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs b/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs index 07b46869e..d44726994 100644 --- a/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs +++ b/Software/Visual_Studio/Tango.BL/Enumerations/LiquidTypes.cs @@ -19,6 +19,12 @@ namespace Tango.BL.Enumerations public enum LiquidTypes { + /// + /// (CT Orange) + /// + [Description("CT Orange")] + CTOrange = 230, + /// /// (Light Cyan) /// @@ -31,30 +37,144 @@ namespace Tango.BL.Enumerations [Description("Cyan")] Cyan = 0, + /// + /// (AM Black) + /// + [Description("AM Black")] + AMBlack = 450, + + /// + /// (HD Navy) + /// + [Description("HD Navy")] + HDNavy = 340, + + /// + /// (HD Orange) + /// + [Description("HD Orange")] + HDOrange = 330, + /// /// (Transparent Ink) /// [Description("Transparent Ink")] TransparentInk = 4, + /// + /// (TW Transparent Ink) + /// + [Description("TW Transparent Ink")] + TWTransparentInk = 100, + + /// + /// (AM Light Yellow) + /// + [Description("AM Light Yellow")] + AMLightYellow = 441, + + /// + /// (TW Cyan) + /// + [Description("TW Cyan")] + TWCyan = 110, + /// /// (Magenta) /// [Description("Magenta")] Magenta = 1, + /// + /// (HD Light Orange) + /// + [Description("HD Light Orange")] + HDLightOrange = 331, + + /// + /// (TW Light Violet) + /// + [Description("TW Light Violet")] + TWLightViolet = 151, + + /// + /// (C1 Yellow) + /// + [Description("C1 Yellow")] + C1Yellow = 135, + + /// + /// (CT Rubine) + /// + [Description("CT Rubine")] + CTRubine = 220, + + /// + /// (TW Light Yellow) + /// + [Description("TW Light Yellow")] + TWLightYellow = 131, + /// /// (Lubricant) /// [Description("Lubricant")] Lubricant = 5, + /// + /// (CT Navy) + /// + [Description("CT Navy")] + CTNavy = 240, + + /// + /// (TW Black) + /// + [Description("TW Black")] + TWBlack = 140, + + /// + /// (HD Light Rubine) + /// + [Description("HD Light Rubine")] + HDLightRubine = 321, + + /// + /// (HD Rubine) + /// + [Description("HD Rubine")] + HDRubine = 320, + + /// + /// (TW Yellow) + /// + [Description("TW Yellow")] + TWYellow = 130, + + /// + /// (AM Light Red) + /// + [Description("AM Light Red")] + AMLightRed = 421, + + /// + /// (TW Violet) + /// + [Description("TW Violet")] + TWViolet = 150, + /// /// (Light Magenta) /// [Description("Light Magenta")] LightMagenta = 8, + /// + /// (AM Blue) + /// + [Description("AM Blue")] + AMBlue = 410, + /// /// (Blue) /// @@ -109,23 +229,125 @@ namespace Tango.BL.Enumerations [Description("Violet")] Violet = 10, + /// + /// (AM Red) + /// + [Description("AM Red")] + AMRed = 420, + + /// + /// (CT Light Rubine) + /// + [Description("CT Light Rubine")] + CTLightRubine = 221, + + /// + /// (TW Light Cyan) + /// + [Description("TW Light Cyan")] + TWLightCyan = 111, + /// /// (Yellow) /// [Description("Yellow")] Yellow = 2, + /// + /// (HD Blue) + /// + [Description("HD Blue")] + HDBlue = 310, + + /// + /// (CT Light Blue) + /// + [Description("CT Light Blue")] + CTLightBlue = 211, + + /// + /// (C1 TI) + /// + [Description("C1 TI")] + C1TI = 105, + + /// + /// (TW Magenta) + /// + [Description("TW Magenta")] + TWMagenta = 120, + /// /// (Black) /// [Description("Black")] Black = 3, + /// + /// (AM Yellow) + /// + [Description("AM Yellow")] + AMYellow = 440, + + /// + /// (AM Light Orange) + /// + [Description("AM Light Orange")] + AMLightOrange = 431, + + /// + /// (AM Orange) + /// + [Description("AM Orange")] + AMOrange = 430, + + /// + /// (C1 Light Yellow) + /// + [Description("C1 Light Yellow")] + C1LightYellow = 136, + /// /// (Cleaner) /// [Description("Cleaner")] Cleaner = 6, + /// + /// (CT Light Orange) + /// + [Description("CT Light Orange")] + CTLightOrange = 231, + + /// + /// (TW Light Magenta) + /// + [Description("TW Light Magenta")] + TWLightMagenta = 121, + + /// + /// (AM Light Blue) + /// + [Description("AM Light Blue")] + AMLightBlue = 411, + + /// + /// (CT Blue) + /// + [Description("CT Blue")] + CTBlue = 210, + + /// + /// (HD Light Navy) + /// + [Description("HD Light Navy")] + HDLightNavy = 341, + + /// + /// (HD Light Blue) + /// + [Description("HD Light Blue")] + HDLightBlue = 311, + } } diff --git a/Software/Visual_Studio/Tango.DAL.Remote/DB/JOB_RUNS.cs b/Software/Visual_Studio/Tango.DAL.Remote/DB/JOB_RUNS.cs index c04183622..0948f293a 100644 --- a/Software/Visual_Studio/Tango.DAL.Remote/DB/JOB_RUNS.cs +++ b/Software/Visual_Studio/Tango.DAL.Remote/DB/JOB_RUNS.cs @@ -67,5 +67,42 @@ namespace Tango.DAL.Remote.DB public long LIGHT_RUBINE_QUANTITY { get; set; } public long NAVY_QUANTITY { get; set; } public long VIOLET_QUANTITY { get; set; } + public long TW_TRANSPARENT_INK_QUANTITY { get; set; } + public long C1_TI_QUANTITY { get; set; } + public long TW_CYAN_QUANTITY { get; set; } + public long TW_LIGHT_CYAN_QUANTITY { get; set; } + public long TW_MAGENTA_QUANTITY { get; set; } + public long TW_LIGHT_MAGENTA_QUANTITY { get; set; } + public long TW_YELLOW_QUANTITY { get; set; } + public long TW_LIGHT_YELLOW_QUANTITY { get; set; } + public long C1_YELLOW_QUANTITY { get; set; } + public long C1_LIGHT_YELLOW_QUANTITY { get; set; } + public long TW_BLACK_QUANTITY { get; set; } + public long TW_VIOLET_QUANTITY { get; set; } + public long TW_LIGHT_VIOLET_QUANTITY { get; set; } + public long CT_BLUE_QUANTITY { get; set; } + public long CT_LIGHT_BLUE_QUANTITY { get; set; } + public long CT_RUBINE_QUANTITY { get; set; } + public long CT_LIGHT_RUBINE_QUANTITY { get; set; } + public long CT_ORANGE_QUANTITY { get; set; } + public long CT_LIGHT_ORANGE_QUANTITY { get; set; } + public long CT_NAVY_QUANTITY { get; set; } + public long HD_BLUE_QUANTITY { get; set; } + public long HD_LIGHT_BLUE_QUANTITY { get; set; } + public long HD_RUBINE_QUANTITY { get; set; } + public long HD_LIGHT_RUBINE_QUANTITY { get; set; } + public long HD_ORANGE_QUANTITY { get; set; } + public long HD_LIGHT_ORANGE_QUANTITY { get; set; } + public long HD_NAVY_QUANTITY { get; set; } + public long HD_LIGHT_NAVY_QUANTITY { get; set; } + public long AM_BLUE_QUANTITY { get; set; } + public long AM_LIGHT_BLUE_QUANTITY { get; set; } + public long AM_RED_QUANTITY { get; set; } + public long AM_LIGHT_RED_QUANTITY { get; set; } + public long AM_ORANGE_QUANTITY { get; set; } + public long AM_LIGHT_ORANGE_QUANTITY { get; set; } + public long AM_YELLOW_QUANTITY { get; set; } + public long AM_LIGHT_YELLOW_QUANTITY { get; set; } + public long AM_BLACK_QUANTITY { get; set; } } } diff --git a/Software/Visual_Studio/Tango.DAL.Remote/DB/LIQUID_TYPES.cs b/Software/Visual_Studio/Tango.DAL.Remote/DB/LIQUID_TYPES.cs index 382efa9e9..197949188 100644 --- a/Software/Visual_Studio/Tango.DAL.Remote/DB/LIQUID_TYPES.cs +++ b/Software/Visual_Studio/Tango.DAL.Remote/DB/LIQUID_TYPES.cs @@ -37,6 +37,7 @@ namespace Tango.DAL.Remote.DB public bool IS_EXTRA_INK { get; set; } public bool IS_LIGHT_INK { get; set; } public int DARK_INK_CODE { get; set; } + public string DISPLAY_NAME { get; set; } [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")] public virtual ICollection CATS { get; set; } diff --git a/Software/Visual_Studio/Tango.DAL.Remote/DB/RML.cs b/Software/Visual_Studio/Tango.DAL.Remote/DB/RML.cs index b1f71c687..f6f747893 100644 --- a/Software/Visual_Studio/Tango.DAL.Remote/DB/RML.cs +++ b/Software/Visual_Studio/Tango.DAL.Remote/DB/RML.cs @@ -82,6 +82,7 @@ namespace Tango.DAL.Remote.DB public string BTSR_APPLICATION_TYPE_GUID { get; set; } public string BTSR_YARN_TYPE_GUID { get; set; } public double BTSR_TENSION_ERROR { get; set; } + public double DEFAULT_LIQUID_FACTOR { get; set; } public virtual BTSR_APPLICATION_TYPES BTSR_APPLICATION_TYPES { get; set; } public virtual BTSR_YARN_TYPES BTSR_YARN_TYPES { get; set; } diff --git a/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx b/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx index 4b7448f98..8ed5c4fed 100644 --- a/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx +++ b/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx @@ -832,6 +832,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -906,6 +943,7 @@ + @@ -1420,6 +1458,7 @@ + @@ -6529,6 +6568,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -6614,6 +6690,7 @@ + @@ -7031,6 +7108,7 @@ + @@ -10009,6 +10087,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -10125,6 +10240,7 @@ + @@ -10477,6 +10593,7 @@ + diff --git a/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx.diagram b/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx.diagram index b7c4620bd..99c611661 100644 --- a/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx.diagram +++ b/Software/Visual_Studio/Tango.DAL.Remote/DB/RemoteADO.edmx.diagram @@ -5,103 +5,103 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Software/Visual_Studio/Tango.PMR/ColorLab/LiquidType.cs b/Software/Visual_Studio/Tango.PMR/ColorLab/LiquidType.cs index 94d2f20b3..f40415159 100644 --- a/Software/Visual_Studio/Tango.PMR/ColorLab/LiquidType.cs +++ b/Software/Visual_Studio/Tango.PMR/ColorLab/LiquidType.cs @@ -22,14 +22,28 @@ namespace Tango.PMR.ColorLab { static LiquidTypeReflection() { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( - "ChBMaXF1aWRUeXBlLnByb3RvEhJUYW5nby5QTVIuQ29sb3JMYWIqhQIKCkxp", + "ChBMaXF1aWRUeXBlLnByb3RvEhJUYW5nby5QTVIuQ29sb3JMYWIq4gYKCkxp", "cXVpZFR5cGUSCAoEQ3lhbhAAEgsKB01hZ2VudGEQARIKCgZZZWxsb3cQAhIJ", "CgVCbGFjaxADEhIKDlRyYW5zcGFyZW50SW5rEAQSDQoJTHVicmljYW50EAUS", "CwoHQ2xlYW5lchAGEg0KCUxpZ2h0Q3lhbhAHEhAKDExpZ2h0TWFnZW50YRAI", "Eg8KC0xpZ2h0WWVsbG93EAkSCgoGVmlvbGV0EAoSCAoEQmx1ZRALEg0KCUxp", "Z2h0Qmx1ZRAMEgoKBk9yYW5nZRANEg8KC0xpZ2h0T3JhbmdlEA4SCgoGUnVi", - "aW5lEA8SDwoLTGlnaHRSdWJpbmUQEBIICgROYXZ5EBFCHgocY29tLnR3aW5l", - "LnRhbmdvLnBtci5jb2xvcmxhYmIGcHJvdG8z")); + "aW5lEA8SDwoLTGlnaHRSdWJpbmUQEBIICgROYXZ5EBESFAoQVFdUcmFuc3Bh", + "cmVudEluaxBkEggKBEMxVEkQaRIKCgZUV0N5YW4QbhIPCgtUV0xpZ2h0Q3lh", + "bhBvEg0KCVRXTWFnZW50YRB4EhIKDlRXTGlnaHRNYWdlbnRhEHkSDQoIVFdZ", + "ZWxsb3cQggESEgoNVFdMaWdodFllbGxvdxCDARINCghDMVllbGxvdxCHARIS", + "Cg1DMUxpZ2h0WWVsbG93EIgBEgwKB1RXQmxhY2sQjAESDQoIVFdWaW9sZXQQ", + "lgESEgoNVFdMaWdodFZpb2xldBCXARILCgZDVEJsdWUQ0gESEAoLQ1RMaWdo", + "dEJsdWUQ0wESDQoIQ1RSdWJpbmUQ3AESEgoNQ1RMaWdodFJ1YmluZRDdARIN", + "CghDVE9yYW5nZRDmARISCg1DVExpZ2h0T3JhbmdlEOcBEgsKBkNUTmF2eRDw", + "ARILCgZIREJsdWUQtgISEAoLSERMaWdodEJsdWUQtwISDQoISERSdWJpbmUQ", + "wAISEgoNSERMaWdodFJ1YmluZRDBAhINCghIRE9yYW5nZRDKAhISCg1IRExp", + "Z2h0T3JhbmdlEMsCEgsKBkhETmF2eRDUAhIQCgtIRExpZ2h0TmF2eRDVAhIL", + "CgZBTUJsdWUQmgMSEAoLQU1MaWdodEJsdWUQmwMSCgoFQU1SZWQQpAMSDwoK", + "QU1MaWdodFJlZBClAxINCghBTU9yYW5nZRCuAxISCg1BTUxpZ2h0T3Jhbmdl", + "EK8DEg0KCEFNWWVsbG93ELgDEhIKDUFNTGlnaHRZZWxsb3cQuQMSDAoHQU1C", + "bGFjaxDCA0IeChxjb20udHdpbmUudGFuZ28ucG1yLmNvbG9ybGFiYgZwcm90", + "bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Tango.PMR.ColorLab.LiquidType), }, null)); @@ -57,6 +71,43 @@ namespace Tango.PMR.ColorLab { [pbr::OriginalName("Rubine")] Rubine = 15, [pbr::OriginalName("LightRubine")] LightRubine = 16, [pbr::OriginalName("Navy")] Navy = 17, + [pbr::OriginalName("TWTransparentInk")] TwtransparentInk = 100, + [pbr::OriginalName("C1TI")] C1Ti = 105, + [pbr::OriginalName("TWCyan")] Twcyan = 110, + [pbr::OriginalName("TWLightCyan")] TwlightCyan = 111, + [pbr::OriginalName("TWMagenta")] Twmagenta = 120, + [pbr::OriginalName("TWLightMagenta")] TwlightMagenta = 121, + [pbr::OriginalName("TWYellow")] Twyellow = 130, + [pbr::OriginalName("TWLightYellow")] TwlightYellow = 131, + [pbr::OriginalName("C1Yellow")] C1Yellow = 135, + [pbr::OriginalName("C1LightYellow")] C1LightYellow = 136, + [pbr::OriginalName("TWBlack")] Twblack = 140, + [pbr::OriginalName("TWViolet")] Twviolet = 150, + [pbr::OriginalName("TWLightViolet")] TwlightViolet = 151, + [pbr::OriginalName("CTBlue")] Ctblue = 210, + [pbr::OriginalName("CTLightBlue")] CtlightBlue = 211, + [pbr::OriginalName("CTRubine")] Ctrubine = 220, + [pbr::OriginalName("CTLightRubine")] CtlightRubine = 221, + [pbr::OriginalName("CTOrange")] Ctorange = 230, + [pbr::OriginalName("CTLightOrange")] CtlightOrange = 231, + [pbr::OriginalName("CTNavy")] Ctnavy = 240, + [pbr::OriginalName("HDBlue")] Hdblue = 310, + [pbr::OriginalName("HDLightBlue")] HdlightBlue = 311, + [pbr::OriginalName("HDRubine")] Hdrubine = 320, + [pbr::OriginalName("HDLightRubine")] HdlightRubine = 321, + [pbr::OriginalName("HDOrange")] Hdorange = 330, + [pbr::OriginalName("HDLightOrange")] HdlightOrange = 331, + [pbr::OriginalName("HDNavy")] Hdnavy = 340, + [pbr::OriginalName("HDLightNavy")] HdlightNavy = 341, + [pbr::OriginalName("AMBlue")] Amblue = 410, + [pbr::OriginalName("AMLightBlue")] AmlightBlue = 411, + [pbr::OriginalName("AMRed")] Amred = 420, + [pbr::OriginalName("AMLightRed")] AmlightRed = 421, + [pbr::OriginalName("AMOrange")] Amorange = 430, + [pbr::OriginalName("AMLightOrange")] AmlightOrange = 431, + [pbr::OriginalName("AMYellow")] Amyellow = 440, + [pbr::OriginalName("AMLightYellow")] AmlightYellow = 441, + [pbr::OriginalName("AMBlack")] Amblack = 450, } #endregion diff --git a/Software/Visual_Studio/Tango.PMR/Printing/DispenserLiquidType.cs b/Software/Visual_Studio/Tango.PMR/Printing/DispenserLiquidType.cs index fb3b5820c..8066298cf 100644 --- a/Software/Visual_Studio/Tango.PMR/Printing/DispenserLiquidType.cs +++ b/Software/Visual_Studio/Tango.PMR/Printing/DispenserLiquidType.cs @@ -23,13 +23,27 @@ namespace Tango.PMR.Printing { byte[] descriptorData = global::System.Convert.FromBase64String( string.Concat( "ChlEaXNwZW5zZXJMaXF1aWRUeXBlLnByb3RvEhJUYW5nby5QTVIuUHJpbnRp", - "bmcqjgIKE0Rpc3BlbnNlckxpcXVpZFR5cGUSCAoEQ3lhbhAAEgsKB01hZ2Vu", + "bmcq6wYKE0Rpc3BlbnNlckxpcXVpZFR5cGUSCAoEQ3lhbhAAEgsKB01hZ2Vu", "dGEQARIKCgZZZWxsb3cQAhIJCgVCbGFjaxADEhIKDlRyYW5zcGFyZW50SW5r", "EAQSDQoJTHVicmljYW50EAUSCwoHQ2xlYW5lchAGEg0KCUxpZ2h0Q3lhbhAH", "EhAKDExpZ2h0TWFnZW50YRAIEg8KC0xpZ2h0WWVsbG93EAkSCgoGVmlvbGV0", "EAoSCAoEQmx1ZRALEg0KCUxpZ2h0Qmx1ZRAMEgoKBk9yYW5nZRANEg8KC0xp", "Z2h0T3JhbmdlEA4SCgoGUnViaW5lEA8SDwoLTGlnaHRSdWJpbmUQEBIICgRO", - "YXZ5EBFCHgocY29tLnR3aW5lLnRhbmdvLnBtci5wcmludGluZ2IGcHJvdG8z")); + "YXZ5EBESFAoQVFdUcmFuc3BhcmVudEluaxBkEggKBEMxVEkQaRIKCgZUV0N5", + "YW4QbhIPCgtUV0xpZ2h0Q3lhbhBvEg0KCVRXTWFnZW50YRB4EhIKDlRXTGln", + "aHRNYWdlbnRhEHkSDQoIVFdZZWxsb3cQggESEgoNVFdMaWdodFllbGxvdxCD", + "ARINCghDMVllbGxvdxCHARISCg1DMUxpZ2h0WWVsbG93EIgBEgwKB1RXQmxh", + "Y2sQjAESDQoIVFdWaW9sZXQQlgESEgoNVFdMaWdodFZpb2xldBCXARILCgZD", + "VEJsdWUQ0gESEAoLQ1RMaWdodEJsdWUQ0wESDQoIQ1RSdWJpbmUQ3AESEgoN", + "Q1RMaWdodFJ1YmluZRDdARINCghDVE9yYW5nZRDmARISCg1DVExpZ2h0T3Jh", + "bmdlEOcBEgsKBkNUTmF2eRDwARILCgZIREJsdWUQtgISEAoLSERMaWdodEJs", + "dWUQtwISDQoISERSdWJpbmUQwAISEgoNSERMaWdodFJ1YmluZRDBAhINCghI", + "RE9yYW5nZRDKAhISCg1IRExpZ2h0T3JhbmdlEMsCEgsKBkhETmF2eRDUAhIQ", + "CgtIRExpZ2h0TmF2eRDVAhILCgZBTUJsdWUQmgMSEAoLQU1MaWdodEJsdWUQ", + "mwMSCgoFQU1SZWQQpAMSDwoKQU1MaWdodFJlZBClAxINCghBTU9yYW5nZRCu", + "AxISCg1BTUxpZ2h0T3JhbmdlEK8DEg0KCEFNWWVsbG93ELgDEhIKDUFNTGln", + "aHRZZWxsb3cQuQMSDAoHQU1CbGFjaxDCA0IeChxjb20udHdpbmUudGFuZ28u", + "cG1yLnByaW50aW5nYgZwcm90bzM=")); descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData, new pbr::FileDescriptor[] { }, new pbr::GeneratedClrTypeInfo(new[] {typeof(global::Tango.PMR.Printing.DispenserLiquidType), }, null)); @@ -57,6 +71,43 @@ namespace Tango.PMR.Printing { [pbr::OriginalName("Rubine")] Rubine = 15, [pbr::OriginalName("LightRubine")] LightRubine = 16, [pbr::OriginalName("Navy")] Navy = 17, + [pbr::OriginalName("TWTransparentInk")] TwtransparentInk = 100, + [pbr::OriginalName("C1TI")] C1Ti = 105, + [pbr::OriginalName("TWCyan")] Twcyan = 110, + [pbr::OriginalName("TWLightCyan")] TwlightCyan = 111, + [pbr::OriginalName("TWMagenta")] Twmagenta = 120, + [pbr::OriginalName("TWLightMagenta")] TwlightMagenta = 121, + [pbr::OriginalName("TWYellow")] Twyellow = 130, + [pbr::OriginalName("TWLightYellow")] TwlightYellow = 131, + [pbr::OriginalName("C1Yellow")] C1Yellow = 135, + [pbr::OriginalName("C1LightYellow")] C1LightYellow = 136, + [pbr::OriginalName("TWBlack")] Twblack = 140, + [pbr::OriginalName("TWViolet")] Twviolet = 150, + [pbr::OriginalName("TWLightViolet")] TwlightViolet = 151, + [pbr::OriginalName("CTBlue")] Ctblue = 210, + [pbr::OriginalName("CTLightBlue")] CtlightBlue = 211, + [pbr::OriginalName("CTRubine")] Ctrubine = 220, + [pbr::OriginalName("CTLightRubine")] CtlightRubine = 221, + [pbr::OriginalName("CTOrange")] Ctorange = 230, + [pbr::OriginalName("CTLightOrange")] CtlightOrange = 231, + [pbr::OriginalName("CTNavy")] Ctnavy = 240, + [pbr::OriginalName("HDBlue")] Hdblue = 310, + [pbr::OriginalName("HDLightBlue")] HdlightBlue = 311, + [pbr::OriginalName("HDRubine")] Hdrubine = 320, + [pbr::OriginalName("HDLightRubine")] HdlightRubine = 321, + [pbr::OriginalName("HDOrange")] Hdorange = 330, + [pbr::OriginalName("HDLightOrange")] HdlightOrange = 331, + [pbr::OriginalName("HDNavy")] Hdnavy = 340, + [pbr::OriginalName("HDLightNavy")] HdlightNavy = 341, + [pbr::OriginalName("AMBlue")] Amblue = 410, + [pbr::OriginalName("AMLightBlue")] AmlightBlue = 411, + [pbr::OriginalName("AMRed")] Amred = 420, + [pbr::OriginalName("AMLightRed")] AmlightRed = 421, + [pbr::OriginalName("AMOrange")] Amorange = 430, + [pbr::OriginalName("AMLightOrange")] AmlightOrange = 431, + [pbr::OriginalName("AMYellow")] Amyellow = 440, + [pbr::OriginalName("AMLightYellow")] AmlightYellow = 441, + [pbr::OriginalName("AMBlack")] Amblack = 450, } #endregion diff --git a/Software/Visual_Studio/Utilities/Tango.Telemetry.Tester.IOT.CLI/Program.cs b/Software/Visual_Studio/Utilities/Tango.Telemetry.Tester.IOT.CLI/Program.cs index 07d301f3d..4f5e2731a 100644 --- a/Software/Visual_Studio/Utilities/Tango.Telemetry.Tester.IOT.CLI/Program.cs +++ b/Software/Visual_Studio/Utilities/Tango.Telemetry.Tester.IOT.CLI/Program.cs @@ -42,16 +42,16 @@ namespace Tango.Telemetry.Tester.IOT.CLI //publisher.RegisterSource(new JobRunsTestSource()); //publisher.RegisterSource(new DiagnosticsTestSource()); - publisher.RegisterSource(new EventsTestSource()); + //publisher.RegisterSource(new EventsTestSource()); publisher.RegisterSource(new MachineStatusTestSource()); - publisher.RegisterSource(new WiresTestSource()); + //publisher.RegisterSource(new WiresTestSource()); var logsSource = new TelemetryLogsStreamingSource(); logsSource.Config.Categories.Add(LogCategory.Info); - publisher.RegisterSource(logsSource); - publisher.RegisterSource(new TelemetryLogsStreamingSource()); - publisher.RegisterSource(new JobStatusTestSource()); + //publisher.RegisterSource(logsSource); + //publisher.RegisterSource(new TelemetryLogsStreamingSource()); + //publisher.RegisterSource(new JobStatusTestSource()); publisher.RegisterDestination(new TelemetryAzureHubDestination("HostName=iot-twine-dev-weu.azure-devices.net;DeviceId=telemetry-dev-01;SharedAccessKey=cZhCMhiVL+TF7p13fpX+lFmyxoy8ZqCkbxUwumWw18Q=")); //publisher.RegisterDestination(new TelemetryMqttDestination("Telemetry MQTT")); @@ -117,7 +117,7 @@ namespace Tango.Telemetry.Tester.IOT.CLI Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine("One or more destinations failed to receive the package."); } - else + else if (e.PublishResult.DestinationsResults.All(x => x.Status == TelemetryPublishResult.DestinationStatus.Passed)) { Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine($"Package {_counter++} successfully published."); @@ -300,7 +300,7 @@ namespace Tango.Telemetry.Tester.IOT.CLI { Task.Factory.StartNew(() => { - for (int i = 10; i < 20; i++) + for (int i = 0; i < 10000; i++) { TelemetryAvailable?.Invoke(this, new TelemetryAvailableEventArgs() { -- cgit v1.3.1