public async Task <bool> DeleteDepartmentStaffingResetJobAsync(int departmentId, CancellationToken cancellationToken = default(CancellationToken))
{
var department = await _departmentsService.GetDepartmentByIdAsync(departmentId);
// TODO: Possible bug here, if they change the managing user after setting up a job, it will miss here
var tasks = (from st in await _scheduledTaskRepository.GetAllAsync()
where st.DepartmentId == departmentId && st.TaskType == (int)TaskTypes.DepartmentStaffingReset
select st).ToList();
//var tasks = GetScheduledTasksByUserType(department.ManagingUserId, (int)TaskTypes.DepartmentStaffingReset);
foreach (var task in tasks)
{
await _scheduledTaskRepository.DeleteAsync(task, cancellationToken);
}
var tasks2 = (from st in await _scheduledTaskRepository.GetAllAsync()
where st.UserId == department.ManagingUserId && st.TaskType == (int)TaskTypes.DepartmentStaffingReset
select st).ToList();
//var tasks = GetScheduledTasksByUserType(department.ManagingUserId, (int)TaskTypes.DepartmentStaffingReset);
foreach (var task in tasks2)
{
await _scheduledTaskRepository.DeleteAsync(task, cancellationToken);
}
InvalidateScheduledTasksCache();
return(true);
}
public async Task <IActionResult> Index()
{
var model = new IndexView();
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId);
model.Profile = _departmentProfileService.GetOrInitializeDepartmentProfile(DepartmentId);
model.ImageUrl = $"{Config.SystemBehaviorConfig.ResgridApiBaseUrl}/api/v3/Avatars/Get?id={model.Profile.DepartmentId}&type=1";
var posts = _departmentProfileService.GetArticlesForDepartment(model.Profile.DepartmentProfileId);
var visiblePosts = _departmentProfileService.GetVisibleArticlesForDepartment(model.Profile.DepartmentProfileId);
if (visiblePosts != null && visiblePosts.Any())
{
model.VisiblePosts = visiblePosts.Count;
}
if (posts.Any())
{
model.Posts = posts.Skip(Math.Max(0, posts.Count() - 3)).ToList();
}
else
{
model.Posts = new List <DepartmentProfileArticle>();
}
return(View(model));
}
public async Task <bool> CanUserViewAndEditWorkLogAsync(string userId, int logId)
{
var department = await _departmentsService.GetDepartmentByUserIdAsync(userId);
var log = await _workLogsService.GetWorkLogByIdAsync(logId);
if (department == null || log == null)
{
return(false);
}
var logDepartment = await _departmentsService.GetDepartmentByIdAsync(log.DepartmentId);
if (department.DepartmentId != logDepartment.DepartmentId)
{
return(false);
}
if (logDepartment.IsUserAnAdmin(userId))
{
return(true);
}
if (log.LoggedByUserId == userId)
{
return(true);
}
if (log.Users.Any(x => x.UserId == userId))
{
return(true);
}
return(false);
}
public async Task <Shift> PopulateShiftData(Shift shift, bool getDepartment, bool getPersonnel, bool getGroups,
bool getSignups, bool getAdmins)
{
if (getDepartment && shift.Department == null)
{
shift.Department = await _departmentsService.GetDepartmentByIdAsync(shift.DepartmentId);
}
if (getPersonnel && shift.Personnel == null)
{
shift.Personnel = (await _shiftPersonRepository.GetAllShiftPersonsByShiftIdAsync(shift.ShiftId)).ToList();
}
else
{
shift.Personnel = new List <ShiftPerson>();
}
if (getGroups && shift.Groups == null)
{
shift.Groups = await GetShiftGroupsForShift(shift.ShiftId);
}
if (getSignups && shift.Signups == null)
{
shift.Signups = (await _shiftSignupRepository.GetAllShiftSignupsByShiftIdAsync(shift.ShiftId)).ToList();
}
return(shift);
}
public async Task <IActionResult> Index()
{
LogsIndexView model = new LogsIndexView();
model.CallLogs = await _workLogsService.GetAllCallLogsForUserAsync(UserId);
model.WorkLogs = await _workLogsService.GetAllLogsForUserAsync(UserId);
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
model.Years = new List <SelectListItem>();
var years = await _workLogsService.GetLogYearsByDeptartmentAsync(DepartmentId);
if (years != null && years.Any())
{
foreach (var year in years)
{
model.Years.Add(new SelectListItem(year, year));
}
model.Year = years[0];
}
return(View(model));
}
public async Task <IActionResult> ViewEntry(int inventoryId)
{
var model = new ViewEntryView();
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId);
model.Inventory = await _inventoryService.GetInventoryByIdAsync(inventoryId);
if (model.Inventory == null || model.Inventory.DepartmentId != DepartmentId)
{
Unauthorized();
}
var profile = await _userProfileService.GetProfileByUserIdAsync(model.Inventory.AddedByUserId);
if (profile != null)
{
model.Name = profile.FullName.AsFirstNameLastName;
}
else
{
model.Name = "Unknown";
}
return(View(model));
}
public async Task <IActionResult> GetAuditLogsList()
{
var auditLogsJson = new List <AuditLogJson>();
var auditLogs = await _auditService.GetAllAuditLogsForDepartmentAsync(DepartmentId);
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
foreach (var auditLog in auditLogs)
{
var auditJson = new AuditLogJson();
auditJson.AuditLogId = auditLog.AuditLogId;
//auditJson.Name = UserHelper.GetFullNameForUser(null, auditLog.UserId);
auditJson.Message = auditLog.Message;
if (auditLog.LoggedOn.HasValue)
{
auditJson.Timestamp = auditLog.LoggedOn.Value.TimeConverterToString(department);
}
else
{
auditJson.Timestamp = "Unknown";
}
auditJson.Type = _auditService.GetAuditLogTypeString((AuditLogTypes)auditLog.LogType);
auditLogsJson.Add(auditJson);
}
return(Json(auditLogsJson));
}
public async Task <ActionResult <List <NotesResult> > > GetAllNotes()
{
var results = new List <NotesResult>();
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
var notes = await _notesService.GetNotesForDepartmentFilteredAsync(DepartmentId, department.IsUserAnAdmin(UserId));
foreach (var n in notes)
{
var noteResult = new NotesResult();
noteResult.Nid = n.NoteId;
noteResult.Uid = n.UserId;
noteResult.Ttl = n.Title;
noteResult.Bdy = StringHelpers.StripHtmlTagsCharArray(n.Body).Truncate(100);
noteResult.Adn = n.AddedOn.TimeConverter(department);
noteResult.Cat = n.Category;
noteResult.Clr = n.Color;
if (n.ExpiresOn.HasValue)
{
noteResult.Exp = n.ExpiresOn.Value;
}
results.Add(noteResult);
}
return(Ok(results));
}
public async Task <IActionResult> Dashboard(bool firstRun = false)
{
var model = new DashboardModel();
var staffingLevel = await _userStateService.GetLastUserStateByUserIdAsync(UserId);
model.UserState = staffingLevel.State;
model.StateNote = staffingLevel.Note;
var staffingLevels = await _customStateService.GetActiveStaffingLevelsForDepartmentAsync(DepartmentId);
if (staffingLevels == null)
{
model.UserStateTypes = model.UserStateEnum.ToSelectList();
ViewBag.UserStateTypes = model.UserStateEnum.ToSelectList();
}
else
{
model.CustomStaffingActive = true;
var selected = staffingLevels.Details.FirstOrDefault(x => x.CustomStateDetailId == staffingLevel.State);
model.UserStateTypes = new SelectList(staffingLevels.GetActiveDetails(), "CustomStateDetailId", "ButtonText", selected);
ViewBag.UserStateTypes = new SelectList(staffingLevels.GetActiveDetails(), "CustomStateDetailId", "ButtonText", selected);
}
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
model.FirstRun = firstRun;
model.Number = await _departmentSettingsService.GetTextToCallNumberForDepartmentAsync(DepartmentId);
model.States = await _customStateService.GetActivePersonnelStateForDepartmentAsync(DepartmentId);
return(View(model));
}
public async Task <ActionResult <List <CalendarItem> > > GetDepartmentCalendarItems()
{
List <CalendarItem> jsonItems = new List <CalendarItem>();
List <Model.CalendarItem> items = null;
items = await _calendarService.GetAllCalendarItemsForDepartmentAsync(DepartmentId);
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
foreach (var item in items)
{
CalendarItem calendarItem = new CalendarItem();
calendarItem.CalendarItemId = item.CalendarItemId;
calendarItem.Title = item.Title;
calendarItem.Start = item.Start.TimeConverter(department);
calendarItem.End = item.End.TimeConverter(department);
calendarItem.StartTimezone = item.StartTimezone;
calendarItem.EndTimezone = item.EndTimezone;
calendarItem.Description = item.Description;
calendarItem.RecurrenceId = item.RecurrenceId;
calendarItem.RecurrenceRule = item.RecurrenceRule;
calendarItem.RecurrenceException = item.RecurrenceException;
calendarItem.IsAllDay = item.IsAllDay;
calendarItem.ItemType = item.ItemType;
calendarItem.Location = item.Location;
calendarItem.SignupType = item.SignupType;
calendarItem.Reminder = item.Reminder;
calendarItem.LockEditing = item.LockEditing;
calendarItem.Entities = item.Entities;
calendarItem.RequiredAttendes = item.RequiredAttendes;
calendarItem.OptionalAttendes = item.OptionalAttendes;
if (!String.IsNullOrWhiteSpace(item.CreatorUserId))
{
calendarItem.CreatorUserId = item.CreatorUserId.ToString();
}
if (department.IsUserAnAdmin(UserId))
{
calendarItem.IsAdminOrCreator = true;
}
else if (!String.IsNullOrWhiteSpace(item.CreatorUserId) && item.CreatorUserId == UserId)
{
calendarItem.IsAdminOrCreator = true;
}
else
{
calendarItem.IsAdminOrCreator = false;
}
jsonItems.Add(calendarItem);
}
return(Ok(jsonItems));
}
public async Task <IActionResult> Index()
{
LogsIndexView model = new LogsIndexView();
model.CallLogs = await _workLogsService.GetAllCallLogsForUserAsync(UserId);
model.WorkLogs = await _workLogsService.GetAllLogsForUserAsync(UserId);
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
return(View(model));
}
public async Task <IActionResult> Index()
{
var model = new LinksIndexView();
model.DepartmentId = DepartmentId;
model.Links = await _departmentLinksService.GetAllLinksForDepartmentAsync(DepartmentId);
model.CanCreateLinks = await _limitsService.CanDepartmentUseLinksAsync(DepartmentId);
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId);
model.Code = department.LinkCode;
return(View(model));
}
public async Task <IActionResult> Report(int trainingId)
{
var model = new TrainingReportView();
model.Training = await _trainingService.GetTrainingByIdAsync(trainingId);
model.UserGroups = new Dictionary <string, string>();
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
if (model.Training.DepartmentId != DepartmentId)
{
Unauthorized();
}
foreach (var user in model.Training.Users)
{
var group = await _departmentGroupsService.GetGroupForUserAsync(user.UserId, DepartmentId);
if (group != null)
{
model.UserGroups.Add(user.UserId, group.Name);
}
}
return(View(model));
}
public async Task <List <ResourceOrder> > GetAllOrdersByDepartmentIdAsync(int departmentId)
{
var items = await _resourceOrdersRepository.GetAllByDepartmentIdAsync(departmentId);
if (items != null && items.Any())
{
var orders = items.ToList();
for (int i = 0; i < orders.Count; i++)
{
orders[i].Department = await _departmentsService.GetDepartmentByIdAsync(orders[i].DepartmentId);
}
}
return(new List <ResourceOrder>());
}
public async Task <List <ResourceOrder> > GetOpenAvailableOrdersAsync(int departmentId)
{
var orders = new List <ResourceOrder>();
var departmentSettings = await GetSettingsByDepartmentIdAsync(departmentId);
var department = await _departmentsService.GetDepartmentByIdAsync(departmentId);
var mapCenterLocation = await _departmentSettingsService.GetMapCenterCoordinatesAsync(department);
// Target department does not want to recieve orders
if (departmentSettings != null && departmentSettings.DoNotReceiveOrders)
{
return(orders);
}
var allRangeOrders = await _resourceOrdersRepository.GetAllNonDepartmentOpenVisibleOrdersAsync(departmentId);
orders.AddRange(allRangeOrders.Where(x => (x.OriginLocation.GetDistanceTo(new GeoCoordinate(mapCenterLocation.Latitude.Value, mapCenterLocation.Longitude.Value)) / 1609.344) <= x.Range));
// TODO: Yea :-(
//orders.AddRange(await _genericResourceOrderRepository.GetAll().Where(x => x.DepartmentId != departmentId && x.CloseDate == null && x.Visibility == 3).ToListAsync());
//orders.AddRange(await _resourceOrdersRepository.GetAllOpenOrdersLinked(departmentId));
return(orders);
}
public async Task <bool> CreateInvitesAsync(Department department, string addingUserId, List <string> emailAddresses, CancellationToken cancellationToken = default(CancellationToken))
{
var sendingUser = _usersService.GetUserById(addingUserId);
var sendingProfile = await _userProfileService.GetProfileByUserIdAsync(addingUserId);
for (int i = 0; i < emailAddresses.Count; i++)
{
Invite invite = new Invite();
invite.Code = Guid.NewGuid();
invite.DepartmentId = department.DepartmentId;
invite.EmailAddress = emailAddresses[i];
invite.SendingUserId = addingUserId;
invite.SentOn = DateTime.UtcNow;
await _invitesRepository.SaveOrUpdateAsync(invite, cancellationToken);
if (invite.Department == null && department != null)
{
invite.Department = department;
}
else if (invite.Department == null)
{
invite.Department = await _departmentsService.GetDepartmentByIdAsync(department.DepartmentId);
}
await _emailService.SendInviteAsync(invite, sendingProfile.FullName.AsFirstNameLastName, sendingUser.Email);
}
return(true);
}
public async Task <bool> SendInviteAsync(Invite invite, string senderName, string senderEmail)
{
if (invite == null)
{
return(false);
}
if (invite.Department == null)
{
invite.Department = await _departmentsService.GetDepartmentByIdAsync(invite.DepartmentId);
}
await _emailProvider.SendInviteMail(invite.Code.ToString(), invite.Department.Name, invite.EmailAddress, senderName, senderEmail);
return(true);
}
public async Task <IActionResult> Index()
{
var model = new UnitsIndexView();
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId);
model.CanUserAddUnit = await _limitsService.CanDepartmentAddNewUnit(DepartmentId);
model.Groups = await _departmentGroupsService.GetAllGroupsForDepartmentAsync(DepartmentId);
model.Units = await _unitsService.GetUnitsForDepartmentAsync(DepartmentId);
model.States = await _unitsService.GetAllLatestStatusForUnitsByDepartmentIdAsync(DepartmentId);
model.UnitStatuses = await _customStateService.GetAllActiveUnitStatesForDepartmentAsync(DepartmentId);
model.UnitCustomStates = new Dictionary <int, CustomState>();
foreach (var unit in model.Units)
{
var type = await _unitsService.GetUnitTypeByNameAsync(DepartmentId, unit.Type);
if (type != null && type.CustomStatesId.HasValue)
{
var customStates = await _customStateService.GetCustomSateByIdAsync(type.CustomStatesId.Value);
if (customStates != null)
{
model.UnitCustomStates.Add(unit.UnitId, customStates);
}
}
}
return(View(model));
}
public async Task <IActionResult> GetActiveCallsAsRSS(string key)
{
if (String.IsNullOrWhiteSpace(key))
{
return(null);
}
var departmentId = await _departmentSettingsService.GetDepartmentIdForRssKeyAsync(key);
if (!departmentId.HasValue)
{
return(null);
}
var department = await _departmentsService.GetDepartmentByIdAsync(departmentId.Value);
var calls = await _callsService.GetActiveCallsByDepartmentAsync(departmentId.Value);
var feed = new SyndicationFeed(string.Format("{0} Active Calls", department.Name), string.Format("The active calls for the department {0}", department.Name), new Uri(Config.SystemBehaviorConfig.ResgridBaseUrl));
feed.Authors.Add(new SyndicationPerson("*****@*****.**"));
feed.Categories.Add(new SyndicationCategory("Resgrid Calls"));
feed.Description = new TextSyndicationContent(string.Format("The active calls for the department {0}", department.Name));
feed.Items = calls.Select(call => new SyndicationItem(call.Name, call.NatureOfCall, new Uri($"{Config.SystemBehaviorConfig.ResgridBaseUrl}/User/Dispatch/ViewCall?callId=" + call.CallId), call.CallId.ToString(), call.LoggedOn)).ToList();
var settings = new XmlWriterSettings
{
Encoding = Encoding.UTF8,
NewLineHandling = NewLineHandling.Entitize,
NewLineOnAttributes = true,
Indent = true
};
using (var stream = new MemoryStream())
{
using (var xmlWriter = XmlWriter.Create(stream, settings))
{
var rssFormatter = new Rss20FeedFormatter(feed, false);
rssFormatter.WriteTo(xmlWriter);
xmlWriter.Flush();
}
return(File(stream.ToArray(), "application/rss+xml; charset=utf-8"));
}
}
public async Task <ActionResult <StatusResult> > GetCurrentUserStatus()
{
var action = await _actionLogsService.GetLastActionLogForUserAsync(UserId, DepartmentId);
var userState = await _userStateService.GetLastUserStateByUserIdAsync(UserId);
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
var statusResult = new StatusResult
{
Act = (int)ActionTypes.StandingBy,
Uid = UserId.ToString(),
Ste = userState.State,
Sts = userState.Timestamp.TimeConverter(department)
};
if (action == null)
{
statusResult.Ats = DateTime.UtcNow.TimeConverter(department);
}
else
{
statusResult.Act = action.ActionTypeId;
statusResult.Ats = action.Timestamp.TimeConverter(department);
if (action.DestinationId.HasValue)
{
if (action.ActionTypeId == (int)ActionTypes.RespondingToScene)
{
statusResult.Did = action.DestinationId.Value;
}
else if (action.ActionTypeId == (int)ActionTypes.RespondingToStation)
{
statusResult.Did = action.DestinationId.Value;
}
else if (action.ActionTypeId == (int)ActionTypes.AvailableStation)
{
statusResult.Did = action.DestinationId.Value;
}
}
}
return(Ok(statusResult));
}
public async Task <ActionResult <IEnumerable <MessageResult> > > GetMessages()
{
var result = new List <MessageResult>();
var messages = (await _messageService.GetInboxMessagesByUserIdAsync(UserId)).OrderBy(x => x.SentOn).OrderByDescending(x => x.SentOn);
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
foreach (var m in messages)
{
var message = new MessageResult();
message.Mid = m.MessageId;
message.Sub = m.Subject;
message.Bdy = StringHelpers.StripHtmlTagsCharArray(m.Body).Truncate(100);
message.Son = m.SentOn.TimeConverter(department);
message.SUtc = m.SentOn;
message.Typ = m.Type;
if (!String.IsNullOrWhiteSpace(m.SendingUserId))
{
message.Uid = m.SendingUserId;
}
var respose = m.MessageRecipients.FirstOrDefault(x => x.UserId == UserId);
if (respose != null)
{
if (String.IsNullOrWhiteSpace(respose.Response))
{
message.Rsp = true;
}
message.Ron = respose.ReadOn;
}
else
{
message.Ron = m.ReadOn;
}
result.Add(message);
}
return(Ok(result));
}
public async Task <IActionResult> Index()
{
var model = new OrdersIndexView();
model.YourOrders = new List <ResourceOrder>();
model.YourOrders.AddRange((await _resourceOrdersService.GetAllOrdersByDepartmentIdAsync(DepartmentId)).OrderByDescending(x => x.OpenDate));
model.OthersOrders = new List <ResourceOrder>();
model.OthersOrders.AddRange(await _resourceOrdersService.GetOpenAvailableOrdersAsync(DepartmentId));
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId);
model.Coordinates = await _departmentSettingsService.GetMapCenterCoordinatesAsync(model.Department);
return(View(model));
}
public async Task <ActionResult <List <UnitStatusResult> > > GetUnitStatuses(string activeFilter)
{
var results = new List <UnitStatusResult>();
string filter = null;
string[] activeFilters = null;
if (!String.IsNullOrWhiteSpace(activeFilter))
{
filter = HttpUtility.UrlDecode(activeFilter);
activeFilters = filter.Split(char.Parse("|"));
}
var filters = await GetFilterOptions();
var units = await _unitsService.GetAllLatestStatusForUnitsByDepartmentIdAsync(DepartmentId);
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
foreach (var u in units)
{
var unitStatus = new UnitStatusResult();
unitStatus.Uid = u.UnitId;
unitStatus.Typ = u.State;
unitStatus.Tmp = u.Timestamp.TimeConverter(department);
if (u.DestinationId.HasValue)
{
unitStatus.Did = u.DestinationId.Value;
}
if (activeFilters != null)
{
foreach (var afilter in activeFilters)
{
var text = GetTextValue(afilter, filters);
if (afilter.Substring(0, 2) == "G:")
{
if (u.Unit != null && u.Unit.StationGroup != null && text == u.Unit.StationGroup.Name)
{
results.Add(unitStatus);
break;
}
}
}
}
else
{
results.Add(unitStatus);
}
}
return(Ok(results));
}
public async Task <ActionResult <List <DepartmentLinkResult> > > GetActiveDepartmentLinks()
{
if (!await _limitsService.CanDepartmentUseLinksAsync(DepartmentId))
{
return(new List <DepartmentLinkResult>());
}
var linkResults = new List <DepartmentLinkResult>();
var links = await _departmentLinksService.GetAllLinksForDepartmentAsync(DepartmentId);
foreach (var link in links)
{
if (link.LinkedDepartmentId == DepartmentId && link.LinkEnabled)
{
var department = await _departmentsService.GetDepartmentByIdAsync(link.DepartmentId);
var result = new DepartmentLinkResult();
result.LinkId = link.DepartmentLinkId;
result.DepartmentName = department.Name;
result.Color = link.DepartmentColor;
result.ShareCalls = link.DepartmentShareCalls;
result.ShareOrders = link.DepartmentShareOrders;
result.SharePersonnel = link.DepartmentSharePersonnel;
result.ShareUnits = link.DepartmentShareUnits;
linkResults.Add(result);
}
}
return(linkResults);
}
public async Task <IActionResult> View(int id)
{
if (!await _authorizationService.CanUserViewProtocolAsync(UserId, id))
{
Unauthorized();
}
var model = new ViewProtocolModel();
model.Protocol = await _protocolsService.GetProtocolByIdAsync(id);
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
return(View(model));
}
public async Task <ActionResult <List <ProtocolResult> > > GetAllProtocols()
{
var results = new List <ProtocolResult>();
var department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
var protocols = await _protocolsService.GetAllProtocolsForDepartmentAsync(DepartmentId);
foreach (var p in protocols)
{
results.Add(ProtocolResult.Convert(p));
}
return(Ok(results));
}
public async Task <IActionResult> View(int noteId)
{
ViewNoteView model = new ViewNoteView();
var note = await _notesService.GetNoteByIdAsync(noteId);
if (note.DepartmentId != DepartmentId)
{
Unauthorized();
}
model.Note = note;
model.Department = await _departmentsService.GetDepartmentByIdAsync(note.DepartmentId);
return(View(model));
}
public async Task <IActionResult> Index(string type, string category)
{
var model = new IndexView();
model.Department = await _departmentsService.GetDepartmentByIdAsync(DepartmentId, false);
model.Documents = await _documentsService.GetFilteredDocumentsByDepartmentIdAsync(DepartmentId, type, category);
model.Categories = await _documentsService.GetDistinctCategoriesByDepartmentIdAsync(DepartmentId);
model.SelectedCategory = category;
model.SelectedType = type;
model.UserId = UserId;
return(View(model));
}
public async Task <List <Training> > GetTrainingsToNotifyAsync(DateTime currentTime)
{
var trainingsToNotify = new List <Training>();
var trainings = await _trainingRepository.GetAllAsync();
if (trainings != null && trainings.Any())
{
foreach (var training in trainings)
{
if (!training.Notified.HasValue)
{
trainingsToNotify.Add(training);
}
else
{
Department d;
if (training.Department != null)
{
d = training.Department;
}
else
{
d = await _departmentService.GetDepartmentByIdAsync(training.DepartmentId);
}
if (d != null)
{
var localizedDate = currentTime.TimeConverter(d);
var setToNotify = new DateTime(localizedDate.Year, localizedDate.Month, localizedDate.Day, 10, 0, 0, 0);
if (localizedDate == setToNotify.Within(TimeSpan.FromMinutes(13)) && training.ToBeCompletedBy.HasValue)
{
if (localizedDate.AddDays(1).ToShortDateString() == training.ToBeCompletedBy.Value.ToShortDateString())
{
trainingsToNotify.Add(training);
}
}
}
}
}
}
return(trainingsToNotify);
}
public async Task <Coordinates> GetMapCenterCoordinatesForGroupAsync(int departmentGroupId)
{
Coordinates coordinates = null;
var departmentGroup = await GetGroupByIdAsync(departmentGroupId);
var department = await _departmentsService.GetDepartmentByIdAsync(departmentGroup.DepartmentId);
if (departmentGroup.Address != null)
{
coordinates = new Coordinates();
string coordinateString = await _geoLocationProvider.GetLatLonFromAddress(string.Format("{0} {1} {2} {3} {4}", departmentGroup.Address.Address1,
departmentGroup.Address.City, departmentGroup.Address.State, departmentGroup.Address.PostalCode,
departmentGroup.Address.Country));
var coords = coordinateString.Split(char.Parse(","));
coordinates.Latitude = double.Parse(coords[0]);
coordinates.Longitude = double.Parse(coords[1]);
}
if (coordinates == null && department.Address != null)
{
coordinates = new Coordinates();
string coordinateString = await _geoLocationProvider.GetLatLonFromAddress(string.Format("{0} {1} {2} {3} {4}", department.Address.Address1,
department.Address.City, department.Address.State, department.Address.PostalCode, department.Address.Country));
var coords = coordinateString.Split(char.Parse(","));
coordinates.Latitude = double.Parse(coords[0]);
coordinates.Longitude = double.Parse(coords[1]);
}
var gpsCoordinates = await _departmentSettingsService.GetBigBoardCenterGpsCoordinatesDepartmentAsync(departmentGroup.DepartmentId);
if (coordinates == null && !string.IsNullOrWhiteSpace(gpsCoordinates))
{
coordinates = new Coordinates();
var coords = gpsCoordinates.Split(char.Parse(","));
coordinates.Latitude = double.Parse(coords[0]);
coordinates.Longitude = double.Parse(coords[1]);
}
return(coordinates);
}
