public async Task UpdateCurrentStateAsync(string stateName, CancellationToken cancellationToken)
{
if (!stateName.StartsWith(StateNode.StateNamePrefix))
{
stateName = StateNode.StateNamePrefix + stateName;
}
var identityState = await _context.IdentityStates
.FindAsync(new object[] { _sessionContext.User.Id }, cancellationToken);
if (identityState == null)
{
identityState = new IdentityState
{
IdentityId = _sessionContext.User.Id,
StateName = stateName
};
await _context.IdentityStates.AddAsync(identityState, cancellationToken);
}
else
{
identityState.StateName = stateName;
}
await _context.SaveChangesAsync(cancellationToken);
}
public void CantContinue_WhenIdentityState_IsOtherThanApproved(IdentityState state, bool shouldContinue)
{
this.tagProfile.SetupGet(x => x.LegalIdentity).Returns(new LegalIdentity {
State = state
});
Given(AViewModel)
.And(async vm => await vm.Bind())
.ThenAssert(vm => shouldContinue ? vm.ContinueCommand.IsEnabled() : vm.ContinueCommand.IsDisabled())
.Finally(async vm => await vm.Unbind());
}
/// <summary>
/// Placeholder for request handling and passing results to a watch action/event to prompt for pop-up notifications
/// </summary>
/// <param name="task"></param>
/// <param name="identity"></param>
/// <param name="properties"></param>
/// <returns></returns>
internal Identity ProcessRequest(ProcessTasks task, Identity identity, Dictionary <string, object> properties)
{
Identity retv = null;
switch (task)
{
case ProcessTasks.VIEW:
break;
case ProcessTasks.CREATE:
retv = Enjin.CreateIdentity(identity);
if (retv != null)
{
EditorUtility.DisplayDialog("SUCCESS", "Identity " + retv.id + " has been created for app id " + retv.app_id + ".", "Ok");
}
else
{
EditorUtility.DisplayDialog("FAILURE", "Identity " + retv.id + " could not be created. Please see the Unity Console for the error returned.", "Ok");
}
RefreshLists();
State = IdentityState.VIEW;
break;
case ProcessTasks.DELETE:
break;
case ProcessTasks.EDIT:
if (CurrentIdentity.linking_code != "")
{
retv = Enjin.UpdateIdentity(CurrentIdentity);
}
else
{
retv = Enjin.UpdateIdentityFields(CurrentIdentity.id, CurrentIdentity.fields);
}
if (retv != null)
{
EditorUtility.DisplayDialog("SUCCESS", "Identity " + retv.id + " was updated successfully.", "Ok");
}
else
{
EditorUtility.DisplayDialog("FAILURE", "Identity " + retv.id + " could not be updated. Please see the Unity Console for the error returned.", "Ok");
}
RefreshLists();
State = IdentityState.VIEW;
break;
}
return(retv);
}
private string GetIdentityId(bool forceRefresh)
{
if (!IsIdentitySet || forceRefresh)
{
_identityState = RefreshIdentity();
if (!string.IsNullOrEmpty(_identityState.LoginProvider))
{
Logins[_identityState.LoginProvider] = _identityState.LoginToken;
}
UpdateIdentity(_identityState.IdentityId);
}
return(identityId);
}
private string GetIdentityId(RefreshIdentityOptions options)
{
if (!IsIdentitySet || options == RefreshIdentityOptions.Refresh)
{
_identityState = RefreshIdentity();
if (!string.IsNullOrEmpty(_identityState.LoginProvider))
{
Logins[_identityState.LoginProvider] = _identityState.LoginToken;
}
UpdateIdentity(_identityState.IdentityId);
}
return(identityId);
}
private static LegalIdentity CreateIdentity(IdentityState state)
{
return(new LegalIdentity
{
State = state,
Provider = "provider",
Id = Guid.NewGuid().ToString(),
Created = DateTime.UtcNow,
Updated = DateTime.UtcNow,
From = DateTime.UtcNow,
To = DateTime.MaxValue,
ClientKeyName = "key"
});
}
public async System.Threading.Tasks.Task <string> GetIdentityIdAsync(bool forceRefresh)
{
if (!IsIdentitySet || forceRefresh)
{
IdentityState state = await RefreshIdentityAsync().ConfigureAwait(false);
if (!string.IsNullOrEmpty(_identityState.LoginProvider))
{
Logins[_identityState.LoginProvider] = _identityState.LoginToken;
}
UpdateIdentity(_identityState.IdentityId);
}
return(identityId);
}
private async System.Threading.Tasks.Task <string> GetIdentityIdAsync(RefreshIdentityOptions options)
{
if (!IsIdentitySet || options == RefreshIdentityOptions.Refresh)
{
_identityState = await RefreshIdentityAsync().ConfigureAwait(false);
if (!string.IsNullOrEmpty(_identityState.LoginProvider))
{
Logins[_identityState.LoginProvider] = _identityState.LoginToken;
}
UpdateIdentity(_identityState.IdentityId);
}
return(identityId);
}
public override async System.Threading.Tasks.Task<CognitoAWSCredentials.IdentityState> RefreshIdentityAsync()
{
var client = new HttpClient();
var response = await client.GetAsync(string.Format(URL,this.Username));
var content = await response.Content.ReadAsStringAsync();
JsonData json = JsonMapper.ToObject(content);
//The backend has to send us back an Identity and a OpenID token
string identityId = json["IdentityId"].ToString();
string token = json["Token"].ToString();
var idState = new IdentityState(identityId, PROVIDER_NAME, token, false);
response.Dispose();
client.Dispose();
return idState;
}
private string GetIdentityId(RefreshIdentityOptions options)
{
// Locking so that concurrent calls do not make separate network calls,
// and instead wait for the first caller to cache the Identity ID.
lock (refreshIdLock)
{
if (!IsIdentitySet || options == RefreshIdentityOptions.Refresh)
{
_identityState = RefreshIdentity();
if (!string.IsNullOrEmpty(_identityState.LoginProvider))
{
Logins[_identityState.LoginProvider] = _identityState.LoginToken;
}
UpdateIdentity(_identityState.IdentityId);
}
}
return(identityId);
}
public override async System.Threading.Tasks.Task <CognitoAWSCredentials.IdentityState> RefreshIdentityAsync()
{
var client = new HttpClient();
var response = await client.GetAsync(string.Format(URL, this.Username));
var content = await response.Content.ReadAsStringAsync();
JsonData json = JsonMapper.ToObject(content);
//The backend has to send us back an Identity and a OpenID token
string identityId = json["IdentityId"].ToString();
string token = json["Token"].ToString();
var idState = new IdentityState(identityId, PROVIDER_NAME, token, false);
response.Dispose();
client.Dispose();
return(idState);
}
public async Task <string> GetOrSetDefaultCurrentStateAsync(string defaultStateName, CancellationToken cancellationToken)
{
var identityState = await _context.IdentityStates
.FindAsync(new object[] { _sessionContext.User.Id }, cancellationToken);
if (identityState != null)
{
return(identityState.StateName);
}
identityState = new IdentityState
{
IdentityId = _sessionContext.User.Id,
StateName = defaultStateName
};
await _context.IdentityStates.AddAsync(identityState, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(identityState.StateName);
}
public ApplicationUser(string userId, IdentityState identityData)
{
UserId = userId;
UserName = identityData.UserName;
NormalizedUserName = identityData.NormalizedUserName;
Email = identityData.Email;
NormalizedEmail = identityData.NormalizedEmail;
EmailConfirmed = identityData.EmailConfirmed;
PhoneNumber = identityData.PhoneNumber;
PhoneNumberConfirmed = identityData.PhoneNumberConfirmed;
PasswordHash = identityData.PasswordHash;
SecurityStamp = identityData.SecurityStamp;
Registered = identityData.Registered;
LockoutEnabled = identityData.LockoutEnabled;
LockoutEnd = identityData.LockoutEnd;
AccessFailedCount = identityData.AccessFailedCount;
TwoFactorEnabled = identityData.TwoFactorEnabled;
Roles = identityData.Roles;
ExternalLogins = identityData.ExternalLogins;
AuthenticationTokens = identityData.AuthenticationTokens;
ConcurrencyStamp = identityData.ConcurrencyStamp;
}
internal void SetParamaters(byte currentPowerState, byte lastEvent, byte miscState)
{
if (base.CompletionCode == 0)
{
#region Power State
// [0] Power is on, 1 = On, 0 = Off
byte state = Convert.ToByte((currentPowerState & 0x01));
// Translate the current power state into an enumeration.
switch (state)
{
case 0x00:
this.powerstate = IpmiPowerState.Off;
break;
case 0x01:
this.powerstate = IpmiPowerState.On;
break;
default:
this.powerstate = IpmiPowerState.Invalid;
break;
}
#endregion
#region Power Policy
state = Convert.ToByte((currentPowerState & 0x60) >> 5);
// Translate the state into Power on Policy.
switch (state)
{
case 0x00:
this.powerOnPolicy = PowerRestoreOption.StayOff;
break;
case 0x01:
this.powerOnPolicy = PowerRestoreOption.PreviousState;
break;
case 0x02:
this.powerOnPolicy = PowerRestoreOption.AlwaysPowerUp;
break;
default:
this.powerOnPolicy = PowerRestoreOption.Unknown;
break;
}
#endregion
#region Power Fault
// [7:5] - reserved
// [4] - 1b = last ‘Power is on’ state was entered via IPMI command
// [3] - 1b = last power downcaused by power fault
// [2] - 1b = last power down caused by a power interlockbeing activated
// [1] - 1b = last power down caused by a Power overload
// [0] - 1b = AC failed
state = Convert.ToByte((lastEvent & 0x1F));
switch (state)
{
case 0x00:
this.lastPowerEvent = PowerEvent.ACfailed;
break;
case 0x01:
this.lastPowerEvent = PowerEvent.PowerOverload;
break;
case 0x02:
this.lastPowerEvent = PowerEvent.PowerInterlockActive;
break;
case 0x03:
this.lastPowerEvent = PowerEvent.PowerFault;
break;
case 0x04:
this.lastPowerEvent = PowerEvent.IpmiSetState;
break;
default:
this.lastPowerEvent = PowerEvent.Unknown;
break;
}
#endregion
#region Identity LED
// [7:4] - reserved
// [6] - 1b = Chassis Identify command and state info supported (Optional)
// 0b = Chassis Identify command support unspecified via this
// command.
byte identitySupport = Convert.ToByte((miscState & 0x40) >> 6);
if (identitySupport == 0x01)
this.identitySupported = true;
// [5:4] - Chassis Identify State. Mandatory when bit [6] = 1b, reserved (return
// as 00b) otherwise.Returns the present chassis identify state. Refer to
// the Chassis Identify command for more info.
// 00b = chassis identify state = Off
// 01b = chassis identify state = Temporary (timed) On
// 10b = chassis identify state = Indefinite On
// 11b = reserved
byte Identity = Convert.ToByte((miscState & 0x30) >> 4);
switch (Identity)
{
case 0x00:
this.identityState = IdentityState.Off;
break;
case 0x01:
this.identityState = IdentityState.TemporaryOn;
break;
case 0x02:
this.identityState = IdentityState.On;
break;
default:
this.identityState = IdentityState.Unknown;
break;
}
#endregion
}
else
{
this.powerstate = IpmiPowerState.Invalid;
}
}
public void NeedsUpdating(IdentityState state, bool expected)
{
Assert.AreEqual(expected, new LegalIdentity {
State = state
}.NeedsUpdating());
}
public void IsCreatedOrApproved(IdentityState state, bool expected)
{
Assert.AreEqual(expected, new LegalIdentity {
State = state
}.IsCreatedOrApproved());
}
public void CantInvite_WhenIdentityState_IsOtherThanCreated_Or_NeuronServiceIsOffline(IdentityState state, bool isOnline, bool shouldContinue)
{
this.tagProfile.SetupGet(x => x.LegalIdentity).Returns(new LegalIdentity {
State = state
});
this.neuronService.SetupGet(x => x.IsOnline).Returns(isOnline);
Given(AViewModel)
.And(async vm => await vm.Bind())
.ThenAssert(vm => shouldContinue ? vm.InviteReviewerCommand.IsEnabled() : vm.InviteReviewerCommand.IsDisabled())
.Finally(async vm => await vm.Unbind());
}
private async System.Threading.Tasks.Task<string> GetIdentityIdAsync(RefreshIdentityOptions options)
{
if (!IsIdentitySet || options == RefreshIdentityOptions.Refresh)
{
_identityState = await RefreshIdentityAsync().ConfigureAwait(false);
if (!string.IsNullOrEmpty(_identityState.LoginProvider))
{
Logins[_identityState.LoginProvider] = _identityState.LoginToken;
}
UpdateIdentity(_identityState.IdentityId);
}
return identityId;
}
private string GetIdentityId(RefreshIdentityOptions options)
{
if (!IsIdentitySet || options == RefreshIdentityOptions.Refresh)
{
_identityState = RefreshIdentity();
if (!string.IsNullOrEmpty(_identityState.LoginProvider))
{
Logins[_identityState.LoginProvider] = _identityState.LoginToken;
}
UpdateIdentity(_identityState.IdentityId);
}
return identityId;
}