/// <summary>
/// Add/update a monthly rollup entry
/// </summary>
/// <param name="parentActual">Parent's actual(rolled up value)</param>
/// <param name="parentMonthlyActualId">Id of the parent actual entry</param>
/// <param name="rollupInfo">Rollup information</param>
private void AddOrUpdateMonthlyRollupEntry(decimal?parentActual,
int?parentMonthlyActualId, RollupInfo rollupInfo)
{
ActualItem rollupEntry = new ActualItem();
rollupEntry.ActualValue = parentActual;
// Assign target and scorecard id
rollupEntry.TargetId = rollupInfo.ParentTargetId.Value;
rollupEntry.ScorecardId = rollupInfo.ParentScorecardId;
// Retrieves the monthly goal for the parent
rollupEntry.GoalValue = goalCalculator.GetMonthlyGoal(
rollupInfo.ParentTargetId.Value, rollupInfo.ActualEntry.Date.Month);
rollupEntry.Date = rollupInfo.ActualEntry.Date;
if (parentMonthlyActualId.HasValue)
{
rollupEntry.Id = parentMonthlyActualId.Value;
actualsModifier.UpdateMonthlyActual(rollupEntry, rollupInfo.GoalTypeId,
rollupInfo.Username);
}
else
{
actualsModifier.AddMonthlyActual(rollupEntry, rollupInfo.GoalTypeId,
rollupInfo.Username);
}
}
/// <summary>
/// Tracks the recordable date.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="actualRequestDate">The actual request date.</param>
public void TrackRecordables(int targetId, ActualItem actualRequest, string userName)
{
Target target = targetRepository.Get(targetId);
DateTime recordableDate = actualRequest.Date;
DateTime currentDate = TimeZoneUtility.GetCurrentTimestamp().Date;
int loggedInUserId = userRepository.GetAll().FirstOrDefault(
x => x.AccountName == userName).Id;
// if tracking method is monthly and actual entry month and current month is same
// set recordable date as current date
if (target.TrackingMethodId == Constants.TrackingMethodMonthly &&
actualRequest.Date.Month == currentDate.Month)
{
recordableDate = currentDate;
}
if (actualRequest.ActualValue > 0)
{
AddOrUpdateRecordable(target, recordableDate, loggedInUserId);
}
else
{
if (target.TrackingMethodId == Constants.TrackingMethodMonthly)
{
DeleteRecordablesOfMonth(target, recordableDate, loggedInUserId);
}
else
{
DeleteRecordablesOfDay(target, recordableDate, loggedInUserId);
}
}
recordableRepository.Save();
}
/// <summary>
/// Adjusts(add or update)monthly actual when adding a new daily actual
/// </summary>
/// <param name="actualRequest">actual request</param>
/// <param name="goalTypeId">goal type id</param>
/// <param name="dataTypeId">data type id</param>
/// <param name="loggedInUserId">logged in user id</param>
/// <returns>Adjusted monthly Actual Entity after including daily target</returns>
private MonthlyActual AdjustMonthlyActual(ActualItem actualRequest, int goalTypeId,
int dataTypeId, int loggedInUserId)
{
// Get existing monthly actual entry if exists
var existingMonthlyActual = monthlyActualRepository.GetAll().FirstOrDefault(x =>
x.TargetId == actualRequest.TargetId &&
x.Month == actualRequest.Date.Month);
if (existingMonthlyActual != null)
{
// updating existing monthly actual
return(UpdateExistingMonthlyActualOfDailyActual(existingMonthlyActual,
actualRequest, goalTypeId, dataTypeId, loggedInUserId));
}
else
{
DateTime curTimestamp = TimeZoneUtility.GetCurrentTimestamp();
// get monthly target
decimal?monthlyTarget = goalCalculator.GetMonthlyGoal(actualRequest.TargetId,
actualRequest.Date.Month);
// Assign the monthly target instead of daily target, because we
// need to create monthly actual here
actualRequest.GoalValue = monthlyTarget;
return(CreateMonthlyActual(actualRequest, goalTypeId, loggedInUserId));
}
}
/// <summary>
/// Method to add new actual entry
/// </summary>
/// <param name="actualRequest">Daily actual request</param>
/// <param name="goalTypeId">Metric goal type id</param>
/// <param name="dataTypeId">Data type id</param>
/// <param name="userName">Logged in user name</param>
/// <returns>Newly created Entity Id</returns>
public virtual int AddDailyActual(ActualItem actualRequest, int goalTypeId,
int dataTypeId, string userName)
{
// Get logged in user id
int loggedInUserId = userRepository.GetAll().FirstOrDefault(
x => x.AccountName == userName).Id;
var target = targetRepository.Get(actualRequest.TargetId);
decimal?actualValueToBeCompared = actualRequest.ActualValue;
decimal?goalValueToBeCompared = actualRequest.GoalValue;
decimal?goalValueToBeSaved = actualRequest.GoalValue;
//get cumulative actual & goal value that needs to be compared in case of cumulative plotting
if (target.GraphPlottingMethodId == Constants.GraphPlottingMethodCumulative)
{
actualValueToBeCompared = actualCalculator.CalculateCumulativeActual(
actualRequest.TargetId, actualRequest.Date, actualRequest.ActualValue);
goalValueToBeCompared = goalCalculator.CalculateCumulativeGoal(
target, actualRequest.Date);
goalValueToBeSaved = goalCalculator.GetDailyGoal(actualRequest.TargetId,
actualRequest.Date.Month, actualRequest.Date.Day);
}
DateTime curTimestamp = TimeZoneUtility.GetCurrentTimestamp();
// Creating daily actual entity
var dailyActual = new DailyActual()
{
Date = actualRequest.Date,
GoalValue = goalValueToBeSaved,
ActualValue = actualRequest.ActualValue,
Status = (actualValueToBeCompared.HasValue) ? TargetActualComparer.GetActualStatus(
goalValueToBeCompared, actualValueToBeCompared, goalTypeId)
: ActualStatus.NotEntered,
TargetId = actualRequest.TargetId,
CreatedOn = curTimestamp,
LastModifiedOn = curTimestamp,
CreatedBy = loggedInUserId,
LastModifiedBy = loggedInUserId
};
dailyActual.DailyActualHistory = new List <DailyActualHistory>()
{
ActualConverters.ConvertDailyActualToDailyActualHistory(dailyActual)
};
// Add/Update corresponding monthly actual
var monthlyActual = AdjustMonthlyActual(actualRequest, goalTypeId,
dataTypeId, loggedInUserId);
// If it is a new monthly actual entry, add explicitly
if (monthlyActual.Id == 0)
{
monthlyActualRepository.AddOrUpdate(monthlyActual);
}
dailyActualRepository.AddOrUpdate(dailyActual);
dailyActualRepository.Save();
return(dailyActual.Id);
}
/// <summary>
/// Add a new monthly actual entry
/// </summary>
/// <param name="actualRequest">Monthly actual request</param>
/// <param name="goalTypeId">Metric goal type id</param>
/// <param name="username">Logged in user name</param>
/// <returns>Newly created Entity Id</returns>
public virtual int AddMonthlyActual(ActualItem actualRequest, int goalTypeId,
string username)
{
int loggedInUserId = userRepository.GetAll().FirstOrDefault(
x => x.AccountName == username)?.Id ?? 0;
var monthlyActual = CreateMonthlyActual(actualRequest, goalTypeId, loggedInUserId);
monthlyActualRepository.AddOrUpdate(monthlyActual);
monthlyActualRepository.Save();
return(monthlyActual.Id);
}
/// <summary>
/// Method to update daily actual and monthly entry
/// </summary>
/// <param name="actualRequest">daily actual request</param>
/// <param name="goalTypeId">metric goal type id</param>
/// <param name="dataTypeId">metric data type id</param>
/// <param name="userName">logged in user name</param>
public virtual void UpdateDailyActual(ActualItem actualRequest, int goalTypeId,
int dataTypeId, string userName)
{
//get logged in user id
int loggedInUserId = userRepository.GetAll().FirstOrDefault(
x => x.AccountName == userName).Id;
//get existing daily actual
var existingDailyActual = dailyActualRepository.Get(actualRequest.Id.Value);
var target = targetRepository.Get(actualRequest.TargetId);
decimal?actualValueToBeCompared = actualRequest.ActualValue;
decimal?goalValueToBeCompared = actualRequest.GoalValue;
decimal?goalValueToBeSaved = actualRequest.GoalValue;
//get cumulative actual & goal value that needs to be compared in case of cumulative plotting
if (target.GraphPlottingMethodId == Constants.GraphPlottingMethodCumulative)
{
actualValueToBeCompared = actualCalculator.CalculateCumulativeActual(
actualRequest.TargetId, actualRequest.Date, actualRequest.ActualValue);
goalValueToBeCompared = goalCalculator.CalculateCumulativeGoal(
target, actualRequest.Date);
goalValueToBeSaved = goalCalculator.GetDailyGoal(actualRequest.TargetId,
actualRequest.Date.Month, actualRequest.Date.Day);
}
//update daily actual with new changes
existingDailyActual.ActualValue = actualRequest.ActualValue;
existingDailyActual.GoalValue = goalValueToBeSaved;
existingDailyActual.Status = (actualValueToBeCompared.HasValue) ?
TargetActualComparer.GetActualStatus(goalValueToBeCompared,
actualValueToBeCompared, goalTypeId) : ActualStatus.NotEntered;
existingDailyActual.LastModifiedOn = TimeZoneUtility.GetCurrentTimestamp();
existingDailyActual.LastModifiedBy = loggedInUserId;
//add history of daily actual
existingDailyActual.DailyActualHistory.Add(
ActualConverters.ConvertDailyActualToDailyActualHistory(existingDailyActual));
// Add/Update corresponding monthly actual
var monthlyActual = AdjustMonthlyActual(actualRequest, goalTypeId,
dataTypeId, loggedInUserId);
// If it is a new monthly actual entry, add explicitly
if (monthlyActual.Id == 0)
{
monthlyActualRepository.AddOrUpdate(monthlyActual);
}
dailyActualRepository.Save();
}
/// <summary>
/// Round the actual item to two decimal places
/// </summary>
/// <param name="actualItem">Input actual item to round</param>
public static void RoundActualItem(ActualItem actualItem)
{
// Round the actual value to two decimal places
if (actualItem.ActualValue != null)
{
actualItem.ActualValue = decimal.Round(actualItem.ActualValue.Value,
2, MidpointRounding.AwayFromZero);
}
// Round the goal value to two decimal places
if (actualItem.GoalValue != null)
{
actualItem.GoalValue = decimal.Round(actualItem.GoalValue.Value,
2, MidpointRounding.AwayFromZero);
}
}
/// <summary>
/// Method to update monthly actual entry
/// </summary>
/// <param name="actualRequest">daily actual request</param>
/// <param name="goalTypeId">metric goal type id</param>
/// <param name="userName">logged in user name</param>
public virtual void UpdateMonthlyActual(ActualItem actualRequest, int goalTypeId, string userName)
{
//get logged in user id
int loggedInUserId = userRepository.GetAll().FirstOrDefault(
x => x.AccountName == userName)?.Id ?? 0;
var monthlyActual = monthlyActualRepository.Get(actualRequest.Id.Value);
monthlyActual.ActualValue = actualRequest.ActualValue;
monthlyActual.Status = TargetActualComparer.GetActualStatus(actualRequest.GoalValue,
actualRequest.ActualValue, goalTypeId);
monthlyActual.LastModifiedOn = TimeZoneUtility.GetCurrentTimestamp();
monthlyActual.LastModifiedBy = loggedInUserId;
monthlyActual.MonthlyActualHistory.Add(
ActualConverters.ConvertMonthlyActualToMonthlyActualHistory(monthlyActual));
monthlyActualRepository.Save();
}
public void ShowSurplus(CellProcessor processor, Parse theLastRow)
{
Parse lastRow = theLastRow;
for (int i = 0; i < myActuals.Count;)
{
ActualItem surplus = myActuals[i];
if (surplus.MatchRow != null)
{
i++;
continue;
}
Parse surplusRow = MakeSurplusRow(processor, surplus.Value);
lastRow.More = surplusRow;
lastRow = surplusRow;
myActuals.RemoveAt(i);
}
}
public IHttpActionResult PutActual(ActualItem actualRequest)
{
//if user is kpi owner not an admin, check if he is the kpi owner/team member of the given
//scorecard else return unauthorized
if (IsUserKPIOwnerOrTeamMemberNotAdmin())
{
bool isUserKPIOwnerOfScorecard = userManager.
IsUserKPIOwnerOfScorecard(Username, actualRequest.ScorecardId.Value);
bool isUserTeamMemberOfScorecard = userManager.
IsUserTeamMemberOfScorecard(Username, actualRequest.ScorecardId.Value);
if (!isUserKPIOwnerOfScorecard && !isUserTeamMemberOfScorecard)
{
return(Unauthorized());
}
}
actualsManager.UpdateActual(actualRequest, Username);
return(Ok());
}
/// <summary>
/// Performs roll up for an actual entry
/// </summary>
/// <param name="actualEntry">Actual entry to rollup</param>
/// <param name="username">Logged in user name</param>
public virtual void PerformRollup(ActualItem actualEntry, bool updateRecordable, string username)
{
// Find target with the given id
var target = targetRepository.Get(actualEntry.TargetId);
if (target.ParentTargetId != null)
{
// Fill the parameters needed for rollup operation
RollupInfo rollupInfo = new RollupInfo();
rollupInfo.ActualEntry = actualEntry;
rollupInfo.Username = username;
rollupInfo.ParentTargetId = target.ParentTargetId;
rollupInfo.ParentScorecardId = target.ParentTarget.ScorecardId;
rollupInfo.RollupMethodId = target.ParentTarget.RollUpMethodId;
rollupInfo.DataTypeId = target.Metric.DataTypeId;
rollupInfo.GoalTypeId = target.Metric.GoalTypeId;
rollupInfo.TrackingMethodId = target.TrackingMethodId;
rollupInfo.UpdateRecordable = updateRecordable;
// Invoke the recursive rollup operation
RollupRecursively(rollupInfo);
}
}
/// <summary>
/// Create MonthlyActual entity from ActualEntry request
/// </summary>
/// <param name="actualRequest">Actual entry</param>
/// <param name="goalTypeId">Goal type id</param>
/// <param name="loggedInUserId">Logged in user id</param>
/// <returns></returns>
private MonthlyActual CreateMonthlyActual(ActualItem actualRequest, int goalTypeId,
int loggedInUserId)
{
DateTime curTimestamp = TimeZoneUtility.GetCurrentTimestamp();
var monthlyActual = new MonthlyActual()
{
Month = actualRequest.Date.Month,
ActualValue = actualRequest.ActualValue,
Status = TargetActualComparer.GetActualStatus(actualRequest.GoalValue,
actualRequest.ActualValue, goalTypeId),
TargetId = actualRequest.TargetId,
CreatedOn = curTimestamp,
LastModifiedOn = curTimestamp,
CreatedBy = loggedInUserId,
LastModifiedBy = loggedInUserId
};
monthlyActual.MonthlyActualHistory = new List <MonthlyActualHistory>()
{
ActualConverters.ConvertMonthlyActualToMonthlyActualHistory(monthlyActual)
};
return(monthlyActual);
}
/// <summary>
/// Update existing monthly actual while adding or updating daily actuals
/// </summary>
/// <param name="existingActual">existing monthly actual</param>
/// <param name="actualUpdRequest">Actual update request</param>
/// <param name="goalTypeId">goal type id</param>
/// <param name="dataTypeId">data type id</param>
/// <param name="loggedInUserId">logged in user id</param>
/// <returns>Updated monthly actual</returns>
public virtual MonthlyActual UpdateExistingMonthlyActualOfDailyActual(
MonthlyActual existingActual, ActualItem actualUpdRequest,
int goalTypeId, int dataTypeId, int loggedInUserId)
{
//set monthly actual value as sum of daily actuals in case
//metric data type is amount/whole number
if (dataTypeId == Constants.DataTypeAmount ||
dataTypeId == Constants.DataTypeWholeNumber ||
dataTypeId == Constants.DataTypeDecimalNumber)
{
if (actualUpdRequest.ActualValue != null)
{
existingActual.ActualValue = FindSumOfDailyActualsExcludingCurrentEntryDate
(actualUpdRequest.TargetId, actualUpdRequest.Date) +
actualUpdRequest.ActualValue.Value;
}
}
else
{
existingActual.ActualValue = actualUpdRequest.ActualValue;
}
existingActual.LastModifiedBy = loggedInUserId;
existingActual.LastModifiedOn = TimeZoneUtility.GetCurrentTimestamp();
decimal?monthlyTarget = goalCalculator.GetMonthlyGoal(actualUpdRequest.TargetId,
actualUpdRequest.Date.Month);
existingActual.Status = TargetActualComparer.GetActualStatus(monthlyTarget,
existingActual.ActualValue, goalTypeId);
// Add the history as well
existingActual.MonthlyActualHistory.Add(
ActualConverters.ConvertMonthlyActualToMonthlyActualHistory(existingActual));
return(existingActual);
}
public async Task <bool> UpdateActualItem(string userId, ActualItem actualItem)
{
try
{
if (string.IsNullOrEmpty(userId))
{
return(false);
}
// The budget category associated with the budget item
var budgetCategory
= await _context.budgetCategories
.FirstOrDefaultAsync(
bc => bc.BudgetCategoryId == actualItem.BudgetCategoryId);
// Does the user own the budget category
if (budgetCategory == null ||
budgetCategory.UserId != userId)
{
// return false, the user doesn't own the budget category
return(false);
}
var budgetPeriod
= await _context.budgetPeriods
.FirstOrDefaultAsync(
bp => bp.BudgetPeriodId == actualItem.BudgetPeriodId);
if (budgetPeriod == null ||
budgetPeriod.UserId != userId)
{
// return false, the user doesn't own the budget period
return(false);
}
// Everything is good, update the item
// Get the current item
var currentActualItem
= await _context.actualItems
.FirstOrDefaultAsync(ai => ai.ActualItemId == actualItem.ActualItemId);
// Update the current item
currentActualItem.UserId = userId;
currentActualItem.BudgetCategoryId = actualItem.BudgetCategoryId;
currentActualItem.BudgetPeriodId = actualItem.BudgetPeriodId;
currentActualItem.Date = actualItem.Date;
currentActualItem.Amount = actualItem.Amount;
currentActualItem.TransactionType = actualItem.TransactionType;
_context.actualItems.Update(currentActualItem);
// Save the item changes
if (await _context.SaveChangesAsync() > 0)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
// Something bad happened, return false
return(false);
}
}
