ReportingDashboard

Solution 'ReportingDashboard' (1 project)
Reporting Dashboard
    [+] Properties
    [+] References
App_Data
    [+] Common
   AbstractRepoBase.cs
   enumReportType.cs
   SqlCcc.cs
   XmlPoco.cs
    [+] Content
    [-] Controllers
   AccountController.cs
   DocumentationController.cs
   HomeController.cs
   ReportController.cs
    [+] Database
    [+] Interfaces
    [-] Models
          AccountModels.cs
          DocumentationModels.cs
          ReportModels.cs
    [+] Repositories
    [+] Scripts
    [+] Views
[+] Account
[+] Documentation
[-] Home
   About.aspx
   Index.aspx
   Requirements.aspx
[-] Report
   Detail.aspx
   Index.aspx
[-] Shared
Error.aspx
LogOnUserControl.ascx
Site.Master
   Web.config
    [-] Global.asax
   Global.asax.cs
    [-] Web.config
   Web.Debug.config
   Web.Release.config

ReportingDashboard.Controllers.ReportController.cs

using System.Collections.Generic;                   // List
using System.Web.Mvc;                               /* ActionResult, View,
                                                    ViewData, ViewResult, Controller, [HttpPost]
                                                    */
using ReportingDashboard.Database_Controllers;   // ReportRepository
using ReportingDashboard.Models;                 // ReportModel

namespace ReportingDashboard.Controllers
{
    public class MetaReportObject : ViewResult
    {
        public List<ReportModel> AllReports { get; set; }
    }
    public class ReportController : Controller
    {
        ReportRepository repo = new ReportRepository();

        // GET: /Report/
        public ActionResult Index()
        {
            ViewData["Message"] = "Welcome to ASP.NET MVC!";

            var reportMetaObj = new MetaReportObject { AllReports = repo.GetAllReportRecords() };

            return View(reportMetaObj);
        }

        // GET: /Report/Details/5
        public ActionResult Details(int id)
        {
            ReportModel record = repo.GetReportById(id);

            return View(record);
        }

        // GET: /Report/Create
        public ActionResult Create()
        {
            return View();
        }

        // POST: /Report/Create
        [HttpPost]
        public ActionResult Create(FormCollection collection)
        {
            try
            {
                // TODO: Add insert logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
       
        // GET: /Report/Edit/5
        public ActionResult Edit(int id)
        {
            return View();
        }

        // POST: /Report/Edit/5
        [HttpPost]
        public ActionResult Edit(int id, FormCollection collection)
        {
            try
            {
                // TODO: Add update logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        // GET: /Report/Delete/5
        public ActionResult Delete(int id)
        {
            return View();
        }

        // POST: /Report/Delete/5
        [HttpPost]
        public ActionResult Delete(int id, FormCollection collection)
        {
            try
            {
                // TODO: Add delete logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }
    }
}

ReportingDashboard.Models.ReportModels.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Security;
using ReportingDashboard.Common;

namespace ReportingDashboard.Models.ReportModels.cs
{
    // for common inheritance
    public class ReportModel
    {
        public int Id { get; set; }
        public ReportType ReportType;
        public string Title;
        public string Status { get; set; }
    }

    #region HL7 Models

    public class HL7RecordCount
    {
        public int Id { get; set; }
        public string Who { get; set; }
        public string What { get; set; }
        public string When { get; set; }
    }
    public class HL7PercentCountDays
    {
        public int Id { get; set; }
        public DateTime Date { get; set; }
    }
    public class HL7DayDif
    {
        public DateTime Date { get; set; }
        public string Dif { get; set; }
    }
    public class HL7PercentCount
    {
        public int Id { get; set; }
        public string Who { get; set; }
        public List<HL7DayDif> DayDifs {get; set;}
    }
    public class HL7Report {
        public string SummationText { get; set; }
        public List<HL7RecordCount> RecordCounts {get; set;}
        public List<HL7PercentCount> PercentCounts {get; set;}
        public List<string> DmisReports {get; set;}
    }
    public class HL7ReportModel : ReportModel
    {
        public string FileLocation { get; set; }
        public List<string> TablesUpdated { get; set; }
        public string TablesUpdatedLocation { get; set; }
        public string RecordDateEnd { get; set; }

        public List<HL7PercentCountDays> PercentCountDays { get; set; }
        public HL7Report Report {get; set;}
    }
    #endregion HL7 Models

    /*
     * <er1:datum xmlns:er1="reportingdashboardreport">
    <er1:id>4</er1:id>
    <er1:title>Data Requests with creation data between 2015-06-07 and 2015-06-13</er1:title>
    <er1:beginDate>20150607</er1:beginDate>
    <er1:endDate>20150607</er1:endDate>
    <er1:dataRequestsStarted>4</er1:dataRequestsStarted>
    <er1:changeRequestsStarted>4</er1:changeRequestsStarted>
    <er1:plls>
<er1:pll>Chaplin, Charlie</er1:pll>
<er1:pll>Saint Troy, Augustus</er1:pll></er1:plls>
<er1:epis>
<er1:epi>Spanial, Cocker</er1:epi>
<er1:epi>Poodle, Simple</er1:epi>
<er1:epi>Dane, Great</er1:epi></er1:epis>
<er1:devs><er1:dev>
<er1:name>Cooper, Jason</er1:name><er1:roles>
<er1:role>QA3</er1:role></er1:roles></er1:dev><er1:dev>
<er1:name>Bystander, Milicent</er1:name><er1:roles>
<er1:role>Programmer</er1:role>
<er1:role>QA3</er1:role></er1:roles></er1:dev><er1:dev>
<er1:name>Wallbanger, Harvey</er1:name><er1:roles>
<er1:role>Programmer</er1:role>
<er1:role>QA2</er1:role>
<er1:role>QA3</er1:role></er1:roles></er1:dev><er1:dev>
<er1:name>Chondria, Mito</er1:name><er1:roles>
<er1:role>Programmer</er1:role></er1:roles></er1:dev><er1:dev>
<er1:name>A Dale, Alan</er1:name><er1:roles>
<er1:role>Programmer</er1:role>
<er1:role>QA2</er1:role>
<er1:role>QA3</er1:role></er1:roles></er1:dev></er1:devs>
    <er1:type>DR</er1:type>
    <er1:status>initial</er1:status>
</er1:datum>
     */

    #region DR Models
    public class DRDev : IEquatable<DRDev>, IComparable<DRDev>
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public List<string> Roles { get; set; }

        public override bool Equals(object obj)
        {
            if (obj == null) return false;
            DRDev castObject = obj as DRDev;

            if (castObject == null) return false;
            else return Equals(castObject);
        }

        public int InternalGetHashCode(object obj)
        {
            return Id;
        }

        public override int GetHashCode()
        {
            return Id;
        }

        public int CompareTo(DRDev other)
        {
            if (other == null)
            {
                return 1;
            }
            else
            {
                var comparison = this.Name.CompareTo(other.Name);
                if (comparison == 0)
                {
                    var r1 = this.Roles.Count;
                    var r2 = other.Roles.Count;
                    comparison = r1.CompareTo(r2);

                    if (comparison == 0)
                    {
                        var haveComparison = false;
                        for (var q = 0; (q < r1 && !haveComparison); q++)
                        {
                            comparison = this.Roles[q].CompareTo(other.Roles[q]);
                            if (comparison != 0)
                            {
                                haveComparison = true;
                            }
                        }

                        if( !haveComparison) {
                            comparison = 0;
                        }
                    }
                }
                return comparison;
            }
        }

        public bool Equals(DRDev other)
        {
            if (other == null) return false;
            return (this.Name.Equals(other.Name) && this.Roles.Equals(other.Roles));
        }
    }
    public class DRReportModel : ReportModel
    {
        public string BeginDate { get; set; }
        public string EndDate { get; set; }
        public int DataRequestsStarted { get; set; }
        public int ChangeRequestsStarted { get; set; }
        public List<string> Plls { get; set; }
        public List<string> Epis { get; set; }
        public List<DRDev> Devs { get; set; }
    }
    #endregion DR Models
}

ReportingDashboard.Common.AbstractRepoBase.cs

using System.IO; // Memory Stream
using System.Text; // Encoding
using EdcReportingDashboard.Interfaces; // IRepoBase, ISqlCcc
using System.Xml; // XmlReader
using System.Xml.Linq; // XElement
using System.Data.SqlClient; // SqlConnection

namespace ReportingDashboard.Common
{
    public class AbstractRepoBase : IRepoBase
    {
        public string Connstr { get; set; }
        public ISqlCcc CmdStd { get; set; }
        public string Table { get; set; }
        public string TableIdFieldName {get; set;}

        public string baseXMl
        {
            get
            {
                return "<?xml version=\"1.0\" encoding=\"UTF-8\" ?><root />";
            }
        }

        protected AbstractRepoBase(ISqlCcc cmdStd, string tableName, string tableIdField = "ID")
        {
            CmdStd = cmdStd;
            Connstr = cmdStd.ConnectionStr;
            Table = tableName;
            TableIdFieldName = tableIdField;
        }

        public XElement GetAllRecords()
        {
            var data = XElement.Load(
                            new MemoryStream(
                                Encoding.UTF8.GetBytes(baseXMl)));
            var pattern = ";WITH XMLNAMESPACES('xml' as dr) " +
                                "SELECT * FROM {0} " +
                                "FOR XML PATH ('dr:row'),Root('dr:rows');";

            var cmdText = string.Format(pattern, Table);

            using (var connection = new SqlConnection(Connstr))
            {
                var command = new SqlCommand(cmdText, connection);
                connection.Open();

                var reader = command.ExecuteXmlReader();
                reader.MoveToContent();

                var stringBytes = Encoding.UTF8.GetBytes(reader.ReadOuterXml());
                var strm = new MemoryStream();
                strm.Write(stringBytes, 0, stringBytes.Length);
                strm.Position = 0;

                connection.Close();

                if (strm.Length > 0)
                {
                    data = XElement.Load(XmlReader.Create(new StreamReader(strm)));
                }
            }
            return data;
        }

        public XElement GetRecordById(int id)
        {
            return GetRecordById(id, null);
        }

        public XElement GetRecordById(int id, string pattern = null)
        {
            var data = XElement.Load(new MemoryStream(Encoding.UTF8.GetBytes(baseXml)));

            if (string.IsNullOrEmpty(pattern))
            {
                pattern = ";WITH XMLNAMESPACES('xml' as dr) " +
                                "SELECT * FROM {0} " +
                                "WHERE {1} = {2} " +
                                "FOR XML PATH ('dr:row'),Root('dr:rows');";
            }

            var cmdText = string.Format(pattern, Table, TableIdFieldName, id);

            using (var connection = new SqlConnection(Connstr))
            {
                var command = new SqlCommand(cmdText, connection);
                connection.Open();

                var reader = command.ExecuteXmlReader();
                reader.MoveToContent();

                var stringBytes = Encoding.UTF8.GetBytes(reader.ReadOuterXml());
                var strm = new MemoryStream();
                strm.Write(stringBytes, 0, stringBytes.Length);
                strm.Position = 0;

                connection.Close();

                if (strm.Length > 0)
                {
                    data = XElement.Load(XmlReader.Create(new StreamReader(strm)));
                }
            }

            return data;
        }
    }
}

ReportingDashboard.Common.enumReportType.cs

namespace ReportingDashboard.Common
{
    public enum ReportType
    {
        HL7
        , DataRequest
        , UnmatchedType
    }
}

ReportingDashboard.Common.XmlPoco.cs

using System.Xml;       // XmlDocument, XmlNamespaceManager
using System.Xml.Linq;  // XElement
using System.Xml.XPath; //XPathSelectElement

namespace ReportingDashboard.Common
{
    public class XmlPoco
    {
        public XmlDocument root { get; set; }
        public XmlNamespaceManager nsmgr { get; set; }

        public XmlPoco(XElement record, string pfx="tk", string uri="timekeeping")
        {
            root = new XmlDocument();
            root.LoadXml(record.ToString());
            nsmgr = new XmlNamespaceManager(root.NameTable);
            nsmgr.AddNamespace(pfx, uri);
        }
    }  
}

ReportingDashboard.Common.SqlCcc.cs

using System.Collections.Generic; // List
using System.Configuration; // ConfigurationManager
using System.Data; // IDataRecord
using System.Text; // StringBuilder
using ReportingDashboard.Interfaces; // ISqlCcc
using System.Data.SqlClient; // SqlConnection, SqlCommand, SqlParameter

namespace ReportingDashboard.Common
{
    public class SqlCcc : ISqlCcc
    {
        #region connection bits
        public string ConnectionStrName
        {
            get { return "Default"; }
        }

        public string ConnectionStr
        {
            get { return ConnStrs[ConnectionStrName].ConnectionString; }
        }

        public ConnectionStringSettingsCollection ConnStrs
        {
            get
            {
                return ConfigurationManager.ConnectionStrings;
            }
        }
        private SqlConnection conn
        {
            get
            {
                return new SqlConnection(ConnectionStr);
            }
        }
        #endregion connection bits

        public int Execute(string commandText, params object[] args)
        {
            using (var connection = conn)
            {
                var command = new SqlCommand(commandText, connection);
                connection.Open();

                var data = command.ExecuteNonQuery();
                return data;
            }
        }

        public List<string> Query(string commandText, params SqlParameter[] parameters)
        {
            using (var connection = conn)
            {
                var command = new SqlCommand(CommandUpdate(commandText), connection);

                foreach (var item in parameters)
                {
                    command.Parameters.Add(item);
                }

                connection.Open();

                var reader = command.ExecuteReader();
                var result = new StringBuilder();
                while (reader.Read())
                {
                    result.Append(((IDataRecord)reader)[0]);
                }
                reader.Close();
                reader.Dispose();

                var o = new List<string> { result.ToString() };
             
                return o;
            }
        }

        private string CommandUpdate(string queryString, params object[] parameters)
        {
            var index = 0;
            var returnedCommandString = queryString;
            foreach (object p in parameters)
            {
                var rs = "N'" + ((p != null) ? p.ToString() : string.Empty) + "'";
                returnedCommandString = returnedCommandString.Replace("@" + index, rs);
                index++;
            }
            return returnedCommandString;
        }
    }
}