public void TestUserActivities()
{
PerformanceController ñontroller = ConfigureController();
DateTime startDate = new DateTime(2020, 1, 1);
IActionResult result = ñontroller.UserActivities(startDate, new DateTime(2020, 1, 3), 0, 10);
Assert.IsTrue(result is OkObjectResult);
OkObjectResult okResult = result as OkObjectResult;
Assert.IsTrue(okResult.Value is UserActivitiesModel);
UserActivitiesModel ea = okResult.Value as UserActivitiesModel;
int days = (int)(DateTime.Now.Date - startDate).TotalDays;
Assert.AreEqual(ea.userName, "User1");
Assert.AreEqual(ea.currentDay, days);
Assert.AreEqual(ea.editedDays, days + 1);
Assert.AreEqual(ea.days.Length, 2);
Assert.AreEqual(ea.days[0].day, startDate);
Assert.AreEqual(ea.days[1].day, new DateTime(2020, 1, 2));
Assert.AreEqual(ea.maxYear, DateTime.Now.Date.Year + 1);
Assert.AreEqual(ea.minYear, 2020);
Assert.AreEqual(ea.monthPerformance, 0);
Assert.AreEqual(ea.monthWorkDays, 0);
result = ñontroller.UserActivities(new DateTime(2020, 1, 3), startDate, 0, 10);
Assert.IsInstanceOfType(result, typeof(BadRequestResult));
}
public static void UserDisconnect(string connectionId, string name, string role, int status)
{
var tempModel = new UserActivitiesModel(connectionId, name, role, status);
//_userActivities.Add(tempModel);
foreach (var user in _activeUsers)
{
if (user.ConnectionId == tempModel.ConnectionId)
{
_activeUsers.Remove(user);
break;
}
}
}
public IActionResult UserActivities(DateTime from, DateTime to, int offset, int count)
{
if (to < from)
{
ModelState.AddModelError("", "Date to must be greater or equals than date from");
}
if (!ModelState.IsValid)
{
return(BadRequest());
}
AppUser user = _ctx.Users.Where(u => u.Login == HttpContext.User.Identity.Name.ToUpper()).SingleOrDefault();
if (null == user)
{
user = new AppUser {
Id = Guid.Empty, Name = $"Not authorized application user ({HttpContext.User.Identity.Name})", Login = HttpContext.User.Identity.Name
};
//return BadRequest("User is not authorized");
}
Guid userId = user.Id;
DateTime now = DateTime.Now.Date;
if (from == default)
{
from = new DateTime(now.Year, now.Month, 1);
}
else
{
from = from.Date;
}
if (to == default)
{
to = now;
}
else
{
to = to.Date;
}
if (from.AddDays(offset) <= to)
{
from = from.AddDays(offset);
}
if (count != 0 && from.AddDays(count - 1) <= to)
{
to = from.AddDays(count - 1);
}
var displayDays = (to - from).Days;
int currentDay = (now - from).Days; //-1; // (int)(now.DayOfWeek) - 1;
DateTime startDate = from; // now.AddDays(-currentDay); // now.AddDays(-6);
DateTime endDate = to; // startDate.AddDays(_displayDays);
DateTime firstDay = new DateTime(now.Year, now.Month, 1);
var userMonthHours = _ctx.UserDateWorkHours
.Where(wh => wh.UserId == userId && wh.Date >= firstDay && wh.Date < now)
.Select(wh => new { wh.Date, wh.WorkHours })
.ToDictionary(wh => wh.Date);
//.Sum(wh => wh.WorkHours);
decimal monthHours = 0;
int monthDays = 0;
DateTime day = firstDay;
while (day < now)
{
if (userMonthHours.ContainsKey(day))
{
decimal.TryParse(userMonthHours[day].WorkHours.Replace('.', ','), out var workHours);
monthHours += workHours;
if (workHours > 0)
{
++monthDays;
}
}
day = day.AddDays(1);
}
decimal monthActivityMins = _ctx.UserActivityDates
.Where(ead => ead.UserActivity.UserId == userId && ead.Date >= firstDay && ead.Date < now)
.Sum(ead => ead.Count * ead.UserActivity.Activity.WorkCost.GetValueOrDefault());
List <UserActivityDate> userActivityDates = _ctx.UserActivityDates
.Where(ead => ead.UserActivity.UserId == userId && ead.Date >= startDate && ead.Date <= endDate)
.Include(ead => ead.UserActivity.Activity)
.OrderBy(a => a.Date)
.ToList();
DateTime lastDay = firstDay.AddMonths(1);
Dictionary <long, decimal> userActivitiesMonth = _ctx.UserActivityDates
.Where(ead => ead.UserActivity.UserId == userId && ead.Date >= firstDay && ead.Date < lastDay)
.GroupBy(ead => new { ead.UserActivity.UserId, ead.UserActivity.ActivityId }, (e, eads) => new { e.ActivityId, sum = eads.Sum(a => a.Count) })
.ToDictionary(ea => ea.ActivityId, ea => Math.Round(ea.sum, 1));
Dictionary <DateTime, UserDateWorkHours> employeeWorkHours = _ctx.UserDateWorkHours
.Where(wh => wh.UserId == userId && wh.Date >= startDate && wh.Date <= endDate)
.ToDictionary(a => a.Date);
UserActivitiesModel model = new UserActivitiesModel
{
currentDay = currentDay,
monthWorkDays = monthDays,
days = new ActivityDayModel[displayDays]
};
if (monthHours > 0)
{
model.monthPerformance = Math.Round(monthActivityMins * 100 / Convert.ToDecimal(monthHours) / 60, 2);
}
model.maxYear = now.Year + 1;
DateTime?minDate = _ctx.UserActivityDates.Where(ead => ead.UserId == userId).Min(ead => (DateTime?)ead.Date);
model.minYear = minDate.HasValue ? minDate.Value.Year : default;
if (model.minYear < model.maxYear - 3)
{
model.minYear = model.maxYear - 3;
}
Dictionary <DateTime, int> dayTypes = _ctx.CalendarDays
.Where(cd => cd.Date >= startDate && cd.Date <= endDate)
.ToDictionary(cd => cd.Date, cd => cd.Type);
Dictionary <long, decimal[]> dea = new Dictionary <long, decimal[]>();
using List <UserActivityDate> .Enumerator en = userActivityDates.GetEnumerator();
en.MoveNext();
for (int i = 0; i < displayDays; ++i)
{
DateTime activityDay = startDate.AddDays(i);
int dayType = dayTypes.ContainsKey(activityDay) ? dayTypes[activityDay] : 0; // 0-Working day, 1- Holiday
string workHours = "0";
if (employeeWorkHours.ContainsKey(activityDay))
{
workHours = employeeWorkHours[activityDay].WorkHours;
}
else
{
if (dayType == 1)
{
workHours = "H";
}
else
{
workHours = "8.0";
}
}
model.days[i] = new ActivityDayModel
{
day = activityDay,
dayType = dayType,
hours = workHours
};
while (null != en.Current && en.Current.Date.Date == activityDay)
{
if (!dea.ContainsKey(en.Current.UserActivity.Activity.Id))
{
dea[en.Current.UserActivity.Activity.Id] = new decimal[displayDays];
}
dea[en.Current.UserActivity.Activity.Id][i] += Math.Round(en.Current.Count, 1);
en.MoveNext();
}
}
long[] activityIds = userActivityDates
.Select(ea => ea.UserActivity.Activity.ParentId ?? ea.ActivityId)
.ToArray();
List <UserActivity> userActivities = _ctx.UserActivities
.Where(ea => ea.UserId == userId)
.Include(ea => ea.Activity)
.OrderBy(ea => ea.Activity.Id)
.ToList();
long[] userActivityIds = userActivities
.Select(ea => ea.Activity.ParentId ?? ea.ActivityId)
.ToArray();
// Children contains only Tracked activities
IEnumerable <Activity> userParentActivities;
if (activityIds.Length > 0)
{
// Children contains only Tracked activities
userParentActivities = _ctx.Activities
.Where(a => !a.ParentId.HasValue && (activityIds.Contains(a.Id) || userActivityIds.Contains(a.Id)))
.OrderByDescending(a => activityIds.Contains(a.Id))
.ThenBy(a => a.Id)
.AsEnumerable();
}
else
{
userParentActivities = _ctx.Activities
.Where(a => !a.ParentId.HasValue && userActivityIds.Contains(a.Id))
.AsEnumerable();
}
model.userActivities = new List <EmployeeActivityModel>();
foreach (Activity a in userParentActivities)
{
model.userActivities.Add(new EmployeeActivityModel
{
activity = a,
counts = dea.ContainsKey(a.Id) ? dea[a.Id] : new decimal[displayDays],
countPerMonth = userActivitiesMonth.ContainsKey(a.Id) ? userActivitiesMonth[a.Id] : 0
});
if (a.Children?.Count > 0)
{
foreach (Activity ca in a.Children.OrderBy(x => x.Id))
{
ca.WorkCost = Math.Round(ca.WorkCost.GetValueOrDefault(), 1);
model.userActivities.Add(new EmployeeActivityModel
{
activity = ca,
counts = dea.ContainsKey(ca.Id) ? dea[ca.Id] : new decimal[displayDays],
countPerMonth = userActivitiesMonth.ContainsKey(ca.Id) ? userActivitiesMonth[ca.Id] : 0
});
}
}
}
model.editedDays = GetEditedDays(model.currentDay, startDate);
model.userName = user.Name;
return(Ok(model));
}
