/// <summary>
        /// Performs an event frame search based on a query string
        /// </summary>
        /// <param name="query">Valid AF query</param>
        /// <param name="pageSize">Pagesize (Defaults to 1000)</param>
        private void RunEFQuery(string query, int pageSize = 1000)
        {
            AFDatabase db = Fixture.AFDatabase;

            using (var search = new AFEventFrameSearch(
                       database: db,
                       name: "EFQueryTest",
                       query: query))
            {
                int startIndex = 0;

                var coll                = search.FindObjects(startIndex: startIndex, pageSize: pageSize);
                int totalEFExamined     = 0;
                int valuesCapturedCount = 0;
                foreach (AFEventFrame ef in coll)
                {
                    totalEFExamined++;

                    if (ef.AreValuesCaptured)
                    {
                        valuesCapturedCount++;
                    }
                }

                Output.WriteLine($"Found {totalEFExamined} Event Frames in [{db.GetPath()}] for a query of [{query}].");
                Output.WriteLine($"{valuesCapturedCount} Event Frame's AreValuesCaptured are true.");
            }
        }
Beispiel #2
0
        /// <summary>
        /// Remove the event frame by name if it exists.
        /// </summary>
        /// <param name="name">The name of the event frame to remove.</param>
        /// <param name="output">The output logger used for writing messages.</param>
        public void RemoveEventFrameIfExists(string name, ITestOutputHelper output)
        {
            Contract.Requires(output != null);

            AFEventFrame preCheckEventFrame = null;

            using (var search = new AFEventFrameSearch(AFDatabase, string.Empty, $"Name:'{name}'"))
            {
                var searchResults = new AFNamedCollectionList <AFEventFrame>(search.FindObjects());
                if (searchResults.Count > 0)
                {
                    preCheckEventFrame = searchResults.First();
                }
            }

            if (preCheckEventFrame?.Name.Equals(name, StringComparison.OrdinalIgnoreCase) ?? false)
            {
                output.WriteLine($"Event Frame [{preCheckEventFrame}] exists, delete it.");
                preCheckEventFrame.Delete();
                preCheckEventFrame.CheckIn();
            }
            else
            {
                output.WriteLine($"Event Frame [{name}] does not exist, can not be deleted.");
            }
        }
        public static void PrintReport(AFDatabase database, AFElementTemplate eventFrameTemplate)
        {
            if (database == null)
            {
                throw new ArgumentNullException(nameof(database));
            }
            if (eventFrameTemplate == null)
            {
                throw new ArgumentNullException(nameof(eventFrameTemplate));
            }
            AFTime startTime   = DateTime.Today.AddDays(-7);
            AFTime endTime     = startTime.LocalTime.AddDays(+8); // Or DateTime.Today.AddDays(1);
            string queryString = $"template:'{eventFrameTemplate.Name}' ElementName:Meter003";

            using (AFEventFrameSearch eventFrameSearch = new AFEventFrameSearch(database, "EventFrame Captures", AFSearchMode.StartInclusive, startTime, endTime, queryString))
            {
                eventFrameSearch.CacheTimeout = TimeSpan.FromMinutes(5);
                foreach (AFEventFrame ef in eventFrameSearch.FindObjects())
                {
                    Console.WriteLine("{0}, {1}, {2}",
                                      ef.Name,
                                      ef.PrimaryReferencedElement.Name,
                                      ef.Attributes["Average Energy Usage"].GetValue().Value);
                }
            }
        }
        public static void CaptureValues(AFDatabase database, AFElementTemplate eventFrameTemplate)
        {
            if (database == null)
            {
                throw new ArgumentNullException(nameof(database));
            }
            if (eventFrameTemplate == null)
            {
                throw new ArgumentNullException(nameof(eventFrameTemplate));
            }

            // Formulate search constraints on time and template
            AFTime startTime   = DateTime.Today.AddDays(-7);
            string queryString = $"template:\"{eventFrameTemplate.Name}\"";

            using (AFEventFrameSearch eventFrameSearch = new AFEventFrameSearch(database, "EventFrame Captures", AFEventFrameSearchMode.ForwardFromStartTime, startTime, queryString))
            {
                eventFrameSearch.CacheTimeout = TimeSpan.FromMinutes(5);
                int count = 0;
                foreach (AFEventFrame item in eventFrameSearch.FindObjects())
                {
                    item.CaptureValues();
                    if ((count++ % 500) == 0)
                    {
                        database.CheckIn();
                    }
                }

                if (database.IsDirty)
                {
                    database.CheckIn();
                }
            }
        }
        public void PrintReportEx5()
        {
            using (StringWriter sw = new StringWriter())
            {
                Console.SetOut(sw);
                var eventFrameTemplate = Ex5WorkingWithEventFramesSln.Program5.CreateEventFrameTemplate(Database);
                Assert.NotNull(eventFrameTemplate);
                Ex5WorkingWithEventFramesSln.Program5.CreateEventFrames(Database, eventFrameTemplate);

                AFTime startTime   = DateTime.Today.AddDays(-7);
                string queryString = $"template:\"{eventFrameTemplate.Name}\"";
                using (AFEventFrameSearch eventFrameSearch = new AFEventFrameSearch(Database, "EventFrame Captures", AFEventFrameSearchMode.ForwardFromStartTime, startTime, queryString))
                {
                    eventFrameSearch.CacheTimeout = TimeSpan.FromMinutes(5);
                    var resp = eventFrameSearch.FindObjects();
                    Assert.True(resp.Any());
                }

                Ex5WorkingWithEventFramesSln.Program5.CaptureValues(Database, eventFrameTemplate);
                Ex5WorkingWithEventFramesSln.Program5.PrintReport(Database, eventFrameTemplate);
                var actual = sw.ToString();
                Assert.Contains("Daily Usage-Meter", actual);
                Assert.Contains(", Meter003,", actual);
            }
        }
        public void EventFrameSearchTest()
        {
            AFDatabase db = Fixture.AFDatabase;

            string baseEFNameText      = $"OSIsoftTests_AF_EFSrchTst - {DateTime.UtcNow.ToString(AFFixture.DateTimeFormat, CultureInfo.InvariantCulture)}_";
            string ef1Name             = $"{baseEFNameText}EF1";
            string ef2Name             = $"{baseEFNameText}EF2";
            string ef3Name             = $"{baseEFNameText}LastEF";
            string eventFrameSearchTxt = $"'{baseEFNameText}EF*'";

            try
            {
                Output.WriteLine($"Create Event Frames for search.");
                _ = new AFEventFrame(db, ef1Name);
                _ = new AFEventFrame(db, ef2Name);
                _ = new AFEventFrame(db, ef3Name);
                db.CheckIn();

                Output.WriteLine($"Execute search for Event Frames using search string [{eventFrameSearchTxt}].");
                db = Fixture.ReconnectToDB(); // This operation clears AFSDK cache and assures retrieval from AF server
                using (var searchResults = new AFEventFrameSearch(db, string.Empty, eventFrameSearchTxt))
                {
                    int       actualEventsFramesFound = searchResults.GetTotalCount();
                    const int ExpectedEventFrames     = 2;
                    Assert.True(actualEventsFramesFound == ExpectedEventFrames, $"Search string [{eventFrameSearchTxt}] found " +
                                $"{actualEventsFramesFound} Event Frames, expected {ExpectedEventFrames}.");

                    int actualEventFramesFoundWithSearch = 0;
                    foreach (AFEventFrame at in searchResults.FindObjects())
                    {
                        actualEventFramesFoundWithSearch++;
                    }

                    Assert.True(actualEventFramesFoundWithSearch == ExpectedEventFrames,
                                $"Only able to find {actualEventFramesFoundWithSearch} Elements returned using Search string " +
                                $"[{eventFrameSearchTxt}], expected {ExpectedEventFrames}.");
                }
            }
            finally
            {
                Fixture.RemoveEventFrameIfExists(ef1Name, Output);
                Fixture.RemoveEventFrameIfExists(ef2Name, Output);
                Fixture.RemoveEventFrameIfExists(ef3Name, Output);
            }
        }