Merge branch 'dev_cyy' into dev_realse_cyy

hongji.li

2023-09-25 d4208b18ee7c6be4b5ebb26e5e942cb24d9f8bf4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
Quintiq file version 2.0
#parent: #root
StaticMethod ValidateInput (
  output String feedback_o,
  output String sanitycheckfeedback_o,
  Unit unit,
  DateTime start,
  Real mincapacity,
  Real maxcapacity,
  Real maxloadpercentage,
  Number nrofunitsopen,
  UnitCapacity unitcapacity,
  Boolean checkunique
) declarative remote as Boolean
{
  Description: 'Check for input obtained from UI.'
  TextBody:
  [*
    // Validate input for UnitCapacity
    feedback_o := '';
    sanitycheckfeedback_o := '';
    gp := guard( unit.MacroPlan().GlobalParameters_MP(), null( GlobalParameters_MP ) );
    
    // Check if the unit is provided
    if( isnull( unit ) )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsNullUnit();
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataWarning();
    }
    // Check if the unit capacity is unique.
    // Check if the primary keys are unique
    else if( checkunique
             and not UnitCapacity::IsPrimaryKeysUnique( unit, start, unitcapacity ) )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsNotUnique();
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Check if the min capacity is larger than zero
    else if( mincapacity < 0.0 )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsNegativeMinCapacity( mincapacity );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Check if the min capacity is within the allowed range
    else if( mincapacity <> 0
             and not GlobalParameters_MP::GetIsValueWithinRange( mincapacity,
                                                                 gp.AbsoluteUpperLimit(),
                                                                 gp.AbsoluteLowerLimit() ) )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_InvalidMinCapacity( mincapacity,
                                                                                    gp.AbsoluteUpperLimit(),
                                                                                    gp.AbsoluteLowerLimit() );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Check if the max capacity is larger than zero
    else if( maxcapacity < 0.0 )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsNegativeMaxCapacity( maxcapacity );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Check if the max capacity is within the allowed range
    else if( maxcapacity <> 0
             and not GlobalParameters_MP::GetIsValueWithinRange( maxcapacity,
                                                                 gp.AbsoluteUpperLimit(),
                                                                 gp.AbsoluteLowerLimit() ) )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_InvalidMaxCapacity( maxcapacity,
                                                                                    gp.AbsoluteUpperLimit(),
                                                                                    gp.AbsoluteLowerLimit() );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Check if the min capacity is less than or equals to max capacity
    else if( mincapacity > maxcapacity )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsMaxCapacityLessThanMinCapacity( maxcapacity, mincapacity );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Check if the max load percentage is larger than zero
    else if( maxloadpercentage < 0 )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsNegativeMaximumLoadPercentage( maxloadpercentage );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Just to make sure max load percentage is not too large to be consistent with unit availability.
    else if( maxloadpercentage > 1000 )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsMaximumLoadPercentageTooLarge( maxloadpercentage );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    // Check if the number of units open is larger than zero
    else if( nrofunitsopen < 0 )
    {
      feedback_o := Translations::MP_UnitCapacity_ValidateInput_IsNegativeNrOfUnitsOpen( nrofunitsopen );
      sanitycheckfeedback_o := SanityCheckCategoryLevel::GetSanityCheckCategoryDataIssue();
    }
    
    // Add instance text if any of the preconditions above are violated
    if( feedback_o <> '' )
    {
      unitname := MacroPlan::GetSubstituteName( guard( unit.Name(), '' ) );
      feedback_o :=  SanityCheckMessage::GetFormattedMessage( Translations::MP_UnitCapacity_Instance( unitname, start ),
                                                              feedback_o );
    }
    
    return feedback_o = '';
  *]
}