1074982726

Build Type

push

github

Committed by Thomas Nind

Commit Message

Merge branch 'develop' of https://github.com/HicServices/RDMP into develop

Run Details

9439 of 18787 branches covered (50.24%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 4 files covered. (85.71%)

329 existing lines in 15 files now uncovered.

26119 of 43619 relevant lines covered (59.88%)

3384.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.89

/Rdmp.Core/Logging/PastEvents/ArchivalDataLoadInfo.cs

// Copyright (c) The University of Dundee 2018-2019
// This file is part of the Research Data Management Platform (RDMP).
// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.Data.Common;
using FAnsi.Discovery;
using ReusableLibraryCode.Settings;

namespace Rdmp.Core.Logging.PastEvents
{
    /// <summary>
    /// Readonly historical version of DataLoadInfo.  The central hierarchical RDMP logging database records activites across all areas of the program in a central
    /// place.  You can process these records programatically via LogManager.  This class contains public properties for each of the sub concepts (Errors, Progress
    /// messages, Tables loaded etc).  See Logging.cd for more information
    /// </summary>
    public class ArchivalDataLoadInfo : IArchivalLoggingRecordOfPastEvent, IComparable
    {
        private readonly DiscoveredDatabase _loggingDatabase;

        public int ID { get; private set; }
        public int DataLoadTaskID { get; set; }
        public const int MaxDescriptionLength = 300;

        public DateTime StartTime { get; private set; }
        public DateTime? EndTime { get; private set; }

        public bool HasErrors { get; private set; }

        public string ToShortString()
        {
            var s = ToString();
            if (s.Length > ArchivalDataLoadInfo.MaxDescriptionLength)
                return s.Substring(0, ArchivalDataLoadInfo.MaxDescriptionLength) + "...";
            return s;
        }

        public override string ToString()
        {
            string elapsed = "";
            if (EndTime != null)
            {
                var ts = EndTime.Value.Subtract(StartTime);
                elapsed = " (" + ts.ToString(@"hh\:mm\:ss")+ ")";
            }

            return Description + "(ID="+ID +") - " + StartTime + " - " + (EndTime != null ? EndTime.ToString() : "<DidNotFinish>") + elapsed;
        }

    
        /// <summary>
        /// All tables loaded during the run
        /// </summary>
        public List<ArchivalTableLoadInfo>  TableLoadInfos { get { return _knownTableInfos.Value; }}
        /// <summary>
        /// All errors that occured during the run
        /// </summary>
        public List<ArchivalFatalError> Errors { get { return _knownErrors.Value; } }
        /// <summary>
        /// All progress messages recorded during the run
        /// </summary>
        public List<ArchivalProgressLog> Progress { get { return _knownProgress.Value; } }

        readonly Lazy<List<ArchivalTableLoadInfo>> _knownTableInfos;
        readonly Lazy<List<ArchivalFatalError>> _knownErrors;
        readonly Lazy<List<ArchivalProgressLog>> _knownProgress;
        
        public string Description { get; set; }
        
        internal ArchivalDataLoadInfo(DbDataReader r,DiscoveredDatabase loggingDatabase)
        {
            _loggingDatabase = loggingDatabase;
            ID = Convert.ToInt32(r["ID"]);
            DataLoadTaskID = Convert.ToInt32(r["dataLoadTaskID"]);
            
            //populate basic facts from the table
            StartTime = (DateTime)r["startTime"];
            if (r["endTime"] == null || r["endTime"] == DBNull.Value)
                EndTime = null;
            else
                EndTime = Convert.ToDateTime(r["endTime"]);

            Description = r["description"] as string;

            HasErrors = r["hasErrors"] != DBNull.Value;

            _knownTableInfos = new Lazy<List<ArchivalTableLoadInfo>>(GetTableInfos);
            _knownErrors = new Lazy<List<ArchivalFatalError>>(GetErrors);
            _knownProgress = new Lazy<List<ArchivalProgressLog>>(GetProgress);
        }


        public int CompareTo(object obj)
        {
            var other = obj as ArchivalDataLoadInfo;
            if (other != null)
                if (StartTime == other.StartTime)
                    return 0;
                else
                    return StartTime > other.StartTime ? 1 : -1;

            return System.String.Compare(ToString(), obj.ToString(), System.StringComparison.Ordinal);
        }

        private List<ArchivalTableLoadInfo> GetTableInfos()
        {
            List<ArchivalTableLoadInfo> toReturn = new List<ArchivalTableLoadInfo>();

            using (var con = _loggingDatabase.Server.GetConnection())
            {
                con.Open();

                using(var cmd =  _loggingDatabase.Server.GetCommand("SELECT * FROM TableLoadRun WHERE dataLoadRunID=" +ID , con))
                    using(var r = cmd.ExecuteReader())
                        while(r.Read())
                        {
                            var audit = new ArchivalTableLoadInfo(this, r, _loggingDatabase);
                        
                            if((audit.Inserts??0) <= 0 && (audit.Updates??0) <= 0 && (audit.Deletes??0) <= 0 && UserSettings.HideEmptyTableLoadRunAudits)
                            {
                                continue;
                            }
                            else
                            {
                                toReturn.Add(audit);
                            }
                        }   
            }

            return toReturn;
        }

        private List<ArchivalProgressLog> GetProgress()
        {
            List<ArchivalProgressLog> toReturn = new List<ArchivalProgressLog>();

            using (var con = _loggingDatabase.Server.GetConnection())
            {
                con.Open();

                using (var cmd = _loggingDatabase.Server.GetCommand("SELECT * FROM ProgressLog WHERE dataLoadRunID=" + ID, con))
                    using (var r = cmd.ExecuteReader())
                        while (r.Read())
                            toReturn.Add(new ArchivalProgressLog(r));
            }

            return toReturn;
        }

        private List<ArchivalFatalError> GetErrors()
        {
            List<ArchivalFatalError> toReturn = new List<ArchivalFatalError>();

            using (var con = _loggingDatabase.Server.GetConnection())
            {
                con.Open();

                using(var cmd = _loggingDatabase.Server.GetCommand("SELECT * FROM FatalError WHERE dataLoadRunID=" + ID, con))
                    using(var r = cmd.ExecuteReader())
                        while (r.Read())
                            toReturn.Add(new ArchivalFatalError(r));
            }

            return toReturn;
        }
    }
}

1	// Copyright (c) The University of Dundee 2018-2019
2	// This file is part of the Research Data Management Platform (RDMP).
3	// RDMP is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
4	// RDMP is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
5	// You should have received a copy of the GNU General Public License along with RDMP. If not, see <https://www.gnu.org/licenses/>.
6
7	using System;
8	using System.Collections.Generic;
9	using System.Data.Common;
10	using FAnsi.Discovery;
11	using ReusableLibraryCode.Settings;
12
13	namespace Rdmp.Core.Logging.PastEvents
14	{
15	/// <summary>
16	/// Readonly historical version of DataLoadInfo. The central hierarchical RDMP logging database records activites across all areas of the program in a central
17	/// place. You can process these records programatically via LogManager. This class contains public properties for each of the sub concepts (Errors, Progress
18	/// messages, Tables loaded etc). See Logging.cd for more information
19	/// </summary>
20	public class ArchivalDataLoadInfo : IArchivalLoggingRecordOfPastEvent, IComparable
21	{
22	private readonly DiscoveredDatabase _loggingDatabase;
23
24	public int ID { get; private set; }	25✔
25	public int DataLoadTaskID { get; set; }	10✔
26	public const int MaxDescriptionLength = 300;
27
28	public DateTime StartTime { get; private set; }	16✔
29	public DateTime? EndTime { get; private set; }	10✔
30
31	public bool HasErrors { get; private set; }	10✔
32
33	public string ToShortString()
34	{
35	var s = ToString();	×
36	if (s.Length > ArchivalDataLoadInfo.MaxDescriptionLength)	×
37	return s.Substring(0, ArchivalDataLoadInfo.MaxDescriptionLength) + "...";	×
UNCOV 38	return s;	×
39	}
40
41	public override string ToString()
42	{
43	string elapsed = "";	×
UNCOV 44	if (EndTime != null)	×
45	{
46	var ts = EndTime.Value.Subtract(StartTime);	×
UNCOV 47	elapsed = " (" + ts.ToString(@"hh\:mm\:ss")+ ")";	×
48	}
49
UNCOV 50	return Description + "(ID="+ID +") - " + StartTime + " - " + (EndTime != null ? EndTime.ToString() : "<DidNotFinish>") + elapsed;	×
51	}
52
53
54	/// <summary>
55	/// All tables loaded during the run
56	/// </summary>
57	public List<ArchivalTableLoadInfo> TableLoadInfos { get { return _knownTableInfos.Value; }}	6✔
58	/// <summary>
59	/// All errors that occured during the run
60	/// </summary>
61	public List<ArchivalFatalError> Errors { get { return _knownErrors.Value; } }	9✔
62	/// <summary>
63	/// All progress messages recorded during the run
64	/// </summary>
65	public List<ArchivalProgressLog> Progress { get { return _knownProgress.Value; } }	8✔
66
67	readonly Lazy<List<ArchivalTableLoadInfo>> _knownTableInfos;
68	readonly Lazy<List<ArchivalFatalError>> _knownErrors;
69	readonly Lazy<List<ArchivalProgressLog>> _knownProgress;
70
71	public string Description { get; set; }	10✔
72
73	internal ArchivalDataLoadInfo(DbDataReader r,DiscoveredDatabase loggingDatabase)	10✔
74	{
75	_loggingDatabase = loggingDatabase;	10✔
76	ID = Convert.ToInt32(r["ID"]);	10✔
77	DataLoadTaskID = Convert.ToInt32(r["dataLoadTaskID"]);	10✔
78
79	//populate basic facts from the table
80	StartTime = (DateTime)r["startTime"];	10✔
81	if (r["endTime"] == null \|\| r["endTime"] == DBNull.Value)	10!
UNCOV 82	EndTime = null;	×
83	else
84	EndTime = Convert.ToDateTime(r["endTime"]);	10✔
85
86	Description = r["description"] as string;	10✔
87
88	HasErrors = r["hasErrors"] != DBNull.Value;	10✔
89
90	_knownTableInfos = new Lazy<List<ArchivalTableLoadInfo>>(GetTableInfos);	10✔
91	_knownErrors = new Lazy<List<ArchivalFatalError>>(GetErrors);	10✔
92	_knownProgress = new Lazy<List<ArchivalProgressLog>>(GetProgress);	10✔
93	}	10✔
94
95
96	public int CompareTo(object obj)
97	{
98	var other = obj as ArchivalDataLoadInfo;	×
99	if (other != null)	×
100	if (StartTime == other.StartTime)	×
UNCOV 101	return 0;	×
102	else
UNCOV 103	return StartTime > other.StartTime ? 1 : -1;	×
104
UNCOV 105	return System.String.Compare(ToString(), obj.ToString(), System.StringComparison.Ordinal);	×
106	}
107
108	private List<ArchivalTableLoadInfo> GetTableInfos()
109	{
110	List<ArchivalTableLoadInfo> toReturn = new List<ArchivalTableLoadInfo>();	5✔
111
112	using (var con = _loggingDatabase.Server.GetConnection())	5✔
113	{
114	con.Open();	5✔
115
116	using(var cmd = _loggingDatabase.Server.GetCommand("SELECT * FROM TableLoadRun WHERE dataLoadRunID=" +ID , con))	5✔
117	using(var r = cmd.ExecuteReader())	5✔
118	while(r.Read())	8✔
119	{
120	var audit = new ArchivalTableLoadInfo(this, r, _loggingDatabase);	3✔
121
122	if((audit.Inserts??0) <= 0 && (audit.Updates??0) <= 0 && (audit.Deletes??0) <= 0 && UserSettings.HideEmptyTableLoadRunAudits)	3!
123	{
124	continue;
125	}
126	else
127	{
128	toReturn.Add(audit);	3✔
129	}
130	}
131	}
132
133	return toReturn;	5✔
134	}
135
136	private List<ArchivalProgressLog> GetProgress()
137	{
138	List<ArchivalProgressLog> toReturn = new List<ArchivalProgressLog>();	4✔
139
140	using (var con = _loggingDatabase.Server.GetConnection())	4✔
141	{
142	con.Open();	4✔
143
144	using (var cmd = _loggingDatabase.Server.GetCommand("SELECT * FROM ProgressLog WHERE dataLoadRunID=" + ID, con))	4✔
145	using (var r = cmd.ExecuteReader())	4✔
146	while (r.Read())	7✔
147	toReturn.Add(new ArchivalProgressLog(r));	3✔
148	}
149
150	return toReturn;	4✔
151	}
152
153	private List<ArchivalFatalError> GetErrors()
154	{
155	List<ArchivalFatalError> toReturn = new List<ArchivalFatalError>();	5✔
156
157	using (var con = _loggingDatabase.Server.GetConnection())	5✔
158	{
159	con.Open();	5✔
160
161	using(var cmd = _loggingDatabase.Server.GetCommand("SELECT * FROM FatalError WHERE dataLoadRunID=" + ID, con))	5✔
162	using(var r = cmd.ExecuteReader())	5✔
163	while (r.Read())	6✔
164	toReturn.Add(new ArchivalFatalError(r));	1✔
165	}
166
167	return toReturn;	5✔
168	}
169	}
170	}

HicServices / RDMP / 1074982726

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous