public Task AddLoginAsync(IdentityUser user, UserLoginInfo login, CancellationToken cancellationToken) =>
Task.Run(() =>
{
if (Base.Host.IsDevelopment)
{
Base.Current.Log.KeyValuePair(MethodBase.GetCurrentMethod().Name, new { user, login }.ToJson(), Message.EContentType.Info);
}
var key = login.StampValue();
var claimsIdentity = (ClaimsIdentity)((ExternalLoginInfo)login).Principal.Identity;
var claimDict = new Dictionary <string, string>();
foreach (var claim in claimsIdentity.Claims.ToList().Where(claim => !claimDict.ContainsKey(claim.Type)))
{
claimDict[claim.Type] = claim.Value;
}
var entry = new Model.Identity
{
Id = key,
IdentityUser = user,
Name = claimsIdentity.Name,
Claims = claimDict,
IsAuthenticated = claimsIdentity.IsAuthenticated,
Label = claimsIdentity.Label,
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey
};
entry.Save();
}, cancellationToken);
public Model.Identity Map(Model.Identity identity, RequestType?requestType = null,
Cluster cluster = null, string node = null, Log log = null)
{
if (!_identityCache.TryGetValue(identity.ID, out Model.Identity result))
{
result = identity;
_identityCache[identity.ID] = result;
}
if (requestType != null &&
(!result.RequestTypes?.Contains(requestType.Value) ?? true))
{
if (result.RequestTypes == null)
{
result.RequestTypes = new List <RequestType>();
}
result.RequestTypes.Add(requestType.Value);
}
Cluster outCluster = null;
if ((cluster?.ID ?? 0) > 0 &&
!_clusterCache.TryGetValue(cluster.ID, out outCluster))
{
_clusterCache[cluster.ID] = cluster;
if (result.Clusters == null)
{
result.Clusters = new List <Cluster>();
}
result.Clusters.Add(cluster);
outCluster = cluster;
}
if (!string.IsNullOrEmpty(node))
{
if (outCluster.Nodes == null)
{
outCluster.Nodes = new List <string>();
}
outCluster.Nodes.Add(node);
}
if ((log?.ID ?? 0) > 0 &&
!_logCache.ContainsKey(log.ID))
{
_logCache[log.ID] = log;
if (result.Logs == null)
{
result.Logs = new List <Log>();
}
result.Logs.Add(log);
}
return(result);
}
public static bool SyncWithLocalStore(this Model.Identity model)
{
var localModel = App.Current.Orchestrator.GetPersonByClaims(model.Claims);
model.InternalId = localModel.Id;
return(true);
}
public static IdentityUser ToIdentityUser(this ClaimsIdentity source, Model.Identity user)
{
var model = new IdentityUser {
Id = user.InternalId, Email = source.Claim(ClaimTypes.Email)
};
model.NormalizedEmail = model.Email.ToUpperInvariant();
model.UserName = source.Claim(ClaimTypes.GivenName);
model.NormalizedUserName = model.UserName.ToUpperInvariant();
model.EmailConfirmed = source.Claim(ZenClaimTypes.EmailConfirmed) == "true";
return(model);
}
public async Task UpdateIdentitySequence(Model.Identity identity)
{
var param = new DynamicParameters();
param.Add("@ID", identity.ID);
param.Add("@Sequence", identity.Sequence);
await SqlMapper.ExecuteAsync(_unitOfWork.Connection,
"UpdateIdentitySequence",
param,
commandType : CommandType.StoredProcedure,
transaction : _unitOfWork.Transaction);
}
public async Task Update(Model.Identity identity)
{
var param = new DynamicParameters();
param.Add("@ID", identity.ID);
param.Add("@Name", identity.Name);
param.Add("@Designation", identity.Designation);
param.Add("@Role", identity.Role);
param.Add("@Permissions", identity.Permissions);
param.Add("@Email", identity.Email.ToLower());
param.Add("@Status", identity.Status);
await SqlMapper.ExecuteAsync(_unitOfWork.Connection,
"UpdateIdentity",
param,
commandType : CommandType.StoredProcedure,
transaction : _unitOfWork.Transaction);
}
public async Task <Model.Identity> UpdateIdentity(Model.Identity identity, Officer user)
{
return(await Execute(new UpdateIdentityCommand(identity, user, _cacheProvider, _eventBus)));
}
public async Task <Model.Identity> CreateIdentity(Model.Identity identity, Officer user)
{
return(await Execute(new CreateIdentityCommand(identity, user, _smtpProvider)));
}
public async Task <Model.Identity> Put(Guid id, [FromBody] Model.Identity identity, Guid userID,
string userName)
{
identity.ID = id;
return(await _identityservice.UpdateIdentity(identity, new Officer(userID, userName)));
}
public async Task <Model.Identity> Post([FromBody] Model.Identity identity, Guid userID,
string userName)
{
return(await _identityservice.CreateIdentity(identity, new Officer(userID, userName)));
}
