Match TFS Changeset 303331

.gitignore

@@ -328,3 +328,12 @@ ASALocalRun/
 
 # MFractors (Xamarin productivity tool) working folder 
 .mfractor/
+
+##
+## Visual Studio Code
+##
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json

Adaptation/.editorconfig

@@ -0,0 +1,336 @@
+# Remove the line below if you want to inherit .editorconfig settings from higher directories
+root = true
+
+# C# files
+[*.cs]
+
+#### Core EditorConfig Options ####
+
+# Indentation and spacing
+indent_size = 4
+indent_style = space
+tab_width = 4
+
+# New line preferences
+end_of_line = crlf
+insert_final_newline = false
+
+#### .NET Coding Conventions ####
+
+# Organize usings
+dotnet_separate_import_directive_groups = false
+dotnet_sort_system_directives_first = false
+file_header_template = unset
+
+# this. and Me. preferences
+dotnet_style_qualification_for_event = false:error
+dotnet_style_qualification_for_field = false
+dotnet_style_qualification_for_method = false:error
+dotnet_style_qualification_for_property = false:error
+
+# Language keywords vs BCL types preferences
+dotnet_style_predefined_type_for_locals_parameters_members = true
+dotnet_style_predefined_type_for_member_access = true
+
+# Parentheses preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity
+
+# Modifier preferences
+dotnet_style_require_accessibility_modifiers = for_non_interface_members
+
+# Expression-level preferences
+dotnet_style_coalesce_expression = true
+dotnet_style_collection_initializer = true:warning
+dotnet_style_explicit_tuple_names = true:warning
+dotnet_style_namespace_match_folder = true
+dotnet_style_null_propagation = true:warning
+dotnet_style_object_initializer = true:warning
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+dotnet_style_prefer_auto_properties = true:warning
+dotnet_style_prefer_compound_assignment = true:warning
+dotnet_style_prefer_conditional_expression_over_assignment = false
+dotnet_style_prefer_conditional_expression_over_return = false
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:warning
+dotnet_style_prefer_inferred_tuple_names = true:warning
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:warning
+dotnet_style_prefer_simplified_boolean_expressions = true:warning
+dotnet_style_prefer_simplified_interpolation = true
+
+# Field preferences
+dotnet_style_readonly_field = true:warning
+
+# Parameter preferences
+dotnet_code_quality_unused_parameters = all
+
+# Suppression preferences
+dotnet_remove_unnecessary_suppression_exclusions = 0
+
+# New line preferences
+dotnet_style_allow_multiple_blank_lines_experimental = false:warning
+dotnet_style_allow_statement_immediately_after_block_experimental = true
+
+#### C# Coding Conventions ####
+
+# var preferences
+csharp_style_var_elsewhere = false:warning
+csharp_style_var_for_built_in_types = false:warning
+csharp_style_var_when_type_is_apparent = false:warning
+
+# Expression-bodied members
+csharp_style_expression_bodied_accessors = when_on_single_line:warning
+csharp_style_expression_bodied_constructors = when_on_single_line:warning
+csharp_style_expression_bodied_indexers = when_on_single_line:warning
+csharp_style_expression_bodied_lambdas = when_on_single_line:warning
+csharp_style_expression_bodied_local_functions = when_on_single_line:warning
+csharp_style_expression_bodied_methods = when_on_single_line:warning
+csharp_style_expression_bodied_operators = when_on_single_line:warning
+csharp_style_expression_bodied_properties = when_on_single_line:warning
+
+# Pattern matching preferences
+csharp_style_pattern_matching_over_as_with_null_check = true:warning
+csharp_style_pattern_matching_over_is_with_cast_check = true:warning
+csharp_style_prefer_not_pattern = true:warning
+csharp_style_prefer_pattern_matching = true:warning
+csharp_style_prefer_switch_expression = true:warning
+
+# Null-checking preferences
+csharp_style_conditional_delegate_call = true
+
+# Modifier preferences
+csharp_prefer_static_local_function = true:warning
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async
+
+# Code-block preferences
+csharp_prefer_braces = false
+csharp_prefer_simple_using_statement = true:warning
+csharp_style_namespace_declarations = file_scoped:warning
+
+# Expression-level preferences
+csharp_prefer_simple_default_expression = true:warning
+csharp_style_deconstructed_variable_declaration = false
+csharp_style_implicit_object_creation_when_type_is_apparent = true:warning
+csharp_style_inlined_variable_declaration = false
+csharp_style_pattern_local_over_anonymous_function = true:warning
+csharp_style_prefer_index_operator = false:warning
+csharp_style_prefer_null_check_over_type_check = true
+csharp_style_prefer_range_operator = false:warning
+csharp_style_throw_expression = true
+csharp_style_unused_value_assignment_preference = discard_variable:warning
+csharp_style_unused_value_expression_statement_preference = discard_variable:warning
+
+# 'using' directive preferences
+csharp_using_directive_placement = outside_namespace
+
+# New line preferences
+csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = true
+csharp_style_allow_blank_lines_between_consecutive_braces_experimental = true
+csharp_style_allow_embedded_statements_on_same_line_experimental = true
+
+#### C# Formatting Rules ####
+
+# New line preferences
+csharp_new_line_before_catch = true
+csharp_new_line_before_else = true
+csharp_new_line_before_finally = true
+csharp_new_line_before_members_in_anonymous_types = true
+csharp_new_line_before_members_in_object_initializers = true
+csharp_new_line_before_open_brace = all
+csharp_new_line_between_query_expression_clauses = true
+
+# Indentation preferences
+csharp_indent_block_contents = true
+csharp_indent_braces = false
+csharp_indent_case_contents = true
+csharp_indent_case_contents_when_block = true
+csharp_indent_labels = one_less_than_current
+csharp_indent_switch_labels = true
+
+# Space preferences
+csharp_space_after_cast = false
+csharp_space_after_colon_in_inheritance_clause = true
+csharp_space_after_comma = true
+csharp_space_after_dot = false
+csharp_space_after_keywords_in_control_flow_statements = true
+csharp_space_after_semicolon_in_for_statement = true
+csharp_space_around_binary_operators = before_and_after
+csharp_space_around_declaration_statements = false
+csharp_space_before_colon_in_inheritance_clause = true
+csharp_space_before_comma = false
+csharp_space_before_dot = false
+csharp_space_before_open_square_brackets = false
+csharp_space_before_semicolon_in_for_statement = false
+csharp_space_between_empty_square_brackets = false
+csharp_space_between_method_call_empty_parameter_list_parentheses = false
+csharp_space_between_method_call_name_and_opening_parenthesis = false
+csharp_space_between_method_call_parameter_list_parentheses = false
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false
+csharp_space_between_method_declaration_name_and_open_parenthesis = false
+csharp_space_between_method_declaration_parameter_list_parentheses = false
+csharp_space_between_parentheses = false
+csharp_space_between_square_brackets = false
+
+# Wrapping preferences
+csharp_preserve_single_line_blocks = true
+csharp_preserve_single_line_statements = false
+
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = warning
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = warning
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.private_or_internal_field_should_be_private_of_internal_field.severity = warning
+dotnet_naming_rule.private_or_internal_field_should_be_private_of_internal_field.symbols = private_or_internal_field
+dotnet_naming_rule.private_or_internal_field_should_be_private_of_internal_field.style = private_of_internal_field
+
+dotnet_naming_rule.enum_should_be_pascal_case.severity = warning
+dotnet_naming_rule.enum_should_be_pascal_case.symbols = enum
+dotnet_naming_rule.enum_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.public_or_protected_field_should_be_private_of_internal_field.severity = warning
+dotnet_naming_rule.public_or_protected_field_should_be_private_of_internal_field.symbols = public_or_protected_field
+dotnet_naming_rule.public_or_protected_field_should_be_private_of_internal_field.style = private_of_internal_field
+
+dotnet_naming_rule.class_should_be_pascal_case.severity = warning
+dotnet_naming_rule.class_should_be_pascal_case.symbols = class
+dotnet_naming_rule.class_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.method_should_be_pascal_case.severity = warning
+dotnet_naming_rule.method_should_be_pascal_case.symbols = method
+dotnet_naming_rule.method_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.private_or_internal_static_field_should_be_private_of_internal_field.severity = warning
+dotnet_naming_rule.private_or_internal_static_field_should_be_private_of_internal_field.symbols = private_or_internal_static_field
+dotnet_naming_rule.private_or_internal_static_field_should_be_private_of_internal_field.style = private_of_internal_field
+
+dotnet_naming_rule.static_field_should_be_pascal_case.severity = warning
+dotnet_naming_rule.static_field_should_be_pascal_case.symbols = static_field
+dotnet_naming_rule.static_field_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.property_should_be_pascal_case.severity = warning
+dotnet_naming_rule.property_should_be_pascal_case.symbols = property
+dotnet_naming_rule.property_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.static_method_should_be_pascal_case.severity = warning
+dotnet_naming_rule.static_method_should_be_pascal_case.symbols = static_method
+dotnet_naming_rule.static_method_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.abstract_method_should_be_pascal_case.severity = warning
+dotnet_naming_rule.abstract_method_should_be_pascal_case.symbols = abstract_method
+dotnet_naming_rule.abstract_method_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.private_method_should_be_pascal_case.severity = warning
+dotnet_naming_rule.private_method_should_be_pascal_case.symbols = private_method
+dotnet_naming_rule.private_method_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.event_should_be_pascal_case.severity = warning
+dotnet_naming_rule.event_should_be_pascal_case.symbols = event
+dotnet_naming_rule.event_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.delegate_should_be_pascal_case.severity = warning
+dotnet_naming_rule.delegate_should_be_pascal_case.symbols = delegate
+dotnet_naming_rule.delegate_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.struct_should_be_pascal_case.severity = warning
+dotnet_naming_rule.struct_should_be_pascal_case.symbols = struct
+dotnet_naming_rule.struct_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = warning
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.class.applicable_kinds = class
+dotnet_naming_symbols.class.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.class.required_modifiers = 
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.struct.applicable_kinds = struct
+dotnet_naming_symbols.struct.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.struct.required_modifiers = 
+
+dotnet_naming_symbols.enum.applicable_kinds = enum
+dotnet_naming_symbols.enum.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.enum.required_modifiers = 
+
+dotnet_naming_symbols.delegate.applicable_kinds = delegate
+dotnet_naming_symbols.delegate.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.delegate.required_modifiers = 
+
+dotnet_naming_symbols.event.applicable_kinds = event
+dotnet_naming_symbols.event.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.event.required_modifiers = 
+
+dotnet_naming_symbols.method.applicable_kinds = method
+dotnet_naming_symbols.method.applicable_accessibilities = public
+dotnet_naming_symbols.method.required_modifiers = 
+
+dotnet_naming_symbols.private_method.applicable_kinds = method
+dotnet_naming_symbols.private_method.applicable_accessibilities = private
+dotnet_naming_symbols.private_method.required_modifiers = 
+
+dotnet_naming_symbols.abstract_method.applicable_kinds = method
+dotnet_naming_symbols.abstract_method.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.abstract_method.required_modifiers = abstract
+
+dotnet_naming_symbols.static_method.applicable_kinds = method
+dotnet_naming_symbols.static_method.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.static_method.required_modifiers = static
+
+dotnet_naming_symbols.property.applicable_kinds = property
+dotnet_naming_symbols.property.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.property.required_modifiers = 
+
+dotnet_naming_symbols.public_or_protected_field.applicable_kinds = field
+dotnet_naming_symbols.public_or_protected_field.applicable_accessibilities = public, protected
+dotnet_naming_symbols.public_or_protected_field.required_modifiers = 
+
+dotnet_naming_symbols.static_field.applicable_kinds = field
+dotnet_naming_symbols.static_field.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.static_field.required_modifiers = static
+
+dotnet_naming_symbols.private_or_internal_field.applicable_kinds = field
+dotnet_naming_symbols.private_or_internal_field.applicable_accessibilities = internal, private, private_protected
+dotnet_naming_symbols.private_or_internal_field.required_modifiers = 
+
+dotnet_naming_symbols.private_or_internal_static_field.applicable_kinds = field
+dotnet_naming_symbols.private_or_internal_static_field.applicable_accessibilities = internal, private, private_protected
+dotnet_naming_symbols.private_or_internal_static_field.required_modifiers = static
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.private_of_internal_field.required_prefix = _
+dotnet_naming_style.private_of_internal_field.required_suffix = 
+dotnet_naming_style.private_of_internal_field.word_separator = 
+dotnet_naming_style.private_of_internal_field.capitalization = pascal_case

Adaptation/Eaf/Core/AutoGenerated/BackboneComponent.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.Core
+{
+    public class BackboneComponent
+    {
+    }
+}

Adaptation/Eaf/Core/AutoGenerated/BackboneStatusCache.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.Core
+{
+    public class BackboneStatusCache
+    {
+    }
+}

Adaptation/Eaf/Core/AutoGenerated/ILoggingSetupManager.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.Core
+{
+    public interface ILoggingSetupManager
+    {
+    }
+}

Adaptation/Eaf/Core/AutoGenerated/StatusItem.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.Core
+{
+    public class StatusItem
+    {
+    }
+}

Adaptation/Eaf/Core/Backbone.cs

@@ -0,0 +1,48 @@
+using Adaptation.PeerGroup.GCL.Annotations;
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Eaf.Core
+{
+    public class Backbone
+    {
+        public const string STATE_ERROR = "Error";
+        public const string STATE_OFFLINE = "Offline";
+        public const string STATE_RUNNING = "Running";
+        public const string STATE_SHUTDOWN = "Shutting Down";
+        public const string STATE_STARTING = "Starting";
+
+        protected Backbone() { }
+
+        [NotNull]
+        public static Backbone Instance { get; }
+        [NotNull]
+        public ILoggingSetupManager LoggingConfigurationManager { get; set; }
+        public BackboneStatusCache Status { get; }
+        public bool IsAutomatedRestartActive { get; }
+        public bool IsReadyForRestart { get; }
+        public string StartTime { get; }
+        public string State { get; }
+        public string Name { get; }
+        public string ConfigurationServiceAddress { get; }
+        public string CellName { get; }
+        protected bool IsInitialized { get; set; }
+        protected Dictionary<string, BackboneComponent> BackboneComponents { get; }
+
+        public void AddBackboneComponent(BackboneComponent backboneComponent) { }
+        public bool ContainsBackboneComponent(string id) { throw new NotImplementedException(); }
+        [Obsolete("Use the capabilities exposed via the Status property -> GetAll. Will be removed with next major release.")]
+        public List<StatusItem> GetAllStatuses() { throw new NotImplementedException(); }
+        public BackboneComponent GetBackboneComponentById(string id) { throw new NotImplementedException(); }
+        public List<T> GetBackboneComponentsOfType<T>() { throw new NotImplementedException(); }
+        public List<BackboneComponent> GetBackboneComponentsOfType(Type type) { throw new NotImplementedException(); }
+        public void RegisterSubprocess(int pid) { }
+        [Obsolete("Use the capabilities exposed via the Status property -> SetValue. Will be removed with next major release.")]
+        public void SetStatus(string statusName, string statusValue) { }
+        [Obsolete("Use the capabilities exposed via the Status property -> SetValue. Will be removed with next major release.")]
+        public void SetStatus(BackboneComponent source, string statusName, string statusValue) { }
+        protected void CloseConnectionOfComponents(List<BackboneComponent> components) { }
+        protected virtual void StopAllComponents() { }
+        protected void StopComponents(List<BackboneComponent> components) { }
+    }
+}

Adaptation/Eaf/Core/Smtp/EmailMessage.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace Adaptation.Eaf.Core.Smtp
+{
+
+    public class EmailMessage
+    {
+        public EmailMessage() { }
+        public EmailMessage(string subject, string body, MailPriority priority = MailPriority.Normal) { }
+
+        public string Body { get; }
+        public MailPriority Priority { get; }
+        public string Subject { get; }
+
+        public EmailMessage PriorityHigh() { throw new NotImplementedException(); }
+        public EmailMessage PriorityLow() { throw new NotImplementedException(); }
+        public EmailMessage PriorityNormal() { throw new NotImplementedException(); }
+        public EmailMessage SetBody(string body) { throw new NotImplementedException(); }
+        public EmailMessage SetPriority(MailPriority priority) { throw new NotImplementedException(); }
+        public EmailMessage SetSubject(string subject) { throw new NotImplementedException(); }
+
+    }
+
+}

Adaptation/Eaf/Core/Smtp/ISmtp.cs

@@ -0,0 +1,9 @@
+namespace Adaptation.Eaf.Core.Smtp
+{
+
+    public interface ISmtp
+    {
+        void Send(EmailMessage message);
+    }
+
+}

Adaptation/Eaf/Core/Smtp/MailPriority.cs

@@ -0,0 +1,11 @@
+namespace Adaptation.Eaf.Core.Smtp
+{
+
+    public enum MailPriority
+    {
+        Low = 0,
+        Normal = 1,
+        High = 2
+    }
+
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/ChangeDataCollectionHandler.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class ChangeDataCollectionHandler
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/DataCollectionRequest.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class DataCollectionRequest
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/EquipmentEvent.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class EquipmentEvent
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/EquipmentException.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class EquipmentException
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/EquipmentSelfDescription.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class EquipmentSelfDescription
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/GetParameterValuesHandler.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class GetParameterValuesHandler
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/IConnectionControl.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IConnectionControl
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/IDataTracingHandler.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IDataTracingHandler
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/IEquipmentCommandService.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IEquipmentCommandService
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/IEquipmentControl.cs

@@ -0,0 +1,16 @@
+using Adaptation.PeerGroup.GCL.Annotations;
+
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IEquipmentControl : IPackageSource
+    {
+        [NotNull]
+        IEquipmentSelfDescriptionBuilder SelfDescriptionBuilder { get; }
+        [NotNull]
+        IEquipmentDataCollection DataCollection { get; }
+        [NotNull]
+        IEquipmentCommandService Commands { get; }
+        [NotNull]
+        IConnectionControl Connection { get; }
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/IEquipmentSelfDescriptionBuilder.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IEquipmentSelfDescriptionBuilder
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/IPackage.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IPackage
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/ISelfDescriptionLookup.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface ISelfDescriptionLookup
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/IVirtualParameterValuesHandler.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IVirtualParameterValuesHandler
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/SetParameterValuesHandler.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class SetParameterValuesHandler
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/AutoGenerated/TraceRequest.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public class TraceRequest
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/IEquipmentDataCollection.cs

@@ -0,0 +1,39 @@
+using Adaptation.Eaf.EquipmentCore.DataCollection.Reporting;
+using Adaptation.Eaf.EquipmentCore.SelfDescription.ElementDescription;
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IEquipmentDataCollection
+    {
+        IVirtualParameterValuesHandler VirtualParameterValuesHandler { get; }
+        ISelfDescriptionLookup SelfDescriptionLookup { get; }
+        EquipmentSelfDescription SelfDescription { get; }
+        IEnumerable<DataCollectionRequest> ActiveRequests { get; }
+        IDataTracingHandler DataTracingHandler { get; }
+
+        ParameterValue CreateParameterValue(EquipmentParameter parameter, object value);
+        void NotifyDataTracingAvailable(bool isAvailable);
+        void RegisterChangeDataCollectionHandler(ChangeDataCollectionHandler handler);
+        void RegisterDataTracingHandler(IDataTracingHandler handler);
+        void RegisterGetParameterValuesHandler(GetParameterValuesHandler handler);
+        void RegisterSetParameterValuesHandler(SetParameterValuesHandler handler);
+        void TriggerDeactivate(DataCollectionRequest deactivateRequest);
+        void TriggerEvent(EquipmentEvent equipmentEvent, IEnumerable<ParameterValue> parameters);
+        void TriggerEvent(EquipmentEvent equipmentEvent, IEnumerable<ParameterValue> parameters, IPackage sourcePackage);
+        void TriggerExceptionClear(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters);
+        void TriggerExceptionClear(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters, IPackage sourcePackage);
+        void TriggerExceptionClear(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters, string severityOverride, string descriptionOverride);
+        void TriggerExceptionClear(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters, string severityOverride, string descriptionOverride, IPackage sourcePackage);
+        void TriggerExceptionSet(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters, string severityOverride, string descriptionOverride, IPackage sourcePackage);
+        void TriggerExceptionSet(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters, string severityOverride, string descriptionOverride);
+        void TriggerExceptionSet(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters, IPackage sourcePackage);
+        void TriggerExceptionSet(EquipmentException equipmentException, IEnumerable<ParameterValue> parameters);
+        void TriggerPerformanceRestored();
+        void TriggerPerformanceWarning();
+        void TriggerTraceSample(TraceRequest traceRequest, long sampleId, IEnumerable<ParameterValue> parameters);
+        void TriggerTraceSample(TraceRequest traceRequest, long sampleId, IEnumerable<ParameterValue> parameters, IPackage sourcePackage);
+        void TriggerTraceSample(TraceRequest traceRequest, long sampleId, IEnumerable<ParameterValue> parameters, DateTime equipmentTimeStamp);
+    }
+}

Adaptation/Eaf/EquipmentCore/Control/IPackageSource.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.EquipmentCore.Control
+{
+    public interface IPackageSource
+    {
+    }
+}

Adaptation/Eaf/EquipmentCore/DataCollection/Reporting/ParameterValue.cs

@@ -0,0 +1,20 @@
+using Adaptation.Eaf.EquipmentCore.SelfDescription.ElementDescription;
+using Adaptation.PeerGroup.GCL.Annotations;
+using System;
+
+namespace Adaptation.Eaf.EquipmentCore.DataCollection.Reporting
+{
+    public class ParameterValue
+    {
+        public ParameterValue(EquipmentParameter definition, object value) { }
+        public ParameterValue(EquipmentParameter definition, object value, DateTime timestamp) { }
+
+        public virtual object Value { get; protected internal set; }
+        [NotNull]
+        public EquipmentParameter Definition { get; }
+        public DateTime Timestamp { get; protected set; }
+
+        public virtual ParameterValue Clone(EquipmentParameter newDefinition) { throw new NotImplementedException(); }
+        public override string ToString() { return base.ToString(); }
+    }
+}

Adaptation/Eaf/EquipmentCore/SelfDescription/ElementDescription/EquipmentParameter.cs

@@ -0,0 +1,24 @@
+using Adaptation.Eaf.EquipmentCore.SelfDescription.ParameterTypes;
+
+namespace Adaptation.Eaf.EquipmentCore.SelfDescription.ElementDescription
+{
+    public class EquipmentParameter
+    {
+        public EquipmentParameter(EquipmentParameter source, ParameterTypeDefinition typeDefinition) { }
+        public EquipmentParameter(string name, ParameterTypeDefinition typeDefinition, string description, bool isTransient = false, bool isReadOnly = true) { }
+        public EquipmentParameter(string id, string name, ParameterTypeDefinition typeDefinition, string description, bool isTransient = false, bool isReadOnly = true) { }
+
+        public string Name { get; }
+        public string Id { get; }
+        public string Description { get; }
+        public string SourcePath { get; }
+        public string SourceEquipment { get; }
+        public ParameterTypeDefinition TypeDefinition { get; }
+        public bool IsTransient { get; }
+        public bool IsReadOnly { get; }
+
+        public override string ToString() { return base.ToString(); }
+        public string ToStringWithDetails() { return base.ToString(); }
+    }
+
+}

Adaptation/Eaf/EquipmentCore/SelfDescription/ParameterTypes/Field.cs

@@ -0,0 +1,12 @@
+namespace Adaptation.Eaf.EquipmentCore.SelfDescription.ParameterTypes
+{
+    public class Field
+    {
+        public Field(string name, string description, bool canBeNull, ParameterTypeDefinition typeDefinition) { }
+
+        public string Name { get; }
+        public string Description { get; }
+        public ParameterTypeDefinition TypeDefinition { get; }
+        public bool CanBeNull { get; }
+    }
+}

Adaptation/Eaf/EquipmentCore/SelfDescription/ParameterTypes/ParameterTypeDefinition.cs

@@ -0,0 +1,12 @@
+namespace Adaptation.Eaf.EquipmentCore.SelfDescription.ParameterTypes
+{
+    public abstract class ParameterTypeDefinition
+    {
+        public ParameterTypeDefinition(string name, string description) { }
+
+        public string Name { get; }
+        public string Description { get; }
+
+        public override string ToString() { return base.ToString(); }
+    }
+}

Adaptation/Eaf/EquipmentCore/SelfDescription/ParameterTypes/StructuredType.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace Adaptation.Eaf.EquipmentCore.SelfDescription.ParameterTypes
+{
+    public class StructuredType : ParameterTypeDefinition
+    {
+
+        public StructuredType(string name, string description, IList<Field> fields) : base(name, description) { }
+
+        public IList<Field> Fields { get; }
+    }
+}

Adaptation/Eaf/Management/ConfigurationData/CellAutomation/IConfigurationObject.cs

@@ -0,0 +1,6 @@
+namespace Adaptation.Eaf.Management.ConfigurationData.CellAutomation
+{
+    public interface IConfigurationObject
+    {
+    }
+}

Adaptation/Eaf/Management/ConfigurationData/CellAutomation/ModelObjectParameterDefinition.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace Adaptation.Eaf.Management.ConfigurationData.CellAutomation
+{
+    [System.Runtime.Serialization.DataContractAttribute(IsReference = true)]
+    public class ModelObjectParameterDefinition : IConfigurationObject
+    {
+        public ModelObjectParameterDefinition() { }
+        public ModelObjectParameterDefinition(string name, ModelObjectParameterType valueType, object defaultValue) { }
+        public ModelObjectParameterDefinition(string name, Type enumType, object defaultValue) { }
+
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long Id { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual string Name { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual string Value { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual ModelObjectParameterType ValueType { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual string EnumType { get; set; }
+
+        public virtual ModelObjectParameterDefinition Clone() { return null; }
+        public virtual bool IsValidValue(string value) { return false; }
+    }
+}

Adaptation/Eaf/Management/ConfigurationData/CellAutomation/ModelObjectParameterType.cs

@@ -0,0 +1,17 @@
+namespace Adaptation.Eaf.Management.ConfigurationData.CellAutomation
+{
+    public enum ModelObjectParameterType
+    {
+        String = 0,
+        Bool = 1,
+        Byte = 2,
+        SignedByte = 3,
+        Integer = 4,
+        UnsignedInteger = 5,
+        LongInteger = 6,
+        UnsignedLongInteger = 7,
+        Double = 8,
+        Float = 9,
+        Enum = 10
+    }
+}

Adaptation/Eaf/Management/ConfigurationData/Semiconductor/CellInstances/SecsConnectionConfiguration.cs

@@ -0,0 +1,44 @@
+using Adaptation.PeerGroup.GCL.SecsDriver;
+using System;
+
+namespace Adaptation.Eaf.Management.ConfigurationData.Semiconductor.CellInstances
+{
+    [System.Runtime.Serialization.DataContractAttribute]
+    public class SecsConnectionConfiguration
+    {
+        public SecsConnectionConfiguration() { }
+
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T6HsmsControlMessage { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T5ConnectionSeperation { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T4InterBlock { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T3MessageReply { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T2Protocol { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T1InterCharacter { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual SerialBaudRate? BaudRate { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual SecsTransportType? PortType { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long? Port { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan LinkTestTimer { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual string Host { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long? DeviceId { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual HsmsSessionMode? SessionMode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual HsmsConnectionMode? ConnectionMode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T7ConnectionIdle { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual TimeSpan T8NetworkIntercharacter { get; set; }
+    }
+}

Adaptation/FileHandlers/FileRead.cs

@@ -0,0 +1,324 @@
+using Adaptation.Helpers;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using log4net;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json;
+
+namespace Adaptation.FileHandlers
+{
+
+    public partial class FileRead : ILogic
+    {
+
+        private ConfigData _ConfigData;
+
+        public FileRead()
+        {
+            Logistics = new Logistics();
+            _Log = LogManager.GetLogger(typeof(FileRead));
+        }
+
+        public ILogic ShallowCopy()
+        {
+            return (ILogic)MemberwiseClone();
+        }
+
+        public void WaitForThread()
+        {
+            WaitForThread(thread: null, threadExceptions: null);
+        }
+
+        public Tuple<string, ConfigDataBase> GetOpenInsightTuple()
+        {
+            Tuple<string, ConfigDataBase> restuls = new Tuple<string, ConfigDataBase>(_ConfigData.OpenInsightSiViewer, _ConfigData);
+            return restuls;
+        }
+
+        public override bool Extract(string reportFullPath, string eventName)
+        {
+            MethodBase methodBase = new StackFrame().GetMethod();
+            _Log.Debug(string.Concat(methodBase.Name, " - Entry - {", reportFullPath, "}"));
+            Tuple<string, JsonElement?, List<FileInfo>> extractResults = null;
+            try
+            {
+                extractResults = GetExtractResult(reportFullPath, eventName);
+                int count = extractResults.Item2.Value.GetArrayLength();
+                if (count > 0 && _ConfigData.EafHosted && (_ConfigData.IsDatabaseExportToIPDSF || !_ConfigData.IsSourceTimer))
+                    Shared1140(extractResults.Item2.Value);
+                Shared0704(reportFullPath, extractResults, count);
+                Move(reportFullPath, extractResults);
+                Shared0406(reportFullPath);
+                _Log.Debug(string.Concat(methodBase.Name, " - Try - Exit"));
+                return true;
+            }
+            catch (Exception ex)
+            {
+                _Log.Error(string.Concat(methodBase.Name, " - Catch - Entry {", ex.Message, "}", Environment.NewLine, Environment.NewLine, ex.StackTrace));
+                Move(reportFullPath, extractResults, exception: ex);
+                return false;
+            }
+        }
+
+        //public void SetColumns(string equipmentElementName, EquipmentType? equipmentType, string reportFullPath, Exception ex) //GaN
+        //{
+        //    if (equipmentConnection is null)
+        //        throw new Exception(string.Concat("Unable to cast EquipmentElementName {", equipmentElementName, "}!"));
+        //    int breakAfterSeconds;
+        //    if (_Configuration is null)
+        //        breakAfterSeconds = 360;
+        //    else
+        //    {
+        //        if (_Configuration.FileScanningOption == FileConnectorConfiguration.FileScanningOptionEnum.TimeBased)
+        //            breakAfterSeconds = 360;
+        //        else
+        //            breakAfterSeconds = Math.Abs(_Configuration.FileScanningIntervalInSeconds);
+        //    }
+        //    ExtractResult = new ExtractResult(breakAfterSeconds, enumColumns: null, pairedColumns: null);
+        //    switch (equipmentConnection.Value)
+        //    {
+        //        case EquipmentConnection.MET08DDUPSFS6420:
+        //            ExtractResult.HeadersAddRange(Column.Process);
+        //            ExtractResult.DetailsAddRange();
+        //            ExtractResult.ParametersAddRange();
+        //            ExtractResult.DatabaseHeadersAddRange();
+        //            ExtractResult.DatabaseDetailsAddRange();
+        //            break;
+        //        case EquipmentConnection.MET08DDUPSP1TBI:
+        //            ExtractResult.HeadersAddRange(Column.Process);
+        //            ExtractResult.DetailsAddRange();
+        //            ExtractResult.ParametersAddRange();
+        //            ExtractResult.DatabaseHeadersAddRange();
+        //            ExtractResult.DatabaseDetailsAddRange();
+        //            break;
+        //        case EquipmentConnection.MET08RESIHGCV:
+        //            ExtractResult.HeadersAddRange(Column.Process);
+        //            ExtractResult.DetailsAddRange();
+        //            ExtractResult.ParametersAddRange();
+        //            ExtractResult.DatabaseHeadersAddRange();
+        //            ExtractResult.DatabaseDetailsAddRange();
+        //            break;
+        //        case EquipmentConnection.MET08THFTIRQS408M:
+        //            ExtractResult.HeadersAddRange(Column.Process);
+        //            ExtractResult.DetailsAddRange();
+        //            ExtractResult.ParametersAddRange();
+        //            ExtractResult.DatabaseHeadersAddRange();
+        //            ExtractResult.DatabaseDetailsAddRange();
+        //            break;
+        //        case EquipmentConnection.MET08THFTIRSTRATUS:
+        //            ExtractResult.HeadersAddRange(Column.Process);
+        //            ExtractResult.DetailsAddRange();
+        //            ExtractResult.ParametersAddRange();
+        //            ExtractResult.DatabaseHeadersAddRange();
+        //            ExtractResult.DatabaseDetailsAddRange();
+        //            break;
+        //        default:
+        //            throw new Exception(string.Concat("Else {", equipmentElementName, "}!"));
+        //    }
+        //    if (!string.IsNullOrEmpty(reportFullPath) && !(ex is null))
+        //    {
+        //        if (!(_Configuration is null) && _ConfigData.IsDuplicator)
+        //            try { File.WriteAllLines(string.Concat(_Configuration.ErrorTargetFileLocation, @"\", Path.GetFileNameWithoutExtension(reportFullPath), ".err"), new string[] { Logistics.Sequence.ToString(), ex.Message, string.Empty, string.Empty, ex.StackTrace }); } catch (Exception) { }
+        //        if (!_ConfigData.IsSourceTimer && !_ConfigData.IsDatabaseExportToIPDSF)
+        //        {
+        //            string fileName = string.Concat(reportFullPath, ".IO");
+        //            if (!(Configuration is null) && Configuration.PostProcessingMode == FileConnectorConfiguration.PostProcessingModeEnum.Copy)
+        //                try { File.WriteAllLines(fileName, new string[] { Configuration.TargetFileName, Logistics.Sequence.ToString(), ex.Message, string.Empty, string.Empty, ex.StackTrace }); } catch (Exception) { }
+        //        }
+        //        if (_ConfigData.EquipmentConnection.HasValue && _ConfigData.EquipmentConnection.Value != _ConfigData.EquipmentType)
+        //        {
+        //            if (!reportFullPath.EndsWith(".pdsf") && !reportFullPath.EndsWith(".ipdsf"))
+        //            {
+        //                string fileName = string.Concat(reportFullPath, ".IO");
+        //                try { File.WriteAllLines(fileName, new string[] { "Configuration.TargetFileName", Logistics.Sequence.ToString(), ex.Message, string.Empty, string.Empty, ex.StackTrace }); } catch (Exception) { }
+        //            }
+        //            else
+        //            {
+        //                List<string> debug = new List<string> { "//Exception:" };
+        //                if (!(Logistics is null) && !(Logistics.Tags is null))
+        //                    debug.AddRange(Logistics.Tags);
+        //                debug.Add(ex.Message);
+        //                debug.Add(ex.StackTrace);
+        //                try { File.AppendAllLines(reportFullPath, debug); } catch (Exception) { }
+        //                if (!(Logistics is null) && Logistics.DateTimeFromSequence != DateTime.MinValue && Logistics.TotalSecondsSinceLastWriteTimeFromSequence > 600)
+        //                {
+        //                    try { File.SetLastWriteTime(reportFullPath, Logistics.DateTimeFromSequence); } catch (Exception) { }
+        //                }
+        //            }
+        //        }
+        //    }
+        //}
+
+        public Tuple<string, JsonElement?, List<FileInfo>> GetExtractResult(string reportFullPath, string eventName)
+        {
+            Tuple<string, JsonElement?, List<FileInfo>> results;
+            _FileParameter.Clear();
+            DateTime dateTime = DateTime.Now;
+            if (_ConfigData.IsEvent && _ConfigData.Duplicator is null)
+                results = GetExtractResult(reportFullPath);
+            else if (_ConfigData.Duplicator.HasValue)
+                results = GetDuplicatorExtractResult(reportFullPath, dateTime);
+            else if (!_ConfigData.IsSourceIPDSF && reportFullPath.EndsWith(".ipdsf"))
+            {
+                results = new Tuple<string, JsonElement?, List<FileInfo>>(string.Empty, null, new List<FileInfo>());
+                NewMethod1(reportFullPath);
+            }
+            else if (reportFullPath.EndsWith(".pdsf"))
+            {
+                results = new Tuple<string, JsonElement?, List<FileInfo>>(string.Empty, null, new List<FileInfo>());
+                NewMethod2(reportFullPath, results);
+            }
+            else
+                throw new Exception();
+            if (results.Item2 is null)
+                results = new Tuple<string, JsonElement?, List<FileInfo>>(results.Item1, JsonSerializer.Deserialize<JsonElement>("[]"), results.Item3);
+            int count = results.Item2.Value.GetArrayLength();
+            if (count > 0 && _ConfigData.EafHosted)
+                WritePDSF(results.Item2.Value);
+            UpdateLastTicksDuration(DateTime.Now.Ticks - dateTime.Ticks);
+            return results;
+        }
+
+        private void NewMethod2(string reportFullPath, Tuple<string, JsonElement?, List<FileInfo>> results)
+        {
+            FileInfo fileInfo = new FileInfo(reportFullPath);
+            Logistics = new Logistics(ConfigData.NullData, _ConfigData.CellNames, _ConfigData.MesEntities, fileInfo, useSplitForMID: false);
+            ProcessData processData = new ProcessData(this, _ConfigData, results.Item3, string.Empty, string.Empty);
+            if (!processData.Details.Any())
+                throw new Exception();
+            else
+            {
+                //foreach (var item in result.Details)
+                //{
+                //    ExtractResult.RowColumns[Description.RowColumn.Test].Add((int)Shared.Metrology.MET08ANLYSDIFAAST230.Test.DiffusionLength);
+                //    ExtractResult.Headers[Column.Process].Add(item.Reactor);
+                //    ExtractResult.Headers[Column.Employee].Add(item.Employee);
+                //    ExtractResult.Headers[Column.Wafer_ID].Add(item.Slot);
+                //    ExtractResult.Headers[Column.Recipe].Add(item.Recipe);
+                //    ExtractResult.Parameters[Column.Wafer_Region].Add(item.DiffusionLength);
+                //    ExtractResult.Parameters[Column.Wafer_Scribe].Add(item.DiffusionLengthStandardDeviation);
+                //}
+                System.Text.StringBuilder stringBuilder = new System.Text.StringBuilder();
+                stringBuilder.Append(nameof(ProcessData.DiffusionLengthDetail.Reactor)).Append(";");
+                stringBuilder.Append("Date").Append(";");
+                stringBuilder.Append(nameof(ProcessData.DiffusionLengthDetail.Employee)).Append(";");
+                stringBuilder.Append(nameof(ProcessData.DiffusionLengthDetail.Slot)).Append(";");
+                stringBuilder.Append(nameof(ProcessData.DiffusionLengthDetail.Recipe)).Append(";");
+                stringBuilder.Append(nameof(ProcessData.DiffusionLengthDetail.DiffusionLength)).Append(";");
+                stringBuilder.Append(nameof(ProcessData.DiffusionLengthDetail.DiffusionLengthStandardDeviation)).Append(";");
+                stringBuilder.AppendLine();
+                foreach (var item in processData.Details)
+                {
+                    stringBuilder.Append("!");
+                    stringBuilder.Append(item.Reactor).Append(";");
+                    stringBuilder.Append(Logistics.DateTimeFromSequence.ToString("MM/dd/yyyy HH:mm:ss")).Append(";");
+                    stringBuilder.Append(item.Employee).Append(";");
+                    stringBuilder.Append(item.Slot).Append(";");
+                    stringBuilder.Append(item.Recipe).Append(";");
+                    stringBuilder.Append(item.DiffusionLength).Append(";");
+                    stringBuilder.Append(item.DiffusionLengthStandardDeviation);
+                    stringBuilder.AppendLine();
+                }
+                string copyFile = string.Concat(_ConfigData.IqsTempPath, @"\", _ConfigData.IqsFile, ".txt");
+                File.WriteAllText(copyFile, stringBuilder.ToString());
+                File.Copy(copyFile, string.Concat(_ConfigData.IqsPath, @"\", _ConfigData.IqsFile, ".txt"));
+            }
+        }
+
+        private void NewMethod1(string reportFullPath)
+        {
+            Tuple<string, string[], string[]> pdsf = ProcessDataStandardFormat.GetLogisticsColumnsAndBody(reportFullPath);
+            Logistics = new Logistics(reportFullPath, pdsf.Item1);
+            SetFileParameterLotIDToLogisticsMID();
+            SetFileParameterSystemDateTimeToLogisticsSequence();
+            var data = ProcessDataStandardFormat.GetTestDictionary(pdsf);
+            ExtractResult.SetCollections(Logistics, data.Item2);
+        }
+
+        private void NewMethod(string reportFullPath)
+        {
+            Tuple<string, string[], string[]> pdsf = ProcessDataStandardFormat.GetLogisticsColumnsAndBody(reportFullPath);
+            Logistics = new Logistics(reportFullPath, pdsf.Item1);
+            SetFileParameterLotIDToLogisticsMID();
+            SetFileParameterSystemDateTimeToLogisticsSequence();
+            bool hardSkip = _Configuration.FileScanningOption == FileConnectorConfiguration.FileScanningOptionEnum.TimeBased; //false;
+            if (!hardSkip && _Configuration.FileScanningIntervalInSeconds > 0 && !_ConfigData.IsArchive)
+            {
+                string successDirectory;
+                string duplicateDirectory;
+                if (!_ConfigData.IsXToAPC)
+                    successDirectory = string.Empty;
+                else
+                {
+                    successDirectory = string.Concat(Path.GetDirectoryName(_Configuration.TargetFileLocation), @"\ViewerPath");
+                    if (!Directory.Exists(successDirectory))
+                        Directory.CreateDirectory(successDirectory);
+                }
+                if (_ConfigData.IsXToSPaCe || _ConfigData.IsXToSPaCeVillach)
+                    duplicateDirectory = _Configuration.TargetFileLocation;
+                else
+                    duplicateDirectory = string.Concat(_Configuration.TargetFileLocation, @"\", Logistics.JobID);
+                if (!Directory.Exists(duplicateDirectory))
+                    Directory.CreateDirectory(duplicateDirectory);
+                string logisticsSequence = Logistics.Sequence.ToString();
+                List<Tuple<IScopeInfo, string>> tuples = new List<Tuple<IScopeInfo, string>>();
+                string duplicateFile = string.Concat(duplicateDirectory, @"\", Path.GetFileName(reportFullPath));
+                if (!_ConfigData.IsXToArchive && !_ConfigData.IsXToIQS)
+                    File.Copy(reportFullPath, duplicateFile, overwrite: true);
+                else
+                {
+                    //Enum[] enumColumns = new Enum[] { ...
+                }
+            }
+        }
+
+        public void Move(string reportFullPath, Tuple<string, JsonElement?, List<FileInfo>> extractResults, Exception exception = null)
+        {
+            bool isErrorFile = !(exception is null);
+            object filePathGeneratorInfo = GetFilePathGeneratorInfo(reportFullPath, isErrorFile);
+            if (filePathGeneratorInfo is null || !(filePathGeneratorInfo is FilePathGeneratorInfo filePathGenerator))
+                OISiViewer.WebClientDownloadString(_Description, reportFullPath, isErrorFile, string.Empty);
+            else
+            {
+                FilePathGeneratorInfo info = (FilePathGeneratorInfo)filePathGeneratorInfo;
+                OISiViewer.WebClientDownloadString(_Description, reportFullPath, isErrorFile, filePathGenerator.To);
+                if (isErrorFile)
+                {
+                    string[] exceptionLines = new string[] { Logistics.Sequence.ToString(), filePathGenerator.ReportFullPath, filePathGenerator.From, filePathGenerator.ResolvedFileLocation, filePathGenerator.To, string.Empty, string.Empty, exception.Message, string.Empty, string.Empty, exception.StackTrace };
+                    if (_ConfigData.IsDuplicator)
+                        CreateProgressDirectory(_ConfigData.ProgressPath, Logistics, level, exceptionLines);
+                    else
+                    {
+                        string fileName = string.Concat(filePathGenerator.To, @"\readme.txt");
+                        try
+                        {
+                            if (!Directory.Exists(filePathGenerator.To))
+                                Directory.CreateDirectory(filePathGenerator.To);
+                            File.WriteAllLines(fileName, exceptionLines);
+                        }
+                        catch (Exception ex) { _Log.Error(ex.Message); }
+                    }
+                }
+            }
+            if (!isErrorFile && _ConfigData.IsDuplicator)
+            {
+                if (_ConfigData.IsXToArchive)
+                    Shared0192(reportFullPath);
+                else if (_ConfigData.IsArchive)
+                {
+                    //Archive
+                }
+                if (_ConfigData.EafHosted && !string.IsNullOrEmpty(_ConfigData.ProgressPath))
+                    CreateProgressDirectory(_ConfigData.ProgressPath, Logistics, level, exceptionLines: null);
+            }
+        }
+
+    }
+
+}

Adaptation/Helpers/ConfigData.Level.cs

@@ -0,0 +1,20 @@
+namespace Adaptation.Helpers
+{
+
+    public partial class ConfigData
+    {
+        public enum Level
+        {
+            IsXToIQS,
+            IsXToOpenInsight,
+            IsXToAPC,
+            IsXToSPaCe,
+            IsXToSPaCeVillach,
+            IsXToArchive,
+            IsArchive,
+            IsDummy
+        }
+
+    }
+
+}

Adaptation/Helpers/ConfigData.cs

@@ -0,0 +1,711 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using Infineon.Monitoring.MonA;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+
+namespace Adaptation.Helpers
+{
+
+    public partial class ConfigData : ConfigDataBase
+    {
+
+        internal class Reactor
+        {
+            public string Name { get; internal set; }
+            public string FilePrefix { get; internal set; }
+        }
+
+        internal const object NullData = null;
+        internal const int MinFileLength = 100;
+
+        public bool EC { get; private set; }
+        public string ApcPath { get; private set; }
+        public string EdaPath { get; private set; }
+        public string IqsFile { get; private set; }
+        public string IqsPath { get; private set; }
+        public string TracePath { get; private set; }
+        public Level? Duplicator { get; private set; }
+        public string IfxChannel { get; private set; }
+        public string IfxSubject { get; private set; }
+        public string IqsTempPath { get; private set; }
+        public string VillachPath { get; private set; }
+        public string LogisticPath { get; private set; }
+        public string ProgressPath { get; private set; }
+        public string IqsQueryFilter { get; private set; }
+        public string IfxSubjectPrefix { get; private set; }
+        public List<string> MappedParts { get; private set; }
+        public string OpenInsightSiViewer { get; internal set; }
+        public string ArchiveSourceDirectory { get; private set; }
+        public string ConnectionStringIrmnSpc { get; private set; }
+        public string ConnectionStringG4Wafers { get; private set; }
+        public string IfxConfigurationLocation { get; private set; }
+        public List<string> TransportSetupMessages { get; private set; }
+        public string IfxConfigurationLocationLocalCopy { get; private set; }
+        public static Dictionary<string, List<long>> DummyRuns { get; private set; }
+
+        private Timer _Timer;
+        private int _LastDummyRunIndex;
+        private readonly Calendar _Calendar;
+        private readonly string _ReportFullPath;
+
+        public ConfigData(ILogic logic, string cellName, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, IList<ModelObjectParameterDefinition> modelObjectParameterDefinitions, string parameterizedModelObjectDefinitionType, bool isEAFHosted) :
+            base(cellName, cellInstanceConnectionName, fileConnectorConfiguration, equipmentTypeName, parameterizedModelObjectDefinitionType, isEAFHosted)
+        {
+            _LastDummyRunIndex = -1;
+            TransportSetupMessages = new List<string>();
+            CultureInfo cultureInfo = new CultureInfo("en-US");
+            _Calendar = cultureInfo.Calendar;
+            string firstSourceFileFilter = fileConnectorConfiguration.SourceFileFilter.Split('|')[0];
+            IsSourceTimer = (fileConnectorConfiguration.SourceFileFilter == "*Timer.txt");
+            if (DummyRuns is null)
+                DummyRuns = new Dictionary<string, List<long>>();
+            bool isDuplicator = cellInstanceConnectionName.StartsWith(cellName);
+            if (!isDuplicator)
+                Duplicator = null;
+            else
+            {
+                CellNames.Add(cellName, cellName);
+                MesEntities.Add(cellName, cellName);
+                int level = (cellInstanceConnectionName.Length - cellInstanceConnectionName.Replace("-", string.Empty).Length);
+                Duplicator = (Level)level;
+            }
+            if (isDuplicator)
+                ProcessDataDescription = new Duplicator.Description();
+            else
+                ProcessDataDescription = new ProcessData.FileRead.Description();
+            if (!isDuplicator)
+            {
+                //Verify(fileConnectorConfiguration, cellInstanceConnectionName);
+                if (!EafHosted)
+                    VerifyProcessDataDescription(logic);
+                else
+                    WriteExportAliases(logic, cellName, cellInstanceConnectionName);
+            }
+            MappedParts = new List<string>();
+            System.Net.NetworkInformation.IPGlobalProperties ipGlobalProperties = System.Net.NetworkInformation.IPGlobalProperties.GetIPGlobalProperties();
+            EC = (ipGlobalProperties.DomainName.ToLower().Contains("ec.local"));
+            bool isMET08PRFUSB4000Villach = (equipmentElementName == string.Concat(EquipmentType.MET08PRFUSB4000, "_Villach"));
+            if (!modelObjectParameterDefinitions.Any())
+            {
+                CellNames.Add(cellName, "****"); MesEntities.Add(cellName, "****");
+                IfxChannel = string.Empty;
+                IfxSubjectPrefix = string.Empty;
+                IfxConfigurationLocation = string.Empty;
+                IfxConfigurationLocationLocalCopy = string.Empty;
+                IfxSubject = string.Empty;
+                ArchiveSourceDirectory = string.Empty;
+                ConnectionStringG4Wafers = string.Empty;
+                ConnectionStringIrmnSpc = string.Empty;
+            }
+            else
+            {
+                int index;
+                string key;
+                string variable = string.Empty;
+                Dictionary<string, string> iqsSection = new Dictionary<string, string>();
+                Dictionary<string, string> pathSection = new Dictionary<string, string>();
+                Dictionary<string, string> tibcoSection = new Dictionary<string, string>();
+                Dictionary<string, string> commonSection = new Dictionary<string, string>();
+                List<Tuple<string, string>> reactorTuples = new List<Tuple<string, string>>();
+                Dictionary<string, string> openInsightSection = new Dictionary<string, string>();
+                Dictionary<string, string> connectionStringsSection = new Dictionary<string, string>();
+                Dictionary<string, Dictionary<string, string>> reactorSection = new Dictionary<string, Dictionary<string, string>>();
+                foreach (ModelObjectParameterDefinition modelObjectParameterDefinition in modelObjectParameterDefinitions)
+                {
+                    if (!modelObjectParameterDefinition.Name.Contains('.'))
+                        continue;
+                    else if (modelObjectParameterDefinition.Name.StartsWith("Description.") && (modelObjectParameterDefinition.Name.EndsWith(".EventName") || modelObjectParameterDefinition.Name.EndsWith(".EquipmentType")))
+                        continue;
+                    index = modelObjectParameterDefinition.Name.IndexOf(".");
+                    if (index <= -1)
+                        continue;
+                    key = modelObjectParameterDefinition.Name.Substring(0, index);
+                    variable = modelObjectParameterDefinition.Name.Substring(index + 1);
+                    if (key == "COMMON")
+                        commonSection.Add(variable, modelObjectParameterDefinition.Value);
+                    else if (key == "CONNECTION STRINGS")
+                        connectionStringsSection.Add(variable, modelObjectParameterDefinition.Value);
+                    else if (key == "IQS")
+                        iqsSection.Add(variable, modelObjectParameterDefinition.Value);
+                    else if (key == "PATH")
+                        pathSection.Add(variable, modelObjectParameterDefinition.Value);
+                    else if (key == "REACTOR")
+                        reactorTuples.Add(new Tuple<string, string>(variable, modelObjectParameterDefinition.Value));
+                    else if (key == "TIBCO")
+                        tibcoSection.Add(variable, modelObjectParameterDefinition.Value);
+                    else if (key == "OpenInsight")
+                        openInsightSection.Add(variable, modelObjectParameterDefinition.Value);
+                    else
+                        throw new Exception();
+                }
+                foreach (Tuple<string, string> tuple in reactorTuples)
+                {
+                    if (!tuple.Item1.Contains('.'))
+                        continue;
+                    index = tuple.Item1.IndexOf(".");
+                    if (index <= -1)
+                        continue;
+                    key = tuple.Item1.Substring(0, index);
+                    variable = tuple.Item1.Substring(index + 1);
+                    if (!reactorSection.ContainsKey(key))
+                        reactorSection.Add(key, new Dictionary<string, string>() { { "NAME", key } });
+                    reactorSection[key].Add(variable, tuple.Item2);
+                }
+                if (!iqsSection.Any())
+                    throw new Exception("IQS section is missing from configuration");
+                else
+                {
+                    key = "PATH";
+                    if (iqsSection.ContainsKey(key))
+                        IqsPath = iqsSection[key];
+                    else
+                        throw new Exception(string.Concat("Missing IQS Configuration entry for ", key));
+                    if (string.IsNullOrEmpty(IqsPath))
+                        throw new Exception(string.Format("IQS key {0} is empty", key));
+                    key = "FILE";
+                    if (iqsSection.ContainsKey(key))
+                        IqsFile = iqsSection[key];
+                    else
+                        throw new Exception(string.Concat("Missing IQS Configuration entry for ", key));
+                    if (eventName.HasValue && eventName.Value == EventName.FileRead && string.IsNullOrEmpty(IqsFile))
+                        throw new Exception(string.Format("IQS key {0} is empty", key));
+                    key = "QUERY";
+                    if (iqsSection.ContainsKey(key))
+                        IqsQueryFilter = iqsSection[key];
+                    else
+                        throw new Exception(string.Concat("Missing IQS Configuration entry for ", key));
+                    if (eventName.HasValue && eventName.Value == EventName.FileRead && string.IsNullOrEmpty(IqsQueryFilter))
+                        throw new Exception(string.Format("IQS key {0} is empty", key));
+                }
+                if (!pathSection.Any())
+                    throw new Exception("Path section is missing from configuration");
+                else
+                {
+                    key = "TRACE";
+                    if (pathSection.ContainsKey(key) && pathSection[key].StartsWith(@"\\"))
+                        TracePath = pathSection[key];
+                    if (!string.IsNullOrEmpty(TracePath) && !Directory.Exists(TracePath))
+                        Directory.CreateDirectory(TracePath);
+                    key = "LOGISTIC";
+                    if (pathSection.ContainsKey(key) && pathSection[key].StartsWith(@"\\"))
+                        LogisticPath = pathSection[key];
+                    if (!string.IsNullOrEmpty(LogisticPath) && !Directory.Exists(LogisticPath))
+                        Directory.CreateDirectory(LogisticPath);
+                    key = "VILLACH";
+                    if (pathSection.ContainsKey(key) && pathSection[key].StartsWith(@"\\"))
+                        VillachPath = pathSection[key];
+                    if (!string.IsNullOrEmpty(VillachPath) && !Directory.Exists(VillachPath))
+                        Directory.CreateDirectory(VillachPath);
+                    key = "IQS";
+                    if (pathSection.ContainsKey(key) && pathSection[key].StartsWith(@"\\"))
+                        IqsTempPath = pathSection[key];
+                    if (!string.IsNullOrEmpty(IqsTempPath) && !Directory.Exists(IqsTempPath))
+                        Directory.CreateDirectory(IqsTempPath);
+                    key = "Progress";
+                    if (pathSection.ContainsKey(key) && pathSection[key].StartsWith(@"\\"))
+                        ProgressPath = pathSection[key];
+                    if (!string.IsNullOrEmpty(ProgressPath) && Directory.Exists(Path.GetPathRoot(ProgressPath)) && !Directory.Exists(ProgressPath))
+                        Directory.CreateDirectory(ProgressPath);
+                    key = "EDA";
+                    if (pathSection.ContainsKey(key) && pathSection[key].StartsWith(@"\\"))
+                        EdaPath = pathSection[key];
+                    if (!string.IsNullOrEmpty(EdaPath) && !Directory.Exists(EdaPath))
+                        Directory.CreateDirectory(EdaPath);
+                    key = "APC";
+                    if (pathSection.ContainsKey(key) && pathSection[key].StartsWith(@"\\"))
+                        ApcPath = pathSection[key];
+                    if (!string.IsNullOrEmpty(ApcPath) && !Directory.Exists(ApcPath))
+                        Directory.CreateDirectory(ApcPath);
+                }
+                if (!commonSection.Any())
+                    throw new Exception("Common section is missing from configuration");
+                else
+                {
+                    if (isMET08PRFUSB4000Villach)
+                    {
+                        key = "MAPPED_PARTS";
+                        if (!commonSection.ContainsKey(key))
+                            throw new Exception("Mapped Parts KEY is missing from Equipment Type Configuration");
+                        else
+                        {
+                            string mappedParts = commonSection[key];
+                            if (mappedParts.Contains(','))
+                                MappedParts = mappedParts.Split(',').ToList();
+                            else
+                                MappedParts = new string[] { mappedParts }.ToList();
+                        }
+                        if (!MappedParts.Any())
+                            throw new Exception(string.Format("Common section key {0} is empty", key));
+                        key = "ARCHIVE_SOURCE_DIRECTORY";
+                        if (commonSection.ContainsKey(key))
+                            ArchiveSourceDirectory = commonSection[key];
+                    }
+                    key = "CELL_NAMES";
+                    if (!commonSection.ContainsKey(key) || !commonSection[key].Contains(';') || !commonSection[key].Contains(':'))
+                        throw new Exception();
+                    else
+                    {
+                        string[] segments;
+                        string[] cellNames = commonSection[key].Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
+                        foreach (string item in cellNames)
+                        {
+                            segments = item.Split(':');
+                            CellNames.Add(segments[0].Trim(), segments[1].Trim());
+                        }
+                    }
+                    if (!string.IsNullOrEmpty(cellName) && !CellNames.ContainsKey(cellName))
+                        throw new Exception();
+                    key = "MES_ENTITIES";
+                    if (!commonSection.ContainsKey(key) || !commonSection[key].Contains(';') || !commonSection[key].Contains(':')) throw new Exception();
+                    else
+                    {
+                        string[] segments;
+                        string[] mesEntity = commonSection[key].Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
+                        foreach (string item in mesEntity)
+                        {
+                            segments = item.Split(':');
+                            MesEntities.Add(segments[0].Trim(), segments[1].Trim());
+                        }
+                    }
+                    if (!string.IsNullOrEmpty(cellName) && !MesEntities.ContainsKey(cellName))
+                        throw new Exception();
+                }
+                if (isMET08PRFUSB4000Villach)
+                {
+                    if (!tibcoSection.Any())
+                        throw new Exception("TIBCO section is missing from configuration");
+                    else
+                    {
+                        key = "IFX_CHANNEL";
+                        if (tibcoSection.ContainsKey(key))
+                            IfxChannel = tibcoSection[key];
+                        else
+                            throw new Exception("IFX_CHANNEL is missing from Equipment Type Configuration");
+                        if (string.IsNullOrEmpty(IfxChannel))
+                            throw new Exception(string.Format("TIBCO section key {0} is empty", key));
+                        key = "IFX_SUBJECT_PREFIX";
+                        if (tibcoSection.ContainsKey(key))
+                            IfxSubjectPrefix = tibcoSection[key];
+                        else
+                            throw new Exception("IFX_SUBJECT_PREFIX is missing from Equipment Type Configuration");
+                        if (string.IsNullOrEmpty(IfxSubjectPrefix))
+                            throw new Exception(string.Format("TIBCO section key {0} is empty", key));
+                        key = "IFX_CONFIGURATION_LOCATION";
+                        if (tibcoSection.ContainsKey(key))
+                            IfxConfigurationLocation = tibcoSection[key];
+                        else
+                            throw new Exception("IFX_CONFIGURATION_LOCATION is missing from Equipment Type Configuration");
+                        if (string.IsNullOrEmpty(IfxConfigurationLocation))
+                            throw new Exception(string.Format("TIBCO section key {0} is empty", key));
+                        key = "IFX_CONFIGURATION_LOCATION_LOCAL_COPY";
+                        if (tibcoSection.ContainsKey(key))
+                            IfxConfigurationLocationLocalCopy = tibcoSection[key];
+                        else
+                            throw new Exception("IFX_CONFIGURATION_LOCATION_LOCAL_COPY is missing from Equipment Type Configuration");
+                        if (string.IsNullOrEmpty(IfxConfigurationLocationLocalCopy))
+                            throw new Exception(string.Format("TIBCO section key {0} is empty", key));
+                        key = "IFX_SUBJECT";
+                        if (tibcoSection.ContainsKey(key))
+                            IfxSubject = tibcoSection[key];
+                        else
+                            throw new Exception("IFX_SUBJECT KEY is missing from Equipment Type Configuration");
+                        if (string.IsNullOrEmpty(IfxSubject))
+                            throw new Exception(string.Format("TIBCO section key {0} is empty", key));
+                    }
+                }
+                if (IsDatabaseExportToIPDSF || isMET08PRFUSB4000Villach)
+                {
+                    if (!connectionStringsSection.Any())
+                        throw new Exception("Connection Strings section is missing from configuration");
+                    else
+                    {
+                        key = "G4WAFERS";
+                        if (connectionStringsSection.ContainsKey(key))
+                            ConnectionStringG4Wafers = connectionStringsSection[key];
+                        else
+                            throw new Exception("G4WAFERS is missing from Equipment Type Configuration");
+                        if (string.IsNullOrEmpty(ConnectionStringG4Wafers))
+                            throw new Exception(string.Format("Connection String key {0} is empty", key));
+                        key = "IRMNSPC";
+                        if (connectionStringsSection.ContainsKey(key))
+                            ConnectionStringIrmnSpc = connectionStringsSection[key];
+                        else
+                            throw new Exception("IRMNSPC is missing from Equipment Type Configuration");
+                        if (string.IsNullOrEmpty(ConnectionStringIrmnSpc))
+                            throw new Exception(string.Format("IRMNSPC key {0} is empty", key));
+                        //
+                        Si.SQLDatabase.SetConnectionStringIrmnSpc(ConnectionStringIrmnSpc);
+                        Si.SQLDatabase.SetConnectionStringG4Wafers(ConnectionStringG4Wafers);
+                        Si.EpiControlPlan.CPGet.Parameters.SetConnectionStringIrmnSpc(ConnectionStringIrmnSpc);
+                        Si.EpiControlPlan.CPGet.Parameters.SetConnectionStringG4Wafers(ConnectionStringG4Wafers);
+                        Si.EpiControlPlan.CPGet.PartHistory.SetConnectionStringIrmnSpc(ConnectionStringIrmnSpc);
+                        Si.EpiControlPlan.CPGet.PartHistory.SetConnectionStringG4Wafers(ConnectionStringG4Wafers);
+                        Si.EpiControlPlan.CPGet.PartParameters.SetConnectionStringIrmnSpc(ConnectionStringIrmnSpc);
+                        Si.EpiControlPlan.CPGet.PartParameters.SetConnectionStringG4Wafers(ConnectionStringG4Wafers);
+                    }
+                }
+                if (!openInsightSection.Any())
+                    throw new Exception("OpenInsight section is missing from configuration");
+                else
+                {
+                    key = "SiViewer";
+                    if (openInsightSection.ContainsKey(key))
+                        OpenInsightSiViewer = openInsightSection[key];
+                    if (string.IsNullOrEmpty(OpenInsightSiViewer))
+                        throw new Exception(string.Format("OpenInsight key {0} is empty", key));
+                    if (!OpenInsightSiViewer.Contains(":") || !OpenInsightSiViewer.Contains("."))
+                        throw new Exception(string.Format("OpenInsight key {0} is invalid", key));
+                }
+                if (!MesEntities.Any())
+                    throw new Exception();
+                if (isMET08PRFUSB4000Villach)
+                {
+                    Si.Transport.Initialize(this);
+                    if (!string.IsNullOrEmpty(fileConnectorConfiguration.SourceFileLocation))
+                        TransportSetupMessages = Si.Transport.Setup(useSleep: true, setIfxTransport: true, setParameters: true);
+                    else
+                        TransportSetupMessages = Si.Transport.Setup(useSleep: false, setIfxTransport: false, setParameters: false);
+                }
+                if (IsSourceTimer || IsDatabaseExportToIPDSF || (Duplicator.HasValue && Duplicator.Value == Level.IsDummy))
+                {
+                    if (!Directory.Exists(fileConnectorConfiguration.SourceFileLocation))
+                        Directory.CreateDirectory(fileConnectorConfiguration.SourceFileLocation);
+                    _ReportFullPath = string.Concat(fileConnectorConfiguration.SourceFileLocation, firstSourceFileFilter.Replace("*", @"\"));
+                    if (Debugger.IsAttached || fileConnectorConfiguration.PreProcessingMode == FileConnectorConfiguration.PreProcessingModeEnum.Process)
+                        Callback(null);
+                    else
+                    {
+                        int milliSeconds;
+                        milliSeconds = (int)((fileConnectorConfiguration.FileScanningIntervalInSeconds * 1000) / 2);
+                        _Timer = new Timer(Callback, null, milliSeconds, Timeout.Infinite); milliSeconds += 2000;
+                    }
+                }
+            }
+        }
+
+        public void CheckProcessDataDescription(Dictionary<Test, List<Duplicator.Description>> results, bool extra)
+        {
+            foreach (Test test in results.Keys)
+            {
+                if (test == Test)
+                {
+                    if (!(ProcessDataDescription is ProcessData.FileRead.Description))
+                        ProcessDataDescription = new ProcessData.FileRead.Description();
+                }
+                else
+                    throw new Exception();
+            }
+        }
+
+        private void CallbackIsDummy(string traceDummyFile, List<Tuple<string, string, string, string, int>> tuples, bool fileConnectorConfigurationIncludeSubDirectories, bool includeSubDirectoriesExtra)
+        {
+            int fileCount;
+            string[] files;
+            string monARessource;
+            string checkDirectory;
+            string sourceArchiveFile;
+            string inProcessDirectory;
+            const string site = "sjc";
+            const string monInURL = "http://moninhttp.sjc.infineon.com/input/text";
+            MonIn monIn = MonIn.GetInstance(monInURL);
+            string stateName = string.Concat("Dummy_", _EventName);
+            foreach (Tuple<string, string, string, string, int> item in tuples)
+            {
+                monARessource = item.Item1;
+                sourceArchiveFile = item.Item2;
+                inProcessDirectory = item.Item3;
+                checkDirectory = item.Item4;
+                fileCount = item.Item5;
+                try
+                {
+                    if (fileCount > 0 || string.IsNullOrEmpty(checkDirectory))
+                    {
+                        File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Warning.ToString() });
+                        monIn.SendStatus(site, monARessource, stateName, State.Warning);
+                        for (int i = 1; i < 12; i++)
+                            Thread.Sleep(500);
+                    }
+                    else if (inProcessDirectory == checkDirectory)
+                        continue;
+                    if (!EafHosted)
+                        continue;
+                    if (!File.Exists(sourceArchiveFile))
+                        continue;
+                    if (!long.TryParse(Path.GetFileNameWithoutExtension(sourceArchiveFile).Replace("x", string.Empty), out long sequence))
+                        continue;
+                    ZipFile.ExtractToDirectory(sourceArchiveFile, inProcessDirectory);
+                    if (fileConnectorConfigurationIncludeSubDirectories && includeSubDirectoriesExtra)
+                    {
+                        if (_EventName == EventName.FileRead)
+                            checkDirectory = string.Concat(checkDirectory, @"\", sequence);
+                        else if (_EventName == EventName.FileReadDaily)
+                            checkDirectory = string.Concat(checkDirectory, @"\Source\", sequence);
+                        else
+                            throw new Exception();
+                    }
+                    if (fileConnectorConfigurationIncludeSubDirectories)
+                        files = Directory.GetFiles(inProcessDirectory, "*", SearchOption.AllDirectories);
+                    else
+                        files = Directory.GetFiles(inProcessDirectory, "*", SearchOption.TopDirectoryOnly);
+                    if (files.Length > 250)
+                        throw new Exception("Safety net!");
+                    foreach (string file in files)
+                        File.SetLastWriteTime(file, new DateTime(sequence));
+                    if (!fileConnectorConfigurationIncludeSubDirectories)
+                    {
+                        foreach (string file in files)
+                            File.Move(file, string.Concat(checkDirectory, @"\", Path.GetFileName(file)));
+                    }
+                    else
+                    {
+                        string[] directories = Directory.GetDirectories(inProcessDirectory, "*", SearchOption.AllDirectories);
+                        foreach (string directory in directories)
+                            Directory.CreateDirectory(string.Concat(checkDirectory, directory.Substring(inProcessDirectory.Length)));
+                        foreach (string file in files)
+                            File.Move(file, string.Concat(checkDirectory, file.Substring(inProcessDirectory.Length)));
+                    }
+                    File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Ok.ToString() });
+                    monIn.SendStatus(site, monARessource, stateName, State.Ok);
+                }
+                catch (Exception exception)
+                {
+                    File.AppendAllLines(traceDummyFile, new string[] { site, monARessource, stateName, State.Critical.ToString(), exception.Message, exception.StackTrace });
+                    monIn.SendStatus(site, monARessource, stateName, State.Critical);
+                    try
+                    {
+                        Eaf.Core.Smtp.ISmtp smtp = Eaf.Core.Backbone.Instance.GetBackboneComponentsOfType<Eaf.Core.Smtp.ISmtp>().SingleOrDefault();
+                        Eaf.Core.Smtp.EmailMessage emailMessage = new Eaf.Core.Smtp.EmailMessage(string.Concat("Exception:", EquipmentElementName), string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace), Eaf.Core.Smtp.MailPriority.High);
+                        smtp.Send(emailMessage);
+                    }
+                    catch (Exception) { }
+                }
+            }
+        }
+
+        private void CallbackIsDummy()
+        {
+            DateTime dateTime = DateTime.Now;
+            bool check = (dateTime.Hour > 7 && dateTime.Hour < 18 && dateTime.DayOfWeek != DayOfWeek.Sunday && dateTime.DayOfWeek != DayOfWeek.Saturday);
+            if (check)
+            {
+                int fileCount;
+                string[] files;
+                string monARessource;
+                string checkDirectory;
+                string sourceArchiveFile;
+                string sourceFileLocation;
+                string inProcessDirectory;
+                string weekOfYear = _Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
+                string traceDummyDirectory = string.Concat(Path.GetPathRoot(TracePath), @"\TracesDummy\", CellName, @"\Source\", dateTime.ToString("yyyy"), "___Week_", weekOfYear);
+                if (!Directory.Exists(traceDummyDirectory))
+                    Directory.CreateDirectory(traceDummyDirectory);
+                string traceDummyFile = string.Concat(traceDummyDirectory, @"\", dateTime.Ticks, " - ", CellName, ".txt");
+                File.AppendAllText(traceDummyFile, string.Empty);
+                List<Tuple<string, string, string, string, int>> tuples = new List<Tuple<string, string, string, string, int>>();
+                string progressDirectory = Path.GetFullPath(string.Concat(FileConnectorConfiguration.SourceFileLocation, @"\_ Progress"));
+                if (progressDirectory != ProgressPath || !Directory.Exists(progressDirectory))
+                    throw new Exception("Invalid progress path");
+                foreach (var keyValuePair in CellNames)
+                {
+                    monARessource = keyValuePair.Key;
+                    if (!keyValuePair.Value.Contains(@"\"))
+                        continue;
+                    foreach (string sourceFileFilter in FileConnectorConfiguration.SourceFileFilter.Split('|'))
+                    {
+                        if (sourceFileFilter.ToLower().StartsWith(keyValuePair.Value.Replace(@"\", string.Empty)))
+                            sourceFileLocation = Path.GetFullPath(FileConnectorConfiguration.SourceFileLocation);
+                        else if (FileConnectorConfiguration.SourceFileLocation.ToLower().EndsWith(keyValuePair.Value))
+                            sourceFileLocation = Path.GetFullPath(FileConnectorConfiguration.SourceFileLocation);
+                        else
+                            sourceFileLocation = Path.GetFullPath(string.Concat(FileConnectorConfiguration.SourceFileLocation, @"\", keyValuePair.Value));
+                        sourceArchiveFile = Path.GetFullPath(string.Concat(sourceFileLocation, @"\", sourceFileFilter));
+                        if (!File.Exists(sourceArchiveFile))
+                            continue;
+                        if (!DummyRuns.ContainsKey(monARessource))
+                            DummyRuns.Add(monARessource, new List<long>());
+                        tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceFileFilter, sourceFileLocation, sourceArchiveFile, 0));
+                    }
+                }
+                File.AppendAllLines(traceDummyFile, from l in tuples select l.Item4);
+                if (tuples.Any())
+                {
+                    _LastDummyRunIndex += 1;
+                    if (_LastDummyRunIndex >= tuples.Count)
+                        _LastDummyRunIndex = 0;
+                    monARessource = tuples[_LastDummyRunIndex].Item1;
+                    string sourceFileFilter = tuples[_LastDummyRunIndex].Item2;
+                    sourceFileLocation = tuples[_LastDummyRunIndex].Item3;
+                    sourceArchiveFile = tuples[_LastDummyRunIndex].Item4;
+                    //fileCount = tuples[_LastDummyRunIndex].Item5;
+                    tuples.Clear();
+                    if (long.TryParse(Path.GetFileNameWithoutExtension(sourceArchiveFile).Replace("x", string.Empty), out long sequence))
+                    {
+                        if (!DummyRuns[monARessource].Contains(sequence))
+                            DummyRuns[monARessource].Add(sequence);
+                        inProcessDirectory = string.Concat(progressDirectory, @"\Dummy_in process\", sequence);
+                        checkDirectory = inProcessDirectory;
+                        if (!Directory.Exists(checkDirectory))
+                            Directory.CreateDirectory(checkDirectory);
+                        files = Directory.GetFiles(checkDirectory, "*", SearchOption.AllDirectories);
+                        fileCount = files.Length;
+                        if (files.Any())
+                        {
+                            if (files.Length > 250)
+                                throw new Exception("Safety net!");
+                            try
+                            {
+                                foreach (string file in files)
+                                    File.Delete(file);
+                            }
+                            catch (Exception) { }
+                        }
+                        tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceArchiveFile, inProcessDirectory, checkDirectory, fileCount));
+                        checkDirectory = sourceFileLocation;
+                        files = Directory.GetFiles(checkDirectory, string.Concat("*", sequence, "*"), SearchOption.TopDirectoryOnly);
+                        fileCount = files.Length;
+                        tuples.Add(new Tuple<string, string, string, string, int>(monARessource, sourceArchiveFile, inProcessDirectory, checkDirectory, fileCount));
+                    }
+                }
+                if (tuples.Any())
+                    CallbackIsDummy(traceDummyFile, tuples, FileConnectorConfiguration.IncludeSubDirectories.Value, includeSubDirectoriesExtra: false);
+            }
+        }
+
+        private void Callback(object state)
+        {
+            try
+            {
+                if (Duplicator is null)
+                {
+                    if (File.Exists(_ReportFullPath))
+                        File.Delete(_ReportFullPath);
+                    File.WriteAllText(_ReportFullPath, string.Empty);
+                }
+                else if (Duplicator.Value == Level.IsDummy)
+                    CallbackIsDummy();
+                else
+                    throw new Exception();
+            }
+            catch (Exception exception)
+            {
+                try
+                {
+                    Eaf.Core.Smtp.ISmtp smtp = Eaf.Core.Backbone.Instance.GetBackboneComponentsOfType<Eaf.Core.Smtp.ISmtp>().SingleOrDefault();
+                    Eaf.Core.Smtp.EmailMessage emailMessage = new Eaf.Core.Smtp.EmailMessage(string.Concat("Exception:", EquipmentElementName), string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace), Eaf.Core.Smtp.MailPriority.High);
+                    smtp.Send(emailMessage);
+                }
+                catch (Exception) { }
+            }
+            try
+            {
+                TimeSpan timeSpan;
+                if (IsDatabaseExportToIPDSF)
+                    timeSpan = new TimeSpan(DateTime.Now.AddMinutes(1).Ticks - DateTime.Now.Ticks);
+                else if (IsSourceTimer)
+                    timeSpan = new TimeSpan(DateTime.Now.AddMinutes(15).Ticks - DateTime.Now.Ticks);
+                else if (Duplicator.HasValue && Duplicator.Value == Level.IsDummy)
+                    timeSpan = new TimeSpan(DateTime.Now.AddSeconds(FileConnectorConfiguration.FileScanningIntervalInSeconds.Value).Ticks - DateTime.Now.Ticks);
+                else if (Duplicator.HasValue)
+                    timeSpan = new TimeSpan(DateTime.Now.AddSeconds(30).Ticks - DateTime.Now.Ticks);
+                else
+                    timeSpan = new TimeSpan(DateTime.Now.AddDays(.5).Ticks - DateTime.Now.Ticks);
+                if (!(_Timer is null))
+                    _Timer.Change((long)timeSpan.TotalMilliseconds, Timeout.Infinite);
+                else
+                    _Timer = new Timer(Callback, null, (long)timeSpan.TotalMilliseconds, Timeout.Infinite);
+            }
+            catch (Exception exception)
+            {
+                try
+                {
+                    Eaf.Core.Smtp.ISmtp smtp = Eaf.Core.Backbone.Instance.GetBackboneComponentsOfType<Eaf.Core.Smtp.ISmtp>().SingleOrDefault();
+                    Eaf.Core.Smtp.EmailMessage emailMessage = new Eaf.Core.Smtp.EmailMessage(string.Concat("Exception:", EquipmentElementName), string.Concat(exception.Message, Environment.NewLine, Environment.NewLine, exception.StackTrace), Eaf.Core.Smtp.MailPriority.High);
+                    smtp.Send(emailMessage);
+                }
+                catch (Exception) { }
+            }
+        }
+
+        public Tuple<string, JsonElement?, List<FileInfo>> IsManualOIEntry(string reportFullPath)
+        {
+            Tuple<string, JsonElement?, List<FileInfo>> results;
+            string monARessource;
+            const string site = "sjc";
+            string equipment = string.Empty;
+            string description = string.Empty;
+            string stateName = "MANUAL_OI_ENTRY";
+            string json = File.ReadAllText(reportFullPath);
+            JsonElement jsonElement = JsonSerializer.Deserialize<JsonElement>(json);
+            results = new Tuple<string, JsonElement?, List<FileInfo>>(string.Empty, jsonElement, new List<FileInfo>());
+            foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
+            {
+                if (jsonProperty.Name == "Equipment")
+                    equipment = jsonProperty.Value.ToString();
+                else if (jsonProperty.Name == "Description")
+                    description = jsonProperty.Value.ToString();
+            }
+            if (string.IsNullOrEmpty(equipment))
+                monARessource = CellName;
+            else
+                monARessource = equipment;
+            const string monInURL = "http://moninhttp.sjc.infineon.com/input/text";
+            MonIn monIn = MonIn.GetInstance(monInURL);
+            if (EafHosted)
+                monIn.SendStatus(site, monARessource, stateName, State.Warning, description);
+            return results;
+        }
+
+        private void Archive(string sourceFileLocation, string sourceFileFilter, Calendar calendar, string directoryName, string newDirectoryName, int minFiles)
+        {
+            string newDirectroyRoot = sourceFileLocation.Replace(directoryName, newDirectoryName);
+            if (!Directory.Exists(newDirectroyRoot))
+                Directory.CreateDirectory(newDirectroyRoot);
+            if (Directory.Exists(sourceFileLocation))
+            {
+                string[] files = Directory.GetFiles(sourceFileLocation, sourceFileFilter, SearchOption.TopDirectoryOnly);
+                if (files.Length > minFiles)
+                {
+                    string newFile;
+                    string weekOfYear;
+                    DateTime dateTime;
+                    string newDirectroy;
+                    DateTime creationTime;
+                    DateTime lastWriteTime;
+                    for (int i = 1; i < 50; i++)
+                        Thread.Sleep(500);
+                    foreach (var file in files)
+                    {
+                        creationTime = new FileInfo(file).CreationTime;
+                        lastWriteTime = new FileInfo(file).LastWriteTime;
+                        if (creationTime < lastWriteTime)
+                            dateTime = creationTime;
+                        else
+                            dateTime = lastWriteTime;
+                        weekOfYear = calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Sunday).ToString("00");
+                        newDirectroy = string.Concat(newDirectroyRoot, @"\", dateTime.ToString("yyyy"), "___Week_", weekOfYear);
+                        if (!Directory.Exists(newDirectroy))
+                            Directory.CreateDirectory(newDirectroy);
+                        newFile = string.Concat(newDirectroy, @"\", Path.GetFileName(file));
+                        if (File.Exists(newFile))
+                            File.Delete(newFile);
+                        try { File.Move(file, string.Concat(newDirectroy, @"\", Path.GetFileName(file))); } catch (Exception e) { Print(string.Concat(e.Message, Environment.NewLine, Environment.NewLine, e.StackTrace)); }
+                        try { Directory.SetLastWriteTime(newDirectroy, dateTime); } catch (Exception e) { Print(string.Concat(e.Message, Environment.NewLine, Environment.NewLine, e.StackTrace)); }
+                    }
+                    try { Directory.SetLastWriteTime(sourceFileLocation, DateTime.Now); } catch (Exception e) { Print(string.Concat(e.Message, Environment.NewLine, Environment.NewLine, e.StackTrace)); }
+                }
+            }
+        }
+
+    }
+
+}

Adaptation/Helpers/ProcessData.cs

@@ -0,0 +1,147 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using log4net;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.Helpers
+{
+
+    public partial class ProcessData : IProcessData
+    {
+
+        public class DiffusionLengthDetail
+        {
+
+            public string Reactor { get; set; }
+            public string Employee { get; set; }
+            public string Recipe { get; set; }
+            public string Slot { get; set; }
+            public string DiffusionLength { get; set; }
+            public string DiffusionLengthStandardDeviation { get; set; }
+
+        }
+
+        private readonly ILog _Log;
+        public List<DiffusionLengthDetail> Details { get; private set; }
+
+        public ProcessData(ILogic logic, ConfigData configData, List<FileInfo> fileInfoCollection, string lot, string pocketNumber)
+        {
+            _Log = LogManager.GetLogger(typeof(ProcessData));
+            Details = new List<DiffusionLengthDetail>();
+            DiffusionLengthDetail diffusionLengthDetail;
+            var data = ProcessDataStandardFormat.GetProcessDataStandardFormat(logic.Logistics.ReportFullPath);
+            Dictionary<Test, Dictionary<string, List<string>>> item2 = data.Item2;
+            if (item2.Any())
+            {
+                Dictionary<string, List<string>> keyValuePairs = item2.ElementAt(0).Value;
+                int count = keyValuePairs[Column.Time.ToString()].Count;
+                if (count > 0)
+                {
+                    string key;
+                    string carrier;
+                    string[] segments;
+                    string logistics = data.Item1;
+                    key = "CARRIER=";
+                    if (!logistics.Contains(key))
+                        carrier = string.Empty;
+                    else
+                    {
+                        segments = logistics.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                        carrier = segments[1].Split(';')[0];
+                    }
+                    string mid;
+                    key = "MID=";
+                    if (!logistics.Contains(key))
+                        mid = string.Empty;
+                    else
+                    {
+                        segments = logistics.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                        mid = segments[1].Split(';')[0];
+                    }
+                    string ppid;
+                    key = "PPID=";
+                    if (!logistics.Contains(key))
+                        ppid = string.Empty;
+                    else
+                    {
+                        segments = logistics.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                        ppid = segments[1].Split(';')[0];
+                    }
+                    for (int i = 0; i < count; i++)
+                    {
+                        diffusionLengthDetail = new DiffusionLengthDetail
+                        {
+                            Reactor = string.Empty,
+                            Employee = "AUTO",
+                            Recipe = ppid,
+                            Slot = keyValuePairs["SlotNumber"][i],
+                            DiffusionLength = keyValuePairs["WW_SPV_DL_LBEF_AVG"][i],
+                            DiffusionLengthStandardDeviation = keyValuePairs["WW_SPV_DL_LBEF_STD"][i]
+                        };
+                        if (!string.IsNullOrEmpty(mid))
+                            diffusionLengthDetail.Reactor = mid.Substring(0, 3);
+                        Details.Add(diffusionLengthDetail);
+                    }
+                }
+            }
+        }
+
+        public Tuple<string, JsonElement?, List<FileInfo>> GetResults(ILogic logic, ConfigDataBase configDataBase, List<FileInfo> fileInfoCollection)
+        {
+            Tuple<string, JsonElement?, List<FileInfo>> results;
+            if (!(configDataBase is ConfigData configData))
+                throw new Exception();
+            List<Test> tests = new List<Test>();
+            List<IProcessDataDescription> descriptions;  
+            EventName eventName = configData.GetEventNameValue();
+            if (eventName == EventName.FileRead && Details.Any())
+            {
+                foreach (var item in Details)
+                    tests.Add(Test);
+                descriptions = configData.GetDescription(logic, tests, this);
+            }
+            else
+                throw new Exception();
+            if (!configData.EafHosted)
+                new FileRead.Description().GetDescription(logic, configData, tests, this);
+            if (tests.Count != descriptions.Count)
+                throw new Exception();
+            for (int i = 0; i < tests.Count; i++)
+            {
+                if (descriptions[i].Test != (int)tests[i])
+                    throw new Exception();
+            }
+            string json;
+            if (descriptions[0] is Duplicator.Description)
+            {
+                List<Duplicator.Description> duplicatorDescriptions = (from l in descriptions select (Duplicator.Description)l).ToList();
+                json = JsonSerializer.Serialize(duplicatorDescriptions, duplicatorDescriptions.GetType());
+            }
+            else if (descriptions[0] is FileRead.Description)
+            {
+                List<FileRead.Description> fileReadDescriptions = (from l in descriptions select (FileRead.Description)l).ToList();
+                json = JsonSerializer.Serialize(fileReadDescriptions, fileReadDescriptions.GetType());
+            }
+            else
+                throw new Exception();
+            object @object = JsonSerializer.Deserialize<object>(json);
+            if (!(@object is JsonElement jsonElement))
+                throw new Exception();
+            results = new Tuple<string, JsonElement?, List<FileInfo>>(logic.Logistics.Logistics1[0], jsonElement, fileInfoCollection);
+            return results;
+        }
+
+        public static Dictionary<Test, List<Duplicator.Description>> GetKeyValuePairs(ConfigData configData, JsonElement jsonElement, List<Duplicator.Description> processDataDescriptions, bool extra = false)
+        {
+            Dictionary<Test, List<Duplicator.Description>> results = configData.GetKeyValuePairs(processDataDescriptions);
+            configData.CheckProcessDataDescription(results, extra);
+            return results;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/LDS2559Reply.cs

@@ -0,0 +1,218 @@
+using Infineon.Yoda;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using TIBCO.Rendezvous;
+
+namespace Adaptation.Si
+{
+
+    public class LDS2559Reply
+    {
+
+        public enum FieldName
+        {
+            ETC,
+            ETX,
+            IFX_ECD,
+            IFX_ETX,
+            PARAMETER,
+            ACCEPTED,
+            EXCLUDE,
+            HIT,
+            CALCULATED,
+            CHANNEL,
+            CKC,
+            OOB,
+            VIOLATION,
+            MEAN,
+            OFFLINE,
+            PARAMETERNAME,
+            SAMPID_64,
+            REPLY,
+            UNACCEPTED,
+            VIOLATIONS
+        }
+
+        public class HIT
+        {
+
+            public object CALCULATED { get; set; } //bool
+            public object CHANNEL { get; set; } //Int32
+            public object CKC { get; set; } //Int32
+            public object OOB { get; set; } //bool
+            public object VIOLATION { get; set; } //Int32
+
+            public HIT(Message value)
+            {
+                MessageField messageField;
+                for (uint i = 0; i < value.FieldCount; i++)
+                {
+                    messageField = value.GetFieldByIndex(i);
+                    if (messageField.Name == FieldName.CALCULATED.ToString())
+                        CALCULATED = messageField.Value;
+                    else if (messageField.Name == FieldName.CHANNEL.ToString())
+                        CHANNEL = messageField.Value;
+                    else if (messageField.Name == FieldName.CKC.ToString())
+                        CKC = messageField.Value;
+                    else if (messageField.Name == FieldName.OOB.ToString())
+                        OOB = messageField.Value;
+                    else if (messageField.Name == FieldName.VIOLATION.ToString())
+                        VIOLATION = messageField.Value;
+                    else
+                        throw new Exception();
+                }
+            }
+
+            public override string ToString()
+            {
+                return string.Concat(CALCULATED, '\t', CHANNEL, '\t', CKC, '\t', OOB, '\t', VIOLATION);
+            }
+
+        }
+
+        public class PARAMETER
+        {
+
+            public object ACCEPTED { get; set; } //bool
+            public object EXCLUDE { get; set; } //Int32
+            public List<HIT> HIT { get; set; }
+            public object MEAN { get; set; } //double
+            public object OFFLINE { get; set; } //bool
+            public object PARAMETERNAME { get; set; } //string
+            public object SAMPID_64 { get; set; } //Int64
+
+            public PARAMETER(Message value)
+            {
+                HIT hit;
+                Message message;
+                HIT = new List<HIT>();
+                object objectFieldValue;
+                MessageField messageField;
+                for (uint i = 0; i < value.FieldCount; i++)
+                {
+                    messageField = value.GetFieldByIndex(i);
+                    if (messageField.Name == FieldName.ACCEPTED.ToString())
+                        ACCEPTED = messageField.Value;
+                    else if (messageField.Name == FieldName.EXCLUDE.ToString())
+                        EXCLUDE = messageField.Value;
+                    else if (messageField.Name == FieldName.HIT.ToString())
+                    {
+                        if (!(messageField.Value is null) && messageField.Value is Message)
+                        {
+                            message = (Message)messageField.Value;
+                            {
+                                for (uint j = 0; j < message.FieldCount; j++)
+                                {
+                                    objectFieldValue = message.GetFieldByIndex(j).Value;
+                                    if (!(objectFieldValue is null) && objectFieldValue is Message)
+                                    {
+                                        hit = new HIT((Message)objectFieldValue);
+                                        HIT.Add(hit);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else if (messageField.Name == FieldName.MEAN.ToString())
+                        MEAN = messageField.Value;
+                    else if (messageField.Name == FieldName.OFFLINE.ToString())
+                        OFFLINE = messageField.Value;
+                    else if (messageField.Name == FieldName.PARAMETERNAME.ToString())
+                        PARAMETERNAME = messageField.Value;
+                    else if (messageField.Name == FieldName.SAMPID_64.ToString())
+                        SAMPID_64 = messageField.Value;
+                    else
+                        throw new Exception();
+                }
+            }
+
+            public override string ToString()
+            {
+                string result;
+                if (!HIT.Any())
+                    result = string.Concat(ACCEPTED, '\t', EXCLUDE, '\t', "HIT = 0", '\t', MEAN, '\t', OFFLINE, '\t', PARAMETERNAME, '\t', SAMPID_64);
+                else
+                    result = string.Concat(ACCEPTED, '\t', EXCLUDE, '\t', "[Count ", HIT.Count, " - 0 {", HIT[0], "}]", '\t', MEAN, '\t', OFFLINE, '\t', PARAMETERNAME, '\t', SAMPID_64);
+                return result;
+            }
+
+        }
+
+        public class DATA
+        {
+
+            public object ETC { get; set; } //Int32
+            public object ETX { get; set; }
+            public object IFX_ECD { get; set; } //Int32
+            public object IFX_ETX { get; set; } //string
+            public List<PARAMETER> PARAMETER { get; set; }
+            public object REPLY { get; set; } //Int32
+            public object UNACCEPTED { get; set; } //Int32
+            public object VIOLATIONS { get; set; } //Int32
+
+            public DATA(IfxDoc ifxDoc = null)
+            {
+                PARAMETER = new List<PARAMETER>();
+                if (!(ifxDoc is null))
+                {
+                    Message message;
+                    PARAMETER parameter;
+                    object objectFieldValue;
+                    MessageField messageField;
+                    for (uint i = 0; i < ifxDoc.msg.FieldCount; i++)
+                    {
+                        messageField = ifxDoc.msg.GetFieldByIndex(i);
+                        if (messageField.Name == FieldName.ETC.ToString())
+                            ETC = messageField.Value;
+                        else if (messageField.Name == FieldName.ETX.ToString())
+                            ETX = messageField.Value;
+                        else if (messageField.Name == FieldName.IFX_ECD.ToString())
+                            IFX_ECD = messageField.Value;
+                        else if (messageField.Name == FieldName.IFX_ETX.ToString())
+                            IFX_ETX = messageField.Value;
+                        else if (messageField.Name == FieldName.PARAMETER.ToString())
+                        {
+                            if (!(messageField.Value is null) && messageField.Value is Message)
+                            {
+                                message = (Message)messageField.Value;
+                                {
+                                    for (uint j = 0; j < message.FieldCount; j++)
+                                    {
+                                        objectFieldValue = message.GetFieldByIndex(j).Value;
+                                        if (!(objectFieldValue is null) && objectFieldValue is Message)
+                                        {
+                                            parameter = new PARAMETER((Message)objectFieldValue);
+                                            PARAMETER.Add(parameter);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else if (messageField.Name == FieldName.REPLY.ToString())
+                            REPLY = messageField.Value;
+                        else if (messageField.Name == FieldName.UNACCEPTED.ToString())
+                            UNACCEPTED = messageField.Value;
+                        else if (messageField.Name == FieldName.VIOLATIONS.ToString())
+                            VIOLATIONS = messageField.Value;
+                        else
+                            throw new Exception();
+                    }
+                }
+            }
+
+            public override string ToString()
+            {
+                string result;
+                if (!PARAMETER.Any())
+                    result = string.Concat(IFX_ECD, '\t', IFX_ETX, '\t', "PARAMETER = 0", '\t', REPLY, '\t', UNACCEPTED, '\t', VIOLATIONS);
+                else
+                    result = string.Concat(IFX_ECD, '\t', IFX_ETX, '\t', "[Count ", PARAMETER.Count, " - 0 {", PARAMETER[0], "}]", '\t', REPLY, '\t', UNACCEPTED, '\t', VIOLATIONS);
+                return result;
+            }
+
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/LDS2559Send.cs

@@ -0,0 +1,317 @@
+using Adaptation.Shared;
+using Infineon.Yoda;
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Si
+{
+
+    public class LDS2559Send
+    {
+
+        public enum FieldName
+        {
+            IFX_SERVICE,
+            KEYS,
+            PARAMETER,
+            SETTINGS,
+            PARAMETERNAME,
+            VALUE
+        }
+
+        public class Settings
+        {
+            public string MODE { get; set; }
+            public int COMTIMEOUT { get; set; }
+            public string DATE { get; private set; }
+            public int KEY { get; set; }
+            public int LDS { get; set; }
+            public string SENDER { get; set; }
+
+            public Settings(string ifxSubjectPrefix, Logistics logistics)
+            {
+                MODE = "FULL";
+                COMTIMEOUT = 10;
+                KEY = 0;
+                switch (ifxSubjectPrefix)
+                {
+                    case "VIH_D": LDS = 2599; break;
+                    case "VIH_P": LDS = 2500; break;
+                    default: LDS = -1; break;
+                }
+                SENDER = Environment.MachineName;
+                DATE = logistics.DateTimeFromSequence.ToString("yyyyMMddHHmmss");
+            }
+
+        }
+
+        public class Value
+        {
+            public DataKeys DataKeys { get; set; }
+            public string VALUE { get; set; }
+
+            public Value(Logistics logistics)
+            {
+                DataKeys = new DataKeys(logistics);
+            }
+
+        }
+
+        public class Parameter
+        {
+
+            public ExtractorKeys ExtractorKeys { get; set; }
+            public DataKeys DataKeys { get; set; }
+            public string COMMENT { get; set; }
+            public double? LSL { get; set; }
+            public string PARAMETERNAME { get; set; }
+            public double? TSL { get; set; }
+            public string UNIT { get; set; }
+            public double? USL { get; set; }
+            public string VALUE { get; set; }
+
+            public Parameter(Logistics logistics)
+            {
+                ExtractorKeys = new ExtractorKeys(logistics);
+                DataKeys = new DataKeys(logistics);
+            }
+
+            public Parameter(Logistics logistics, string parameterName, string value)
+            {
+                ExtractorKeys = new ExtractorKeys(logistics);
+                DataKeys = new DataKeys(logistics);
+                PARAMETERNAME = parameterName;
+                VALUE = value;
+            }
+
+            public Parameter(Logistics logistics, ExtendedParameter extendedParameter)
+            {
+                ExtractorKeys = new ExtractorKeys(logistics);
+                DataKeys = new DataKeys(logistics);
+                PARAMETERNAME = extendedParameter.DiplayName;
+                LSL = extendedParameter.LSL;
+                TSL = extendedParameter.TSL;
+                UNIT = extendedParameter.Unit;
+                USL = extendedParameter.USL;
+                VALUE = extendedParameter.Value;
+            }
+
+        }
+
+        public class DataKeys
+        {
+
+            public string Employee { get; set; } //1
+            public string SID { get; set; } //2
+            public string WaferRegion { get; set; } //3
+            public string WaferScribe { get; set; } //4
+            public string WaferPosition { get; set; } //5
+            public string X { get; set; } //6
+            public string Y { get; set; } //7
+            public string EAFCellInstance { get; set; } //8
+            public string EAFReference { get; set; } //9
+            public string IQSReference { get; set; } //10
+
+            public DataKeys(Logistics logistics, IScopeInfo scopeInfo = null, string sID = null)
+            {
+                if (scopeInfo is null)
+                {
+                    SID = null;
+                    EAFReference = null;
+                    IQSReference = null;
+                    EAFCellInstance = null;
+                }
+                else
+                {
+                    if (string.IsNullOrEmpty(sID))
+                        SID = "-";
+                    else
+                        SID = sID;
+                    EAFReference = scopeInfo.EquipmentType.ToString();
+                    if (string.IsNullOrEmpty(scopeInfo.QueryFilter))
+                        IQSReference = null;
+                    else
+                        IQSReference = scopeInfo.QueryFilter;
+                    if (logistics is null)
+                        EAFCellInstance = null;
+                    else
+                        EAFCellInstance = logistics.JobID;
+                }
+            }
+
+        }
+
+        public class ExtractorKeys
+        {
+
+            public string Lot { get; set; } //1
+            public string ToolID { get; set; } //2
+            public string Process { get; set; } //3
+            public string WaferID { get; set; } //4
+            public string Part { get; set; } //5
+            public string Recipe { get; set; } //6
+            public string ProcessFlow { get; set; } //7
+
+            public ExtractorKeys(Logistics logistics, IScopeInfo scopeInfo = null)
+            {
+                if (scopeInfo is null)
+                {
+                    ToolID = null;
+                    Lot = null;
+                    Part = null;
+                }
+                else
+                {
+                    ToolID = logistics.MesEntity;
+                    Lot = "-";
+                    Part = "-";
+                }
+            }
+
+        }
+
+        public class DATA
+        {
+            public string IFX_SERVICE { get; set; }
+            public ExtractorKeys ExtractorKeys { get; set; }
+            public DataKeys DataKeys { get; set; }
+            public Parameter Parameter { get; set; }
+            public Settings Settings { get; set; }
+
+            public DATA(string ifxSubjectPrefix, Logistics logistics, IScopeInfo scopeInfo, string sID)
+            {
+                ExtractorKeys = new ExtractorKeys(logistics, scopeInfo);
+                DataKeys = new DataKeys(logistics, scopeInfo, sID);
+                Parameter = new Parameter(logistics);
+                Settings = new Settings(ifxSubjectPrefix, logistics);
+            }
+
+            internal static IfxDoc GetIfxDoc(string service, string value, DataKeys dataKeys, ExtractorKeys extractorKeys, Settings settings)
+            {
+                IfxDoc result = new IfxDoc();
+                if (!string.IsNullOrEmpty(service))
+                    result.Add(string.Concat(FieldName.IFX_SERVICE), service);
+                if (!(value is null))
+                {
+                    if (string.IsNullOrEmpty(value))
+                        result.Add(string.Concat(FieldName.VALUE), "-");
+                    else
+                        result.Add(string.Concat(FieldName.VALUE), value);
+                }
+                if (!(dataKeys is null))
+                {
+                    if (!string.IsNullOrEmpty(dataKeys.EAFCellInstance))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.EAFCellInstance)), dataKeys.EAFCellInstance);
+                    if (!string.IsNullOrEmpty(dataKeys.EAFReference))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.EAFReference)), dataKeys.EAFReference);
+                    if (!string.IsNullOrEmpty(dataKeys.Employee))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.Employee)), dataKeys.Employee);
+                    if (!string.IsNullOrEmpty(dataKeys.IQSReference))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.IQSReference)), dataKeys.IQSReference);
+                    if (!string.IsNullOrEmpty(dataKeys.SID))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.SID)), dataKeys.SID);
+                    if (!string.IsNullOrEmpty(dataKeys.WaferPosition))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.WaferPosition)), dataKeys.WaferPosition);
+                    if (!string.IsNullOrEmpty(dataKeys.WaferRegion))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.WaferRegion)), dataKeys.WaferRegion);
+                    if (!string.IsNullOrEmpty(dataKeys.WaferScribe))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.WaferScribe)), dataKeys.WaferScribe);
+                    if (!string.IsNullOrEmpty(dataKeys.X))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.X)), dataKeys.X);
+                    if (!string.IsNullOrEmpty(dataKeys.Y))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.DataKeys.Y)), dataKeys.Y);
+                }
+                if (!(extractorKeys is null))
+                {
+                    if (!string.IsNullOrEmpty(extractorKeys.Lot))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.ExtractorKeys.Lot)), extractorKeys.Lot);
+                    if (!string.IsNullOrEmpty(extractorKeys.Part))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.ExtractorKeys.Part)), extractorKeys.Part);
+                    if (!string.IsNullOrEmpty(extractorKeys.Process))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.ExtractorKeys.Process)), extractorKeys.Process);
+                    if (!string.IsNullOrEmpty(extractorKeys.ProcessFlow))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.ExtractorKeys.ProcessFlow)), extractorKeys.ProcessFlow);
+                    if (!string.IsNullOrEmpty(extractorKeys.Recipe))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.ExtractorKeys.Recipe)), extractorKeys.Recipe);
+                    if (!string.IsNullOrEmpty(extractorKeys.ToolID))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.ExtractorKeys.ToolID)), extractorKeys.ToolID);
+                    if (!string.IsNullOrEmpty(extractorKeys.WaferID))
+                        result.Add(string.Concat(FieldName.KEYS, "/", nameof(LDS2559Send.ExtractorKeys.WaferID)), extractorKeys.WaferID);
+                }
+                if (!(settings is null))
+                {
+                    result.Add(string.Concat(FieldName.SETTINGS, "/", nameof(LDS2559Send.Settings.MODE)), settings.MODE);
+                    result.Add(string.Concat(FieldName.SETTINGS, "/", nameof(LDS2559Send.Settings.COMTIMEOUT)), settings.COMTIMEOUT);
+                    result.Add(string.Concat(FieldName.SETTINGS, "/", nameof(LDS2559Send.Settings.DATE)), settings.DATE);
+                    result.Add(string.Concat(FieldName.SETTINGS, "/", nameof(LDS2559Send.Settings.KEY)), settings.KEY);
+                    result.Add(string.Concat(FieldName.SETTINGS, "/", nameof(LDS2559Send.Settings.LDS)), settings.LDS);
+                    result.Add(string.Concat(FieldName.SETTINGS, "/", nameof(LDS2559Send.Settings.SENDER)), settings.SENDER);
+                }
+                return result;
+            }
+
+            public IfxDoc GetIfxDoc(List<IfxDoc> parameters)
+            {
+                IfxDoc result = GetIfxDoc("EVALUATESPCDATA", value: null, dataKeys: DataKeys, extractorKeys: ExtractorKeys, settings: Settings);
+                result.Add(string.Concat(FieldName.PARAMETER), parameters.ToArray());
+                return result;
+            }
+
+        }
+
+        public class ParameterCollection
+        {
+            public List<Parameter> Collection { get; set; }
+
+            public ParameterCollection()
+            {
+                Collection = new List<Parameter>();
+            }
+
+            public IfxDoc GetIfxDoc()
+            {
+                IfxDoc value;
+                IfxDoc result = new IfxDoc();
+                Parameter parameter;
+                List<IfxDoc> values = new List<IfxDoc>();
+                for (int i = 0; i < Collection.Count; i++)
+                {
+                    parameter = Collection[i];
+                    if (i == 0)
+                    {
+                        if (parameter.TSL.HasValue & parameter.USL.HasValue && parameter.TSL.Value > parameter.USL.Value)
+                            parameter.USL = parameter.TSL.Value;
+                        if (parameter.TSL.HasValue & parameter.LSL.HasValue && parameter.TSL.Value < parameter.LSL.Value)
+                            parameter.LSL = parameter.TSL.Value;
+                        //
+                        if (parameter.LSL.HasValue & parameter.USL.HasValue && parameter.LSL.Value > parameter.USL.Value && parameter.USL.Value == 0)
+                            parameter.USL = null;
+                        //
+                        if (parameter.USL.HasValue & parameter.LSL.HasValue && parameter.USL.Value < parameter.LSL.Value)
+                            throw new Exception();
+                        if (parameter.LSL.HasValue & parameter.USL.HasValue && parameter.LSL.Value > parameter.USL.Value)
+                            throw new Exception();
+                        //
+                        if (parameter.LSL.HasValue)
+                            result.Add(nameof(Parameter.LSL), parameter.LSL);
+                        if (!string.IsNullOrEmpty(parameter.PARAMETERNAME))
+                            result.Add(string.Concat(FieldName.PARAMETERNAME), parameter.PARAMETERNAME);
+                        if (parameter.TSL.HasValue)
+                            result.Add(nameof(Parameter.TSL), parameter.TSL.Value);
+                        if (!string.IsNullOrEmpty(parameter.UNIT))
+                            result.Add(nameof(Parameter.UNIT), parameter.UNIT);
+                        if (parameter.USL.HasValue)
+                            result.Add(nameof(Parameter.USL), parameter.USL.Value);
+                    }
+                    value = DATA.GetIfxDoc(service: string.Empty, value: parameter.VALUE, dataKeys: parameter.DataKeys, extractorKeys: parameter.ExtractorKeys, settings: null);
+                    values.Add(value);
+                }
+                result.Add(string.Concat(FieldName.VALUE), values.ToArray());
+                return result;
+            }
+
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Metrology/MET08ANLYSDIFAAST230.cs

@@ -0,0 +1,35 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Adaptation.Metrology
+{
+
+    internal class MET08ANLYSDIFAAST230
+    {
+
+        internal static Dictionary<int, List<object>> GetPreRunInfo(Logistics logistics, EventName eventName)
+        {
+            Dictionary<int, List<object>> results = new Dictionary<int, List<object>>();
+            return results;
+        }
+
+        internal static List<PreRunInfo> Verify(EventName eventName, List<PreRunInfo> results)
+        {
+            return results;
+        }
+
+        internal static string GetSid(List<PreRunInfo> preRunInfo, bool isMappedPart, IScopeInfo scopeInfo, List<string> tags)
+        {
+            string result = string.Empty;
+            if (preRunInfo.Any())
+            {
+                result = tags[0];
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Metrology/MET08DDUPSFS6420.cs

@@ -0,0 +1,104 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Adaptation.Metrology
+{
+
+    internal class MET08DDUPSFS6420
+    {
+
+        internal static Dictionary<int, List<object>> GetPreRunInfo(Logistics logistics, EventName eventName)
+        {
+            //2019-12-27 - 001
+            Dictionary<int, List<object>> results;
+            StringBuilder sql = new StringBuilder();
+            sql.Append(" SELECT ").
+                Append(" wafer_id, [run number], recipe, [part number], date, pocket_number, wafer_lot, [satellite group], ISNULL(( ").
+                Append(" SELECT max(startstamp) ").
+                Append(" FROM G4Wafers_01.dbo.ToolTimeInfo ").
+                Append(" WHERE (lot = @mid OR lot = @midSubstring) ").
+                Append(" ), date) startstamp ").
+                Append(" FROM G4Wafers_01.dbo.[prerun info] ").
+                Append(" WHERE (wafer_id = @mid OR [run number] = @mid) ").
+                Append(" ORDER by date ");
+            List<Tuple<string, string>> parameters = new List<Tuple<string, string>>
+            {
+                new Tuple<string, string>("@midSubstring", string.Concat("'", logistics.MID.Substring(0, logistics.MID.Length - 2), "'")),
+                new Tuple<string, string>("@mid", string.Concat("'", logistics.MID, "'"))
+            };
+            results = SQLDatabase.ExecuteReader(sql, parameters, columns: 9, isG4Wafers: true, isIrmnSpc: false);
+            return results;
+        }
+
+        internal static List<PreRunInfo> Verify(EventName eventName, List<PreRunInfo> results)
+        {
+            //2019-12-28 - 004
+            if (results.Any())
+            {
+                string partFromRecipe;
+                Dictionary<int, List<object>> check;
+                StringBuilder sql = new StringBuilder();
+                string lastPartFromRecipe = string.Empty;
+                List<Tuple<string, string>> parameters = new List<Tuple<string, string>>();
+                for (int i = 0; i < results.Count; i++)
+                {
+                    partFromRecipe = results[i].Recipe;
+                    if (string.IsNullOrEmpty(lastPartFromRecipe) || partFromRecipe != lastPartFromRecipe)
+                    {
+                        // re-format recipe name by extracting middle part of it
+                        if ((!partFromRecipe.ToUpper().StartsWith("PROD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("MAMD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("QUAL")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ENGR")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ANKO")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("U")))
+                            partFromRecipe = "ENG";
+                        else if (partFromRecipe.Split('-').Length == 3) // recipe name has 3 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim() + "-" + partFromRecipe.Split('-')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('-').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim(); // first part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 3)
+                            partFromRecipe = partFromRecipe.Split('_')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('_')[0].Trim(); // first part of recipe name
+                        if (results[i].PartNumber != partFromRecipe)
+                            results[i].PartNumber = partFromRecipe;
+                        if (partFromRecipe != "ENG")
+                        {
+                            sql.Append(" SELECT ").
+                                Append(" count(*) AS my_count ").
+                                Append(" FROM IRMNSPC.dbo.part_dat ").
+                                Append(" WHERE f_name = @part ");
+                            parameters.Clear();
+                            parameters.Add(new Tuple<string, string>("@part", string.Concat("'", partFromRecipe, "'")));
+                            check = SQLDatabase.ExecuteReader(sql, parameters, columns: 1, isG4Wafers: true, isIrmnSpc: false);
+                            if (check.ElementAt(0).Value[0].ToString() == "0")
+                            {
+                                partFromRecipe = "ENG";
+                                results[i].PartNumber = partFromRecipe;
+                            }
+                        }
+                    }
+                    lastPartFromRecipe = partFromRecipe;
+                }
+            }
+            return results;
+        }
+
+        internal static string GetSid(List<PreRunInfo> preRunInfo, bool isMappedPart, IScopeInfo scopeInfo, List<string> tags)
+        {
+            string result = string.Empty;
+            if (preRunInfo.Any())
+            {
+                result = tags[0];
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Metrology/MET08DDUPSP1TBI.cs

@@ -0,0 +1,104 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Adaptation.Metrology
+{
+
+    internal class MET08DDUPSP1TBI
+    {
+
+        internal static Dictionary<int, List<object>> GetPreRunInfo(Logistics logistics, EventName eventName)
+        {
+            //2019-12-27 - 001
+            Dictionary<int, List<object>> results;
+            StringBuilder sql = new StringBuilder();
+            sql.Append(" SELECT ").
+                Append(" wafer_id, [run number], recipe, [part number], date, pocket_number, wafer_lot, [satellite group], ISNULL(( ").
+                Append(" SELECT max(startstamp) ").
+                Append(" FROM G4Wafers_01.dbo.ToolTimeInfo ").
+                Append(" WHERE (lot = @mid OR lot = @midSubstring) ").
+                Append(" ), date) startstamp ").
+                Append(" FROM G4Wafers_01.dbo.[prerun info] ").
+                Append(" WHERE (wafer_id = @mid OR [run number] = @mid) ").
+                Append(" ORDER by date ");
+            List<Tuple<string, string>> parameters = new List<Tuple<string, string>>
+            {
+                new Tuple<string, string>("@midSubstring", string.Concat("'", logistics.MID.Substring(0, logistics.MID.Length - 2), "'")),
+                new Tuple<string, string>("@mid", string.Concat("'", logistics.MID, "'"))
+            };
+            results = SQLDatabase.ExecuteReader(sql, parameters, columns: 9, isG4Wafers: true, isIrmnSpc: false);
+            return results;
+        }
+
+        internal static List<PreRunInfo> Verify(EventName eventName, List<PreRunInfo> results)
+        {
+            //2019-12-28 - 004
+            if (results.Any())
+            {
+                string partFromRecipe;
+                Dictionary<int, List<object>> check;
+                StringBuilder sql = new StringBuilder();
+                string lastPartFromRecipe = string.Empty;
+                List<Tuple<string, string>> parameters = new List<Tuple<string, string>>();
+                for (int i = 0; i < results.Count; i++)
+                {
+                    partFromRecipe = results[i].Recipe;
+                    if (string.IsNullOrEmpty(lastPartFromRecipe) || partFromRecipe != lastPartFromRecipe)
+                    {
+                        // re-format recipe name by extracting middle part of it
+                        if ((!partFromRecipe.ToUpper().StartsWith("PROD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("MAMD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("QUAL")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ENGR")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ANKO")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("U")))
+                            partFromRecipe = "ENG";
+                        else if (partFromRecipe.Split('-').Length == 3) // recipe name has 3 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim() + "-" + partFromRecipe.Split('-')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('-').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim(); // first part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 3)
+                            partFromRecipe = partFromRecipe.Split('_')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('_')[0].Trim(); // first part of recipe name
+                        if (results[i].PartNumber != partFromRecipe)
+                            results[i].PartNumber = partFromRecipe;
+                        if (partFromRecipe != "ENG")
+                        {
+                            sql.Append(" SELECT ").
+                                Append(" count(*) AS my_count ").
+                                Append(" FROM IRMNSPC.dbo.part_dat ").
+                                Append(" WHERE f_name = @part ");
+                            parameters.Clear();
+                            parameters.Add(new Tuple<string, string>("@part", string.Concat("'", partFromRecipe, "'")));
+                            check = SQLDatabase.ExecuteReader(sql, parameters, columns: 1, isG4Wafers: true, isIrmnSpc: false);
+                            if (check.ElementAt(0).Value[0].ToString() == "0")
+                            {
+                                partFromRecipe = "ENG";
+                                results[i].PartNumber = partFromRecipe;
+                            }
+                        }
+                    }
+                    lastPartFromRecipe = partFromRecipe;
+                }
+            }
+            return results;
+        }
+
+        internal static string GetSid(List<PreRunInfo> preRunInfo, bool isMappedPart, IScopeInfo scopeInfo, List<string> tags)
+        {
+            string result = string.Empty;
+            if (preRunInfo.Any())
+            {
+                result = tags[0];
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Metrology/MET08RESIHGCV.cs

@@ -0,0 +1,104 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Adaptation.Metrology
+{
+
+    internal class MET08RESIHGCV
+    {
+
+        internal static Dictionary<int, List<object>> GetPreRunInfo(Logistics logistics, EventName eventName)
+        {
+            //2019-12-27 - 001
+            Dictionary<int, List<object>> results;
+            StringBuilder sql = new StringBuilder();
+            sql.Append(" SELECT ").
+                Append(" wafer_id, [run number], recipe, [part number], date, pocket_number, wafer_lot, [satellite group], ISNULL(( ").
+                Append(" SELECT max(startstamp) ").
+                Append(" FROM G4Wafers_01.dbo.ToolTimeInfo ").
+                Append(" WHERE (lot = @mid OR lot = @midSubstring) ").
+                Append(" ), date) startstamp ").
+                Append(" FROM G4Wafers_01.dbo.[prerun info] ").
+                Append(" WHERE (wafer_id = @mid OR [run number] = @mid) ").
+                Append(" ORDER by date ");
+            List<Tuple<string, string>> parameters = new List<Tuple<string, string>>
+            {
+                new Tuple<string, string>("@midSubstring", string.Concat("'", logistics.MID.Substring(0, logistics.MID.Length - 2), "'")),
+                new Tuple<string, string>("@mid", string.Concat("'", logistics.MID, "'"))
+            };
+            results = SQLDatabase.ExecuteReader(sql, parameters, columns: 9, isG4Wafers: true, isIrmnSpc: false);
+            return results;
+        }
+
+        internal static List<PreRunInfo> Verify(EventName eventName, List<PreRunInfo> results)
+        {
+            //2019-12-28 - 004
+            if (results.Any())
+            {
+                string partFromRecipe;
+                Dictionary<int, List<object>> check;
+                StringBuilder sql = new StringBuilder();
+                string lastPartFromRecipe = string.Empty;
+                List<Tuple<string, string>> parameters = new List<Tuple<string, string>>();
+                for (int i = 0; i < results.Count; i++)
+                {
+                    partFromRecipe = results[i].Recipe;
+                    if (string.IsNullOrEmpty(lastPartFromRecipe) || partFromRecipe != lastPartFromRecipe)
+                    {
+                        // re-format recipe name by extracting middle part of it
+                        if ((!partFromRecipe.ToUpper().StartsWith("PROD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("MAMD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("QUAL")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ENGR")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ANKO")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("U")))
+                            partFromRecipe = "ENG";
+                        else if (partFromRecipe.Split('-').Length == 3) // recipe name has 3 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim() + "-" + partFromRecipe.Split('-')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('-').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim(); // first part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 3)
+                            partFromRecipe = partFromRecipe.Split('_')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('_')[0].Trim(); // first part of recipe name
+                        if (results[i].PartNumber != partFromRecipe)
+                            results[i].PartNumber = partFromRecipe;
+                        if (partFromRecipe != "ENG")
+                        {
+                            sql.Append(" SELECT ").
+                                Append(" count(*) AS my_count ").
+                                Append(" FROM IRMNSPC.dbo.part_dat ").
+                                Append(" WHERE f_name = @part ");
+                            parameters.Clear();
+                            parameters.Add(new Tuple<string, string>("@part", string.Concat("'", partFromRecipe, "'")));
+                            check = SQLDatabase.ExecuteReader(sql, parameters, columns: 1, isG4Wafers: true, isIrmnSpc: false);
+                            if (check.ElementAt(0).Value[0].ToString() == "0")
+                            {
+                                partFromRecipe = "ENG";
+                                results[i].PartNumber = partFromRecipe;
+                            }
+                        }
+                    }
+                    lastPartFromRecipe = partFromRecipe;
+                }
+            }
+            return results;
+        }
+
+        internal static string GetSid(List<PreRunInfo> preRunInfo, bool isMappedPart, IScopeInfo scopeInfo, List<string> tags)
+        {
+            string result = string.Empty;
+            if (preRunInfo.Any())
+            {
+                result = tags[0];
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Metrology/MET08RESIMAPCDE.cs

@@ -0,0 +1,104 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Adaptation.Metrology
+{
+
+    internal class MET08RESIMAPCDE
+    {
+
+        internal static Dictionary<int, List<object>> GetPreRunInfo(Logistics logistics, EventName eventName)
+        {
+            //2019-12-27 - 001
+            Dictionary<int, List<object>> results;
+            StringBuilder sql = new StringBuilder();
+            sql.Append(" SELECT ").
+                Append(" wafer_id, [run number], recipe, [part number], date, pocket_number, wafer_lot, [satellite group], ISNULL(( ").
+                Append(" SELECT max(startstamp) ").
+                Append(" FROM G4Wafers_01.dbo.ToolTimeInfo ").
+                Append(" WHERE (lot = @mid OR lot = @midSubstring) ").
+                Append(" ), date) startstamp ").
+                Append(" FROM G4Wafers_01.dbo.[prerun info] ").
+                Append(" WHERE (wafer_id = @mid OR [run number] = @mid) ").
+                Append(" ORDER by date ");
+            List<Tuple<string, string>> parameters = new List<Tuple<string, string>>
+            {
+                new Tuple<string, string>("@midSubstring", string.Concat("'", logistics.MID.Substring(0, logistics.MID.Length - 2), "'")),
+                new Tuple<string, string>("@mid", string.Concat("'", logistics.MID, "'"))
+            };
+            results = SQLDatabase.ExecuteReader(sql, parameters, columns: 9, isG4Wafers: true, isIrmnSpc: false);
+            return results;
+        }
+
+        internal static List<PreRunInfo> Verify(EventName eventName, List<PreRunInfo> results)
+        {
+            //2019-12-28 - 004
+            if (results.Any())
+            {
+                string partFromRecipe;
+                Dictionary<int, List<object>> check;
+                StringBuilder sql = new StringBuilder();
+                string lastPartFromRecipe = string.Empty;
+                List<Tuple<string, string>> parameters = new List<Tuple<string, string>>();
+                for (int i = 0; i < results.Count; i++)
+                {
+                    partFromRecipe = results[i].Recipe;
+                    if (string.IsNullOrEmpty(lastPartFromRecipe) || partFromRecipe != lastPartFromRecipe)
+                    {
+                        // re-format recipe name by extracting middle part of it
+                        if ((!partFromRecipe.ToUpper().StartsWith("PROD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("MAMD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("QUAL")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ENGR")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ANKO")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("U")))
+                            partFromRecipe = "ENG";
+                        else if (partFromRecipe.Split('-').Length == 3) // recipe name has 3 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim() + "-" + partFromRecipe.Split('-')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('-').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim(); // first part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 3)
+                            partFromRecipe = partFromRecipe.Split('_')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('_')[0].Trim(); // first part of recipe name
+                        if (results[i].PartNumber != partFromRecipe)
+                            results[i].PartNumber = partFromRecipe;
+                        if (partFromRecipe != "ENG")
+                        {
+                            sql.Append(" SELECT ").
+                                Append(" count(*) AS my_count ").
+                                Append(" FROM IRMNSPC.dbo.part_dat ").
+                                Append(" WHERE f_name = @part ");
+                            parameters.Clear();
+                            parameters.Add(new Tuple<string, string>("@part", string.Concat("'", partFromRecipe, "'")));
+                            check = SQLDatabase.ExecuteReader(sql, parameters, columns: 1, isG4Wafers: true, isIrmnSpc: false);
+                            if (check.ElementAt(0).Value[0].ToString() == "0")
+                            {
+                                partFromRecipe = "ENG";
+                                results[i].PartNumber = partFromRecipe;
+                            }
+                        }
+                    }
+                    lastPartFromRecipe = partFromRecipe;
+                }
+            }
+            return results;
+        }
+
+        internal static string GetSid(List<PreRunInfo> preRunInfo, bool isMappedPart, IScopeInfo scopeInfo, List<string> tags)
+        {
+            string result = string.Empty;
+            if (preRunInfo.Any())
+            {
+                result = tags[0];
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Metrology/MET08THFTIRQS408M.cs

@@ -0,0 +1,104 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Adaptation.Metrology
+{
+
+    internal class MET08THFTIRQS408M
+    {
+
+        internal static Dictionary<int, List<object>> GetPreRunInfo(Logistics logistics, EventName eventName)
+        {
+            //2019-12-27 - 001
+            Dictionary<int, List<object>> results;
+            StringBuilder sql = new StringBuilder();
+            sql.Append(" SELECT ").
+                Append(" wafer_id, [run number], recipe, [part number], date, pocket_number, wafer_lot, [satellite group], ISNULL(( ").
+                Append(" SELECT max(startstamp) ").
+                Append(" FROM G4Wafers_01.dbo.ToolTimeInfo ").
+                Append(" WHERE (lot = @mid OR lot = @midSubstring) ").
+                Append(" ), date) startstamp ").
+                Append(" FROM G4Wafers_01.dbo.[prerun info] ").
+                Append(" WHERE (wafer_id = @mid OR [run number] = @mid) ").
+                Append(" ORDER by date ");
+            List<Tuple<string, string>> parameters = new List<Tuple<string, string>>
+            {
+                new Tuple<string, string>("@midSubstring", string.Concat("'", logistics.MID.Substring(0, logistics.MID.Length - 2), "'")),
+                new Tuple<string, string>("@mid", string.Concat("'", logistics.MID, "'"))
+            };
+            results = SQLDatabase.ExecuteReader(sql, parameters, columns: 9, isG4Wafers: true, isIrmnSpc: false);
+            return results;
+        }
+
+        internal static List<PreRunInfo> Verify(EventName eventName, List<PreRunInfo> results)
+        {
+            //2019-12-28 - 004
+            if (results.Any())
+            {
+                string partFromRecipe;
+                Dictionary<int, List<object>> check;
+                StringBuilder sql = new StringBuilder();
+                string lastPartFromRecipe = string.Empty;
+                List<Tuple<string, string>> parameters = new List<Tuple<string, string>>();
+                for (int i = 0; i < results.Count; i++)
+                {
+                    partFromRecipe = results[i].Recipe;
+                    if (string.IsNullOrEmpty(lastPartFromRecipe) || partFromRecipe != lastPartFromRecipe)
+                    {
+                        // re-format recipe name by extracting middle part of it
+                        if ((!partFromRecipe.ToUpper().StartsWith("PROD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("MAMD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("QUAL")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ENGR")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ANKO")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("U")))
+                            partFromRecipe = "ENG";
+                        else if (partFromRecipe.Split('-').Length == 3) // recipe name has 3 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim() + "-" + partFromRecipe.Split('-')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('-').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim(); // first part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 3)
+                            partFromRecipe = partFromRecipe.Split('_')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('_')[0].Trim(); // first part of recipe name
+                        if (results[i].PartNumber != partFromRecipe)
+                            results[i].PartNumber = partFromRecipe;
+                        if (partFromRecipe != "ENG")
+                        {
+                            sql.Append(" SELECT ").
+                                Append(" count(*) AS my_count ").
+                                Append(" FROM IRMNSPC.dbo.part_dat ").
+                                Append(" WHERE f_name = @part ");
+                            parameters.Clear();
+                            parameters.Add(new Tuple<string, string>("@part", string.Concat("'", partFromRecipe, "'")));
+                            check = SQLDatabase.ExecuteReader(sql, parameters, columns: 1, isG4Wafers: true, isIrmnSpc: false);
+                            if (check.ElementAt(0).Value[0].ToString() == "0")
+                            {
+                                partFromRecipe = "ENG";
+                                results[i].PartNumber = partFromRecipe;
+                            }
+                        }
+                    }
+                    lastPartFromRecipe = partFromRecipe;
+                }
+            }
+            return results;
+        }
+
+        internal static string GetSid(List<PreRunInfo> preRunInfo, bool isMappedPart, IScopeInfo scopeInfo, List<string> tags)
+        {
+            string result = string.Empty;
+            if (preRunInfo.Any())
+            {
+                result = tags[0];
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Metrology/MET08THFTIRSTRATUS.cs

@@ -0,0 +1,104 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Adaptation.Metrology
+{
+
+    internal class MET08THFTIRSTRATUS
+    {
+
+        internal static Dictionary<int, List<object>> GetPreRunInfo(Logistics logistics, EventName eventName)
+        {
+            //2019-12-27 - 001
+            Dictionary<int, List<object>> results;
+            StringBuilder sql = new StringBuilder();
+            sql.Append(" SELECT ").
+                Append(" wafer_id, [run number], recipe, [part number], date, pocket_number, wafer_lot, [satellite group], ISNULL(( ").
+                Append(" SELECT max(startstamp) ").
+                Append(" FROM G4Wafers_01.dbo.ToolTimeInfo ").
+                Append(" WHERE (lot = @mid OR lot = @midSubstring) ").
+                Append(" ), date) startstamp ").
+                Append(" FROM G4Wafers_01.dbo.[prerun info] ").
+                Append(" WHERE (wafer_id = @mid OR [run number] = @mid) ").
+                Append(" ORDER by date ");
+            List<Tuple<string, string>> parameters = new List<Tuple<string, string>>
+            {
+                new Tuple<string, string>("@midSubstring", string.Concat("'", logistics.MID.Substring(0, logistics.MID.Length - 2), "'")),
+                new Tuple<string, string>("@mid", string.Concat("'", logistics.MID, "'"))
+            };
+            results = SQLDatabase.ExecuteReader(sql, parameters, columns: 9, isG4Wafers: true, isIrmnSpc: false);
+            return results;
+        }
+
+        internal static List<PreRunInfo> Verify(EventName eventName, List<PreRunInfo> results)
+        {
+            //2019-12-28 - 004
+            if (results.Any())
+            {
+                string partFromRecipe;
+                Dictionary<int, List<object>> check;
+                StringBuilder sql = new StringBuilder();
+                string lastPartFromRecipe = string.Empty;
+                List<Tuple<string, string>> parameters = new List<Tuple<string, string>>();
+                for (int i = 0; i < results.Count; i++)
+                {
+                    partFromRecipe = results[i].Recipe;
+                    if (string.IsNullOrEmpty(lastPartFromRecipe) || partFromRecipe != lastPartFromRecipe)
+                    {
+                        // re-format recipe name by extracting middle part of it
+                        if ((!partFromRecipe.ToUpper().StartsWith("PROD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("MAMD")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("QUAL")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ENGR")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("ANKO")) &&
+                            (!partFromRecipe.ToUpper().StartsWith("U")))
+                            partFromRecipe = "ENG";
+                        else if (partFromRecipe.Split('-').Length == 3) // recipe name has 3 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim() + "-" + partFromRecipe.Split('-')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('-').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('-')[0].Trim(); // first part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 3)
+                            partFromRecipe = partFromRecipe.Split('_')[1].Trim(); // middle part of recipe name
+                        else if (partFromRecipe.Split('_').Length == 2) // recipe name has 2 parts
+                            partFromRecipe = partFromRecipe.Split('_')[0].Trim(); // first part of recipe name
+                        if (results[i].PartNumber != partFromRecipe)
+                            results[i].PartNumber = partFromRecipe;
+                        if (partFromRecipe != "ENG")
+                        {
+                            sql.Append(" SELECT ").
+                                Append(" count(*) AS my_count ").
+                                Append(" FROM IRMNSPC.dbo.part_dat ").
+                                Append(" WHERE f_name = @part ");
+                            parameters.Clear();
+                            parameters.Add(new Tuple<string, string>("@part", string.Concat("'", partFromRecipe, "'")));
+                            check = SQLDatabase.ExecuteReader(sql, parameters, columns: 1, isG4Wafers: true, isIrmnSpc: false);
+                            if (check.ElementAt(0).Value[0].ToString() == "0")
+                            {
+                                partFromRecipe = "ENG";
+                                results[i].PartNumber = partFromRecipe;
+                            }
+                        }
+                    }
+                    lastPartFromRecipe = partFromRecipe;
+                }
+            }
+            return results;
+        }
+
+        internal static string GetSid(List<PreRunInfo> preRunInfo, bool isMappedPart, IScopeInfo scopeInfo, List<string> tags)
+        {
+            string result = string.Empty;
+            if (preRunInfo.Any())
+            {
+                result = tags[0];
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/PreRunInfo.cs

@@ -0,0 +1,54 @@
+using Adaptation.Shared;
+namespace Adaptation.Si
+{
+
+    public class PreRunInfo
+    {
+
+        public string MID { get; private set; }
+        public string RunNumber { get; private set; }
+        public string Recipe { get; private set; }
+        public string PartNumber { get; internal set; }
+        public string Date { get; private set; }
+        public string PocketNumber { get; private set; }
+        public string WaferLot { get; private set; }
+        public string SatelliteGroup { get; private set; }
+        public string StartStamp { get; private set; }
+        public Logistics Logistics { get; private set; }
+
+        public PreRunInfo(Logistics logistics, object partNumber)
+        {
+            MID = logistics.MID;
+            RunNumber = string.Empty;
+            Recipe = string.Empty;
+            PartNumber = partNumber.ToString();
+            Date = logistics.DateTimeFromSequence.ToString();
+            PocketNumber = "00";
+            WaferLot = string.Empty;
+            SatelliteGroup = string.Empty;
+            StartStamp = logistics.DateTimeFromSequence.ToString();
+            Logistics = logistics;
+        }
+
+        public PreRunInfo(Logistics logistics, object mID, object runNumber, object recipe, object partNumber, object date, object pocketNumber, object waferLot, object satelliteGroup, object startStamp)
+        {
+            MID = mID.ToString();
+            RunNumber = runNumber.ToString();
+            Recipe = recipe.ToString();
+            PartNumber = partNumber.ToString();
+            Date = date.ToString();
+            PocketNumber = pocketNumber.ToString();
+            WaferLot = waferLot.ToString();
+            SatelliteGroup = satelliteGroup.ToString();
+            StartStamp = startStamp.ToString();
+            Logistics = logistics;
+        }
+
+        public override string ToString()
+        {
+            return string.Concat(MID, " - ", RunNumber, " - ", Recipe, " - ", PartNumber, " - ", Date, " - ", PocketNumber, " - ", WaferLot, " - ", SatelliteGroup, " - ", StartStamp);
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/SQLDatabase.cs

@@ -0,0 +1,208 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+using System.Threading;
+
+namespace Adaptation.Si
+{
+
+    public class SQLDatabase
+    {
+
+        private static string _ConnectionStringIrmnSpc;
+        private static string _ConnectionStringG4Wafers;
+
+        public static void SetConnectionStringIrmnSpc(string connectionString)
+        {
+            _ConnectionStringIrmnSpc = connectionString;
+        }
+
+        public static void SetConnectionStringG4Wafers(string connectionString)
+        {
+            _ConnectionStringG4Wafers = connectionString;
+        }
+
+        public static Dictionary<string, List<object>> ExecuteReader(StringBuilder rawSql, List<Tuple<string, string>> parameters, List<Tuple<string, int>> columns, bool isG4Wafers, bool isIrmnSpc)
+        {
+            Dictionary<string, List<object>> results = new Dictionary<string, List<object>>();
+            foreach (var item in parameters)
+                rawSql.Replace(item.Item1, item.Item2);
+            string sql = rawSql.ToString();
+            if (sql.Contains("@"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            if (sql.Contains("<"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            if (sql.Contains(">"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            if (sql.Contains("!"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            foreach (var item in columns)
+                results.Add(item.Item1, new List<object>());
+            string connectionString;
+            if (isG4Wafers && isIrmnSpc)
+                throw new Exception();
+            else if (isG4Wafers)
+                connectionString = _ConnectionStringG4Wafers;
+            else if (isIrmnSpc)
+                connectionString = _ConnectionStringIrmnSpc;
+            else
+                throw new Exception();
+            using (SqlConnection conn = new SqlConnection(connectionString))
+            {
+                conn.Open();
+                using (SqlCommand sqlComm = new SqlCommand(sql.ToString(), conn))
+                {
+                    using (SqlDataReader sqlReader = sqlComm.ExecuteReader())
+                    {
+                        while (sqlReader.Read())
+                        {
+                            foreach (var item in columns)
+                                results[item.Item1].Add(sqlReader.GetSqlValue(item.Item2));
+                        }
+                    }
+                }
+            }
+            return results;
+        }
+
+        public static Dictionary<int, List<object>> ExecuteReader(StringBuilder rawSql, List<Tuple<string, string>> parameters, int columns, bool isG4Wafers, bool isIrmnSpc)
+        {
+            Dictionary<int, List<object>> results = new Dictionary<int, List<object>>();
+            foreach (var item in parameters)
+                rawSql.Replace(item.Item1, item.Item2);
+            string sql = rawSql.ToString();
+            if (sql.Contains("@"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            if (sql.Contains("{"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            if (sql.Contains("}"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            if (sql.Contains("!"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            string connectionString;
+            if (isG4Wafers && isIrmnSpc)
+                throw new Exception();
+            else if (isG4Wafers)
+                connectionString = _ConnectionStringG4Wafers;
+            else if (isIrmnSpc)
+                connectionString = _ConnectionStringIrmnSpc;
+            else
+                throw new Exception();
+            using (SqlConnection conn = new SqlConnection(connectionString))
+            {
+                conn.Open();
+                using (SqlCommand sqlComm = new SqlCommand(sql.ToString(), conn))
+                {
+                    using (SqlDataReader sqlReader = sqlComm.ExecuteReader())
+                    {
+                        while (sqlReader.Read())
+                        {
+                            for (int i = 0; i < columns; i++)
+                            {
+                                if (!results.ContainsKey(i))
+                                    results.Add(i, new List<object>());
+                                results[i].Add(sqlReader.GetSqlValue(i));
+                            }
+                        }
+                    }
+                }
+            }
+            return results;
+        }
+
+        private static int? CheckDisableHistory(string sid)
+        {
+            int? result = null;
+            if (sid != "1")
+            {
+                object exits;
+                StringBuilder sql = new StringBuilder();
+                sql.Append("SELECT ");
+                sql.Append("hs.SID [SID] ");
+                sql.Append("FROM [IRMNSPC].[dbo].[HIST_DISABLE] hs ");
+                sql.Append("WHERE hs.SID = '").Append(sid).Append("' ");
+                using (SqlConnection conn = new SqlConnection(_ConnectionStringIrmnSpc))
+                {
+                    conn.Open();
+                    using (SqlCommand sqlComm = new SqlCommand(sql.ToString(), conn))
+                        exits = sqlComm.ExecuteScalar();
+                }
+                if (exits is null)
+                {
+                    sql.Clear();
+                    sql.Append("INSERT INTO HIST_DISABLE VALUES ('").Append(sid).Append("' , 0) ");
+                    using (SqlConnection conn = new SqlConnection(_ConnectionStringIrmnSpc))
+                    {
+                        conn.Open();
+                        using (SqlCommand sqlComm = new SqlCommand(sql.ToString(), conn))
+                            result = sqlComm.ExecuteNonQuery();
+                    }
+                }
+            }
+            return result;
+        }
+
+        public static object ExecuteScalar(string sql, bool isMappedPart, double totalSecondsSinceLastWriteTime, Tuple<string, string> replace, bool selectForSID, bool isG4Wafers, bool isIrmnSpc)
+        {
+            object result;
+            if (sql.Contains("@"))
+                throw new Exception("Invalid query (a parameter didn't get populated)!");
+            List<object> results = new List<object>();
+            for (int i = 1; i < 15; i++)
+            {
+                string connectionString;
+                if (isG4Wafers && isIrmnSpc)
+                    throw new Exception();
+                else if (isG4Wafers)
+                    connectionString = _ConnectionStringG4Wafers;
+                else if (isIrmnSpc)
+                    connectionString = _ConnectionStringIrmnSpc;
+                else
+                    throw new Exception();
+                using (SqlConnection conn = new SqlConnection(connectionString))
+                {
+                    conn.Open();
+                    using (SqlCommand sqlComm = new SqlCommand(sql, conn))
+                    {
+                        using (SqlDataReader sqlReader = sqlComm.ExecuteReader())
+                        {
+                            while (sqlReader.Read())
+                                results.Add(sqlReader.GetSqlValue(0));
+                        }
+                    }
+                }
+                if (results.Any())
+                    break;
+                if ((i > 10 && !(replace is null)) || (!isMappedPart && totalSecondsSinceLastWriteTime > 1800) || totalSecondsSinceLastWriteTime > 432000 && sql.Contains(replace.Item1)) //30 minutes and 5 days
+                {
+                    sql = sql.Replace(replace.Item1, replace.Item2);
+                    continue;
+                }
+                if (!isMappedPart)
+                    break;
+                for (int j = 1; j < 60; j++)
+                    Thread.Sleep(500);
+            }
+            if (!isMappedPart && !results.Any())
+                result = "-";
+            else if (isMappedPart && !results.Any())
+                throw new Exception("Didn't find a matching record!");
+            else if (isMappedPart && results.Count > 1)
+                throw new Exception("Found more than one matching record!");
+            else
+            {
+                result = results[0];
+                if (selectForSID && results.Count() == 1)
+                {
+                    int? exits = CheckDisableHistory(result.ToString());
+                    { }
+                }
+            }
+            return result;
+        }
+
+    }
+
+}

Adaptation/Helpers/Si/Transport.cs

@@ -0,0 +1,945 @@
+using Adaptation.Shared;
+using Adaptation.Shared.Metrology;
+using Infineon.Yoda;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Xml;
+
+namespace Adaptation.Si
+{
+
+    internal class Transport
+    {
+
+        private static object _IfxTransport;
+        private static ConfigData _ConfigData;
+        private static Dictionary<string, List<Parameters>> _Parameters;
+
+        internal static void Initialize(ConfigData configData)
+        {
+            _IfxTransport = null;
+            _ConfigData = configData;
+            _Parameters = new Dictionary<string, List<Parameters>>();
+        }
+
+        internal static List<string> Setup(bool useSleep, bool setIfxTransport, bool setParameters)
+        {
+            List<string> results = new List<string>();
+            if (useSleep)
+            {
+                for (int i = 1; i < 50; i++)
+                    Thread.Sleep(500);
+            }
+            if (setIfxTransport)
+            {
+                results.Add(string.Concat("IfxTransport Subject: ", _ConfigData.IfxSubject));
+                IfxDoc ifxDoc = new IfxDoc();
+                ifxDoc.Add(IfxConst.SUBJECT_PREFIX, _ConfigData.IfxSubjectPrefix);
+                ifxDoc.Add(IfxConst.IFX_CHANNEL, _ConfigData.IfxChannel);
+                ifxDoc.Add(IfxConst.IFX_CONFIGURATION_LOCATION, _ConfigData.IfxConfigurationLocation);
+                ifxDoc.Add(IfxConst.IFX_CONFIGURATION_LOCATION_LOCAL_COPY, _ConfigData.IfxConfigurationLocationLocalCopy);
+                results.Add(string.Concat("IfxTransport Config: ", ifxDoc));
+                _IfxTransport = new IfxTransport();
+                IfxTransport ifxTransport = (IfxTransport)_IfxTransport;
+                ifxTransport.Create(ifxDoc);
+                if (useSleep)
+                {
+                    for (int i = 1; i < 10; i++)
+                        Thread.Sleep(500);
+                }
+                results.Add(string.Concat("IfxTransport Current Daemon: ", ifxTransport.CurrentDaemon));
+                results.Add(string.Concat("IfxTransport Current Network: ", ifxTransport.CurrentNetwork));
+                results.Add(string.Concat("IfxTransport Current Service: ", ifxTransport.CurrentService));
+                results.Add(string.Concat("IfxTransport Current PoolName: ", ifxTransport.CurrentPoolName));
+            }
+            if (setParameters)
+            {
+                try { _Parameters = GetParameters(); } catch { /* Dev doesn't have this table */ }
+            }
+            return results;
+        }
+
+        private static Dictionary<string, List<Parameters>> GetParameters()
+        {
+            Dictionary<string, List<Parameters>> results = new Dictionary<string, List<Parameters>>();
+            List<Parameters> parameters = Parameters.GetParameters();
+            string iqsName;
+            foreach (var parameter in parameters)
+            {
+                iqsName = string.Concat(parameter.Iqs_name);
+                if (!results.ContainsKey(iqsName))
+                    results.Add(iqsName, new List<Parameters>());
+                results[iqsName].Add(parameter);
+            }
+            return results;
+        }
+
+        internal static bool IsMappedPart(List<string> parts)
+        {
+            List<string> check = (from l in parts where _ConfigData.MappedParts.Contains(l) select l).ToList();
+            return check.Any();
+        }
+
+        internal static List<string> GetDistinctParts(List<PreRunInfo> preRunInfo)
+        {
+            List<string> results = new List<string>();
+            foreach (var item in preRunInfo)
+                results.Add(item.PartNumber);
+            results = results.Distinct().ToList();
+            return results;
+        }
+
+        internal static Dictionary<Test, IScopeInfo> GetScopeInfoCollections(ILogic logic, ConfigData configData, Dictionary<Test, Dictionary<string, List<string>>> rawData, Dictionary<Test, List<int>> tests)
+        {
+            Dictionary<Test, IScopeInfo> results = new Dictionary<Test, IScopeInfo>();
+            int min;
+            int max;
+            IScopeInfo scopeInfo;
+            foreach (var element in rawData)
+            {
+                min = tests[element.Key].Min();
+                max = tests[element.Key].Max() + 1;
+                scopeInfo = new ScopeInfo(logic, configData, element.Key);
+                results.Add(element.Key, scopeInfo);
+            }
+            return results;
+        }
+
+        internal static ExtractResult MergeAndMaybeSort(ExtractResult extractResult, List<PreRunInfo> preRunInfo, Dictionary<Test, List<int>> tests)
+        {
+            if (!preRunInfo.Any())
+                throw new Exception();
+            if (tests.ElementAt(0).Key != Test.AFMRoughness && tests.ElementAt(0).Key != Test.UV)
+            {
+                int min;
+                int max;
+                List<PreRunInfo> matchingPreRunInfo;
+                Dictionary<Enum, List<string>> keyValuePairs;
+                foreach (var testKeyValuePair in tests)
+                {
+                    min = testKeyValuePair.Value.Min();
+                    max = testKeyValuePair.Value.Max() + 1;
+                    for (int i = min; i < max; i++)
+                    {
+                        switch (testKeyValuePair.Key)
+                        {
+                            default:
+                                if (preRunInfo.Count != 1)
+                                    throw new Exception();
+                                else
+                                    matchingPreRunInfo = preRunInfo;
+                                break;
+                        }
+                        if (matchingPreRunInfo.Count > 1)
+                            throw new Exception();
+                        for (int g = 1; g < 3; g++)
+                        {
+                            switch (g)
+                            {
+                                case 1: keyValuePairs = extractResult.DatabaseHeaders; break;
+                                case 2: keyValuePairs = extractResult.DatabaseDetails; break;
+                                default: throw new Exception();
+                            }
+                            foreach (var element in keyValuePairs)
+                            {
+                                if (matchingPreRunInfo.Count == 0)
+                                    element.Value[i] = string.Empty;
+                                else
+                                {
+                                    switch (element.Key)
+                                    {
+                                        case Column.SID: break;
+                                        //case "MID": element.Value[i] = matchingPreRunInfo[0].MID; break;
+                                        case Column.Lot: element.Value[i] = matchingPreRunInfo[0].RunNumber; break;
+                                        case Column.Recipe: element.Value[i] = matchingPreRunInfo[0].Recipe; break;
+                                        case Column.Part: element.Value[i] = matchingPreRunInfo[0].PartNumber; break;
+                                        case Column.Date: element.Value[i] = matchingPreRunInfo[0].Date; break;
+                                        case Column.Wafer_ID: element.Value[i] = matchingPreRunInfo[0].PocketNumber; break;
+                                        case Column.WaferPocket_Candela: element.Value[i] = matchingPreRunInfo[0].PocketNumber; break;
+                                        case Column.Wafer_Scribe: element.Value[i] = matchingPreRunInfo[0].WaferLot; break;
+                                        //case "SatelliteGroup": element.Value[i] = matchingPreRunInfo[0].SatelliteGroup; break;
+                                        //case "StartStamp": element.Value[i] = matchingPreRunInfo[0].StartStamp; break;
+                                        default: throw new Exception();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (tests.ElementAt(0).Key == Test.CandelaKlarfDC || tests.ElementAt(0).Key == Test.CandelaLaser || tests.ElementAt(0).Key == Test.CandelaPSL || tests.ElementAt(0).Key == Test.CandelaVerify)
+            {
+                int min;
+                int max;
+                List<int> sortIndeices;
+                List<string> singleColumnSortedValues;
+                List<string> singleColumnBeforeSortValues;
+                Dictionary<Enum, List<string>> valuesCollection;
+                foreach (var testKeyValuePair in tests)
+                {
+                    if (testKeyValuePair.Key == Test.CandelaKlarfDC || testKeyValuePair.Key == Test.CandelaLaser || testKeyValuePair.Key == Test.CandelaPSL || testKeyValuePair.Key == Test.CandelaVerify)
+                    {
+                        min = testKeyValuePair.Value.Min();
+                        max = testKeyValuePair.Value.Max() + 1;
+                        sortIndeices = new List<int>();
+                        singleColumnBeforeSortValues = (from l in extractResult.DatabaseDetails[Column.WaferPocket_Candela] select l).ToList();
+                        singleColumnSortedValues = (from l in extractResult.DatabaseDetails[Column.WaferPocket_Candela] orderby !string.IsNullOrEmpty(l), l select l).ToList();
+                        for (int i = min; i < max; i++)
+                            sortIndeices.Add(singleColumnBeforeSortValues.IndexOf(singleColumnSortedValues[i]));
+                        valuesCollection = new Dictionary<Enum, List<string>>();
+                        foreach (var element in extractResult.DatabaseDetails)
+                        {
+                            valuesCollection.Add(element.Key, new List<string>());
+                            for (int i = min; i < max; i++)
+                                valuesCollection[element.Key].Add(extractResult.DatabaseDetails[element.Key][i]);
+                            element.Value.Clear();
+                            for (int i = min; i < max; i++)
+                                extractResult.DatabaseDetails[element.Key].Add(valuesCollection[element.Key][sortIndeices[i]]);
+                        }
+                        valuesCollection = new Dictionary<Enum, List<string>>();
+                        foreach (var element in extractResult.Details)
+                        {
+                            valuesCollection.Add(element.Key, new List<string>());
+                            for (int i = min; i < max; i++)
+                                valuesCollection[element.Key].Add(extractResult.Details[element.Key][i]);
+                            element.Value.Clear();
+                            for (int i = min; i < max; i++)
+                                extractResult.Details[element.Key].Add(valuesCollection[element.Key][sortIndeices[i]]);
+                        }
+                        valuesCollection = new Dictionary<Enum, List<string>>();
+                        foreach (var element in extractResult.Parameters)
+                        {
+                            valuesCollection.Add(element.Key, new List<string>());
+                            for (int i = min; i < max; i++)
+                                valuesCollection[element.Key].Add(extractResult.Parameters[element.Key][i]);
+                            element.Value.Clear();
+                            for (int i = min; i < max; i++)
+                                extractResult.Parameters[element.Key].Add(valuesCollection[element.Key][sortIndeices[i]]);
+                        }
+                    }
+                }
+            }
+            return extractResult;
+        }
+
+        private static Dictionary<Column, List<PartParameters>> GetPartParameters(string partNumber, bool isMappedPart)
+        {
+            Dictionary<Column, List<PartParameters>> results = new Dictionary<Column, List<PartParameters>>();
+            List<PartParameters> partParameters = PartParameters.GetPartParameters(partNumber);
+            foreach (var partParameter in partParameters)
+            {
+                if (Convert.IsDBNull(partParameter.Enum) || !Enum.TryParse(partParameter.Enum.ToString(), out Column column))
+                {
+                    if (isMappedPart && partParameter.Crit_to_ship.ToString() == "CRIT")
+                        throw new Exception();
+                    else
+                        continue;
+                }
+                else
+                {
+                    if (!results.ContainsKey(column))
+                        results.Add(column, new List<PartParameters>());
+                    results[column].Add(partParameter);
+                }
+            }
+            return results;
+        }
+
+        private static List<PartHistory> GetPartHistory(string partNumber)
+        {
+            List<PartHistory> results = PartHistory.GetPartHistory(partNumber);
+            return results;
+        }
+
+        private static DataKeys GetDataKeys(Dictionary<Enum, List<string>> columns, Logistics logistics, Dictionary<Enum, List<int>> ignoreIndeices, DataKeys dataKeys, int r, bool forParameter)
+        {
+            DataKeys result = dataKeys;
+            Column key;
+            if (!forParameter)
+            {
+                key = Column.Employee;
+                if (!columns.ContainsKey(key))
+                    result.Employee = "AUTO";
+                else
+                    result.Employee = columns[key][r];
+            }
+            key = Column.WaferPosition_BV;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferPosition = columns[key][r];
+            key = Column.WaferPosition_CV;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferPosition = columns[key][r];
+            key = Column.WaferPosition_Hall;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferPosition = columns[key][r];
+            key = Column.WaferPosition_PR;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferPosition = columns[key][r];
+            //
+            key = Column.Wafer_Region;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferRegion = columns[key][r];
+            //
+            key = Column.Wafer_Scribe;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferScribe = columns[key][r];
+            //
+            key = Column.X_Coord;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.X = columns[key][r];
+            //
+            key = Column.Y_Coord;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.Y = columns[key][r];
+            return result;
+        }
+
+        private static ExtractorKeys GetExtractorKeys(Dictionary<Enum, List<string>> columns, Logistics logistics, Dictionary<Enum, List<int>> ignoreIndeices, ExtractorKeys extractorKeys, int r, bool forParameter)
+        {
+            ExtractorKeys result = extractorKeys;
+            Column key;
+            key = Column.Lot;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.Lot = columns[key][r];
+            //
+            key = Column.Part;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.Part = columns[key][r];
+            //
+            key = Column.Process;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.Process = columns[key][r];
+            //
+            key = Column.Recipe;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.Recipe = columns[key][r];
+            //
+            key = Column.Wafer_ID;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferID = columns[key][r];
+            key = Column.Denton_Gun_Pocket;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferID = columns[key][r];
+            key = Column.WaferPocket_Candela;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferID = columns[key][r];
+            key = Column.WaferPocket_Warp;
+            if (columns.ContainsKey(key) && (!ignoreIndeices.ContainsKey(key) || !ignoreIndeices[key].Contains(r)))
+                result.WaferID = columns[key][r];
+            return result;
+        }
+
+        private static string GetUnit(string columnDiplayName, string columnDatabaseName)
+        {
+            string result;
+            if (_Parameters.ContainsKey(columnDiplayName) && !(_Parameters[columnDiplayName][0].Units is null) && !string.IsNullOrEmpty(_Parameters[columnDiplayName][0].Units.ToString()))
+                result = _Parameters[columnDiplayName][0].Units.ToString();
+            else if (_Parameters.ContainsKey(columnDatabaseName) && !(_Parameters[columnDatabaseName][0].Units is null) && !string.IsNullOrEmpty(_Parameters[columnDatabaseName][0].Units.ToString()))
+                result = _Parameters[columnDatabaseName][0].Units.ToString();
+            else
+                result = "xx";
+            return result;
+        }
+
+        private static double? GetLsl(PartParameters partParameters)
+        {
+            if (!(partParameters.Lsl is null) && !string.IsNullOrEmpty(partParameters.Lsl.ToString()))
+            {
+                double.TryParse(partParameters.Lsl.ToString(), out double lsl);
+                return lsl;
+            }
+            return null;
+        }
+
+        private static double? GetUsl(PartParameters partParameters)
+        {
+            if (!(partParameters.Usl is null) && !string.IsNullOrEmpty(partParameters.Usl.ToString()))
+            {
+                double.TryParse(partParameters.Usl.ToString(), out double usl);
+                return usl;
+            }
+            return null;
+        }
+
+        private static double? GetTsl(PartParameters partParameters)
+        {
+            if (!(partParameters.Target is null) && !string.IsNullOrEmpty(partParameters.Target.ToString()))
+            {
+                double.TryParse(partParameters.Target.ToString(), out double tsl);
+                return tsl;
+            }
+            return null;
+        }
+
+        private static Dictionary<string, List<string>> GetKeyValuePairs(Logistics logistics, ExtractResult extractResult, string xml2Text)
+        {
+            Dictionary<string, List<string>> results = new Dictionary<string, List<string>>();
+            bool documentKeys = false;
+            bool fieldParameter = false;
+            bool isFirstParmeter = true;
+            bool documnetParameter = false;
+            string elementName = string.Empty;
+            const string elementField = "Field";
+            bool fieldParameterNameKeys = false;
+            bool fieldParameterNameValue = false;
+            string attributeNameValue = string.Empty;
+            const string elementDocument = "Document";
+            string parameterAttributeNameValue = string.Empty;
+            string keyOrSettingAttributeNameValue = string.Empty;
+            string parameterKeyAttributeNameValue = string.Empty;
+            const string attributeNameValueParameter = "PARAMETER";
+            const string attributeNameValueParameterName = "PARAMETERNAME";
+            StringReader stringReader = new StringReader(xml2Text);
+            XmlReaderSettings xmlReaderSettings = new XmlReaderSettings { IgnoreWhitespace = true };
+            XmlReader xmlReader = XmlReader.Create(stringReader, xmlReaderSettings);
+            while (xmlReader.Read())
+            {
+                switch (xmlReader.NodeType)
+                {
+                    case XmlNodeType.Element:
+                        elementName = xmlReader.Name;
+                        if (elementName == elementDocument || elementName == elementField)
+                        {
+                            while (xmlReader.HasAttributes && xmlReader.MoveToNextAttribute())
+                            {
+                                if (xmlReader.Name == "name")
+                                {
+                                    attributeNameValue = xmlReader.Value;
+                                    if (!documentKeys && attributeNameValue == "KEYS")
+                                        documentKeys = true;
+                                    else if (documentKeys && !fieldParameter && elementName == elementField && attributeNameValue != attributeNameValueParameter)
+                                        keyOrSettingAttributeNameValue = attributeNameValue;
+                                    else if (documentKeys && !fieldParameter && elementName == elementField && attributeNameValue == attributeNameValueParameter)
+                                        fieldParameter = true;
+                                    else if (documentKeys && fieldParameter && elementName == elementDocument && attributeNameValue == attributeNameValueParameter && !documnetParameter)
+                                        documnetParameter = true;
+                                    else if (documentKeys && fieldParameter && documnetParameter && elementName == elementField && attributeNameValue == attributeNameValueParameterName && string.IsNullOrEmpty(parameterAttributeNameValue))
+                                    {
+                                        xmlReader.Read(); xmlReader.Read(); parameterAttributeNameValue = xmlReader.Value;
+                                    }
+                                    else if (documentKeys && fieldParameter && documnetParameter && !string.IsNullOrEmpty(parameterAttributeNameValue))
+                                    {
+                                        if (elementName == elementDocument && attributeNameValue == attributeNameValueParameter)
+                                        {
+                                            parameterAttributeNameValue = string.Empty;
+                                            if (isFirstParmeter)
+                                                isFirstParmeter = false;
+                                            if (fieldParameterNameValue)
+                                                fieldParameterNameValue = false;
+                                            if (fieldParameterNameKeys)
+                                                fieldParameterNameKeys = false;
+                                            if (!string.IsNullOrEmpty(parameterKeyAttributeNameValue))
+                                                parameterKeyAttributeNameValue = string.Empty;
+                                        }
+                                        else if (attributeNameValue == "VALUE")
+                                        {
+                                            if (!fieldParameterNameValue)
+                                                fieldParameterNameValue = true;
+                                            if (fieldParameterNameKeys)
+                                                fieldParameterNameKeys = false;
+                                        }
+                                        else if (!fieldParameterNameKeys && attributeNameValue == "KEYS")
+                                            fieldParameterNameKeys = true;
+                                        else if (fieldParameterNameValue && fieldParameterNameKeys)
+                                            parameterKeyAttributeNameValue = attributeNameValue;
+                                    }
+                                }
+                            }
+                        }
+                        break;
+                    case XmlNodeType.Text:
+                        if (documentKeys && !documnetParameter)
+                        {
+                            if (!results.ContainsKey(keyOrSettingAttributeNameValue))
+                                results.Add(keyOrSettingAttributeNameValue, new List<string>());
+                            results[keyOrSettingAttributeNameValue].Add(xmlReader.Value);
+                        }
+                        else if (fieldParameter && documnetParameter && !string.IsNullOrEmpty(parameterAttributeNameValue) && fieldParameterNameValue && !fieldParameterNameKeys)
+                        {
+                            if (!results.ContainsKey(parameterAttributeNameValue))
+                                results.Add(parameterAttributeNameValue, new List<string>());
+                            results[parameterAttributeNameValue].Add(xmlReader.Value);
+                        }
+                        else if (fieldParameter && documnetParameter && !string.IsNullOrEmpty(parameterAttributeNameValue) && fieldParameterNameValue && fieldParameterNameKeys && isFirstParmeter)
+                        {
+                            if (!results.ContainsKey(parameterKeyAttributeNameValue))
+                                results.Add(parameterKeyAttributeNameValue, new List<string>());
+                            results[parameterKeyAttributeNameValue].Add(xmlReader.Value);
+                        }
+                        break;
+                }
+            }
+            return results;
+        }
+
+        internal static void SaveXmlAsHtml(Logistics logistics, ExtractResult extractResult, ConfigData configData, string xml2Text, string htmlDirectory, string file)
+        {
+            StringBuilder html = new StringBuilder();
+            html.Clear();
+            html.AppendLine("<html>");
+            html.AppendLine("<head>");
+            html.Append("<title>").Append(configData.GetEquipmentType()).AppendLine("</title>");
+            html.AppendLine("</head>");
+            html.AppendLine("<body>");
+            int count;
+            string htmlFile;
+            List<int> counts = new List<int>();
+            Array array = Enum.GetValues(typeof(Column));
+            List<string> allDataKeyNames = new List<string>();
+            List<string> allSettingNames = new List<string>();
+            List<string> logisticsColumns = new List<string>();
+            List<string> presentSettingNames = new List<string>();
+            List<string> allLDSParameterNames = new List<string>();
+            List<string> allExtractorKeyNames = new List<string>();
+            List<string> parameterOrRowColumns = new List<string>();
+            Dictionary<string, List<string>> keyValuePairs = GetKeyValuePairs(logistics, extractResult, xml2Text);
+            foreach (var item in typeof(Settings).GetProperties())
+                allSettingNames.Add(item.Name);
+            foreach (var item in typeof(ExtractorKeys).GetProperties())
+                allExtractorKeyNames.Add(item.Name);
+            foreach (var item in typeof(DataKeys).GetProperties())
+                allDataKeyNames.Add(item.Name);
+            foreach (var item in typeof(Parameter).GetProperties())
+                allLDSParameterNames.Add(item.Name);
+            Dictionary<string, Column> columnNames = new Dictionary<string, Column>();
+            foreach (Column column in array)
+                columnNames.Add(column.GetDiplayName(), column);
+            foreach (KeyValuePair<string, List<string>> element in keyValuePairs)
+            {
+                counts.Add(element.Value.Count());
+                if (columnNames.ContainsKey(element.Key))
+                    parameterOrRowColumns.Add(element.Key);
+                else
+                {
+                    if (Enum.TryParse(element.Key, out Description.RowColumn rowColumnTry))
+                        parameterOrRowColumns.Add(rowColumnTry.ToString());
+                    else
+                    {
+                        if (Enum.TryParse(element.Key, out Description.LogisticsColumn logisticsColumnTry))
+                            logisticsColumns.Add(logisticsColumnTry.ToString());
+                        else
+                        {
+                            if (allSettingNames.Contains(element.Key))
+                                presentSettingNames.Add(element.Key);
+                            else
+                            {
+                                if (allExtractorKeyNames.Contains(element.Key))
+                                    parameterOrRowColumns.Add(element.Key);
+                                else
+                                {
+                                    if (allDataKeyNames.Contains(element.Key))
+                                        parameterOrRowColumns.Add(element.Key);
+                                    else
+                                    {
+                                        if (allLDSParameterNames.Contains(element.Key))
+                                            parameterOrRowColumns.Add(element.Key);
+                                        else
+                                            throw new Exception();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            count = counts.Max();
+            html.AppendLine("<table border = '2' CellPadding = '2' ");
+            html.Append("       id = '").Append(configData.GetEquipmentType()).AppendLine("' ");
+            html.Append("       title = '").Append("Missing \"Column\"(s)").AppendLine("' ");
+            html.AppendLine(">");
+            html.AppendLine("<tr>");
+            foreach (var element in keyValuePairs)
+            {
+                if (element.Value.Count() == 0 && parameterOrRowColumns.Contains(element.Key))
+                    html.Append("<th nowrap>").Append(element.Key).AppendLine("</th>");
+            }
+            html.AppendLine("</tr>");
+            html.AppendLine("</table>");
+            //
+            html.AppendLine("<hr>");
+            //
+            html.AppendLine("<table border = '2' CellPadding = '2' ");
+            html.Append("       id = '").Append(configData.GetEquipmentType()).AppendLine("' ");
+            html.Append("       title = '").Append("\"settingNames\"(s)").AppendLine("' ");
+            html.AppendLine(">");
+            html.AppendLine("<tr>");
+            foreach (var item in presentSettingNames)
+                html.Append("<th nowrap>").Append(item).AppendLine("</th>");
+            html.AppendLine("</tr>");
+            html.AppendLine("<tr>");
+            foreach (var element in keyValuePairs)
+            {
+                if (presentSettingNames.Contains(element.Key))
+                {
+                    if (string.IsNullOrEmpty(element.Value[0]))
+                        html.AppendLine("<td nowrap>&nbsp;</td>");
+                    else
+                        html.Append("<td nowrap>").Append(element.Value[0]).AppendLine("</td>");
+                }
+            }
+            html.AppendLine("</tr>");
+            html.AppendLine("</table>");
+            //
+            html.AppendLine("<hr>");
+            //
+            html.AppendLine("<table border = '2' CellPadding = '2' ");
+            html.Append("       id = '").Append(configData.GetEquipmentType()).AppendLine("' ");
+            html.Append("       title = '").Append("\"LogisticsColumn\"(s)").AppendLine("' ");
+            html.AppendLine(">");
+            html.AppendLine("<tr>");
+            foreach (var item in logisticsColumns)
+                html.Append("<th nowrap>").Append(item).AppendLine("</th>");
+            html.AppendLine("</tr>");
+            for (int i = 0; i < 1; i++)
+            {
+                html.AppendLine("<tr>");
+                foreach (var element in keyValuePairs)
+                {
+                    if (logisticsColumns.Contains(element.Key))
+                    {
+                        if (string.IsNullOrEmpty(element.Value[i]))
+                            html.AppendLine("<td nowrap>&nbsp;</td>");
+                        else
+                            html.Append("<td nowrap>").Append(element.Value[i]).AppendLine("</td>");
+                    }
+                }
+            }
+            html.AppendLine("</tr>");
+            html.AppendLine("</table>");
+            //
+            html.AppendLine("<hr>");
+            //
+            html.AppendLine("<table border = '2' CellPadding = '2' ");
+            html.Append("       id = '").Append(configData.GetEquipmentType()).AppendLine("' ");
+            html.Append("       title = '").Append("\"Parameter\"(s) Single-row").AppendLine("' ");
+            html.AppendLine(">");
+            html.AppendLine("<tr>");
+            foreach (var item in parameterOrRowColumns)
+                html.Append("<th nowrap>").Append(item).AppendLine("</th>");
+            html.AppendLine("</tr>");
+            for (int i = 0; i < 1; i++)
+            {
+                html.AppendLine("<tr>");
+                foreach (var element in keyValuePairs)
+                {
+                    if (parameterOrRowColumns.Contains(element.Key))
+                    {
+                        if (element.Value.Count() > 1 || element.Value.Count() <= i || string.IsNullOrEmpty(element.Value[i]))
+                            html.Append("<td nowrap>&nbsp;</td>");
+                        else
+                        {
+                            if (!allExtractorKeyNames.Contains(element.Key) && element.Key != "SID")
+                                html.Append("<td nowrap>").Append(element.Value[i]).AppendLine("</td>");
+                            else
+                                html.Append("<td nowrap style = \"background:yellow;\">").Append(element.Value[i]).AppendLine("</td>");
+                        }
+                    }
+                }
+                html.AppendLine("</tr>");
+            }
+            html.AppendLine("</table>");
+            //
+            html.AppendLine("<hr>");
+            //
+            html.AppendLine("<table border = '2' CellPadding = '2' ");
+            html.Append("       id = '").Append(configData.GetEquipmentType()).AppendLine("' ");
+            html.Append("       title = '").Append("\"Parameter\"(s) Multi-row").AppendLine("' ");
+            html.AppendLine(">");
+            html.AppendLine("<tr>");
+            foreach (var item in parameterOrRowColumns)
+                html.Append("<th nowrap>").Append(item).AppendLine("</th>");
+            html.AppendLine("</tr>");
+            for (int i = 0; i < count; i++)
+            {
+                html.AppendLine("<tr>");
+                foreach (var element in keyValuePairs)
+                {
+                    if (parameterOrRowColumns.Contains(element.Key))
+                    {
+                        if (element.Value.Count() == 1 || element.Value.Count() <= i || string.IsNullOrEmpty(element.Value[i]))
+                            html.Append("<td nowrap>&nbsp;</td>");
+                        else
+                        {
+                            if (!allExtractorKeyNames.Contains(element.Key))
+                                html.Append("<td nowrap>").Append(element.Value[i]).AppendLine("</td>");
+                            else
+                                html.Append("<td nowrap style = \"background:yellow;\">").Append(element.Value[i]).AppendLine("</td>");
+                        }
+                    }
+                }
+                html.AppendLine("</tr>");
+            }
+            html.AppendLine("</table>");
+            //
+            html.AppendLine("</body>");
+            html.AppendLine("</html>");
+            htmlFile = string.Concat(htmlDirectory, @"\", Path.GetFileNameWithoutExtension(file), ".html");
+            File.WriteAllText(htmlFile, html.ToString());
+            File.SetLastWriteTime(htmlFile, logistics.DateTimeFromSequence);
+            try { File.SetLastWriteTime(htmlFile, logistics.DateTimeFromSequence); } catch (Exception) { }
+        }
+
+        internal static Dictionary<string, IfxDoc> GetIfxDocs(Logistics logistics, ExtractResult extractResult, ConfigData configData, string writePath, Dictionary<Test, List<int>> tests, List<string> distinctParts, Dictionary<Test, IScopeInfo> scopeInfoCollections, bool isMappedPart)
+        {
+            Dictionary<string, IfxDoc> results = new Dictionary<string, IfxDoc>();
+            int c;
+            int min;
+            int max;
+            DATA data;
+            string sid;
+            string file;
+            IfxDoc ifxDoc;
+            string nullData;
+            string xml2Text;
+            IScopeInfo scopeInfo;
+            Parameter parameter;
+            string testAppendage;
+            string htmlDirectory;
+            List<PartHistory> partHistory;
+            List<int> rowCheck = new List<int>();
+            if (scopeInfoCollections.Any())
+            {
+                string xmlDirectory = string.Empty;
+                ExtendedParameter extendedParameter;
+                List<ExtendedParameter> extendedParameters;
+                Dictionary<Enum, List<int>> ignoreIndeices;
+                List<IfxDoc> parameters = new List<IfxDoc>();
+                List<ParameterCollection> parameterCollections = new List<ParameterCollection>();
+                string directory = string.Concat(writePath, @"\", configData.GetEquipmentType(), @"\Target");
+                Dictionary<Enum, List<string>> toolHeadersAndDatabaseHeadersCollection = extractResult.GetToolHeadersAndDatabaseHeadersCollection();
+                Dictionary<Enum, List<string>> toolDetailsAndDatabaseDetailsCollection = extractResult.GetToolDetailsAndDatabaseDetailsCollection();
+                if (logistics.NullData is null)
+                    nullData = string.Empty;
+                else
+                    nullData = logistics.NullData.ToString();
+                if (!distinctParts.Any())
+                    partHistory = new List<PartHistory>();
+                else
+                {
+                    if (distinctParts.Count != 1)
+                        throw new Exception();
+                    partHistory = GetPartHistory(distinctParts[0]);
+                }
+                if (!string.IsNullOrEmpty(writePath))
+                {
+                    xmlDirectory = string.Concat(directory, @"\xml");
+                    if (!Directory.Exists(xmlDirectory))
+                        Directory.CreateDirectory(xmlDirectory);
+                }
+                foreach (var testKeyValuePair in tests)
+                {
+                    if (isMappedPart && !partHistory.Any())
+                        throw new Exception();
+                    min = testKeyValuePair.Value.Min();
+                    max = testKeyValuePair.Value.Max() + 1;
+                    scopeInfo = scopeInfoCollections[testKeyValuePair.Key];
+                    ignoreIndeices = extractResult.IgnoreIndeices[testKeyValuePair.Key];
+                    data = new DATA(_ConfigData.IfxSubjectPrefix, logistics, scopeInfo, extractResult.DatabaseHeaders[Column.SID][min]);
+                    if (toolHeadersAndDatabaseHeadersCollection.Any())
+                    {
+                        data.DataKeys = GetDataKeys(toolHeadersAndDatabaseHeadersCollection, logistics, ignoreIndeices, data.DataKeys, r: min, forParameter: false);
+                        data.ExtractorKeys = GetExtractorKeys(toolHeadersAndDatabaseHeadersCollection, logistics, ignoreIndeices, data.ExtractorKeys, r: min, forParameter: false);
+                    }
+                    if (partHistory.Any())
+                    {
+                        if (!(partHistory[0].Process_flow is null) && !string.IsNullOrEmpty(partHistory[0].Process_flow.ToString()))
+                            data.ExtractorKeys.ProcessFlow = partHistory[0].Process_flow.ToString();
+                    }
+                    c = 0;
+                    parameterCollections.Clear();
+                    foreach (KeyValuePair<Enum, List<string>> element in extractResult.Parameters)
+                    {
+                        rowCheck.Clear();
+                        for (int r = min; r < max; r++)
+                        {
+                            if (ignoreIndeices[element.Key].Contains(r))
+                                rowCheck.Add(r);
+                        }
+                        if (rowCheck.Count != (max - min))
+                        {
+                            extendedParameters = extractResult.ExtendedParameters[element.Key];
+                            parameterCollections.Add(new ParameterCollection());
+                            for (int r = min; r < max; r++)
+                            {
+                                if (!ignoreIndeices[element.Key].Contains(r))
+                                {
+                                    extendedParameter = extendedParameters[r];
+                                    if (!extendedParameter.Ignore.Value && extendedParameter.CriticalToShip.HasValue && extendedParameter.CriticalToShip.Value)
+                                    {
+                                        parameter = new Parameter(logistics, extendedParameter);
+                                        if (toolDetailsAndDatabaseDetailsCollection.Any())
+                                        {
+                                            parameter.DataKeys = GetDataKeys(toolDetailsAndDatabaseDetailsCollection, logistics, ignoreIndeices, parameter.DataKeys, r, forParameter: true);
+                                            parameter.ExtractorKeys = GetExtractorKeys(toolDetailsAndDatabaseDetailsCollection, logistics, ignoreIndeices, parameter.ExtractorKeys, r, forParameter: true);
+                                        }
+                                        parameterCollections[c].Collection.Add(parameter);
+                                    }
+                                }
+                            }
+                            c += 1;
+                        }
+                    }
+                    if (parameterCollections.Any())
+                        parameterCollections = (from l in parameterCollections where l.Collection.Any() select l).ToList();
+                    if (parameterCollections.Any())
+                    {
+                        parameters.Clear();
+                        foreach (var item in parameterCollections)
+                            parameters.Add(item.GetIfxDoc());
+                        ifxDoc = data.GetIfxDoc(parameters);
+                        if (ifxDoc.GetFieldCount() == 0)
+                            throw new Exception();
+                        else
+                        {
+                            xml2Text = ifxDoc.GetAsXml2();
+                            if (!(logistics.NullData is null) && !string.IsNullOrEmpty(nullData) && xml2Text.Contains(nullData))
+                                throw new Exception();
+                            if (xml2Text.Contains("<Field name=\"Lot\"><String>-</String>") && !(rowCheck is null))
+                                throw new Exception();
+                            if (!string.IsNullOrEmpty(writePath))
+                            {
+                                //testAppendage = string.Concat(" - ", (int)element.Key);
+                                testAppendage = string.Concat(" - ", scopeInfo.FileNameWithoutExtension);
+                                file = string.Concat(xmlDirectory, @"\", logistics.JobID, "_", logistics.Sequence, testAppendage, ".xml");
+                                ifxDoc.Save(file, IfxConst.IfxDocFileType.Xml2, Overwrite: true);
+                                if (logistics.TotalSecondsSinceLastWriteTimeFromSequence > 600)
+                                {
+                                    try { File.SetLastWriteTime(file, logistics.DateTimeFromSequence); } catch (Exception) { }
+                                }
+                                htmlDirectory = string.Concat(directory, @"\html");
+                                if (!Directory.Exists(htmlDirectory))
+                                    Directory.CreateDirectory(htmlDirectory);
+                                SaveXmlAsHtml(logistics, extractResult, configData, xml2Text, htmlDirectory, file);
+                            }
+                            sid = extractResult.DatabaseHeaders[Column.SID][min];
+                            if (!isMappedPart && results.ContainsKey(sid))
+                            {
+                                sid = string.Concat(sid, " ", DateTime.Now.Ticks.ToString());
+                                Thread.Sleep(100);
+                            }
+                            results.Add(sid, ifxDoc);
+                        }
+                    }
+                }
+            }
+            return results;
+        }
+
+        internal static List<LDS2559Reply.DATA> SendIfxDocs(ILogic logic, ConfigData configData, bool isMappedPart, Dictionary<string, IfxDoc> ifxDocs)
+        {
+            List<LDS2559Reply.DATA> results = new List<LDS2559Reply.DATA>();
+            IfxDoc reply;
+            string replyString;
+            LDS2559Reply.DATA lds2559Data;
+            if (_IfxTransport is null)
+            {
+                bool setParameters = !_Parameters.Any();
+                List<string> messages = Setup(useSleep: false, setIfxTransport: true, setParameters: setParameters);
+                foreach (string message in messages)
+                {
+                    System.Diagnostics.Debug.Print(message);
+                }
+            }
+            if (_IfxTransport is null)
+                throw new Exception();
+            else
+            {
+                IfxTransport ifxTransport = (IfxTransport)_IfxTransport;
+                if (isMappedPart && !(configData.EquipmentConnection is null))
+                {
+                    DateTime dateTime = new DateTime(2019, 08, 25);
+                    if (!(logic.Logistics is null) && logic.Logistics.DateTimeFromSequence >= dateTime)
+                    {
+                        foreach (var element in ifxDocs)
+                        {
+                            if (element.Value.GetFieldCount() == 0)
+                                throw new Exception();
+                            else
+                                element.Value.Save(string.Concat(@"\\MESSV02ECC1.EC.LOCAL\EC_EAFLog\Production\IFXDocs\", configData.GetEquipmentType(), @"\", element.Key.Replace("*", string.Empty), ".xml"), IfxConst.IfxDocFileType.Xml2, Overwrite: true);
+                        }
+                    }
+                }
+                foreach (var element in ifxDocs)
+                {
+                    if (element.Value.GetFieldCount() == 0)
+                        throw new Exception();
+                    else
+                    {
+                        element.Value.SendSubject = string.Concat(ifxTransport.SubjectPrefix, ".", _ConfigData.IfxSubject);
+                        if (ifxTransport.SubjectPrefix.StartsWith("MES_"))
+                        {
+                            ifxTransport.Publish(element.Value, false, 60);
+                            lds2559Data = null;
+                        }
+                        else
+                        {
+                            if (!isMappedPart)
+                                lds2559Data = null;
+                            else
+                            {
+                                IfxEnvelope ifxEnvelope = ifxTransport.SendRequest(element.Value, false, 60, IfxConst.IfxMessageType.Yoda);
+                                if (ifxEnvelope is null)
+                                    throw new Exception("SendRequest timeout occurred");
+                                else
+                                {
+                                    reply = ifxEnvelope.ExtractDocument();
+                                    replyString = reply.ToString();
+                                    try { lds2559Data = new LDS2559Reply.DATA(reply); } catch (Exception) { lds2559Data = null; }
+                                }
+                            }
+                        }
+                    }
+                    results.Add(lds2559Data);
+                }
+            }
+            return results;
+        }
+
+        internal static string EvaluateSendResults(ILogic logic, ConfigData configData, List<string> distinctParts, bool isMappedPart, List<LDS2559Reply.DATA> transportSendResults)
+        {
+            StringBuilder result = new StringBuilder();
+            string mID;
+            if (logic is null || logic.Logistics is null || logic.Logistics.MID is null)
+                mID = string.Empty;
+            else
+                mID = logic.Logistics.MID;
+            string part;
+            if (!distinctParts.Any())
+                part = string.Empty;
+            else
+            {
+                if (!isMappedPart)
+                    part = distinctParts[0];
+                else
+                    part = string.Concat(distinctParts[0], " (Mapped) ");
+            }
+            if (!transportSendResults.Any())
+                throw new Exception(string.Concat(configData.GetEquipmentType(), " - ", mID, " - ", part, " Nothing was sent!"));
+            foreach (var item in transportSendResults)
+            {
+                if (item is null)
+                    result.AppendLine(string.Concat(configData.GetEquipmentType(), " - ", mID, " - ", part, " null"));
+                else
+                {
+                    if (item.UNACCEPTED is null || (!(item.ETC is null) && item.ETC.ToString() == "-1"))
+                        throw new Exception(string.Concat(configData.GetEquipmentType(), " - ", mID, " - ", part, " Invalid data"));
+                    else
+                    {
+                        double.TryParse(item.UNACCEPTED.ToString(), out double unaccepted);
+                        if (unaccepted > 0)
+                            throw new Exception("Unaccepted record present");
+                        else
+                            result.AppendLine(string.Concat("Reply: ", item, Environment.NewLine, Environment.NewLine));
+                    }
+                }
+            }
+            return result.ToString();
+        }
+
+    }
+
+}

Adaptation/Ifx/Eaf/Common/Configuration/ConnectionSetting.cs

@@ -0,0 +1,13 @@
+namespace Adaptation.Ifx.Eaf.Common.Configuration
+{
+    [System.Runtime.Serialization.DataContractAttribute]
+    public class ConnectionSetting
+    {
+        public ConnectionSetting(string name, string value) { }
+
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string Name { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string Value { get; set; }
+    }
+}

Adaptation/Ifx/Eaf/EquipmentConnector/File/Component/File.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Ifx.Eaf.EquipmentConnector.File.Component
+{
+    public class File
+    {
+        public File(string filePath) { throw new NotImplementedException(); }
+        public File(string filePath, DateTime timeFileFound) { throw new NotImplementedException(); }
+
+        public string Path { get; }
+        public DateTime TimeFound { get; }
+        public bool IsErrorFile { get; }
+        public Dictionary<string, string> ContentParameters { get; }
+
+        public File UpdateContentParameters(Dictionary<string, string> contentParameters) { throw new NotImplementedException(); }
+        public File UpdateParsingStatus(bool isErrorFile) { throw new NotImplementedException(); }
+    }
+}

Adaptation/Ifx/Eaf/EquipmentConnector/File/Component/FilePathGenerator.cs

@@ -0,0 +1,35 @@
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Ifx.Eaf.EquipmentConnector.File.Component
+{
+    public class FilePathGenerator
+    {
+        public const char PLACEHOLDER_IDENTIFIER = '%';
+        public const char PLACEHOLDER_SEPARATOR = ':';
+        public const string PLACEHOLDER_NOT_AVAILABLE = "NA";
+        public const string PLACEHOLDER_ORIGINAL_FILE_NAME = "OriginalFileName";
+        public const string PLACEHOLDER_ORIGINAL_FILE_EXTENSION = "OriginalFileExtension";
+        public const string PLACEHOLDER_DATE_TIME = "DateTime";
+        public const string PLACEHOLDER_SUB_FOLDER = "SubFolder";
+        public const string PLACEHOLDER_CELL_NAME = "CellName";
+
+        public FilePathGenerator(FileConnectorConfiguration config, Dictionary<string, string> customPattern = null) { throw new NotImplementedException(); }
+        public FilePathGenerator(FileConnectorConfiguration config, File file, bool isErrorFile = false, Dictionary<string, string> customPattern = null) { throw new NotImplementedException(); }
+        public FilePathGenerator(FileConnectorConfiguration config, string sourceFilePath, bool isErrorFile = false, Dictionary<string, string> customPattern = null) { throw new NotImplementedException(); }
+
+        protected string SubFolderPath { get; }
+        protected FileConnectorConfiguration Configuration { get; }
+        protected File File { get; }
+        protected bool IsErrorFile { get; }
+        protected string DefaultPlaceHolderValue { get; }
+
+        public string GetFullTargetPath() { throw new NotImplementedException(); }
+        public virtual string GetTargetFileName() { throw new NotImplementedException(); }
+        public string GetTargetFolder(bool throwExceptionIfNotExist = true) { throw new NotImplementedException(); }
+        protected virtual string GetSubFolder(string folderPattern, string subFolderPath) { throw new NotImplementedException(); }
+        protected virtual string PrepareFolderPath(string targetFolderPath, string subFolderPath) { throw new NotImplementedException(); }
+        protected string ReplacePlaceholder(string inputPath) { throw new NotImplementedException(); }
+    }
+}

Adaptation/Ifx/Eaf/EquipmentConnector/File/Configuration/FileConnectorConfiguration.cs

@@ -0,0 +1,135 @@
+using Adaptation.Ifx.Eaf.Common.Configuration;
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration
+{
+    [System.Runtime.Serialization.DataContractAttribute]
+    public class FileConnectorConfiguration
+    {
+        public const ulong IDLE_EVENT_WAIT_TIME_DEFAULT = 360;
+        public const ulong FILE_HANDLE_TIMEOUT_DEFAULT = 15;
+
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual bool? TriggerOnChanged { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long? PostProcessingRetries { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual bool? CopySourceFolderStructure { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public IfPostProcessingFailsEnum? IfPostProcessingFailsAction { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string AlternateTargetFolder { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public long? FileHandleTimeout { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public bool? DeleteEmptySourceSubFolders { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public long? IdleEventWaitTimeInSeconds { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string FileAgeThreshold { get; set; }
+        public bool? FolderAgeCheckIndividualSubFolders { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual ZipModeEnum? ZipMode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public FileAgeFilterEnum? FileAgeFilterMode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string ZipTargetFileName { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string ZipErrorTargetFileName { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public long? ZipFileSubFolderLevel { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string DefaultPlaceHolderValue { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public bool? UseZip64Mode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public List<ConnectionSetting> ConnectionSettings { get; set; }
+        public string SourceDirectoryCloaking { get; set; }
+        public string FolderAgeThreshold { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long? FileScanningIntervalInSeconds { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual bool? TriggerOnCreated { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long? ZipFileTime { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string SourceFileLocation { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string SourceFileFilter { get; set; }
+        public List<string> SourceFileFilters { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual bool? IncludeSubDirectories { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual FileScanningOptionEnum? FileScanningOption { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string TargetFileLocation { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string ErrorTargetFileLocation { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string TargetFileName { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long? FileHandleWaitTime { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public IfFileExistEnum? IfFileExistAction { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public long? ConnectionRetryInterval { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public PreProcessingModeEnum? PreProcessingMode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public PostProcessingModeEnum? PostProcessingMode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public PostProcessingModeEnum? ErrorPostProcessingMode { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public virtual long? ZipFileAmount { get; set; }
+        [System.Runtime.Serialization.DataMemberAttribute]
+        public string ErrorTargetFileName { get; set; }
+
+        public void Initialize() { throw new NotImplementedException(); }
+
+        public enum PostProcessingModeEnum
+        {
+            None = 0,
+            Move = 1,
+            Copy = 2,
+            Rename = 3,
+            Zip = 4,
+            Delete = 5,
+            MoveFolder = 6,
+            CopyFolder = 7,
+            DeleteFolder = 8
+        }
+        public enum PreProcessingModeEnum
+        {
+            None = 0,
+            Process = 1
+        }
+        public enum IfFileExistEnum
+        {
+            Overwrite = 0,
+            LeaveFiles = 1,
+            Delete = 2
+        }
+        public enum IfPostProcessingFailsEnum
+        {
+            LeaveFiles = 0,
+            Delete = 1
+        }
+        public enum FileScanningOptionEnum
+        {
+            FileWatcher = 0,
+            TimeBased = 1
+        }
+        public enum ZipModeEnum
+        {
+            ZipByAmountOrTime = 0,
+            ZipByFileName = 1,
+            ZipBySubFolderName = 2
+        }
+        public enum FileAgeFilterEnum
+        {
+            IgnoreNewer = 0,
+            IgnoreOlder = 1
+        }
+    }
+}

Adaptation/Ifx/Eaf/EquipmentConnector/File/SelfDescription/FileConnectorParameterTypeDefinitionProvider.cs

@@ -0,0 +1,14 @@
+using Adaptation.Eaf.EquipmentCore.SelfDescription.ParameterTypes;
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Ifx.Eaf.EquipmentConnector.File.SelfDescription
+{
+    public class FileConnectorParameterTypeDefinitionProvider
+    {
+        public FileConnectorParameterTypeDefinitionProvider() { }
+
+        public IEnumerable<ParameterTypeDefinition> GetAllParameterTypeDefinition() { return null; }
+        public ParameterTypeDefinition GetParameterTypeDefinition(string name) { return null; }
+    }
+}

Adaptation/PeerGroup/GCL/Annotations/NotNullAttribute.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Adaptation.PeerGroup.GCL.Annotations
+{
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.Delegate, AllowMultiple = false, Inherited = true)]
+    public sealed class NotNullAttribute : Attribute
+    {
+        public NotNullAttribute() { }
+    }
+}

Adaptation/PeerGroup/GCL/SecsDriver/HsmsConnectionMode.cs

@@ -0,0 +1,8 @@
+namespace Adaptation.PeerGroup.GCL.SecsDriver
+{
+    public enum HsmsConnectionMode
+    {
+        Active = 0,
+        Passive = 1
+    }
+}

Adaptation/PeerGroup/GCL/SecsDriver/HsmsSessionMode.cs

@@ -0,0 +1,8 @@
+namespace Adaptation.PeerGroup.GCL.SecsDriver
+{
+    public enum HsmsSessionMode
+    {
+        MultiSession = 0,
+        SingleSession = 1
+    }
+}

Adaptation/PeerGroup/GCL/SecsDriver/SecsTransportType.cs

@@ -0,0 +1,8 @@
+namespace Adaptation.PeerGroup.GCL.SecsDriver
+{
+    public enum SecsTransportType
+    {
+        HSMS = 0,
+        Serial = 1
+    }
+}

Adaptation/PeerGroup/GCL/SecsDriver/SerialBaudRate.cs

@@ -0,0 +1,16 @@
+namespace Adaptation.PeerGroup.GCL.SecsDriver
+{
+    public enum SerialBaudRate
+    {
+        Baud9600 = 0,
+        Baud19200 = 1,
+        Baud4800 = 2,
+        Baud2400 = 3,
+        Baud1200 = 4,
+        Baud300 = 5,
+        Baud150 = 6,
+        Baud38400 = 7,
+        Baud57600 = 8,
+        Baud115200 = 9
+    }
+}

Adaptation/Shared/CellInstance.cs

@@ -0,0 +1 @@
+

Adaptation/Shared/Deposition/DEP08EGANAIXG5H.cs

@@ -0,0 +1,20 @@
+namespace Adaptation.Shared.Deposition
+{
+
+    public class DEP08EGANAIXG5
+    {
+
+        public enum Test
+        {
+            GRATXTCenter = Deposition.Test.GRATXTCenter,
+            GRATXTEdge = Deposition.Test.GRATXTEdge,
+            GRAXMLCenter = Deposition.Test.GRAXMLCenter,
+            GRAXMLEdgeN = Deposition.Test.GRAXMLEdgeN,
+            Health = Deposition.Test.Health,
+            Temps = Deposition.Test.Temps,
+            ToolTime = Deposition.Test.ToolTime
+        }
+
+    }
+
+}

Adaptation/Shared/Deposition/Test.cs

@@ -0,0 +1,16 @@
+namespace Adaptation.Shared.Deposition
+{
+
+    public enum Test
+    {
+        AFMRoughness = -1,
+        GRATXTCenter = 0,
+        GRATXTEdge = 1,
+        GRAXMLCenter = 2,
+        GRAXMLEdgeN = 3,
+        Health = 4,
+        Temps = 5,
+        ToolTime = 6
+    }
+
+}

Adaptation/Shared/Description.cs

@@ -0,0 +1,182 @@
+using Adaptation.Eaf.Core;
+using Adaptation.Eaf.EquipmentCore.Control;
+using Adaptation.Eaf.EquipmentCore.DataCollection.Reporting;
+using Adaptation.Eaf.EquipmentCore.SelfDescription.ElementDescription;
+using Adaptation.Eaf.EquipmentCore.SelfDescription.ParameterTypes;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.SelfDescription;
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+
+namespace Adaptation.Shared
+{
+
+    public class Description
+    {
+
+        public enum RowColumn
+        {
+            Test = 1000,
+            Count,
+            Index
+        }
+
+        public enum LogisticsColumn
+        {
+            EventName = 2000,
+            NullData,
+            JobID,
+            Sequence,
+            MesEntity,
+            ReportFullPath,
+            ProcessJobID,
+            MID
+        }
+
+        public enum Param
+        {
+            String = 0,
+            Integer = 2,
+            Double = 3,
+            Boolean = 4,
+            StructuredType = 5
+        }
+
+        internal const string FileFound = "FileFound";
+
+
+        public List<EquipmentParameter> EquipmentParameters { get; private set; }
+        public List<ParameterTypeDefinition> ParameterTypeDefinitions { get; private set; }
+
+        private readonly bool _UseCyclical;
+        private readonly List<string> _HeaderNames;
+        private readonly Dictionary<string, int> _KeyIndexPairs;
+        private readonly ParameterTypeDefinition _StructuredType;
+        private readonly FileConnectorParameterTypeDefinitionProvider _FileConnectorParameterTypeDefinitionProvider;
+
+        public Description(ILogic logic, ConfigDataBase configDataBase, IEquipmentControl equipmentControl)
+        {
+            _KeyIndexPairs = new Dictionary<string, int>();
+            _HeaderNames = configDataBase.GetHeaderNames(logic);
+            _UseCyclical = configDataBase.UseCyclicalForDescription;
+            _StructuredType = new StructuredType(nameof(StructuredType), string.Empty, new List<Field>());
+            _FileConnectorParameterTypeDefinitionProvider = new FileConnectorParameterTypeDefinitionProvider();
+            EquipmentParameters = new List<EquipmentParameter>();
+            ParameterTypeDefinitions = new List<ParameterTypeDefinition> { _StructuredType };
+            Dictionary<string, List<Tuple<Enum, string, string, object>>> keyValuePairsCollection = configDataBase.GetParameterInfo(logic, allowNull: false);
+            List<ParameterValue> results = GetParameterValues(equipmentControl, keyValuePairsCollection);
+        }
+
+        private List<ParameterValue> GetParameterValues(IEquipmentControl equipmentControl, Dictionary<string, List<Tuple<Enum, string, string, object>>> keyValuePairsCollection)
+        {
+            List<ParameterValue> results = new List<ParameterValue>();
+            Enum param;
+            object value;
+            Enum[] @params;
+            string description;
+            List<object[]> list;
+            EquipmentParameter equipmentParameter;
+            ParameterTypeDefinition parameterTypeDefinition;
+            bool addToEquipmentParameters = !EquipmentParameters.Any();
+            foreach (KeyValuePair<string, List<Tuple<Enum, string, string, object>>> keyValuePair in keyValuePairsCollection)
+            {
+                if (!addToEquipmentParameters && !_KeyIndexPairs.ContainsKey(keyValuePair.Key))
+                    continue;
+                @params = (from l in keyValuePair.Value select l.Item1).Distinct().ToArray();
+                if (@params.Length != 1)
+                    throw new Exception();
+                if (keyValuePair.Value[0].Item2 != keyValuePair.Key)
+                    throw new Exception();
+                param = @params[0];
+                if (!addToEquipmentParameters)
+                    equipmentParameter = EquipmentParameters[_KeyIndexPairs[keyValuePair.Key]];
+                else
+                {
+                    description = keyValuePair.Value[0].Item3;
+                    _KeyIndexPairs.Add(keyValuePair.Key, EquipmentParameters.Count());
+                    if (param is Param.StructuredType || (_UseCyclical && !_HeaderNames.Contains(keyValuePair.Key)))
+                        parameterTypeDefinition = _StructuredType;
+                    else
+                        parameterTypeDefinition = _FileConnectorParameterTypeDefinitionProvider.GetParameterTypeDefinition(param.ToString());
+                    equipmentParameter = new EquipmentParameter(keyValuePair.Key, parameterTypeDefinition, description);
+                    EquipmentParameters.Add(equipmentParameter);
+                }
+                if (!_UseCyclical || _HeaderNames.Contains(keyValuePair.Key))
+                    value = keyValuePair.Value[0].Item4;
+                else
+                {
+                    list = new List<object[]>();
+                    for (int i = 0; i < keyValuePair.Value.Count; i++)
+                        list.Add(new object[] { i, keyValuePair.Value[i].Item4 });
+                    value = list;
+                }
+                if (equipmentControl is null || !(param is Param.StructuredType))
+                    results.Add(new ParameterValue(equipmentParameter, value, DateTime.Now));
+                else
+                    results.Add(equipmentControl.DataCollection.CreateParameterValue(equipmentParameter, value));
+            }
+            return results;
+        }
+
+        public List<ParameterValue> GetParameterValues(ILogic logic, IEquipmentControl equipmentControl, JsonElement jsonElement, int? i = null, Dictionary<string, object> keyValuePairs = null)
+        {
+            List<ParameterValue> results = new List<ParameterValue>();
+            if (_UseCyclical && (i is null || i.Value > 0))
+                throw new Exception();
+            if (jsonElement.ValueKind != JsonValueKind.Array)
+                throw new Exception();
+            Enum param;
+            Tuple<Enum, string, string, object> tuple;
+            JsonElement[] jsonElements = jsonElement.EnumerateArray().ToArray();
+            Dictionary<string, List<Tuple<Enum, string, string, object>>> keyValuePairsCollection = new Dictionary<string, List<Tuple<Enum, string, string, object>>>();
+            for (int r = i.Value; r < jsonElements.Length; r++)
+            {
+                foreach (JsonProperty jsonProperty in jsonElement[r].EnumerateObject())
+                {
+                    if (jsonProperty.Value.ValueKind == JsonValueKind.Object || jsonProperty.Value.ValueKind == JsonValueKind.Array)
+                    {
+                        param = Param.StructuredType;
+                        //jValue = jObject.Value<JValue>("Item1");
+                        throw new NotImplementedException("Item1");
+                    }
+                    else
+                    {
+                        switch (jsonProperty.Value.ValueKind)
+                        {
+                            case JsonValueKind.String: param = Param.String; break;
+                            case JsonValueKind.Number: param = Param.Double; break;
+                            case JsonValueKind.True:
+                            case JsonValueKind.False: param = Param.Boolean; break;
+                            case JsonValueKind.Null: param = Param.String; break;
+                            default: param = Param.StructuredType; break;
+                        }
+                    }
+                    tuple = new Tuple<Enum, string, string, object>(param, jsonProperty.Name, string.Empty, jsonProperty.Value.ToString());
+                    if (!keyValuePairsCollection.ContainsKey(jsonProperty.Name))
+                        keyValuePairsCollection.Add(jsonProperty.Name, new List<Tuple<Enum, string, string, object>>());
+                    keyValuePairsCollection[jsonProperty.Name].Add(tuple);
+                }
+                if (!_UseCyclical)
+                    break;
+            }
+            results = GetParameterValues(equipmentControl, keyValuePairsCollection);
+            return results;
+        }
+
+        public static string GetCellName()
+        {
+            string result;
+            if (Backbone.Instance?.CellName is null)
+                result = string.Empty;
+            else
+                result = Backbone.Instance.CellName;
+            if (result.Contains("-IO"))
+                result = result.Replace("-IO", string.Empty);
+            return result;
+        }
+
+    }
+
+}

Adaptation/Shared/EquipmentType.cs

@@ -0,0 +1,53 @@
+namespace Adaptation.Shared
+{
+
+    public enum EquipmentType
+    {
+        FileEquipment,
+        SemiEquipment,
+        //
+        DEP08EGANAIXG5,
+        //
+        MET08ANLYSDIFAAST230_Semi,
+        MET08DDUPSFS6420,
+        MET08DDUPSP1TBI,
+        MET08RESIHGCV,
+        MET08RESIMAPCDE,
+        MET08THFTIRQS408M,
+        MET08THFTIRSTRATUS,
+        //
+        MET08AFMD3100,
+        MET08BVHGPROBE,
+        MET08CVHGPROBE802B150,
+        MET08CVHGPROBE802B150_Monthly,
+        MET08CVHGPROBE802B150_Weekly,
+        MET08DDINCAN8620,
+        MET08DDINCAN8620_Daily,
+        MET08EBEAMINTEGRITY26,
+        MET08HALLHL5580,
+        MET08HALLHL5580_Monthly,
+        MET08HALLHL5580_Weekly,
+        MET08MESMICROSCOPE,
+        MET08NDFRESIMAP151C,
+        MET08NDFRESIMAP151C_Verification,
+        MET08PLMAPRPM,
+        MET08PLMAPRPM_Daily,
+        MET08PLMAPRPM_Verification,
+        MET08PLMPPLATO,
+        MET08PRFUSB4000,
+        MET08PRFUSB4000_Daily,
+        MET08PRFUSB4000_Monthly,
+        MET08PRFUSB4000_Weekly,
+        MET08PRFUSB4000_Verification,
+        MET08PRFUSB4000_Villach,
+        MET08UVH44GS100M,
+        MET08VPDSUBCON,
+        MET08WGEOMX203641Q,
+        MET08WGEOMX203641Q_Verification,
+        MET08XRDXPERTPROMRDXL,
+        MET08XRDXPERTPROMRDXL_Monthly,
+        MET08XRDXPERTPROMRDXL_Weekly,
+        METBRXRAYJV7300L
+    }
+
+}

Adaptation/Shared/ExtendedParameter.cs

@@ -0,0 +1,178 @@
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+
+namespace Adaptation.Shared
+{
+
+    public class ExtendedParameter
+    {
+
+        public string DiplayName { get; set; }
+        public string ControlPlanName { get; set; }
+        public bool? CriticalToShip { get; set; }
+        public string Unit { get; set; }
+        public double? LSL { get; set; }
+        public double? TSL { get; set; }
+        public double? USL { get; set; }
+        public string Value { get; set; }
+        public bool? Ignore { get; set; }
+
+        //public class ExtractorKeys
+        public string Lot { get; set; } //1
+        public string ToolID { get; set; } //2
+        public string Process { get; set; } //3
+        public string WaferID { get; set; } //4
+        public string Part { get; set; } //5
+        public string Recipe { get; set; } //6
+        public string ProcessFlow { get; set; } //7
+
+        //public class DataKeys
+        public string Employee { get; set; } //1
+        public string SID { get; set; } //2
+        public string WaferRegion { get; set; } //3
+        public string WaferScribe { get; set; } //4
+        public string WaferPosition { get; set; } //5
+        public string X { get; set; } //6
+        public string Y { get; set; } //7
+        public string EAFCellInstance { get; set; } //8
+        public string EAFReference { get; set; } //9
+        public string IQSReference { get; set; } //10
+
+        public ExtendedParameter(Logistics logistics, string diplayName, string controlPlanName)
+        {
+            DiplayName = diplayName;
+            ControlPlanName = controlPlanName;
+            CriticalToShip = null;
+            Unit = string.Empty;
+            LSL = null;
+            TSL = null;
+            USL = null;
+            Ignore = null;
+            Value = string.Empty;
+            //public class ExtractorKeys
+            Lot = string.Empty; //1
+            ToolID = string.Empty; //2
+            Process = string.Empty; //3
+            WaferID = string.Empty; //4
+            Part = string.Empty; //5
+            Recipe = string.Empty; //6
+            ProcessFlow = string.Empty; //7
+            //public class DataKeys
+            Employee = string.Empty; //1
+            SID = string.Empty; //2
+            WaferRegion = string.Empty; //3
+            WaferScribe = string.Empty; //4
+            WaferPosition = string.Empty; //5
+            X = string.Empty; //6
+            Y = string.Empty; //7
+            EAFCellInstance = string.Empty; //8
+            EAFReference = string.Empty; //9
+            IQSReference = string.Empty; //10
+            //
+            Lot = "-";
+            SID = "-";
+            Part = "-";
+            if (!(logistics is null))
+            {
+                ToolID = logistics.MesEntity;
+                EAFCellInstance = logistics.JobID;
+            }
+        }
+
+        public override string ToString()
+        {
+            return Value;
+        }
+
+        internal void Set(EquipmentType equipmentConnection, string queryFilter, Dictionary<Enum, string> allColumnCollection)
+        {
+            Column key;
+            EAFReference = equipmentConnection.ToString();
+            if (string.IsNullOrEmpty(queryFilter))
+                IQSReference = null;
+            else
+                IQSReference = queryFilter;
+            //
+            key = Column.SID;
+            if (!allColumnCollection.ContainsKey(key))
+                SID = "-";
+            else
+                SID = allColumnCollection[key];
+            key = Column.Employee;
+            if (!allColumnCollection.ContainsKey(key))
+                Employee = "AUTO";
+            else
+                Employee = allColumnCollection[key];
+            //
+            key = Column.Lot;
+            if (allColumnCollection.ContainsKey(key))
+                Lot = allColumnCollection[key];
+            //
+            key = Column.Part;
+            if (allColumnCollection.ContainsKey(key))
+                Part = allColumnCollection[key];
+            //
+            key = Column.Process;
+            if (allColumnCollection.ContainsKey(key))
+                Process = allColumnCollection[key];
+            //
+            key = Column.Recipe;
+            if (allColumnCollection.ContainsKey(key))
+                Recipe = allColumnCollection[key];
+            //
+            key = Column.Wafer_ID;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            key = Column.Denton_Gun_Pocket;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            key = Column.WaferPocket_Candela;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            key = Column.WaferPocket_Warp;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            //
+            key = Column.Wafer_ID;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            key = Column.Denton_Gun_Pocket;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            key = Column.WaferPocket_Candela;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            key = Column.WaferPocket_Warp;
+            if (allColumnCollection.ContainsKey(key))
+                WaferID = allColumnCollection[key];
+            //
+            key = Column.Wafer_Region;
+            if (allColumnCollection.ContainsKey(key))
+                WaferRegion = allColumnCollection[key];
+            key = Column.Wafer_Scribe;
+            if (allColumnCollection.ContainsKey(key))
+                WaferScribe = allColumnCollection[key];
+            key = Column.WaferPosition_BV;
+            if (allColumnCollection.ContainsKey(key))
+                WaferPosition = allColumnCollection[key];
+            key = Column.WaferPosition_CV;
+            if (allColumnCollection.ContainsKey(key))
+                WaferPosition = allColumnCollection[key];
+            key = Column.WaferPosition_Hall;
+            if (allColumnCollection.ContainsKey(key))
+                WaferPosition = allColumnCollection[key];
+            key = Column.WaferPosition_PR;
+            if (allColumnCollection.ContainsKey(key))
+                WaferPosition = allColumnCollection[key];
+            key = Column.X_Coord;
+            if (allColumnCollection.ContainsKey(key))
+                X = allColumnCollection[key];
+            key = Column.Y_Coord;
+            if (allColumnCollection.ContainsKey(key))
+                Y = allColumnCollection[key];
+        }
+
+    }
+
+}

Adaptation/Shared/ExtractResult.cs

@@ -0,0 +1,613 @@
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Adaptation.Shared
+{
+
+    public class ExtractResult
+    {
+
+        public object ProcessData { get; internal set; }
+        public long LastTicksDuration { get; private set; }
+        public long BreakAfterSeconds { get; private set; }
+        public Enum[] EnumColumns { get; protected set; }
+        public List<string> SourceFiles { get; private set; }
+        public Column[] PairedColumns { get; protected set; }
+        public Dictionary<Enum, List<string>> Headers { get; protected set; }
+        public Dictionary<Enum, List<string>> Details { get; protected set; }
+        public Dictionary<Enum, List<string>> Parameters { get; protected set; }
+        public Dictionary<Enum, List<ExtendedParameter>> ExtendedParameters { get; protected set; }
+        public Dictionary<Enum, List<string>> DatabaseHeaders { get; protected set; }
+        public Dictionary<Enum, List<string>> DatabaseDetails { get; protected set; }
+        public Dictionary<Description.RowColumn, List<int>> RowColumns { get; protected set; }
+        public Dictionary<Test, Dictionary<Enum, List<int>>> IgnoreIndeices { get; protected set; }
+        public Dictionary<Description.LogisticsColumn, List<string>> LogisticsColumns { get; protected set; }
+
+        public ExtractResult(ExtractResult extractResult, long breakAfterSeconds, Enum[] enumColumns, Column[] pairedColumns)
+        {
+            if (enumColumns is null)
+                enumColumns = new Enum[] { };
+            if (pairedColumns is null)
+                pairedColumns = new Column[] { };
+            ProcessData = null;
+            EnumColumns = enumColumns;
+            PairedColumns = pairedColumns;
+            SourceFiles = new List<string>();
+            if (!(extractResult is null) && !(extractResult.SourceFiles is null))
+                SourceFiles.AddRange(extractResult.SourceFiles);
+            BreakAfterSeconds = breakAfterSeconds;
+            List<Enum> headers = new List<Enum>();
+            List<Enum> details = new List<Enum>();
+            List<Enum> parameters = new List<Enum>();
+            List<Enum> databaseHeaders = new List<Enum>();
+            List<Enum> databaseDetails = new List<Enum>();
+            UpdateLastTicksDuration(breakAfterSeconds * 10000000);
+            Common(headers, details, parameters, databaseHeaders, databaseDetails);
+        }
+
+        private void Common(List<Enum> headers, List<Enum> details, List<Enum> parameters, List<Enum> databaseHeaders, List<Enum> databaseDetails)
+        {
+            Headers = new Dictionary<Enum, List<string>>();
+            Details = new Dictionary<Enum, List<string>>();
+            Parameters = new Dictionary<Enum, List<string>>();
+            ExtendedParameters = new Dictionary<Enum, List<ExtendedParameter>>();
+            DatabaseHeaders = new Dictionary<Enum, List<string>>();
+            DatabaseDetails = new Dictionary<Enum, List<string>>();
+            IgnoreIndeices = new Dictionary<Test, Dictionary<Enum, List<int>>>();
+            LogisticsColumns = new Dictionary<Description.LogisticsColumn, List<string>>();
+            foreach (Enum item in headers)
+                Headers.Add(item, new List<string>());
+            foreach (Enum item in details)
+                Details.Add(item, new List<string>());
+            foreach (Enum item in parameters)
+                Parameters.Add(item, new List<string>());
+            foreach (Enum item in parameters)
+                ExtendedParameters.Add(item, new List<ExtendedParameter>());
+            foreach (Enum item in databaseHeaders)
+                DatabaseHeaders.Add(item, new List<string>());
+            foreach (Enum item in databaseDetails)
+                DatabaseDetails.Add(item, new List<string>());
+            Array array;
+            array = Enum.GetValues(typeof(Description.RowColumn));
+            RowColumns = new Dictionary<Description.RowColumn, List<int>>();
+            foreach (Description.RowColumn item in array)
+                RowColumns.Add(item, new List<int>());
+            array = Enum.GetValues(typeof(Description.LogisticsColumn));
+            foreach (Description.LogisticsColumn item in array)
+                LogisticsColumns.Add(item, new List<string>());
+        }
+
+        internal void Reset()
+        {
+            ProcessData = null;
+            SourceFiles.Clear();
+            List<Enum> headers = new List<Enum>();
+            List<Enum> details = new List<Enum>();
+            List<Enum> parameters = new List<Enum>();
+            List<Enum> databaseHeaders = new List<Enum>();
+            List<Enum> databaseDetails = new List<Enum>();
+            foreach (KeyValuePair<Enum, List<string>> item in Headers)
+                headers.Add(item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in Details)
+                details.Add(item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in Parameters)
+                parameters.Add(item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseHeaders)
+                databaseHeaders.Add(item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseDetails)
+                databaseDetails.Add(item.Key);
+            Common(headers, details, parameters, databaseHeaders, databaseDetails);
+        }
+
+        public ExtractResult ShallowCopy()
+        {
+            return (ExtractResult)this.MemberwiseClone();
+        }
+
+        internal void HeadersAddRange(Enum column)
+        {
+            Headers.Add(column, new List<string>());
+        }
+
+        internal void HeadersAddRange(params Enum[] columns)
+        {
+            foreach (Enum item in columns)
+                Headers.Add(item, new List<string>());
+        }
+
+        internal void HeadersAddRange(List<Enum> columns)
+        {
+            foreach (Enum item in columns)
+                Headers.Add(item, new List<string>());
+        }
+
+        internal void DetailsAddRange(Enum column)
+        {
+            Details.Add(column, new List<string>());
+        }
+
+        internal void DetailsAddRange(params Enum[] columns)
+        {
+            foreach (Enum item in columns)
+                Details.Add(item, new List<string>());
+        }
+
+        internal void DetailsAddRange(List<Enum> columns)
+        {
+            foreach (Enum item in columns)
+                Details.Add(item, new List<string>());
+        }
+
+        internal void ParametersAddRange(Enum column)
+        {
+            Parameters.Add(column, new List<string>());
+        }
+
+        internal void ParametersAddRange(params Enum[] columns)
+        {
+            foreach (Enum item in columns)
+                Parameters.Add(item, new List<string>());
+        }
+
+        internal void ParametersAddRange(List<Enum> columns)
+        {
+            foreach (Enum item in columns)
+                Parameters.Add(item, new List<string>());
+        }
+
+        internal void DatabaseHeadersAddRange(Enum column)
+        {
+            DatabaseHeaders.Add(column, new List<string>());
+        }
+
+        internal void DatabaseHeadersAddRange(params Enum[] columns)
+        {
+            foreach (Enum item in columns)
+                DatabaseHeaders.Add(item, new List<string>());
+        }
+
+        internal void DatabaseHeadersAddRange(List<Enum> columns)
+        {
+            foreach (Enum item in columns)
+                DatabaseHeaders.Add(item, new List<string>());
+        }
+
+        internal void DatabaseDetailsAddRange(Enum column)
+        {
+            DatabaseDetails.Add(column, new List<string>());
+        }
+
+        internal void DatabaseDetailsAddRange(params Enum[] columns)
+        {
+            foreach (Enum item in columns)
+                DatabaseDetails.Add(item, new List<string>());
+        }
+
+        internal void DatabaseDetailsAddRange(List<Enum> columns)
+        {
+            foreach (Enum item in columns)
+                DatabaseDetails.Add(item, new List<string>());
+        }
+
+        internal int GetCount()
+        {
+            int result;
+            List<int> counts = new List<int>
+            {
+                RowColumns[Description.RowColumn.Test].Count()
+            };
+            foreach (KeyValuePair<Enum, List<string>> item in Headers)
+                counts.Add(item.Value.Count());
+            foreach (KeyValuePair<Enum, List<string>> item in Details)
+                counts.Add(item.Value.Count());
+            foreach (KeyValuePair<Enum, List<string>> item in Parameters)
+                counts.Add(item.Value.Count());
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseHeaders)
+                counts.Add(item.Value.Count());
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseDetails)
+                counts.Add(item.Value.Count());
+            result = counts.Max();
+            if (counts.Distinct().Count() != 1)
+                throw new Exception();
+            return result;
+        }
+
+        private Dictionary<Enum, List<string>> Merge(List<KeyValuePair<Enum, List<string>>> keyValuePairs)
+        {
+            Dictionary<Enum, List<string>> results = new Dictionary<Enum, List<string>>();
+            foreach (KeyValuePair<Enum, List<string>> element in keyValuePairs)
+                results.Add(element.Key, element.Value);
+            return results;
+        }
+
+        private List<KeyValuePair<Enum, List<string>>> GetAllColumnKeyValuePairs()
+        {
+            List<KeyValuePair<Enum, List<string>>> results = new List<KeyValuePair<Enum, List<string>>>();
+            foreach (KeyValuePair<Enum, List<string>> item in Headers)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            foreach (KeyValuePair<Enum, List<string>> item in Details)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            foreach (KeyValuePair<Enum, List<string>> item in Parameters)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseHeaders)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseDetails)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            return results;
+        }
+
+        internal Dictionary<Enum, List<string>> GetAllColumnCollection()
+        {
+            Dictionary<Enum, List<string>> results;
+            if (!EnumColumns.Any())
+            {
+                List<KeyValuePair<Enum, List<string>>> keyValuePairs = GetAllColumnKeyValuePairs();
+                results = Merge(keyValuePairs);
+            }
+            else
+            {
+                results = new Dictionary<Enum, List<string>>();
+                foreach (Enum item in EnumColumns)
+                    results.Add(item, new List<string>());
+                foreach (Column item in PairedColumns)
+                    results.Add(item, new List<string>());
+                foreach (KeyValuePair<Enum, List<string>> item in Headers)
+                    results[item.Key].AddRange(item.Value);
+                foreach (KeyValuePair<Enum, List<string>> item in Details)
+                    results[item.Key].AddRange(item.Value);
+                foreach (KeyValuePair<Enum, List<string>> item in Parameters)
+                    results[item.Key].AddRange(item.Value);
+                foreach (KeyValuePair<Enum, List<string>> item in DatabaseHeaders)
+                    results[item.Key].AddRange(item.Value);
+                foreach (KeyValuePair<Enum, List<string>> item in DatabaseDetails)
+                    results[item.Key].AddRange(item.Value);
+                int count = GetCount();
+                foreach (KeyValuePair<Enum, List<string>> keyValuePair in results)
+                {
+                    for (int i = keyValuePair.Value.Count; i < count; i++)
+                        results[keyValuePair.Key].Add(string.Empty);
+                }
+            }
+            return results;
+        }
+
+        private Dictionary<Enum, string> Merge(List<KeyValuePair<Enum, string>> keyValuePairs)
+        {
+            Dictionary<Enum, string> results = new Dictionary<Enum, string>();
+            foreach (KeyValuePair<Enum, string> element in keyValuePairs)
+                results.Add(element.Key, element.Value);
+            return results;
+        }
+
+        private List<KeyValuePair<Enum, string>> GetAllColumnKeyValuePairs(int? i)
+        {
+            List<KeyValuePair<Enum, string>> results = new List<KeyValuePair<Enum, string>>();
+            if (i.HasValue)
+            {
+                foreach (KeyValuePair<Enum, List<string>> item in Headers)
+                    results.Add(new KeyValuePair<Enum, string>(item.Key, item.Value[i.Value]));
+                foreach (KeyValuePair<Enum, List<string>> item in Details)
+                    results.Add(new KeyValuePair<Enum, string>(item.Key, item.Value[i.Value]));
+                foreach (KeyValuePair<Enum, List<string>> item in Parameters)
+                    results.Add(new KeyValuePair<Enum, string>(item.Key, item.Value[i.Value]));
+                foreach (KeyValuePair<Enum, List<string>> item in DatabaseHeaders)
+                    results.Add(new KeyValuePair<Enum, string>(item.Key, item.Value[i.Value]));
+                foreach (KeyValuePair<Enum, List<string>> item in DatabaseDetails)
+                    results.Add(new KeyValuePair<Enum, string>(item.Key, item.Value[i.Value]));
+            }
+            return results;
+        }
+
+        internal Dictionary<Enum, string> GetAllColumnCollection(int? i)
+        {
+            Dictionary<Enum, string> results;
+            List<KeyValuePair<Enum, string>> keyValuePairs = GetAllColumnKeyValuePairs(i);
+            results = Merge(keyValuePairs);
+            return results;
+        }
+
+        private List<KeyValuePair<Enum, List<string>>> GetToolHeadersAndDatabaseHeadersColumnKeyValuePairs()
+        {
+            List<KeyValuePair<Enum, List<string>>> results = new List<KeyValuePair<Enum, List<string>>>();
+            foreach (KeyValuePair<Enum, List<string>> item in Headers)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseHeaders)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            return results;
+        }
+
+        internal Dictionary<Enum, List<string>> GetToolHeadersAndDatabaseHeadersCollection()
+        {
+            Dictionary<Enum, List<string>> results;
+            List<KeyValuePair<Enum, List<string>>> keyValuePairs = GetToolHeadersAndDatabaseHeadersColumnKeyValuePairs();
+            results = Merge(keyValuePairs);
+            return results;
+        }
+
+        private List<KeyValuePair<Enum, List<string>>> GetToolDetailsAndDatabaseDetailsColumnKeyValuePairs()
+        {
+            List<KeyValuePair<Enum, List<string>>> results = new List<KeyValuePair<Enum, List<string>>>();
+            foreach (KeyValuePair<Enum, List<string>> item in Details)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            foreach (KeyValuePair<Enum, List<string>> item in Parameters)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseDetails)
+                results.Add(new KeyValuePair<Enum, List<string>>(item.Key, item.Value));
+            return results;
+        }
+
+        internal Dictionary<Enum, List<string>> GetToolDetailsAndDatabaseDetailsCollection()
+        {
+            Dictionary<Enum, List<string>> results;
+            List<KeyValuePair<Enum, List<string>>> keyValuePairs = GetToolDetailsAndDatabaseDetailsColumnKeyValuePairs();
+            results = Merge(keyValuePairs);
+            return results;
+        }
+
+        internal Dictionary<Test, List<int>> GetTests()
+        {
+            Dictionary<Test, List<int>> results = new Dictionary<Test, List<int>>();
+            Test test;
+            for (int i = 0; i < RowColumns[Description.RowColumn.Test].Count; i++)
+            {
+                test = (Test)RowColumns[Description.RowColumn.Test][i];
+                if (!results.ContainsKey(test))
+                    results.Add(test, new List<int>());
+                results[test].Add(i);
+            }
+            return results;
+        }
+
+        internal void FillIn(string nullData, int count, Enum[] currentColumns)
+        {
+            foreach (Enum column in Headers.Keys)
+            {
+                for (int i = Headers[column].Count(); i < count; i++)
+                    Headers[column].Add(nullData);
+            }
+            foreach (Enum column in Details.Keys)
+            {
+                for (int i = Details[column].Count(); i < count; i++)
+                    Details[column].Add(nullData);
+            }
+            if (!(currentColumns is null))
+            {
+                foreach (Enum column in currentColumns)
+                {
+                    for (int i = Parameters[column].Count(); i < count; i++)
+                        Parameters[column].Add(nullData);
+                }
+            }
+            foreach (Enum column in Parameters.Keys)
+            {
+                for (int i = Parameters[column].Count(); i < count; i++)
+                    Parameters[column].Add(string.Empty);
+            }
+            foreach (Enum column in DatabaseHeaders.Keys)
+            {
+                for (int i = DatabaseHeaders[column].Count(); i < count; i++)
+                    DatabaseHeaders[column].Add(string.Empty);
+            }
+            foreach (Enum column in DatabaseDetails.Keys)
+            {
+                for (int i = DatabaseDetails[column].Count(); i < count; i++)
+                    DatabaseDetails[column].Add(string.Empty);
+            }
+            if (RowColumns[Description.RowColumn.Count].Count() != RowColumns[Description.RowColumn.Test].Count())
+            {
+                count = RowColumns[Description.RowColumn.Test].Count();
+                RowColumns[Description.RowColumn.Count].Clear();
+                for (int i = 0; i < count; i++)
+                    RowColumns[Description.RowColumn.Count].Add(count);
+            }
+        }
+
+        internal void SetCollections(Logistics logistics, Dictionary<Test, Dictionary<string, List<string>>> rawData)
+        {
+            Array array;
+            Column? column;
+            bool recordStartPresent = false;
+            Description.RowColumn? rowColumn;
+            Description.LogisticsColumn? logisticsColumn;
+            array = Enum.GetValues(typeof(Description.RowColumn));
+            Dictionary<string, Enum> headers = new Dictionary<string, Enum>();
+            Dictionary<string, Enum> details = new Dictionary<string, Enum>();
+            Dictionary<string, Enum> parameters = new Dictionary<string, Enum>();
+            Dictionary<string, Enum> databaseHeaders = new Dictionary<string, Enum>();
+            Dictionary<string, Enum> databaseDetails = new Dictionary<string, Enum>();
+            Dictionary<Description.RowColumn, List<string>> rowColumns = new Dictionary<Description.RowColumn, List<string>>();
+            foreach (KeyValuePair<Enum, List<string>> item in Headers)
+                headers.Add(item.Key.ToString(), item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in Details)
+                details.Add(item.Key.ToString(), item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in Parameters)
+                parameters.Add(item.Key.ToString(), item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseHeaders)
+                databaseHeaders.Add(item.Key.ToString(), item.Key);
+            foreach (KeyValuePair<Enum, List<string>> item in DatabaseDetails)
+                databaseDetails.Add(item.Key.ToString(), item.Key);
+            foreach (Description.RowColumn item in array)
+                rowColumns.Add(item, new List<string>());
+            foreach (KeyValuePair<Test, Dictionary<string, List<string>>> element in rawData)
+            {
+                foreach (KeyValuePair<string, List<string>> item in element.Value)
+                {
+                    column = null;
+                    rowColumn = null;
+                    logisticsColumn = null;
+                    if (item.Key == "Time")
+                        continue;
+                    else if (item.Key == "A_LOGISTICS")
+                        continue;
+                    else if (item.Key == "B_LOGISTICS")
+                        continue;
+                    else if (item.Key == "EventId")
+                        continue;
+                    else if (item.Key == ProcessDataStandardFormat.RecordStart)
+                    {
+                        recordStartPresent = true;
+                        continue;
+                    }
+                    if (Enum.TryParse(item.Key, out Column columnTry))
+                        column = columnTry;
+                    else
+                    {
+                        if (Enum.TryParse(item.Key, out Description.LogisticsColumn logisticsColumnTry))
+                            logisticsColumn = logisticsColumnTry;
+                        else
+                        {
+                            if (Enum.TryParse(item.Key, out Description.RowColumn rowColumnTry))
+                                rowColumn = rowColumnTry;
+                        }
+                    }
+                    if (rowColumn.HasValue)
+                        rowColumns[rowColumn.Value].AddRange(item.Value);
+                    else if (logisticsColumn.HasValue)
+                        LogisticsColumns[logisticsColumn.Value].AddRange(item.Value);
+                    else if (column.HasValue)
+                    {
+                        if (Headers.ContainsKey(column.Value))
+                            Headers[column.Value].AddRange(item.Value);
+                        else if (Details.ContainsKey(column.Value))
+                            Details[column.Value].AddRange(item.Value);
+                        else if (Parameters.ContainsKey(column.Value))
+                            Parameters[column.Value].AddRange(item.Value);
+                        else if (DatabaseHeaders.ContainsKey(column.Value))
+                            DatabaseHeaders[column.Value].AddRange(item.Value);
+                        else if (DatabaseDetails.ContainsKey(column.Value))
+                            DatabaseDetails[column.Value].AddRange(item.Value);
+                        else
+                        {
+                            if (!recordStartPresent)
+                                throw new Exception();
+                        }
+                    }
+                    else
+                    {
+                        if (headers.ContainsKey(item.Key))
+                            Headers[headers[item.Key]].AddRange(item.Value);
+                        else if (details.ContainsKey(item.Key))
+                            Details[details[item.Key]].AddRange(item.Value);
+                        else if (parameters.ContainsKey(item.Key))
+                            Parameters[parameters[item.Key]].AddRange(item.Value);
+                        else if (databaseHeaders.ContainsKey(item.Key))
+                            DatabaseHeaders[databaseHeaders[item.Key]].AddRange(item.Value);
+                        else if (databaseDetails.ContainsKey(item.Key))
+                            DatabaseDetails[databaseDetails[item.Key]].AddRange(item.Value);
+                        else
+                        {
+                            if (!recordStartPresent)
+                                throw new Exception();
+                        }
+                    }
+                }
+            }
+            foreach (KeyValuePair<Description.RowColumn, List<string>> element in rowColumns)
+            {
+                for (int i = 0; i < element.Value.Count(); i++)
+                {
+                    int.TryParse(element.Value[i], out int rowColumnTry);
+                    RowColumns[element.Key].Add(rowColumnTry);
+                }
+            }
+            array = Enum.GetValues(typeof(Description.RowColumn));
+            foreach (Description.RowColumn item in array)
+            {
+                if (!RowColumns.ContainsKey(item))
+                    throw new Exception();
+            }
+            array = Enum.GetValues(typeof(Description.LogisticsColumn));
+            foreach (Description.LogisticsColumn item in array)
+            {
+                if (!LogisticsColumns.ContainsKey(item))
+                    throw new Exception();
+            }
+            int count = rowColumns[Description.RowColumn.Test].Count();
+            foreach (KeyValuePair<Enum, List<string>> element in DatabaseHeaders)
+            {
+                for (int i = element.Value.Count(); i < count; i++)
+                    element.Value.Add(string.Empty);
+            }
+            foreach (KeyValuePair<Enum, List<string>> element in DatabaseDetails)
+            {
+                for (int i = element.Value.Count(); i < count; i++)
+                    element.Value.Add(string.Empty);
+            }
+            string nullData;
+            if (logistics.NullData is null)
+                nullData = string.Empty;
+            else
+                nullData = logistics.NullData.ToString();
+            Dictionary<Enum, List<string>> keyValuePairs;
+            foreach (Test key in rawData.Keys)
+            {
+                IgnoreIndeices.Add(key, new Dictionary<Enum, List<int>>());
+                for (int g = 1; g < 4; g++)
+                {
+                    switch (g)
+                    {
+                        case 1: keyValuePairs = Details; break;
+                        case 2: keyValuePairs = Parameters; break;
+                        case 3: keyValuePairs = DatabaseDetails; break;
+                        default: throw new Exception();
+                    }
+                    foreach (KeyValuePair<Enum, List<string>> element in keyValuePairs)
+                    {
+                        IgnoreIndeices[key].Add(element.Key, new List<int>());
+                        if (!element.Value.Any())
+                        {
+                            for (int i = 0; i < RowColumns[Description.RowColumn.Test].Count(); i++)
+                            {
+                                IgnoreIndeices[key][element.Key].Add(i);
+                                element.Value.Add(string.Empty);
+                            }
+                        }
+                        else
+                        {
+                            for (int i = 0; i < element.Value.Count(); i++)
+                            {
+                                if (RowColumns[Description.RowColumn.Test][i] == (int)key)
+                                {
+                                    if (string.IsNullOrEmpty(element.Value[i]))
+                                        IgnoreIndeices[key][element.Key].Add(i);
+                                    else if (!(logistics.NullData is null) && element.Value[i] == nullData)
+                                        IgnoreIndeices[key][element.Key].Add(i);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (recordStartPresent)
+                FillIn(string.Empty, RowColumns[Description.RowColumn.Test].Count(), currentColumns: null);
+            GetCount();
+        }
+
+        internal void UpdateLastTicksDuration(long ticksDuration)
+        {
+            if (ticksDuration < 50000000)
+                ticksDuration = 50000000;
+            LastTicksDuration = (long)Math.Ceiling(ticksDuration * .667);
+        }
+
+        internal void AutoAdd(Enum key, string value)
+        {
+            if (Headers.ContainsKey(key))
+                Headers[key].Add(value);
+            else if (Details.ContainsKey(key))
+                Details[key].Add(value);
+            else if (Parameters.ContainsKey(key))
+                Parameters[key].Add(value);
+            else if (DatabaseHeaders.ContainsKey(key))
+                DatabaseHeaders[key].Add(value);
+            else if (DatabaseDetails.ContainsKey(key))
+                DatabaseDetails[key].Add(value);
+            else
+                throw new Exception();
+        }
+
+    }
+
+}

Adaptation/Shared/IProcessData.cs

@@ -0,0 +1,16 @@
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+
+namespace Adaptation.Shared
+{
+    public interface IProcessData
+    {
+
+        Tuple<string, JsonElement?, List<FileInfo>> GetResults(ILogic logic, ConfigDataBase configData, List<FileInfo> fileInfoCollection);
+
+    }
+
+}

Adaptation/Shared/IProcessDataDescription.cs

@@ -0,0 +1,26 @@
+using Adaptation.Shared.Metrology;
+using System.Collections.Generic;
+
+namespace Adaptation.Shared
+{
+
+    public interface IProcessDataDescription
+    {
+
+        int Test { get; set; }
+        int Count { get; set; }
+        int Index { get; set; }
+        IProcessDataDescription GetDefault(ILogic logic, ConfigDataBase configDataBase);
+        IProcessDataDescription GetDisplayNames(ILogic logic, ConfigDataBase configDataBase);
+        List<IProcessDataDescription> GetDescription(ILogic logic, ConfigDataBase configDataBase, List<Test> tests, IProcessData iProcessData);
+        List<string> GetDetailNames(ILogic logic, ConfigDataBase configDataBase);
+        List<string> GetHeaderNames(ILogic logic, ConfigDataBase configDataBase);
+        List<string> GetIgnoreParameterNames(ILogic logic, ConfigDataBase configDataBase, Test test);
+        List<string> GetNames(ILogic logic, ConfigDataBase configDataBase);
+        List<string> GetPairedParameterNames(ILogic logic, ConfigDataBase configDataBase);
+        List<string> GetParameterNames(ILogic logic, ConfigDataBase configDataBase);
+        string GetEventDescription();
+
+    }
+
+}

Adaptation/Shared/IQSRecord.cs

@@ -0,0 +1,239 @@
+using Adaptation.Shared.Metrology;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Adaptation.Shared
+{
+
+    internal class IQSRecord
+    {
+
+        public string SID { get; protected set; }
+        public string Part { get; protected set; }
+        public string Process { get; protected set; }
+        public string Lot { get; protected set; }
+        public string SampleSize { get; protected set; }
+        public string ParameterName { get; protected set; }
+        public string TestNumber { get; protected set; }
+        public string ParameterValue { get; protected set; }
+        public string WaferID { get; protected set; }
+        public string WaferScribe { get; protected set; }
+        public string Pocket { get; protected set; }
+        public string EpiThicknessMean { get; protected set; }
+        public string WaferRegion { get; protected set; }
+        public string ToolID { get; protected set; }
+        public string EmployeeID { get; protected set; }
+        public string EmployeeName { get; protected set; }
+        public string Date { get; protected set; }
+        public Column Column { get; protected set; }
+
+        public IQSRecord(object sID, object part, object process, object lot, object sampleSize, object parameterName, object testNumber, object parameterValue, object waferID, object waferScribe, object pocket, object epiThicknessMean, object waferRegion, object toolID, object employeeID, object employeeName, object date, Dictionary<string, Column> keyValuePairs)
+        {
+            if (sID is null)
+                SID = string.Empty;
+            else
+                SID = sID.ToString();
+            if (part is null)
+                Part = string.Empty;
+            else
+                Part = part.ToString();
+            if (process is null)
+                Process = string.Empty;
+            else
+                Process = process.ToString();
+            if (lot is null)
+                Lot = string.Empty;
+            else
+                Lot = lot.ToString();
+            if (sampleSize is null)
+                SampleSize = string.Empty;
+            else
+                SampleSize = sampleSize.ToString();
+            if (parameterName is null)
+                ParameterName = string.Empty;
+            else
+                ParameterName = parameterName.ToString();
+            if (testNumber is null)
+                TestNumber = string.Empty;
+            else
+                TestNumber = testNumber.ToString();
+            if (parameterValue is null)
+                ParameterValue = string.Empty;
+            else
+                ParameterValue = parameterValue.ToString();
+            if (waferID is null)
+                WaferID = string.Empty;
+            else
+                WaferID = waferID.ToString();
+            if (waferScribe is null)
+                WaferScribe = string.Empty;
+            else
+                WaferScribe = waferScribe.ToString();
+            if (pocket is null)
+                Pocket = string.Empty;
+            else
+                Pocket = pocket.ToString();
+            if (epiThicknessMean is null)
+                EpiThicknessMean = string.Empty;
+            else
+                EpiThicknessMean = epiThicknessMean.ToString();
+            if (waferRegion is null)
+                WaferRegion = string.Empty;
+            else
+                WaferRegion = waferRegion.ToString();
+            if (toolID is null)
+                ToolID = string.Empty;
+            else
+                ToolID = toolID.ToString();
+            if (employeeID is null)
+                EmployeeID = string.Empty;
+            else
+                EmployeeID = employeeID.ToString();
+            if (employeeName is null)
+                EmployeeName = string.Empty;
+            else
+                EmployeeName = employeeName.ToString();
+            if (date is null)
+                Date = string.Empty;
+            else
+                Date = date.ToString();
+            if (parameterName is null || !keyValuePairs.ContainsKey(parameterName.ToString()))
+                Column = Column.AFM_Roughness;
+            else
+                Column = keyValuePairs[parameterName.ToString()];
+        }
+
+        private static string GetBaseTableJoins()
+        {
+            StringBuilder result = new StringBuilder();
+            result.Append(" from [irmnspc].[dbo].sgrp_ext se ").
+            Append(" join [irmnspc].[dbo].test_dat td on se.f_test = td.f_test ").
+            Append(" join [irmnspc].[dbo].part_dat pd on se.f_part = pd.f_part ").
+            Append(" join [irmnspc].[dbo].part_lot pl on se.f_lot = pl.f_lot ").
+            Append(" join [irmnspc].[dbo].prcs_dat pr on se.f_prcs = pr.f_prcs ").
+            Append(" join [irmnspc].[dbo].empl_inf em on se.f_empl = em.f_empl ");
+            return result.ToString();
+        }
+
+        internal static StringBuilder GetIqsRecordsSinceSql()
+        {
+            StringBuilder result = new StringBuilder();
+            result.Append(" select ").
+                Append(" se.f_sgrp [sid], concat(se.f_sgrp, ', ', td.f_name, ', ', pd.f_name, ', ', pl.f_name, ', ', pr.f_name, ', ', em.f_name, ', ', se.f_sgtm) [csv] ").
+                Append(GetBaseTableJoins()).
+                Append(" where se.f_sgrp >= 1543459064 ").
+                Append(" and se.f_sgrp > ( @lastSID - 20 ) ").
+                Append(" /* and dateadd(hh, -7, (dateadd(ss, convert(bigint, se.f_sgtm), '19700101'))) >= '2019-08-25 00:00:00.000' */ ").
+                Append(" and td.f_name = @key ").
+                Append(" group by se.f_sgrp, td.f_name, pd.f_name, pl.f_name, pr.f_name, em.f_name, se.f_sgtm ").
+                Append(" order by se.f_sgrp, pd.f_name, td.f_name ");
+            return result;
+        }
+
+        internal static StringBuilder GetIqsRecordsSql()
+        {
+            StringBuilder result = new StringBuilder();
+            result.Append(" select ").
+              Append(" ta.id [SID], ").
+              Append(" ta.ms [Part], ").
+              Append(" ta.pr [Process], ").
+              Append(" ta.lt [Lot], ").
+              Append(" ta.sz [Sample Size], ").
+              Append(" ta.pn [Parameter Name], ").
+              Append(" ta.tn [Test Number], ").
+              Append(" ta.pv [Parameter Value], ").
+              Append(" tb.v1337859646 [Wafer ID], ").
+              Append(" tb.v1337859592 [Wafer Scribe], ").
+              Append(" tb.v1342510661 [Pocket], ").
+              Append(" tb.v1340294286 [Epi Thickness Mean], ").
+              Append(" tb.v1345566180 [Wafer Region], ").
+              Append(" tb.v1363881711 [Tool ID], ").
+              Append(" ta.em [Employee ID], ").
+              Append(" ta.en [Employee Name], ").
+              Append(" ta.dt [Date] ").
+              Append(" from ( ").
+              Append(" select ").
+              Append(" se.f_sgrp id, ").
+              Append(" se.f_sgsz sz, ").
+              Append(" concat(se.f_tsno, '.', se.f_sbno) tn, ").
+              Append(" se.f_val pv, ").
+              Append(" se.f_empl em, ").
+              Append(" dateadd(hh, -7, (dateadd(ss, convert(bigint, se.f_sgtm), '19700101'))) dt, ").
+              Append(" td.f_name pn, ").
+              Append(" pd.f_name as ms, ").
+              Append(" pl.f_name lt, ").
+              Append(" pr.f_name pr, ").
+              Append(" em.f_name en ").
+              Append(GetBaseTableJoins()).
+              Append(" where se.f_sgrp = @sid ").
+              Append(" ) as ta ").
+              Append(" join ( ").
+              Append(" select ").
+              Append(" se.f_sgrp id, ").
+              Append(" max(case when dd.f_dsgp = 1337859646 then dd.f_name end) as v1337859646, ").
+              Append(" max(case when dd.f_dsgp = 1337859592 then dd.f_name end) as v1337859592, ").
+              Append(" max(case when dd.f_dsgp = 1342510661 then dd.f_name end) as v1342510661, ").
+              Append(" max(case when dd.f_dsgp = 1340294286 then dd.f_name end) as v1340294286, ").
+              Append(" max(case when dd.f_dsgp = 1345566180 then dd.f_name end) as v1345566180, ").
+              Append(" max(case when dd.f_dsgp = 1363881711 then dd.f_name end) as v1363881711 ").
+              Append(" from [irmnspc].[dbo].sgrp_ext se ").
+              Append(" join [irmnspc].[dbo].test_dat td on se.f_test = td.f_test ").
+              Append(" join [irmnspc].[dbo].sgrp_dsc sd on se.f_sgrp = sd.f_sgrp ").
+              Append(" join [irmnspc].[dbo].desc_dat dd on sd.f_desc = dd.f_desc ").
+              Append(" and isnull(dd.f_name, '') <> '' ").
+              Append(" where se.f_sgrp = @sid ").
+              Append(" and dd.f_dsgp in (1337859646 /* Wafer ID */, 1337859592 /* Wafer Scribe */, 1342510661 /* Pocket */, 1340294286 /* Epi Thickness Mean */, 1345566180 /* Wafer Region */, 1363881711 /* Tool ID */) ").
+              Append(" group by se.f_sgrp ").
+              Append(" ) tb on ta.id = tb.id ").
+              Append(" order by ta.id desc, ta.ms, ta.pr, ta.lt, ta.sz, ta.tn, ta.dt, ta.pn ");
+            return result;
+        }
+
+        internal static List<IQSRecord> GetIqsRecords(Dictionary<int, List<object>> rawData, int count)
+        {
+            List<IQSRecord> results = new List<IQSRecord>();
+            IQSRecord iqsRecord;
+            List<object> c0 = rawData[0];
+            List<object> c1 = rawData[1];
+            List<object> c2 = rawData[2];
+            List<object> c3 = rawData[3];
+            List<object> c4 = rawData[4];
+            List<object> c5 = rawData[5];
+            List<object> c6 = rawData[6];
+            List<object> c7 = rawData[7];
+            List<object> c8 = rawData[8];
+            List<object> c9 = rawData[9];
+            List<object> cA = rawData[10];
+            List<object> cB = rawData[11];
+            List<object> cC = rawData[12];
+            List<object> cD = rawData[13];
+            List<object> cE = rawData[14];
+            List<object> cF = rawData[15];
+            List<object> cG = rawData[16];
+            if (c0.Any())
+            {
+                Array array = Enum.GetValues(typeof(Column));
+                Dictionary<string, Column> keyValuePairs = new Dictionary<string, Column>();
+                foreach (Column column in array)
+                    keyValuePairs.Add(column.GetDiplayName(), column);
+                for (int i = 0; i < c0.Count; i++)
+                {
+                    iqsRecord = new IQSRecord(c0[i], c1[i], c2[i], c3[i], c4[i], c5[i], c6[i], c7[i], c8[i], c9[i], cA[i], cB[i], cC[i], cD[i], cE[i], cF[i], cG[i], keyValuePairs);
+                    results.Add(iqsRecord);
+                }
+            }
+            return results;
+        }
+
+        public override string ToString()
+        {
+            //(1337859646 /* Wafer ID */, 1337859592 /* Wafer Scribe */, 1342510661 /* Pocket */, 1340294286 /* Epi Thickness Mean */, 1345566180 /* Wafer Region */, 1363881711 /* Tool ID */) ").
+            //return string.Concat(SID, Part, Process, Lot, SampleSize, TestNumber, WaferID, WaferScribe, Pocket, EpiThicknessMean, WaferRegion, ToolID, EmployeeID, EmployeeName, Date);
+            return string.Concat(SID, Part, Process, Lot, SampleSize, TestNumber, EmployeeID, EmployeeName, Date);
+        }
+
+    }
+
+}

Adaptation/Shared/IScopeInfo.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Adaptation.Shared
+{
+
+    public interface IScopeInfo
+    {
+
+        Enum Enum { get; }
+        string HTML { get; }
+        string Title { get; }
+        string FileName { get; }
+        int TestValue { get; }
+        string Header { get; }
+        string QueryFilter { get; }
+        string FileNameWithoutExtension { get; }
+        EquipmentType EquipmentType { get; }
+
+    }
+
+}

Adaptation/Shared/IsEnvironment.cs

@@ -0,0 +1,171 @@
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Shared
+{
+
+    public class IsEnvironment
+    {
+
+        public enum Name
+        {
+            LinuxDevelopment,
+            LinuxProduction,
+            LinuxStaging,
+            OSXDevelopment,
+            OSXProduction,
+            OSXStaging,
+            WindowsDevelopment,
+            WindowsProduction,
+            WindowsStaging
+        }
+
+        public bool DebuggerWasAttachedDuringConstructor { get; private set; }
+        public bool Development { get; private set; }
+        public bool Linux { get; private set; }
+        public bool OSX { get; private set; }
+        public bool Production { get; private set; }
+        public bool Staging { get; private set; }
+        public bool Windows { get; private set; }
+        public string Profile { get; private set; }
+        public string AppSettingsFileName { get; private set; }
+        public string ASPNetCoreEnvironment { get; private set; }
+
+        public IsEnvironment(string testCategory)
+        {
+            if (testCategory.EndsWith(".json"))
+            {
+                Production = testCategory == "appsettings.json";
+                Staging = testCategory.EndsWith(nameof(Staging));
+                OSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+                Development = testCategory.EndsWith(nameof(Development));
+                Linux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+                DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+                Windows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+                ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+            }
+            else
+            {
+                DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+                OSX = !string.IsNullOrEmpty(testCategory) && testCategory.StartsWith(nameof(OSX));
+                ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+                Linux = !string.IsNullOrEmpty(testCategory) && testCategory.StartsWith(nameof(Linux));
+                Staging = !string.IsNullOrEmpty(testCategory) && testCategory.EndsWith(nameof(Staging));
+                Windows = !string.IsNullOrEmpty(testCategory) && testCategory.StartsWith(nameof(Windows));
+                Production = !string.IsNullOrEmpty(testCategory) && testCategory.EndsWith(nameof(Production));
+                Development = !string.IsNullOrEmpty(testCategory) && testCategory.EndsWith(nameof(Development));
+            }
+            Profile = GetProfile();
+            AppSettingsFileName = GetAppSettingsFileName(processesCount: null);
+        }
+
+        public IsEnvironment(bool isDevelopment, bool isStaging, bool isProduction)
+        {
+            Staging = isStaging;
+            Production = isProduction;
+            Development = isDevelopment;
+            OSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+            Linux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+            DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+            Windows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+            ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+            Profile = GetProfile();
+            AppSettingsFileName = GetAppSettingsFileName(processesCount: null);
+        }
+
+        public IsEnvironment(int? processesCount, bool nullASPNetCoreEnvironmentIsDevelopment, bool nullASPNetCoreEnvironmentIsProduction)
+        {
+            OSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+            Linux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+            DebuggerWasAttachedDuringConstructor = Debugger.IsAttached;
+            Windows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+            ASPNetCoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
+            if (nullASPNetCoreEnvironmentIsDevelopment && nullASPNetCoreEnvironmentIsProduction)
+                throw new Exception();
+            else if (string.IsNullOrEmpty(ASPNetCoreEnvironment) && nullASPNetCoreEnvironmentIsProduction)
+                Production = true;
+            else if (string.IsNullOrEmpty(ASPNetCoreEnvironment) && nullASPNetCoreEnvironmentIsDevelopment)
+                Development = true;
+            else if (string.IsNullOrEmpty(ASPNetCoreEnvironment) && !nullASPNetCoreEnvironmentIsDevelopment && !nullASPNetCoreEnvironmentIsProduction)
+                throw new Exception();
+            else
+            {
+                Staging = ASPNetCoreEnvironment is not null && ASPNetCoreEnvironment.EndsWith(nameof(Staging));
+                Production = ASPNetCoreEnvironment is not null && ASPNetCoreEnvironment.EndsWith(nameof(Production));
+                Development = ASPNetCoreEnvironment is not null && ASPNetCoreEnvironment.EndsWith(nameof(Development));
+            }
+            Profile = GetProfile();
+            AppSettingsFileName = GetAppSettingsFileName(processesCount);
+        }
+
+        private string GetProfile()
+        {
+            string result;
+            if (Windows && Production)
+                result = nameof(Production);
+            else if (Windows && Staging)
+                result = nameof(Staging);
+            else if (Windows && Development)
+                result = nameof(Development);
+            else if (Linux && Production)
+                result = nameof(Name.LinuxProduction);
+            else if (Linux && Staging)
+                result = nameof(Name.LinuxStaging);
+            else if (Linux && Development)
+                result = nameof(Name.LinuxDevelopment);
+            else if (OSX && Production)
+                result = nameof(Name.OSXProduction);
+            else if (OSX && Staging)
+                result = nameof(Name.OSXStaging);
+            else if (OSX && Development)
+                result = nameof(Name.OSXDevelopment);
+            else
+                throw new Exception();
+            return result;
+        }
+
+        private string GetAppSettingsFileName(int? processesCount)
+        {
+            string result;
+            if (Production)
+            {
+                if (processesCount is null)
+                    result = "appsettings.json";
+                else
+                    result = $"appsettings.{processesCount}.json";
+            }
+            else
+            {
+                string environment;
+                if (Staging)
+                    environment = nameof(Staging);
+                else if (Development)
+                    environment = nameof(Development);
+                else
+                    throw new Exception();
+                if (processesCount is null)
+                    result = $"appsettings.{environment}.json";
+                else
+                    result = $"appsettings.{environment}.{processesCount}.json";
+            }
+            return result;
+        }
+
+        public static string GetEnvironmentName(IsEnvironment isEnvironment)
+        {
+            string result;
+            if (isEnvironment.Windows)
+                result = nameof(IsEnvironment.Windows);
+            else if (isEnvironment.Linux)
+                result = nameof(IsEnvironment.Linux);
+            else if (isEnvironment.OSX)
+                result = nameof(IsEnvironment.OSX);
+            else
+                throw new Exception();
+            return result;
+        }
+
+    }
+
+}

Adaptation/Shared/Logistics.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+namespace Adaptation.Shared
+{
+
+    public class Logistics
+    {
+
+        public object NullData { get; private set; }
+        public string JobID { get; private set; } //CellName
+        public long Sequence { get; private set; } //Ticks
+        public DateTime DateTimeFromSequence { get; private set; }
+        public double TotalSecondsSinceLastWriteTimeFromSequence { get; private set; }
+        public string MesEntity { get; private set; } //SPC
+        public string ReportFullPath { get; private set; } //Extract file
+        public string ProcessJobID { get; internal set; } //Reactor (duplicate but I want it in the logistics)
+        public string MID { get; internal set; } //Lot & Pocket || Lot
+        public List<string> Tags { get; internal set; }
+        public List<string> Logistics1 { get; internal set; }
+        public List<Logistics2> Logistics2 { get; internal set; }
+
+        public Logistics()
+        {
+            DateTime dateTime = DateTime.Now;
+            NullData = null;
+            JobID = Description.GetCellName();
+            Sequence = dateTime.Ticks;
+            DateTimeFromSequence = dateTime;
+            TotalSecondsSinceLastWriteTimeFromSequence = (DateTime.Now - dateTime).TotalSeconds;
+            MesEntity = DefaultMesEntity(dateTime);
+            ReportFullPath = string.Empty;
+            ProcessJobID = nameof(ProcessJobID);
+            MID = nameof(MID);
+            Tags = new List<string>();
+            Logistics1 = new string[] { string.Concat("LOGISTICS_1", '\t', "A_JOBID=", JobID, ";A_MES_ENTITY=", MesEntity, ";") }.ToList();
+            Logistics2 = new List<Logistics2>();
+        }
+
+        public Logistics(object nullData, Dictionary<string, string> cellNames, Dictionary<string, string> mesEntities, FileInfo fileInfo, bool useSplitForMID, int? fileInfoLength = null)
+        {
+            NullData = nullData;
+            string mesEntity = string.Empty;
+            string jobID = Description.GetCellName();
+            DateTime dateTime = fileInfo.LastWriteTime;
+            if (fileInfoLength.HasValue && fileInfo.Length < fileInfoLength.Value)
+                dateTime = dateTime.AddTicks(-1);
+            if (string.IsNullOrEmpty(jobID))
+            {
+                if (cellNames.Count == 1)
+                    jobID = cellNames.ElementAt(0).Key;
+                else
+                {
+                    foreach (var element in cellNames)
+                    {
+                        if (fileInfo.FullName.IndexOf(element.Key, StringComparison.OrdinalIgnoreCase) > -1 || fileInfo.FullName.IndexOf(element.Value, StringComparison.OrdinalIgnoreCase) > -1)
+                        {
+                            jobID = element.Key;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (string.IsNullOrEmpty(jobID))
+                throw new Exception();
+            if (mesEntities.ContainsKey(jobID))
+                mesEntity = mesEntities[jobID];
+            else if (mesEntities.Count == 1)
+                mesEntity = mesEntities.ElementAt(0).Value;
+            //
+            if (string.IsNullOrEmpty(mesEntity))
+                throw new Exception();
+            JobID = jobID;
+            Sequence = dateTime.Ticks;
+            DateTimeFromSequence = dateTime;
+            TotalSecondsSinceLastWriteTimeFromSequence = (DateTime.Now - dateTime).TotalSeconds;
+            MesEntity = mesEntity;
+            ReportFullPath = fileInfo.FullName;
+            ProcessJobID = nameof(ProcessJobID);
+            string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileInfo.FullName);
+            if (useSplitForMID)
+            {
+                if (fileNameWithoutExtension.IndexOf(".") > -1)
+                    fileNameWithoutExtension = fileNameWithoutExtension.Split('.')[0].Trim();
+                if (fileNameWithoutExtension.IndexOf("_") > -1)
+                    fileNameWithoutExtension = fileNameWithoutExtension.Split('_')[0].Trim();
+                if (fileNameWithoutExtension.IndexOf("-") > -1)
+                    fileNameWithoutExtension = fileNameWithoutExtension.Split('-')[0].Trim();
+            }
+            MID = string.Concat(fileNameWithoutExtension.Substring(0, 1).ToUpper(), fileNameWithoutExtension.Substring(1).ToLower());
+            Tags = new List<string>();
+            Logistics1 = new string[] { string.Concat("LOGISTICS_1", '\t', "A_JOBID=", JobID, ";A_MES_ENTITY=", MesEntity, ";") }.ToList();
+            Logistics2 = new List<Logistics2>();
+        }
+
+        public Logistics(string reportFullPath, string logistics)
+        {
+            string key;
+            DateTime dateTime;
+            string[] segments;
+            Logistics1 = logistics.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).ToList();
+            if (!Logistics1.Any() || !Logistics1[0].StartsWith("LOGISTICS_1"))
+            {
+                NullData = null;
+                JobID = "null";
+                dateTime = new FileInfo(reportFullPath).LastWriteTime;
+                Sequence = dateTime.Ticks;
+                DateTimeFromSequence = dateTime;
+                TotalSecondsSinceLastWriteTimeFromSequence = (DateTime.Now - dateTime).TotalSeconds;
+                MesEntity = DefaultMesEntity(dateTime);
+                ReportFullPath = reportFullPath;
+                ProcessJobID = "R##";
+                MID = "null";
+                Tags = new List<string>();
+                Logistics1 = new string[] { string.Concat("LOGISTICS_1", '\t', "A_JOBID=", JobID, ";A_MES_ENTITY=", MesEntity, ";") }.ToList();
+                Logistics2 = new List<Logistics2>();
+            }
+            else
+            {
+                string logistics1Line1 = Logistics1[0];
+                key = "NULL_DATA=";
+                if (!logistics1Line1.Contains(key))
+                    NullData = null;
+                else
+                {
+                    segments = logistics1Line1.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                    NullData = segments[1].Split(';')[0];
+                }
+                key = "JOBID=";
+                if (!logistics1Line1.Contains(key))
+                    JobID = "null";
+                else
+                {
+                    segments = logistics1Line1.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                    JobID = segments[1].Split(';')[0];
+                }
+                key = "SEQUENCE=";
+                if (!logistics1Line1.Contains(key))
+                    dateTime = new FileInfo(reportFullPath).LastWriteTime;
+                else
+                {
+                    segments = logistics1Line1.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                    if (!long.TryParse(segments[1].Split(';')[0].Split('.')[0], out long sequence) || sequence < new DateTime(1999, 1, 1).Ticks)
+                        dateTime = new FileInfo(reportFullPath).LastWriteTime;
+                    else
+                        dateTime = new DateTime(sequence);
+                }
+                Sequence = dateTime.Ticks;
+                DateTimeFromSequence = dateTime;
+                TotalSecondsSinceLastWriteTimeFromSequence = (DateTime.Now - dateTime).TotalSeconds;
+                DateTime lastWriteTime = new FileInfo(reportFullPath).LastWriteTime;
+                if (TotalSecondsSinceLastWriteTimeFromSequence > 600)
+                {
+                    if (lastWriteTime != dateTime)
+                        try { File.SetLastWriteTime(reportFullPath, dateTime); } catch (Exception) { }
+                }
+                key = "MES_ENTITY=";
+                if (!logistics1Line1.Contains(key))
+                    MesEntity = DefaultMesEntity(dateTime);
+                else
+                {
+                    segments = logistics1Line1.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                    MesEntity = segments[1].Split(';')[0];
+                }
+                ReportFullPath = reportFullPath;
+                key = "PROCESS_JOBID=";
+                if (!logistics1Line1.Contains(key))
+                    ProcessJobID = "R##";
+                else
+                {
+                    segments = logistics1Line1.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                    ProcessJobID = segments[1].Split(';')[0];
+                }
+                key = "MID=";
+                if (!logistics1Line1.Contains(key))
+                    MID = "null";
+                else
+                {
+                    segments = logistics1Line1.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                    MID = segments[1].Split(';')[0];
+                }
+            }
+            Logistics2 logistics2;
+            Tags = new List<string>();
+            Logistics2 = new List<Logistics2>();
+            for (int i = 1; i < Logistics1.Count(); i++)
+            {
+                if (Logistics1[i].StartsWith("LOGISTICS_2"))
+                {
+                    logistics2 = new Logistics2(Logistics1[i]);
+                    Logistics2.Add(logistics2);
+                }
+            }
+            for (int i = Logistics1.Count() - 1; i > -1; i--)
+            {
+                if (Logistics1[i].StartsWith("LOGISTICS_2"))
+                    Logistics1.RemoveAt(i);
+            }
+        }
+
+        public Logistics ShallowCopy()
+        {
+            return (Logistics)this.MemberwiseClone();
+        }
+
+        private string DefaultMesEntity(DateTime dateTime)
+        {
+            return string.Concat(dateTime.Ticks, "_MES_ENTITY");
+        }
+
+        internal string GetLotViaMostCommonMethod()
+        {
+            return MID.Substring(0, MID.Length - 2);
+        }
+
+        internal string GetPocketNumberViaMostCommonMethod()
+        {
+            return MID.Substring(MID.Length - 2);
+        }
+
+        internal void Update(string dateTime, string processJobID, string mid)
+        {
+            if (!DateTime.TryParse(dateTime, out DateTime dateTimeCasted))
+                dateTimeCasted = DateTime.Now;
+            NullData = null;
+            //JobID = Description.GetCellName();
+            Sequence = dateTimeCasted.Ticks;
+            DateTimeFromSequence = dateTimeCasted;
+            TotalSecondsSinceLastWriteTimeFromSequence = (DateTime.Now - dateTimeCasted).TotalSeconds;
+            //MesEntity = DefaultMesEntity(dateTime);
+            //ReportFullPath = string.Empty;
+            ProcessJobID = processJobID;
+            MID = mid;
+            Tags = new List<string>();
+            Logistics1 = new string[] { string.Concat("LOGISTICS_1", '\t', "A_JOBID=", JobID, ";A_MES_ENTITY=", MesEntity, ";") }.ToList();
+            Logistics2 = new List<Logistics2>();
+        }
+    }
+
+}

Adaptation/Shared/Logistics2.cs

@@ -0,0 +1,80 @@
+using System;
+
+namespace Adaptation.Shared
+{
+    public class Logistics2
+    {
+
+        public string MID { get; private set; }
+        public string RunNumber { get; private set; }
+        public string SatelliteGroup { get; private set; }
+        public string PartNumber { get; private set; }
+        public string PocketNumber { get; private set; }
+        public string WaferLot { get; private set; }
+        public string Recipe { get; private set; }
+
+        public Logistics2(string logistics2)
+        {
+            string key;
+            string[] segments;
+            key = "JOBID=";
+            if (!logistics2.Contains(key))
+                MID = "null";
+            else
+            {
+                segments = logistics2.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                MID = segments[1].Split(';')[0];
+            }
+            key = "MID=";
+            if (!logistics2.Contains(key))
+                RunNumber = "null";
+            else
+            {
+                segments = logistics2.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                RunNumber = segments[1].Split(';')[0];
+            }
+            key = "INFO=";
+            if (!logistics2.Contains(key))
+                SatelliteGroup = "null";
+            else
+            {
+                segments = logistics2.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                SatelliteGroup = segments[1].Split(';')[0];
+            }
+            key = "PRODUCT=";
+            if (!logistics2.Contains(key))
+                PartNumber = "null";
+            else
+            {
+                segments = logistics2.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                PartNumber = segments[1].Split(';')[0];
+            }
+            key = "CHAMBER=";
+            if (!logistics2.Contains(key))
+                PocketNumber = "null";
+            else
+            {
+                segments = logistics2.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                PocketNumber = segments[1].Split(';')[0];
+            }
+            key = "WAFER_ID=";
+            if (!logistics2.Contains(key))
+                WaferLot = "null";
+            else
+            {
+                segments = logistics2.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                WaferLot = segments[1].Split(';')[0];
+            }
+            key = "PPID=";
+            if (!logistics2.Contains(key))
+                Recipe = "null";
+            else
+            {
+                segments = logistics2.Split(new string[] { key }, StringSplitOptions.RemoveEmptyEntries);
+                Recipe = segments[1].Split(';')[0];
+            }
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/Column.cs

@@ -0,0 +1,803 @@
+using System;
+
+namespace Adaptation.Shared.Metrology
+{
+
+    public static class ColumnGet
+    {
+
+        public static string GetDiplayName(this Column column)
+        {
+            string results;
+            switch (column)
+            {
+                //case Column._8in_Total_Warp_Verification: results = "8in Total Warp Verification"; break;
+                //case Column.AFM_Monthly_Y: results = "AFM-Monthly Y"; break;
+                //case Column.AFM_Monthly: results = "AFM_Monthly"; break;
+                case Column.AFM_Pit_Count: results = "AFM Pit Count"; break;
+                case Column.AFM_Roughness: results = "AFM Roughness"; break;
+                //case Column.Adder_Bin_1: results = "Adder Bin 1"; break;
+                //case Column.Adder_Bin_2: results = "Adder Bin 2"; break;
+                //case Column.Adder_Bin_3: results = "Adder Bin 3"; break;
+                //case Column.Adder_Bin_4: results = "Adder Bin 4"; break;
+                //case Column.Adder_Bin_5: results = "Adder Bin 5"; break;
+                //case Column.Adder_Bin_6: results = "Adder Bin 6"; break;
+                //case Column.Adder_Bin_9: results = "Adder Bin 9"; break;
+                case Column.Al_B_B_WTAVG: results = "Al% B.B. WTAVG"; break;
+                case Column.Al_B_B_: results = "Al% B.B."; break;
+                case Column.Al_Barrier_WTAVG: results = "Al% Barrier WTAVG"; break;
+                case Column.Al_Barrier: results = "Al% Barrier"; break;
+                case Column.Al_SLS_WTAVG: results = "Al% SLS WTAVG"; break;
+                case Column.Al_SLS: results = "Al% SLS"; break;
+                case Column.Al_TL1_WTAVG: results = "Al% TL1 WTAVG"; break;
+                case Column.Al_TL1: results = "Al% TL1"; break;
+                case Column.Al_TL2_WTAVG: results = "Al% TL2 WTAVG"; break;
+                //case Column.BV_Resistance: results = "BV Resistance"; break; //BV Monthly Verification
+                case Column.BandEdge_V: results = "BandEdge_V"; break;
+                case Column.BandEdge_V_XY: results = "BandEdge_V_XY"; break;
+                case Column.BandEdge_nm: results = "BandEdge_nm"; break;
+                case Column.Barrier_Composition_RPM_XY: results = "Barrier_Composition_RPM_XY"; break;
+                case Column.Bow_Calibration: results = "Bow Calibration"; break;
+                case Column.Bow_Range: results = "Bow Range"; break;
+                case Column.Bow: results = "Bow"; break;
+                case Column.BowCenter: results = "BowCenter"; break;
+                case Column.BowX: results = "BowX"; break;
+                case Column.BowY: results = "BowY"; break;
+                case Column.Breakdown_Voltage_Edge: results = "Breakdown Voltage - Edge"; break;
+                case Column.Breakdown_VoltageMiddle: results = "Breakdown Voltage - Middle"; break;
+                case Column.Breakdown_Voltage: results = "Breakdown Voltage"; break;
+                case Column.CV_C_at_10V: results = "CV C at -10V"; break;
+                case Column.CV_Nd_Min: results = "CV Nd Min"; break;
+                //case Column.Candela_Large_LPD_Quarterly: results = "Candela Large LPD Quarterly"; break;
+                //case Column.Candela_Medium_LPD_Quarterly: results = "Candela Medium LPD Quarterly"; break;
+                //case Column.Candela_Small_LPD_Quarterly: results = "Candela Small LPD Quarterly"; break;
+                //case Column.Candela_Total_Quarterly: results = "Candela Total Quarterly"; break;
+                case Column.Candela_102_83nm: results = "102-83nm"; break;
+                case Column.Candela_1_1um: results = "1.1um"; break;
+                case Column.Candela_496nm: results = "496nm"; break;
+                case Column.Candela_600nm: results = "600nm"; break;
+                case Column.Candela_8620_Small: results = "Candela 8620 Small"; break;
+                case Column.Candela_Crack_Verification: results = "Crack Verification"; break;
+                case Column.Candela_Cracking: results = "Candela Cracking"; break;
+                case Column.Candela_Cracking_Acceptable: results = "Candela Cracking Acceptable"; break;
+                case Column.Candela_Crater: results = "Candela Crater"; break;
+                case Column.Candela_Crater_Verification: results = "Crater verification"; break;
+                case Column.Candela_Haze: results = "Candela Haze"; break;
+                case Column.Candela_LPD_Large: results = "Candela LPD Large"; break;
+                case Column.Candela_LPD_Medium: results = "Candela LPD Medium"; break;
+                case Column.Candela_LPD_Small: results = "Candela LPD Small"; break;
+                case Column.Candela_Large_Verification: results = "Large Verification"; break;
+                case Column.Candela_Medium_Verification: results = "Medium Verification"; break;
+                case Column.Candela_Pits: results = "Candela Pits"; break;
+                case Column.Candela_Pits_Verification: results = "Pits verification"; break;
+                case Column.Candela_SPE: results = "Candela SPE"; break;
+                case Column.Candela_SPE_Verification: results = "SPE verification"; break;
+                case Column.Candela_Slip: results = "Candela Slip"; break;
+                case Column.Candela_Small_Verification: results = "Small Verification"; break;
+                case Column.Candela_Spirals: results = "Candela Spirals"; break;
+                case Column.Candela_Spirals_Verification: results = "Candela Spirals Verification"; break;
+                case Column.Candela_Total_Defects: results = "Candela Total Defects"; break;
+                case Column.Candela_Total_PSL: results = "Candela Total PSL"; break;
+                case Column.Candela__1_1um: results = ">1.1um"; break;
+                //case Column.Comment: results = "Comment"; break;
+                //case Column.Conductivity: results = "Conductivity"; break;
+                case Column.Contact_Symmetry: results = "Contact Symmetry"; break;
+                //case Column.Cracking_verification: results = "Cracking verification"; break;
+                //case Column.Crater_verification: results = "Crater verification"; break;
+                case Column.Date: results = "Date"; break;
+                case Column.Denton_Crystal_Life: results = "Denton_Crystal_Life"; break;
+                case Column.Denton_Current_AVG: results = "Denton_Current_AVG"; break;
+                case Column.Denton_Current_STDEV: results = "Denton_Current_STDEV"; break;
+                case Column.Denton_Deposition_Power_AVG: results = "Denton_Deposition_Power_AVG"; break;
+                case Column.Denton_Deposition_Power_STDEV: results = "Denton_Deposition_Power_STDEV"; break;
+                case Column.Denton_Deposition_Rate_AVG: results = "Denton_Deposition_Rate_AVG"; break;
+                case Column.Denton_Deposition_Rate_STDEV: results = "Denton_Deposition_Rate_STDEV"; break;
+                case Column.Denton_Gun_Pocket: results = "Denton_Gun_Pocket"; break;
+                case Column.Denton_Pumpdown_Time: results = "Denton_Pumpdown_Time"; break;
+                case Column.Denton_Voltage_AVG: results = "Denton_Voltage_AVG"; break;
+                case Column.Denton_Voltage_STDEV: results = "Denton_Voltage_STDEV"; break;
+                case Column.Employee: results = "Employee"; break;
+                case Column.Epi_Thickness_Mean: results = "Epi Thickness Mean"; break;
+                case Column.Epi_Thickness_Mean_XY: results = "Epi Thickness Mean_XY"; break;
+                case Column.Epi_Thickness_Std_Dev_: results = "Epi Thickness Std Dev %"; break;
+                case Column.FWHM_006_WTAVG: results = "FWHM 006 WTAVG"; break;
+                case Column.FWHM_006: results = "FWHM 006"; break;
+                case Column.FWHM_105_WTAVG: results = "FWHM 105 WTAVG"; break;
+                case Column.FWHM_105: results = "FWHM 105"; break;
+                case Column.Hall_Rs: results = "Hall Rs"; break;
+                case Column.Hall_Mobility_verif_sample: results = "Hall_Mobility_verif_sample"; break;
+                case Column.Hall_Ns_verif_sample: results = "Hall_Ns_verif_sample"; break;
+                case Column.Hall_Rs_verif_sample: results = "Hall_Rs_verif_sample"; break;
+                case Column.Job: results = "Job"; break;
+                case Column.LEI_RS_Average_value: results = "LEI RS Average value"; break;
+                case Column.LEI_RS_Maximum_value: results = "LEI RS Maximum value"; break;
+                case Column.LEI_RS_Minimum_value: results = "LEI RS Minimum value"; break;
+                case Column.LEI_RS_STDEV: results = "LEI RS STDEV"; break;
+                case Column.LEI_RS_STDEV_: results = "LEI RS STDEV%"; break;
+                //case Column.Large_Adder_Sum: results = "Large Adder Sum"; break;
+                case Column.Lot: results = "Lot"; break;
+                //case Column.Medium_Adder_Sum: results = "Medium Adder Sum"; break;
+                case Column.Microscope_Center_5x: results = "Microscope Center 5x"; break;
+                case Column.Microscope_Center_50x: results = "Microscope Center 50x"; break;
+                case Column.Microscope_Middle_5x: results = "Microscope Middle 5x"; break;
+                case Column.Microscope_Middle_50x: results = "Microscope Middle 50x"; break;
+                case Column.Microscope_Edge_5x: results = "Microscope Edge 5x"; break;
+                case Column.Microscope_Edge_50x: results = "Microscope Edge 50x"; break;
+                case Column.Mobility_Verification: results = "Mobility Verification"; break;
+                case Column.Mobility: results = "Mobility"; break;
+                case Column.Ns_Verification: results = "Ns Verification"; break;
+                case Column.PL_Edge_Wavelength: results = "PL Edge Wavelength"; break;
+                case Column.PL_Ratio: results = "PL Ratio"; break;
+                case Column.PR_Barrier_Composition: results = "PR Barrier Composition"; break;
+                case Column.PR_Peak: results = "PR Peak"; break;
+                case Column.Part: results = "Part"; break;
+                //case Column.Particles_verification: results = "Particles verification"; break;
+                //case Column.Pits_verification: results = "Pits verification"; break;
+                //case Column.Pocket: results = "Pocket"; break;
+                //case Column.Post_Bin_1: results = "Post Bin 1"; break;
+                //case Column.Post_Bin_2: results = "Post Bin 2"; break;
+                //case Column.Post_Bin_3: results = "Post Bin 3"; break;
+                //case Column.Post_Bin_4: results = "Post Bin 4"; break;
+                //case Column.Post_Bin_5: results = "Post Bin 5"; break;
+                //case Column.Post_Bin_6: results = "Post Bin 6"; break;
+                //case Column.Post_Bin_9: results = "Post Bin 9"; break;
+                //case Column.Pre_Bin_1: results = "Pre Bin 1"; break;
+                //case Column.Pre_Bin_2: results = "Pre Bin 2"; break;
+                //case Column.Pre_Bin_3: results = "Pre Bin 3"; break;
+                //case Column.Pre_Bin_4: results = "Pre Bin 4"; break;
+                //case Column.Pre_Bin_5: results = "Pre Bin 5"; break;
+                //case Column.Pre_Bin_6: results = "Pre Bin 6"; break;
+                //case Column.Pre_Bin_9: results = "Pre Bin 9"; break;
+                case Column.Process: results = "Process"; break;
+                //case Column.RPM_verif_Thickness_1: results = "RPM_verif_Thickness_1"; break;
+                //case Column.RPM_verif_Thickness_2: results = "RPM_verif_Thickness_2"; break;
+                //case Column.RPM_verif_Thickness_3: results = "RPM_verif_Thickness_3"; break;
+                //case Column.RPM_verif_Thickness_Average: results = "RPM_verif_Thickness_Average"; break;
+                //case Column.RTA_oxide_Thk_Change: results = "RTA oxide Thk Change"; break;
+                //case Column.RTA_oxide_post_anneal_Thk: results = "RTA oxide post-anneal Thk"; break;
+                //case Column.RTA_oxide_pre_anneal_Thk: results = "RTA oxide pre-anneal Thk"; break;
+                case Column.Recipe: results = "Recipe"; break;
+                //case Column.Resistivity_2_ohm_cm: results = "Resistivity 2 ohm cm"; break; //LEI Weekly Verification
+                //case Column.Resistivity_600_ohm_cm: results = "Resistivity 600 ohm cm"; break; //LEI Weekly Verification
+                case Column.Rs_verification: results = "Rs verification"; break;
+                case Column.Rs_verif_100kohm: results = "Rs_verif_100kohm"; break;
+                case Column.Rs_verif_10ohm: results = "Rs_verif_10ohm"; break;
+                case Column.Rs_verif_1kohm: results = "Rs_verif_1kohm"; break;
+                case Column.SID: results = "SID"; break;
+                case Column.SL_Period_WTAVG: results = "SL Period WTAVG"; break;
+                case Column.SL_Period: results = "SL Period"; break;
+                //case Column.SPE_verification: results = "SPE verification"; break;
+                //case Column.Sample_ID: results = "Sample ID"; break;
+                case Column.Sheet_Concentration: results = "Sheet Concentration"; break;
+                //case Column.Size: results = "Size"; break;
+                //case Column.Small_Adder_Sum: results = "Small Adder Sum"; break;
+                //case Column.Spirals_verification: results = "Spirals verification"; break;
+                case Column.Time: results = "Time"; break;
+                case Column.Tool_ID: results = "Tool ID"; break;
+                //case Column.Total_LPD_Adder: results = "Total LPD Adder"; break;
+                //case Column.Total_Verification: results = "Total Verification"; break;
+                case Column.Total_Warp_Calibration: results = "Total Warp Calibration"; break;
+                case Column.UV_Broken: results = "UV Broken"; break;
+                case Column.UV_Chipping: results = "UV Chipping"; break;
+                case Column.UV_Cracking_0_3mm_: results = "UV Cracking (0-3mm)"; break;
+                case Column.UV_Cracking_3_7mm_: results = "UV Cracking (3-7mm)"; break;
+                case Column.UV_Cracking_7mm_: results = "UV Cracking (>7mm)"; break;
+                case Column.UV_Crazing: results = "UV Crazing"; break;
+                case Column.UV_Crazing_Acceptable: results = "UV Crazing Acceptable"; break;
+                case Column.UV_FULL_Characterization_Wafer: results = "UV FULL Characterization Wafer"; break;
+                case Column.UV_Haze_count_: results = "UV Haze (count)"; break;
+                case Column.UV_LIGHT_Characterization_Wafer: results = "UV LIGHT Characterization Wafer"; break;
+                case Column.UV_Non_rotation: results = "UV Non-rotation"; break;
+                case Column.UV_Other: results = "UV Other"; break;
+                case Column.UV_Scratch_count_: results = "UV Scratch (count)"; break;
+                case Column.UV_Slip_count_: results = "UV Slip (count)"; break;
+                case Column.UV_True_Haze: results = "UV True Haze"; break;
+                case Column.UV_True_Haze_Acceptable: results = "UV True Haze Acceptable"; break;
+                case Column.UV_SPE_1mm_count: results = "UV-SPE (>1mm) count"; break;
+                case Column.UV_SPE_count_: results = "UV-SPE (count)"; break;
+                case Column.Verification_Contact_Symmetry: results = "Verification Contact Symmetry"; break;
+                case Column.Vp_Pinch_Off_Voltage: results = "Vp Pinch Off Voltage"; break;
+                case Column.Wafer_ID: results = "Wafer ID"; break;
+                //case Column.Wafer_Pocket: results = "Wafer Pocket"; break;
+                case Column.Wafer_Region: results = "Wafer Region"; break;
+                case Column.Wafer_Scribe: results = "Wafer Scribe"; break;
+                case Column.WaferPocket_Candela: results = "WaferPocket_Candela"; break;
+                case Column.WaferPocket_Warp: results = "WaferPocket_Warp"; break;
+                case Column.WaferPosition_CV: results = "WaferPosition_CV"; break;
+                case Column.WaferPosition_BV: results = "WaferPosition_BV"; break;
+                case Column.WaferPosition_Hall: results = "WaferPosition_Hall"; break;
+                case Column.WaferPosition_PR: results = "WaferPosition_PR"; break;
+                case Column.Warp: results = "Warp"; break;
+                case Column.X_Coord: results = "X-Coord"; break;
+                case Column.XRD_2_Theta_Peak_002: results = "XRD 2 Theta Peak 002"; break;
+                case Column.XRD_2_Theta_Peak_101: results = "XRD 2 Theta Peak 101"; break;
+                case Column.XRD_2_Theta_Position: results = "XRD 2-Theta Position"; break;
+                case Column.XRD_2_Theta_Position_Si_1: results = "XRD 2-Theta Position Si 1"; break;
+                case Column.XRD_2_Theta_Position_Si_2: results = "XRD 2-Theta Position Si 2"; break;
+                case Column.XRD_2_Theta_Position_Si_3: results = "XRD 2-Theta Position Si 3"; break;
+                case Column.XRD_Peak_002_Intensity: results = "XRD Peak 002 Intensity"; break;
+                case Column.XRD_Peak_101_Intensity: results = "XRD Peak 101 Intensity"; break;
+                case Column.XRD_Weekly_AL_Center: results = "XRD Weekly AL% Center"; break;
+                case Column.XRD_Weekly_Back_Barrier_Al_: results = "Back Barrier Al%"; break;
+                case Column.XRD_Weekly_Barrier_Al_: results = "Barrier Al%"; break;
+                case Column.XRD_Weekly_FWHM_002: results = "XRD Weekly FWHM 002"; break;
+                case Column.XRD_Weekly_FWHM_101: results = "XRD Weekly FWHM 101"; break;
+                case Column.XRD_Weekly_FWHM_105: results = "XRD Weekly FWHM 105"; break;
+                case Column.XRD_Weekly_Fringe_thick_0_0_: results = "XRD Weekly Fringe thick (0,0)"; break;
+                case Column.XRD_Weekly_Fringe_thick_48_48_: results = "XRD Weekly Fringe thick (48,48)"; break;
+                case Column.XRD_Weekly_Intensity: results = "XRD Weekly Intensity"; break;
+                case Column.XRD_Weekly_Super_Lattice_Al_: results = "Super Lattice Al%"; break;
+                case Column.XRD_Weekly_Super_Lattice_period: results = "Super Lattice period"; break;
+                case Column.XRD_Weekly_Super_Lattice_tks: results = "Super Lattice tks"; break;
+                case Column.XRR_Thickness_nm_WTAVG: results = "XRR Thickness (nm) WTAVG"; break;
+                case Column.XRR_Thickness_nm_: results = "XRR Thickness (nm)"; break;
+                case Column.Y_Coord: results = "Y-Coord"; break;
+                case Column.YellowBand_Power_mW_: results = "YellowBand_Power (mW)"; break;
+                case Column.YellowBand_V: results = "YellowBand_V"; break;
+                case Column.YellowBand_V_XY: results = "YellowBand_V_XY"; break;
+                case Column.YellowBand_nm: results = "YellowBand_nm"; break;
+                //case Column.pH: results = "pH"; break;
+                case Column.Ag: results = "Ag"; break;
+                case Column.Al: results = "Al"; break;
+                case Column.As: results = "As"; break;
+                case Column.Au: results = "Au"; break;
+                case Column.B: results = "B"; break;
+                case Column.Ba: results = "Ba"; break;
+                case Column.Ca: results = "Ca"; break;
+                case Column.Ce: results = "Ce"; break;
+                case Column.Co: results = "Co"; break;
+                case Column.Cr: results = "Cr"; break;
+                case Column.Cu: results = "Cu"; break;
+                case Column.Fe: results = "Fe"; break;
+                case Column.Ga: results = "Ga"; break;
+                case Column.Ge: results = "Ge"; break;
+                case Column.Hf: results = "Hf"; break;
+                case Column.K: results = "K"; break;
+                case Column.Li: results = "Li"; break;
+                case Column.Mg: results = "Mg"; break;
+                case Column.Mn: results = "Mn"; break;
+                case Column.Mo: results = "Mo"; break;
+                case Column.Na: results = "Na"; break;
+                case Column.Ni: results = "Ni"; break;
+                case Column.P: results = "P"; break;
+                case Column.Pb: results = "Pb"; break;
+                case Column.Sn: results = "Sn"; break;
+                case Column.Ta: results = "Ta"; break;
+                case Column.Ti: results = "Ti"; break;
+                case Column.W: results = "W"; break;
+                case Column.Y: results = "Y"; break;
+                case Column.Zn: results = "Zn"; break;
+                default: throw new Exception();
+            }
+            return results;
+        }
+
+        public static Description.Param GetParam(this Column column)
+        {
+            Description.Param results;
+            switch (column)
+            {
+                //case Column._8in_Total_Warp_Verification: results = Description.Param.String; break;
+                //case Column.AFM_Monthly_Y: results = Description.Param.String; break;
+                //case Column.AFM_Monthly: results = Description.Param.String; break;
+                case Column.AFM_Pit_Count: results = Description.Param.String; break;
+                case Column.AFM_Roughness: results = Description.Param.String; break;
+                //case Column.Adder_Bin_1: results = Description.Param.String; break;
+                //case Column.Adder_Bin_2: results = Description.Param.String; break;
+                //case Column.Adder_Bin_3: results = Description.Param.String; break;
+                //case Column.Adder_Bin_4: results = Description.Param.String; break;
+                //case Column.Adder_Bin_5: results = Description.Param.String; break;
+                //case Column.Adder_Bin_6: results = Description.Param.String; break;
+                //case Column.Adder_Bin_9: results = Description.Param.String; break;
+                case Column.Al_B_B_WTAVG: results = Description.Param.String; break;
+                case Column.Al_B_B_: results = Description.Param.String; break;
+                case Column.Al_Barrier_WTAVG: results = Description.Param.String; break;
+                case Column.Al_Barrier: results = Description.Param.String; break;
+                case Column.Al_SLS_WTAVG: results = Description.Param.String; break;
+                case Column.Al_SLS: results = Description.Param.String; break;
+                case Column.Al_TL1_WTAVG: results = Description.Param.String; break;
+                case Column.Al_TL1: results = Description.Param.String; break;
+                case Column.Al_TL2_WTAVG: results = Description.Param.String; break;
+                //case Column.BV_Resistance: results = Description.Param.String; break;
+                case Column.BandEdge_V: results = Description.Param.String; break;
+                case Column.BandEdge_V_XY: results = Description.Param.String; break;
+                case Column.BandEdge_nm: results = Description.Param.String; break;
+                case Column.Barrier_Composition_RPM_XY: results = Description.Param.String; break;
+                case Column.Bow_Calibration: results = Description.Param.String; break;
+                case Column.Bow_Range: results = Description.Param.String; break;
+                case Column.Bow: results = Description.Param.String; break;
+                case Column.BowCenter: results = Description.Param.String; break;
+                case Column.BowX: results = Description.Param.String; break;
+                case Column.BowY: results = Description.Param.String; break;
+                case Column.Breakdown_Voltage_Edge: results = Description.Param.String; break;
+                case Column.Breakdown_VoltageMiddle: results = Description.Param.String; break;
+                case Column.Breakdown_Voltage: results = Description.Param.String; break;
+                case Column.CV_C_at_10V: results = Description.Param.String; break;
+                case Column.CV_Nd_Min: results = Description.Param.String; break;
+                //case Column.Candela_Large_LPD_Quarterly: results = Description.Param.String; break;
+                //case Column.Candela_Medium_LPD_Quarterly: results = Description.Param.String; break;
+                //case Column.Candela_Small_LPD_Quarterly: results = Description.Param.String; break;
+                //case Column.Candela_Total_Quarterly: results = Description.Param.String; break;
+                case Column.Candela_102_83nm: results = Description.Param.String; break;
+                case Column.Candela_1_1um: results = Description.Param.String; break;
+                case Column.Candela_496nm: results = Description.Param.String; break;
+                case Column.Candela_600nm: results = Description.Param.String; break;
+                case Column.Candela_8620_Small: results = Description.Param.String; break;
+                case Column.Candela_Crack_Verification: results = Description.Param.String; break;
+                case Column.Candela_Cracking: results = Description.Param.String; break;
+                case Column.Candela_Cracking_Acceptable: results = Description.Param.String; break;
+                case Column.Candela_Crater: results = Description.Param.String; break;
+                case Column.Candela_Crater_Verification: results = Description.Param.String; break;
+                case Column.Candela_Haze: results = Description.Param.String; break;
+                case Column.Candela_LPD_Large: results = Description.Param.String; break;
+                case Column.Candela_LPD_Medium: results = Description.Param.String; break;
+                case Column.Candela_LPD_Small: results = Description.Param.String; break;
+                case Column.Candela_Large_Verification: results = Description.Param.String; break;
+                case Column.Candela_Medium_Verification: results = Description.Param.String; break;
+                case Column.Candela_Pits: results = Description.Param.String; break;
+                case Column.Candela_Pits_Verification: results = Description.Param.String; break;
+                case Column.Candela_SPE: results = Description.Param.String; break;
+                case Column.Candela_SPE_Verification: results = Description.Param.String; break;
+                case Column.Candela_Slip: results = Description.Param.String; break;
+                case Column.Candela_Small_Verification: results = Description.Param.String; break;
+                case Column.Candela_Spirals: results = Description.Param.String; break;
+                case Column.Candela_Spirals_Verification: results = Description.Param.String; break;
+                case Column.Candela_Total_Defects: results = Description.Param.String; break;
+                case Column.Candela_Total_PSL: results = Description.Param.String; break;
+                case Column.Candela__1_1um: results = Description.Param.String; break;
+                //case Column.Comment: results = Description.Param.String; break;
+                //case Column.Conductivity: results = Description.Param.String; break;
+                case Column.Contact_Symmetry: results = Description.Param.String; break;
+                //case Column.Cracking_verification: results = Description.Param.String; break;
+                //case Column.Crater_verification: results = Description.Param.String; break;
+                case Column.Date: results = Description.Param.String; break;
+                case Column.Denton_Crystal_Life: results = Description.Param.String; break;
+                case Column.Denton_Current_AVG: results = Description.Param.String; break;
+                case Column.Denton_Current_STDEV: results = Description.Param.String; break;
+                case Column.Denton_Deposition_Power_AVG: results = Description.Param.String; break;
+                case Column.Denton_Deposition_Power_STDEV: results = Description.Param.String; break;
+                case Column.Denton_Deposition_Rate_AVG: results = Description.Param.String; break;
+                case Column.Denton_Deposition_Rate_STDEV: results = Description.Param.String; break;
+                case Column.Denton_Gun_Pocket: results = Description.Param.String; break;
+                case Column.Denton_Pumpdown_Time: results = Description.Param.String; break;
+                case Column.Denton_Voltage_AVG: results = Description.Param.String; break;
+                case Column.Denton_Voltage_STDEV: results = Description.Param.String; break;
+                case Column.Employee: results = Description.Param.String; break;
+                case Column.Epi_Thickness_Mean: results = Description.Param.String; break;
+                case Column.Epi_Thickness_Mean_XY: results = Description.Param.String; break;
+                case Column.Epi_Thickness_Std_Dev_: results = Description.Param.String; break;
+                case Column.FWHM_006_WTAVG: results = Description.Param.String; break;
+                case Column.FWHM_006: results = Description.Param.String; break;
+                case Column.FWHM_105_WTAVG: results = Description.Param.String; break;
+                case Column.FWHM_105: results = Description.Param.String; break;
+                case Column.Hall_Rs: results = Description.Param.String; break;
+                case Column.Hall_Mobility_verif_sample: results = Description.Param.String; break;
+                case Column.Hall_Ns_verif_sample: results = Description.Param.String; break;
+                case Column.Hall_Rs_verif_sample: results = Description.Param.String; break;
+                case Column.Job: results = Description.Param.String; break;
+                case Column.LEI_RS_Average_value: results = Description.Param.String; break;
+                case Column.LEI_RS_Maximum_value: results = Description.Param.String; break;
+                case Column.LEI_RS_Minimum_value: results = Description.Param.String; break;
+                case Column.LEI_RS_STDEV: results = Description.Param.String; break;
+                case Column.LEI_RS_STDEV_: results = Description.Param.String; break;
+                //case Column.Large_Adder_Sum: results = Description.Param.String; break;
+                case Column.Lot: results = Description.Param.String; break;
+                //case Column.Medium_Adder_Sum: results = Description.Param.String; break;
+                case Column.Microscope_Center_5x: results = Description.Param.String; break;
+                case Column.Microscope_Center_50x: results = Description.Param.String; break;
+                case Column.Microscope_Middle_5x: results = Description.Param.String; break;
+                case Column.Microscope_Middle_50x: results = Description.Param.String; break;
+                case Column.Microscope_Edge_5x: results = Description.Param.String; break;
+                case Column.Microscope_Edge_50x: results = Description.Param.String; break;
+                case Column.Mobility_Verification: results = Description.Param.String; break;
+                case Column.Mobility: results = Description.Param.String; break;
+                case Column.Ns_Verification: results = Description.Param.String; break;
+                case Column.PL_Edge_Wavelength: results = Description.Param.String; break;
+                case Column.PL_Ratio: results = Description.Param.String; break;
+                case Column.PR_Barrier_Composition: results = Description.Param.String; break;
+                case Column.PR_Peak: results = Description.Param.String; break;
+                case Column.Part: results = Description.Param.String; break;
+                //case Column.Particles_verification: results = Description.Param.String; break;
+                //case Column.Pits_verification: results = Description.Param.String; break;
+                //case Column.Pocket: results = Description.Param.String; break;
+                //case Column.Post_Bin_1: results = Description.Param.String; break;
+                //case Column.Post_Bin_2: results = Description.Param.String; break;
+                //case Column.Post_Bin_3: results = Description.Param.String; break;
+                //case Column.Post_Bin_4: results = Description.Param.String; break;
+                //case Column.Post_Bin_5: results = Description.Param.String; break;
+                //case Column.Post_Bin_6: results = Description.Param.String; break;
+                //case Column.Post_Bin_9: results = Description.Param.String; break;
+                //case Column.Pre_Bin_1: results = Description.Param.String; break;
+                //case Column.Pre_Bin_2: results = Description.Param.String; break;
+                //case Column.Pre_Bin_3: results = Description.Param.String; break;
+                //case Column.Pre_Bin_4: results = Description.Param.String; break;
+                //case Column.Pre_Bin_5: results = Description.Param.String; break;
+                //case Column.Pre_Bin_6: results = Description.Param.String; break;
+                //case Column.Pre_Bin_9: results = Description.Param.String; break;
+                case Column.Process: results = Description.Param.String; break;
+                //case Column.RPM_verif_Thickness_1: results = Description.Param.String; break;
+                //case Column.RPM_verif_Thickness_2: results = Description.Param.String; break;
+                //case Column.RPM_verif_Thickness_3: results = Description.Param.String; break;
+                //case Column.RPM_verif_Thickness_Average: results = Description.Param.String; break;
+                //case Column.RTA_oxide_Thk_Change: results = Description.Param.String; break;
+                //case Column.RTA_oxide_post_anneal_Thk: results = Description.Param.String; break;
+                //case Column.RTA_oxide_pre_anneal_Thk: results = Description.Param.String; break;
+                case Column.Recipe: results = Description.Param.String; break;
+                //case Column.Resistivity_2_ohm_cm: results = Description.Param.String; break;
+                //case Column.Resistivity_600_ohm_cm: results = Description.Param.String; break;
+                case Column.Rs_verification: results = Description.Param.String; break;
+                case Column.Rs_verif_100kohm: results = Description.Param.String; break;
+                case Column.Rs_verif_10ohm: results = Description.Param.String; break;
+                case Column.Rs_verif_1kohm: results = Description.Param.String; break;
+                case Column.SID: results = Description.Param.String; break;
+                case Column.SL_Period_WTAVG: results = Description.Param.String; break;
+                case Column.SL_Period: results = Description.Param.String; break;
+                //case Column.SPE_verification: results = Description.Param.String; break;
+                //case Column.Sample_ID: results = Description.Param.String; break;
+                case Column.Sheet_Concentration: results = Description.Param.String; break;
+                //case Column.Size: results = Description.Param.String; break;
+                //case Column.Small_Adder_Sum: results = Description.Param.String; break;
+                //case Column.Spirals_verification: results = Description.Param.String; break;
+                case Column.Time: results = Description.Param.String; break;
+                case Column.Tool_ID: results = Description.Param.String; break;
+                //case Column.Total_LPD_Adder: results = Description.Param.String; break;
+                //case Column.Total_Verification: results = Description.Param.String; break;
+                case Column.Total_Warp_Calibration: results = Description.Param.String; break;
+                case Column.UV_Broken: results = Description.Param.String; break;
+                case Column.UV_Chipping: results = Description.Param.String; break;
+                case Column.UV_Cracking_0_3mm_: results = Description.Param.String; break;
+                case Column.UV_Cracking_3_7mm_: results = Description.Param.String; break;
+                case Column.UV_Cracking_7mm_: results = Description.Param.String; break;
+                case Column.UV_Crazing: results = Description.Param.String; break;
+                case Column.UV_Crazing_Acceptable: results = Description.Param.String; break;
+                case Column.UV_FULL_Characterization_Wafer: results = Description.Param.String; break;
+                case Column.UV_Haze_count_: results = Description.Param.String; break;
+                case Column.UV_LIGHT_Characterization_Wafer: results = Description.Param.String; break;
+                case Column.UV_Non_rotation: results = Description.Param.String; break;
+                case Column.UV_Other: results = Description.Param.String; break;
+                case Column.UV_Scratch_count_: results = Description.Param.String; break;
+                case Column.UV_Slip_count_: results = Description.Param.String; break;
+                case Column.UV_True_Haze: results = Description.Param.String; break;
+                case Column.UV_True_Haze_Acceptable: results = Description.Param.String; break;
+                case Column.UV_SPE_1mm_count: results = Description.Param.String; break;
+                case Column.UV_SPE_count_: results = Description.Param.String; break;
+                case Column.Verification_Contact_Symmetry: results = Description.Param.String; break;
+                case Column.Vp_Pinch_Off_Voltage: results = Description.Param.String; break;
+                case Column.Wafer_ID: results = Description.Param.String; break;
+                //case Column.Wafer_Pocket: results = Description.Param.String; break;
+                case Column.Wafer_Region: results = Description.Param.String; break;
+                case Column.Wafer_Scribe: results = Description.Param.String; break;
+                case Column.WaferPocket_Candela: results = Description.Param.String; break;
+                case Column.WaferPocket_Warp: results = Description.Param.String; break;
+                case Column.WaferPosition_CV: results = Description.Param.String; break;
+                case Column.WaferPosition_BV: results = Description.Param.String; break;
+                case Column.WaferPosition_Hall: results = Description.Param.String; break;
+                case Column.WaferPosition_PR: results = Description.Param.String; break;
+                case Column.Warp: results = Description.Param.String; break;
+                case Column.X_Coord: results = Description.Param.String; break;
+                case Column.XRD_2_Theta_Peak_002: results = Description.Param.String; break;
+                case Column.XRD_2_Theta_Peak_101: results = Description.Param.String; break;
+                case Column.XRD_2_Theta_Position: results = Description.Param.String; break;
+                case Column.XRD_2_Theta_Position_Si_1: results = Description.Param.String; break;
+                case Column.XRD_2_Theta_Position_Si_2: results = Description.Param.String; break;
+                case Column.XRD_2_Theta_Position_Si_3: results = Description.Param.String; break;
+                case Column.XRD_Peak_002_Intensity: results = Description.Param.String; break;
+                case Column.XRD_Peak_101_Intensity: results = Description.Param.String; break;
+                case Column.XRD_Weekly_AL_Center: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Back_Barrier_Al_: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Barrier_Al_: results = Description.Param.String; break;
+                case Column.XRD_Weekly_FWHM_002: results = Description.Param.String; break;
+                case Column.XRD_Weekly_FWHM_101: results = Description.Param.String; break;
+                case Column.XRD_Weekly_FWHM_105: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Fringe_thick_0_0_: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Fringe_thick_48_48_: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Intensity: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Super_Lattice_Al_: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Super_Lattice_period: results = Description.Param.String; break;
+                case Column.XRD_Weekly_Super_Lattice_tks: results = Description.Param.String; break;
+                case Column.XRR_Thickness_nm_WTAVG: results = Description.Param.String; break;
+                case Column.XRR_Thickness_nm_: results = Description.Param.String; break;
+                case Column.Y_Coord: results = Description.Param.String; break;
+                case Column.YellowBand_Power_mW_: results = Description.Param.String; break;
+                case Column.YellowBand_V: results = Description.Param.String; break;
+                case Column.YellowBand_V_XY: results = Description.Param.String; break;
+                case Column.YellowBand_nm: results = Description.Param.String; break;
+                //case Column.pH: results = Description.Param.String; break;
+                case Column.Ag: results = Description.Param.String; break;
+                case Column.Al: results = Description.Param.String; break;
+                case Column.As: results = Description.Param.String; break;
+                case Column.Au: results = Description.Param.String; break;
+                case Column.B: results = Description.Param.String; break;
+                case Column.Ba: results = Description.Param.String; break;
+                case Column.Ca: results = Description.Param.String; break;
+                case Column.Ce: results = Description.Param.String; break;
+                case Column.Co: results = Description.Param.String; break;
+                case Column.Cr: results = Description.Param.String; break;
+                case Column.Cu: results = Description.Param.String; break;
+                case Column.Fe: results = Description.Param.String; break;
+                case Column.Ga: results = Description.Param.String; break;
+                case Column.Ge: results = Description.Param.String; break;
+                case Column.Hf: results = Description.Param.String; break;
+                case Column.K: results = Description.Param.String; break;
+                case Column.Li: results = Description.Param.String; break;
+                case Column.Mg: results = Description.Param.String; break;
+                case Column.Mn: results = Description.Param.String; break;
+                case Column.Mo: results = Description.Param.String; break;
+                case Column.Na: results = Description.Param.String; break;
+                case Column.Ni: results = Description.Param.String; break;
+                case Column.P: results = Description.Param.String; break;
+                case Column.Pb: results = Description.Param.String; break;
+                case Column.Sn: results = Description.Param.String; break;
+                case Column.Ta: results = Description.Param.String; break;
+                case Column.Ti: results = Description.Param.String; break;
+                case Column.W: results = Description.Param.String; break;
+                case Column.Y: results = Description.Param.String; break;
+                case Column.Zn: results = Description.Param.String; break;
+                default: throw new Exception();
+            }
+            return results;
+        }
+
+    }
+
+    public enum Column
+    {
+        //_8in_Total_Warp_Verification,
+        //AFM_Monthly_Y,
+        //AFM_Monthly,
+        AFM_Pit_Count,
+        AFM_Roughness,
+        //Adder_Bin_1,
+        //Adder_Bin_2,
+        //Adder_Bin_3,
+        //Adder_Bin_4,
+        //Adder_Bin_5,
+        //Adder_Bin_6,
+        //Adder_Bin_9,
+        Al_B_B_WTAVG,
+        Al_B_B_,
+        Al_Barrier_WTAVG,
+        Al_Barrier,
+        Al_SLS_WTAVG,
+        Al_SLS,
+        Al_TL1_WTAVG,
+        Al_TL1,
+        Al_TL2_WTAVG,
+        //BV_Resistance,
+        BandEdge_V,
+        BandEdge_V_XY,
+        BandEdge_nm,
+        Barrier_Composition_RPM_XY,
+        Bow_Calibration,
+        Bow_Range,
+        Bow,
+        BowCenter,
+        BowX,
+        BowY,
+        Breakdown_Voltage_Edge,
+        Breakdown_VoltageMiddle,
+        Breakdown_Voltage,
+        CV_C_at_10V,
+        CV_Nd_Min,
+        //Candela_Large_LPD_Quarterly,
+        //Candela_Medium_LPD_Quarterly,
+        //Candela_Small_LPD_Quarterly,
+        //Candela_Total_Quarterly,
+        Candela_102_83nm,
+        Candela_1_1um,
+        Candela_496nm,
+        Candela_600nm,
+        Candela_8620_Small,
+        Candela_Crack_Verification,
+        Candela_Cracking,
+        Candela_Cracking_Acceptable,
+        Candela_Crater,
+        Candela_Crater_Verification,
+        Candela_Haze,
+        Candela_LPD_Large,
+        Candela_LPD_Medium,
+        Candela_LPD_Small,
+        Candela_Large_Verification,
+        Candela_Medium_Verification,
+        Candela_Pits,
+        Candela_Pits_Verification,
+        Candela_SPE,
+        Candela_SPE_Verification,
+        Candela_Slip,
+        Candela_Small_Verification,
+        Candela_Spirals,
+        Candela_Spirals_Verification,
+        Candela_Total_Defects,
+        Candela_Total_PSL,
+        Candela__1_1um,
+        //Comment,
+        //Conductivity,
+        Contact_Symmetry,
+        //Cracking_verification,
+        //Crater_verification,
+        Date,
+        Denton_Crystal_Life,
+        Denton_Current_AVG,
+        Denton_Current_STDEV,
+        Denton_Deposition_Power_AVG,
+        Denton_Deposition_Power_STDEV,
+        Denton_Deposition_Rate_AVG,
+        Denton_Deposition_Rate_STDEV,
+        Denton_Gun_Pocket,
+        Denton_Pumpdown_Time,
+        Denton_Voltage_AVG,
+        Denton_Voltage_STDEV,
+        Employee,
+        Epi_Thickness_Mean,
+        Epi_Thickness_Mean_XY,
+        Epi_Thickness_Std_Dev_,
+        FWHM_006_WTAVG,
+        FWHM_006,
+        FWHM_105_WTAVG,
+        FWHM_105,
+        Hall_Rs,
+        Hall_Mobility_verif_sample,
+        Hall_Ns_verif_sample,
+        Hall_Rs_verif_sample,
+        Job,
+        LEI_RS_Average_value,
+        LEI_RS_Maximum_value,
+        LEI_RS_Minimum_value,
+        LEI_RS_STDEV,
+        LEI_RS_STDEV_,
+        //Large_Adder_Sum,
+        Lot,
+        //Medium_Adder_Sum,
+        Microscope_Center_50x,
+        Microscope_Center_5x,
+        Microscope_Edge_50x,
+        Microscope_Edge_5x,
+        Microscope_Middle_50x,
+        Microscope_Middle_5x,
+        Mobility_Verification,
+        Mobility,
+        Ns_Verification,
+        PL_Edge_Wavelength,
+        PL_Ratio,
+        PR_Barrier_Composition,
+        PR_Peak,
+        Part,
+        //Particles_verification,
+        //Pits_verification,
+        //Pocket,
+        //Post_Bin_1,
+        //Post_Bin_2,
+        //Post_Bin_3,
+        //Post_Bin_4,
+        //Post_Bin_5,
+        //Post_Bin_6,
+        //Post_Bin_9,
+        //Pre_Bin_1,
+        //Pre_Bin_2,
+        //Pre_Bin_3,
+        //Pre_Bin_4,
+        //Pre_Bin_5,
+        //Pre_Bin_6,
+        //Pre_Bin_9,
+        Process,
+        //RPM_verif_Thickness_1,
+        //RPM_verif_Thickness_2,
+        //RPM_verif_Thickness_3,
+        //RPM_verif_Thickness_Average,
+        //RTA_oxide_Thk_Change,
+        //RTA_oxide_post_anneal_Thk,
+        //RTA_oxide_pre_anneal_Thk,
+        Recipe,
+        //Resistivity_2_ohm_cm,
+        //Resistivity_600_ohm_cm,
+        Rs_verification,
+        Rs_verif_100kohm,
+        Rs_verif_10ohm,
+        Rs_verif_1kohm,
+        SID,
+        SL_Period_WTAVG,
+        SL_Period,
+        //SPE_verification,
+        //Sample_ID,
+        Sheet_Concentration,
+        //Size,
+        //Small_Adder_Sum,
+        //Spirals_verification,
+        Time,
+        Tool_ID,
+        //Total_LPD_Adder,
+        //Total_Verification,
+        Total_Warp_Calibration,
+        UV_Broken,
+        UV_Chipping,
+        UV_Cracking_0_3mm_,
+        UV_Cracking_3_7mm_,
+        UV_Cracking_7mm_,
+        UV_Crazing,
+        UV_Crazing_Acceptable,
+        UV_FULL_Characterization_Wafer,
+        UV_Haze_count_,
+        UV_LIGHT_Characterization_Wafer,
+        UV_Non_rotation,
+        UV_Other,
+        UV_Scratch_count_,
+        UV_Slip_count_,
+        UV_True_Haze,
+        UV_True_Haze_Acceptable,
+        UV_SPE_1mm_count,
+        UV_SPE_count_,
+        Verification_Contact_Symmetry,
+        Vp_Pinch_Off_Voltage,
+        Wafer_ID,
+        //Wafer_Pocket,
+        Wafer_Region,
+        Wafer_Scribe,
+        WaferPocket_Candela,
+        WaferPocket_Warp,
+        WaferPosition_CV,
+        WaferPosition_BV,
+        WaferPosition_Hall,
+        WaferPosition_PR,
+        Warp,
+        X_Coord,
+        XRD_2_Theta_Peak_002,
+        XRD_2_Theta_Peak_101,
+        XRD_2_Theta_Position,
+        XRD_2_Theta_Position_Si_1,
+        XRD_2_Theta_Position_Si_2,
+        XRD_2_Theta_Position_Si_3,
+        XRD_Peak_002_Intensity,
+        XRD_Peak_101_Intensity,
+        XRD_Weekly_AL_Center,
+        XRD_Weekly_Back_Barrier_Al_,
+        XRD_Weekly_Barrier_Al_,
+        XRD_Weekly_FWHM_002,
+        XRD_Weekly_FWHM_101,
+        XRD_Weekly_FWHM_105,
+        XRD_Weekly_Fringe_thick_0_0_,
+        XRD_Weekly_Fringe_thick_48_48_,
+        XRD_Weekly_Intensity,
+        XRD_Weekly_Super_Lattice_Al_,
+        XRD_Weekly_Super_Lattice_period,
+        XRD_Weekly_Super_Lattice_tks,
+        XRR_Thickness_nm_,
+        XRR_Thickness_nm_WTAVG,
+        Y_Coord,
+        YellowBand_Power_mW_,
+        YellowBand_V,
+        YellowBand_V_XY,
+        YellowBand_nm,
+        //pH,
+        Ag,
+        Al,
+        As,
+        Au,
+        B,
+        Ba,
+        Ca,
+        Ce,
+        Co,
+        Cr,
+        Cu,
+        Fe,
+        Ga,
+        Ge,
+        Hf,
+        K,
+        Li,
+        Mg,
+        Mn,
+        Mo,
+        Na,
+        Ni,
+        P,
+        Pb,
+        Sn,
+        Ta,
+        Ti,
+        W,
+        Y,
+        Zn
+    }
+
+}

Adaptation/Shared/Metrology/ConfigDataBase.cs

@@ -0,0 +1,398 @@
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace Adaptation.Shared.Metrology
+{
+
+    public class ConfigDataBase
+    {
+
+        public bool UseCyclicalForDescription { get; protected set; }
+        public Dictionary<string, string> CellNames { get; protected set; }
+        public Dictionary<string, string> MesEntities { get; protected set; }
+        public IProcessDataDescription ProcessDataDescription { get; protected set; }
+
+        public bool IsEvent { get; private set; }
+        public bool EafHosted { get; private set; }
+        public string CellName { get; private set; }
+        public bool IsSourceTimer { get; private set; }
+        public EquipmentType EquipmentType => _EquipmentType;
+        public string EquipmentElementName { get; private set; }
+        public bool IsDatabaseExportToIPDSF { get; private set; }
+        public EquipmentType? EquipmentConnection => _EquipmentConnection;
+        public FileConnectorConfiguration FileConnectorConfiguration { get; private set; }
+
+        protected readonly EventName _EventName;
+        protected readonly EquipmentType _EquipmentType;
+        protected readonly EquipmentType? _EquipmentConnection;
+        protected readonly Dictionary<string, string> _Reactors;
+
+        public ConfigDataBase(string cellName, string cellInstanceConnectionName, FileConnectorConfiguration fileConnectorConfiguration, string equipmentTypeName, string parameterizedModelObjectDefinitionType, bool isEAFHosted)
+        {
+            CellName = cellName;
+            EafHosted = isEAFHosted;
+            EquipmentType equipmentTypeValue;
+            _Reactors = new Dictionary<string, string>();
+            CellNames = new Dictionary<string, string>();
+            MesEntities = new Dictionary<string, string>();
+            EquipmentElementName = cellInstanceConnectionName;
+            FileConnectorConfiguration = fileConnectorConfiguration;
+            string[] segments = parameterizedModelObjectDefinitionType.Split('.');
+            IsSourceTimer = (fileConnectorConfiguration.SourceFileFilter.StartsWith("*Timer.txt"));
+            string cellInstanceConnectionNameBase = cellInstanceConnectionName.Replace("-", string.Empty);
+            IsDatabaseExportToIPDSF = (fileConnectorConfiguration.SourceFileLocation.Contains("DatabaseExport"));
+            if (!Enum.TryParse(segments[segments.Length - 1], out EventName eventNameValue))
+                throw new Exception(cellInstanceConnectionName);
+            if (!Enum.TryParse(cellInstanceConnectionNameBase, out equipmentTypeValue))
+                _EquipmentConnection = null;
+            else
+                _EquipmentConnection = equipmentTypeValue;
+            string suffix;
+            switch (eventNameValue)
+            {
+                case EventName.FileRead: suffix = string.Empty; break;
+                case EventName.FileReadDaily: suffix = "_Daily"; break;
+                case EventName.FileReadWeekly: suffix = "_Weekly"; break;
+                case EventName.FileReadMonthly: suffix = "_Monthly"; break;
+                case EventName.FileReadVerification: suffix = "_Verification"; break;
+                default: throw new Exception(cellInstanceConnectionName);
+            }
+            string parameterizedModelObjectDefinitionTypeAppended = string.Concat(segments[0], suffix);
+            IsEvent = cellInstanceConnectionNameBase != parameterizedModelObjectDefinitionTypeAppended;
+            _EventName = eventNameValue;
+            if (!Enum.TryParse(parameterizedModelObjectDefinitionTypeAppended, out equipmentTypeValue))
+                throw new Exception(cellInstanceConnectionName);
+            _EquipmentType = equipmentTypeValue;
+            if (!isEAFHosted && equipmentTypeName != parameterizedModelObjectDefinitionTypeAppended)
+                throw new Exception(cellInstanceConnectionName);
+        }
+
+        public string GetEventName()
+        {
+            string result = _EventName.ToString();
+            return result;
+        }
+
+        public EventName GetEventNameValue()
+        {
+            EventName result = _EventName;
+            return result;
+        }
+
+        public string GetEquipmentType()
+        {
+            string result;
+            if (_EquipmentConnection is null)
+                result = _EquipmentType.ToString();
+            else
+                result = _EquipmentConnection.Value.ToString();
+            return result;
+        }
+
+        public string GetEventDescription()
+        {
+            string result = ProcessDataDescription.GetEventDescription();
+            return result;
+        }
+
+        public IProcessDataDescription GetDefault(ILogic logic)
+        {
+            IProcessDataDescription result = ProcessDataDescription.GetDefault(logic, this);
+            return result;
+        }
+
+        public IProcessDataDescription GetDisplayNames(ILogic logic)
+        {
+            IProcessDataDescription result = ProcessDataDescription.GetDisplayNames(logic, this);
+            return result;
+        }
+
+        public List<string> GetDetailNames(ILogic logic)
+        {
+            List<string> results = ProcessDataDescription.GetDetailNames(logic, this);
+            return results;
+        }
+
+        public List<string> GetHeaderNames(ILogic logic)
+        {
+            List<string> results = ProcessDataDescription.GetHeaderNames(logic, this);
+            return results;
+        }
+
+        public List<string> GetNames(ILogic logic)
+        {
+            List<string> results = ProcessDataDescription.GetNames(logic, this);
+            return results;
+        }
+
+        public List<string> GetPairedParameterNames(ILogic logic)
+        {
+            List<string> results = ProcessDataDescription.GetPairedParameterNames(logic, this);
+            return results;
+        }
+
+        public List<string> GetParameterNames(ILogic logic)
+        {
+            List<string> results = ProcessDataDescription.GetParameterNames(logic, this);
+            return results;
+        }
+
+        public List<IProcessDataDescription> GetDescription(ILogic logic, List<Test> tests, IProcessData iProcessData)
+        {
+            List<IProcessDataDescription> results = ProcessDataDescription.GetDescription(logic, this, tests, iProcessData);
+            return results;
+        }
+
+        public string GetCurrentReactor(ILogic logic)
+        {
+            string result = string.Empty;
+            foreach (KeyValuePair<string, string> keyValuePair in _Reactors)
+            {
+                foreach (string filePrefix in keyValuePair.Value.Split('|'))
+                {
+                    if (logic.Logistics.MID.StartsWith(filePrefix) || (_EventName != EventName.FileRead && MesEntities.ContainsKey(logic.Logistics.JobID) && keyValuePair.Value == MesEntities[logic.Logistics.JobID]))
+                    {
+                        result = keyValuePair.Key;
+                        break;
+                    }
+                }
+            }
+            if (string.IsNullOrEmpty(result) && _Reactors.Count == 1)
+                result = _Reactors.ElementAt(0).Key;
+            return result;
+        }
+
+        protected JsonElement GetDefaultJsonElement(ILogic logic)
+        {
+            JsonElement result;
+            IProcessDataDescription processDataDescription = ProcessDataDescription.GetDefault(logic, this);
+            string json = JsonSerializer.Serialize(processDataDescription, processDataDescription.GetType());
+            object @object = JsonSerializer.Deserialize<object>(json);
+            result = (JsonElement)@object;
+            return result;
+        }
+
+        public Dictionary<string, List<Tuple<Enum, string, string, object>>> GetParameterInfo(ILogic logic, bool allowNull)
+        {
+            Dictionary<string, List<Tuple<Enum, string, string, object>>> results = new Dictionary<string, List<Tuple<Enum, string, string, object>>>();
+            string description;
+            Enum param;
+            Tuple<Enum, string, string, object> tuple;
+            JsonElement defaultJsonElement = GetDefaultJsonElement(logic);
+            Dictionary<string, string> keyValuePairs = GetDisplayNamesJsonElement(logic);
+            foreach (JsonProperty jsonProperty in defaultJsonElement.EnumerateObject())
+            {
+                if (jsonProperty.Value.ValueKind == JsonValueKind.Null && !allowNull)
+                    throw new Exception();
+                if (jsonProperty.Value.ValueKind == JsonValueKind.Object || jsonProperty.Value.ValueKind == JsonValueKind.Array)
+                {
+                    description = string.Empty;
+                    param = Description.Param.StructuredType;
+                    //jValue = jObject.Value<JValue>("Item1");
+                    throw new NotImplementedException("Item1");
+                }
+                else
+                {
+                    switch (jsonProperty.Value.ValueKind)
+                    {
+                        case JsonValueKind.String: param = Description.Param.String; break;
+                        case JsonValueKind.Number: param = Description.Param.Double; break;
+                        case JsonValueKind.True:
+                        case JsonValueKind.False: param = Description.Param.Boolean; break;
+                        case JsonValueKind.Null: param = Description.Param.String; break;
+                        default: param = Description.Param.StructuredType; break;
+                    }
+                }
+                if (!keyValuePairs.ContainsKey(jsonProperty.Name))
+                    description = string.Empty;
+                else
+                    description = keyValuePairs[jsonProperty.Name];
+                tuple = new Tuple<Enum, string, string, object>(param, jsonProperty.Name, description, jsonProperty.Value.ToString());
+                if (!results.ContainsKey(jsonProperty.Name))
+                    results.Add(jsonProperty.Name, new List<Tuple<Enum, string, string, object>>());
+                results[jsonProperty.Name].Add(tuple);
+            }
+            return results;
+        }
+
+        protected void WriteExportAliases(ILogic logic, string cellName, string equipmentElementName)
+        {
+            int i = 0;
+            Enum param;
+            object value;
+            Enum[] @params;
+            string description;
+            StringBuilder stringBuilder = new StringBuilder();
+            string shareRoot = @"\\messv02ecc1.ec.local\EC_EDA";
+            string shareDirectory = string.Concat(shareRoot, @"\Staging\Pdsf\", cellName, @"\ExportAliases\", equipmentElementName);
+            Dictionary<string, List<Tuple<Enum, string, string, object>>> keyValuePairs;
+            if (!(logic is null))
+                keyValuePairs = GetParameterInfo(logic, allowNull: false);
+            else
+                keyValuePairs = new Dictionary<string, List<Tuple<Enum, string, string, object>>>();
+            stringBuilder.AppendLine("\"AliasName\";\"Condition\";\"EventId\";\"ExceptionId\";\"Formula\";\"HardwareId\";\"OrderId\";\"ParameterName\";\"Remark\";\"ReportName\";\"SourceId\";\"Use\"");
+            if (!Directory.Exists(shareRoot))
+                return;
+            if (!Directory.Exists(shareDirectory))
+                Directory.CreateDirectory(shareDirectory);
+            string shareFile = string.Concat(shareDirectory, @"\", DateTime.Now.Ticks, ".csv");
+            foreach (KeyValuePair<string, List<Tuple<Enum, string, string, object>>> keyValuePair in keyValuePairs)
+            {
+                i += 1;
+                @params = (from l in keyValuePair.Value select l.Item1).Distinct().ToArray();
+                if (@params.Length != 1)
+                    throw new Exception();
+                if (keyValuePair.Value[0].Item2 != keyValuePair.Key)
+                    throw new Exception();
+                param = @params[0];
+                if (!(param is Description.Param.String))
+                    stringBuilder.AppendLine($"\"{keyValuePair.Key}\";\"\";\"\";\"\";\"\";\"\";\"{i}\";\"{cellName}/{EquipmentElementName}/{keyValuePair.Key}\";\"\";\"{cellName}/{EquipmentElementName}/{_EventName}\";\"\";\"True\"");
+                else
+                {
+                    description = keyValuePair.Value[0].Item3.Split('|')[0];
+                    if (string.IsNullOrEmpty(description))
+                        continue;
+                    value = keyValuePair.Value[0].Item4;
+                    stringBuilder.AppendLine($"\"'{description}'\";\"\";\"\";\"\";\"\";\"\";\"{i}\";\"{cellName}/{EquipmentElementName}/{value}\";\"\";\"{cellName}/{EquipmentElementName}/{_EventName}\";\"\";\"True\"");
+                }
+            }
+            if (keyValuePairs.Any())
+                File.WriteAllText(shareFile, stringBuilder.ToString());
+        }
+
+        public Dictionary<string, string> GetDisplayNamesJsonElement(ILogic logic)
+        {
+            Dictionary<string, string> results = new Dictionary<string, string>();
+            IProcessDataDescription processDataDescription = ProcessDataDescription.GetDisplayNames(logic, this);
+            string json = JsonSerializer.Serialize(processDataDescription, processDataDescription.GetType());
+            JsonElement jsonElement = JsonSerializer.Deserialize<JsonElement>(json);
+            foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
+            {
+                if (!results.ContainsKey(jsonProperty.Name))
+                    results.Add(jsonProperty.Name, string.Empty);
+                if (jsonProperty.Value is JsonElement jsonPropertyValue)
+                    results[jsonProperty.Name] = jsonPropertyValue.ToString();
+            }
+            return results;
+        }
+
+        public List<string> GetIgnoreParameterNames(ILogic logic, Test test, bool includePairedParameterNames)
+        {
+            List<string> results = ProcessDataDescription.GetIgnoreParameterNames(logic, this, test);
+            if (includePairedParameterNames)
+            {
+                string value;
+                List<string> pairedParameterNames = ProcessDataDescription.GetPairedParameterNames(logic, this);
+                IProcessDataDescription processDataDescription = ProcessDataDescription.GetDisplayNames(logic, this);
+                string json = JsonSerializer.Serialize(processDataDescription, processDataDescription.GetType());
+                object @object = JsonSerializer.Deserialize<object>(json);
+                if (!(@object is JsonElement jsonElement))
+                    throw new Exception();
+                foreach (JsonProperty jsonProperty in jsonElement.EnumerateObject())
+                {
+                    if (jsonProperty.Value.ValueKind == JsonValueKind.Object || jsonProperty.Value.ValueKind == JsonValueKind.Array)
+                        throw new Exception();
+                    value = jsonProperty.Value.ToString();
+                    if (!results.Contains(jsonProperty.Name) && pairedParameterNames.Contains(jsonProperty.Name) && (string.IsNullOrEmpty(value) || value[0] == '|'))
+                        results.Add(jsonProperty.Name);
+                }
+            }
+            return results;
+        }
+
+        public List<Duplicator.Description> GetProcessDataDescriptions(JsonElement jsonElement)
+        {
+            List<Duplicator.Description> results;
+            if (jsonElement.ValueKind != JsonValueKind.Array)
+                throw new Exception();
+            JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString };
+            results = JsonSerializer.Deserialize<List<Duplicator.Description>>(jsonElement.ToString(), jsonSerializerOptions);
+            return results;
+        }
+
+        public Dictionary<Test, List<Duplicator.Description>> GetKeyValuePairs(List<Duplicator.Description> processDataDescriptions)
+        {
+            Dictionary<Test, List<Duplicator.Description>> results = new Dictionary<Test, List<Duplicator.Description>>();
+            Test testKey;
+            for (int i = 0; i < processDataDescriptions.Count; i++)
+            {
+                testKey = (Test)processDataDescriptions[i].Test;
+                if (!results.ContainsKey(testKey))
+                    results.Add(testKey, new List<Duplicator.Description>());
+                results[testKey].Add(processDataDescriptions[i]);
+            }
+            return results;
+        }
+
+        public Dictionary<string, List<string>> GetKeyValuePairs(JsonElement jsonElement, List<Duplicator.Description> processDataDescriptions, Test test)
+        {
+            Dictionary<string, List<string>> results = new Dictionary<string, List<string>>();
+            Test testKey;
+            if (jsonElement.ValueKind != JsonValueKind.Array)
+                throw new Exception();
+            JsonElement[] jsonElements = jsonElement.EnumerateArray().ToArray();
+            if (processDataDescriptions.Count != jsonElements.Length)
+                throw new Exception();
+            for (int i = 0; i < processDataDescriptions.Count; i++)
+            {
+                testKey = (Test)processDataDescriptions[i].Test;
+                if (testKey != test)
+                    continue;
+                foreach (JsonProperty jsonProperty in jsonElements[i].EnumerateObject())
+                {
+                    if (jsonProperty.Value.ValueKind == JsonValueKind.Object || jsonProperty.Value.ValueKind == JsonValueKind.Array)
+                        throw new Exception();
+                    if (!results.ContainsKey(jsonProperty.Name))
+                        results.Add(jsonProperty.Name, new List<string>());
+                    results[jsonProperty.Name].Add(jsonProperty.Value.ToString());
+                }
+            }
+            return results;
+        }
+
+        protected void VerifyProcessDataDescription(ILogic logic)
+        {
+            string description;
+            bool allowNull = false;
+            JsonElement defaultJsonElement = GetDefaultJsonElement(logic);
+            Dictionary<string, string> keyValuePairs = GetDisplayNamesJsonElement(logic);
+            JsonProperty[] jsonProperties = defaultJsonElement.EnumerateObject().ToArray();
+            foreach (JsonProperty jsonProperty in jsonProperties)
+            {
+                if (jsonProperty.Value.ValueKind == JsonValueKind.Null && !allowNull)
+                    throw new Exception();
+                if (!(jsonProperty.Value.ValueKind is JsonValueKind.String) || !keyValuePairs.ContainsKey(jsonProperty.Name))
+                    description = string.Empty;
+                else
+                    description = keyValuePairs[jsonProperty.Name].Split('|')[0];
+            }
+        }
+
+        public List<IProcessDataDescription> GetIProcessDataDescriptions(JsonElement jsonElement)
+        {
+            List<IProcessDataDescription> results = new List<IProcessDataDescription>();
+            if (jsonElement.ValueKind != JsonValueKind.Array)
+                throw new Exception();
+            object @object;
+            Type type = ProcessDataDescription.GetType();
+            JsonElement[] jsonElements = jsonElement.EnumerateArray().ToArray();
+            JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions { NumberHandling = JsonNumberHandling.AllowReadingFromString | JsonNumberHandling.WriteAsString };
+            for (int i = 0; i < jsonElements.Length; i++)
+            {
+                @object = JsonSerializer.Deserialize(jsonElements[i].ToString(), type, jsonSerializerOptions);
+                if (!(@object is IProcessDataDescription processDataDescription))
+                    continue;
+                results.Add(processDataDescription);
+            }
+            return results;
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/EventName.cs

@@ -0,0 +1,13 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public enum EventName
+    {
+        FileRead,
+        FileReadDaily,
+        FileReadMonthly,
+        FileReadVerification,
+        FileReadWeekly
+    }
+
+}

Adaptation/Shared/Metrology/ILogic.cs

@@ -0,0 +1,45 @@
+using Adaptation.Eaf.Management.ConfigurationData.CellAutomation;
+using Adaptation.Ifx.Eaf.EquipmentConnector.File.Configuration;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Text.Json;
+
+namespace Adaptation.Shared.Metrology
+{
+
+    public interface ILogic
+    {
+
+        ILogic ShallowCopy();
+        Logistics Logistics { get; }
+
+        void ConfigurationRestore();
+        string GetConfigurationErrorTargetFileLocation();
+        string GetConfigurationSourceFileLocation();
+        string GetConfigurationTarget2FileLocation();
+        string GetConfigurationTargetFileLocation();
+        string GetConfigurationTargetFileName();
+        Tuple<string, JsonElement?, List<FileInfo>> GetExtractResult(string reportFullPath, string eventName);
+        object GetFilePathGeneratorInfo(string reportFullPath, bool isErrorFile);
+        string GetReportFullPath(Dictionary<string, object> keyValuePairs);
+        string GetTarget2FileLocation();
+        void Move(string reportFullPath, Tuple<string, JsonElement?, List<FileInfo>> extractResults, Exception exception = null);
+        Tuple<string, JsonElement?, List<FileInfo>> ReExtract(string searchDirectory, string sourceFileFilter);
+        void ReflectionCreateSelfDescription(string equipmentElementName, int? input, string cellName, string debugConfig, string[] strings, bool[] booleans, long[] numbers, string[] enums);
+        ConfigDataBase ReflectionCreateSelfDescriptionV2(string json);
+        string ResolveErrorTargetPlaceHolders(string reportFullPath, bool createDirectory = true, string fileFoundPath = "");
+        string ResolveSourcePlaceHolders(string reportFullPath, bool createDirectory = true);
+        string ResolveTarget2PlaceHolders(string reportFullPath, bool createDirectory = true, string fileFoundPath = "");
+        string ResolveTargetPlaceHolders(string reportFullPath, bool createDirectory = true, string fileFoundPath = "");
+        void SetFileParameter(string key, string value);
+        void SetFileParameterLotID(string value, bool includeLogisticsSequence = false);
+        void SetFileParameterLotIDToLogisticsMID(bool includeLogisticsSequence = true);
+        void SetFileParameterSystemDateTimeToLogisticsSequence();
+        void SetPlaceHolder(string reportFullPath, string key, string value);
+        void SetTarget2FileLocation(string value);
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08AFMD3100.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08AFMD3100
+    {
+
+        public enum Test
+        {
+            AFMRoughness = Metrology.Test.AFMRoughness
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08ANLYSDIFAAST230.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08ANLYSDIFAAST230
+    {
+
+        public enum Test
+        {
+            DiffusionLength = Metrology.Test.DiffusionLength
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08BVHGPROBE.cs

@@ -0,0 +1,16 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08BVHGPROBE
+    {
+
+        public enum Test
+        {
+            BreakdownVoltageCenter = Metrology.Test.BreakdownVoltageCenter,
+            BreakdownVoltageEdge = Metrology.Test.BreakdownVoltageEdge,
+            BreakdownVoltageMiddle8in = Metrology.Test.BreakdownVoltageMiddle8in
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08CVHGPROBE802B150.cs

@@ -0,0 +1,16 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08CVHGPROBE802B150
+    {
+
+        public enum Test
+        {
+            CV = Metrology.Test.CV,
+            MonthlyCV = Metrology.Test.MonthlyCV,
+            WeeklyCV = Metrology.Test.WeeklyCV
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08DDINCAN8620.cs

@@ -0,0 +1,18 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08DDINCAN8620
+    {
+
+        public enum Test
+        {
+            CandelaKlarfDC = Metrology.Test.CandelaKlarfDC,
+            CandelaLaser = Metrology.Test.CandelaLaser,
+            CandelaVerify = Metrology.Test.CandelaVerify,
+            CandelaPSL = Metrology.Test.CandelaPSL,
+            CandelaProdU = Metrology.Test.CandelaProdU
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08DDUPSFS6420.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08DDUPSFS6420
+    {
+
+        public enum Test
+        {
+            Tencor = Metrology.Test.Tencor
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08DDUPSP1TBI.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08DDUPSP1TBI
+    {
+
+        public enum Test
+        {
+            SP1 = Metrology.Test.SP1
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08EBEAMINTEGRITY26.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08EBEAMINTEGRITY26
+    {
+
+        public enum Test
+        {
+            Denton = Metrology.Test.Denton
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08HALLHL5580.cs

@@ -0,0 +1,16 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08HALLHL5580
+    {
+
+        public enum Test
+        {
+            Hall = Metrology.Test.Hall,
+            MonthlyHall = Metrology.Test.MonthlyHall,
+            WeeklyHall = Metrology.Test.WeeklyHall
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08MESMICROSCOPE.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08MESMICROSCOPE
+    {
+
+        public enum Test
+        {
+            Microscope = Metrology.Test.Microscope
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08NDFRESIMAP151C.cs

@@ -0,0 +1,15 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08NDFRESIMAP151C
+    {
+
+        public enum Test
+        {
+            Lehighton = Metrology.Test.Lehighton,
+            VerificationLehighton = Metrology.Test.VerificationLehighton
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08PLMAPRPM.cs

@@ -0,0 +1,20 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08PLMAPRPM
+    {
+
+        public enum Test
+        {
+            RPMXY = Metrology.Test.RPMXY,
+            RPMAverage = Metrology.Test.RPMAverage,
+            RPMPLRatio = Metrology.Test.RPMPLRatio,
+            DailyRPMXY = Metrology.Test.DailyRPMXY,
+            DailyRPMAverage = Metrology.Test.DailyRPMAverage,
+            DailyRPMPLRatio = Metrology.Test.DailyRPMPLRatio,
+            VerificationRPM = Metrology.Test.VerificationRPM
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08PRFUSB4000.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08PRFUSB4000
+    {
+
+        public enum Test
+        {
+            Photoreflectance = Metrology.Test.Photoreflectance
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08RESIHGCV.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08RESIHGCV
+    {
+
+        public enum Test
+        {
+            HgCV = Metrology.Test.HgCV
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08RESIMAPCDE.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08RESIMAPCDE
+    {
+
+        public enum Test
+        {
+            CDE = Metrology.Test.CDE
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08THFTIRQS408M.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08THFTIRQS408M
+    {
+
+        public enum Test
+        {
+            BioRadQS408M = Metrology.Test.BioRadQS408M
+        }
+
+    }
+
+}

Adaptation/Shared/Metrology/MET08THFTIRSTRATUS.cs

@@ -0,0 +1,14 @@
+namespace Adaptation.Shared.Metrology
+{
+
+    public class MET08THFTIRSTRATUS
+    {
+
+        public enum Test
+        {
+            BioRadStratus = Metrology.Test.BioRadStratus
+        }
+
+    }
+
+}