Function Reactor_Services(@Service, @Params)
/***********************************************************************************************************************

    This program is proprietary and is not to be used by or disclosed to others, nor is it to be copied without written
    permission from SRP Computer Solutions, Inc.

    Name        :   Reactor_Services

    Description :   Handler program for all module related services.

    Notes       :   The generic parameters should contain all the necessary information to process the services. Often
                    this will be information like the data Record and Key ID.

    Parameters  :
        Service         [in] -- Name of the service being requested
        Param1-10   [in/out] -- Additional request parameter holders
        Response       [out] -- Response to be sent back to the Controller (MCP) or requesting procedure

    Metadata    :

    History     :   (Date, Initials, Notes)
        08/10/17    dmb     Original programmer. Adapted from Scheduling_Services. - [IREPIOI-8]
        01/08/18    dmb     Update the CreatePerformanceTrackers service so the CreateWeeklyPerformanceReport is called
                            on Friday mornings for the upcoming week rather than Monday mornings for the current week.
                            - [IREPIOI-14]
        02/17/18    dmb     Add logging to track reactor performance activities. - [IREPIOI-14]
        05/30/18    dmb     Update various services to allow newer reactors to be used for reporting. - [IREPIOI-17]
        06/21/18    dmb     Update the path where templates and reports are stored. - [IREPIOI-33]
        06/26/18    dmb     Add logging to track when this service is being called. - [IREPIOI-56]
        06/26/18    dmb     Update logic on how reactors are selected for reporting. - [IREPIOI-56]
        04/20/21    djs     Added PickPlace to objReactor JSON object in GetReactor service.
        12/06/23    djm     Add MD3 conversion to TargetThickness in metric increment and decrement services.

***********************************************************************************************************************/
#pragma precomp SRP_PreCompiler

$insert APP_INSERTS
$insert SERVICE_SETUP
$insert REACTOR_EQUATES
$insert RDS_EQUATES
$insert RLIST_EQUATES
$insert TOOL_EQUATES
$Insert REACTOR_LOG_EQUATES
$Insert REACTOR_CHILD_KEY_IDS_EQUATES
$Insert REACTOR_MODES_EQUATES
$Insert REACT_MODE_EQU ;* THESE ARE NOT THE SAME jch, Update 9/15/21. These are the equates for the CONFIG records
$Insert REACT_MODE_NG_EQUATES
$Insert REACT_UTIL_EQU
$Insert SCHED_DET_NG_EQUATES
$Insert REACT_STATUS_EQUATES
$Insert WO_LOG_EQUATES
$Insert REACTOR_DAILY_UPTIME_EQUATES
$Insert REACT_LL_EQUATES
$Insert IQS_VIOL_DATA_EQUATES
$Insert FEATURE_FLAGS_EQUATES

Equ WOCust$      to 2

// Uptime Percentage Equates
Equ PRODUCTIVE$          to 1
Equ UNSCHED$             to 2
Equ SCHED$               to 3
Equ NONSCHED$			 to 4
Equ ENG$				 to 5

Declare subroutine  Error_Services, Reactor_Services, Memory_Services, RList, Database_Services, SRP_JSON
Declare subroutine  Excel_Services, Schedule_Services, Logging_Services, Set_Status, obj_React_Status, Errmsg
Declare subroutine  Obj_Notes, Btree.Extract, SRP_Fastarray, Delay, Mona_Services, SRP_List, Msg, Rds_Services
Declare subroutine  React_Assign_Conv, Nica_Orders_Services, obj_React_Mode
Declare function    SRP_Array, Reactor_Services, Memory_Services, Database_Services, SRP_Sort_Array, Excel_Services
Declare function    SRP_Math, SRP_Hash, SRP_JSON, Epi_Part_Services, Schedule_Services, Date_Services, Environment_Services
Declare function    Logging_Services, GetCommandLine, NextKey, Reactor_Log_Services, SRP_DateTime, ole_getwebpage
Declare function    Datetime, Reactor_Modes_Services, Work_Order_Services, React_Mode_NG_Services, Lsl_Users_Services
Declare function    SRP_Time, Rds_Services, SRP_Fastarray, Httpclient_Services, SRP_List, Utility, Memberof, Error_Services
Declare function	Nica_Orders_Services

// Report paths for various performance report services.
TemplatesFolder     = Environment_Services('GetApplicationRootPath') : '\Reports\Scheduler\Templates\'
DailyReportsFolder  = Environment_Services('GetApplicationRootPath') : '\Reports\Scheduler\Daily\'
WeeklyReportsFolder = Environment_Services('GetApplicationRootPath') : '\Reports\Scheduler\Weekly\'

CommandLine = GetCommandLine()
Machine     = Environment_Services('GetServer')
LogDate     = Oconv(Date(), 'D4/')
LogTime     = Oconv(Time(), 'MTS')
LoggingDTM  = LogDate : ' ' : LogTime   ; // Logging DTM

GoToService else

end

Return Response else ''

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Service Parameter Options
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Options BOOLEAN       = True$, False$
Options REACTORMETRIC = 'TUBE_BELL_JAR_THK', 'TUBE_BELL_JAR_WFR_CNT', 'SUSC_THK', 'SUSC_WFR_CNT', 'LOWER_QUARTZ_THK', 'LOWER_QUARTZ_WFR', 'ARMS_WFR_CNT'

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Services
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//----------------------------------------------------------------------------------------------------------------------
// IncrementWfrMetrics
//
// RDSNo. - [Required]
//
// Increment the REACTOR wafer count and thickness when RDS unload is signed.
// 
//----------------------------------------------------------------------------------------------------------------------
Service IncrementWfrMetrics(RDSNo)
	
	// Get Reactor and run count details
	RDSRec          = Xlate('RDS', RDSNo, '', 'X', '')
	TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
	TargetThickness = OConv(TargetThickness, 'MD3')
	WaferCount      = RDSRec<RDS_WAFERS_IN$>
	ReactorNo       = RDSRec<RDS_REACTOR$>
	OldReactorRec   = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
	NewReactorRec   = OldReactorRec
	ReactorType     = OldReactorRec<REACTOR_REACT_TYPE$>
	SusceptorSize   = OldReactorRec<REACTOR_SUSC_POCKET_SIZE$>
	SusceptorSize   = SusceptorSize[-4,1]
	
	// Get Old Values
	CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
    CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
    CurrSuscThk        = OldReactorRec<REACTOR_SUSC_THK$>
    CurrSuscWfrCnt     = OldReactorRec<REACTOR_SUSC_WFR_CNT$>
    CurrLowerQuartzThk = OldReactorRec<REACTOR_LOWER_QUARTZ_THK$>
    CurrLowerQuartzWfr = OldReactorRec<REACTOR_LOWER_QUARTZ_WFR$>
    
    // Arms are not used for EPP
	If ReactorType NE  'EPP' then
		CurrArmsWfrCnt = OldReactorRec<REACTOR_ARMS_WFR_CNT$>
		If CurrArmsWfrCnt = '' then CurrArmsWfrCnt = 0
	end
	
	// Set values to 0 if blank
	If CurrTubeBellJarThk = '' then CurrTubeBellJarThk = 0
	If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
	If CurrSuscThk  	  = '' then CurrSuscThk = 0
	If CurrSuscWfrCnt     = '' then CurrSuscWfrCnt = 0
	If CurrLowerQuartzThk = '' then CurrLowerQuartzThk = 0
	If CurrLowerQuartzWfr = '' then CurrLowerQuartzWfr = 0
	
	Begin Case
	    
	    Case ReactorType = 'EPP'
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + TargetThickness
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + 1
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + TargetThickness
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + 1
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + TargetThickness
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + 1
	        
	    Case ReactorType = 'HTR'
	        
	        Begin Case
	            
	            Case SusceptorSize = 6
	                CntAddition                                   = (WaferCount / 5)
	                ThkAddition                                   = (WaferCount / 5) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt + WaferCount
                    
                Case SusceptorSize = 8
                    // Round up
	                CntAddition = (WaferCount / 3)
	                If Count(CntAddition, '.') EQ 1 Then
	                    CntAddition = Int(CntAddition) + 1
	                end
	                
	                ThkAddition                                   = (WaferCount / 3) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt + WaferCount
                    
	        End Case
	     	
	    Case ReactorType = 'ASM' OR ReactorType = 'ASM+'
	        
	        ThkAddition = WaferCount * TargetThickness
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + ThkAddition
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + WaferCount
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + WaferCount
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + ThkAddition
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + WaferCount
	        NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt + WaferCount
	    
	End Case
	
	Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec, 1, 0, 0)
	
end service


Service GetWaferCntMetricsByReactorID(ReactorID)
	
	If ReactorID NE '' then
		If RowExists('REACTOR', ReactorID) then
			ReactorRec   = Database_Services('ReadDataRow', 'REACTOR', ReactorID)
			ReactorType  = ReactorRec<REACTOR_REACT_TYPE$>
			ResponseData = ''
			Begin Case
				Case ReactorType EQ 'ASM' OR ReactorType EQ 'ASM+'
					ResponseData<1, 1> = ReactorID
					ResponseData<1, 2> = ReactorRec<REACTOR_SUSC_WFR_CNT$>
					ResponseData<1, 3> = ReactorRec<REACTOR_SUSC_THK$>
					ResponseData<1, 4> = ReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
					ResponseData<1, 5> = ReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
					ResponseData<1, 6> = ReactorRec<REACTOR_ARMS_WFR_CNT$>
					//These are the column titles to help us with API Responses
					ResponseData<2, 1> = 'ReactorID'
					ResponseData<2, 2> = 'SusceptorWaferCount'
					ResponseData<2, 3> = 'SusceptorThickness'
					ResponseData<2, 4> = 'TubeWaferCount'
					ResponseData<2, 5> = 'TubeThickness'
					ResponseData<2, 6> = 'ArmsWaferCount'
				Case ReactorType EQ 'HTR'
					ResponseData<1, 1> = ReactorID
					ResponseData<1, 2> = ReactorRec<REACTOR_SUSC_WFR_CNT$>
					ResponseData<1, 3> = ReactorRec<REACTOR_SUSC_THK$>
					ResponseData<1, 4> = ReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
					ResponseData<1, 5> = ReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
					ResponseData<1, 6> = ReactorRec<REACTOR_ARMS_WFR_CNT$>
					//These are the column titles to help us with API Responses
					ResponseData<2, 1> = 'ReactorID'
					ResponseData<2, 2> = 'SusceptorWaferCount'
					ResponseData<2, 3> = 'SusceptorThickness'
					ResponseData<2, 4> = 'TubeWaferCount'
					ResponseData<2, 5> = 'TubeThickness'
					ResponseData<2, 6> = 'ArmsWaferCount'
				Case ReactorType EQ 'EPP'
					ResponseData<1, 1> = ReactorID
					ResponseData<1, 2> = ReactorRec<REACTOR_SUSC_WFR_CNT$>
					ResponseData<1, 3> = ReactorRec<REACTOR_SUSC_THK$>
					ResponseData<1, 4> = ReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
					ResponseData<1, 5> = ReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
					ResponseData<1, 6> = ReactorRec<REACTOR_LOWER_QUARTZ_WFR$>
					ResponseData<1, 7> = ReactorRec<REACTOR_LOWER_QUARTZ_THK$>
					//These are the column titles to help us with API Responses
					ResponseData<2, 1> = 'ReactorID'
					ResponseData<2, 2> = 'SusceptorWaferCount'
					ResponseData<2, 3> = 'SusceptorThickness'
					ResponseData<2, 4> = 'BellJarWaferCount'
					ResponseData<2, 5> = 'BellJarThickness'
					ResponseData<2, 6> = 'LowerQuartzWaferCount'
					ResponseData<2, 7> = 'LowerQuartzThickness'
			End Case
			Response = ResponseData
		end else
			Error_Services('Add', 'Error: Invalid Reactor ID passed to REACTOR_SERVICES("GetWaferMetricsByReactorID"')
		end
	end else
		Error_Services('Add', 'Error: Null Reactor ID passed to REACTOR_SERVICES("GetWaferMetricsByReactorID"')
	end
	
end service


//----------------------------------------------------------------------------------------------------------------------
// DecrementWfrMetrics
//
// RDSNo. - [Required]
//
// Decrement the REACTOR wafer count and thickness when RDS unload is unsigned.
// 
//----------------------------------------------------------------------------------------------------------------------
Service DecrementWfrMetrics(RDSNo)
	
	// Get Reactor and run count details
	RDSRec          = Xlate('RDS', RDSNo, '', 'X', '')
	TargetThickness = Xlate('RDS', RDSNo, 'THICK_TARGET_TOT', 'X', '')
	TargetThickness = OConv(TargetThickness, 'MD3')
	WaferCount      = RDSRec<RDS_WAFERS_IN$>
	ReactorNo       = RDSRec<RDS_REACTOR$>
	OldReactorRec   = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
	NewReactorRec   = OldReactorRec
	ReactorType     = OldReactorRec<REACTOR_REACT_TYPE$>
	SusceptorSize   = OldReactorRec<REACTOR_SUSC_POCKET_SIZE$>
	SusceptorSize   = SusceptorSize[-4,1]
	
	// Get Old Values
	CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
    CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
    CurrSuscThk        = OldReactorRec<REACTOR_SUSC_THK$>
    CurrSuscWfrCnt     = OldReactorRec<REACTOR_SUSC_WFR_CNT$>
    CurrLowerQuartzThk = OldReactorRec<REACTOR_LOWER_QUARTZ_THK$>
    CurrLowerQuartzWfr = OldReactorRec<REACTOR_LOWER_QUARTZ_WFR$>
    
    // Arms are not used for EPP
	If ReactorType NE  'EPP' then
		CurrArmsWfrCnt = OldReactorRec<REACTOR_ARMS_WFR_CNT$>
		If CurrArmsWfrCnt = '' then CurrArmsWfrCnt = 0
	end
	
	// Set values to 0 if blank
	If CurrTubeBellJarThk  = '' then CurrTubeBellJarThk = 0
	If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
	If CurrSuscThk = '' then CurrSuscThk = 0
	If CurrSuscWfrCnt = '' then CurrSuscWfrCnt = 0
	If CurrLowerQuartzThk = '' then CurrLowerQuartzThk = 0
	If CurrLowerQuartzWfr = '' then CurrLowerQuartzWfr = 0
	
	Begin Case
	    
	    Case ReactorType = 'EPP'
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - TargetThickness
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - 1
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk - TargetThickness
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - 1
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - TargetThickness
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - 1
	        
	    Case ReactorType = 'HTR'
	        
	        Begin Case
	            
	            Case SusceptorSize = 6
	                CntAddition                                   = (WaferCount / 5)
	                ThkAddition                                   = (WaferCount / 5) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt - WaferCount
                    
                Case SusceptorSize = 8
                    // Round up
	                CntAddition = (WaferCount / 3)
	                If Count(CntAddition, '.') EQ 1 Then
	                    CntAddition = Int(CntAddition) + 1
	                end
	                
	                ThkAddition                                   = (WaferCount / 3) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk - ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt - WaferCount
                    
	        End Case
	     	
	    Case ReactorType = 'ASM' OR ReactorType = 'ASM+'
	        
	        ThkAddition = WaferCount * TargetThickness
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - ThkAddition
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - WaferCount
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk - ThkAddition
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - WaferCount
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - ThkAddition
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - WaferCount
	        NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt - WaferCount
	    
	End Case
	
	Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec, 1, 0, 0)
	
end service


//----------------------------------------------------------------------------------------------------------------------
// IncrementTestWfrMetrics
//
// TargetThickness - [Required]
// WaferCount - [Required]
// ReactorNo - [Required]
//
// Increment the REACTOR wafer count and thickness for test wafers.
// 
//----------------------------------------------------------------------------------------------------------------------
Service IncrementTestWfrMetrics(TargetThickness, WaferCount, ReactorNo)
	
	OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
	NewReactorRec = OldReactorRec
	ReactorType   = OldReactorRec<REACTOR_REACT_TYPE$>
	SusceptorSize = OldReactorRec<REACTOR_SUSC_POCKET_SIZE$>
	SusceptorSize = SusceptorSize[-4,1]
	
	// Get Old Values
	CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
    CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
    CurrSuscThk        = OldReactorRec<REACTOR_SUSC_THK$>
    CurrSuscWfrCnt     = OldReactorRec<REACTOR_SUSC_WFR_CNT$>
    CurrLowerQuartzThk = OldReactorRec<REACTOR_LOWER_QUARTZ_THK$>
    CurrLowerQuartzWfr = OldReactorRec<REACTOR_LOWER_QUARTZ_WFR$>
    
    // Arms are not used for EPP
	If ReactorType NE  'EPP' then
		CurrArmsWfrCnt = OldReactorRec<REACTOR_ARMS_WFR_CNT$>
		If CurrArmsWfrCnt = '' then CurrArmsWfrCnt = 0
	end
	
	// Set values to 0 if blank
	If CurrTubeBellJarThk = '' then CurrTubeBellJarThk = 0
	If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
	If CurrSuscThk  	  = '' then CurrSuscThk = 0
	If CurrSuscWfrCnt     = '' then CurrSuscWfrCnt = 0
	If CurrLowerQuartzThk = '' then CurrLowerQuartzThk = 0
	If CurrLowerQuartzWfr = '' then CurrLowerQuartzWfr = 0
	
	Begin Case
	    
	    Case ReactorType = 'EPP'
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + TargetThickness
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + 1
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + TargetThickness
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + 1
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + TargetThickness
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + 1
	        
	    Case ReactorType = 'HTR'
	        
	        Begin Case
	            
	            Case SusceptorSize = 6
	                CntAddition                                   = (WaferCount / 5)
	                ThkAddition                                   = (WaferCount / 5) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt + WaferCount
                    
                Case SusceptorSize = 8
                    // Round up
	                CntAddition = (WaferCount / 3)
	                If Count(CntAddition, '.') EQ 1 Then
	                    CntAddition = Int(CntAddition) + 1
	                end
	                
	                ThkAddition                                   = (WaferCount / 3) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt + WaferCount
                    
	        End Case
	     	
	    Case ReactorType = 'ASM' OR ReactorType = 'ASM+'
	        
	        ThkAddition = WaferCount * TargetThickness
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk + ThkAddition
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt + WaferCount
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt + WaferCount
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk + ThkAddition
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr + WaferCount
	        NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt + WaferCount
	    
	End Case
	
	Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec, 1, 0, 0)
	
end service


//----------------------------------------------------------------------------------------------------------------------
// DecrementTestWfrMetrics
//
// TargetThickness - [Required]
// WaferCount - [Required]
// ReactorNo - [Required]
//
// Decrement the REACTOR wafer count and thickness for test wafers.
// 
//----------------------------------------------------------------------------------------------------------------------
Service DecrementTestWfrMetrics(TargetThickness, WaferCount, ReactorNo)
	
	OldReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
	NewReactorRec = OldReactorRec
	ReactorType   = OldReactorRec<REACTOR_REACT_TYPE$>
	SusceptorSize = OldReactorRec<REACTOR_SUSC_POCKET_SIZE$>
	SusceptorSize = SusceptorSize[-4,1]
	
	// Get Old Values
	CurrTubeBellJarThk = OldReactorRec<REACTOR_TUBE_BELL_JAR_THK$>
    CurrTubeBellJarCnt = OldReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$>
    CurrSuscThk        = OldReactorRec<REACTOR_SUSC_THK$>
    CurrSuscWfrCnt     = OldReactorRec<REACTOR_SUSC_WFR_CNT$>
    CurrLowerQuartzThk = OldReactorRec<REACTOR_LOWER_QUARTZ_THK$>
    CurrLowerQuartzWfr = OldReactorRec<REACTOR_LOWER_QUARTZ_WFR$>
    
    // Arms are not used for EPP
	If ReactorType NE  'EPP' then
		CurrArmsWfrCnt = OldReactorRec<REACTOR_ARMS_WFR_CNT$>
		If CurrArmsWfrCnt = '' then CurrArmsWfrCnt = 0
	end
	
	// Set values to 0 if blank
	If CurrTubeBellJarThk  = '' then CurrTubeBellJarThk = 0
	If CurrTubeBellJarCnt = '' then CurrTubeBellJarCnt = 0
	If CurrSuscThk = '' then CurrSuscThk = 0
	If CurrSuscWfrCnt = '' then CurrSuscWfrCnt = 0
	If CurrLowerQuartzThk = '' then CurrLowerQuartzThk = 0
	If CurrLowerQuartzWfr = '' then CurrLowerQuartzWfr = 0
	
	Begin Case
	    
	    Case ReactorType = 'EPP'
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - TargetThickness
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - 1
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk - TargetThickness
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - 1
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - TargetThickness
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - 1
	        
	    Case ReactorType = 'HTR'
	        
	        Begin Case
	            
	            Case SusceptorSize = 6
	                CntAddition                                   = (WaferCount / 5)
	                ThkAddition                                   = (WaferCount / 5) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk + ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt - WaferCount
                    
                Case SusceptorSize = 8
                    // Round up
	                CntAddition = (WaferCount / 3)
	                If Count(CntAddition, '.') EQ 1 Then
	                    CntAddition = Int(CntAddition) + 1
	                end
	                
	                ThkAddition                                   = (WaferCount / 3) * TargetThickness
	                NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - ThkAddition
                    NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - CntAddition
                    NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk - ThkAddition
                    NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - CntAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - ThkAddition
                    NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - CntAddition
                    NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt - WaferCount
                    
	        End Case
	     	
	    Case ReactorType = 'ASM' OR ReactorType = 'ASM+'
	        
	        ThkAddition = WaferCount * TargetThickness
	        
	        NewReactorRec<REACTOR_TUBE_BELL_JAR_THK$>     = CurrTubeBellJarThk - ThkAddition
            NewReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = CurrTubeBellJarCnt - WaferCount
            NewReactorRec<REACTOR_SUSC_THK$>              = CurrSuscThk - ThkAddition
            NewReactorRec<REACTOR_SUSC_WFR_CNT$>          = CurrSuscWfrCnt - WaferCount
            NewReactorRec<REACTOR_LOWER_QUARTZ_THK$>      = CurrLowerQuartzThk - ThkAddition
            NewReactorRec<REACTOR_LOWER_QUARTZ_WFR$>      = CurrLowerQuartzWfr - WaferCount
	        NewReactorRec<REACTOR_ARMS_WFR_CNT$>          = CurrArmsWfrCnt - WaferCount
	    
	End Case
	
	Database_Services('WriteDataRow', 'REACTOR', ReactorNo, NewReactorRec, 1, 0, 0)
	
end service



//----------------------------------------------------------------------------------------------------------------------
// ResetWfrMetric
//
// RDSNo. - [Required]
// MetricType - [Required]('TUBE_BELL_JAR_THK', 'TUBE_BELL_JAR_WFR_CNT', 'SUSC_THK', 'SUSC_WFR_CNT', 'LOWER_QUARTZ_THK', 'LOWER_QUARTZ_WFR', 'ARMS_WFR_CNT')
//
// Reset a specified REACTOR metric to 0.
// 
//----------------------------------------------------------------------------------------------------------------------
Service ResetWfrMetric(ReactorNo, MetricType = REACTORMETRIC)
	
	ReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
	
	Begin Case
		
		Case MetricType = 'TUBE_BELL_JAR_THK'
			ReactorRec<REACTOR_TUBE_BELL_JAR_THK$> = 0
			
		Case MetricType = 'TUBE_BELL_JAR_WFR_CNT'
			ReactorRec<REACTOR_TUBE_BELL_JAR_WFR_CNT$> = 0
			
		Case MetricType = 'SUSC_THK'
			ReactorRec<REACTOR_SUSC_THK$> = 0
			
		Case MetricType = 'SUSC_WFR_CNT'
			ReactorRec<REACTOR_SUSC_WFR_CNT$> = 0
			
		Case MetricType = 'LOWER_QUARTZ_THK'
			ReactorRec<REACTOR_LOWER_QUARTZ_THK$> = 0
			
		Case MetricType = 'LOWER_QUARTZ_WFR'
			ReactorRec<REACTOR_LOWER_QUARTZ_WFR$> = 0
			
		Case MetricType = 'ARMS_WFR_CNT'
			ReactorRec<REACTOR_ARMS_WFR_CNT$> = 0
			
	End Case
	
	Database_Services('WriteDataRow', 'REACTOR', ReactorNo, ReactorRec, 1, 0, 0)
	
end service


//----------------------------------------------------------------------------------------------------------------------
// GetReactors
//
// Returns a JSON formatted array of reactor objects. Reactor number 0 will be ommitted. If the MatchType or MatchSize
// arguments are populated, the array will be filterd accordingly.
//----------------------------------------------------------------------------------------------------------------------
Service GetReactors(MatchType, MatchSize)
    
    ServiceKeyID   := '*' : MatchType : '*' : MatchSize
    Reactors        = ''
    
    If Memory_Services('IsValueCurrent', ServiceKeyID, 3600, True$) then
        Reactors    = Memory_Services('GetValue', ServiceKeyID)
    end else
        objReactors = ''
        If SRP_JSON(objReactors, 'NEW', 'OBJECT') then
            objReactorArray = ''
            If SRP_JSON(objReactorArray, 'NEW', 'ARRAY') then
                hReactors   = Database_Services('GetTableHandle', 'REACTOR')
                If Error_Services('NoError') then
                    rv = Set_Status(0)
                    RList('SELECT REACTOR BY REACT_NO', 5, '', '', '')
                    Done        = False$
                    Reactors    = ''
                    Loop
                        Readnext ReactorNo else Done = True$
                    Until Done
                        Reactor     = Reactor_Services('GetReactor', ReactorNo)
                        If SRP_JSON(objReactor, 'PARSE', Reactor) EQ '' then
                            ReactorType = SRP_JSON(objReactor, 'GETVALUE', 'Type')
                            ReactorSize = SRP_JSON(objReactor, 'GETVALUE', 'SusceptorSize')
                            IncludeReactor  = True$ ; // Assume reactor will be included in the response.
                            Begin Case
                                Case ReactorNo EQ 0
                                    // Reactor number 0 is not a real reactor.
                                    IncludeReactor  = False$
                                Case MatchType NE ''
                                    Begin Case
                                        Case MatchType[1, 3] EQ 'ASM' AND Not((ReactorType[1, 3] EQ 'ASM' OR ReactorType EQ 'EPS'))
                                            IncludeReactor  = False$
                                        Case MatchType EQ 'EPS' AND Not((ReactorType[1, 3] EQ 'ASM' OR ReactorType EQ 'EPS'))
                                            IncludeReactor  = False$
                                        Case MatchType EQ 'EPP' AND Not((ReactorType EQ 'EPP' OR ReactorType EQ 'EpiPro'))
                                            IncludeReactor  = False$
                                        Case MatchType EQ 'EpiPro' AND Not((ReactorType EQ 'EPP' OR ReactorType EQ 'EpiPro'))
                                            IncludeReactor  = False$
                                        Case MatchType _EQC 'GAN' AND Not(ReactorType _EQC 'GAN')
                                            IncludeReactor  = False$
                                        Case MatchType NE ReactorType
                                            IncludeReactor  = False$
                                    End Case
                                Case MatchSize NE ''
                                    If MatchSize NE ReactorSize then IncludeReactor  = False$
                                Case Not(RowExists('TOOL', 'R':ReactorNo))
                                    // This tool does not exist
                                    IncludeReactor  = False$
                            End Case
                            If IncludeReactor then
                                SRP_JSON(objReactorArray, 'ADD', objReactor)
                            end
                            SRP_JSON(objReactor, 'RELEASE')
                        end
                    Repeat
                    SRP_JSON(objReactors, 'SET', 'Reactors', objReactorArray)
                    Reactors    = SRP_JSON(objReactors, 'STRINGIFY', 'FAST')
                    Memory_Services('SetValue', ServiceKeyID, Reactors)
                end
                SRP_JSON(objReactorArray, 'RELEASE')
            end else
                Error_Services('Add', 'Error creating objReactorArray in the ' : Service : ' service.')
            end
            SRP_JSON(objReactors, 'RELEASE')
        end else
            Error_Services('Add', 'Error creating objReactors in the ' : Service : ' service.')
        end
    end
    
    Response    = Reactors
    
end service


//----------------------------------------------------------------------------------------------------------------------
// GetReactorNumbers
//
// Returns an @FM delimited list of Reactor Numbers.
//----------------------------------------------------------------------------------------------------------------------
Service GetReactorNumbers(MatchType, MatchSize)
    
    ServiceKeyID   := '*' : MatchType : '*' : MatchSize
    ReactorNumbers  = ''
    
    If Memory_Services('IsValueCurrent', ServiceKeyID, 3600, True$) then
        ReactorNumbers  = Memory_Services('GetValue', ServiceKeyID)
    end else
        hReactors       = Database_Services('GetTableHandle', 'REACTOR')
        If Error_Services('NoError') then
            rv = Set_Status(0)
            RList('SELECT REACTOR BY REACT_NO', 5, '', '', '')
            Done        = False$
            Reactors    = ''
            Loop
                Readnext ReactorNo else Done = True$
            Until Done
                Reactor     = Reactor_Services('GetReactor', ReactorNo)
                If SRP_JSON(objReactor, 'PARSE', Reactor) EQ '' then
                    ReactorType = SRP_JSON(objReactor, 'GETVALUE', 'Type')
                    ReactorSize = SRP_JSON(objReactor, 'GETVALUE', 'SusceptorSize')
                    IncludeReactor  = True$ ; // Assume reactor will be included in the response.
                    Begin Case
                        Case ReactorType EQ ''
                            IncludeReactor = False$
                        Case MatchType NE ''
                            Begin Case
                                Case MatchType[1, 3] EQ 'ASM' AND Not((ReactorType[1, 3] EQ 'ASM' OR ReactorType EQ 'EPS'))
                                    IncludeReactor  = False$
                                Case MatchType EQ 'EPS' AND Not((ReactorType[1, 3] EQ 'ASM' OR ReactorType EQ 'EPS'))
                                    IncludeReactor  = False$
                                Case MatchType EQ 'EPP' AND Not((ReactorType EQ 'EPP' OR ReactorType EQ 'EpiPro'))
                                    IncludeReactor  = False$
                                Case MatchType EQ 'EpiPro' AND Not((ReactorType EQ 'EPP' OR ReactorType EQ 'EpiPro'))
                                    IncludeReactor  = False$
                                Case MatchType _EQC 'GAN' AND Not(ReactorType _EQC 'GAN')
                                    IncludeReactor  = False$
                                Case MatchType NE ReactorType
                                    IncludeReactor  = False$
                            End Case
                        Case MatchSize NE ''
                            If MatchSize NE ReactorSize then IncludeReactor  = False$
                    End Case
                    If IncludeReactor then
                        ReactorNumbers := ReactorNo : @FM
                    end
                end
            Repeat
            ReactorNumbers[-1, 1]   = ''
            Memory_Services('SetValue', ServiceKeyID, ReactorNumbers)
        end
    end
    
    Response    = ReactorNumbers
    
end service


//----------------------------------------------------------------------------------------------------------------------
// GetReactor
//
// Returns a JSON formatted object of information related to the indicated reactor number.
//----------------------------------------------------------------------------------------------------------------------
Service GetReactor(ReactorNo)
    
    ServiceKeyID   := '*' : ReactorNo
    Reactor         = ''
    
    If Memory_Services('IsValueCurrent', ServiceKeyID, 3600, True$) then
        Reactor     = Memory_Services('GetValue', ServiceKeyID)
    end else
        If (ReactorNo NE '') AND (ReactorNo NE 0) then
            ReactorRow  = Database_Services('ReadDataRow', 'REACTOR', ReactorNo)
            If SRP_JSON(objReactor, 'NEW', 'OBJECT') then
                ReactorType     = ReactorRow<REACTOR_REACT_TYPE$>
                SRP_JSON(objReactor, 'SETVALUE', 'ReactorNumber', ReactorNo, 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'Type', ReactorType, 'STRING')
                Begin Case
                    Case ReactorType _EQC 'ASM' ; ReactorTypeVerbose = 'ASM'
                    Case ReactorType _EQC 'ASM+'; ReactorTypeVerbose = 'ASM+'
                    Case ReactorType _EQC 'EPP' ; ReactorTypeVerbose = 'EpiPro'
                    Case ReactorType _EQC 'EPS' ; ReactorTypeVerbose = 'ASM'
                    Case ReactorType _EQC 'HTR' ; ReactorTypeVerbose = 'HTR'
                    Case ReactorType _EQC 'GAN' ; ReactorTypeVerbose = 'GaN'
                    Case ReactorType _EQC ''	; ReactorTypeVerbose = '***'
                End Case
                SRP_JSON(objReactor, 'SETVALUE', 'TypeVerbose', ReactorTypeVerbose, 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'AssignmentCode', ReactorRow<REACTOR_REACT_ASSIGNMENT$>, 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'AssignmentDescription', Oconv(ReactorRow<REACTOR_REACT_ASSIGNMENT$>, '[REACT_ASSIGN_CONV]'), 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'Location', ReactorRow<REACTOR_LOCATIONX$>, 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'SusceptorSize', ReactorRow<REACTOR_SUSC_POCKET_SIZE$>, 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'SecondChamber', ReactorRow<REACTOR_SECOND_CHAMBER$>, 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'PickPlace', ReactorRow<REACTOR_PICK_PLACE$>, 'STRING')
                SRP_JSON(objReactor, 'SETVALUE', 'NotRepairable', ReactorRow<REACTOR_NOT_REPAIRABLE$>, 'STRING')
                Reactor     = SRP_JSON(objReactor, 'STRINGIFY', 'FAST')
                Memory_Services('SetValue', ServiceKeyID, Reactor)
                SRP_JSON(objReactor, 'RELEASE')
            end else
                Error_Services('Add', 'Error creating objReactor in the ' : Service : ' service.')
            end
        end else
            Error_Services('Add', 'ReactorNo argument was missing from the ' : Service : ' service.')
        end
    end
    
    Response    = Reactor
    
end service


//----------------------------------------------------------------------------------------------------------------------
// CreatePerformanceTrackers
//
// Creates performance tracking database rows in the REACTOR_PERFORMANCE table. This creates a unique tracker for each
// Reactor/Part pair based on the indicated dates scheduled work orders.
//----------------------------------------------------------------------------------------------------------------------
Service CreatePerformanceTrackers(ScheduleDate, CreateReports)
    
    // Force the auto scheduler to run to make sure that all adjustments are being made to the scheduler.
    *    Schedule_Services('AutoScheduler')
    
    If Num(ScheduleDate) else ScheduleDate = Iconv(ScheduleDate, 'D')
    If ScheduleDate EQ '' then ScheduleDate = Date()
    If CreateReports NE False$ then CreateReports = True$
    
    // There will be two procedures. The first is a pass through the scheduled events to create the Reactor Performance
    // rows. The second is a pass through the recently created Reactor Performance records to adjust the expected
    // wafer count based part changes.
    
    // Get a list of all the scheduled events for the indicated schedule date. Note: this service expects to be ran
    // shortly after midnight for the indicated schedule date.
    ScheduleEvents  = Schedule_Services('GetScheduleEvents', ScheduleDate, ScheduleDate, '', '', False$)
    If ScheduleEvents NE '' then
        PerfKeyIDs  = ''
        For Each ScheduleEvent in ScheduleEvents using @FM
            KeyIDs          = ScheduleEvent<0, 2>
            WorkOrderNo     = KeyIDs[1, '*']
            EpiPartNo       = KeyIDs[Col2() + 1, '*']
            ReactorNo       = KeyIDs[Col2() + 1, '*']
            ScheduleDate    = KeyIDs[Col2() + 1, '*']
            Sequence        = KeyIDs[Col2() + 1, '*']
            If EpiPartNo NE '' then
                PartUsedKeyID   = Service : '*' : ReactorNo : '*' : ScheduleDate : '*' : EpiPartNo
                If Memory_Services('KeyExists', PartUsedKeyID) EQ False$ then
                    PartCountKeyID  = Service : '*' : ReactorNo : '*' : ScheduleDate
                    NumParts        = Memory_Services('GetValue', PartCountKeyID)
                    NumParts       += 1
                    Memory_Services('SetValue', PartCountKeyID, NumParts)
                    Memory_Services('SetValue', PartUsedKeyID, True$)
                end
                // This is a work order event rather than a block out event.
                ScheduleEventSummary    = Schedule_Services('GetScheduleEventSummary', ReactorNo, WorkOrderNo, ScheduleDate, Sequence, True$)
                StartDate               = Iconv(ScheduleEventSummary<6>, 'D')
                ReactorType             = ScheduleEventSummary<1>
                EndDate                 = Iconv(ScheduleEventSummary<7>, 'D')
                TotalWafers             = ScheduleEventSummary<9>
                Begin Case
                    Case ReactorType _eqc 'ASM+'    ; ReactorType = 'ASM+'
                    Case ReactorType _eqc 'EPP'     ; ReactorType = 'EpiPro'
                    Case ReactorType _eqc 'EPS'     ; ReactorType = 'ASM'
                    Case ReactorType _eqc 'HTR'     ; ReactorType = 'HTR'
                    Case ReactorType _eqc 'GAN'     ; ReactorType = 'GaN'
                    Case ReactorType _eqc ''	    ; ReactorType = '***'
                End Case
                MinutesPerWafer = Epi_Part_Services('GetMinutesPerWaferScheduler', EpiPartNo, ReactorType)
                WafersPerDay    = Epi_Part_Services('GetAdjustedWafersPerDayScheduler', EpiPartNo, ReactorType, MinutesPerWafer)
                If ScheduleDate LT EndDate then
                    // The end date of this schedule event is still in the future. Therefore, the current event is expected
                    // to run the whole day. Use the calculated wafers per day.
                    WafersExpected  = WafersPerDay
                end else
                    // This is the end of the schedule event. Wafers expected will be the remaining total wafers after
                    // all previous wafers per day have been deducted.
                    TotalPreviousDays   = EndDate - StartDate
                    TotalPreviousWafers = TotalPreviousDays * WafersPerDay
                    WafersExpected      = TotalWafers - TotalPreviousWafers
                    If WafersExpected GT WafersPerDay then WafersExpected = WafersPerDay    ; // Cap to the wafers per day.
                end
                If WafersExpected LT 0 then WafersExpected = 0
                // Full KeyID = {REACTOR_NO} * {EPI_PART_NO} * {WEEK_YEAR} * {WEEK_NO} * {SCHEDULE_DATE}
                WeekDate    = Date_Services('GetISOWeekDate', ScheduleDate)
                WeekYear    = WeekDate[1, '-']
                WeekNo      = WeekDate[Col2() + 1, '-']
                PerfKeyID   = ReactorNo : '*' : EpiPartNo : '*' : WeekYear : '*' : WeekNo : '*' : ScheduleDate
                PerfRow     = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, True$, 0)
                PerfRow<2>  = PerfRow<2> + Iconv(WafersExpected, 'MD2')
                Database_Services('WriteDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, PerfRow, True$, False$, True$)
                Locate PerfKeyID in PerfKeyIDs using @FM setting fPos else PerfKeyIDs := PerfKeyID : @FM
            end
        Next ScheduleEvent
        
        // Pass through each Reactor Performance row. For every part being run on a given reactor, the following
        // adjustment is required:
        //
        //   1. Total expected amount per part should be prorated by the number of parts. This accounts for the fact
        //      that one reactor will be splitting its time for each part. For example, if Part A is normally estimated
        //      to run 200 parts and Part B is normally estimated to run 300 parts, they will each be prorated by .5.
        //      Thus, Part A will now be estimated to run 100 parts and Part B will be estimated to run 150 parts.
        //
        //   2. Since each part change requires an average of 6 hours of down time to prepare the reactor, the amount
        //      per part should be prorated by the remaining hours in the day. For example, if there are two parts being
        //      ran on the reactor, this only allows 18 hours (out of 24) to run parts, which is a prorated value of
        //      .75. Using the above example, Part A would then have 100 parts prorated to 75 (100 * .75) and Part would
        //      then have 150 parts prorated to 112.50 (150 * .75).
        If PerfKeyIDs NE '' then
            For Each PerfKeyID in PerfKeyIDs using @FM
                ReactorNo       = PerfKeyID[1, '*']
                EpiPartNo       = PerfKeyID[Col2() + 1, '*']
                WeekYear        = PerfKeyID[Col2() + 1, '*']
                WeekNo          = PerfKeyID[Col2() + 1, '*']
                ScheduleDate    = PerfKeyID[Col2() + 1, '*']
                PartCountKeyID  = Service : '*' : ReactorNo : '*' : ScheduleDate
                NumParts        = Memory_Services('GetValue', PartCountKeyID)
                If NumParts GT 1 then
                    // Only prorate if there is more then one part.
                    Prorate1    = 1 / NumParts                          ; // Adjust for the number of parts.
                    Prorate2    = ((24 - ((NumParts - 1) * 6) ) / 24)   ; // Adjust for the number of hours remaining in the day.
                    Prorate     = Prorate1 * Prorate2
                    PerfRow     = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, True$, 0)
                    PerfRow<2>  = PerfRow<2> * ProRate
                    Database_Services('WriteDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, PerfRow, True$, False$, True$)
                end
            Next PerfKeyID
            
            // Clear out all cached data.
            Memory_Services('ReleaseHashTable')
        end
    end
    
    If CreateReports then
        Reactor_Services('CreateDailyPerformanceReport', ScheduleDate)
        If Mod(ScheduleDate, 7) EQ 5 then
            // This is early Friday. Create the weekly performance report for the upcoming week. First, the
            // CreatePerformanceTrackers must be called for all days in the upcoming week.
            NextMonday  = ScheduleDate + 3
            NextSunday  = ScheduleDate + 9
            For ScheduleDate = NextMonday to NextSunday
                Reactor_Services('CreatePerformanceTrackers', ScheduleDate, False$)
            Next ScheduleDate
            // Create the weekly performance report based on the daily performance tracking data.
            YearWeekNo = Date_Services('GetISOWeekDate', NextMonday)
            YearWeekNo = Field(YearWeekNo, '-', 1, 2)
            Reactor_Services('CreateWeeklyPerformanceReport', YearWeekNo)
            // Clear the daily performance tracking data for the upcoming week since these will be recreated
            // automatically on the morning of each date.
            For ScheduleDate = NextMonday to NextSunday
                Reactor_Services('ClearWafersExpected', ScheduleDate)
            Next ScheduleDate
        end
    end
    
end service


//----------------------------------------------------------------------------------------------------------------------
// UpdatePerformanceTrackers
//
// Updates the wafers processed column in the performance tracking database rows.
//----------------------------------------------------------------------------------------------------------------------
Service UpdatePerformanceTrackers(ScheduleDate, CreateReports)   
    
    If Num(ScheduleDate) else ScheduleDate = Iconv(ScheduleDate, 'D')
    If ScheduleDate EQ '' then ScheduleDate = Date()
    If CreateReports NE False$ then CreateReports = True$
    
    rv          = Set_Status(0)
    Sentence    = 'SELECT RDS WITH DATE_OUT EQ ' : Quote(Oconv(ScheduleDate, 'D4/'))
    RList(Sentence, 5, '', '', '')
    EOF         = False$
    Loop
        Readnext RDSID else EOF = True$
    Until EOF
        RDSRow  = Database_Services('ReadDataRow', 'RDS', RDSID)
        If Error_Services('NoError') then
            WeekDate    = Date_Services('GetISOWeekDate', ScheduleDate)
            WeekYear    = WeekDate[1, '-']
            WeekNo      = WeekDate[Col2() + 1, '-']
            ReactorNo   = RDSRow<RDS_REACTOR$>
            ReactorRow  = Database_Services('ReadDataRow', 'REACTOR', ReactorNo, True$, 60, False$)
            ReactorType = ReactorRow<REACTOR_REACT_TYPE$>
            If ReactorType EQ 'EPP' then
                // This is an EpiPro reactor. Check to see if has a second chamber. If so, then this is the primary
                // reactor. If not, then check the previous reactor to see if it references this current reactor as its
                // second chamber. If so then use the previous reactor to track the wafers processed.
                SecondChamber   = ReactorRow<REACTOR_SECOND_CHAMBER$>
                If SecondChamber EQ '' then
                    CompareReactorNo        = ReactorNo - 2
                    CompareReactorRow       = Database_Services('ReadDataRow', 'REACTOR', CompareReactorNo, True$, 60, False$)
                    CompareSecondChamber    = CompareReactorRow<REACTOR_SECOND_CHAMBER$>
                    If CompareSecondChamber EQ ReactorNo then Transfer CompareReactorNo to ReactorNo
                end
            end
            
            *            EpiPartNo   = RDSRow<RDS_PART_NUM$>
            EpiPartNo   = Xlate('RDS', RDSID, 'EPI_PART_NO', 'X')
            // Full KeyID = {REACTOR_NO} * {EPI_PART_NO} * {WEEK_YEAR} * {WEEK_NO} * {SCHEDULE_DATE}
            PerfKeyID   = ReactorNo : '*' : EpiPartNo : '*' : WeekYear : '*' : WeekNo : '*' : ScheduleDate
            PerfRow     = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, True$, 0)
            If Error_Services('NoError') then
                WafersProcessed = RDSRow<RDS_WAFERS_IN$>
                PerfRow<3>      = PerfRow<3> + Iconv(WafersProcessed, 'MD2')
                Database_Services('WriteDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, PerfRow, True$, False$, True$)
            end
        end
    Repeat
    
    If CreateReports then
        Reactor_Services('UpdateDailyPerformanceReport', ScheduleDate)
        If Mod(ScheduleDate, 7) EQ 0 then
            // This is a Sunday, which means the last day of a work week has been updated. Update the weekly performance
            // report but set the date to the previous Monday.
            YearWeekNo = Date_Services('GetISOWeekDate', ScheduleDate - 6)
            YearWeekNo = Field(YearWeekNo, '-', 1, 2)
            Reactor_Services('UpdateWeeklyPerformanceReport', ScheduleDate - 6)
        end
    end
    
end service


//----------------------------------------------------------------------------------------------------------------------
// ClearWafersExpected
//
// Clears the expected wafers for all database rows the REACTOR_PERFORMANCE table based on the indicated schedule date.
//----------------------------------------------------------------------------------------------------------------------
Service ClearWafersExpected(ScheduleDate)
    
    If Num(ScheduleDate) else ScheduleDate = Iconv(ScheduleDate, 'D')
    If ScheduleDate EQ '' then ScheduleDate = Date()
    
    hReactors   = Database_Services('GetTableHandle', 'REACTOR')
    If Error_Services('NoError') then
        If Error_Services('NoError') then
            rv          = Set_Status(0)
            RList('SELECT REACTOR BY REACT_NO', 5, '', '', '')
            Done        = False$
            ReportData  = ''
            Loop
                Readnext ReactorNo else Done = True$
            Until Done
                ReactorRow      = Database_Services('ReadDataRow', 'REACTOR', ReactorNo, True$, 0)
                ReactorType     = ReactorRow<REACTOR_REACT_TYPE$>
                SecondChamber   = ReactorRow<REACTOR_SECOND_CHAMBER$>
                @DICT           = Database_Services('GetTableHandle', 'DICT.REACTOR_PERFORMANCE')
                If (((ReactorNo GT 0) AND (ReactorNo LE 79))) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) then
                    *                If (ReactorNo NE 0) AND (ReactorNo LE 74) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) AND (ReactorType NE 'GAN') then
                    @ID     = ReactorNo : '****' : ScheduleDate
                    @RECORD = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', @ID, True$, 0)
                    If Error_Services('NoError') then
                        DetailPerfKeyIDs    = {ALL_DETAIL_CHILD_KEY_IDS}
                        If DetailPerfKeyIDs NE '' then
                            For Each PerfKeyID in DetailPerfKeyIDs using @VM
                                PerfRow     = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, True$, 0)
                                PerfRow<2>  = ''
                                Database_Services('WriteDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, PerfRow, True$, False$, True$)
                            Next DetailPerfKeyID
                        end
                    end
                end
            Repeat
        end
    end
    
end service


//----------------------------------------------------------------------------------------------------------------------
// ClearWafersProcessed
//
// Clears the processed wafers for all database rows the REACTOR_PERFORMANCE table based on the indicated schedule date.
//----------------------------------------------------------------------------------------------------------------------
Service ClearWafersProcessed(ScheduleDate)
    
    If Num(ScheduleDate) else ScheduleDate = Iconv(ScheduleDate, 'D')
    If ScheduleDate EQ '' then ScheduleDate = Date()
    
    hReactors   = Database_Services('GetTableHandle', 'REACTOR')
    If Error_Services('NoError') then
        If Error_Services('NoError') then
            rv          = Set_Status(0)
            RList('SELECT REACTOR BY REACT_NO', 5, '', '', '')
            Done        = False$
            ReportData  = ''
            Loop
                Readnext ReactorNo else Done = True$
            Until Done
                ReactorRow      = Database_Services('ReadDataRow', 'REACTOR', ReactorNo, True$, 0)
                ReactorType     = ReactorRow<REACTOR_REACT_TYPE$>
                SecondChamber   = ReactorRow<REACTOR_SECOND_CHAMBER$>
                @DICT           = Database_Services('GetTableHandle', 'DICT.REACTOR_PERFORMANCE')
                If (((ReactorNo GT 0) AND (ReactorNo LE 79))) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) then
                    *                If (ReactorNo NE 0) AND (ReactorNo LE 74) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) AND (ReactorType NE 'GAN') then
                    @ID     = ReactorNo : '****' : ScheduleDate
                    @RECORD = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', @ID, True$, 0)
                    If Error_Services('NoError') then
                        DetailPerfKeyIDs    = {ALL_DETAIL_CHILD_KEY_IDS}
                        If DetailPerfKeyIDs NE '' then
                            For Each PerfKeyID in DetailPerfKeyIDs using @VM
                                PerfRow     = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, True$, 0)
                                PerfRow<3>  = ''
                                Database_Services('WriteDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, PerfRow, True$, False$, True$)
                            Next DetailPerfKeyID
                        end
                    end
                end
            Repeat
        end
    end
    
end service


//----------------------------------------------------------------------------------------------------------------------
// CreateDailyPerformanceReport
//
// Creates daily performance tracking report using the database rows in the REACTOR_PERFORMANCE table. This creates an
// Excel spreadsheet using the "Fab Performance Daily Template.xlsx" file as a template.
//----------------------------------------------------------------------------------------------------------------------
Service CreateDailyPerformanceReport(ScheduleDate)
    
    If Num(ScheduleDate) else ScheduleDate = Iconv(ScheduleDate, 'D')
    If ScheduleDate EQ '' then ScheduleDate = Date()
    
    DisplayDate     = Oconv(ScheduleDate, 'D4/')
    XLSXTemplate    = 'Fab Performance Daily Template.xlsx'
    objDocument     = Excel_Services('OpenDocument', TemplatesFolder : XLSXTemplate)
    If Error_Services('NoError') then
        hReactors   = Database_Services('GetTableHandle', 'REACTOR')
        If Error_Services('NoError') then
            If Error_Services('NoError') then
                rv          = Set_Status(0)
                RList('SELECT REACTOR BY REACT_NO', 5, '', '', '')
                Done        = False$
                ReportData  = ''
                Loop
                    Readnext ReactorNo else Done = True$
                Until Done
                    ReactorRow      = Database_Services('ReadDataRow', 'REACTOR', ReactorNo, True$, 0)
                    ReactorType     = ReactorRow<REACTOR_REACT_TYPE$>
                    SecondChamber   = ReactorRow<REACTOR_SECOND_CHAMBER$>
                    @DICT           = Database_Services('GetTableHandle', 'DICT.REACTOR_PERFORMANCE')
                    If (((ReactorNo GT 0) AND (ReactorNo LE 79))) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) then
                        *                    If (ReactorNo NE 0) AND (ReactorNo LE 74) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) AND (ReactorType NE 'GAN') then
                        PerfKeyID           = ReactorNo : '****' : ScheduleDate
                        PerfRow             = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, True$, 0)
                        DetailPerfKeyIDs    = PerfRow<1>
                        If DetailPerfKeyIDs NE '' then
                            For Each @ID in DetailPerfKeyIDs using @VM
                                @RECORD                 = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', @ID, True$, 0)
                                ReactorName             = {REACTOR_NAME}
                                EpiPartNo               = {EPI_PART_NO}
                                WafersExpected          = Oconv({TOTAL_WAFERS_EXPECTED}, 'MD2')
                                WafersExpectedRounded   = Oconv({TOTAL_WAFERS_EXPECTED_ROUNDED}, 'MD2')
                                ReportData             := ReactorType : @VM : ReactorName : @VM : DisplayDate : @VM : EpiPartNo : @VM : WafersExpected : @VM : WafersExpectedRounded : @VM : ReactorNo : @FM
                            Next DetailPerfKeyID
                        end else
                            ReportData := ReactorType : @VM : ReactorNo : @VM : DisplayDate : @VM : '' : @VM : '' : @VM : '' : @VM : ReactorNo : @FM
                        end
                    end
                Repeat
                ReportData[-1, 1]   = ''    ; // Strip off the last @FM
                ReportData          = SRP_Array('SortRows', ReportData, 'AR7' : @VM : 'AL4', 'LIST', @FM, @VM)
                CellRow             = 1     ; // Initialize the cell row to start entering data into.
                
                If ReportData NE '' then
                    For Each ReportRow in ReportData using @FM
                        ReactorType             = ReportRow[1, @VM]
                        ReactorName             = ReportRow[Col2() + 1, @VM]
                        DisplayDate             = ReportRow[Col2() + 1, @VM]
                        EpiPartNo               = ReportRow[Col2() + 1, @VM]
                        WafersExpected          = ReportRow[Col2() + 1, @VM]
                        WafersExpectedRounded   = ReportRow[Col2() + 1, @VM]
                        CellRow                += 1
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'A', CellRow, ReactorType)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'B', CellRow, ReactorName)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'E', CellRow, DisplayDate)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'F', CellRow, EpiPartNo)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'G', CellRow, WafersExpected)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'H', CellRow, WafersExpectedRounded)
                    Next ReportRow
                end
            end
            NewDocument = DisplayDate[7, 4] : '-' : DisplayDate[1, 2] : '-' : DisplayDate[4, 2] : ' Fab Performance.xlsx'
            Excel_Services('SaveDocument', objDocument, DailyReportsFolder : NewDocument)
            If Error_Services('NoError') then
                Call Send_SRP_Mail(DailyReportsFolder : NewDocument)
                rv  = Set_Status(0)
                OSRead PerformanceReport from DailyReportsFolder : NewDocument then
                    OSWrite PerformanceReport to DailyReportsFolder : NewDocument
                    If Status() then
                        Error_Services('Add', 'Error writing ' : DailyReportsFolder : NewDocument : ' in the ' : Service : ' service. Status: ' : Status())
                    end
                end else
                    Error_Services('Add', 'Error reading ' : DailyReportsFolder : NewDocument : ' in the ' : Service : ' service. Status: ' : Status())
                end
            end
        end
    end
    
end service


//----------------------------------------------------------------------------------------------------------------------
// UpdateDailyPerformanceReport
//
// Creates daily performance tracking report using the database rows in the REACTOR_PERFORMANCE table. This creates an
// Excel spreadsheet using the "Fab Performance Daily Template.xlsx" file as a template.
//----------------------------------------------------------------------------------------------------------------------
Service UpdateDailyPerformanceReport(ScheduleDate)
    
    If Num(ScheduleDate) else ScheduleDate = Iconv(ScheduleDate, 'D')
    If ScheduleDate EQ '' then ScheduleDate = Date()
    
    DisplayDate     = Oconv(ScheduleDate, 'D4/')
    Document        = DisplayDate[7, 4] : '-' : DisplayDate[1, 2] : '-' : DisplayDate[4, 2] : ' Fab Performance.xlsx'
    If Excel_Services('DocumentExists', DailyReportsFolder : Document) then
        objDocument     = Excel_Services('OpenDocument', DailyReportsFolder : Document)
    end else
        Error_Services('Add', 'Unable to find ' : Document : ' in the ' : Service : ' service.')
    end
    If Error_Services('NoError') then
        @DICT           = Database_Services('GetTableHandle', 'DICT.REACTOR_PERFORMANCE')
        If Error_Services('NoError') then
            CellRow             = 1     ; // Initialize the cell row to start entering data into.
            Loop
                CellRow    += 1
                Date        = Excel_Services('GetCellValue', objDocument, 'SSR', 'E', CellRow)
            Until Date EQ ''
                ReactorName        = Excel_Services('GetCellValue', objDocument, 'SSR', 'B', CellRow)
                ReactorNo          = ReactorName[1, 'F/']
                EpiPartNo          = Excel_Services('GetCellValue', objDocument, 'SSR', 'F', CellRow)
                WeekDate           = Date_Services('GetISOWeekDate', ScheduleDate)
                WeekYear           = WeekDate[1, '-']
                WeekNo             = WeekDate[Col2() + 1, '-']
                // Full KeyID = {REACTOR_NO} * {EPI_PART_NO} * {WEEK_YEAR} * {WEEK_NO} * {SCHEDULE_DATE}
                @ID                = ReactorNo : '*' : EpiPartNo : '*' : WeekYear : '*' : WeekNo : '*' : ScheduleDate
                @RECORD            = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', @ID, True$, 0)
                WafersProcessed    = Oconv({TOTAL_WAFERS_PROCESSED}, 'MD2')
                WafersDelta        = Oconv({TOTAL_WAFERS_DELTA}, 'MD2')
                WafersDeltaRounded = Oconv({TOTAL_WAFERS_DELTA_ROUNDED}, 'MD2')
                Excel_Services('SetCellValue', objDocument, 'SSR', 'I', CellRow, WafersProcessed)
                Excel_Services('SetCellValue', objDocument, 'SSR', 'K', CellRow, WafersDelta)
                Excel_Services('SetCellValue', objDocument, 'SSR', 'L', CellRow, WafersDeltaRounded)
                //Comment            = Excel_Services('GetCellValue', objDocument, 'SSR', 'M', CellRow)
                //Excel_Services('SetCellValue', objDocument, 'SSR', 'M', CellRow, Comment)
            Repeat
            Excel_Services('SaveDocument', objDocument)
            If Error_Services('NoError') then
                Call Send_SRP_Mail(DailyReportsFolder : Document)
                rv  = Set_Status(0)
                OSRead PerformanceReport from DailyReportsFolder : Document then
                    OSWrite PerformanceReport to DailyReportsFolder : Document
                    If Status() then
                        Error_Services('Add', 'Error writing ' : DailyReportsFolder : Document : ' in the ' : Service : ' service. Status: ' : Status())
                    end
                end else
                    Error_Services('Add', 'Error reading ' : DailyReportsFolder : Document : ' in the ' : Service : ' service. Status: ' : Status())
                end
            end else
                ErrorMessage = Error_Services('GetMessage')
            end
        end
    end
    
end service


//----------------------------------------------------------------------------------------------------------------------
// CreateWeeklyPerformanceReport
//
// Creates weekly performance tracking report using the database rows in the REACTOR_PERFORMANCE table. This creates an
// Excel spreadsheet using the "Fab Performance Weekly Template.xlsx" file as a template.
//----------------------------------------------------------------------------------------------------------------------
Service CreateWeeklyPerformanceReport(YearWeekNo)
    
    // YearWeekNo looks like 2017-W44. For testing purposes it might be easier to pass in a date and the YearWeekNo
    // will be calculated.
    If (Num(Iconv(YearWeekNo, 'D')) AND (Iconv(YearWeekNo, 'D') NE '')) OR Num(YearWeekNo) then
        // A internal or external formatted date was passed in.
        YearWeekNo = Date_Services('GetISOWeekDate', YearWeekNo)
        YearWeekNo = Field(YearWeekNo, '-', 1, 2)
    end
    
    WeekYear        = YearWeekNo[1, '-']
    WeekNo          = YearWeekNo[Col2() + 1, '-']
    XLSXTemplate    = 'Fab Performance Weekly Template.xlsx'
    objDocument     = Excel_Services('OpenDocument', TemplatesFolder : XLSXTemplate)
    If Error_Services('NoError') then
        hReactors   = Database_Services('GetTableHandle', 'REACTOR')
        If Error_Services('NoError') then
            If Error_Services('NoError') then
                rv          = Set_Status(0)
                RList('SELECT REACTOR BY REACT_NO', 5, '', '', '')
                Done        = False$
                ReportData  = ''
                Loop
                    Readnext ReactorNo else Done = True$
                Until Done
                    ReactorRow      = Database_Services('ReadDataRow', 'REACTOR', ReactorNo, True$, 0)
                    ReactorType     = ReactorRow<REACTOR_REACT_TYPE$>
                    SecondChamber   = ReactorRow<REACTOR_SECOND_CHAMBER$>
                    @DICT           = Database_Services('GetTableHandle', 'DICT.REACTOR_PERFORMANCE')
                    If (((ReactorNo GT 0) AND (ReactorNo LE 79))) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) then
                        *                    If (ReactorNo NE 0) AND (ReactorNo LE 74) AND ((ReactorType EQ 'EPP' AND SecondChamber NE '') OR (ReactorType NE 'EPP')) AND (ReactorType NE 'GAN') then
                        PerfKeyID           = ReactorNo : '**' : WeekYear : '*' : WeekNo : '*'
                        PerfRow             = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', PerfKeyID, True$, 0)
                        DetailPerfKeyIDs    = PerfRow<1>
                        If DetailPerfKeyIDs NE '' then
                            DetailPerfKeyIDs            = SRP_Array('SortRows', DetailPerfKeyIDs, 'AL2', 'LIST', @VM, '*')
                            PrevEpiPartNo               = ''
                            TotalWafersExpected         = 0
                            TotalWafersExpectedRounded  = 0
                            For Each @ID in DetailPerfKeyIDs using @VM
                                @RECORD                     = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', @ID, True$, 0)
                                ReactorName                 = {REACTOR_NAME}
                                EpiPartNo                   = {EPI_PART_NO}
                                If (EpiPartNo NE PrevEpiPartNo) AND (PrevepiPartNo NE '') then
                                    // Epi Part No has changed. Add the current totals for the previous Epi Part No to
                                    // the report and reset the variables.
                                    ReportData                 := ReactorType : @VM : ReactorName : @VM : YearWeekNo : @VM : PrevEpiPartNo : @VM : TotalWafersExpected : @VM : TotalWafersExpectedRounded : @VM : ReactorNo : @FM
                                    TotalWafersExpected         = 0
                                    TotalWafersExpectedRounded  = 0
                                end
                                PrevEpiPartNo               = EpiPartNo
                                TotalWafersExpected        += Oconv({TOTAL_WAFERS_EXPECTED}, 'MD2')
                                TotalWafersExpectedRounded += Oconv({TOTAL_WAFERS_EXPECTED_ROUNDED}, 'MD2')
                            Next DetailPerfKeyID
                            // Add the final total values to the report.
                            ReportData := ReactorType : @VM : ReactorName : @VM : YearWeekNo : @VM : PrevEpiPartNo : @VM : TotalWafersExpected : @VM : TotalWafersExpectedRounded : @VM : ReactorNo : @FM
                        end else
                            ReportData := ReactorType : @VM : ReactorNo : @VM : YearWeekNo : @VM : '' : @VM : '' : @VM : '' : @VM : ReactorNo : @FM
                        end
                    end
                Repeat
                ReportData[-1, 1]   = ''    ; // Strip off the last @FM
                ReportData          = SRP_Array('SortRows', ReportData, 'AR7' : @VM : 'AL4', 'LIST', @FM, @VM)
                CellRow             = 1     ; // Initialize the cell row to start entering data into.
                
                If ReportData NE '' then
                    For Each ReportRow in ReportData using @FM
                        ReactorType             = ReportRow[1, @VM]
                        ReactorName             = ReportRow[Col2() + 1, @VM]
                        YearWeekNo              = ReportRow[Col2() + 1, @VM]
                        EpiPartNo               = ReportRow[Col2() + 1, @VM]
                        WafersExpected          = ReportRow[Col2() + 1, @VM]
                        WafersExpectedRounded   = ReportRow[Col2() + 1, @VM]
                        CellRow                += 1
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'A', CellRow, ReactorType)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'B', CellRow, ReactorName)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'E', CellRow, YearWeekNo)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'F', CellRow, EpiPartNo)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'G', CellRow, WafersExpected)
                        Excel_Services('SetCellValue', objDocument, 'SSR', 'H', CellRow, WafersExpectedRounded)
                    Next ReportRow
                end
            end
            NewDocument = YearWeekNo : ' Fab Performance.xlsx'
            Excel_Services('SaveDocument', objDocument, WeeklyReportsFolder : NewDocument)
            If Error_Services('NoError') then
                Call Send_SRP_Mail(WeeklyReportsFolder : NewDocument)
                rv  = Set_Status(0)
                OSRead PerformanceReport from WeeklyReportsFolder : NewDocument then
                    OSWrite PerformanceReport to WeeklyReportsFolder : NewDocument
                    If Status() then
                        Error_Services('Add', 'Error writing ' : WeeklyReportsFolder : NewDocument : ' in the ' : Service : ' service. Status: ' : Status())
                    end
                end else
                    Error_Services('Add', 'Error reading ' : WeeklyReportsFolder : NewDocument : ' in the ' : Service : ' service. Status: ' : Status())
                end
            end
        end
    end
    
end service


//----------------------------------------------------------------------------------------------------------------------
// UpdateWeeklyPerformanceReport
//
// Creates daily performance tracking report using the database rows in the REACTOR_PERFORMANCE table. This creates an
// Excel spreadsheet using the "Fab Performance Daily Template.xlsx" file as a template.
//----------------------------------------------------------------------------------------------------------------------
Service UpdateWeeklyPerformanceReport(YearWeekNo)
    
    // YearWeekNo looks like 2017-W44. For testing purposes it might be easier to pass in a date and the YearWeekNo
    // will be calculated.
    If (Num(Iconv(YearWeekNo, 'D')) AND (Iconv(YearWeekNo, 'D') NE '')) OR Num(YearWeekNo) then
        // A internal or external formatted date was passed in.
        YearWeekNo = Date_Services('GetISOWeekDate', YearWeekNo)
        YearWeekNo = Field(YearWeekNo, '-', 1, 2)
    end
    
    WeekYear        = YearWeekNo[1, '-']
    WeekNo          = YearWeekNo[Col2() + 1, '-']
    Document        = YearWeekNo : ' Fab Performance.xlsx'
    If Excel_Services('DocumentExists', WeeklyReportsFolder : Document) then
        objDocument     = Excel_Services('OpenDocument', WeeklyReportsFolder : Document)
    end else
        Error_Services('Add', 'Unable to find ' : Document : ' in the ' : Service : ' service.')
    end
    If Error_Services('NoError') then
        @DICT           = Database_Services('GetTableHandle', 'DICT.REACTOR_PERFORMANCE')
        If Error_Services('NoError') then
            CellRow             = 1     ; // Initialize the cell row to start entering data into.
            Loop
                CellRow    += 1
                Date        = Excel_Services('GetCellValue', objDocument, 'SSR', 'E', CellRow)
            Until Date EQ ''
                ReactorName         = Excel_Services('GetCellValue', objDocument, 'SSR', 'B', CellRow)
                ReactorNo           = ReactorName[1, 'F/']
                EpiPartNo           = Excel_Services('GetCellValue', objDocument, 'SSR', 'F', CellRow)
                // Full KeyID = {REACTOR_NO} * {EPI_PART_NO} * {WEEK_YEAR} * {WEEK_NO} * {SCHEDULE_DATE}
                @ID                 = ReactorNo : '*' : EpiPartNo : '*' : WeekYear : '*' : WeekNo : '*'
                @RECORD             = Database_Services('ReadDataRow', 'REACTOR_PERFORMANCE', @ID, True$, 0)
                WafersProcessed     = Oconv({TOTAL_WAFERS_PROCESSED}, 'MD2')
                WafersDelta         = Oconv({TOTAL_WAFERS_DELTA}, 'MD2')
                WafersDeltaRounded  = Oconv({TOTAL_WAFERS_DELTA_ROUNDED}, 'MD2')
                Excel_Services('SetCellValue', objDocument, 'SSR', 'J', CellRow, WafersProcessed)
                Excel_Services('SetCellValue', objDocument, 'SSR', 'K', CellRow, WafersDelta)
                Excel_Services('SetCellValue', objDocument, 'SSR', 'L', CellRow, WafersDeltaRounded)
            Repeat
            Excel_Services('SaveDocument', objDocument)
            If Error_Services('NoError') then
                Call Send_SRP_Mail(WeeklyReportsFolder : Document)
                rv  = Set_Status(0)
                OSRead PerformanceReport from WeeklyReportsFolder : Document then
                    OSWrite PerformanceReport to WeeklyReportsFolder : Document
                    If Status() then
                        Error_Services('Add', 'Error writing ' : WeeklyReportsFolder : Document : ' in the ' : Service : ' service. Status: ' : Status())
                    end
                end else
                    Error_Services('Add', 'Error reading ' : WeeklyReportsFolder : Document : ' in the ' : Service : ' service. Status: ' : Status())
                end
            end
        end
    end
    
end service



Service GetReactorCurrLoad(ReactNo)
	
    Response = ''
    ReactStatusRec = Database_Services('ReadDataRow', 'REACT_STATUS', ReactNo)
    LoadedCassettes = ReactStatusRec<REACT_STATUS_LOAD_CASS_ID$>
    Response = LoadedCassettes
    
end service


Service GetReactorCurrLoadRDS(ReactNo)
	
    Response = ''
    ReactStatusRec = Database_Services('ReadDataRow', 'REACT_STATUS', ReactNo)
    LoadedCassettes = ReactStatusRec<REACT_STATUS_LOAD_RDS$>
    Response = LoadedCassettes
    
	
	Response = ''
	ReactStatusRec = Database_Services('ReadDataRow', 'REACT_STATUS', ReactNo)
	LoadedCassettes = ReactStatusRec<REACT_STATUS_LOAD_RDS$>
	Response = LoadedCassettes
	
end service



Service GetReactCurrModeRec(ReactNo)
	
	Response        = ''
	ReactModeRecKey = Xlate('REACTOR_CHILD_KEY_IDS_NG', ReactNo, REACTOR_CHILD_KEY_IDS_REACT_MODE_KEY_IDS$, 'X')
	ReactModeRec    = Database_Services('ReadDataRow', 'REACT_MODE_NG', ReactModeRecKey)
	Response        = ReactModeRec
	
end service



Service GetReactCurrModeId(ReactNo)
	
	Response        = ''
	ReactModeRecKey = Xlate('REACTOR_CHILD_KEY_IDS_NG', ReactNo, REACTOR_CHILD_KEY_IDS_REACT_MODE_KEY_IDS$, 'X')
	Response        = ReactModeRecKey
	
end service



Service GetReactCurrModeName(ReactNo)
	
	Response     = ''
	ReactModeRec = Reactor_Services('GetReactCurrModeRec', ReactNo)
	Response     = ReactModeRec<REACT_MODE_NG_MODE$>
	
end service



Service GetReactModeHistory(ReactNo, DaysToReport)

    StartDt = Date() - DaysToReport
    Response   = ''
    LegacyDate = 19749
    If ( (ReactNo NE '') and (DaysToReport NE '') ) then
        If Date() - DaysToReport LE LegacyDate then
            modeArray  = ''
            // New Modes
            SelectSent = 'SELECT REACT_MODE_NG WITH REACT_NO = ':QUOTE(ReactNo):' AND WITH START_DT > ':QUOTE(OConv(StartDt, 'D4/')):'  BY-DSND START_DTM '
            Set_Status(0)
            RList(SelectSent, TARGET_ACTIVELIST$, "", "", "")
            IF Get_Status(errCode) THEN
                ErrMsg(errCode)
                RETURN
            END
            IF @RecCount then
                EoF = 0
                NumKeys = @RecCount
                Cnt = 0
                
                Loop
                    ReadNext Mode Else EoF = 1
                until EoF
                    RowToAdd           = ''
                    ServiceCategories  = XLATE('REACT_MODE_NG', Mode, 'PROB_CAT_DESC', 'X')
                    swap @VM with @svm in ServiceCategories
                    ServiceDescs       = XLATE('REACT_MODE_NG', Mode, 'SERV_DESC', 'X')
                    ReactorLogID       = XLATE('REACT_MODE_NG', Mode, 'START_RL_ID', 'X')
                    StartDTM           = OCONV(XLATE('REACT_MODE_NG', Mode, 'START_DTM', 'X'),'DT2/^HS')
                    ServiceNotes       = XLATE('REACTOR_LOG',ReactorLogID, REACTOR_LOG_NOTES$, 'X')
                    swap @VM with @svm in ServiceDescs
                    RowToAdd <1,1>     = StartDTM                 
                    RowToAdd <1,2>     = OCONV(XLATE('REACT_MODE_NG', Mode,'ELAP_HRS','X'),'MD2,')
                    RowToAdd <1,3>     = OCONV(XLATE('REACT_MODE_NG', Mode, 'MODE', 'X' ),'[REACT_MODE_CONV]')
                    RowToAdd <1,4>     = XLATE('REACT_MODE_NG', Mode, 'START_NOTES', 'X')
                    RowToAdd <1,5>     = ServiceCategories
                    RowToAdd <1,6>     = XLATE('REACT_MODE_NG', Mode, 'START_USER', 'X')
                    RowToAdd <1,7>     = ReactorLogID
                    RowToAdd <1,8>     = ServiceDescs
                    
                    ServiceNotesDtms      = Xlate('REACTOR_LOG', ReactorLogID, REACTOR_LOG_NOTES_DTMS$, 'X')
                    ServiceNotesUsers     = Xlate('REACTOR_LOG', ReactorLogID, REACTOR_LOG_NOTES_USERS$, 'X')
                    
                    ServiceNotesFormatted = ''
                    For each ServiceNote in ServiceNotes using @VM setting vPos
                        ServiceNotesFormatted<0, vPos> = OConv(ServiceNotesDtms<0, vPos>, 'DT2/^H') : ' - ' : OConv(ServiceNotesUsers<0, vPos>, '[CONV_XLATE,LSL_USERS*FIRST_LAST]') : ' - ' : ServiceNote
                    Next ServiceNote
                    
                    NumNotes = DCount(ServiceNotesFormatted, @VM)
                    // Wrap text using CRLF$
                    For NoteIndex = 1 to NumNotes
                        Note    = ServiceNotesFormatted<0, NoteIndex>
                        NoteLen = Len(Note)
                        If NoteLen GT 100 then
                            NumLoops = Int(NoteLen/100)
                            For LoopIndex = 1 to NumLoops
                                Dummy        = Note[LoopIndex * 100, 'F ']
                                Loc          = Col2()
                                Note[Loc, 0] = CRLF$
                            Next LoopIndex
                            ServiceNotesFormatted<0, NoteIndex> = Note : CRLF$
                        end
                    Next NoteIndex
                    
                    ServiceNotes = ServiceNotesFormatted
                    
                    Swap @VM with CRLF$ in ServiceNotes
                    RowToAdd <1,9>     = ServiceNotes
                    modeArray         := RowToAdd : @FM
                Repeat
                
            end    
            GoSub ClearCursors
            ClearSelect TARGET_ACTIVELIST$
            // Old Modes
            SelectSent = 'SELECT REACT_MODE WITH REACT_NO = ':QUOTE(ReactNo):' AND WITH START_DT > ':QUOTE(OConv(StartDt, 'D4/')):'  BY-DSND START_DTM '
            Set_Status(0)
            RList(SelectSent, TARGET_ACTIVELIST$, "", "", "")
            IF Get_Status(errCode) THEN
                ErrMsg(errCode)
                RETURN
            END
            
            IF @RecCount then
                EoF = 0
                NumKeys = @RecCount
                Cnt = 0
                
                Loop
                    ReadNext Mode Else EoF = 1
                until EoF
                    
                    RowToAdd           = ''
                    ServiceCategories  = XLATE('REACT_MODE', Mode, 'PROB_CAT_DESC', 'X')
                    swap @VM with @svm in ServiceCategories
                    ServiceDescs       = XLATE('REACT_MODE', Mode, 'SERV_DESC', 'X')
                    ReactorLogID       = XLATE('REACT_MODE', Mode, 'START_RL_ID', 'X')
                    StartDTM           = OCONV(XLATE('REACT_MODE', Mode, 'START_DTM', 'X'),'DT2/^HS')
                    ServiceNotes       = XLATE('REACTOR_LOG',ReactorLogID, REACTOR_LOG_NOTES$, 'X')
                    swap @VM with @svm in ServiceDescs
                    RowToAdd <1,1>     = StartDTM                       
                    RowToAdd <1,2>     = OCONV(XLATE('REACT_MODE', Mode,'ELAP_HRS','X'),'MD2,')
                    RowToAdd <1,3>     = OCONV(XLATE('REACT_MODE', Mode, 'MODE', 'X' ),'[REACT_MODE_CONV]')
                    RowToAdd <1,4>     = XLATE('REACT_MODE', Mode, 'START_NOTES', 'X')
                    RowToAdd <1,5>     = ServiceCategories
                    RowToAdd <1,6>     = XLATE('REACT_MODE', Mode, 'START_USER', 'X')
                    RowToAdd <1,7>     = ReactorLogID
                    RowToAdd <1,8>     = ServiceDescs
                    
                    ServiceNotesDtms  = Xlate('REACTOR_LOG', ReactorLogID, REACTOR_LOG_NOTES_DTMS$, 'X')
                    ServiceNotesUsers = Xlate('REACTOR_LOG', ReactorLogID, REACTOR_LOG_NOTES_USERS$, 'X')
                    
                    ServiceNotesFormatted  = ''
                    For each ServiceNote in ServiceNotes using @VM setting vPos
                        ServiceNotesFormatted<0, vPos> = OConv(ServiceNotesDtms<0, vPos>, 'DT2/^H') : ' - ' : OConv(ServiceNotesUsers<0, vPos>, '[CONV_XLATE,LSL_USERS*FIRST_LAST]') : ' - ' : ServiceNote
                    Next ServiceNote
                    
                    NumNotes = DCount(ServiceNotesFormatted, @VM)
                    // Wrap text using CRLF$
                    For NoteIndex = 1 to NumNotes
                        Note    = ServiceNotesFormatted<0, NoteIndex>
                        NoteLen = Len(Note)
                        If NoteLen GT 100 then
                            NumLoops = Int(NoteLen/100)
                            For LoopIndex = 1 to NumLoops
                                Dummy        = Note[LoopIndex * 100, 'F ']
                                Loc          = Col2()
                                Note[Loc, 0] = CRLF$
                            Next LoopIndex
                            ServiceNotesFormatted<0, NoteIndex> = Note : CRLF$
                        end
                    Next NoteIndex
                    
                    ServiceNotes = ServiceNotesFormatted
                    
                    Swap @VM with @SVM in ServiceNotes
                    RowToAdd <1,9>     = ServiceNotes
                    modeArray         := RowToAdd : @FM
                    
                    
                Repeat
                response = modeArray
            end
        end else
            Open 'REACT_MODE_NG' to ReactModeTable then
                OPEN 'DICT.REACT_MODE_NG' TO @DICT then
                    
                    //StartDt = OCONV(StartDt,'D4/')
                    SelectSent = 'SELECT REACT_MODE_NG WITH REACT_NO = ':QUOTE(ReactNo):' AND WITH START_DT > ':QUOTE(OConv(StartDt, 'D4/')):'  BY-DSND START_DTM '
                    Set_Status(0)
                    errCode = ''
                    RList(SelectSent, TARGET_ACTIVELIST$, "", "", "")
                    If Not(Get_Status(errCode)) then
                        @RecCount = 0
                        EOF       = False$
                        Loop
                            Readnext @ID else EOF = True$
                        While EOF EQ False$    
                            READO @RECORD FROM ReactModeTable,@ID then
                                @RecCount             += 1
                                StartDTM               = OCONV({START_DTM},'DT2/^HS')
                                StopDTM                = OCONV({STOP_DTM},'DT2/^HS')
                                ElapsedHrs             = OCONV({ELAP_HRS},'MD2,')
                                Mode                   = OCONV({MODE},'[REACT_MODE_CONV]')
                                StartRLID              = {START_RL_ID}
                                ProbCatIDs             = {PROB_CAT_ID}
                                ProbCatDescs           = {PROB_CAT_DESC}
                                ServIDs                = {SERV_ID}
                                ServDescs              = {SERV_DESC}
                                StartUser              = {START_USER}
                                StopUser               = {STOP_USER}
                                Notes                  = {START_NOTES}
                                ServiceNotes           = XLATE('REACTOR_LOG', StartRLID, REACTOR_LOG_NOTES$, 'X')
                                ServiceNotesDtms       = Xlate('REACTOR_LOG', StartRLID, REACTOR_LOG_NOTES_DTMS$, 'X')
                                ServiceNotesUsers      = Xlate('REACTOR_LOG', StartRLID, REACTOR_LOG_NOTES_USERS$, 'X')
                                ServiceNotesFormatted  = ''
                                
                                For each ServiceNote in ServiceNotes using @VM setting vPos
                                    ServiceNotesFormatted<0, vPos> = OConv(ServiceNotesDtms<0, vPos>, 'DT2/^H') : ' - ' : OConv(ServiceNotesUsers<0, vPos>, '[CONV_XLATE,LSL_USERS*FIRST_LAST]') : ' - ' : ServiceNote
                                Next ServiceNote
                                
                                NumNotes = DCount(ServiceNotesFormatted, @VM)
                                // Wrap text using CRLF$
                                For NoteIndex = 1 to NumNotes
                                    Note    = ServiceNotesFormatted<0, NoteIndex>
                                    NoteLen = Len(Note)
                                    If NoteLen GT 100 then
                                        NumLoops = Int(NoteLen/100)
                                        For LoopIndex = 1 to NumLoops
                                            Dummy        = Note[LoopIndex * 100, 'F ']
                                            Loc          = Col2()
                                            Note[Loc, 0] = CRLF$
                                        Next LoopIndex
                                        ServiceNotesFormatted<0, NoteIndex> = Note : CRLF$
                                    end
                                Next NoteIndex
                                
                                ServiceNotes = ServiceNotesFormatted    
                                
                                FOR I = 1 TO COUNT(ProbCatIDs,@VM) + (ProbCatIDs NE '')
                                    ProbCatDescs<1,I> = ProbCatIDs<1,I>:' - ':ProbCatDescs<1,I>
                                NEXT I
                                
                                FOR I = 1 TO COUNT(ServIDs,@VM) + (ServIDs NE '')
                                    ServDescs<1,I> = ServIDs<1,I>:' - ':ServDescs<1,I>
                                NEXT I
                                
                                SWAP @VM WITH CRLF$ IN ProbCatDescs
                                SWAP @VM WITH CRLF$ IN ServDescs
                                Swap @VM with CRLF$ in ServiceNotes
                                
                                Response<@RecCount, 1> = StartDTM                        
                                Response<@RecCount, 2> = ElapsedHrs
                                Response<@RecCount, 3> = Mode
                                Response<@RecCount, 4> = Notes
                                Response<@RecCount, 5> = ProbCatDescs
                                Response<@RecCount, 6> = StartUser
                                Response<@RecCount, 7> = StartRLID
                                Response<@RecCount, 8> = ServDescs
                                Response<@RecCount, 9> = ServiceNotes
                            end
                        Repeat
                    end else
                        ErrMsg = 'Error in service ':Service:'. Error code: ':errCode:'.'
                        Error_Services('Add', ErrorMsg)          
                    end
                end else
                    ErrorMsg = 'Unable to Open "DICT.REACT_MODE_NG" table!'
                    Error_Services('Add', ErrorMsg)            
                end
            end else
                ErrorMsg = 'Unable to Open "REACT_MODE_NG" table!'
                Error_Services('Add', ErrorMsg)
            end
            
        end
    end
    
end service


Service GetReactorCassLoadHistory(ReactNo, DaysToReport)
    
    Response = ''
    If ( (ReactNo NE '') and (DaysToReport NE '') ) then
        Open 'RDS' to RDSTable then
            OPEN 'DICT.RDS' TO @DICT then
                StartDt    = Date() - DaysToReport
                SelectSent = 'SELECT RDS WITH REACTOR = ':QUOTE(ReactNo):' AND WITH DATE_IN > ':QUOTE(OConv(StartDt, 'D4/')):'  BY-DSND DATETIME_IN '
                Set_Status(0)
                errCode    = ''
                RList(SelectSent, TARGET_ACTIVELIST$, "", "", "")
                If Not(Get_Status(errCode)) then
                    @RecCount = 0
                    EOF       = False$
                    Loop
                        Readnext @ID else EOF = True$
                    While EOF EQ False$    
                        READO @RECORD FROM RDSTable,@ID then
                            @RecCount      += 1
                            RDSNo           = {SEQ}
                            DateIn          = OCONV({DATETIME_IN},'DT2/^HS')
                            DateOut         = OCONV({DATETIME_OUT},'DT2/^HS')
                            LoadOperator    = {OPERATOR_IN}
                            UnLoadOperator  = {OPERATOR_OUT}
                            
                            Response<@RecCount, 1> = RDSNo 
                            Response<@RecCount, 2> = DateIn                        
                            Response<@RecCount, 3> = DateOut
                            Response<@RecCount, 4> = LoadOperator
                            Response<@RecCount, 5> = UnLoadOperator
                        end
                    Repeat
                end else
                    ErrMsg = 'Error in service ':Service:'. Error code: ':errCode:'.'
                    Error_Services('Add', ErrorMsg)          
                end
            end else
                ErrorMsg = 'Unable to Open "DICT.RDS" table!'
                Error_Services('Add', ErrorMsg)            
            end
        end else
            ErrorMsg = 'Unable to Open "RDS" table!'
            Error_Services('Add', ErrorMsg)
        end
    end
    
end service



Service GetReactorCassLoadHistoryRange(ReactNo, StartDTM, StopDTM)
    
    Response = ''
    If ( (ReactNo NE '') and (StartDTM NE '') and (StopDTM NE '')) then
        Open 'RDS' to RDSTable then
            OPEN 'DICT.RDS' TO @DICT then
                SelectSent = 'SELECT RDS WITH REACTOR EQ ':ReactNo:' AND WITH DATETIME_IN GE ':StartDTM:' AND WITH DATETIME_IN LE ':StopDTM:' BY-DSND DATETIME_IN '
                Set_Status(0)
                errCode    = ''
                RList(SelectSent, TARGET_ACTIVELIST$, "", "", "")
                If Not(Get_Status(errCode)) then
                    @RecCount = 0
                    EOF       = False$
                    Loop
                        Readnext @ID else EOF = True$
                    While EOF EQ False$    
                        READO @RECORD FROM RDSTable,@ID then
                            @RecCount      += 1
                            RDSNo           = {SEQ}
                            DateIn          = OCONV({DATETIME_IN},'DT2/^HS')
                            DateOut         = OCONV({DATETIME_OUT},'DT2/^HS')
                            LoadOperator    = {OPERATOR_IN}
                            UnLoadOperator  = {OPERATOR_OUT}
                            
                            Response<@RecCount, 1> = RDSNo 
                            Response<@RecCount, 2> = DateIn                        
                            Response<@RecCount, 3> = DateOut
                            Response<@RecCount, 4> = LoadOperator
                            Response<@RecCount, 5> = UnLoadOperator
                        end
                    Repeat
                end else
                    ErrMsg = 'Error in service ':Service:'. Error code: ':errCode:'.'
                    Error_Services('Add', ErrorMsg)          
                end
            end else
                ErrorMsg = 'Unable to Open "DICT.RDS" table!'
                Error_Services('Add', ErrorMsg)            
            end
        end else
            ErrorMsg = 'Unable to Open "RDS" table!'
            Error_Services('Add', ErrorMsg)
        end
    end
    
end service


Service IncrementCycleCount(ToolID)  
    
    If ToolID NE '' then
        // A reactor number may be passed in. Convert it to the corresponding tool ID if necessary.
        If Num(ToolID) then ToolID = 'R':ToolID
        ToolRec                   = Database_Services('ReadDataRow', 'TOOL', ToolID)
        If Error_Services('NoError') then
            CycleCnt                  = ToolRec<TOOL_CYCLE_CNT$>
            CycleCnt                 += 1
            ToolRec<TOOL_CYCLE_CNT$>  = CycleCnt
            Database_Services('WriteDataRow', 'TOOL', ToolID, ToolRec, True$, False$, True$)
        end
    end
    
end service


Service CreateReactModeChange(UserID, ReactNo, Mode, ModeSubCat, ModeText, ForceModeChange)
    
	LogPath     = Environment_Services('GetApplicationRootPath') : '\LogFiles\ReactorModeChg'
	LogDate     = Oconv(Date(), 'D4/')
	LogTime     = Oconv(Time(), 'MTS')
	LogFileName = LogDate[7, 4] : '-' : LogDate[1, 2] : '-' : LogDate[4, 2] : ' Mode Change Log.csv'
	Headers     = 'Logging DTM' : @FM : 'Notes'
	objLog      = Logging_Services('NewLog', LogPath, LogFileName, CRLF$, ' ', Headers, '', False$, False$, True$)    
    LoggingDTM  = LogDate : ' ' : LogTime   ; // Logging DTM
    
    ErrorMsg           = ''
    IF ForceModeChange NE True$ then ForceModeChange = False$
    If ( (UserID NE '') and (ReactNo NE '') and (Mode NE '') and (ModeSubCat NE '')) then
        CurTime         = Time()
        CurDate         = Date()
        NGPrevModeKey   = Xlate('REACTOR_CHILD_KEY_IDS_NG', ReactNo, REACTOR_CHILD_KEY_IDS_REACT_MODE_KEY_IDS$, 'X')<1, 1>
        PrevModeRec     = Reactor_Services('GetReactCurrModeRec', ReactNo)
        SelectedModeRec = Database_Services('ReadDataRow', 'REACTOR_MODES', Mode)
        SelE10State     = SelectedModeRec<REACTOR_MODES_E10_STATE$>
        
        CommentException = False$
        
        Begin Case
            Case    PrevModeRec<REACT_MODE_NG_MODE$> EQ 'WAITING_FOR_MAINTENANCE_UNSCHEDULED' AND Mode EQ 'MAINTENANCE_UNSCHEDULED'
                CommentException = True$
                
            Case    PrevModeRec<REACT_MODE_NG_MODE$> EQ 'WAITING_FOR_MAINTENANCE_SCHEDULED' AND Mode EQ 'MAINTENANCE_SCHEDULED'
                CommentException = True$
                
            Case    PrevModeRec<REACT_MODE_NG_MODE$> EQ 'WAITING_FOR_ENGINEER_UNSCHEDULED' AND Mode EQ 'ENGINEERING_INVESTIGATION'
                CommentException = True$
            
            Case    PrevModeRec<REACT_MODE_NG_MODE$> EQ 'WAITING_FOR_ENGINEER_SCHEDULED' AND Mode EQ 'ENGINEERING_DEVELOPMENT'
                CommentException = True$
            
            Case    PrevModeRec<REACT_MODE_NG_MODE$> EQ 'WAITING_FOR_ENGTECH_UNSCHEDULED' AND (Mode EQ 'TROUBLESHOOT_ENGTECH' OR Mode EQ 'ENGINEERING_INVESTIGATION')
                CommentException = True$
            
            Case    PrevModeRec<REACT_MODE_NG_MODE$> EQ 'WAITING_FOR_ENGTECH_SCHEDULED' AND Mode EQ 'ENGINEERING_DEVELOPMENT'
                CommentException = True$
                
        End Case
        If ((ModeText NE '') and (Len(ModeText) GE 4)) OR CommentException then
            
            NewModeCategory = SelectedModeRec<REACTOR_MODES_MODE_CATEGORY$>
            OldRlRecordKey  = PrevModeRec<REACT_MODE_NG_START_RL_ID$>
            If Reactor_Log_Services('IsMaint', OldRlRecordKey) AND ForceModeChange EQ False$ then
                If (NOT(Reactor_Log_Services('IsSigned', OldRlRecordKey))) then
                    ErrorMsg = 'The current mode cannot be changed until the technician has signed off on the Reactor Log.'
                end
            end
            
            ModeSubCatID = ''
            Locate ModeSubCat in SelectedModeRec<REACTOR_MODES_SERVICE_CATEGORIES$> using @VM setting SvcPos then
                NewModeSvcList = SelectedModeRec<REACTOR_MODES_SERVICE_CATEGORY_ID$>
                ModeSubCatID   = NewModeSvcList<1,SvcPos>
            end else
                ErrorMsg = 'Failed to locate ModeSubCat.'
            end
			
			CurrentMode = PrevModeRec<REACT_MODE_NG_MODE$>
			ActiveProveInPreventsModeChange = Reactor_Services('ActiveProveInPreventsModeChange', ReactNo, Mode, CurrentMode)
			
			If Error_Services('HasError') then
				ErrorMsg = Error_Services('GetMessage')
			end else
				If ActiveProveInPreventsModeChange EQ True$ then
					ErrorMsg = 'A reactor prove in is required before changing the mode. Active prove in types: '
					
					TypeList     = ''
					ProveInTypes = Reactor_Services('GetActiveProveInTypes', ReactNo)
					for each ProveInType in ProveInTypes using @VM setting Idx
						If Idx GT 1 then
							TypeList := ', '
						end
						TypeList := ProveInType
					Next ProveInType
					
					ErrorMsg := TypeList
				end
			end
			
			IdleStartupRequired = Reactor_Services('GetIdleStartupRequired', ReactNo)
			If ErrorMsg EQ '' and IdleStartupRequired and Mode[1, 2] EQ 'UP' then
				ProveInTypes = Reactor_Services('GetActiveProveInTypes', ReactNo)
				IdleStartupActive = False$
				For each ProveInType in ProveInTypes using @VM setting Idx
					If ProveInType EQ 'IDLE' then
						IdleStartupActive = True$
					end
				Next ProveInType
				
				If IdleStartupActive EQ True$ then
					ErrorMsg = "You must complete the IDLE_STARTUP prove in checklist before putting the reactor UP."
				end else
					ErrorMsg = "An IDLE_STARTUP prove in checklist is required before putting the reactor UP. Change the mode to IDLE_STARTUP, then complete the checklist."
				end
			end
			
			If ErrorMsg EQ '' then
				ActiveHgCVChecklists = Nica_Orders_Services('GetActiveOrders', 'REACTOR', ReactNo, 'IQS_HGCV_ALARM')
				HgCVChecklistActive  = (ActiveHgCVChecklists NE '') 				
				If ( HgCVChecklistActive and (SelE10State _EQC 'Productive') ) then
					ErrorMsg = "An HgCV OCAP Checklist is active for this reactor and must be completed or overridden in order to change to a productive state."
				end
			end
			
			If ErrorMsg EQ '' then
				IntrMaintFeatureFlag = Xlate('FEATURE_FLAGS', 'NICA_INTRUSIVE_MAINTENANCE', FEATURE_FLAGS.ENABLED$, 'X')
				If IntrMaintFeatureFlag EQ True$ then 
					ActiveIntrusiveMaintChecklists = Nica_Orders_Services('GetActiveOrders', 'REACTOR', ReactNo, 'INTRUSIVE_MAINT')
					IntrusiveMaintChecklistActive  = (ActiveIntrusiveMaintChecklists NE '')
					If ( IntrusiveMaintChecklistActive and (SelE10State _EQC 'Productive') ) then
						ErrorMsg = "An Intrusive Maintenance Checklist is active for this reactor and must be completed or overridden in order to change to a productive state."
					end
				end
			end
			
			If ErrorMsg EQ '' then
				If Len(Mode) GT 10 and Mode[1, 10] EQ 'CHANGEOVER' then
					Nica_Orders_Services('CreateNewOrder', 'REACTOR', ReactNo, 'CHANGEOVER')
				end
				
				If Mode EQ 'INITIATE_IDLE' then
					Nica_Orders_Services('CreateNewOrder', 'REACTOR', ReactNo, 'INITIATE_IDLE')
				end
				
				If Mode EQ 'IDLE_STARTUP' then
					Nica_Orders_Services('CreateNewOrder', 'REACTOR', ReactNo, 'IDLE')
				end
            end
            
            If ErrorMsg EQ '' then
                //Log the current Mode Change
                LogData     = ''
                LogData<1>  = Oconv(Date(), 'D4/') : ' ' : Oconv(Time(), 'MTS') ; // Logging DTM
                LogData<2>  = 'Reactor No: ' : ReactNo : ' - Requested Mode Change: ' : Mode
                Logging_Services('AppendLog', objLog, LogData, @RM, @FM, False$)   
                
                OldReactUtilID = PrevModeRec<REACT_MODE_NG_START_RU_ID$>
                
                if OldReactUtilID NE '' then
                    OldReactUtilRec                               = Database_Services('ReadDataRow', 'REACT_UTIL', OldReactUtilID)
                    OldReactUtilRec<react_util_end_date$>         = CurDate
                    OldReactUtilRec<react_util_end_time$>         = CurTime
                    OldReactUtilRec<react_util_mode_finish_user$> = UserId
                    Database_Services('WriteDataRow', 'REACT_UTIL', OldReactUtilID, OldReactUtilRec)
                end
                
                If Error_Services('NoError') then
                    **********************************************************************************
                    * WRITE OUT NEW MODE INFORMATION
                    
                    //Create new React_Util record
                    NewRUKey = NextKey('REACT_UTIL')
                    
                    If Error_Services('NoError') then
                        
                        NewRLKey = NextKey('REACTOR_LOG')
                        
                        If Error_Services('NoError') then
                            
                            RUtilRec                              = ''
                            RUtilRec<react_util_reactor$>         = ReactNo
                            RUtilRec<REACT_UTIL_NOTES$>           = ModeText
                            RMode                                 = ''
                            RUtilRec<react_util_mode$>            = Mode
                            RUtilRec<react_util_start_date$>      = CurDate
                            RUtilRec<react_util_start_time$>      = CurTime
                            RUtilRec<react_util_mode_start_user$> = UserID
                            RUtilRec<react_util_reactor_log_id$>  = NewRLKey
                            // Get current work order from the CONFIG table
                            DailySchedName = 'WO_DAILY_SCHED':ReactNo
                            DSR            = XLATE('CONFIG', DailySchedName, '', 'X')
                            WOCust         = DSR<WOCust$>
                            WorkOrder      = Field(WOCust, ' ', 1)
                            RUtilRec<react_util_wo$>              = WorkOrder
                            RUtilRec<react_util_cust_no$>         = xlate( 'WO_LOG', WorkOrder, wo_log_cust_no$, 'X' )			;
                            ********************************************************************************************************
                            
                            //Create a new Reactor_Log Entry
                            EntryId = UserID
                            
                            RLRec = ''
                            RLRec<reactor_log_start_date$>    = CurDate
                            RLRec<reactor_log_start_time$>    = CurTime
                            RLRec<reactor_log_reactor$>       = ReactNo
                            if NewModeCategory EQ 'MAINTENANCE' then
                                RLRec<reactor_log_category$>      = 'M' ;* for maintenance
                            end
                            RLRec<reactor_log_entry_id$>          = UserID		
                            RLRec<reactor_log_entry_date$>        = CurDate
                            RLRec<reactor_log_react_util_id$>     = NewRUKey
                            RLRec<reactor_log_react_prob_cat_id$> = ModeSubCatID
                            
                            Database_Services('WriteDataRow', 'REACTOR_LOG', NewRLKey, RLRec)
                            If Error_Services('NoError') then
                                Database_Services('WriteDataRow', 'REACT_UTIL', NewRUKey, RUtilRec)
                                If Error_Services('NoError') then
                                    Rec                = ''
                                    Rec<Mode$>         = Mode
                                    Rec<Username$>     = oconv( UserID, '[XLATE_CONV,LSL_USERS*FIRST_LAST]' )
                                    Rec<Date$>         = oconv( CurDate, 'D4/' )
                                    Rec<Time$>         = oconv( CurTime, 'MTH' )
                                    Rec<ReactUtilID$>  = NewRUKey
                                    Rec<ReactorLogID$> = NewRLKey
                                    Rec<Service$>      = ModeSubCat
                                    Rec<Note$>         = ModeText
                                    CurrDTM            = Rec<Date$>:" ":Rec<Time$>
                                    
                                    NGPrevModeDTM = Field(NGPrevModeKey, '*', 2)
                                    PrevModeKey   = NGPrevModeKey
                                    OldMode       = OCONV(XLATE('REACTOR',ReactNo,'CURR_MODE','X'),'[REACT_MODE_CONV]')
                                    OpenDTM       = FIELD(PrevModeKey,'*',2)
                                    OpenDTM       = OCONV(OpenDTM,'DT4/^S')
                                    Mode          = Rec<Mode$>
                                    RecName       = 'REACT_MODE':ReactNo
                                    
                                    * * * * * Changes by JCH on 11/5/2007 * * * * *
                                    ProdModes  = 'Production':@VM
                                    ProdModes := 'Production (incr sampling)':@VM
                                    ProdModes := 'UP_WITH_RESTRICTIONS':@VM
                                    ProdModes := 'UP':@VM
                                    ProdModes := 'UP_WITH_INCREASED_SAMPLING':@VM
                                    ProdModes := 'UP_WITH_INCREASED_SAMPLING_SAMPLING':@VM
                                    ProdModes := 'UP_WITH_INCREASED_SAMPLING_METROLOGY':@VM
                                    ProdModes := 'UP_NOT_RUNNING':@VM
                                    
                                    LogData     = ''
                                    LogData<1>  = Oconv(Date(), 'D4/') : ' ' : Oconv(Time(), 'MTS') ; // Logging DTM
                                    LogData<2>  = 'Reactor No: ' : ReactNo : ' - Current Mode: ' : OldMode : ' - New Mode: ' : Mode
                                    Logging_Services('AppendLog', objLog, LogData, @RM, @FM, False$)
                                    LOCATE OldMode IN ProdModes USING @VM SETTING DUMMY THEN
                                        
                                        LOCATE Mode IN ProdModes USING @VM SETTING DUMMY ELSE
                                            
                                            OutOfProdDTM = Rec<Date$>:' ':Rec<Time$>
                                            
                                            obj_React_Status('SetOutOfProdDTM',ReactNo:@RM:OutOfProdDTM)
                                            
                                            IF Get_Status(errCode) THEN ErrorMsg = errCode
                                            
                                        END		;* End of check on New Mode
                                    END		;* End of check on Current Mode
                                    
                                    * * * End of changes * * * * *
                                    //Write new mode info to config table.
                                    OrigConfigRec = Database_Services('ReadDataRow', 'CONFIG', RecName)
                                    Database_Services('WriteDataRow', 'CONFIG', RecName, Rec)
                                    
                                    If Error_Services('NoError') then
                                        IF OldMode NE '' THEN
                                            crParms  = ReactNo
                                            crParms := @RM:OpenDTM
                                            crParms := @RM:CurrDTM
                                            crParms := @RM:UserID
                                            crParms := @RM:Rec<Note$>
                                            crParms := @RM:Rec<ReactUtilID$>
                                            crParms := @RM:Rec<ReactorLogID$>
                                            LogData     = ''
                                            LogData<1>  = Oconv(Date(), 'D4/') : ' ' : Oconv(Time(), 'MTS') ; // Logging DTM
                                            LogData<2>  = 'Reactor No: ' : ReactNo : ' - obj_React_Mode("Close") - Key ID: ' : ReactNo : '*' : Iconv(OpenDTM, 'DT')
                                            Logging_Services('AppendLog', objLog, LogData, @RM, @FM, False$)
                                            obj_React_Mode('Close',crParms)				;* Close the currently active mode
                                        END
                                        If Not(Get_Status(errCode)) then
                                            
                                            crParms  = ReactNo
                                            crParms := @RM:CurrDTM
                                            crParms := @RM:UserID
                                            crParms := @RM:Mode
                                            crParms := @RM:Rec<Note$>
                                            crParms := @RM:Rec<ReactUtilID$>
                                            crParms := @RM:Rec<ReactorLogID$>
                                            crParms := @RM:ModeSubCat
                                            
                                            LogData     = ''
                                            LogData<1>  = Oconv(Date(), 'D4/') : ' ' : Oconv(Time(), 'MTS') ; // Logging DTM
                                            LogData<2>  = 'Reactor No: ' : ReactNo : ' - obj_React_Mode("Create") - Key ID: ' : ReactNo : '*' : Iconv(CurrDTM, 'DT')
                                            Logging_Services('AppendLog', objLog, LogData, @RM, @FM, False$)
                                            
                                            obj_React_Mode('Create',crParms)		;* Create new active mode record
                                            
                                            IF Get_Status(errCode) THEN
                                                // Failed to create new react mode
                                                ErrorMsg         = errCode
                                                GoSub RollbackReactUtil
                                                // Delete new REACTOR_LOG record
                                                Database_Services('DeleteDataRow', 'REACTOR_LOG', NewRLKey)
                                                // Delete new REACT_UTIL record
                                                Database_Services('DeleteDataRow', 'REACT_UTIL', NewRUKey)
                                                // Rollback CONFIG record
                                                Database_Services('WriteDataRow', 'CONFIG', RecName, OrigConfigRec)
                                                // Reopen previous react mode
                                                Database_Services('WriteDataRow', 'REACT_MODE_NG', NGPrevModeKey, PrevModeRec)
                                            end else
                                                // Check to see if notifications are active for this mode
                                                If SelectedModeRec<REACTOR_MODES_NOTIFICATION_ACTIVE$> then
                                                    //If notifications are active get the classes from the REACTOR_MODE record
                                                    SendToClasses = SelectedModeRec<REACTOR_MODES_NOTIFY_CLASS$>
                                                    For each class in SendToClasses using @VM
                                                        //Send to all the classes
                                                        notesParms       = ''
                                                        IncludeNextShift = False$
                                                        //If we are close to shift change we want to add in the next shift.
                                                        CurrTime         = Time()
                                                        if SRP_Time('Hour', CurrTime) EQ 17 OR SRP_Time('Hour', CurrTime) EQ 5 then
                                                            IncludeNextShift = True$
                                                        end
                                                        Recipients    = LSL_USERS_SERVICES('GetOnShiftUsersByClass', class, IncludeNextShift); *Get all the on shift recipients
                                                        SentFrom      = 'OI_ADMIN'
                                                        Subject       = 'Reactor Mode Notification - ': ReactNo : ' ' : Mode
                                                        Message       = 'Reactor: ' :ReactNo: ' has been placed into ' : Mode :'.'
                                                        Message      := CRLF$ : 'Sub-Category: ' : ModeSubCat
                                                        Message      := CRLF$ : 'User: ' : UserID
                                                        Message      := CRLF$ : 'Notes: '
                                                        Message      := CRLF$ : ModeText
                                                        AttachWindow  = ''
                                                        AttachKey     = ''
                                                        SendToGroup   = ''
                                                        notesParms    = Recipients:@RM:SentFrom:@RM:Subject:@RM:Message:@RM:AttachWindow:@RM:AttachKey:@RM:SendToGroup
                                                        Obj_Notes('Create', notesParms)
                                                    Next class
                                                end
                                                
                                                // If new mode sub category is an ABORT/ALARM or particular Facilities Failure, then apply abort metrology to the oldest loaded RDS
												
												ReactType = Xlate('REACTOR', ReactNo, 'REACT_TYPE', 'X')
												If ReactType NE 'EPP' then 
													Begin Case
														Case ModeSubCat _EQC 'ABORT/ALARM - TC Failure'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Contactor Not Sensed On'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Temp Up Failure'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'Gas Delivery Issue'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'Toxic Gas Alarm'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Facilities Level Failure'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Exhaust System Failure (Scrubber Toxic)'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Gas Flow - TCS'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Gas Flow - Dopant'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Gas Flow - Hydrogen'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Susceptor Faults'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - 24V. Interlock Abort'
															ApplyAbortMet = True$
														Case ModeSubCat _EQC 'ABORT/ALARM - Wafer Handling'
															ApplyAbortMet = True$
														Case Otherwise$
															ApplyAbortMet = False$
													End Case
													
													If ApplyAbortMet then
															
														LogPath     = Environment_Services('GetApplicationRootPath') : '\LogFiles\ReactorAborts'
														LogDate     = Oconv(Date(), 'D4/')
														LogTime     = Oconv(Time(), 'MTS')
														LogFileName = LogDate[7, 4] : '-' : LogDate[1, 2] : '-' : LogDate[4, 2] : ' Reactor Abort Log.csv'
														Headers     = 'Logging DTM' : @FM : 'ReactorNo' : @FM : 'Notes'
														objAbortLog = Logging_Services('NewLog', LogPath, LogFileName, CRLF$, ' ', Headers, '', False$, False$, True$) 
														LoggingDTM  = LogDate : ' ' : LogTime   ; // Logging DTM
														
														LogMsg      = 'Intermediate or Major ABORT/ALARM mode sub category, ':ModeSubCat:'. '
														LogMsg     := 'Attempting to apply abort metrology to loaded RDS.'
														LogData     = ''
														LogData<1>  = LoggingDtm
														LogData<2>  = ReactNo
														LogData<3>  = LogMsg
														Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM)
														
														// Get the loaded RDS key(s) and apply abort metrology. If two are loaded, select the one loaded first.
														LoadedRdsKeys = Xlate('REACT_STATUS', ReactNo, 'LOAD_RDS', 'X')
														If LoadedRdsKeys NE '' then
															
															AbortRds = ''
															
															Begin Case
																Case DCount(LoadedRdsKeys, @VM) EQ 2
																	// Select the oldest one
																	LoadDtms = Xlate('RDS', LoadedRdsKeys, 'DATETIME_IN', 'X')
																	If LoadDtms<0, 2> GT LoadDtms<0, 1> then
																		AbortRds = LoadedRdsKeys<0, 1>
																	end else
																		AbortRds = LoadedRdsKeys<0, 2>
																	end
																	
																	Swap @VM with ' ' in LoadedRdsKeys
																	LogMsg     = 'Two loaded RDS keys, ':LoadedRdsKeys:', found in REACT_STATUS record.'
																	LogData    = ''
																	LogData<1> = LoggingDtm
																	LogData<2> = ReactNo
																	LogData<3> = LogMsg
																	Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM)
																	
																	LogMsg     = 'Selecting RDS ':AbortRDS:' as it was loaded earlier.'
																	LogData    = ''
																	LogData<1> = LoggingDtm
																	LogData<2> = ReactNo
																	LogData<3> = LogMsg
																	Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM)  
																	
																Case DCount(LoadedRdsKeys, @VM) EQ 1
																	// Only one loaded, so use that
																	AbortRds   = LoadedRdsKeys
																	LogMsg     = 'One loaded RDS key, ':AbortRds:', found in REACT_STATUS record.'
																	LogData    = ''
																	LogData<1> = LoggingDtm
																	LogData<2> = ReactNo
																	LogData<3> = LogMsg
																	Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM)                                                 				
																	
																Case Otherwise$
																	// Unexpected condition - log error
																	Swap @VM with ' ' in LoadedRdsKeys
																	LogMsg     = 'Error selecting RDS to apply abort metrology to. Loaded RDS keys, ':LoadedRdsKeys:', found in REACT_STATUS record.'
																	LogData    = ''
																	LogData<1> = LoggingDtm
																	LogData<2> = ReactNo
																	LogData<3> = LogMsg
																	Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM) 
																	
															End Case
															
															If AbortRds NE '' then
																LogMsg     = 'Attempting to apply abort metrology to RDS ':AbortRds:'.'
																LogData    = ''
																LogData<1> = LoggingDtm
																LogData<2> = ReactNo
																LogData<3> = LogMsg
																Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM)
																
																Rds_Services('ApplyAbortMetrology', AbortRds)
																If Error_Services('NoError') then

																	LogMsg     = 'Successfully applied abort metrology to RDS ':AbortRds:'.'
																	LogData    = ''
																	LogData<1> = LoggingDtm
																	LogData<2> = ReactNo
																	LogData<3> = LogMsg
																	Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM) 

																end else
																	
																	ErrorMsg = Error_Services('GetMessage')

																	LogMsg     = 'Error occurred while applying abort metrology to RDS ':AbortRds:'. Error message: ':ErrorMsg
																	LogData    = ''
																	LogData<1> = LoggingDtm
																	LogData<2> = ReactNo
																	LogData<3> = LogMsg
																	Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM) 
																	
																end
															end
															
														end else
															// No loaded RDS runs detected
															LogMsg     = 'No loaded RDS keys found in REACT_STATUS record.'
															LogData    = ''
															LogData<1> = LoggingDtm
															LogData<2> = ReactNo
															LogData<3> = LogMsg
															Logging_Services('AppendLog', objAbortLog, LogData, @RM, @FM)                                                		
														end
													end
                                                end
                                            end
                                        end else
                                            // Failed to close previous react mode
                                            ErrorMsg = errCode
                                            GoSub RollbackReactUtil
                                            // Delete new REACTOR_LOG record
                                            Database_Services('DeleteDataRow', 'REACTOR_LOG', NewRLKey)
                                            // Delete new REACT_UTIL record
                                            Database_Services('DeleteDataRow', 'REACT_UTIL', NewRUKey)
                                            // Rollback CONFIG record
                                            Database_Services('WriteDataRow', 'CONFIG', RecName, OrigConfigRec)
                                        end
                                    END ELSE
                                        ErrorMsg   = 'Reactor No: ' : ReactNo : 'Unable to write ':RecName:' on CONFIG table...' : ReactNo : '*' : Iconv(CurrDTM, 'DT')
                                        LogData    = ''
                                        LogData<1> = Oconv(Date(), 'D4/') : ' ' : Oconv(Time(), 'MTS') ; // Logging DTM
                                        LogData<2> = ErrorMsg
                                        Logging_Services('AppendLog', objLog, LogData, @RM, @FM, False$)
                                        GoSub RollbackReactUtil
                                        // Delete new REACTOR_LOG record
                                        Database_Services('DeleteDataRow', 'REACTOR_LOG', NewRLKey)
                                        // Delete new REACT_UTIL record
                                        Database_Services('DeleteDataRow', 'REACT_UTIL', NewRUKey)
                                    end
                                end else
                                    // Failed to write REACT_UTIL record
                                    ErrorMsg = Error_Services('GetMessage')
                                    GoSub RollbackReactUtil
                                    // Delete new REACTOR_LOG record
                                    Database_Services('DeleteDataRow', 'REACTOR_LOG', NewRLKey)
                                end
                            end else
                                // Failed to write REACTOR_LOG record
                                ErrorMsg = Error_Services('GetMessage')
                                GoSub RollbackReactUtil
                            end
                        end else
                            // Failed to get new REACTOR_LOG key
                            ErrorMsg = Error_Services('GetMessage')
                            GoSub RollbackReactUtil
                        end
                    end else
                        // Failed to get new REACT_UTIL key
                        ErrorMsg = Error_Services('GetMessage')
                        GoSub RollbackReactUtil
                    end
                end else
                    ErrorMsg = Error_Services('GetMessage')
                end
            end
        end else
           Begin Case
               Case ModeText EQ ''
                ErrorMsg = 'You must enter a comment.'
                
                Case Len(ModeText) LT 5
                ErrorMsg = 'Comments must be more than 4 characters...'
           End Case
        end
         
    end else
        
        Begin Case
            
            Case UserID EQ ''
                ErrorMsg = 'Null UserID passed into service.'
                
            Case ReactNo EQ ''
                ErrorMsg = 'You must choose a Reactor.'
                
            Case Mode EQ ''
                ErrorMsg = 'You must choose a VALID Reactor Mode.'
                
            Case ModeSubCat EQ ''
                ErrorMsg = 'You must choose a VALID Reactor Problem Category.'
  
        End Case
    end
    
    If ErrorMsg EQ '' then
        Response = True$
    end else
        Error_Services('Add', 'Error in ':Service:' service. ':ErrorMsg)
        Response = False$
    end
    
end service


Service FormatReactStatusSingle(ReactNo)
	
	Response     = ''
	CurrModeRec  = Reactor_Services('GetReactCurrModeRec', ReactNo)
	CurrLoadings = Reactor_Services('GetReactorCurrLoad', ReactNo)
	
	ReactStatusArray     = CurrModeRec
	ReactStatusArray<12> = CurrLoadings; *Currently loaded cassettes
	
	Response = ReactStatusArray
	
end service


Service GetSingleReactStatusJson(reactNo)
    
    response = ''
    // Create the root object JSON
    If SRP_Json(objReactor, "New") then
        // Create the array of reactors
        If SRP_Json(objReactorArray, "New", "Array") then
            ReactStatusArray = Reactor_Services('FormatReactStatusSingle', reactNo)
            CurrE10State  = Xlate('REACTOR_MODES', ReactStatusArray<REACT_MODE_NG_MODE$>, REACTOR_MODES_E10_STATE$, 'X')
            ModeIconName  = Xlate('REACTOR_MODES', ReactStatusArray<REACT_MODE_NG_MODE$>, REACTOR_MODES_ICON$, 'X')
            RunningStatus = false$
            CurrLoad      = Reactor_Services('GetReactorCurrLoad', ReactNo)
            CurrSubCat    = ReactStatusArray<REACT_MODE_NG_SERVICE_DESC$>
            if CurrLoad NE '' then
                RunningStatus = true$
            end
            objSingleReactor = ''
            If SRP_Json(objSingleReactor, "New") then
                SRP_JSON(objSingleReactor, 'SETVALUE', 'ReactorNumber', reactNo, 'STRING')
                SRP_JSON(objSingleReactor, 'SETVALUE', 'ReactorMode', ReactStatusArray<REACT_MODE_NG_MODE$>, 'STRING')
                SRP_JSON(objSingleReactor, 'SETVALUE', 'E10State', CurrE10State, 'STRING')
                SRP_JSON(objSingleReactor, 'SETVALUE', 'ModeIconName', ModeIconName, 'STRING')
                SRP_JSON(objSingleReactor, 'SETVALUE', 'IsRunning', RunningStatus, 'BOOLEAN')
                SRP_JSON(objSingleReactor, 'SETVALUE', 'ModeSubCat', CurrSubCat, 'STRING')
                SRP_Json(objReactorArray, "Add", objSingleReactor)
                SRP_Json(objSingleReactor, "Release")
            end
            // Now add the array as a member of the root object
            SRP_Json(objReactor, "Set", "reactors", objReactorArray)
            
            // All done with the array object
            SRP_Json(objReactorArray, "Release")
        end
        // Now get the actual JSON
        resultingJSON = SRP_Json(objReactor, "Stringify", "STYLED")
        
        // All done with the root object
        SRP_Json(objReactor, "Release")
    end

    response = resultingJSON
    
end service


Service GetAllReactStatusJson()
    
    Response = ''
    
    AllReactNos = Reactor_Services('GetReactorNumbers')
    
    //Create the root objec JSON
    If SRP_Json(objReactor, "New") then
        //Create the array of reactors
        If SRP_Json(objReactorArray, "New", "Array") then
            //Loop through all reactor nums and add to the array
            for each reactNo in AllReactNos using @FM
                if reactNo NE 'Cln' OR reactNo NE '140' then
                    ReactStatusArray = Reactor_Services('FormatReactStatusSingle', reactNo)
                    CurrE10State     = Xlate('REACTOR_MODES', ReactStatusArray<REACT_MODE_NG_MODE$>, REACTOR_MODES_E10_STATE$, 'X')
                    ModeIconName     = Xlate('REACTOR_MODES', ReactStatusArray<REACT_MODE_NG_MODE$>, REACTOR_MODES_ICON$, 'X')
                    RunningStatus    = false$
                    CurrLoad         = Reactor_Services('GetReactorCurrLoad', ReactNo)
                    if CurrLoad NE '' then
                        RunningStatus = true$
                    end
                    If SRP_Json(objSingleReactor, "New") then
                        SRP_JSON(objSingleReactor, 'SETVALUE', 'ReactorNumber', reactNo, 'STRING')
                        SRP_JSON(objSingleReactor, 'SETVALUE', 'ReactorMode', ReactStatusArray<REACT_MODE_NG_MODE$>, 'STRING')
                        SRP_JSON(objSingleReactor, 'SETVALUE', 'E10State', CurrE10State, 'STRING')
                        SRP_JSON(objSingleReactor, 'SETVALUE', 'ModeIconName', ModeIconName, 'STRING')
                        SRP_JSON(objSingleReactor, 'SETVALUE', 'IsRunning', RunningStatus, 'BOOLEAN')
                        SRP_Json(objReactorArray, "Add", objSingleReactor)
                        SRP_Json(objSingleReactor, "Release")
                    end
                end
                
                
            Next reactNo
            // Now add the array as a member of the root object
            SRP_Json(objReactor, "Set", "reactors", objReactorArray)
            
            // All done with the array object
            SRP_Json(objReactorArray, "Release")
        end
        // Now get the actual JSON
        resultingJSON = SRP_Json(objReactor, "Stringify", "STYLED")
        
        // All done with the root object
        SRP_Json(objReactor, "Release")
    end

    response = resultingJSON
    
end service


Service IsReactorLoaded(ReactNo)
	
	ErrorMsg = ''
	Response = False$
	If ReactNo NE '' then
		LoadedRDS = Xlate('REACT_STATUS', ReactNo, 'LOAD_RDS', 'X')
		If LoadedRDS NE '' then Response = True$
	end else
		ErrorMsg = 'Error in ':Service:' service. Null ReactNo passed in.'
	end
	If ErrorMsg NE '' then
		Error_Services('Add', ErrorMsg)
	end
	
end service


Service GetReactorTimeSinceUnload(ReactNo)
	
	ErrorMsg = ''
	Response = 0
	
	If ReactNo NE '' then
		LastUnloadTime = Xlate('REACT_STATUS', ReactNo, 'UNLOAD_DTM', 'X')
		
		Response = SRP_DateTime("MinuteSpan", LastUnloadTime, Datetime(), 0)
	end else
		ErrorMsg = 'Error in ':Service:' service. Null ReactNo passed in.'
	end
	
	If ErrorMsg NE '' then
		Error_Services('Add', ErrorMsg)
	end
	
end service


Service ConvertRecordToJSON(ReactorNo, ItemURL, CurrUser, FullObject=BOOLEAN)
	
	If FullObject EQ '' then FullObject = True$
	ErrorMsg = ''
	JSON     = ''
	If ReactorNo then
		objJSON = ''
		If SRP_JSON(objJSON, 'New', 'Object') then
			// Add in reactor current mode, available modes, and available sub categories.
			CurrModeKey = Reactor_Services('GetReactCurrModeId', ReactorNo)
			CurrMode    = Xlate('REACT_MODE_NG', CurrModeKey, REACT_MODE_NG_MODE$, 'X')
			ServiceDesc = Xlate('REACT_MODE_NG', CurrModeKey, REACT_MODE_NG_SERVICE_DESC$, 'X')
			If (CurrUser NE '') then AvailModes = Reactor_Modes_Services('AvailableModes', CurrMode, CurrUser)
			CurrRLKey   = Xlate('REACT_MODE_NG', CurrModeKey, REACT_MODE_NG_START_RL_ID$ , 'X')
			ReactorType = Xlate('REACTOR', ReactorNo, 'REACT_TYPE', 'X')
			ReactAssign = Xlate('REACTOR', ReactorNo, 'REACT_ASSIGNMENT', 'X')
			React_Assign_Conv('OCONV', ReactAssign, '', ReactAssign)
			// Create reactor object
			If SRP_JSON(objReactor, 'New', 'Object') then
				SRP_JSON(objReactor, 'SetValue', 'reactorNo', ReactorNo)
				SRP_JSON(objReactor, 'SetValue', 'reactType', ReactorType)
				SRP_JSON(objReactor, 'SetValue', 'reactAssignment', ReactAssign)
				PickPlace     = Xlate('REACTOR', ReactorNo, 'PICK_PLACE', 'X')
				SRP_JSON(objReactor, 'SetValue', 'pickPlace', PickPlace, 'Boolean')
				LLDisabledKey = Xlate('REACTOR', ReactorNo, 'ACTIVE_LL_DISABLED', 'X')
				LoadLockDisabled = Xlate('REACT_LL', LLDisabledKey, 'DISABLED', 'X')
				SRP_JSON(objReactor, 'SetValue', 'loadLockDown', LoadLockDisabled)
				SRP_JSON(objReactor, 'SetValue', '0311Active', Xlate('REACTOR', ReactorNo, '0311_ACTIVE', 'X'), 'Boolean')
				SRP_JSON(objReactor, 'SetValue', 'active0311Checklist', Xlate('REACTOR', ReactorNo, '0311_ACTIVE', 'X'), 'Boolean')
				SRP_JSON(objReactor, 'SetValue', 'TubeBellJarCnt', Xlate('REACTOR', ReactorNo, REACTOR_TUBE_BELL_JAR_THK$, 'X'))
				SRP_JSON(objReactor, 'SetValue', 'TubeBellJarThk', Xlate('REACTOR', ReactorNo, REACTOR_TUBE_BELL_JAR_WFR_CNT$, 'X'))
				SRP_JSON(objReactor, 'SetValue', 'SusceptorCnt', Xlate('REACTOR', ReactorNo, REACTOR_SUSC_WFR_CNT$, 'X'))
				SRP_JSON(objReactor, 'SetValue', 'SusceptorThk', Xlate('REACTOR', ReactorNo, REACTOR_SUSC_THK$, 'X'))
				SRP_JSON(objReactor, 'SetValue', 'LowerQuartzCnt', Xlate('REACTOR', ReactorNo, REACTOR_LOWER_QUARTZ_WFR$, 'X'))
				SRP_JSON(objReactor, 'SetValue', 'LowerQuartzThk', Xlate('REACTOR', ReactorNo, REACTOR_LOWER_QUARTZ_THK$, 'X'))
				SRP_JSON(objReactor, 'SetValue', 'ArmsCnt', Xlate('REACTOR', ReactorNo, REACTOR_ARMS_WFR_CNT$, 'X'))
				
				// Add Current Run Status (Current Loaded Cassettes)
				LoadedRDS   = Xlate('REACT_STATUS', ReactorNo, 'LOAD_RDS', 'X')
				If LoadedRDS NE '' then
					objLoadedRDS = ''
					If SRP_JSON(objLoadedRDS, 'New', 'Array') then
						For each RDS in LoadedRDS using @VM setting vPos
							SRP_JSON(objLoadedRDS, 'AddValue', RDS)
						Next RDS
						SRP_JSON(objReactor, 'Set', 'loadedRDS', objLoadedRDS)
						SRP_JSON(objLoadedRDS, 'Release')
					end
				end else
					SRP_JSON(objReactor, 'SetValue', 'loadedRDS', '')
				end
				
				// Add new reactor items here
				InstItems = Xlate('REACTOR', ReactorNo, REACTOR_CURR_INST_ITEMS$, 'X')
				If InstItems NE '' then
					objInstItems = ''
					If SRP_JSON(objInstItems, 'New', 'Array') then
						For each Item in InstItems using @VM setting vPos
							swap '*' with @VM in Item
							SRP_JSON(objInstItems, 'AddValue', Item<1, 2>)
						Next Item
						SRP_JSON(objReactor, 'Set', 'installedReactItems', objInstItems)
						SRP_JSON(objInstItems, 'Release')
					end
				end else
					SRP_JSON(objReactor, 'SetValue', 'installedReactItems', '')
				end
				
				// Add Current Run Status (Is running)
				ReactorRunning = (LoadedRDS NE '')
				SRP_JSON(objReactor, 'SetValue', 'isRunning', ReactorRunning, 'Boolean')
				
				// Add Out of prod time
				OutofProdDTM = Xlate('REACT_STATUS', ReactorNo, 'OUT_OF_PROD_DTM', 'X')
				SRP_JSON(objReactor, 'SetValue', 'outOfProdDTM', OConv(OutofProdDTM, 'DT2/^H'))
				
				If FullObject then
					// Add Last Unload Time
					LastUnloadDTM = Xlate('REACT_STATUS', ReactorNo, 'UNLOAD_RDS_DTM', 'X')
					SRP_JSON(objReactor, 'SetValue', 'unloadDTM', OConv(LastUnloadDTM, 'DT2/^H'))
					
					// Add Last Load Time
					LastLoadDTM = Xlate('REACT_STATUS', ReactorNo, 'LOAD_RDS_DTM', 'X')
					LastLoadDTM = LastLoadDTM[-1, 'B':@VM]
					SRP_JSON(objReactor, 'SetValue', 'loadDTM', OConv(LastLoadDTM, 'DT2/^H'))
					
					// Add Last Reactor Readings
					LastReadWfrsDTM	= Xlate('REACTOR', ReactorNo, 'LAST_READ_WFRS_DTM', 'X')
					LastReadWfrs	= Xlate('REACT_READS', ReactorNo:'*':LastReadWfrsDTM, 'WAFER_CNT', 'X')
					SRP_JSON(objReactor, 'SetValue', 'lastReadWafersDTM', OConv(LastReadWfrsDTM, 'DT2/^H'))
					SRP_JSON(objReactor, 'SetValue', 'lastReadWafers', LastReadWfrs)
				end
				
				// Add work order object
				SchedConfigRec = Database_Services('ReadDataRow', 'CONFIG', 'WO_DAILY_SCHED':ReactorNo)
				WorkOrderCust  = SchedConfigRec<WOCust$>
				CurrWorkOrder  = Field(WorkOrderCust, ' ', 1)
				SRP_JSON(objReactor, 'SetValue', 'workOrder', CurrWorkOrder)
				WOHotStatus    = Xlate('WO_LOG', CurrWorkOrder, 'HOT_FLAG', 'X')
				SRP_JSON(objReactor, 'SetValue', 'workOrderHotStatus', WOHotStatus)
				WOCustomer     = Field(WorkOrderCust, ' ', 2)
				SRP_JSON(objReactor, 'SetValue', 'workOrderCustomer', WOCustomer)
				If FullObject then
					JSONWorkOrder = Work_Order_Services('ConvertRecordToJSON', CurrWorkOrder)
					objWorkOrder  = '' 
					If SRP_JSON(objWorkOrder, 'Parse', JSONWorkOrder) EQ '' then
						objTemp = SRP_JSON(objWorkOrder, 'Get', 'workOrder')
						SRP_JSON(objReactor, 'Set', 'workOrder', objTemp)
						SRP_JSON(objTemp, 'Release')
						SRP_JSON(objWorkOrder, 'Release')
					end
				end
				
				// Reactor Mode object/properties
				If FullObject then
					// Add reactor mode object
					JSONReactorMode = React_Mode_NG_Services('ConvertRecordToJSON', CurrModeKey, '', CurrUser)
					objReactorMode  = ''
					If SRP_JSON(objReactorMode, 'Parse', JSONReactorMode) EQ '' then
						objTemp = SRP_JSON(objReactorMode, 'Get', 'reactorMode')
						SRP_JSON(objReactor, 'Set', 'reactorMode', objTemp)
						SRP_JSON(objTemp, 'Release')
						SRP_JSON(objReactorMode, 'Release')
					end
				end else
					CurrMode = Xlate('REACT_MODE_NG', CurrModeKey, 'MODE', 'X')
					SubCat   = Xlate('REACT_MODE_NG', CurrModeKey, 'SERVICE_DESC', 'X')
					E10State = Xlate('REACTOR_MODES', CurrMode, 'E10_STATE', 'X')
					SRP_JSON(objReactor, 'SetValue', 'currMode', CurrMode)
					SRP_JSON(objReactor, 'SetValue', 'serviceDesc', SubCat)
					SRP_JSON(objReactor, 'SetValue', 'e10State', E10State)
				end
				
				If Not(FullObject) then
					// Add reactor log properties
					CurrRlKey = Xlate('REACTOR', ReactorNo, 'CURR_MODE_RL_ID', 'X')
					If CurrRLKey NE '' then
						RlChecklistActive   = Xlate('REACTOR_LOG', CurrRlKey, 'CHECKLIST_ACTIVE', 'X')
						SRP_JSON(objReactor, 'SetValue', 'reactorLogChecklistActive', RlChecklistActive, 'Boolean')
						If RlChecklistActive then
							RlChecklistTypes    = Xlate('REACTOR_LOG', CurrRlKey, 'CHECKLIST_TYPE', 'X')
							RlChecklistOrderIds = Xlate('REACTOR_LOG', CurrRlKey, 'CHECKLIST_ORDER_ID', 'X')
							objRlChecklistArray = ''
							If SRP_JSON(objRlChecklistArray, 'New', 'Array') then
								objChecklist = ''
								For each RlChecklistType in RlChecklistTypes using @VM setting vPos
									If SRP_JSON(objChecklist, 'New', 'Object') then
										SRP_JSON(objChecklist, 'SetValue', 'reactorLogChecklistType', RlChecklistType)
										RlChecklistOrderId = RlChecklistOrderIds<0, vPos>
										SRP_JSON(objChecklist, 'SetValue', 'reactorLogChecklistOrderId', RlChecklistOrderId)
										SRP_JSON(objRlChecklistArray, 'Add', objChecklist)
										SRP_JSON(objChecklist, 'Release')
									end
								Next RlChecklistType
								SRP_JSON(objReactor, 'Set', 'reactorLogChecklists', objRlChecklistArray)
								SRP_JSON(objRlChecklistArray, 'Release')
							end
						end
					end
					// Add prove in checklist properties
					PiChecklistActive = Xlate('REACTOR', ReactorNo, 'PROVE_IN_ACTIVE', 'X')
					SRP_JSON(objReactor, 'SetValue', 'proveInChecklistActive', PiChecklistActive, 'Boolean')
					If PiChecklistActive then
						PiTypes             = Xlate('REACTOR', ReactorNo, 'PROVE_IN_TYPE', 'X')
						PiChecklistOrderIds = Xlate('REACTOR', ReactorNo, 'PROVE_IN_ORDER_ID', 'X')
						objPiChecklistArray = ''
						If SRP_JSON(objPiChecklistArray, 'New', 'Array') then
							objProveIn = ''
							For each PiType in PiTypes using @VM setting vPos
								If SRP_JSON(objProveIn, 'New', 'Object') then
									SRP_JSON(objProveIn, 'SetValue', 'proveInType', PiType)
									PiChecklistOrderId = PiCheckListOrderIds<0, vPos>
									SRP_JSON(objProveIn, 'SetValue', 'proveInOrderId', PiChecklistOrderId)
									SRP_JSON(objPiChecklistArray, 'Add', objProveIn)
									SRP_JSON(objProveIn, 'Release')
								end
							Next PiType
							SRP_JSON(objReactor, 'Set', 'proveInChecklists', objPiChecklistArray)
							SRP_JSON(objPiChecklistArray)
						end
					end
				end
				
				If itemURL NE '' then
					// The itemURL was passed in so add HAL+JSON properties.
					objLinks = ''
					// Create the _links property and then all link objects needed for this resource.
					If SRP_JSON(objLinks, 'New', 'Object') then
						// Create a self link.
						objLink = ''
						If SRP_JSON(objLink, 'New', 'Object') then
							SRP_JSON(objLink, 'SetValue', 'href', ItemURL, 'String')
							SRP_JSON(objLink, 'SetValue', 'title', 'Self', 'String')
							SRP_JSON(objLinks, 'Set', 'self', objLink)
							SRP_JSON(objLink, 'Release')
						end
						SRP_JSON(objReactor, 'Set', '_links', objLinks)
						SRP_JSON(objLinks, 'Release')
					end
					// Create the _class property for this resource.
					SRP_JSON(objReactor, 'SetValue', '_class', 'resource')
				end
				SRP_JSON(objJSON, 'Set', 'reactor', objReactor)
				SRP_JSON(objReactor, 'Release')
			end
			JSON = SRP_JSON(objJSON, 'Stringify', 'Styled')
			SRP_JSON(objJSON, 'Release')
		end else
			ErrorMsg = 'Error in ':Service:' service. Error creating JSON object.'
		end
	end else
		ErrorMsg = 'Error in ':Service:' service. Null ReactNo passed in.'
	end
	
	If ErrorMsg EQ '' then
		Response = JSON
	end else
		Error_Services('Add', ErrorMsg)
	end
	
end service


Service ConvertJSONToRecord(KeyID, JSON)
	
	Record = ''
	If JSON NE '' then
		If SRP_JSON(objJSON, 'Parse', JSON) EQ '' then
			objReactor = SRP_JSON(objJSON, 'Get', 'reactor')
			Record     = Database_Services('ReadDataRow', 'REACTOR', KeyID)
			If Error_Services('NoError') then
				// Add code to update additional columns as needed.
				// If property is "" then clear the field.
				// If property is null then do not update it.
				NewVal                       = SRP_JSON(objReactor, 'GetValue', '0311Active')
				If NewVal NE 'null' then
					Record<REACTOR_0311_ACTIVE$> = NewVal
				end
			end
			SRP_JSON(objReactor, 'Release')
			SRP_JSON(objJSON, 'Release')
		end else
			Error_Services('Add', 'Error in ':Service:' service. Unable to parse JSON payload.')
		end
	end else
		Error_Services('Add', 'Error in ':Service:' service. Null JSON passed in.')
	end
	
	Response = Record
	
end service


Service CleanReactStatus()
	
	hSysLists = Database_Services('GetTableHandle', 'SYSLISTS')
	Lock hSysLists, ServiceKeyID then
		ReactNos  = Reactor_Services('GetReactorNumbers')
		For each ReactNo in ReactNos using @FM
			HaveLock         = Database_Services('GetKeyIDLock', 'REACT_STATUS', ReactNo)
			If HaveLock then
				OrigReactStatRec = Database_Services('ReadDataRow', 'REACT_STATUS', ReactNo)
				ReactStatRec     = OrigReactStatRec
				If Error_Services('NoError') then
					For Col = 1 to 9
						OrigList = OrigReactStatRec<Col>
						If OrigList NE '' then
							CleanList = ''
							For each Val in OrigList using @VM
								If Val NE 1 then CleanList<0, -1> = Val
							Next Val
							ReactStatRec<Col> = CleanList
						end
					Next Col
					If OrigReactStatRec NE ReactStatRec then
						Database_Services('WriteDataRow', 'REACT_STATUS', ReactNo, ReactStatRec, True$, False$, False$)
					end else
						Database_Services('ReleaseKeyIDLock', 'REACT_STATUS', ReactNo)
					end
				end
			end
		Next ReactNo
		Unlock hSysLists, ServiceKeyID else Null
	end
	
end service


Service GetReactModeKeysByTimeSpan(ReactorNo, StartDtm, StopDtm)
	
    Begin Case
        Case ReactorNo Eq ''
            Error_Services('Add', 'Error in ' : Service : ' service. ReactorNo not supplied.')
        Case StartDtm Eq ''
            Error_Services('Add', 'Error in ' : Service : ' service. StartDtm not supplied.')
        Case StopDtm Eq ''
            Error_Services('Add', 'Error in ' : Service : ' service. StopDtm not supplied.')
    End Case
    If Error_Services('NoError') then
        //Get all modes within the StartDtm and StopDtm
        StartDt = FIELD(StartDtm, '.', 1)
        StopDt  = Field(StopDtm, '.', 1)
        keys    = ''
        OPEN 'DICT.REACT_MODE_NG' TO @DICT then
            SearchString  = ''
            SearchString := "START_DTM" :@VM: StartDtm : '~' : StopDtm: @FM
            SearchString := "STOP_DTM" :@VM: ';' : StartDtm : '~' : StopDtm : @FM
            SearchString := "REACT_NO" :@VM: ReactorNo : @FM
            keylist       = ""
            option        = ""
            flag          = ""
            Btree.Extract(SearchString, 'REACT_MODE_NG', @DICT, keylist, option, flag)
            for each key in keylist
                keys<-1> = key
            Next key
        end
        if keys<1> EQ '' then
            //Get Current Mode because it started before report date and has yet to finish
            //Is the report time for the current mode?
            CurrReactorModeKey      = Reactor_Services('GetReactCurrModeId', ReactorNo)
            CurrReactorModeStartDtm = Field(CurrReactorModeKey, '*', 2)
            IF StopDtm GT CurrReactorModeStartDtm then
                keys<-1> = CurrReactorModeKey
            end else
                //
                SearchString  = ''
                SearchString := "START_DTM" :@VM: '<=' : StartDtm: @FM
                SearchString := "STOP_DTM" :@VM: '>=' : StopDtm : @FM
                SearchString := "REACT_NO" :@VM: ReactorNo : @FM
                SubKeyList    = ""
                option        = ""
                flag          = ""
                Btree.Extract(SearchString, 'REACT_MODE_NG', @DICT, SubKeyList, option, flag)
                for each SubKey in SubKeyList
                    keys<-1> = SubKey
                Next SubKey
            end
            
            
            //Is the report time outside of the current mode
        end
        Response = keys
    end else
        Response = Error_Services('GetMessage')
    end
    
end service



Service GetReactorUptimeMetricsByTimeSpan(ReactorNo, StartDtm, StopDtm)
	
    ToolData                     = ''
    TotalProductiveMinutes      = 0
    TotalUnscheduledDownMinutes = 0
    TotalScheduledDownMinutes   = 0
    TotalNonSchedMinutes   = 0
    TotalEngMinutes = 0
    
    Begin Case
        Case ReactorNo Eq ''
            Error_Services('Add', 'Error in ' : Service : ' service. ReactorNo not supplied.')
        Case StartDtm Eq ''
            Error_Services('Add', 'Error in ' : Service : ' service. StartDtm not supplied.')
        Case StopDtm Eq ''
            Error_Services('Add', 'Error in ' : Service : ' service. StopDtm not supplied.')
    End Case
    //If StopDtm is in future then set it to current time.
    If StopDtm GT Datetime()  then
        StopDtm = Datetime()
    end
    If Error_Services('NoError') then
        
        //Get Keys for the supplied time span
        ReactModeNGKeys    = Reactor_Services('GetReactModeKeysByTimeSpan', ReactorNo, StartDtm, StopDtm)
        If Error_Services('NoError') then
            //Get total minutes of timespan.
            TotalReportMinutes = SRP_Datetime('MinuteSpan', StartDtm, StopDtm)
            //Loop Through each mode key returned
            
            for each key in ReactModeNGKeys using @VM
                ReactModeNGRec = Database_Services('ReadDataRow', 'REACT_MODE_NG', key)
                ModeStartDtm   = Field(key, '*', 2)
                ModeStopDtm    = ReactModeNGRec<REACT_MODE_NG_STOP_DTM$>
                ReactModeName  = ReactModeNGRec<REACT_MODE_NG_MODE$>
                E10State       = Xlate('REACTOR_MODES', ReactModeName, REACTOR_MODES_E10_STATE$, 'X')
                MinutesInMode  = 0
                Begin Case
                    CASE E10State EQ 'Productive'
                        //Begin Production
                        if ModeStartDtm LT StartDtm then
                        //Mode Started Earlier than report time
                        If ModeStopDtm LT StopDtm then
                            //Mode finished within the timespan
                            If ModeStopDtm NE '' then
                                MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, ModeStopDtm)
                            end else
                                //Mode is not closed
                                 
                                If ModeStartDtm LT StartDtm then
                                    //if ModeStartDtm is before StartDtm and is not close used the total report timespan
                                    MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                                end else
                                    //Use the ModeStartDtm and the StopDtm
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end
                        end else
                            //Mode finished after the timespan
                            MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                        end
                        end else
                            //Mode started after report time
                            If ModeStopDtm LT StopDtm then
                                //Mode finished within the timespan OR isn't yet closed
                                If ModeStopDtm NE '' then
                                    //Mode is closed. Started and finished within the report time so use the Mode's start and stop
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, ModeStopDtm)
                                end else
                                    //Mode is not closed. Started within the report time but has yet to stop.
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end else
                                //Mode finished after the timespan
                                MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                            end
                        end
                        TotalProductiveMinutes += MinutesInMode
                    Case E10State EQ 'Unscheduled Down'
                                                //Begin Production
                        if ModeStartDtm LT StartDtm then
                        //Mode Started Earlier than report time
                        If ModeStopDtm LT StopDtm then
                            //Mode finished within the timespan
                            If ModeStopDtm NE '' then
                                MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, ModeStopDtm)
                            end else
                                //Mode is not closed
                                 
                                If ModeStartDtm LT StartDtm then
                                    //if ModeStartDtm is before StartDtm and is not close used the total report timespan
                                    MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                                end else
                                    //Use the ModeStartDtm and the StopDtm
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end
                        end else
                            //Mode finished after the timespan
                            MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                        end
                        end else
                            //Mode started after report time
                            If ModeStopDtm LT StopDtm then
                                //Mode finished within the timespan OR isn't yet closed
                                If ModeStopDtm NE '' then
                                    //Mode is closed. Started and finished within the report time so use the Mode's start and stop
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, ModeStopDtm)
                                end else
                                    //Mode is not closed. Started within the report time but has yet to stop.
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end else
                                //Mode finished after the timespan
                                MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                            end
                        end
                        TotalUnscheduledDownMinutes += MinutesInMode
                    Case E10State EQ 'Scheduled Down'
                                                                        //Begin Production
                        if ModeStartDtm LT StartDtm then
                        //Mode Started Earlier than report time
                        If ModeStopDtm LT StopDtm then
                            //Mode finished within the timespan
                            If ModeStopDtm NE '' then
                                MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, ModeStopDtm)
                            end else
                                //Mode is not closed
                                 
                                If ModeStartDtm LT StartDtm then
                                    //if ModeStartDtm is before StartDtm and is not close used the total report timespan
                                    MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                                end else
                                    //Use the ModeStartDtm and the StopDtm
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end
                        end else
                            //Mode finished after the timespan
                            MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                        end
                        end else
                            //Mode started after report time
                            If ModeStopDtm LT StopDtm then
                                //Mode finished within the timespan OR isn't yet closed
                                If ModeStopDtm NE '' then
                                    //Mode is closed. Started and finished within the report time so use the Mode's start and stop
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, ModeStopDtm)
                                end else
                                    //Mode is not closed. Started within the report time but has yet to stop.
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end else
                                //Mode finished after the timespan
                                MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                            end
                        end
                        TotalScheduledDownMinutes += MinutesInMode
                    Case E10State EQ 'Non-Scheduled' OR E10State EQ 'Standby'
                    	if ModeStartDtm LT StartDtm then
                        //Mode Started Earlier than report time
                        If ModeStopDtm LT StopDtm then
                            //Mode finished within the timespan
                            If ModeStopDtm NE '' then
                                MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, ModeStopDtm)
                            end else
                                //Mode is not closed
                                 
                                If ModeStartDtm LT StartDtm then
                                    //if ModeStartDtm is before StartDtm and is not close used the total report timespan
                                    MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                                end else
                                    //Use the ModeStartDtm and the StopDtm
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end
                        end else
                            //Mode finished after the timespan
                            MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                        end
                        end else
                            //Mode started after report time
                            If ModeStopDtm LT StopDtm then
                                //Mode finished within the timespan OR isn't yet closed
                                If ModeStopDtm NE '' then
                                    //Mode is closed. Started and finished within the report time so use the Mode's start and stop
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, ModeStopDtm)
                                end else
                                    //Mode is not closed. Started within the report time but has yet to stop.
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end else
                                //Mode finished after the timespan
                                MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                            end
                        end
                        TotalNonSchedMinutes += MinutesInMode
                	Case E10State EQ 'Engineering'
                    	if ModeStartDtm LT StartDtm then
                        //Mode Started Earlier than report time
                        If ModeStopDtm LT StopDtm then
                            //Mode finished within the timespan
                            If ModeStopDtm NE '' then
                                MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, ModeStopDtm)
                            end else
                                //Mode is not closed
                                 
                                If ModeStartDtm LT StartDtm then
                                    //if ModeStartDtm is before StartDtm and is not close used the total report timespan
                                    MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                                end else
                                    //Use the ModeStartDtm and the StopDtm
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end
                        end else
                            //Mode finished after the timespan
                            MinutesInMode = SRP_Datetime('MinuteSpan', StartDTM, StopDtm)
                        end
                        end else
                            //Mode started after report time
                            If ModeStopDtm LT StopDtm then
                                //Mode finished within the timespan OR isn't yet closed
                                If ModeStopDtm NE '' then
                                    //Mode is closed. Started and finished within the report time so use the Mode's start and stop
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, ModeStopDtm)
                                end else
                                    //Mode is not closed. Started within the report time but has yet to stop.
                                    MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                                end
                            end else
                                //Mode finished after the timespan
                                MinutesInMode = SRP_Datetime('MinuteSpan', ModeStartDtm, StopDtm)
                            end
                        end
                        TotalEngMinutes += MinutesInMode
                End Case
                
            Next key
            ProdPercentage        = (TotalProductiveMinutes / TotalReportMinutes) * 100
            UnschedDownPercentage = (TotalUnscheduledDownMinutes / TotalReportMinutes) * 100
            SchedDownPercentage   = (TotalScheduledDownMinutes / TotalReportMinutes) * 100
            NonSchedPercentage = (TotalNonSchedMinutes / TotalReportMinutes) * 100
            EngPercentage = (TotalEngMinutes / TotalReportMinutes) * 100
            

            //Percentages
            ToolData<1, PRODUCTIVE$>  = ProdPercentage
            ToolData<1, UNSCHED$>     = UnschedDownPercentage
            ToolData<1, SCHED$>       = SchedDownPercentage
            ToolData<1, NONSCHED$>       = NonSchedPercentage
            ToolData<1, ENG$> = EngPercentage
            //Total Minutes
            ToolData<2, PRODUCTIVE$>  = TotalProductiveMinutes
            ToolData<2, UNSCHED$>     = TotalUnscheduledDownMinutes
            ToolData<2, SCHED$>       = TotalScheduledDownMinutes
            ToolData<2, NONSCHED$>    = TotalNonSchedMinutes
            ToolData<2, ENG$>		  = TotalEngMinutes
            Response                  = ToolData
        end else
            Response = Error_Services('GetMessage')
        end
    end else
        Response = Error_Services('GetMessage')
    end
    
end service


Service GetReactorUptimeMetricsByTypeAndTimeSpan(startDtm, endDtm, reactType)
	
	Begin Case
		Case startDtm EQ ''
			Error_Services('Add', 'Error getting reactor uptime metrics -> Report start date not supplied')
		Case endDtm EQ ''
			Error_Services('Add', 'Error getting reactor uptime metrics -> Report end date not supplied')
	End Case
	If reactType EQ '' then reactType = 'ALL'
	If Error_Services('NoError') then
		If endDtm GT Date() then
			//This sets the current report end time to the current time.
			endDtm = Datetime()
		end
		reportMinutes = SRP_Datetime('MinuteSpan', startDtm, endDtm)
		if num(reportMinutes) then
			Begin Case
				Case reactType EQ 'ASM' or reactType EQ 'ASM+'
					Reactors = Reactor_Services('GetReactorNumbers', 'ASM') : @FM : Reactor_Services('GetReactorNumbers', 'ASM+')
				Case reactType EQ 'HTR'
					Reactors = Reactor_Services('GetReactorNumbers', 'HTR')
				Case reactType EQ 'EPP'
					Reactors = Reactor_Services('GetReactorNumbers', 'EPP')
				Case reactType EQ 'ALL'
					Reactors = Reactor_Services('GetReactorNumbers', 'ASM') : @FM : Reactor_Services('GetReactorNumbers', 'ASM+') : @FM : Reactor_Services('GetReactorNumbers', 'HTR') : @FM : Reactor_Services('GetReactorNumbers', 'EPP')
			End Case
			AllReactorsScheduledMinutes = 0
			AllReactorsUptimeMinutes = 0
			AllReactorsProdMinutes = 0
			AllReactorsUnschedDownMinutes = 0
			AllReactorsSchedDownMinutes = 0
			AllReactorsEngMinutes = 0
			AllReactorsIdleMinutes = 0
			AllReactorsSingleLL= 0 
			TotalMinutesUp = 0
			ReactorsData = ''
			ReactorsExcluded = ''
			for each Reactor in Reactors using @FM
				ReactorStateTimes = Reactor_Services('GetReactorUptimeMetricsByTimeSpan', Reactor, startDtm, endDtm)
				PercentProd = ReactorStateTimes<1,PRODUCTIVE$>
				MinuteProd = ReactorStateTimes<2,PRODUCTIVE$>
				PercentUnSchedDown = ReactorStateTimes<1,UNSCHED$>
				MinuteUnschedDown = ReactorStateTimes<2,UNSCHED$>
				PercentSchedDown = ReactorStateTimes<1,SCHED$>
				MinuteSchedDown = ReactorStateTimes<2,SCHED$>
				PercentNonSched = ReactorStateTimes<1,NONSCHED$>
				MinutesNonSched = ReactorStateTimes<2,NONSCHED$>
				PercentEng = ReactorStateTimes<1, ENG$>
				MinutesEng = ReactorStateTimes<2, ENG$>
				if MinutesNonSched LT reportMinutes then
					thisReactorExpectedAvailMinutes = reportMinutes - MinutesNonSched; * This is the amount of minutes the single reactor was scheduled to run work.
					AllReactorsScheduledMinutes += thisReactorExpectedAvailMinutes; * Add it to the collective of reactors
					thisReactorUptimeMinutes = MinuteProd + MinutesEng
					AllReactorsUptimeMinutes = thisReactorUptimeMinutes + AllReactorsUptimeMinutes
					AllReactorsProdMinutes += MinuteProd
					AllReactorsUnschedDownMinutes += MinuteUnschedDown
					AllReactorsSchedDownMinutes += MinuteSchedDown
					AllReactorsEngMinutes += MinutesEng
					AllReactorsIdleMinutes += MinutesNonSched
					if reactType NE 'EPP' then
						thisReactorDisabledLoadLock = Reactor_Services('GetReactorDownLL', Reactor) NE ''
						AllReactorsSingleLL += thisReactorDisabledLoadLock
					end else
						thisReactorDisabledLoadLock = 0
					end
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTORS$,-1> = Reactor
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_PROD_PERCENTAGE$,-1> = PercentProd
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_PROD_MINUTES$,-1> = MinuteProd
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_ENG_PERCENTAGE$, -1> = PercentEng
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_ENG_MINUTES$, -1> = MinutesEng
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_DOWN_UNSCHED_PERCENTAGE$, -1> = PercentUnSchedDown
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_DOWN_UNSCHED_MINUTES$, -1> = MinuteUnschedDown
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_DOWN_SCHED_PERCENTAGE$, -1> = PercentSchedDown
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_DOWN_SCHED_MINUTES$, -1> = MinuteSchedDown
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_IDLE_PERCENTAGE$, -1> = PercentNonSched
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_IDLE_MINUTES$, -1> = MinutesNonSched
					ReactorsData<REACTOR_DAILY_UPTIME_INCL_REACTOR_SINGLE_LL$, -1> = thisReactorDisabledLoadLock
				end else
					ReactorsData<REACTOR_DAILY_UPTIME_EXCLUDED_REACTORS$, -1> = Reactor
				end
			Next Reactor
			if AllReactorsScheduledMinutes GT 0  then
				TotalUptimePercent = SRP_Math('ROUND', AllReactorsUptimeMinutes / AllReactorsScheduledMinutes, 5)
				TotalUptimeMinutes = SRP_Math('ROUND', AllReactorsUptimeMinutes, 5)
				TotalAvailMinutes = SRP_Math('ROUND', AllReactorsScheduledMinutes, 5)
				TotalProdPercent = SRP_Math('ROUND', AllReactorsProdMinutes / AllReactorsScheduledMinutes, 5)
				TotalUnschedDownPercent = SRP_Math('ROUND', AllReactorsUnschedDownMinutes / AllReactorsScheduledMinutes, 5)
				TotalSchedDownPercent = SRP_Math('ROUND', AllReactorsSchedDownMinutes / AllReactorsScheduledMinutes, 5)
				TotalEngPercent = SRP_Math('ROUND', AllReactorsEngMinutes / AllReactorsScheduledMinutes, 5)
				TotalIdlePercent = SRP_Math('ROUND', AllReactorsIdleMinutes / AllReactorsScheduledMinutes, 5)
			end else
				TotalUptimePercent = 0
				TotalUptimeMinutes = 0
				TotalAvailMinutes = 0
				TotalProdPercent = 0
				TotalUnschedDownPercent = 0
				TotalSchedDownPercent = 0
				TotalEngPercent = 0
				TotalIdlePercent = 0
			end
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_UPTIME_PERCENTAGE$> = TotalUptimePercent
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_PROD_PERCENTAGE$> = TotalProdPercent
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_PROD_MINUTES$> = AllReactorsProdMinutes
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_ENG_PERCENTAGE$> = TotalEngPercent
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_ENG_MINUTES$> = AllReactorsEngMinutes
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_DOWN_UNSCHED_PERCENTAGE$> = TotalUnschedDownPercent
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_DOWN_UNSCHED_MINUTES$> = AllReactorsUnschedDownMinutes
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_DOWN_SCHED_PERCENTAGE$> = TotalSchedDownPercent
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_DOWN_SCHED_MINUTES$> = AllReactorsSchedDownMinutes
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_IDLE_PERCENTAGE$> = TotalIdlePercent
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_IDLE_MINUTES$> = AllReactorsIdleMinutes
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_UPTIME_MINUTES$> = TotalUptimeMinutes
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_AVAIL_MINUTES$> = TotalAvailMinutes
			ReactorsData<REACTOR_DAILY_UPTIME_TOTAL_SINGLE_LL$> = AllReactorsSingleLL
			Response = ReactorsData
		end else
			Error_Services('Add', 'Error getting reactor uptime metrics -> Unable to get total report duration.')
		end
	end
	
end service


Service GetLoadedRds(ReactNo)
	
	StopRDS = Xlate('REACT_STATE', ReactNo, 'LAST_RDS_NO', 'X')
	
	// Get list of RDS on current reactor that are not FQA
	ReactorConfigKey = 'WO_DAILY_SCHED':ReactNo
	WoNo = Field(Xlate('CONFIG', ReactorConfigKey, WOCust$, 'X'), ' ', 1)
	RDSColumns        = ''
	RDSColumns<0, 1>  = 'SEQ'
	RDSList = RDS_Services('GetRDSData', WoNo, RDSColumns, False$, '')
	
	// Find the index of StopRDS
	RDSList      = SRP_Sort_Array(RDSList, "AN1")
	RDSFastArray = SRP_Fastarray("Create", RDSList)
	StopRDSIdx   = 0
	SRP_Fastarray("Match", RDSFastArray, StopRDS, StopRDSIdx)
	RDSList      = SRP_Fastarray("GetVariable", RDSFastArray)
	
	RdsKeys         = '':@FM:''
	RdsKeysPosition = 1
	RdsIdx          = StopRDSIdx + 1
	DateIn          = ''
	DateOut         = ''
	Loop
		DateIn = Xlate('RDS', RDSList<RdsIdx>, RDS_DATE_IN$, 'X')
		DateOut = Xlate('RDS', RDSList<RdsIdx>, RDS_DATE_OUT$, 'X')
	While (DateIn NE '') and (DateOut EQ '')
		RdsKeys<RdsKeysPosition> = RDSList<RdsIdx>
		If (RdsKeysPosition EQ 1) then
			RdsKeysPosition = 2
		end else
			RdsKeysPosition = 1
		end
		RdsIdx += 1
	Repeat
	
	Response = RdsKeys
	
end service


Service ActiveProveInPreventsModeChange(ReactNo, NewMode, CurrentMode)

	If (ReactNo NE '') then
		If (NewMode NE '') then 
			ReactorRec    = Database_Services('ReadDataRow', 'REACTOR', ReactNo)
			ActiveProveIn = Reactor_Services('GetProveInActive', ReactNo)
			If ActiveProveIn EQ True$ then
				Nica_Orders_Services('GetOrderUpdates')
				ActiveProveIn = Reactor_Services('GetProveInActive', ReactNo)
				If ActiveProveIn EQ True$ then
					Begin Case
						Case CurrentMode EQ 'INITIATE_IDLE'
							IdleStartupActive   = Reactor_Services('GetIdleStartupRequired', ReactNo)
							If IdleStartupActive EQ True$ then
								Response = True$
							end else
								Response = False$
							end
						Case Len(NewMode) GE 2 and NewMode[1, 2] EQ 'UP'
							Response = True$
						Case Otherwise$
							Response = False$
					End Case
				end else
					Response = False$
				end
			end else
				Response = False$
			end
		end else
			Error_Services('Add', 'Error in ' : Service : ' service. NewMode was empty')
		end
	end else
		Error_Services('Add', 'Error in ' : Service : ' service. ReactNo was empty')
	end
	
end service


Service GetReactorDownLL(ReactNo)
	
	Response = ''
	If RowExists('REACTOR', ReactNo) then
		LLDisabledID = Database_Services('ReadDataColumn', 'REACTOR', ReactNo, REACTOR_ACTIVE_LL_DISABLED$, True$, 0)
		If LLDisabledID NE '' then
			If RowExists('REACT_LL', LLDisabledID) then
				DownLoadLock = Database_Services('ReadDataColumn', 'REACT_LL', LLDisabledID, REACT_LL_DISABLED$, True$, 0)
				Response = DownLoadLock
			end
		end
	end
	
end service


Service GetReactorLoadCountLimit(ReactNo)
	
	ErrMsg       = 'Error in ReactorServices -> GetReactorLoadCountLimit: '
	MaxLoadCount = 999
	If ReactNo NE '' then
		If RowExists('REACTOR', ReactNo) then
			ReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactNo)
			If Error_Services('NoError') then
				ReactType           = ReactorRec<REACTOR_REACT_TYPE$>
				PickPlace           = ReactorRec<REACTOR_PICK_PLACE$>
				DisabledLoadLockCnt = DCount(ReactorRec<REACTOR_ACTIVE_LL_DISABLED$>, @VM)
				Begin Case
					Case ReactType EQ 'ASM'
						If PickPlace then
							MaxLoadCount = 2 - DisabledLoadLockCnt
						end else
							MaxLoadCount = 1
						end
					Case ReactType EQ 'ASM+'
						If PickPlace then
							MaxLoadCount = 2 - DisabledLoadLockCnt
						end else
							MaxLoadCount = 1
						end
					Case ReactType EQ 'HTR'
						If PickPlace then
							MaxLoadCount = 2 - DisabledLoadLockCnt
						end else
							MaxLoadCount = 1
						end
					Case ReactType EQ 'EPP'
						MaxLoadCount = 2;*EPP needs to have an additional load capability.
				End Case
			end else
				ErrMsg := Error_Services('GetMessage')
				Error_Services('Add', ErrMsg)
			end
		end else
			ErrMsg := 'Reactor ' : ReactNo : ' does not exist.'
			Error_Services('Add', ErrMsg)
		end
	end else
		ErrMsg := 'Reactor Number was null.'
		Error_Services('Add', ErrMsg)
	end
	Response = MaxLoadCount
	
end service


Service GetReactorAvailChamberCount(ReactNo)
	
	ErrMsg                = 'Error in ReactorServices -> GetReactorAvailChamberCount: '
	AvailableChamberCount = 0
	If ReactNo NE '' then
		If RowExists('REACTOR', ReactNo) then
			LoadedRDS          = Reactor_Services('GetReactorCurrLoadRDS', ReactNo)
			ReactorCurrLoadCnt = DCount(LoadedRDS, @VM)
			ReactorCurrCapacity   = Reactor_Services('GetReactorLoadCountLimit', ReactNo)
			AvailableChamberCount = ReactorCurrCapacity - ReactorCurrLoadCnt
		end else
			ErrMsg := 'Reactor ' : ReactNo : ' does not exist.'
			Error_Services('Add', ErrMsg)
		end
	end else
		ErrMsg := 'Reactor Number was null.'
		Error_Services('Add', ErrMsg)
	end
	Response = AvailableChamberCount
	
end service


Service RemoveRDSFromReactorLoad(RDSNo, ReactorNo, User)
	
	Response = 0
	If User NE '' then
			If RDSNo NE '' then
				If ReactorNo NE '' then
					ReactStatusRec = Database_Services('ReadDataRow', 'REACT_STATUS', ReactorNo)
					If Error_Services('NoError') then
							Locate RDSNo in ReactStatusRec<REACT_STATUS_LOAD_RDS$> setting RDSPos then
								ReactStatusRec = Delete(ReactStatusREc, REACT_STATUS_LOAD_RDS$, RDSPos, 0)
								ReactStatusRec = Delete(ReactStatusREc, REACT_STATUS_LOAD_RDS_DTM$, RDSPos, 0)
								ReactStatusRec = Delete(ReactStatusREc, REACT_STATUS_LOAD_CASS_ID$, RDSPos, 0)
								ReactStatusRec = Delete(ReactStatusREc, REACT_STATUS_LOAD_DTM$, RDSPos, 0)
								Database_Services('WriteDataRow', 'REACT_STATUS', ReactorNo, ReactStatusRec, 1, 0, 1)
								If Error_Services('NoError') then
									Response = 1
								end else
									ErrMsg = Error_Services('GetMessage')
									Error_Services('Add', ErrMsg)
								end
							end else
								Error_Services('Add', 'Error in Reactor Services -> RemoveRDSFromReactorLoad: RDS was not found as a loaded lot.')
							end
					end else
						ErrMsg = Error_Services('GetMessage')
						Error_Services('Add', ErrMsg)
					end
				end else
					Error_Services('Add', 'Error in Reactor Services -> RemoveRDSFromReactorLoad: No Reactor No was supplied.')
				end
			end else
				Error_Services('Add', 'Error in Reactor Services -> RemoveRDSFromReactorLoad: No RDS No was supplied.')
			end
	end else
		Error_Services('Add', 'Error in Reactor Services -> RemoveRDSFromReactorLoad: No Username was supplied.')
	end

end service


Service AddRDSToReactorLoad(RDSNo, ReactorNo)
	
	Response = 0
	If RDSNo NE '' then
		If ReactorNo NE '' then
			ReactStatusRec = Database_Services('ReadDataRow', 'REACT_STATUS', ReactorNo)
			If Error_Services('NoError') then
				Locate RDSNo in ReactStatusRec<REACT_STATUS_LOAD_RDS$> using @VM setting iPos else
					WONo                                           = Xlate('RDS', RDSNo, 'WO_NO', 'X')
					CassNo                                         = Xlate('RDS', RDSNo, 'CASS_NO', 'X')
					WOMatKey                                       = WONo : '*' : CassNo
					ThisDTM                                        = SRP_Datetime('Now')
					ReactStatusRec<REACT_STATUS_LOAD_RDS$, -1>     = RDSNo
					ReactStatusRec<REACT_STATUS_LOAD_RDS_DTM$, -1> = ThisDTM
					ReactStatusRec<REACT_STATUS_LOAD_CASS_ID$, -1> = WOMatKey
					ReactStatusRec<REACT_STATUS_LOAD_DTM$, -1>     = ThisDTM
					Database_Services('WriteDataRow', 'REACT_STATUS', ReactorNo, ReactStatusRec, 1, 0, 1)
				end 
			end else
				ErrMsg = Error_Services('GetMessage')
				Error_Services('Add', ErrMsg)
			end
		end else
			Error_Services('Add', 'Error in Reactor Services -> RemoveRDSFromReactorLoad: No Reactor No was supplied.')
		end
	end else
		Error_Services('Add', 'Error in Reactor Services -> RemoveRDSFromReactorLoad: No RDS No was supplied.')
	end
	
end service


Service UpdateReactorIQSViolations()
	
	ReactNos = Reactor_Services('GetReactorNumbers')
	If Error_Services('NoError') then
		CurrViols = Database_Services('ReadDataRow', 'CONFIG', 'IQS_VIOL_DATA')
		If Error_Services('NoError') then
			ViolatingReactors = CurrViols<IQS_VIOL_DATA.REACTOR$>
			ViolationDtms     = CurrViols<IQS_VIOL_DATA.LAST_ALARM$>
			ViolationTests    = CurrViols<IQS_VIOL_DATA.TEST$>
			Swap ' AM' with 'AM' in ViolationDtms
			Swap ' PM' with 'PM' in ViolationDtms
			ViolationDtms = IConv(ViolationDtms, 'DT')
			For each ReactNo in ReactNos
				ActiveAlarm = False$
				For each ViolReactor in ViolatingReactors using @VM setting vPos
					If ViolReactor EQ ReactNo then
						ActiveAlarm   = True$
						ThisAlarmDtm  = ViolationDtms<0, vPos>
						ThisAlarmTest = ViolationTests<0, vPos>
						// Check if a new alarm and update if necessary
						LastAlarmDtm  = Xlate('REACTOR', ReactNo, REACTOR_IQS_ALARM_DTM$, 'X')
						If LastAlarmDtm LT ThisAlarmDtm then
							// New alarm
							HaveLock = Database_Services('GetKeyIDLock', 'REACTOR', ReactNo, True$)
							If HaveLock then
								ReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactNo)
								If Error_Services('NoError') then 
									ReactorRec<REACTOR_IQS_ALARM_DTM$>  = ThisAlarmDtm
									ReactorRec<REACTOR_IQS_ALARM_TEST$> = ThisAlarmTest
									// WriteDataRow will clear the lock as long as "IgnoreAllLocks" is false
									// REACTOR_ACTIONS will be triggered, which will generate a NICA order if a new HgCV alarm is detected
									Database_Services('WriteDataRow', 'REACTOR', ReactNo, ReactorRec, True$, False$, False$)							
								end
							end
						end						
					end
				Next ViolReactor				
				
				If Not(ActiveAlarm) then 
					// Clear last active alarm
					HaveLock     = Database_Services('GetKeyIDLock', 'REACTOR', ReactNo, True$)
					If HaveLock then
						ReactorRec = Database_Services('ReadDataRow', 'REACTOR', ReactNo)
						If Error_Services('NoError') then
							ReactorRec<REACTOR_IQS_ALARM_DTM$>  = ''
							ReactorRec<REACTOR_IQS_ALARM_TEST$> = ''
							// WriteDataRow will clear the lock as long as "IgnoreAllLocks" is false
							Database_Services('WriteDataRow', 'REACTOR', ReactNo, ReactorRec, True$, False$, False$)
						end
					end					
				end
			Next ReactNo
		end
	end
	
end service


Service GetProveInActive(ReactNo)

	If ReactNo NE '' then
		OrderTypes       = 'CHANGEOVER' : @VM : 'INITIATE_IDLE' : @VM : 'IDLE'
		ActiveProveInIds = Nica_Orders_Services('GetActiveOrders', 'REACTOR', ReactNo, OrderTypes)
		Response         = (ActiveProveInIds NE '')
	end else
		Error_Services('Add', 'Error in ':Service:' service. Null ReactNo passed into service.')
	end
	
end service


Service GetActiveProveInTypes(ReactNo)
	
	If ReactNo NE '' then 
		ActiveProveInOrderIds = Reactor_Services('GetActiveProveInOrderIds', ReactNo)
		If ActiveProveInOrderIds NE '' then
			Response = Xlate('NICA_ORDERS', ActiveProveInOrderIds, 'ORDER_TYPE', 'X')
		end
	end else
		Error_Services('Add', 'Error in ':Service:' service. Null ReactNo passed into service.')
	end
	
end service


Service GetActiveProveInProgresses(ReactNo)
	
	Response = ''
	If ReactNo NE '' then 
		ActiveProveInOrderIds = Reactor_Services('GetActiveProveInOrderIds', ReactNo)
		If ActiveProveInOrderIds NE '' then
			OrderTypes = Xlate('NICA_ORDERS', ActiveProveInOrderIds, 'ORDER_TYPE', 'X')
			OrderCount = Dcount(OrderTypes, @VM)
			For I = 1 to OrderCount
			    OrderType = OrderTypes<I>
			    ProgressPercentage = Xlate('NICA_ORDERS', ActiveProveInOrderIds<i>, 'PROGRESS_PERCENTAGE', 'X')
			    Response<-1> = OrderType :  '- ' : ProgressPercentage :'% Complete.'
			Next I
		end
	end else
		Error_Services('Add', 'Error in ':Service:' service. Null ReactNo passed into service.')
	end
	
end service

Service GetActiveProveInOrderIds(ReactNo)
	
	If ReactNo NE '' then
		OrderTypes          = 'CHANGEOVER' : @VM : 'INITIATE_IDLE' : @VM : 'IDLE'
		Response            = Nica_Orders_Services('GetActiveOrders', 'REACTOR', ReactNo, OrderTypes)		
	end else
		Error_Services('Add', 'Error in ':Service:' service. Null ReactNo passed into service.')
	end
	
end service


Service GetIdleStartupRequired(ReactNo)
	
	If ReactNo NE '' then 
		Response        = Xlate('REACTOR', ReactNo, REACTOR_IDLE_STARTUP_REQUIRED$, 'X')
	end else
		Error_Services('Add', 'Error in ':Service:' service. Null ReactNo passed into service.')
	end
	
end service

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Internal GoSubs
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

RollbackReactUtil:
	
	// Reopen previous REACT_UTIL record
	If OldReactUtilID NE '' then
		OldReactUtilRec                               = Database_Services('ReadDataRow', 'REACT_UTIL', OldReactUtilID)
		OldReactUtilRec<react_util_end_date$>         = ''
		OldReactUtilRec<react_util_end_time$>         = ''
		OldReactUtilRec<react_util_mode_finish_user$> = ''
		Database_Services('WriteDataRow', 'REACT_UTIL', OldReactUtilID, OldReactUtilRec)
	end
	
return


ClearCursors:
	
	For counter = 0 to 8
		ClearSelect counter
	Next counter
	
return