Develop

Core/Resgrid.Model/PhoneNumberResult.cs

@@ -7,5 +7,12 @@ public class PhoneNumberResult
 		public bool IsValid { get; set; }
 		public string CountryCode { get; set; }
 		public string ErrorMessage { get; set; }
+
+		/// <summary>
+		/// ISO region the number actually parsed as ("GB", "AU"), which is not necessarily the region
+		/// that was passed in - an E.164 number carries its own. Lets a caller learn the region a set of
+		/// numbers belongs to and reuse it for the ones that arrived in national format.
+		/// </summary>
+		public string Region { get; set; }
 	}
 }

Core/Resgrid.Model/Repositories/IActionLogsRepository.cs

@@ -14,11 +14,20 @@ public interface IActionLogsRepository: IRepository<ActionLog>
 		/// <summary>
 		/// Gets the last action logs for department asynchronous.
 		/// </summary>
+		/// <remarks>
+		/// BREAKING CHANGE: the <paramref name="includeHiddenAndDisabled"/> parameter was added to this
+		/// signature. The default value keeps ordinary call sites source compatible, but implementers of
+		/// this interface must add the parameter, precompiled assemblies bound to the three parameter
+		/// overload must be rebuilt, and expression tree call sites (Moq Setup/Verify, LINQ expressions)
+		/// must pass the argument explicitly because C# rejects omitted optional arguments there (CS0854).
+		/// See Documentation/breaking-changes.md.
+		/// </remarks>
 		/// <param name="departmentId">The department identifier.</param>
 		/// <param name="disableAutoAvailable">if set to <c>true</c> [disable automatic available].</param>
 		/// <param name="timeStamp">The time stamp.</param>
+		/// <param name="includeHiddenAndDisabled">if set to <c>true</c> include logs for hidden and disabled department members.</param>
 		/// <returns>Task&lt;IEnumerable&lt;ActionLog&gt;&gt;.</returns>
-		Task<IEnumerable<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool disableAutoAvailable, DateTime timeStamp);
+		Task<IEnumerable<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool disableAutoAvailable, DateTime timeStamp, bool includeHiddenAndDisabled = false);
 
 		/// <summary>
 		/// Gets all action logs for user.

Core/Resgrid.Model/Services/IActionLogsService.cs

@@ -26,11 +26,20 @@ public interface IActionLogsService
 		/// <summary>
 		/// Gets the last action logs for department asynchronous.
 		/// </summary>
+		/// <remarks>
+		/// BREAKING CHANGE: the <paramref name="includeHiddenAndDisabled"/> parameter was added to this
+		/// signature. The default value keeps ordinary call sites source compatible, but implementers of
+		/// this interface must add the parameter, precompiled assemblies bound to the three parameter
+		/// overload must be rebuilt, and expression tree call sites (Moq Setup/Verify, LINQ expressions)
+		/// must pass the argument explicitly because C# rejects omitted optional arguments there (CS0854).
+		/// See Documentation/breaking-changes.md.
+		/// </remarks>
 		/// <param name="departmentId">The department identifier.</param>
 		/// <param name="forceDisableAutoAvailable">if set to <c>true</c> [force disable automatic available].</param>
 		/// <param name="bypassCache">if set to <c>true</c> [bypass cache].</param>
+		/// <param name="includeHiddenAndDisabled">if set to <c>true</c> include logs for hidden and disabled members.</param>
 		/// <returns>Task&lt;List&lt;ActionLog&gt;&gt;.</returns>
-		Task<List<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool forceDisableAutoAvailable = false, bool bypassCache = false);
+		Task<List<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool forceDisableAutoAvailable = false, bool bypassCache = false, bool includeHiddenAndDisabled = false);
 
 		/// <summary>
 		/// Gets all action logs for user.

Core/Resgrid.Services/ActionLogsService.cs

@@ -71,7 +71,7 @@ public void InvalidateActionLogs(int departmentId)
 			_cacheProvider.Remove(string.Format(CacheKey, departmentId));
 		}
 
-		public async Task<List<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool forceDisableAutoAvailable = false, bool bypassCache = false)
+		public async Task<List<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool forceDisableAutoAvailable = false, bool bypassCache = false, bool includeHiddenAndDisabled = false)
 		{
 			async Task<List<ActionLog>> getActionLogs()
 			{
@@ -83,7 +83,7 @@ async Task<List<ActionLog>> getActionLogs()
 				else
 					disableAutoAvailable = await _departmentSettingsService.GetDisableAutoAvailableForDepartmentAsync(departmentId, false);
 
-				var statuses = await _actionLogsRepository.GetLastActionLogsForDepartmentAsync(departmentId, disableAutoAvailable, time);
+				var statuses = await _actionLogsRepository.GetLastActionLogsForDepartmentAsync(departmentId, disableAutoAvailable, time, includeHiddenAndDisabled);
 
 				var values = statuses.GroupBy(l => l.UserId)
 					.Select(g => g.OrderByDescending(l => l.ActionLogId).First())
@@ -110,7 +110,7 @@ async Task<List<ActionLog>> getActionLogs()
 
 			if (!bypassCache)
 			{
-				return await _cacheProvider.RetrieveAsync(string.Format(CacheKey, departmentId), (Func<Task<List<ActionLog>>>) getActionLogs, CacheLength);
+				return await _cacheProvider.RetrieveAsync(string.Format(CacheKey, departmentId) + (includeHiddenAndDisabled ? "_IncHidden" : ""), (Func<Task<List<ActionLog>>>) getActionLogs, CacheLength);
 			}
 
 			return await getActionLogs();

Core/Resgrid.Services/CallEmailTemplates/CallEmailFactory.cs

@@ -5,6 +5,7 @@
 using Resgrid.Model.Identity;
 using System.Threading.Tasks;
 using Resgrid.Model.Providers;
+using Resgrid.Framework;
 
 namespace Resgrid.Services.CallEmailTemplates
 {
@@ -48,6 +49,8 @@ public async Task<Call> GenerateCallFromEmailText(CallEmailTypes type, CallEmail
 			try
 			{
 				call = await _templates[(int)type].GenerateCall(email, managingUser, users, department, activeCalls, units, priority, activePriorities, callTypes, geolocationProvider);
+
+				EnsureRequiredValues(call, email);
 			}
 			catch (Exception ex)
 			{
@@ -56,5 +59,33 @@ public async Task<Call> GenerateCallFromEmailText(CallEmailTypes type, CallEmail
 
 			return call;
 		}
+
+		/// <summary>
+		/// Name and NatureOfCall are non-nullable on the Calls table. A template that can't find a value
+		/// for either, a CAD sending a blank segment or a body that didn't match the format, would hand
+		/// back a null and lose the dispatch on the insert. Fall back to the email itself instead.
+		/// </summary>
+		private static void EnsureRequiredValues(Call call, CallEmail email)
+		{
+			if (call == null)
+				return;
+
+			if (String.IsNullOrWhiteSpace(call.NatureOfCall))
+				call.NatureOfCall = FirstWithValue(email?.Subject, email?.Body, email?.TextBody);
+
+			if (String.IsNullOrWhiteSpace(call.Name))
+				call.Name = FirstWithValue(email?.Subject, call.NatureOfCall);
+		}
+
+		private static string FirstWithValue(params string[] values)
+		{
+			foreach (var value in values)
+			{
+				if (!String.IsNullOrWhiteSpace(value))
+					return value.Trim().Truncate(4000);
+			}
+
+			return String.Empty;
+		}
 	}
 }

Core/Resgrid.Services/CallEmailTemplates/ResgridEmailTemplate.cs

@@ -41,7 +41,11 @@ public async Task<Call> GenerateCall(CallEmail email, string managingUser, List<
 				c.Type = ParseCallType(GetValue(data, 1), callTypes);
 				c.Priority = ParseCallPriority(GetValue(data, 2), priority, activePriorities);
 				c.MapPage = GetValue(data, 4);
-				c.NatureOfCall = GetValue(data, 5);
+
+				// NATURE is a non-nullable column but CADs do send the segment empty. Fall back to
+				// the call type and then the subject so the dispatch still lands, GetValue hands
+				// back a null for a blank segment and that used to fail the insert.
+				c.NatureOfCall = GetValue(data, 5) ?? GetValue(data, 1) ?? email.Subject;
 
 				// Re-join everything from index 6 on, a pipe inside the notes text shouldn't
 				// truncate them. When NOTES isn't supplied the raw body stays in Notes, which

Providers/Resgrid.Providers.Number/PhoneNumberProcesserProvider.cs

@@ -1,4 +1,7 @@
-using System;
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Text;
 using Resgrid.Model;
 using Resgrid.Model.Providers;
 
@@ -14,33 +17,36 @@ public PhoneNumberResult Process(string phoneNumber, string countryCode = null)
 			{
 				var territory = string.IsNullOrWhiteSpace(countryCode) ? "US" : countryCode.ToUpperInvariant();
 
-				// Normalize: strip non-digit characters except leading +
-				var cleaned = phoneNumber?.Trim() ?? string.Empty;
+				// Strip characters the parser cannot see past. Real stored numbers carry invisible
+				// bidi/format marks pasted in from other apps, tabs, and non-standard brackets - all of
+				// which make an otherwise perfectly good number fail to parse.
+				var cleaned = Sanitize(phoneNumber);
 
-				GlobalPhone.Number number;
-				// Try with the given territory first
-				if (GlobalPhone.GlobalPhone.TryParse(cleaned, out number, territory) && number.IsValid)
-				{
-					result.IsValid = true;
-					result.InternationalNumber = number.InternationalString;
-					result.LocalNumber = number.NationalString;
+				if (string.IsNullOrWhiteSpace(cleaned))
 					return result;
-				}
 
-				// Try with no territory hint (for numbers starting with +)
-				if (GlobalPhone.GlobalPhone.TryParse(cleaned, out number, "ZZ") && number.IsValid)
+				// In order of confidence. The first two are the original behaviour; the rest only ever
+				// run once those have failed, so a number that parsed before still parses the same way.
+				foreach (var attempt in Attempts(cleaned, territory))
 				{
+					if (!GlobalPhone.GlobalPhone.TryParse(attempt.Value, out var candidate, attempt.Territory) ||
+						candidate == null || !candidate.IsValid)
+						continue;
+
 					result.IsValid = true;
-					result.InternationalNumber = number.InternationalString;
-					result.LocalNumber = number.NationalString;
+					result.InternationalNumber = candidate.InternationalString;
+					result.LocalNumber = candidate.NationalString;
+					result.Region = candidate.RegionCode;
+
 					return result;
 				}
 
-				result.IsValid = number != null && number.IsValid;
-				if (number != null)
+				// Nothing parsed. Report against the original input so the caller sees what it passed in.
+				if (GlobalPhone.GlobalPhone.TryParse(cleaned, out var parsed, territory) && parsed != null)
 				{
-					result.InternationalNumber = number.InternationalString;
-					result.LocalNumber = number.NationalString;
+					result.InternationalNumber = parsed.InternationalString;
+					result.LocalNumber = parsed.NationalString;
+					result.Region = parsed.RegionCode;
 				}
 			}
 			catch (Exception e)
@@ -51,5 +57,72 @@ public PhoneNumberResult Process(string phoneNumber, string countryCode = null)
 
 			return result;
 		}
+
+		private static (string Value, string Territory)[] Attempts(string cleaned, string territory)
+		{
+			var digits = new string(cleaned.Where(char.IsDigit).ToArray());
+
+			return new[]
+			{
+				// Original behaviour: the caller's region, then no region hint (for "+" numbers).
+				(cleaned, territory),
+				(cleaned, "ZZ"),
+
+				// "00" is the international access prefix in most of the world - the typed equivalent of
+				// "+". Stored values routinely use it ("0040...", "00306..."), and it parses as nothing.
+				(cleaned.StartsWith("00", StringComparison.Ordinal) && digits.Length > 4
+					? "+" + digits.Substring(2)
+					: null, "ZZ"),
+
+				// A country code with no "+" at all ("447700900123"). Only worth trying when the length
+				// rules out a national number, and only after the region attempts have failed - so a
+				// valid national number is never reinterpreted as an international one.
+				(digits.Length >= 11 && digits.Length <= 15 && !cleaned.Contains('+')
+					? "+" + digits
+					: null, "ZZ")
+			}
+			.Where(a => !string.IsNullOrWhiteSpace(a.Item1))
+			.Select(a => (a.Item1, a.Item2))
+			.ToArray();
+		}
+
+		/// <summary>
+		/// Removes characters that carry no dialling meaning but do stop the number parsing: Unicode
+		/// format and control marks (bidi overrides pasted in from other applications), and bracket
+		/// styles the parser does not recognise. Digits, "+", and the ordinary separators the parser
+		/// already understands are left exactly as they are.
+		/// </summary>
+		private static string Sanitize(string phoneNumber)
+		{
+			if (string.IsNullOrWhiteSpace(phoneNumber))
+				return string.Empty;
+
+			var builder = new StringBuilder(phoneNumber.Length);
+
+			foreach (var character in phoneNumber)
+			{
+				var category = CharUnicodeInfo.GetUnicodeCategory(character);
+
+				if (category == UnicodeCategory.Format || category == UnicodeCategory.Control)
+					continue;
+
+				// "{201} 555-0123" is a real stored shape; the parser handles "()" but not "{}" or "[]".
+				if (character == '{' || character == '[')
+				{
+					builder.Append('(');
+					continue;
+				}
+
+				if (character == '}' || character == ']')
+				{
+					builder.Append(')');
+					continue;
+				}
+
+				builder.Append(character);
+			}
+
+			return builder.ToString().Trim();
+		}
 	}
 }

Repositories/Resgrid.Repositories.DataRepository/ActionLogsRepository.cs

@@ -31,7 +31,7 @@ public ActionLogsRepository(IConnectionProvider connectionProvider, SqlConfigura
 			_unitOfWork = unitOfWork;
 		}
 
-		public async Task<IEnumerable<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool disableAutoAvailable, DateTime timeStamp)
+		public async Task<IEnumerable<ActionLog>> GetLastActionLogsForDepartmentAsync(int departmentId, bool disableAutoAvailable, DateTime timeStamp, bool includeHiddenAndDisabled = false)
 		{
 			try
 			{
@@ -45,7 +45,9 @@ public async Task<IEnumerable<ActionLog>> GetLastActionLogsForDepartmentAsync(in
 					dynamicParameters.Add("Timestamp", timeStamp);
 					dynamicParameters.Add("LatestTimestamp", latestTimestamp);
 
-					var query = _queryFactory.GetQuery<SelectLastActionLogsForDepartmentQuery>();
+					var query = includeHiddenAndDisabled
+						? _queryFactory.GetQuery<SelectLastActionLogsForDepartmentIncHiddenQuery>()
+						: _queryFactory.GetQuery<SelectLastActionLogsForDepartmentQuery>();
 
 					return await x.QueryAsync<ActionLog, IdentityUser, ActionLog>(sql: query,
 						param: dynamicParameters,

Repositories/Resgrid.Repositories.DataRepository/Configs/SqlConfiguration.cs

@@ -28,6 +28,7 @@ protected SqlConfiguration() { }
 		public string ActionLogsTable { get; set; }
 
 		public string SelectLastActionLogsForDepartmentQuery { get; set; }
+		public string SelectLastActionLogsForDepartmentIncHiddenQuery { get; set; }
 		public string SelectActionLogsByUserIdQuery { get; set; }
 		public string SelectALogsByUserInDateRangQuery { get; set; }
 		public string SelectALogsByDateRangeQuery { get; set; }

Repositories/Resgrid.Repositories.DataRepository/Queries/ActionLogs/SelectLastActionLogsForDepartmentIncHiddenQuery.cs

@@ -0,0 +1,64 @@
+using System;
+using Resgrid.Model;
+using Resgrid.Model.Repositories.Queries.Contracts;
+using Resgrid.Repositories.DataRepository.Configs;
+using Resgrid.Repositories.DataRepository.Extensions;
+
+namespace Resgrid.Repositories.DataRepository.Queries.ActionLogs
+{
+    public class SelectLastActionLogsForDepartmentIncHiddenQuery : ISelectQuery
+    {
+        private readonly SqlConfiguration _sqlConfiguration;
+        public SelectLastActionLogsForDepartmentIncHiddenQuery(SqlConfiguration sqlConfiguration)
+        {
+            // Guarded here so every SqlConfiguration access in GetQuery is provably safe. A missing
+            // configuration is a container misregistration, fail at construction rather than handing
+            // back a query string that would reach the database malformed.
+            _sqlConfiguration = sqlConfiguration ?? throw new ArgumentNullException(nameof(sqlConfiguration));
+        }
+
+        public string GetQuery()
+        {
+	        var queryTemplate = _sqlConfiguration.SelectLastActionLogsForDepartmentIncHiddenQuery;
+
+	        if (string.IsNullOrWhiteSpace(queryTemplate))
+		        throw new InvalidOperationException(
+			        $"{nameof(SqlConfiguration.SelectLastActionLogsForDepartmentIncHiddenQuery)} is not set on {_sqlConfiguration.GetType().Name}.");
+
+	        var query = queryTemplate
+		        .ReplaceQueryParameters(_sqlConfiguration, _sqlConfiguration.SchemaName,
+			        string.Empty,
+			        _sqlConfiguration.ParameterNotation,
+			        new string[] {
+				        "%DID%",
+				        "%DAA%",
+				        "%LTS%",
+				        "%TS%"
+			        },
+			        new string[] {
+				        "DepartmentId",
+				        "DisableAutoAvailable",
+				        "LatestTimestamp",
+				        "Timestamp"
+			        },
+			        new string[] {
+				        "%ACTIONLOGSTABLE%",
+				        "%ASPNETUSERSTABLE%",
+						"%DEPARTMENTMEMBERSTABLE%"
+			        },
+			        new string[] {
+				        _sqlConfiguration.ActionLogsTable,
+				        _sqlConfiguration.UserTable,
+						_sqlConfiguration.DepartmentMembersTable
+			        }
+		        );
+
+	        return query;
+        }
+
+        public string GetQuery<TEntity>() where TEntity : class, IEntity
+        {
+	        throw new System.NotImplementedException();
+        }
+    }
+}

Repositories/Resgrid.Repositories.DataRepository/Servers/PostgreSql/PostgreSqlConfiguration.cs

@@ -49,10 +49,18 @@ public PostgreSqlConfiguration()
 							SELECT al.*, u.*
 							FROM %SCHEMA%.%ACTIONLOGSTABLE% al
 							INNER JOIN %SCHEMA%.%ASPNETUSERSTABLE% u ON u.Id = al.UserId
-							INNER JOIN %SCHEMA%.%DEPARTMENTMEMBERSTABLE% dm ON dm.UserId = al.UserId
+							INNER JOIN %SCHEMA%.%DEPARTMENTMEMBERSTABLE% dm ON dm.UserId = al.UserId AND dm.DepartmentId = al.DepartmentId
 							WHERE al.DepartmentId = %DID% AND dm.IsDeleted = false AND
 							(%DAA% = true OR al.Timestamp >= %TS%) AND
 							dm.IsDisabled = false AND dm.IsHidden = false AND al.Timestamp >= %LTS%";
+			SelectLastActionLogsForDepartmentIncHiddenQuery = @"
+							SELECT al.*, u.*
+							FROM %SCHEMA%.%ACTIONLOGSTABLE% al
+							INNER JOIN %SCHEMA%.%ASPNETUSERSTABLE% u ON u.Id = al.UserId
+							INNER JOIN %SCHEMA%.%DEPARTMENTMEMBERSTABLE% dm ON dm.UserId = al.UserId AND dm.DepartmentId = al.DepartmentId
+							WHERE al.DepartmentId = %DID% AND dm.IsDeleted = false AND
+							(%DAA% = true OR al.Timestamp >= %TS%) AND
+							al.Timestamp >= %LTS%";
 			SelectActionLogsByUserIdQuery = @"
 					SELECT %SCHEMA%.%ACTIONLOGSTABLE%.*, %SCHEMA%.%ASPNETUSERSTABLE%.*
 					FROM %SCHEMA%.%ACTIONLOGSTABLE%