internal DeviceDetails(DeviceDetails source)
{
Type = source.Type;
DeviceName = source.DeviceName;
DeviceId = source.DeviceId;
Model = source.Model;
OperatingSystem = source.OperatingSystem;
OperatingSystemVersion = source.OperatingSystemVersion;
AdditionalProperties = source.AdditionalProperties == null
? null
: source.AdditionalProperties.ToDictionary(
s => s.Key,
s => s.Value);
}
public async Task EnsureRegisteredAsync(UserDetails user, DeviceDetails device, string appVersion,
bool isReplacement)
{
// store app version for ReplaceRegistration calls
_appVersion = appVersion;
try
{
await _synchroniseLock.WaitAsync();
await EnsureRegisteredWithoutLockAsync(user, device, appVersion, isReplacement);
}
finally
{
_synchroniseLock.Release();
}
}
private async Task UpdateDeviceInContext(DeviceDetails device)
{
var deviceContext = device ?? new DeviceDetails();
deviceContext.DeviceId = _environmentInformation.DeviceId;
deviceContext.OperatingSystem = _environmentInformation.OperatingSystem;
deviceContext.OperatingSystemVersion = _environmentInformation.OperatingSystemVersion;
deviceContext.Model = _environmentInformation.Model;
await _registrationContext.SetDevice(deviceContext);
}
private async Task<Device> CreateServiceDevice(DeviceDetails device)
{
return new Device
{
AdditionalProperties = device == null ? null : device.AdditionalProperties,
Id = _environmentInformation.DeviceId,
Model = _environmentInformation.Model,
Name = device == null ? null : device.DeviceName,
OperatingSystem = _environmentInformation.OperatingSystem,
OperatingSystemVersion = _environmentInformation.OperatingSystemVersion,
PushConfiguration = await CreatePushConfiguration(),
Secret = GetOrGenerateDeviceSecret(),
Type = device == null ? null : device.Type
};
}
private async Task RegisterAsync(UserDetails user, DeviceDetails device, string appVersion, bool alreadyLocked = false)
{
try
{
if (!alreadyLocked)
{
await _synchroniseLock.WaitAsync();
}
var isAnonymous = user == null || string.IsNullOrEmpty(user.UserId);
_logger.LogInformation("Starting registration for user: {0}",
isAnonymous ? "(anonymous)" : user.UserId);
var request = new RegistrationDetail
{
Client = CreateClientDetail(appVersion),
Device = await CreateServiceDevice(device),
User = user == null
? null
: CreateServiceUser(user)
};
var response = await _publicRegistrationService.RegisterAsync(request);
await UpdateUserInContext(user, response.UserId, isAnonymous);
await UpdateDeviceInContext(device);
_registrationContext.NetworkId = response.NetworkId;
_serviceContext.UpdateFromAccessDetail(response.AccessDetails);
await _configurationManager.UpdateConfigurationAsync(
response.AccessDetails.Configuration.ConfigurationItems,
response.AccessDetails.Configuration.ConfigurationSets);
_logger.LogInformation("Registered successfully. NetworkId: {0}",
response.NetworkId);
PublishRegistrationChanged();
_logger.LogDebug("New token expiry time: {0}", response.AccessDetails.ExpiresOn);
}
finally
{
if (!alreadyLocked)
{
_synchroniseLock.Release();
}
}
}
private async Task EnsureRegisteredWithoutLockAsync(UserDetails user, DeviceDetails device, string appVersion, bool isReplacement)
{
var existingUser = await _registrationContext.GetUser();
if (existingUser == null || isReplacement)
{
// New registration or ReplaceRegistration
await RegisterAsync(user, device, appVersion, true);
}
if (isReplacement)
{
// Refresh token
await _tokenRefresher.RefreshTokenAsync();
_registrationContext.DeviceSecret = Guid.NewGuid().ToString();
}
PublishRegistrationChanged();
}
public async Task<ApiResult> UpdateRegistrationDetailsAsync(UserDetails user = null, DeviceDetails device = null)
{
return await ApiResult.ForOperationAsync(async () =>
{
try
{
await _synchroniseLock.WaitAsync();
if (user == null && device == null)
{
throw new ArgumentException("user or device must be specified");
}
var existingUser = await _registrationContext.GetUser();
var wasAnonymous = existingUser.IsAnonymous;
var oldUserId = existingUser.UserId;
if (user != null && device != null)
{
// Composite update
var isAnonymous = wasAnonymous && oldUserId == user.UserId;
try
{
await _secureRegistrationService.UpdateRegistrationAsync(new RegistrationDetail
{
Client = CreateClientDetail(),
Device = await CreateServiceDevice(device),
User = CreateServiceUser(user)
});
}
catch (ValidationException ex)
{
if (ex.ValidationFailures.Count == 1 && ex.ValidationFailures.Single().FailureKey == "UserIdAlreadyTaken")
{
Logger.Instance.LogInformation("UserId {0} is already taken. Starting ReplaceRegistration flow.", user.UserId);
await EnsureRegisteredWithoutLockAsync(user, device, _appVersion, true);
return;
}
else
{
throw;
}
}
await UpdateUserInContext(user, user.UserId, isAnonymous);
await UpdateDeviceInContext(device);
}
else if (user != null)
{
var isAnonymous = wasAnonymous && oldUserId == user.UserId;
try
{
// User only update
await _secureRegistrationService.UpdateUserAsync(CreateServiceUser(user));
}
catch (ValidationException ex)
{
if (ex.ValidationFailures.Count == 1 && ex.ValidationFailures.Single().FailureKey == "UserIdAlreadyTaken")
{
Logger.Instance.LogInformation("UserId {0} is already taken. Starting ReplaceRegistration flow.", user.UserId);
await EnsureRegisteredWithoutLockAsync(user, null, _appVersion, true);
return;
}
else
{
throw;
}
}
await UpdateUserInContext(user, user.UserId, isAnonymous);
}
else
{
// Device only update
await _secureRegistrationService.UpdateDeviceAsync(await CreateServiceDevice(device));
await UpdateDeviceInContext(device);
}
PublishRegistrationChanged();
}
finally
{
_synchroniseLock.Release();
}
}, "UpdateRegistrationDetailsAsync");
}
public async Task ReplaceRegistrationAsync(UserDetails user, DeviceDetails device)
{
await EnsureRegisteredAsync(user, device, _appVersion, true);
}
public async Task SetDevice(DeviceDetails device)
{
_device = device;
await SetValueAsync(device, "Device");
}
public async Task<DeviceDetails> GetDevice()
{
return _device ?? (_device = await GetValueAsync<DeviceDetails>("Device"));
}
