﻿<?xml version="1.0" encoding="utf-8" ?>
<!-- Spring Manged Objects -->
<objects xmlns="http://www.springframework.net"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:v="http://www.springframework.net/validation"
         xsi:schemaLocation="http://www.springframework.net http://www.springframework.net/xsd/spring-objects.xsd
                             http://www.springframework.net Xsd/spring-validation-1.3.xsd" >

  <description>
    Spring Validation
    See this for more info:
    http://www.springframework.net/doc-latest/reference/html/validation.html
  </description>

  <v:group id="processEmissionValidationRules">
    <v:ref name="processEmissionValidationRulesGroup" context="ProcessEmission" />
  </v:group>


  <v:group id="processEmissionImportValidationRules">
    <!-- Run through Process Emissions and validiate if they are even eligible for import -->
    <v:validator test="ProcessEmissions" type="Sleis.Validation.Spring.ListValidator" when="ProcessEmissions != null">
      <v:property name="ProviderFormat" value="ProcessEmissions[{0}]." />
      <v:property name="Validator" ref="importProcessEmissionGroupValidation" />
    </v:validator>

    <!-- Validates the shared process emissions rules that exists for add/edit, import, and report validation/submission -->
    <v:validator test="ProcessEmissions" type="Sleis.Validation.Spring.ListValidator" when="ProcessEmissions != null">
      <v:property name="ProviderFormat" value="ProcessEmissions[{0}]." />
      <v:property name="Validator" ref="processEmissionValidationRulesGroup" />
    </v:validator>

    <!-- Validates the shared process emissions, emissions rules that exists for add/edit, import, and report validation/submission -->
    <v:validator test="Emissions" type="Sleis.Validation.Spring.ListValidator" when="Emissions != null">
      <v:property name="ProviderFormat" value="Emissions[{0}]." />
      <v:property name="Validator" ref="processEmissionsPollutantValidationRules" />
    </v:validator>
  </v:group>


  <!--Validate process emissions eligibility for import-->
  <v:group id ="importProcessEmissionGroupValidation">
    <!-- Do not allow process emissions with parent emissions units that have been shutdown in current reporting year or earlier -->
    <v:condition test="UnitProcess.EmissionUnit.StatusEffectiveDate.Year &gt; #Report.Number" when="UnitProcess.EmissionUnit.StatusCode == 'TS' or UnitProcess.EmissionUnit.StatusCode == 'PS'">
      <v:message id="valid.pe.import.invalid.emission.unit" providers="ProcessEmission">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!-- Do not allow process emissions with unit process last/final inventory year less than current reporting year -->
    <v:condition test="UnitProcess.LastEmissionsYear &gt;= #Report.Number" when="UnitProcess.LastEmissionsYear != null">
      <v:message id="valid.pe.import.invalid.unit.process" providers="ProcessEmission">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
  </v:group>


  <!--
    Do not validate process emissions with parent emissions units that have been shutdown in current reporting year or earlier
    Do not validate process emissions with unit process last/final inventory year less than current reporting year
  -->
  <v:group id="processEmissionValidationRulesGroup" when="(IsReported == true or IsReported == null)
           and ((UnitProcess.EmissionUnit.StatusCode == 'OP') or (UnitProcess.EmissionUnit.StatusCode == 'PS' and UnitProcess.EmissionUnit.StatusEffectiveDate.Year &gt; #Report.Number) or (UnitProcess.EmissionUnit.StatusCode == 'TS' and UnitProcess.EmissionUnit.StatusEffectiveDate.Year &gt; #Report.Number))
           and ((UnitProcess.LastEmissionsYear == null) or (UnitProcess.LastEmissionsYear &gt;= #Report.Number))">
    <!--<v:ref name="monthlyThroughputValidationRules"/>-->

    <!-- Process Rate/Throughput Related Validation-->
    <v:validator test="Value" type="Sleis.Validation.Spring.NullableDecimalValidator" when ="(#this is T(Sleis.Models.PublicProcessEmission)) and ('${app.enable.monthly.throughput.totals}' == 'false')">
      <v:property name="MessageId" value="valid.pe.annualthroughput.required"/>
      <v:property name="Provider" value="ProcessEmission.Value"/>
    </v:validator>
    <!-- NOTE: This does leave the possibility that the sum of the monthly values exceeds the (P,S) of 25,10 -->
    <v:validator id="processEmissionValueValidator" test="Value.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="'${app.enable.monthly.throughput.totals}' == 'false' and Value != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.format" providers="ProcessEmission.Value">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>

    <v:required test="ValueUomCode" when="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:message id="valid.pe.uomcode.required" providers="ProcessEmission.ValueUomCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>
    <v:required test="ValueUomCode" when="Value != null">
      <v:message id="valid.pe.uomcode.required.when" providers="ProcessEmission.ValueUomCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>

    <v:required test="ValueTypeCode" when="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:message id="valid.pe.valuetypecode.required" providers="ProcessEmission.ValueTypeCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>
    <v:required test="ValueTypeCode" when="Value != null">
      <v:message id="valid.pe.valuetypecode.required.when" providers="ProcessEmission.ValueTypeCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>

    <v:required test="MaterialTypeCode" when="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:message id="valid.pe.materialtypecode.required" providers="ProcessEmission.MaterialTypeCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>
    <v:required test="MaterialTypeCode" when="Value != null">
      <v:message id="valid.pe.materialtypecode.required.when" providers="ProcessEmission.MaterialTypeCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>


    <!--Supplemental Calculation Parameters-->
    <!--
    <v:validator test="AshContentPercent" type="Sleis.Validation.Spring.NullableDecimalValidator"">
      <v:property name="MessageId" value="valid.pe.ashcontentpercent.required"/>
      <v:property name="Provider" value="ProcessEmission.AshContentPercent"/>
    </v:validator>
    -->
    <v:validator id="processEmissionAshContentPercentValidator" test="AshContentPercent.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="AshContentPercent != null">
      <v:property name="PrecisionFormat" value="8,5" />
      <v:message id="valid.pe.ashcontentpercent.format" providers="ProcessEmission.AshContentPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="AshContentPercent &gt;= .01 and AshContentPercent &lt;= 30" when="AshContentPercent != null">
      <v:message id="valid.pe.ashcontentpercent.range" providers="ProcessEmission.AshContentPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!--
    <v:validator test="SulfurContentPercent" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.sulfurcontentpercent.required"/>
      <v:property name="Provider" value="ProcessEmission.SulfurContentPercent"/>
    </v:validator>
    -->
    <v:validator id="processEmissionSulfurContentPercentValidator" test="SulfurContentPercent.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="SulfurContentPercent != null">
      <v:property name="PrecisionFormat" value="8,5" />
      <v:message id="valid.pe.sulfurcontentpercent.format" providers="ProcessEmission.SulfurContentPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="SulfurContentPercent &gt;= .00001 and SulfurContentPercent &lt;= 10" when="SulfurContentPercent != null">
      <v:message id="valid.pe.sulfurcontentpercent.range" providers="ProcessEmission.SulfurContentPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!--
    <v:validator test="HeatContent" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.heatcontent.required"/>
      <v:property name="Provider" value="ProcessEmission.HeatContent"/>
    </v:validator>
    -->
    <v:validator id="processEmissionHeatContentValidator" test="HeatContent.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="HeatContent != null">
      <v:property name="PrecisionFormat" value="15,5" />
      <v:message id="valid.pe.heatcontent.format" providers="ProcessEmission.HeatContent">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="HeatContent &gt;= 0 and HeatContent &lt;= 1000000" when="HeatContent != null">
      <v:message id="valid.pe.heatcontent.range" providers="ProcessEmission.HeatContent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>


    <!--v:required test="Comment">
      <v:message id="valid.pe.comment.required" providers="ProcessEmission.Comment">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required-->
    <v:regex test="Comment" expression="^[\s\S]{0,4000}$" when="Comment != null">
      <v:message id="valid.pe.comment.length" providers="ProcessEmission.Comment">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:regex>


    <!-- OPERATIONS - OPERATING HOURS, DAYS, WEEKS, TOTAL HOURS -->
    <!--
    <v:validator test="AvgHoursPerDay" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.avghoursperday.required"/>
      <v:property name="Provider" value="ProcessEmission.AvgHoursPerDay"/>
    </v:validator>
    -->
    <!--
    <v:validator test="AvgHoursPerDay" type="Sleis.Validation.Spring.NullableDecimalValidator" when="Value != null and Value > 0">
      <v:property name="MessageId" value="valid.pe.avghoursperday.required.when"/>
      <v:property name="Provider" value="ProcessEmission.AvgHoursPerDay"/>
    </v:validator>
    -->
    <v:validator id="AvgHoursPerDay" test="AvgHoursPerDay.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="AvgHoursPerDay != null">
      <v:property name="PrecisionFormat" value="3,1" />
      <v:message id="valid.pe.avghoursperday.format" providers="ProcessEmission.AvgHoursPerDay">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="AvgHoursPerDay &gt;= 0 and AvgHoursPerDay &lt;= 24" when="AvgHoursPerDay != null">
      <v:message id="valid.pe.avghoursperday.range" providers="ProcessEmission.AvgHoursPerDay">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!--
    <v:validator test="AvgDaysPerWeek" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.avgdaysperweek.required"/>
      <v:property name="Provider" value="ProcessEmission.AvgDaysPerWeek"/>
    </v:validator>
    -->
    <!--
    <v:validator test="AvgDaysPerWeek" type="Sleis.Validation.Spring.NullableDecimalValidator" when ="Value != null and Value > 0 ">
      <v:property name="MessageId" value="valid.pe.avgdaysperweek.required.when"/>
      <v:property name="Provider" value="ProcessEmission.AvgDaysPerWeek"/>
    </v:validator>
    -->
    <v:validator id="AvgDaysPerWeek" test="AvgDaysPerWeek.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="AvgDaysPerWeek != null">
      <v:property name="PrecisionFormat" value="2,1" />
      <v:message id="valid.pe.avgdaysperweek.format" providers="ProcessEmission.AvgDaysPerWeek">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="AvgDaysPerWeek &gt;= 0 and AvgDaysPerWeek &lt;= 7" when="AvgDaysPerWeek != null">
      <v:message id="valid.pe.avgdaysperweek.range" providers="ProcessEmission.AvgDaysPerWeek">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!--
    <v:validator test="AvgWeeksPerPeriod" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.avgweeksperperiod.required"/>
      <v:property name="Provider" value="ProcessEmission.AvgWeeksPerPeriod"/>
    </v:validator>
    -->
    <!--
    <v:validator test="AvgWeeksPerPeriod" type="Sleis.Validation.Spring.NullableDecimalValidator" when ="Value != null and Value > 0 ">
      <v:property name="MessageId" value="valid.pe.avgweeksperperiod.required.when"/>
      <v:property name="Provider" value="ProcessEmission.AvgWeeksPerPeriod"/>
    </v:validator>
    -->
    <v:validator id="AvgWeeksPerPeriod" test="AvgWeeksPerPeriod.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="AvgWeeksPerPeriod != null">
      <v:property name="PrecisionFormat" value="3,1" />
      <v:message id="valid.pe.avgweeksperperiod.format" providers="ProcessEmission.AvgWeeksPerPeriod">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="AvgWeeksPerPeriod &gt;= 0 and AvgWeeksPerPeriod &lt;= 52" when="AvgWeeksPerPeriod != null">
      <v:message id="valid.pe.avgweeksperperiod.range" providers="ProcessEmission.AvgWeeksPerPeriod">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <v:validator test="ActualHoursPerPeriod" type="Sleis.Validation.Spring.NullableDecimalValidator" when ="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:property name="MessageId" value="valid.pe.actualhoursperperiod.required"/>
      <v:property name="Provider" value="ProcessEmission.ActualHoursPerPeriod"/>
    </v:validator>
    <!-- Require only if Annual Thhroughout provided -->
    <!--
    <v:validator test="ActualHoursPerPeriod" type="Sleis.Validation.Spring.NullableDecimalValidator" when ="Value != null and Value > 0">
      <v:property name="MessageId" value="valid.pe.actualhoursperperiod.required.when"/>
      <v:property name="Provider" value="ProcessEmission.ActualHoursPerPeriod"/>
    </v:validator>
    -->
    <v:validator id="ActualHoursPerPeriod" test="ActualHoursPerPeriod.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="ActualHoursPerPeriod != null">
      <v:property name="PrecisionFormat" value="5,1" />
      <v:message id="valid.pe.actualhoursperperiod.format" providers="ProcessEmission.ActualHoursPerPeriod">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="ActualHoursPerPeriod &gt;= 0 and ActualHoursPerPeriod &lt;= 8789" when="ActualHoursPerPeriod != null">
      <v:message id="valid.pe.actualhoursperperiod.range" providers="ProcessEmission.ActualHoursPerPeriod">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>


    <!-- OPERATIONS - SEASONAL % -->
    <v:validator test="WinterActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:property name="MessageId" value="valid.pe.winteractivitypercent.required"/>
      <v:property name="Provider" value="ProcessEmission.WinterActivityPercent"/>
    </v:validator>
    <v:validator id="WinterActivityPercent" test="WinterActivityPercent.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="WinterActivityPercent != null">
      <v:property name="PrecisionFormat" value="3,1" />
      <v:message id="valid.pe.winteractivitypercent.format" providers="ProcessEmission.WinterActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="WinterActivityPercent &gt;= 0 and WinterActivityPercent &lt;= 100" when="WinterActivityPercent != null">
      <v:message id="valid.pe.winteractivitypercent.range" providers="ProcessEmission.WinterActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <v:validator test="SpringActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:property name="MessageId" value="valid.pe.springactivitypercent.required"/>
      <v:property name="Provider" value="ProcessEmission.SpringActivityPercent"/>
    </v:validator>
    <v:validator id="SpringActivityPercent" test="SpringActivityPercent.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="SpringActivityPercent != null">
      <v:property name="PrecisionFormat" value="3,1" />
      <v:message id="valid.pe.springactivitypercent.format" providers="ProcessEmission.SpringActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="SpringActivityPercent &gt;= 0 and SpringActivityPercent &lt;= 100" when="SpringActivityPercent != null">
      <v:message id="valid.pe.springactivitypercent.range" providers="ProcessEmission.SpringActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <v:validator test="SummerActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:property name="MessageId" value="valid.pe.summeractivitypercent.required"/>
      <v:property name="Provider" value="ProcessEmission.SummerActivityPercent"/>
    </v:validator>
    <v:validator id="SummerActivityPercent" test="SummerActivityPercent.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="SummerActivityPercent != null">
      <v:property name="PrecisionFormat" value="3,1" />
      <v:message id="valid.pe.summeractivitypercent.format" providers="ProcessEmission.SummerActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="SummerActivityPercent &gt;= 0 and SummerActivityPercent &lt;= 100" when="SummerActivityPercent != null">
      <v:message id="valid.pe.summeractivitypercent.range" providers="ProcessEmission.SummerActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <v:validator test="FallActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="#this is T(Sleis.Models.PublicProcessEmission)">
      <v:property name="MessageId" value="valid.pe.fallactivitypercent.required"/>
      <v:property name="Provider" value="ProcessEmission.FallActivityPercent"/>
    </v:validator>
    <v:validator id="FallActivityPercent" test="FallActivityPercent.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="FallActivityPercent != null">
      <v:property name="PrecisionFormat" value="3,1" />
      <v:message id="valid.pe.fallactivitypercent.format" providers="ProcessEmission.FallActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <v:condition test ="FallActivityPercent &gt;= 0 and FallActivityPercent &lt;= 100" when="FallActivityPercent != null">
      <v:message id="valid.pe.fallactivitypercent.range" providers="ProcessEmission.FallActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>


    <!-- If seasonal values not required above, require all seasonal values if any seasonal value entered. comment out if required above -->
    <v:validator test="WinterActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="(SpringActivityPercent != null or SummerActivityPercent != null or FallActivityPercent != null)">
      <v:property name="MessageId" value="valid.pe.winteractivitypercent.required.when"/>
      <v:property name="Provider" value="ProcessEmission.WinterActivityPercent"/>
    </v:validator>

    <v:validator test="SpringActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="(WinterActivityPercent != null or SummerActivityPercent != null or FallActivityPercent != null)">
      <v:property name="MessageId" value="valid.pe.springactivitypercent.required.when"/>
      <v:property name="Provider" value="ProcessEmission.SpringActivityPercent"/>
    </v:validator>

    <v:validator test="SummerActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="(SpringActivityPercent != null or WinterActivityPercent != null or FallActivityPercent != null)">
      <v:property name="MessageId" value="valid.pe.summeractivitypercent.required.when"/>
      <v:property name="Provider" value="ProcessEmission.SummerActivityPercent"/>
    </v:validator>

    <v:validator test="FallActivityPercent" type="Sleis.Validation.Spring.NullableDecimalValidator" when="(SpringActivityPercent != null or SummerActivityPercent != null or WinterActivityPercent != null)">
      <v:property name="MessageId" value="valid.pe.fallactivitypercent.required.when"/>
      <v:property name="Provider" value="ProcessEmission.FallActivityPercent"/>
    </v:validator>


    <!-- Total seasonal % must be between 99.5 and 100.5 or 0 -->
    <v:condition test="(((WinterActivityPercent + SpringActivityPercent + SummerActivityPercent + FallActivityPercent) &gt;= 99.5) and ((WinterActivityPercent + SpringActivityPercent + SummerActivityPercent + FallActivityPercent) &lt;= 100.5)) or ((WinterActivityPercent + SpringActivityPercent + SummerActivityPercent + FallActivityPercent) == 0)" when="WinterActivityPercent != null and SpringActivityPercent != null and SummerActivityPercent != null and FallActivityPercent != null">
      <v:message id="valid.pe.seasontotal" providers="ProcessEmission.FallActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>


    <!-- OPERATIONS - OZONE, SUMMER, CO SEASON DAYS -->
    <!-- Total Ozone Season Days Required -->
    <!-- <v:validator test="TotalOzoneSeasonDays" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.totalozoneseasondays.required"/>
      <v:property name="Provider" value="ProcessEmission.TotalOzoneSeasonDays"/>
    </v:validator> -->
    <!-- If the June-August (%) is &gt; 0 then the Total Ozone Season Days must be &gt; 0 -->
    <!-- <v:condition test="TotalOzoneSeasonDays != null and TotalOzoneSeasonDays > 0"  when="SummerActivityPercent > 0 and SummerActivityPercent != null">
      <v:message id="valid.pe.totalozoneseasondays.required.2.when" providers="ProcessEmission.TotalOzoneSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition> -->
    <!-- If the March-May (%) is not &gt;0 and June-August (%) is not &gt; 0 and September-November (%) is not &gt;0, the Total Ozone Season Days cannot be &gt; 0 -->
    <!-- <v:condition test="TotalOzoneSeasonDays == null" when="(TotalOzoneSeasonDays != null and TotalOzoneSeasonDays > 0) and (SpringActivityPercent == 0 or SpringActivityPercent == null) and (SummerActivityPercent == 0 or SummerActivityPercent == null) and (FallActivityPercent == 0 or FallActivityPercent == null)">
      <v:message id="valid.pe.totalozoneseasondays.invalid" providers="ProcessEmission.TotalOzoneSeasonDays">
            <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition> -->
    <!-- Numeric format validation -->
    <!-- <v:validator id="TotalOzoneSeasonDays" test="TotalOzoneSeasonDays.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="TotalOzoneSeasonDays != null">
      <v:property name="PrecisionFormat" value="3,0" />
      <v:message id="valid.pe.totalozoneseasondays.format" providers="ProcessEmission.TotalOzoneSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator> -->
    <!-- Numeric range validation -->
    <!-- <v:condition test ="TotalOzoneSeasonDays &gt;= 0 and TotalOzoneSeasonDays &lt;= 153" when="TotalOzoneSeasonDays != null">
      <v:message id="valid.pe.totalozoneseasondays.range" providers="ProcessEmission.TotalOzoneSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition> -->


    <!-- Summer Season Days Required -->
    <!--
    <v:validator test="ActualSummerSeasonDays" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.totalsummerseasondays.required"/>
      <v:property name="Provider" value="ProcessEmission.ActualSummerSeasonDays"/>
    </v:validator>
    -->
    <!-- If the June-August (%) is &gt; 0, then the Total Summer Season Days must be &gt; 0 -->
    <!--
    <v:condition test="ActualSummerSeasonDays != null and ActualSummerSeasonDays > 0"  when="SummerActivityPercent > 0 and SummerActivityPercent != null">
      <v:message id="valid.pe.ActualSummerSeasonDays.notnull" providers="ProcessEmission.ActualSummerSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    -->
    <!-- If the June-August (%) is not &gt; 0, the Total Summer Season Days cannot be &gt; 0 -->
    <v:condition test="ActualSummerSeasonDays == null"  when="(ActualSummerSeasonDays !=null and ActualSummerSeasonDays > 0) and (SummerActivityPercent == 0 or SummerActivityPercent == null)">
      <v:message id="valid.pe.totalsummerseasondays.notnull" providers="ProcessEmission.ActualSummerSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- Numeric format validation -->
    <v:validator id="ActualSummerSeasonDays" test="ActualSummerSeasonDays.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="ActualSummerSeasonDays != null">
      <v:property name="PrecisionFormat" value="2,0" />
      <v:message id="valid.pe.totalsummerseasondays.format" providers="ProcessEmission.ActualSummerSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <!-- Numeric range validation -->
    <v:condition test ="ActualSummerSeasonDays &gt;= 0 and ActualSummerSeasonDays &lt;= 92" when="ActualSummerSeasonDays != null">
      <v:message id="valid.pe.totalsummerseasondays.range" providers="ProcessEmission.ActualSummerSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!-- Total CO Season Days Required -->
    <!--
    <v:validator test="TotalCoSeasonDays" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.totalcoseasondays.required"/>
      <v:property name="Provider" value="ProcessEmission.TotalCoSeasonDays"/>
    </v:validator>
    -->
    <!-- If the December-February (%) is &gt; 0, then the Total CO Season Days must be &gt; 0 -->
    <!--
    <v:condition test="TotalCoSeasonDays != null and TotalCoSeasonDays > 0"  when="WinterActivityPercent > 0 and WinterActivityPercent != null">
      <v:message id="valid.pe.CoSeasonDays.notnull" providers="ProcessEmission.TotalCoSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    -->
    <!-- If the December-February (%) is not &gt; 0, the Total CO Season Days cannot be &gt; 0 -->
    <v:condition test="TotalCoSeasonDays == null"  when="(TotalCoSeasonDays != null and TotalCoSeasonDays > 0) and (WinterActivityPercent == 0 or WinterActivityPercent == null)">
      <v:message id="valid.pe.totalcoseasondays.notnull" providers="ProcessEmission.TotalCoSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- Numeric format validation -->
    <v:validator id="TotalCoSeasonDays" test="TotalCoSeasonDays.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="TotalCoSeasonDays != null">
      <v:property name="PrecisionFormat" value="2,0" />
      <v:message id="valid.pe.totalcoseasondays.format" providers="ProcessEmission.TotalCoSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>
    <!-- Numeric range validation -->
    <v:condition test ="TotalCoSeasonDays &gt;= 0 and TotalCoSeasonDays &lt;= 91" when="TotalCoSeasonDays != null">
      <v:message id="valid.pe.totalcoseasondays.range" providers="ProcessEmission.TotalCoSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>


    <!-- PROCESS EMISSIONS -->
    <v:required test="Emissions">
      <v:message id="valid.pe.pollutant.required" providers="ProcessEmission.Emissions">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>

    <!-- Validate individual process emission pollutants -->
    <v:validator id="pePollutant" test="Emissions" type="Sleis.Validation.Spring.ListValidator">
      <v:property name="ProviderFormat" value="ProcessEmission.Emissions[{0}]." />
      <v:property name="Validator" ref="processEmissionsPollutantValidationRules" />
    </v:validator>

    <!-- Pollutant must be unique to the process -->
    <v:group id="processEmissionPollutantValidation" when="Emissions != null">
      <!-- Pollutant Code must be unique for the current process -->
      <v:validator test="Emissions" type="Sleis.Validation.Spring.UniqueListValidator">
        <v:property name="ProviderFormat" value="ProcessEmission.Emissions[{0}]." />
        <v:property name="MessageId" value="valid.pe.pollutant.code.unique" />
        <v:property name="Keys">
          <dictionary key-type="string" value-type="string">
            <!--
                Key: What has to be uique
                Value: What is the field name to be appended to the ProviderFormat
            -->
            <entry key="PollutantCode" value="PollutantCode" />
          </dictionary>
        </v:property>
      </v:validator>
    </v:group>
  </v:group>


  <v:group id="processEmissionsPollutantValidationRules" when ="ProcessEmission != null">
    <!-- Require Pollutant Code -->
    <v:required test="PollutantCode">
      <v:message id="valid.pe.pollutantcode.required" providers="PollutantCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>

    <!-- Require Calculation Method -->
    <v:required test="CalculationMethodCode">
      <v:message id="valid.pe.calculationmethodcode.required" providers="CalculationMethodCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>

    <!-- Require Annual Throughput if a calculation method is used that utilizes an Emission Factor -->
    <v:validator test="ProcessEmission.Value" type="Sleis.Validation.Spring.NullableDecimalValidator" when="CalculationMethodCode != null and CalculationMethodCode != '1' and CalculationMethodCode != '2' and CalculationMethodCode != '3' and CalculationMethodCode != '5' and CalculationMethodCode != '6' and CalculationMethodCode != '7'">
      <v:property name="MessageId" value="valid.pe.annualthroughput.required.when"/>
      <v:property name="Provider" value="~ProcessEmission.Value"/>
    </v:validator>

    <!-- Require emission factor if calculation method code requires one -->
    <v:validator test="Factor" type="Sleis.Validation.Spring.NullableDecimalValidator" when="CalculationMethodCode != null and CalculationMethodCode != '1' and CalculationMethodCode != '2' and CalculationMethodCode != '3' and CalculationMethodCode != '5' and CalculationMethodCode != '6' and CalculationMethodCode != '7'">
      <v:property name="MessageId" value="valid.pe.factor.required"/>
      <v:property name="Provider" value="Factor"/>
    </v:validator>
    <v:validator id="processEmissionPollutantFactor" test="Factor.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="Factor != null">
      <v:property name="PrecisionFormat" value="28,15" />
      <v:message id="valid.pe.factor.format" providers="Factor">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>

    <!-- Require emission factor unit if calculation method code requires an emission factor -->
    <v:required test="FactorDenomenatorUomCode" when="CalculationMethodCode != null and CalculationMethodCode != '1' and CalculationMethodCode != '2' and CalculationMethodCode != '3' and CalculationMethodCode != '5' and CalculationMethodCode != '6' and CalculationMethodCode != '7'">
      <v:message id="valid.pe.factordenomenatoruomcode.required" providers="FactorDenomenatorUomCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:required>

    <!-- Require that emission factor unit and throughput unit match, when applicable-->
    <v:condition test="FactorDenomenatorUomCode == ProcessEmission.ValueUomCode"  when="FactorDenomenatorUomCode != null and ProcessEmission.ValueUomCode != null">
      <v:message id="valid.pe.uom.match" providers="FactorDenomenatorUomCode">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!-- Estimated Emissions -->
    <v:validator test="TotalEmissions" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.pollutant.totalemissions.required"/>
      <v:property name="Provider" value="TotalEmissions"/>
    </v:validator>
    <v:validator id="processEmissionPollutantTotalEmissions" test="TotalEmissions.ToString()" type="Sleis.Validation.Spring.DecimalValidator" when="TotalEmissions != null">
      <v:property name="PrecisionFormat" value="28,15" />
      <v:message id="valid.pe.pollutant.totalemissions.format" providers="TotalEmissions">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>

    <!-- Emissions Comments -->
    <v:regex test="Comment" expression="^[\s\S]{0,400}$" when="Comment != null">
      <v:message id="valid.pe.emissions.comment.length" providers="Comment">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:regex>
  </v:group>


  <v:group id="monthlyThroughputValidationRules" when="'${app.enable.monthly.throughput.totals}' == 'true'" >
    <!--MONTHLY THROUGHPUT SPECIFIC-->
    <!-- Dec Throughput Required -->
    <!--
    <v:validator test="DecemberVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.dec.required"/>
      <v:property name="Provider" value="ProcessEmission.DecemberVal"/>
    </v:validator>
    -->
    <!-- If the December-February (%) is not > 0, the December Throughput cannot be > 0-->
    <v:condition test="DecemberVal == null or DecemberVal == 0"  when="WinterActivityPercent == 0 or WinterActivityPercent == null">
      <v:message id="valid.pe.DecemberVal.notnull" providers="ProcessEmission.DecemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- Dec Throughput precision/scale validation -->
    <v:validator id="processEmissionDecemberValidator" test="DecemberVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="DecemberVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.DecemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- Jan Throughput Required -->
    <!--
    <v:validator test="JanuaryVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.jan.required"/>
      <v:property name="Provider" value="ProcessEmission.JanuaryVal"/>
    </v:validator>
    -->
    <!-- If the December-February (%) is not > 0, the January Throughput cannot be > 0-->
    <v:condition test="JanuaryVal == null or JanuaryVal == 0"  when="WinterActivityPercent == 0 or WinterActivityPercent == null">
      <v:message id="valid.pe.JanuaryVal.notnull" providers="ProcessEmission.JanuaryVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- Jan Throughput precision/scale validation -->
    <v:validator id="processEmissionJanuaryValidator" test="JanuaryVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="JanuaryVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.JanuaryVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- Feb Throughput Required -->
    <!--
    <v:validator test="FebruaryVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.feb.required"/>
      <v:property name="Provider" value="ProcessEmission.FebruaryVal"/>
    </v:validator>
    -->
    <!-- If the December-February (%) is not > 0, the February Throughput cannot be > 0-->
    <v:condition test="FebruaryVal == null or FebruaryVal == 0"  when="WinterActivityPercent == 0 or WinterActivityPercent == null">
      <v:message id="valid.pe.FebruaryVal.notnull" providers="ProcessEmission.FebruaryVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- Feb Throughput precision/scale validation -->
    <v:validator id="processEmissionFebruaryValidator" test="FebruaryVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="FebruaryVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.FebruaryVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- Mar Throughput Required -->
    <!--
    <v:validator test="MarchVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.mar.required"/>
      <v:property name="Provider" value="ProcessEmission.MarchVal"/>
    </v:validator>
    -->
    <!-- If the March-May (%) is not > 0, the March Throughput cannot be > 0-->
    <v:condition test="MarchVal == null or MarchVal == 0"  when="SpringActivityPercent == 0 or SpringActivityPercent == null">
      <v:message id="valid.pe.MarchVal.notnull" providers="ProcessEmission.MarchVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- Mar Throughput precision/scale validation -->
    <v:validator id="processEmissionMarchValidator" test="MarchVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="MarchVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.MarchVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- Apr Throughput Required -->
    <!--
    <v:validator test="AprilVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.apr.required"/>
      <v:property name="Provider" value="ProcessEmission.AprilVal"/>
    </v:validator>
    -->
    <!-- If the March-May (%) is not > 0, the April Throughput cannot be > 0-->
    <v:condition test="AprilVal == null or AprilVal == 0"  when="SpringActivityPercent == 0 or SpringActivityPercent == null">
      <v:message id="valid.pe.AprilVal.notnull" providers="ProcessEmission.AprilVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- Apr Throughput precision/scale validation -->
    <v:validator id="processEmissionAprilValidator" test="AprilVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="AprilVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.AprilVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- May Throughput Required -->
    <!--
    <v:validator test="MayVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.may.required"/>
      <v:property name="Provider" value="ProcessEmission.MayVal"/>
    </v:validator>
    -->
    <!-- If the March-May (%) is not > 0, the May Throughput cannot be > 0-->
    <v:condition test="MayVal == null or MayVal == 0"  when="SpringActivityPercent == 0 or SpringActivityPercent == null">
      <v:message id="valid.pe.MayVal.notnull" providers="ProcessEmission.MayVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- May Throughput precision/scale validation -->
    <v:validator id="processEmissionMayValidator" test="MayVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="MayVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.MayVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- June Throughput Required -->
    <!--
    <v:validator test="JuneVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.jun.required"/>
      <v:property name="Provider" value="ProcessEmission.JuneVal"/>
    </v:validator>
    -->
    <!-- If the June-August (%) is not > 0, the June Throughput cannot be > 0-->
    <v:condition test="JuneVal == null or JuneVal == 0"  when="SummerActivityPercent == 0 or SummerActivityPercent == null">
      <v:message id="valid.pe.JuneVal.notnull" providers="ProcessEmission.JuneVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- June Throughput precision/scale validation -->
    <v:validator id="processEmissionJuneValidator" test="JuneVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="JuneVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.JuneVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- July Throughput Required -->
    <!--
    <v:validator test="JulyVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.jul.required"/>
      <v:property name="Provider" value="ProcessEmission.JulyVal"/>
    </v:validator>
    -->
    <!-- If the June-August (%) is not > 0, the July Throughput cannot be > 0-->
    <v:condition test="JulyVal == null or JulyVal == 0"  when="SummerActivityPercent == 0 or SummerActivityPercent == null">
      <v:message id="valid.pe.JulyVal.notnull" providers="ProcessEmission.JulyVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- July Throughput precision/scale validation -->
    <v:validator id="processEmissionJulyValidator" test="JulyVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="JulyVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.JulyVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- August Throughput Required -->
    <!--
    <v:validator test="AugustVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.aug.required"/>
      <v:property name="Provider" value="ProcessEmission.AugustVal"/>
    </v:validator>
    -->
    <!-- If the June-August (%) is not > 0, the August Throughput cannot be > 0-->
    <v:condition test="AugustVal == null or AugustVal == 0"  when="SummerActivityPercent == 0 or SummerActivityPercent == null">
      <v:message id="valid.pe.AugustVal.notnull" providers="ProcessEmission.AugustVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- August Throughput precision/scale validation -->
    <v:validator id="processEmissionAugustValidator" test="AugustVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="AugustVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.AugustVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- September Throughput Required -->
    <!--
    <v:validator test="SeptemberVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.sep.required"/>
      <v:property name="Provider" value="ProcessEmission.SeptemberVal"/>
    </v:validator>
    -->
    <!-- If the September-November (%) is not > 0, the September Throughput cannot be > 0-->
    <v:condition test="SeptemberVal == null or SeptemberVal == 0"  when="FallActivityPercent == 0 or FallActivityPercent == null">
      <v:message id="valid.pe.SeptemberVal.notnull" providers="ProcessEmission.SeptemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- September Throughput precision/scale validation -->
    <v:validator id="processEmissionSeptemberValidator" test="SeptemberVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="SeptemberVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.SeptemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- October Throughput Required -->
    <!--
    <v:validator test="OctoberVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.oct.required"/>
      <v:property name="Provider" value="ProcessEmission.OctoberVal"/>
    </v:validator>
    -->
    <!-- If the September-November (%) is not > 0, the October Throughput cannot be > 0-->
    <v:condition test="OctoberVal == null or OctoberVal == 0"  when="FallActivityPercent == 0 or FallActivityPercent == null">
      <v:message id="valid.pe.OctoberVal.notnull" providers="ProcessEmission.OctoberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- October Throughput precision/scale validation -->
    <v:validator id="processEmissionOctoberValidator" test="OctoberVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="OctoberVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.OctoberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- November Throughput Required -->
    <!--
    <v:validator test="NovemberVal" type="Sleis.Validation.Spring.NullableDecimalValidator">
      <v:property name="MessageId" value="valid.pe.nov.required"/>
      <v:property name="Provider" value="ProcessEmission.NovemberVal"/>
    </v:validator>
    -->
    <!-- If the September-November (%) is not > 0, the November Throughput cannot be > 0-->
    <v:condition test="NovemberVal == null or NovemberVal == 0"  when="FallActivityPercent == 0 or FallActivityPercent == null">
      <v:message id="valid.pe.NovemberVal.notnull" providers="ProcessEmission.NovemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- November Throughput precision/scale validation -->
    <v:validator id="processEmissionNovemberValidator" test="NovemberVal.ToString('G29')" type="Sleis.Validation.Spring.DecimalValidator" when="NovemberVal != null">
      <v:property name="PrecisionFormat" value="25,10" />
      <v:message id="valid.pe.throughput.monthly.format" providers="ProcessEmission.NovemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
      <v:property name="AllowPartialMatching" value="true"/>
    </v:validator>


    <!-- REQUIRE SEASONAL MONTHS IF SEASONAL % PROVIDED AND VICE VERSA -->
    <!-- If Operations Dec-Feb % is > 0 then Dec, Jan, or Feb monthly throughput must be > 0 -->
    <v:condition test="WinterActivityPercent == null or WinterActivityPercent == 0" when="((DecemberVal == null or DecemberVal == 0) and (JanuaryVal == null or JanuaryVal == 0) and (FebruaryVal == null or FebruaryVal == 0))">
      <v:message id="valid.pe.wintermonths.notnull" providers="ProcessEmission.DecemberVal,ProcessEmission.JanuaryVal,ProcessEmission.FebruaryVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- If Dec, Jan, or Feb monthly throughput > 0 then Operations Dec-Feb % is must be > 0 -->
    <v:condition test="(DecemberVal == null or DecemberVal == 0) and (JanuaryVal == null or JanuaryVal == 0) and (FebruaryVal == null or FebruaryVal == 0)"  when="WinterActivityPercent == null or WinterActivityPercent == 0">
      <v:message id="valid.pe.winter.notnull" providers="ProcessEmission.WinterActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- If Dec, Jan, or Feb monthly throughput is > 0 then Operations CO Season Day must be > 0 -->
    <v:condition test="(DecemberVal == null or DecemberVal == 0) and (JanuaryVal == null or JanuaryVal == 0) and (FebruaryVal == null or FebruaryVal == 0)"  when="TotalCoSeasonDays == null or TotalCoSeasonDays == 0">
      <v:message id="valid.pe.totalcoseasondays.required.when" providers="ProcessEmission.TotalCoSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!-- If Operations March-May % is > 0 then March, April, or May monthly throughput must be > 0 -->
    <v:condition test="SpringActivityPercent == null or SpringActivityPercent == 0"  when="((MarchVal == null or MarchVal == 0) and (AprilVal == null or AprilVal == 0) and (MayVal == null or MayVal == 0))">
      <v:message id="valid.pe.springmonths.notnull" providers="ProcessEmission.MarchVal,ProcessEmission.AprilVal,ProcessEmission.MayVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- If March, April, or May monthly throughput is > 0 then Operations March-May % must be > 0 -->
    <v:condition test="(MarchVal == null or MarchVal == 0) and (AprilVal == null or AprilVal == 0) and (MayVal == null or MayVal == 0)"  when="SpringActivityPercent == null or SpringActivityPercent == 0">
      <v:message id="valid.pe.spring.notnull" providers="ProcessEmission.SpringActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!-- If Operations Jun-Aug % is > 0 then June, July, or August monthly throughput must be > 0 -->
    <v:condition test="SummerActivityPercent == null or SummerActivityPercent ==0"  when="((JuneVal == null or JuneVal == 0) and (JulyVal == null or JulyVal == 0) and (AugustVal == null or AugustVal == 0))">
      <v:message id="valid.pe.summermonths.notnull" providers="ProcessEmission.JuneVal,ProcessEmission.JulyVal,ProcessEmission.AugustVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- If June, July, or August monthly throughput is > 0 then Operations Jun-Aug % must be > 0 -->
    <v:condition test="(JuneVal == null or JuneVal == 0) and (JulyVal == null or JulyVal == 0) and (AugustVal == null or AugustVal == 0)" when="SummerActivityPercent == null or SummerActivityPercent == 0">
      <v:message id="valid.pe.summer.notnull" providers="ProcessEmission.SummerActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- If June, July, or August monthly throughput is > 0 then Operations Summer Season Day must be > 0 -->
    <v:condition test="(JuneVal == null or JuneVal == 0) and (JulyVal == null or JulyVal == 0) and (AugustVal == null or AugustVal == 0)"  when="ActualSummerSeasonDays == null or ActualSummerSeasonDays == 0">
      <v:message id="valid.pe.totalsummerseasondays.required.when" providers="ProcessEmission.ActualSummerSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- If May, June, July, August, or September monthly throughput is > 0 then Operations Total Ozone Season Days must be > 0 -->
    <!-- <v:condition test="(MayVal == null or MayVal == 0) and (JuneVal == null or JuneVal == 0) and (JulyVal == null or JulyVal == 0) and (AugustVal == null or AugustVal == 0) and (SeptemberVal == null or SeptemberVal == 0)"  when="TotalOzoneSeasonDays == null or TotalOzoneSeasonDays == 0">
      <v:message id="valid.pe.totalozoneseasondays.required.when" providers="ProcessEmission.TotalOzoneSeasonDays">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition> -->

    <!-- If Operations September-November % is > 0 then September, October, or November monthly throughput must be > 0 -->
    <v:condition test="FallActivityPercent == null or FallActivityPercent == 0"  when="((SeptemberVal == null or SeptemberVal == 0) and (OctoberVal == null or OctoberVal == 0) and (NovemberVal == null or NovemberVal == 0))">
      <v:message id="valid.pe.fallmonths.notnull" providers="ProcessEmission.SeptemberVal,ProcessEmission.OctoberVal,ProcessEmission.NovemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!-- If September, October, or November monthly throughput is > 0 then Operations September-November %  must be > 0 -->
    <v:condition test="(SeptemberVal == null or SeptemberVal == 0) and (OctoberVal == null or OctoberVal == 0) and (NovemberVal == null or NovemberVal == 0)"  when="FallActivityPercent == null or FallActivityPercent == 0">
      <v:message id="valid.pe.fall.notnull" providers="ProcessEmission.FallActivityPercent">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>



    <!-- OZONE, SUMMER DAY, CO SEASON DAYS -->
    <!-- If Operations Total CO Season Days > 0 then Dec, Jan, or Feb must be > 0-->
    <v:condition test="TotalCoSeasonDays == null or TotalCoSeasonDays == 0" when="((DecemberVal == null or DecemberVal == 0) and (JanuaryVal == null or JanuaryVal == 0) and (FebruaryVal == null or FebruaryVal == 0))">
      <v:message id="valid.pe.comonths.required" providers="ProcessEmission.JanuaryVal,ProcessEmission.FebruaryVal,ProcessEmission.DecemberVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>

    <!-- If Operations Total Ozone Days > 0 then May, June, July, August, or September ThroughtPut must be > 0 -->
    <!-- <v:condition test="TotalOzoneSeasonDays == null or TotalOzoneSeasonDays == 0" when="((MayVal == null or MayVal == 0) and (JuneVal == null or JuneVal == 0) and (JulyVal == null or JulyVal == 0) and (AugustVal == null or AugustVal == 0) and (SeptemberVal == null or SeptemberVal == 0))">
      <v:message id="valid.pe.ozonemonths.required.when" providers="ProcessEmission.JuneVal,ProcessEmission.JulyVal,ProcessEmission.AugustVal,ProcessEmission.SeptemberVal,ProcessEmission.MayVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>  -->

    <!-- If Operations Total Summer Seasons Days > 0 then May, June, July, August, or September ThroughtPut must be > 0 -->
    <v:condition test="ActualSummerSeasonDays == null or ActualSummerSeasonDays == 0" when="((JuneVal == null or JuneVal == 0) and (JulyVal == null or JulyVal == 0) and (AugustVal == null or AugustVal == 0))">
      <v:message id="valid.pe.summermonths.required.when" providers="ProcessEmission.JuneVal,ProcessEmission.JulyVal,ProcessEmission.AugustVal">
        <v:param value="ValidationContxt"/>
      </v:message>
    </v:condition>
    <!--End Monthly Throughput-->
  </v:group>
</objects>