public IJobLoader Parse(JobParser parser, ParseState state)
        {
            var connection = state.Require <string>("Database", true);

            if (!connection.Contains("="))
            {
                var builder =
                    new SqlConnectionStringBuilder(
                        ConfigurationManager.ConnectionStrings["ExperienceExtractor.Sql"].ConnectionString);
                builder.InitialCatalog = connection;
                connection             = builder.ConnectionString;
            }

            using (var conn = new SqlConnection(connection))
            {
                conn.Open();
                if (DBNull.Value.Equals(new SqlCommand("SELECT OBJECT_ID('Sitecore.JobInfo', 'U')", conn).ExecuteScalar()))
                {
                    throw new ParseException(state, "Database does not contain the job info table. Was it created with Experience Extractor?");
                }

                var json = (string)new SqlCommand("SELECT TOP 1 [Prototype] FROM Sitecore.JobInfo", conn).ExecuteScalar();
                if (string.IsNullOrEmpty(json))
                {
                    throw new ParseException(state, "Database does not contain a job prototype");
                }

                var job = new JsonJobParser(JObject.Parse(json));
                return(new StaticJobLoader(job));
            }
        }
        public ITableMapper Parse(JobParser parser, ParseState state)
        {
            var table = parser.ParseTableDefinition(state.Select("Table") ?? state.Select(null, true));

            Type itemType;
            var  selector = Selectors.SelectFromName(GetSelector(parser, state), out itemType);

            var expand = state.Select("Expand");

            if (expand != null)
            {
                var expandField = parser.ParseFieldMapper(expand) as SimpleFieldMapper;
                if (expandField == null)
                {
                    throw ParseException.AttributeError(expand, "Invalid field specified");
                }

                var delimiter = state.TryGet("Delimiter", "|");

                return(new SimpleTableMapper(selector,
                                             new TableDefinition("").Map(
                                                 new SimpleTableMapper(
                                                     scope =>
                                                     expandField.Selector(scope)
                                                     .TryGet(v => "" + v, "")
                                                     .Split(new[] { delimiter }, StringSplitOptions.RemoveEmptyEntries), table))));
            }

            return(new SimpleTableMapper(selector, table));
        }
Beispiel #3
0
        /// <summary>
        /// Look for all jobs that match a certian criteria.
        /// </summary>
        protected override void ProcessRecord()
        {
            Func <AtlasJob, bool> nameSelector    = _ => true;
            Func <AtlasJob, bool> versionSelector = _ => true;

            if (!string.IsNullOrWhiteSpace(JobName))
            {
                var matcher = new Regex(JobName.Replace("*", ".*"));
                nameSelector = j => matcher.Match(j.Name).Success;
            }

            if (!string.IsNullOrWhiteSpace(JobVersion))
            {
                int version = 0;
                if (!int.TryParse(JobVersion, out version))
                {
                    throw new ArgumentException(string.Format("JobVersion must be a valid integer, not '{0}'", JobVersion));
                }

                versionSelector = j => j.Version == version;
            }

            // Now we can actually go through and get all the jobs.

            var jobs = JobParser.FindJobs(j => nameSelector(j) && versionSelector(j));

            // And return what we found out.
            foreach (var j in jobs.Select(fullSpec => new AtlasJobSpec()
            {
                JobName = fullSpec.Name, JobVersion = fullSpec.Version
            }))
            {
                WriteObject(j);
            }
        }
Beispiel #4
0
 public IFieldMapper Parse(JobParser parser, ParseState state)
 {
     return(new SimpleFieldMapper("AITraining",
                                  scope => GetTrainingValue(scope.Current <IVisitAggregationContext>().Contact),
                                  valueType: typeof(string),
                                  fieldType: FieldType.Dimension));
 }
Beispiel #5
0
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var tableName = state.Require <string>("Name");
            var inline    = state.TryGet("Inline", false);

            var fieldState = state.Clone();

            var affix = state.TryGet("AffixNames", true);

            if (affix)
            {
                tableName = state.AffixName(tableName);
            }
            else
            {
                fieldState = fieldState.ClearAffix();
            }

            var fieldPrefix = state.TryGet("Prefix", "");


            return(new FieldMapperSet(tableName, inline,
                                      fieldState.SelectMany("Fields").Select(parser.ParseFieldMapper), state.AffixName,
                                      fieldNamePrefix: fieldPrefix)
            {
                Key = state.TryGet("Key", false)
            });
        }
Beispiel #6
0
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var testIdString = state.Require <string>("TestId", true);

            Guid testId;

            if (!Guid.TryParse(testIdString, out testId))
            {
                throw state.AttributeError("Invalid test id specified ({0})", testIdString);
            }


            var testSet = TestManager.GetTestSet(testId);

            var testMapper = new MvTestFieldMapper(testSet, state.AffixName(state.TryGet("Name", "MvTest")));

            if (state.SelectMany("Fields").Any())
            {
                var splitter = new SplittingFieldMapper(new MvTestSplitter(testId),
                                                        postfix =>
                                                        state.Postfix(postfix).SelectMany("Fields").Select(parser.ParseFieldMapper).ToArray());

                return(new FieldMapperSet(testMapper.Name, true, new IFieldMapper[] { testMapper, splitter }, state.AffixName));
            }

            return(testMapper);
        }
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var name = state.AffixName(state.TryGet("Name", "Count", true));

            var scopeOffset = Math.Abs(state.TryGet("Scope", 0));

            return(new SimpleFieldMapper(name, ctx =>
            {
                if (scopeOffset == 0)
                {
                    return 1;
                }
                var p = ctx;
                for (var i = 0; i < scopeOffset && p != null; i++)
                {
                    p = p.Parent;
                }
                if (p != null)
                {
                    return ctx.OncePerScope(p, 1);
                }

                return 0;
            }, typeof(int), FieldType.Fact));
        }
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var source = state.TryGet("Select", "Pages", true);
            var path   = source.Split('.');

            source = path[0];
            var name = state.TryGet("Name", source);

            Type itemType;
            var  items = Selectors.SelectFromName(source, out itemType);

            var selector = string.Join(".", path.Skip(1));

            if (string.IsNullOrEmpty(selector))
            {
                selector = Selectors.DefaultSelector(source);
            }

            var getterInfo = parser.CompileGetter(itemType, selector);

            return(new SequenceFieldMapper(name,
                                           scope => items(scope).Select(item => getterInfo.Getter(item, scope)),
                                           (SequenceType)
                                           Enum.Parse(typeof(SequenceType), state.TryGet("Type", "Path"), true)));
        }
Beispiel #9
0
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var name = state.AffixName(state.TryGet("Name", "Index", true));

            var scopeOffset = Math.Abs(state.TryGet("Scope", -1, true));

            return(new SimpleFieldMapper(name, ctx =>
            {
                if (scopeOffset == 0)
                {
                    return ctx.GlobalIndex;
                }

                var p = ctx;
                for (var i = 0; i < scopeOffset && p != null; i++)
                {
                    p = p.Parent;
                }
                if (p != null)
                {
                    return ctx.Index(p);
                }

                return 0;
            }, typeof(int), FieldType.Dimension));
        }
            public IFieldMapper Parse(JobParser parser, ParseState state)
            {
                var selector = state.TryGet("Select", DefaultPath, true);

                if (selector.StartsWith("/"))
                {
                    selector = DefaultPath + selector;
                }

                var getter = parser.CompileGetter(typeof(T), selector);

                var name      = state.TryGet("Name", DefaultName ?? SuggestName(getter.SuggestedName));
                var fieldType = (FieldType)Enum.Parse(typeof(FieldType), state.TryGet("Type", "Dimension"), true);


                IFieldMapper mapper = new SimpleFieldMapper(state.AffixName(name),
                                                            scope => SelectItem(scope).TryGet(item => getter.Getter(item, scope), getter.DefaultValue),
                                                            getter.ValueType, fieldType);

                var labelState = state.Select("Labels");

                if (labelState != null)
                {
                    var labels = labelState.Keys.ToDictionary(labelState.AffixName, key =>
                                                              (ILabelProvider)
                                                              new SitecoreFieldLabelProvider(labelState.TryGet <string>(key), parser.DefaultLanguage));
                    if (labels.Count > 0)
                    {
                        return(new LabeledFieldMapper(mapper, labels));
                    }
                }

                return(mapper);
            }
Beispiel #11
0
        public void JobParserTestMethod()
        {
            bool    extraMargin = true;
            bool    taxExempt   = false;
            string  description = "envelopes";
            decimal price       = 556.40m;

            JobParser job1 = new JobParser("../../JobFiles/Job1.txt");

            job1.LoadJobElements();

            JobComponents temp = job1.getJob(0);

            Assert.AreEqual(description, temp.getJobType);
            Assert.AreEqual(extraMargin, temp.getIsExtraMargin);
            Assert.AreEqual(price, temp.getPrice);
            Assert.AreEqual(taxExempt, temp.getIsTaxExempt);

            extraMargin = true;
            taxExempt   = true;
            description = "letterhead";
            price       = 1983.37m;

            temp = job1.getJob(1);

            Assert.AreEqual(description, temp.getJobType);
            Assert.AreEqual(extraMargin, temp.getIsExtraMargin);
            Assert.AreEqual(price, temp.getPrice);
            Assert.AreEqual(taxExempt, temp.getIsTaxExempt);
        }
            public ISplitter Parse(JobParser parser, ParseState state)
            {
                var pageIdString = state.TryGet <string>("PageId", mainParameter: true);

                var includeSelf = state.TryGet("IncludePage", false);

                var pageId = pageIdString != null?Guid.Parse(pageIdString) : (Guid?)null;

                return(new PageConditionSplitter((context, page) =>
                {
                    var thisPageId = pageId;
                    if (!thisPageId.HasValue && context != null)
                    {
                        var e = context.Current <PageData>();
                        if (e != null)
                        {
                            thisPageId = e.Item.Id;
                        }
                        else
                        {
                            var d = context.Current <DimensionData>();
                            if (d != null)
                            {
                                Guid result;
                                thisPageId = Guid.TryParse(d.DimensionKey, out result) ? result : (Guid?)null;
                            }
                        }
                    }

                    return thisPageId.HasValue && page.Item.Id == thisPageId;
                }, includeMatchBefore: !includeSelf));
            }
        public static GetterInfo CompileGetter(this JobParser parser, Type type, string selector, Language language = null)
        {
            var slash = selector.IndexOf('/');

            var path    = (slash != -1 ? selector.Substring(0, slash) : selector).Split(new[] { "." }, StringSplitOptions.RemoveEmptyEntries);
            var scField = slash != -1 ? selector.Substring(slash + 1) : null;

            Type valueType;
            var  valueGetter = CompileGetter(type, path, out valueType);

            Func <object, ProcessingScope, object> getter = (item, scope) => valueGetter(item);


            if (!string.IsNullOrEmpty(scField))
            {
                valueType = typeof(string);
                getter    =
                    (item, scope) =>
                    valueGetter(item).TryGet(id => scope.FieldLookup.TryGet(lu => lu.Lookup(id, scField, language)));
            }

            return(new GetterInfo
            {
                Path = path,
                SitecoreField = scField,
                Type = type,
                ValueType = valueType,
                Getter = getter
            });
        }
Beispiel #14
0
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var splitter = parser.ParseSplitter(state.Select("Splitter") ?? state);

            return(new SplittingFieldMapper(splitter, postfix =>
                                            state.Postfix(postfix).SelectMany("Fields").Select(parser.ParseFieldMapper).ToArray()
                                            ));
        }
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var factTypes = XaFactsFieldFactory.ParseFactTypes(state.TryGet("Types", new string[0], true));

            var prefix = state.TryGet <string>("Prefix");

            return(new FactsMapper(factTypes, state.Prefix(prefix).AffixName, state.TryGet("EntireVisit", false)));
        }
Beispiel #16
0
        public void JobParser_ValidJobWithParent_ShouldParse()
        {
            IJobParser parser = new JobParser();
            var        result = parser.Parse("A => B");

            Assert.AreEqual(result.JobId, "A");
            Assert.AreEqual(result.DependantJobId, "B");
        }
Beispiel #17
0
        /// <summary>
        /// Do the lookup!
        /// </summary>
        protected override void ProcessRecord()
        {
            // Setup for verbosity if we need it.
            var listener = new PSListener(this);

            Trace.Listeners.Add(listener);
            try
            {
                PandaTask t            = null;
                bool      needdatasets = OutputContainerNames.IsPresent || InputContainerNames.IsPresent;

                if (ParameterSetName == "TaskID")
                {
                    t = TaskID.FindPandaJobWithTaskName(needdatasets);
                }
                if (ParameterSetName == "TaskObject")
                {
                    t = PandaTaskObject.ID.FindPandaJobWithTaskName(needdatasets);
                }
                if (ParameterSetName == "TaskName")
                {
                    t = TaskName.FindPandaJobWithTaskName(needdatasets);
                }
                if (ParameterSetName == "DatasetGRIDJob")
                {
                    // Get the job and resulting dataset name.
                    var job = JobParser.FindJob(JobName, JobVersion);
                    var ds  = job.ResultingDataSetName(DatasetName.Trim(), JobIteration);

                    // Now, look up the job itself.
                    t = (ds + "/").FindPandaJobWithTaskName();
                }

                // We really can't deal with a bad task below. The returned objects are sufficiently complex.
                if (t == null)
                {
                    throw new ArgumentException("Unable to find the task in panda: was it ever submitted?");
                }

                // Dump the info to the output pipeline as requested.
                if (JobStatus.IsPresent)
                {
                    WriteObject(t.status);
                }
                if (InputContainerNames.IsPresent)
                {
                    WriteObject(t.DataSetNamesIN());
                }
                if (OutputContainerNames.IsPresent)
                {
                    WriteObject(t.DataSetNamesOUT());
                }
            } finally
            {
                Trace.Listeners.Remove(listener);
            }
        }
Beispiel #18
0
            public IDataFilter Parse(JobParser parser, ParseState state)
            {
                var p      = state.Require <double>("Percentage", mainParameter: true);
                var offset = state.TryGet("Offset", 0d);

                var filter = new MongoRandomSampleFilter(Math.Max(0, offset), Math.Min(1, offset + p));

                return(filter);
            }
Beispiel #19
0
        /// <summary>
        /// Process a single dataset and fetch the info about it.
        /// </summary>
        protected override void ProcessRecord()
        {
            var trimmedDSName = DatasetName.Trim();

            if (_resultsCache.Value[trimmedDSName] is PSGRIDDatasetInfo cHit)
            {
                WriteObject(cHit);
            }
            else
            {
                // Setup for verbosity if we need it.
                var listener = new PSListener(this);
                Trace.Listeners.Add(listener);
                try
                {
                    // Where are we going to be doing query on - we need a machine.
                    var sm = JobParser.GetSubmissionMachine();

                    // Get the remove environment configured if it needs to be
                    if (_connection == null)
                    {
                        _connection = new SSHConnection(sm.MachineName, sm.UserName);
                        _connection
                        .Apply(() => DisplayStatus("Setting up ATLAS"))
                        .setupATLAS()
                        .Apply(() => DisplayStatus("Setting up Rucio"))
                        .setupRucio(_gridCredentials.Username)
                        .Apply(() => DisplayStatus("Acquiring GRID credentials"))
                        .VomsProxyInit("atlas", failNow: () => Stopping);
                    }

                    // Great - get the info on this dataset.
                    var fileInfo = _connection
                                   .Apply(() => DisplayStatus($"Checking for info on {trimmedDSName}."))
                                   .FileInfoFromGRID(trimmedDSName, failNow: () => Stopping);

                    // Next, build the resulting thingy.
                    var r = new PSGRIDDatasetInfo()
                    {
                        DatasetName = trimmedDSName,
                        nFiles      = fileInfo.Count,
                        TotalSizeMB = (int)fileInfo.Sum(fi => fi.size),
                        FileInfo    = fileInfo.ToArray()
                    };
                    _resultsCache.Value[trimmedDSName] = r;
                    using (var pp = listener.PauseListening())
                    {
                        WriteObject(r);
                    }
                }
                finally
                {
                    Trace.Listeners.Remove(listener);
                }
            }
        }
 protected override IFieldMapper Parse(Func<ProcessingScope, DateTime?> selector, string defaultName,
     JobParser parser, ParseState state)
 {
     return new TimeDimension(
         state.AffixName(state.TryGet("Name", defaultName + "Time")),
         selector,
         inlineFields: state.TryGet<bool>("Inline"),
         cultureInfo: parser.DefaultLanguage.CultureInfo,
         detailLevel: state.TryGet("Resolution", TimeDetailLevel.Hour, true));
 }
Beispiel #21
0
 protected override IFieldMapper Parse(Func <ProcessingScope, DateTime?> selector, string defaultName,
                                       JobParser parser, ParseState state)
 {
     return(new TimeDimension(
                state.AffixName(state.TryGet("Name", defaultName + "Time")),
                selector,
                inlineFields: state.TryGet <bool>("Inline"),
                cultureInfo: parser.DefaultLanguage.CultureInfo,
                detailLevel: state.TryGet("Resolution", TimeDetailLevel.Hour, true)));
 }
Beispiel #22
0
        /// <summary>
        /// Create a new instance of RepairInfo.
        /// </summary>
        /// <param name="nodes">Collection of HtmlNodes with relevant information.</param>
        public RepairInfo(HtmlNodeCollection nodes)
        {
            var repair    = nodes[2].LastChild.InnerText;
            var jobString = repair.Substring(0, repair.IndexOf(" "));
            var lvString  = repair.Substring(repair.LastIndexOf(" ") + 1);
            var grade     = nodes[3].LastChild.InnerText[6].ToString();

            Job           = JobParser.Parse(jobString);
            Level         = int.Parse(lvString);
            MaterialGrade = int.Parse(grade);
        }
Beispiel #23
0
        public IFieldMapper Parse(JobParser parser, ParseState state)
        {
            var dimension = state.ParseDimension();

            var keyName   = state.AffixName(state.TryGet("KeyName", () => dimension.GetType().Name + "Key"));
            var labelName = state.AffixName(state.TryGet("LabelName", () => dimension.GetType().Name + "Label"));


            return(new LabeledFieldMapper(new XaFieldMapper(dimension, false, keyName), labelName,
                                          XaLabelProvider.FromDimension(dimension, parser.DefaultLanguage), friendlyName: XaFieldMapper.SuggestFriendlyLabelName(labelName)));
        }
Beispiel #24
0
        IDataFilter IParseFactory <IDataFilter> .Parse(JobParser parser, ParseState state)
        {
            var splitter = parser.ParseSplitter(state.Select("Splitter") ?? state);
            var filter   = splitter as IDataFilter;

            if (filter == null)
            {
                throw new Exception(filter.GetType().Name + " does not implement IDataFilter");
            }

            return(filter);
        }
        public IDataFilter Parse(JobParser parser, ParseState state)
        {
            using (new SecurityDisabler())
            {
                var ruleContextItem = parser.Database.GetRootItem(parser.DefaultLanguage);

                var json = state.TryGet <string>("Rule");
                if (!string.IsNullOrEmpty(json))
                {
                    var filter = RulesFilter.FromString(json);
                    filter.RuleContextItem = ruleContextItem;
                    return(filter);
                }


                var  ruleItem = state.Require <string>("Item", true);
                Item item;
                ID   id;
                if (!ID.TryParse(ruleItem, out id))
                {
                    if (!ruleItem.StartsWith("/"))
                    {
                        var rootItem =
                            state.Parser.Database.GetItem(
                                ExperienceExtractorApiContainer.ItemPaths.GetOrDefault("experienceAnalyticsFilters") ??
                                "/sitecore/system/Marketing Control Panel/Experience Analytics/Filters");

                        ruleItem = rootItem.Paths.FullPath + "/" + ruleItem;
                    }


                    item = parser.Database.GetItem(ruleItem, parser.DefaultLanguage);
                }
                else
                {
                    item = parser.Database.GetItem(id, parser.DefaultLanguage);
                }



                if (item == null)
                {
                    throw ParseException.AttributeError(state, string.Format("Rule item not found '{0}'", ruleItem));
                }

                var rules = RuleFactory.GetRules <RuleContext>(item.Fields["Rule"]);

                return(new RulesFilter(rules)
                {
                    RuleContextItem = ruleContextItem
                });
            }
        }
            public ISplitter Parse(JobParser parser, ParseState state)
            {
                var testIdString = state.Require <string>("TestId", true);

                Guid testId;

                if (!Guid.TryParse(testIdString, out testId))
                {
                    throw state.AttributeError("Invalid test id specified ({0})", testIdString);
                }

                return(new MvTestSplitter(testId));
            }
 protected override IFieldMapper Parse(Func<ProcessingScope, DateTime?> selector, string defaultName,
     JobParser parser, ParseState state)
 {           
     return new DateDimension(
             state.AffixName(state.TryGet("Name", defaultName)),
             selector,
             useDateForKey: state.TryGet("DateKey", true),
             inlineFields: state.TryGet("Inline", false),                    
             cultureInfo: parser.DefaultLanguage.CultureInfo,
             key: state.TryGet("Key", false),
             detailLevel:
                  state.TryGet("Resolution", DateDetailLevel.Date, true));
 }
 protected override IFieldMapper Parse(Func <ProcessingScope, DateTime?> selector, string defaultName,
                                       JobParser parser, ParseState state)
 {
     return(new DateDimension(
                state.AffixName(state.TryGet("Name", defaultName)),
                selector,
                useDateForKey: state.TryGet("DateKey", true),
                inlineFields: state.TryGet("Inline", false),
                cultureInfo: parser.DefaultLanguage.CultureInfo,
                key: state.TryGet("Key", false),
                detailLevel:
                state.TryGet("Resolution", DateDetailLevel.Date, true)));
 }
Beispiel #29
0
 public IFieldMapper Parse(JobParser parser, ParseState state)
 {
     return(new SimpleFieldMapper(state.AffixName("ContactId"), scope => scope.Current <IVisitAggregationContext>().TryGet(ctx => ctx.Visit.ContactId), typeof(Guid),
                                  valueKind: "ContactId",
                                  calculatedFields: new[]
     {
         new CalculatedField {
             Name = "Unique visitors",
             DaxPattern = string.Format("DISTINCTCOUNT([{0}])", state.AffixName("ContactId")),
             ChildDaxPattern = string.Format("CALCULATE(DISTINCTCOUNT(@Parent[{0}]), @TableName)", state.AffixName("ContactId")),
             FormatString = CalculatedFieldFormat.Integer
         }
     }));
 }
Beispiel #30
0
            public IDataSource Parse(JobParser parser, ParseState state)
            {
                var connectionString = state.TryGet("connection", ExperienceExtractorWebApiConfig.XdbConnectionString, true);

                if (!connectionString.StartsWith("mongodb://"))
                {
                    var connection = ConfigurationManager.ConnectionStrings[connectionString];
                    if (connection == null)
                    {
                        throw state.AttributeError("Connection string '{0}' not found", connectionString);
                    }
                    connectionString = connection.ConnectionString;
                }

                var source = new MongoDbVisitAggregationContextSource(new MongoDbDriver(connectionString), ExperienceExtractorWebApiConfig.JobExecutionSettings.LoadThreads);

                //source.SecondaryLookup = state.TryGet("SecondaryLookup", false);

                var index = state.TryGet <string>("index");

                if (!string.IsNullOrEmpty(index))
                {
                    source.CursorInitializing += (sender, cursor) =>
                    {
                        if (index == "$natural")
                        {
                            cursor.SetSortOrder(SortBy.Ascending("$natural"));
                        }
                        else
                        {
                            cursor.SetHint(index);
                        }
                    };
                }

                var fields = state.TryGet("fields", new string[0]);

                if (fields.Length > 0)
                {
                    source.CursorInitializing += (sender, cursor) => cursor.SetFields(fields);
                }


                foreach (var filter in state.SelectMany("Filters"))
                {
                    source.Filters.Add(parser.ParseDataFilter(filter));
                }

                return(source);
            }
Beispiel #31
0
            public IDataFilter Parse(JobParser parser, ParseState state)
            {
                var start = state.TryGet <DateTime?>("Start");
                var end   = state.TryGet <DateTime?>("End");

                if (!start.HasValue && !end.HasValue)
                {
                    throw ParseException.AttributeError(state, "Expected start and/or end");
                }

                var field = state.TryGet("Field", "StartDateTime");

                return(new MongoDateRangeFilter(start, end, field));
            }
Beispiel #32
0
        static void ProcessJobs(int index)
        {
            Console.WriteLine("\nJob {0} Output\n", index);
            JobParser job1 = new JobParser($"../../JobFiles/Job{index}.txt");

            job1.LoadJobElements();

            JobComponents        temp = job1.getJob(0);
            List <JobComponents> test = job1.getJobAllElements().ToList();

            JobCalculator pCalc = new JobCalculator(temp, test);

            pCalc.DumpOutput(index);
        }