public JsonResult SessionLengthGraphData(string game, AWSRegion region, TimeInterval interval, string start, string end)
        {
            DateTime st = Convert.ToDateTime(start);
            DateTime et = Convert.ToDateTime(end);

            return JsonResult(GameSessionsModel.Instance.GetAverageSessionLength(interval, region, st, et, game));
        }

        public void TestEquality()
        {
            TimeInterval interval1 = new TimeInterval(new JulianDate(1.0), new JulianDate(2.0));
            TimeInterval interval2 = new TimeInterval(new JulianDate(1.0), new JulianDate(2.0));
            Assert.AreEqual(interval1, interval2);
            Assert.AreEqual(interval2, interval1);
            Assert.IsTrue(interval1.Equals(interval2));
            Assert.IsTrue(interval2.Equals(interval1));
            Assert.IsTrue(interval1 == interval2);
            Assert.IsTrue(interval2 == interval1);
            Assert.IsFalse(interval1 != interval2);
            Assert.IsFalse(interval2 != interval1);

            interval2 = new TimeInterval(new JulianDate(1.0), new JulianDate(3.0));
            Assert.AreNotEqual(interval1, interval2);
            Assert.AreNotEqual(interval2, interval1);
            Assert.IsFalse(interval1.Equals(interval2));
            Assert.IsFalse(interval2.Equals(interval1));
            Assert.IsFalse(interval1 == interval2);
            Assert.IsFalse(interval2 == interval1);
            Assert.IsTrue(interval1 != interval2);
            Assert.IsTrue(interval2 != interval1);

            Assert.AreNotEqual(interval1, 5);
        }

        public JsonResult UsersOnlineBySessionType(string game, AWSRegion region, TimeInterval interval, string start, string end)
        {
            DateTime st = Convert.ToDateTime(start);
            DateTime et = Convert.ToDateTime(end);

            return JsonResult(GameSessionsModel.Instance.UsersOnlineBySessionType(game, interval, region, st, et));
        }

        public void Add(string[] cbttPcodeList, DateTime t1, DateTime t2,
            HydrometHost svr = HydrometHost.PN, TimeInterval interval = TimeInterval.Monthly, int back=0)
        {
            // make cbttPcodeList unique.
            List<string> lst = new List<string>(cbttPcodeList);
            cbttPcodeList =  lst.Distinct().ToArray();

            //minT = t1;
            //maxT = t2;
            m_interval = interval;

            string query = String.Join(",",cbttPcodeList);

            if (query.Length >0)
            {
                DataTable m_table = new DataTable();
                if (interval == TimeInterval.Monthly)
                {
                    m_table = HydrometDataUtility.MPollTable(svr, query, t1, t2);
                }
                else if (interval == TimeInterval.Daily)
                {
                    m_table = HydrometDataUtility.ArchiveTable(svr, query, t1, t2,back);
                }
                else if (interval == TimeInterval.Irregular)
                {
                    m_table = HydrometDataUtility.DayFilesTable(svr, query, t1, t2,back);
                }
                m_table.ExtendedProperties.Add("interval", interval.ToString());
                s_counter++;
                m_table.TableName = svr.ToString()+"_"+interval.ToString() + s_counter;
                m_dataSet.Tables.Add(m_table);
            }
        }

 public ConstantSeries(string name, string parameter, double value, TimeInterval interval)
 {
     m_value = value;
       this.Name = name;
       this.Parameter = parameter;
       this.TimeInterval = interval;
 }

        public ActionResult Create(string name, int poolId)
        {
            try
            {
                Pool p = db.PoolSet.Find(poolId);
                int max = p.Division.Pools.Max(x => x.Teams.Count);
                if (p.Teams.Count == max)
                {
                    db.FinalsLinkSet.Add(new FinalsLink() { Division = p.Division, PoolPlacement = max + 1, Finalstage = max + 1 });
                }
                Team t = db.TeamSet.Add(new Team() { Name = name, Pool = p });
                // Add time intervals and default them to the tournament's time intervals
                foreach (TimeInterval ti in p.Division.Tournament.TimeIntervals)
                {
                    TimeInterval timeinterval = new TimeInterval() { Team = t, StartTime = ti.StartTime, EndTime = ti.EndTime };
                    db.TimeIntervalSet.Add(timeinterval);
                    t.TimeIntervals.Add(timeinterval);
                }
                //Clear the schedule
                sm.DeleteSchedule(p.Division.Tournament.Id, db);

                db.SaveChanges();

                return Json(new { status = "success", message = "New team added", id = t.Id }, JsonRequestBehavior.AllowGet);
            }
            catch (Exception ex)
            {
                return Json(new { status = "error", message = "New team not added", details = ex.Message }, JsonRequestBehavior.AllowGet);
            }
        }

 public DataTableSeries(DataTable tbl, TimeInterval interval, string dateColumn, string valueColumnName)
 {
     this.data = tbl;
     this.TimeInterval = interval;
     this.dateColumn = dateColumn;
     this.valueColumnName = valueColumnName;
 }

 public void SetFacultyModificator(TimeInterval interval)
 {
     foreach (var dataProvider in _dataProviders)
     {
         dataProvider.SetFacultyModificator(interval);
     }
 }

 public void SetProfessorModificator(Person professor, TimeInterval interval)
 {
     foreach (var dataProvider in _dataProviders)
     {
         dataProvider.SetPersonModificator(professor, interval);
     }
 }

        /// <summary>
        /// </summary>
        /// <param name="stationID">example: 13245000</param>
        /// <param name="ipcoType">Q,Qin,HW,Qx,S</param>
        /// <param name="numDays">how many days back</param>
        /// <returns></returns>
        public static Series GetIdahoPowerData(string stationID, string ipcoType, int numDays, TimeInterval interval)
        {
            string xmlFileName = GetIdahoPowerXmlFile(stationID, interval, numDays);

            var s = ParseXmlData(xmlFileName, stationID, ipcoType, interval);
            return s;
        }

 public void SetCathedraModificator(Cathedra cathedra, TimeInterval interval)
 {
     foreach (var dataProvider in _dataProviders)
     {
         dataProvider.SetCathedraModificator(cathedra, interval);
     }
 }

        /// <summary>
        /// Lookup hydromet Series.
        /// name is  interval_cbtt_pcode
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public override ParserResult Lookup(string name, TimeInterval defaultInterval)
        {
            var interval = defaultInterval;

            TimeSeriesName tn = new TimeSeriesName(name);
            if( tn.HasInterval)
            {
                interval = tn.GetTimeInterval();
            }

            if (tn.Valid)
            {
                Logger.WriteLine("Hydromet Lookup " + tn.siteid + "," + tn.pcode);
                var s = new Series();

                if (interval ==  TimeInterval.Monthly)
                {
                    s = new HydrometMonthlySeries(tn.siteid, tn.pcode,svr);
                }
                else if (interval == TimeInterval.Irregular)
                {
                    s = new HydrometInstantSeries(tn.siteid, tn.pcode,svr);
                }
                else if (interval == TimeInterval.Daily)
                {
                    s = new HydrometDailySeries(tn.siteid, tn.pcode,svr);
                }

                return new ParserResult(s);
            }
            else
            {
                return base.Lookup(name,interval);
            }
        }

        public void PassToIso8601Interval()
        {
            //Since ToIso8601Interval is just a simple wrapper around two calls to
            //CesiumFormattingHelper.ToIso8601, this test is just a smoke screen.
            string expectedBasicInterval = "19800801T000000Z/20720703T000000Z";
            string expectedExtendedInterval = "1980-08-01T00:00:00Z/2072-07-03T00:00:00Z";
            string expectedCompactInterval = "19800801T00Z/20720703T00Z";

            JulianDate start = new GregorianDate(1980, 08, 01).ToJulianDate();
            JulianDate stop = new GregorianDate(2072, 07, 03).ToJulianDate();

            string basicInterval = CesiumFormattingHelper.ToIso8601Interval(start, stop, Iso8601Format.Basic);
            Assert.AreEqual(expectedBasicInterval, basicInterval);

            string extendedInterval = CesiumFormattingHelper.ToIso8601Interval(start, stop, Iso8601Format.Extended);
            Assert.AreEqual(expectedExtendedInterval, extendedInterval);

            string compactInterval = CesiumFormattingHelper.ToIso8601Interval(start, stop, Iso8601Format.Compact);
            Assert.AreEqual(expectedCompactInterval, compactInterval);

            TimeInterval interval = new TimeInterval(start, stop);
            basicInterval = CesiumFormattingHelper.ToIso8601Interval(interval, Iso8601Format.Basic);
            Assert.AreEqual(expectedBasicInterval, basicInterval);

            extendedInterval = CesiumFormattingHelper.ToIso8601Interval(interval, Iso8601Format.Extended);
            Assert.AreEqual(expectedExtendedInterval, extendedInterval);

            compactInterval = CesiumFormattingHelper.ToIso8601Interval(interval, Iso8601Format.Compact);
            Assert.AreEqual(expectedCompactInterval, compactInterval);
        }

        public JsonResult PrivateVsPublic(string game, AWSRegion region, TimeInterval interval, string start, string end)
        {
            DateTime st = Convert.ToDateTime(start);
            DateTime et = Convert.ToDateTime(end);

            return JsonResult(GameSessionsModel.Instance.GetPrivateSessionTimeSeries(game, interval, st, et));
        }

        public List<PVTimeSeries> GetAverageSessionLength(TimeInterval interval, AWSRegion region, DateTime startDate, DateTime endDate, string gameShortName)
        {
            List<PVTimeSeries> timeSeriesData = new List<PVTimeSeries>();
            DataTable queryResults = new DataTable();

            GameMonitoringConfig game = Games.Instance.GetMonitoredGames().Where(x => x.ShortTitle == gameShortName).FirstOrDefault();
            string query = String.Format(
                        @"select DATE(RecordCreated) as RecordTimeStamp,
                         SessionTypeFriendly as SeriesName,
                         round(avg(minute(timediff(RecordLastUpdateTime, RecordCreated)))) * 60 * 1000 as AverageSessionLength
                            from {0}
                            WHERE GameId = '{1}'
                            AND DATE(RecordCreated) BETWEEN '{2}' and '{3}'
                            AND minute(timediff(RecordLastUpdateTime, RecordCreated)) > 1
                            group by DATE(RecordCreated), SessionTypeFriendly
                            order by RecordCreated asc;",
                        "GameSessionMeta", game.Id, startDate.ToString("yyyy-MM-dd HH:mm:ss"), endDate.ToString("yyyy-MM-dd HH:mm:ss"));

            try
            {
                queryResults = DBManager.Instance.Query(Datastore.Monitoring, query);
                timeSeriesData = Charts.Instance.ProcessedTimeSeries(queryResults, interval, startDate, endDate, "RecordTimestamp");

            }
            catch (Exception ex)
            {
                Logger.Instance.Exception(ex.Message, ex.StackTrace);
            }

            return timeSeriesData;
        }

        public static Series ReadCorpsDataFile(string url, TimeInterval interval, params string[] headers)
        {
            string units = headers[headers.Length - 1];
            if( units == "n (ft)") // hack for Banks Lake.
                units = "(ft)";

            Series rval = new Series(units, interval);
            rval.HasFlags = true;

            string fileName = FileUtility.GetTempFileName(".txt");
            Web.GetTextFile(url, fileName, true);

            int[] widths = new int[] { 9, 5, 9, 9, 9, 9, 9, 9, 9, 9, 9,9,9 };

            var tf = new FixedWidthTextFile(fileName, widths);

            int col, row;
            tf.FindIndexToRange(headers, out row, out col);
            if (row < 0 || col < 0)
            {
                Logger.WriteLine("Error: no index found for headers '" + String.Join("','", headers) + "'");
                return rval;
            }

            rval.Name = String.Join(" ", headers, 0, headers.Length - 1);
            ReadDataIntoSeries(tf, rval, row + headers.Length, col);

            return rval;
        }

        public List<PVTableRow> AverageSessionLengthChart(string gameShort, TimeInterval interval, AWSRegion region, DateTime startDate, DateTime endDate)
        {
            GameMonitoringConfig game = Games.Instance.GetMonitoredGames().Where(x => x.ShortTitle == gameShort).FirstOrDefault();
            List<PVTableRow> DataTableInfo = GetAverageSessionLengthTable(interval, region, startDate, endDate, game);

            return DataTableInfo;
        }

 public void MomentTest() {
     DateTime moment = ClockProxy.Clock.Now;
     TimeInterval timeInterval = new TimeInterval(moment);
     Assert.AreEqual(timeInterval.Start, moment);
     Assert.AreEqual(timeInterval.End, moment);
     Assert.IsTrue(timeInterval.IsMoment);
     Assert.IsTrue(timeInterval.IsDegenerate);
 }

 public void TestRetainValue()
 {
     JulianDate start = new JulianDate(DateTime.UtcNow);
     JulianDate stop = start + Duration.FromDays(1.5);
     TimeInterval interval = new TimeInterval(start, stop);
     Assert.AreEqual(start, interval.Start);
     Assert.AreEqual(stop, interval.Stop);
 }

        public void TestCalculateDuration()
        {
            JulianDate start = new JulianDate(2451545.0);
            JulianDate stop = start + Duration.FromDays(1.5);
            TimeInterval interval = new TimeInterval(start, stop);

            Assert.AreEqual(Duration.FromDays(1.5), interval.ToDuration());
        }