/// <summary>
/// Method to Add or Update Daily Target
/// </summary>
/// <param name="monthlyTarget">The monthly target.</param>
/// <param name="date">The date.</param>
/// <param name="loggedInUserId">The logged in user identifier.</param>
public virtual void AddOrUpdateDailyTarget(MonthlyTarget monthlyTarget, DateTime date, int loggedInUserId)
{
var currentDate = TimeZoneUtility.GetCurrentTimestamp();
var dailyTarget = dailyTargetRepository.GetAll().FirstOrDefault(x => x.MonthlyTargetId == monthlyTarget.Id && x.Day == date.Day);
// add update delete
if (dailyTarget == null)
{
var dailyTargetDate = new DailyTarget()
{
MonthlyTargetId = monthlyTarget.Id,
Day = date.Day,
MaxGoalValue = monthlyTarget.DailyRate,
CreatedOn = currentDate,
CreatedBy = loggedInUserId,
LastModifiedOn = currentDate,
LastModifiedBy = loggedInUserId
};
dailyTargetRepository.AddOrUpdate(dailyTargetDate);
}
else
{
dailyTarget.MaxGoalValue = monthlyTarget.DailyRate;
dailyTarget.LastModifiedBy = loggedInUserId;
dailyTarget.LastModifiedOn = currentDate;
dailyTargetRepository.AddOrUpdate(dailyTarget);
}
dailyTargetRepository.Save();
}
/// <summary>
/// Gets the last day with target for current month.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="monthlyTarget">The monthly target.</param>
private int GetLastDayWithTargetForCurrentMonth(Target target, MonthlyTarget monthlyTarget)
{
bool isRolledUpTarget = false;
var currentDate = TimeZoneUtility.GetCurrentTimestamp();
var day = currentDate.Day;
DailyTarget dailyTarget = new DailyTarget();
if (target.CascadedMetricsTrackingMethodId.HasValue)
{
// check whether cascaded metrics tracking method is rolled up targets
isRolledUpTarget = (target.CascadedMetricsTrackingMethodId.Value == (int)CascadedMetricsTrackingMethod.RolledUpTargets && target.IsCascaded);
}
if (isRolledUpTarget)
{
dailyTarget = monthlyTarget.DailyTargets
.Where(x => x.Day <= currentDate.Day && (x.RolledUpGoalValue != null))
.OrderByDescending(x => x.Day)
.FirstOrDefault();
}
else
{
dailyTarget = monthlyTarget.DailyTargets
.Where(x => x.Day <= currentDate.Day && (x.MaxGoalValue != null))
.OrderByDescending(x => x.Day)
.FirstOrDefault();
}
if (dailyTarget != null)
{
day = dailyTarget.Day;
}
return(day);
}
/// <summary>
/// Method to convert daily target entity to daily target item DTO
/// </summary>
/// <param name="dailyTarget">daily target entity to be converted</param>
/// <returns>Daily target item DTO</returns>
public static DailyTargetItem ConvertDailyTargetToDailyTargetItemDTO(DailyTarget dailyTarget)
{
var dailyTargetItem = new DailyTargetItem()
{
Id = dailyTarget.Id,
Day = dailyTarget.Day,
GoalValue = dailyTarget.MaxGoalValue,
RolledUpGoalValue = dailyTarget.RolledUpGoalValue,
IsManual = dailyTarget.IsManual
};
return(dailyTargetItem);
}
public void calcDailyTest()
{
DailyTarget testTarget = User.readFromJson().getDailyTarget();
Performance.Daily daily = new Performance.Daily(0, 0, 0);
daily.CalcPerformance(testTarget.calorieTarget, testTarget.workoutTarget,
testTarget.sleepTarget, testTarget.actualCalories, testTarget.actualWorkout
, testTarget.actualSleep);
Assert.AreEqual(daily.CalorieDeficit, 9000);
Assert.AreEqual(daily.WorkoutDeficit, 30);
Assert.AreEqual(daily.SleepDeficit, -6);
}
/// <summary>
/// Convert DailyTarget data structure to DailyTargetHistory
/// </summary>
/// <param name="dailyTarget">Input DailyTarget DS</param>
/// <returns>DailyTargetHistory DS</returns>
public static DailyTargetHistory ConvertDailyTargetToDailyTargetHistory(
DailyTarget dailyTarget)
{
return(new DailyTargetHistory()
{
DailyTarget = dailyTarget,
MonthlyTarget = dailyTarget.MonthlyTarget,
Day = dailyTarget.Day,
MaxGoalValue = dailyTarget.MaxGoalValue,
RolledUpGoalValue = dailyTarget.RolledUpGoalValue,
IsManual = dailyTarget.IsManual,
CreatedOn = dailyTarget.CreatedOn,
LastModifiedOn = dailyTarget.LastModifiedOn,
CreatedBy = dailyTarget.CreatedBy,
LastModifiedBy = dailyTarget.LastModifiedBy
});
}
public static void Clear()
{
Wheels.Clear();
GoodsId.Clear();
Goods.Clear();
GoodsBundle.Clear();
Store.Clear();
Inventory.Clear();
Sound.Clear();
Sounds.Clear();
Question.Clear();
Degree.Clear();
AdChannelPostfix.Clear();
DailyTarget.Clear();
Language.Clear();
GameConst.Clear();
}
public void loadDatabaseTest()
{
User testUser = User.readFromJson();
DailyTarget testTarget = testUser.getDailyTarget();
DailyResults testDailyResults = new DailyResults {
date = testTarget.date.Date,
calorieTarget = testTarget.calorieTarget,
sleepTarget = testTarget.sleepTarget,
workoutTarget = testTarget.workoutTarget,
caloriesLogged = testTarget.actualCalories,
sleepLogged = testTarget.actualSleep,
workoutLogged = testTarget.actualWorkout,
notesLogged = " ",
};
App.Database.SaveTargetAsync(testDailyResults);
Assert.NotNull(App.Database.GetDailyTargetsListAsync());
}
public static void Init()
{
Inited = true;
if (GameConfig.Inst.DebugEnable && (Application.platform == RuntimePlatform.WindowsEditor || Application.platform == RuntimePlatform.OSXEditor))
{
Wheels.Init();
GoodsId.Init();
Goods.Init();
GoodsBundle.Init();
Store.Init();
Inventory.Init();
Sound.Init();
Sounds.Init();
Question.Init();
Degree.Init();
AdChannelPostfix.Init();
DailyTarget.Init();
Language.Init();
GameConst.Init();
}
}
/// <summary>
/// Convert DailyTargetItem DS to DailyTarget
/// </summary>
/// <param name="dailyTarget">Input DailyTargetItem</param>
/// <param name="monthlyTarget">Corresponding monthly target</param>
/// <param name="loggedInUserId">Logged In UserId</param>
/// <returns>DailyTarget DS</returns>
public static DailyTarget ConvertDailyTargetItemToDailyTargetEntity(
DailyTargetItem dailyTarget,
MonthlyTarget monthlyTarget,
int loggedInUserId)
{
DateTime curTimestamp = TimeZoneUtility.GetCurrentTimestamp();
DailyTarget daily = new DailyTarget();
daily.MonthlyTarget = monthlyTarget;
daily.Day = dailyTarget.Day;
daily.MaxGoalValue = dailyTarget.GoalValue;
daily.IsManual = dailyTarget.IsManual;
daily.CreatedOn = curTimestamp;
daily.LastModifiedOn = curTimestamp;
daily.CreatedBy = loggedInUserId; //Need to update with logged in user in future
daily.LastModifiedBy = loggedInUserId; //Need to update with logged in user in future
daily.DailyTargetHistory = new List <DailyTargetHistory>()
{
ConvertDailyTargetToDailyTargetHistory(daily)
};
return(daily);
}
/// <summary>
/// Adds the or update daily targets.
/// </summary>
/// <param name="targetId">The target identifier.</param>
/// <param name="dailyTargets">The daily targets.</param>
/// <param name="userName">Name of the user.</param>
public void AddOrUpdateDailyTargets(int targetId, IList <RollupTargetItem> dailyTargets, string userName)
{
int loggedInUserId = userRepository.GetAll().FirstOrDefault(
x => x.AccountName == userName)?.Id ?? 0;
DateTime curTimestamp = TimeZoneUtility.GetCurrentTimestamp();
// exclude months before previous month from roll up
var targetMonths = dailyTargets?.Where(x => x.TargetEntryDate.Month >= (curTimestamp.Month - 1))?
.Select(x => x.TargetEntryDate.Month).Distinct();
if (targetMonths == null || !targetMonths.Any())
{
return;
}
foreach (int month in targetMonths)
{
decimal?monthlyRollupValue = null;
var monthlyTarget = AdjustMonthlyTarget(targetId, month, loggedInUserId);
var dailyTargetsInMonth = dailyTargets.Where(x => x.TargetEntryDate.Month == month);
foreach (RollupTargetItem target in dailyTargetsInMonth)
{
DailyTarget existingDailyTarget = null;
if (target.TargetId.HasValue)
{
existingDailyTarget = dailyTargetRepository.Get(target.TargetId.Value);
}
else
{
//extra check for duplicate entry
existingDailyTarget = dailyTargetRepository.GetAll().FirstOrDefault(x => x.MonthlyTargetId == monthlyTarget.Id &&
x.Day == target.TargetEntryDate.Day);
}
if (existingDailyTarget != null)
{
if ((target.IsHoliday && existingDailyTarget.MaxGoalValue.HasValue) || target.GoalValue.HasValue)
{
existingDailyTarget.MaxGoalValue = target.GoalValue;
}
existingDailyTarget.RolledUpGoalValue = target.RollUpValue;
existingDailyTarget.LastModifiedBy = loggedInUserId;
existingDailyTarget.LastModifiedOn = curTimestamp;
existingDailyTarget.DailyTargetHistory.Add(
TargetConverters.ConvertDailyTargetToDailyTargetHistory(existingDailyTarget)
);
}
else if (target.RollUpValue.HasValue || target.GoalValue.HasValue)
{
var dailyTarget = new DailyTarget
{
MonthlyTarget = monthlyTarget,
MonthlyTargetId = monthlyTarget.Id,
Day = target.TargetEntryDate.Day,
RolledUpGoalValue = target.RollUpValue,
MaxGoalValue = target.GoalValue,
IsManual = false,
CreatedBy = loggedInUserId,
CreatedOn = curTimestamp,
LastModifiedBy = loggedInUserId,
LastModifiedOn = curTimestamp
};
dailyTarget.DailyTargetHistory = new List <DailyTargetHistory> {
TargetConverters.ConvertDailyTargetToDailyTargetHistory(dailyTarget)
};
dailyTargetRepository.AddOrUpdate(dailyTarget);
}
if (monthlyRollupValue.HasValue)
{
if (target.RollUpValue.HasValue)
{
monthlyRollupValue += target.RollUpValue.Value;
}
}
else
{
monthlyRollupValue = target.RollUpValue;
}
}
monthlyTarget.RolledUpGoalValue = monthlyRollupValue;
}
dailyTargetRepository.Save();
}
/// <summary>
/// Method to convert Target item DTO to Target entity
/// </summary>
/// <param name="targetItem">Target item DTO to be converted</param>
/// <param name="Parent target Id">Identifier of the parent target</param>
/// <param name="loggedInUserId">Logged In UserId</param>
/// <returns>Target entity</returns>
public static Target ConvertTargetItemDTOToTarget(TargetItem targetItem,
int?parentTargetId, int loggedInUserId)
{
DateTime curTimestamp = TimeZoneUtility.GetCurrentTimestamp();
var target = new Target()
{
ScorecardId = targetItem.ScorecardId,
KPIId = targetItem.KPIId.Value,
MetricId = targetItem.MetricId.Value,
MetricType = targetItem.MetricType,
EffectiveStartDate = targetItem.EffectiveStartDate,
EffectiveEndDate = targetItem.EffectiveEndDate,
CascadeFromParent = targetItem.CascadeFromParent,
ParentTargetId = parentTargetId,
IsStretchGoalEnabled = targetItem.IsStretchGoalEnabled ?? false,
TrackingMethodId = targetItem.TrackingMethodId ?? Constants.TrackingMethodDaily,
TargetEntryMethodId = targetItem.TargetEntryMethodId,
GraphPlottingMethodId = targetItem.GraphPlottingMethodId,
MTDPerformanceTrackingMethodId = targetItem.MTDPerformanceTrackingMethodId,
CascadedMetricsTrackingMethodId = targetItem.CascadedMetricsTrackingMethodId,
AnnualTarget = targetItem.AnnualTarget,
IsCascaded = false,
IsActive = true,
IsCopiedMetric = false,
CalendarYearId = targetItem.CalendarYearId.Value,
CreatedOn = curTimestamp,
LastModifiedOn = curTimestamp,
CreatedBy = loggedInUserId, //Need to update with logged in user in future
LastModifiedBy = loggedInUserId, //Need to update with logged in user in future
};
target.TargetHistory = new List <TargetHistory>()
{
ConvertTargetToTargetHistory(target)
};
// Iterate monthly targets and insert
List <MonthlyTarget> monthlyTargets = new List <MonthlyTarget>();
foreach (var monthlyTarget in targetItem.MonthlyTargets)
{
if (monthlyTarget.GoalValue != null || monthlyTarget.DailyRateValue != null)
{
MonthlyTarget mthlyTarget = ConvertMonthlyTargetItemToMonthlyTargetEntity
(monthlyTarget, loggedInUserId);
mthlyTarget.MonthlyTargetHistory = new List <MonthlyTargetHistory>()
{
ConvertMonthlyTargetToMonthlyTargetHistory(mthlyTarget)
};
mthlyTarget.DailyTargets = new List <DailyTarget>();
if (monthlyTarget.DailyTargets != null)
{
foreach (var dailyTargetItem in monthlyTarget.DailyTargets)
{
if (!dailyTargetItem.IsHoliday && !dailyTargetItem.IsOutofRange)
{
DailyTarget dailyTarget =
ConvertDailyTargetItemToDailyTargetEntity(dailyTargetItem,
mthlyTarget, loggedInUserId);
mthlyTarget.DailyTargets.Add(dailyTarget);
}
}
}
monthlyTargets.Add(mthlyTarget);
}
}
target.MonthlyTargets = monthlyTargets;
return(target);
}
