public static RetentionRow Get(DateTime datetime)
        {
            RetentionRow RetentionRow = new RetentionRow()
            {
                date = datetime.Date
            };
            string query = String.Format(@"SELECT * FROM {1} where DATE(Date) = DATE('{0}')", datetime.ToString("yyyy/MM/dd HH:mm:ss"), "Retention");
            try
            {
                DataTable singleRetentionRow = DBManager.Instance.Query(Datastore.Monitoring, query);
                if (singleRetentionRow.Rows.Count > 0)
                {

                    DataRow c = singleRetentionRow.Rows[0];
                    foreach (DataColumn col in singleRetentionRow.Columns)
                    {
                        if (col.ColumnName.Contains("Day"))
                        {
                            int colIndex = Convert.ToInt32(Regex.Split(col.ColumnName, @"\D+")[1]);
                            float perc = c.Field<float>(col.ColumnName);
                            RetentionRow.SetDayPercent(colIndex, perc);
                        }
                    }
                }
                else
                {
                    RetentionRow = new RetentionRow()
                    {
                        date = datetime.Date
                    };
                }
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("Retention Get Problems" + datetime.ToString());
            }

            return RetentionRow;
        }
        public void UpdateRetentionRow(RetentionRow thatDay)
        {
            StringBuilder query = new StringBuilder();
            query.Append("UPDATE Retention SET ");
            for (int i = thatDay.days.Length - 1; i > 0; i--)
            {
                query.AppendFormat("Day{0} = '{1}'", i, thatDay.days[i]);
                if (i != 1)
                {
                    query.Append(",");
                }
                else
                {
                    query.AppendFormat(" WHERE DATE(Date) = DATE('{0}');", thatDay.date.ToString("yyyy/MM/dd 00:00:00"));
                }
            }
            try
            {
                MoniverseResponse response = new MoniverseResponse()
                {
                    Status = "unsent",
                    TimeStamp = DateTime.UtcNow
                };

                lock (MoniverseBase.ConsoleWriterLock)
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("Beginning Update of Retention Row Batch");
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("");
                }
                Retention.Service(Service =>
                    response = Service.Insert(new MoniverseRequest()
                    {
                        TaskName = "UpdateRetentionRow Row Batch",
                        Task = query.ToString(),
                        TimeStamp = DateTime.UtcNow
                    }));
                if (response.Status != "404" || response.Status != "500" || response.Status != "fail")
                {
                    Retention.Instance.InsertRetentionRow(thatDay);
                    lock (MoniverseBase.ConsoleWriterLock)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Logger.Instance.Info("--------------------------------------");
                        Logger.Instance.Info("Retention Row Update Success");
                        Logger.Instance.Info("--------------------------------------");
                        Logger.Instance.Info("");
                        Logger.Instance.Info(String.Format("--== Updated Retention Row: {0} ==--", thatDay.date.ToString()));
                        Logger.Instance.Info("");
                        Console.ResetColor();
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Instance.Error(ex.Message);
                Logger.Instance.Info(ex.Message);
            }
        }
 private string GenerateDayString(RetentionRow row)
 {
     List<string> stringlist = new List<string>();
     for (int i = 1; i < row.days.Length; i++)
     {
         string dayString = "Day" + i;
         stringlist.Add(dayString);
     }
     return string.Join(",", stringlist.ToArray());
 }
 public bool ShouldProcess(RetentionRow row)
 {
     return true;
 }
        public void ProcessXRetentionDays(int I)
        {
            //#if DEBUG
            //            Debugger.Launch();
            //#endif
            DateTime RealToday = DateTime.UtcNow;
            int DaysLeft = I;
            for (int i = 1; i <= I; i++)
            {
                int DayToCheck = (RealToday - RealToday.AddDays(-DaysLeft)).Days;
                DateTime RetentionInstallCheckDate = RealToday.AddDays(-DaysLeft);
                lock (MoniverseBase.ConsoleWriterLock)
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info(String.Format("-= {0} - RetentionInstallCheckDate - Getting RetentionRow for date =- \r\n", RetentionInstallCheckDate));
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("");
                }

                RetentionRow YesterdayRow = GetRetentionRow(RetentionInstallCheckDate);
                if (YesterdayRow == null || YesterdayRow.installsOnThisDay.Equals(0))
                {
                    lock (MoniverseBase.ConsoleWriterLock)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Logger.Instance.Info("--------------------------------------");
                        Logger.Instance.Info(String.Format("-= {0} - Success Getting RetentionRow for date =- \r\n", RetentionInstallCheckDate));
                        Logger.Instance.Info("--------------------------------------");
                        Logger.Instance.Info("");
                    }

                    try
                    {
                        YesterdayRow = new RetentionRow();
                        YesterdayRow.date = RetentionInstallCheckDate;
                        lock (MoniverseBase.ConsoleWriterLock)
                        {
                            Console.ForegroundColor = ConsoleColor.Cyan;
                            Logger.Instance.Info("--------------------------------------");
                            Logger.Instance.Info(String.Format("--== {0} iteration : {1} New Users Added ==--", i, RetentionInstallCheckDate.Date.AddDays(-1)));
                            Logger.Instance.Info("--------------------------------------");
                            Logger.Instance.Info("");
                        }

                        YesterdayRow.installsOnThisDay = GetNewUsersCount(RetentionInstallCheckDate);
                        YesterdayRow.loginsOnThisDay = GetLoginsCount(RetentionInstallCheckDate);
                        Logger.Instance.Info(String.Format("{0} : installs {1}", RetentionInstallCheckDate.ToString(), YesterdayRow.installsOnThisDay));
                    }
                    catch (Exception ex)
                    {
                        Logger.Instance.Info(ex.Message);
                    }

                }
                if (ShouldProcess(YesterdayRow))
                {
                    UpdateDayPercents(YesterdayRow);
                }

                UpdateRetentionRow(YesterdayRow);
                DaysLeft--;
                Logger.Instance.Info(String.Format("---- {0} Days Left ---- \r\n\r\n", DaysLeft));
            }
        }
        public void ProcessRetentionForDate(DateTime processDate)
        {
            lock (MoniverseBase.ConsoleWriterLock)
            {
                Console.ForegroundColor = ConsoleColor.Cyan;
                Logger.Instance.Info("--------------------------------------");
                Logger.Instance.Info(String.Format("-= {0} - RetentionInstallCheckDate - Getting RetentionRow for date =- \r\n", processDate));
                Logger.Instance.Info("--------------------------------------");
                Logger.Instance.Info("");
            }

            RetentionRow YesterdayRow = GetRetentionRow(processDate);
            if (YesterdayRow == null || YesterdayRow.installsOnThisDay.Equals(0))
            {
                lock (MoniverseBase.ConsoleWriterLock)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info(String.Format("-= {0} - Success Getting RetentionRow for date =- \r\n", processDate));
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("");
                }

                try
                {
                    YesterdayRow = new RetentionRow();
                    YesterdayRow.date = processDate;
                    lock (MoniverseBase.ConsoleWriterLock)
                    {
                        Console.ForegroundColor = ConsoleColor.Cyan;
                        Logger.Instance.Info("--------------------------------------");
                        Logger.Instance.Info(String.Format("--== {1} New Users Added ==--", processDate.Date.AddDays(-1)));
                        Logger.Instance.Info("--------------------------------------");
                        Logger.Instance.Info("");
                    }

                    YesterdayRow.installsOnThisDay = GetNewUsersCount(processDate);
                    YesterdayRow.loginsOnThisDay = GetLoginsCount(processDate);
                    Logger.Instance.Info(String.Format("{0} : installs {1}", processDate.ToString(), YesterdayRow.installsOnThisDay));
                }
                catch (Exception ex)
                {
                    Logger.Instance.Info(ex.Message);
                }

            }
            if (ShouldProcess(YesterdayRow))
            {
                UpdateDayPercents(YesterdayRow);
            }

            UpdateRetentionRow(YesterdayRow);
        }
        public void InsertRetentionRow(RetentionRow newday)
        {
            StringBuilder query = new StringBuilder();
            query.Append("INSERT INTO Retention");
            query.AppendFormat("(Date, NewUsers, Logins, " + GenerateDayString(newday) + ") VALUES ('{0}','{1}', '{2}'", newday.date.ToString("yyyy/MM/dd 00:00:00"), newday.installsOnThisDay, newday.loginsOnThisDay);

            for (int i = 1; i <= newday.days.Length - 1; i++)
            {
                query.AppendFormat(",'{0}'", newday.days[i]);
            }
            query.Append(");");
            try
            {

                MoniverseResponse response = new MoniverseResponse()
                {
                    Status = "unsent",
                    TimeStamp = DateTime.UtcNow
                };

                lock (MoniverseBase.ConsoleWriterLock)
                {
                    Console.ForegroundColor = ConsoleColor.Cyan;
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("Beginning Insert of Retention Row Batch");
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("");
                }
                Retention.Service(Service => Service.Insert(new MoniverseRequest()
                {
                    TaskName = "Insert Retention Row Batch",
                    Task = query.ToString(),
                    TimeStamp = DateTime.UtcNow
                }));
                //int result = DBManager.Instance.Insert(Datastore.Monitoring, query.ToString());

                lock (MoniverseBase.ConsoleWriterLock)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("Insert Retention Row Batch success");
                    Logger.Instance.Info("--------------------------------------");
                    Logger.Instance.Info("");
                    Logger.Instance.Info("Done inserting Retention Row Data.");
                    Logger.Instance.Info(String.Format("success!! {0}", response.Status));
                    Logger.Instance.Info("");
                    Console.ResetColor();
                }

            }
            catch (Exception ex)
            {
                Logger.Instance.Info(ex.Message);
                //Logger.Instance.Error(ex.Message);
            }
        }
        //we're in a for loop when this is called, so we only want one row at a time
        public RetentionRow GetRetentionRow(DateTime datetime)
        {
            RetentionRow RetentionRow = new RetentionRow();
            string query = String.Format(@"SELECT * FROM Retention where DATE(Date) = DATE('{0}')", datetime.ToString("yyyy/MM/dd HH:mm:ss"));
            try
            {
                DataTable singleRetentionRow = DBManager.Instance.Query(Datastore.Monitoring, query);
                if (singleRetentionRow.Rows.Count > 0)
                {

                    DataRow c = singleRetentionRow.Rows[0];
                    RetentionRow.date = DateTime.Parse(c["Date"].ToString());
                    RetentionRow.installsOnThisDay = Convert.ToInt32(c["NewUsers"].ToString());
                    RetentionRow.loginsOnThisDay = Convert.ToInt32(c["Logins"].ToString());

                    int index = 0;
                    foreach (object o in c.ItemArray)
                    {
                        if (o is float)
                        {
                            index++;
                            RetentionRow.SetDayPercent(index, (float)o);
                        }
                    }
                }
                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("Do not have Retention Entry for date" + datetime.ToString());
            }

            return RetentionRow;
        }