/// <summary>
/// Makes a user identity
/// </summary>
/// <param name="authentication"></param>
/// <returns></returns>
public static IUserIdentity ToStackModel(this CredentialModel authentication)
{
switch (authentication?.Type ?? CredentialType.None)
{
case CredentialType.UserName:
if (authentication.Value is JObject o &&
o.TryGetValue("user", StringComparison.InvariantCultureIgnoreCase,
out var user) && user.Type == JTokenType.String &&
o.TryGetValue("password", StringComparison.InvariantCultureIgnoreCase,
out var password) && password.Type == JTokenType.String)
{
return(new UserIdentity((string)user, (string)password));
}
throw new ServiceResultException(StatusCodes.BadNotSupported,
$"User/passord token format is not supported.");
case CredentialType.X509Certificate:
return(new UserIdentity(new X509Certificate2(
authentication.Value?.ToObject <byte[]>())));
case CredentialType.JwtToken:
return(new UserIdentity(new IssuedIdentityToken {
DecryptedTokenData = authentication.Value?.ToObject <byte[]>()
}));
case CredentialType.None:
return(new UserIdentity(new AnonymousIdentityToken()));
default:
throw new ServiceResultException(StatusCodes.BadNotSupported,
$"Token type {authentication.Type} is not supported");
}
}
/// <summary>
/// Overload that runs in the foreground, does not continue on exception
/// but allows specifying timeout.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="elevation"></param>
/// <param name="timeout"></param>
/// <param name="endpoint"></param>
/// <param name="service"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, TimeSpan timeout,
Func <Session, Task <T> > service)
{
return(client.ExecuteServiceAsync(endpoint, elevation, 0, service,
timeout, CancellationToken.None, _ => true));
}
/// <summary>
/// Makes a user identity
/// </summary>
/// <param name="authentication"></param>
/// <returns></returns>
public static IUserIdentity ToStackModel(this CredentialModel authentication)
{
switch (authentication?.Type ?? CredentialType.None)
{
case CredentialType.UserName:
if (authentication.Value.IsObject &&
authentication.Value.TryGetProperty("user", out var user) &&
user.IsString &&
authentication.Value.TryGetProperty("password", out var password) &&
password.IsString)
{
return(new UserIdentity((string)user, (string)password));
}
throw new ServiceResultException(StatusCodes.BadNotSupported,
$"User/passord token format is not supported.");
case CredentialType.X509Certificate:
return(new UserIdentity(new X509Certificate2(
authentication.Value?.ConvertTo <byte[]>())));
case CredentialType.JwtToken:
return(new UserIdentity(new IssuedIdentityToken {
DecryptedTokenData = authentication.Value?.ConvertTo <byte[]>()
}));
case CredentialType.None:
return(new UserIdentity(new AnonymousIdentityToken()));
default:
throw new ServiceResultException(StatusCodes.BadNotSupported,
$"Token type {authentication.Type} is not supported");
}
}
public async Task <ActionResult <string> > LoginIdentity([FromBody] CredentialModel credential, [FromServices] IMediator mediator)
{
var retornoAutenticacao = await _apiNovoSgp.Autenticar(credential.Username, credential.Password);
if (retornoAutenticacao == null || !retornoAutenticacao.Autenticado)
{
return(Unauthorized("Usuário e/ou senha invalida"));
}
if (retornoAutenticacao.ModificarSenha)
{
return(Unauthorized("Você deve alterar a sua senha diretamente no Novo SGP"));
}
var perfisMenus = await mediator.Send(new ObterVerificarPerfisDoUsuarioLoginQuery(credential.Username, retornoAutenticacao.PerfisUsuario.Perfis));
retornoAutenticacao.PerfisUsuario.Perfis = perfisMenus.Perfis;
retornoAutenticacao.Permissoes = perfisMenus.Menus;
return(Ok(retornoAutenticacao));
}
public async Task <TokenModel> Build(CredentialModel creds)
{
var client = await _tokenRepository.ClientRepository.GetByIdAsync(creds.Id);
if (client == null)
{
throw new FaultException($"Client by Id {creds.Id} isn't exist");
}
if (!_credentialsValidator.IsValid(creds, client))
{
throw new FaultException("Wrong password");
}
var tokenValue = BuildSecureToken();
_tokenRepository.Add(tokenValue, client);
await _tokenRepository.Save();
var token = new TokenModel
{
TimeToLive = _tokenValidator.GetTokenTimeToLive(),
Value = tokenValue
};
return(token);
}
public async Task <ILoginToken <UsersDTO> > LoginByContext(string audience, string site)
{
var credentials = new CredentialModel();
if (context != null)
{
var userName = context?.User?.Identity?.Name ?? context.User.Claims.FirstOrDefault(s => s.Type == ClaimTypes.NameIdentifier)?.Value;
if (!String.IsNullOrWhiteSpace(userName) && context.User.Identity.IsAuthenticated)
{
skipPassword = true;
}
else
{
return(null);
}
credentials.Site = site;
credentials.UserName = userName;
}
else
{
throw new APVRESTException("Unable to login. Context is invalid.");
}
return(await this.Login(credentials, audience, site));
}
public async Task <IActionResult> Login([FromBody] CredentialModel model)
{
try
{
var result = await _signInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
if (result.Succeeded) //succeeded olmadi ise, username password hatali.
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
var tokenPacket = CreateToken(user);
if (tokenPacket != null && tokenPacket.Result != null)
{
return(Ok(tokenPacket.Result));
}
}
}
}
catch (Exception)
{
//log
}
return(BadRequest("login basarili olamadi!"));
}
private DeliveryProduct CreateDeliveryProduct(CheckOut checkOut, Bill bill)
{
DeliveryProduct delivery = new DeliveryProduct()
{
DeliveryProductAddress = checkOut.DeliveryProductAddress,
DeliveryProductBillId = bill.BillId,
DeliveryProductPhoneNumber = checkOut.DeliveryProductPhoneNumber,
DeliveryProductNote = checkOut.DeliveryProductNote,
DeliveryProductStateId = checkOut.DeliveryProductStateId,
DeliveryProductTypeId = checkOut.DeliveryProductTypeId
};
CredentialModel credential = JsonConvert.DeserializeObject <CredentialModel>(HttpContext.Session.GetString(Constants.VM));
string token = credential.JwToken;
// post Delivery
using (HttpClient client = Common.HelperClient.GetClient(token))
{
client.BaseAddress = new Uri(Common.Constants.BASE_URI);
var postTask = client.PostAsJsonAsync <DeliveryProduct>(Constants.DELIVERY_PRODUCT, delivery);
postTask.Wait();
var result = postTask.Result;
if (result.IsSuccessStatusCode)
{
return(delivery);
}
else
{
return(null);
}
}
}
public async Task <IActionResult> Login(CredentialViewModel model)
{
if (!ModelState.IsValid || model == null)
{
ModelState.AddModelError("Authorization error", "Invalid data");
return(View(new CredentialViewModel(Database, model)));
}
CredentialModel user = Database.Users.FirstOrDefault(i => i.Email == model.Credential.Email);
if (user == null || !Encryptor.VerifyHash(model?.Credential.Password, user.Password))
{
if (!Database.Users.Any())
{
goto Authorize;
}
ModelState.AddModelError("Authorization error", "Invaild e-mail or password");
return(View(new CredentialViewModel(Database, model)));
}
Authorize:
Claim claim = new Claim(ClaimsIdentity.DefaultNameClaimType, user?.Email ?? "root");
ClaimsIdentity id = new ClaimsIdentity(new Claim[] { claim }, "ApplicationCookie", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);
await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(id)).ConfigureAwait(false);
return(Redirect(model.ReturnUrl ?? "/Admin"));
}
public async Task <IHttpActionResult> CreateToken([FromBody] CredentialModel model)
{
var user = await _userManager.FindByNameAsync(model.UserName);
if (user != null)
{
if (_hasher.VerifyHashedPassword(user.PasswordHash, model.Password) == PasswordVerificationResult.Success)
{
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("JUSTDOITJUSTDOITJUSTDOIT"));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "http//mybudget.com",
audience: "",
claims: claims,
expires: DateTime.UtcNow.AddMinutes(30),
signingCredentials: creds
);
return(Ok(new JwtSecurityTokenHandler().WriteToken(token)));
}
}
return(BadRequest());
}
public IActionResult AddFeedback(string feedback)
{
if (ModelState.IsValid)
{
Feedback fb = JsonConvert.DeserializeObject <Feedback>(feedback);
CredentialModel credential = JsonConvert.DeserializeObject <CredentialModel>(HttpContext.Session.GetString("vm"));
string token = credential.JwToken;
// post comment
using (HttpClient client = Common.HelperClient.GetClient(token))
{
client.BaseAddress = new Uri(Common.Constants.BASE_URI);
var postTask = client.PostAsJsonAsync <Feedback>("feedbacks", fb);
postTask.Wait();
var result = postTask.Result;
if (result.IsSuccessStatusCode)
{
return(NoContent());
}
}
}
return(NoContent());
}
public async Task <IActionResult> Signup([FromBody] CredentialModel model)
{
try
{
if (!ModelState.IsValid)
{
return(StatusCode(412));
}
var user = new TodoUser()
{
Email = model.Email, UserName = model.Email
};
var result = await _userMgr.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(await this.ReturnToken(user));
}
}
catch (Exception ex)
{
_logger.LogError($"Exception thrown while creating JWT: {ex}");
}
return(BadRequest("Failed to generate token"));
}
public async Task <IActionResult> SignIn([FromBody] CredentialModel model)
{
try
{
if (string.IsNullOrWhiteSpace(model.UserName))
{
throw new InvalidOperationException("UserName is required!");
}
var manToMachine = model.GameMode == "auto" || string.IsNullOrWhiteSpace(model.GameMode);
var token = await _jwtService.CreateToken(model.UserName);
await _gameSerivce.SignIn(model.UserName, manToMachine);
if (manToMachine)
{
await _gameSerivce.SignIn("Machine", true);
}
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
}));
}
catch (Exception ex)
{
_logger.LogError($"Exception thrown while creating JWT: {ex}");
}
return(BadRequest("Failed to generate token"));
}
/// <summary>
/// Overload that does not continue on exception and can only be cancelled.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
/// <param name="ct"></param>
/// <param name="endpoint"></param>
/// <param name="service"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, int priority,
CancellationToken ct, Func <Session, Task <T> > service)
{
return(client.ExecuteServiceAsync(endpoint, elevation, priority, ct, service,
_ => true));
}
private UserProfile UpdateProfile(UserProfile profile)
{
CredentialModel credential = JsonConvert.DeserializeObject <CredentialModel>(HttpContext.Session.GetString("vm"));
string token = credential.JwToken;
using (HttpClient client = Common.HelperClient.GetClient(token))
{
client.BaseAddress = new Uri(Common.Constants.BASE_URI);
var postTask = client.PutAsJsonAsync <UserProfile>("userprofiles/" + profile.UserProfileId, profile);
postTask.Wait();
var result = postTask.Result;
if (result.IsSuccessStatusCode)
{
var readTask = result.Content.ReadAsAsync <UserProfile>();
readTask.Wait();
return(readTask.Result);
}
else
{
return(null);
}
}
}
// PUT: api/Guid/5
/// <summary>
/// update user data controller method
/// </summary>
/// <param name="id"> guid to use</param>
/// <param name="model">model with data</param>
/// <returns></returns>
public async Task <GuidResult> Put(Guid id, [FromBody] CredentialModel model)
{
model.UserId = id.ToString();
var result = await UserCredService.Update(model);
return(result);
}
/// <summary>
/// ReadValueAsync
/// </summary>
/// <param name="endpointId"></param>
/// <param name="nodeId"></param>
/// <returns>Read value</returns>
public async Task <string> ReadValueAsync(string endpointId, string nodeId, CredentialModel credential = null)
{
var model = new ValueReadRequestApiModel()
{
NodeId = nodeId
};
model.Header = Elevate(new RequestHeaderApiModel(), credential);
try {
var value = await _twinService.NodeValueReadAsync(endpointId, model);
if (value.ErrorInfo == null)
{
return(value.Value?.ToJson()?.TrimQuotes());
}
else
{
return(value.ErrorInfo.ToString());
}
}
catch (UnauthorizedAccessException) {
return("Unauthorized access: Bad User Access Denied.");
}
catch (Exception e) {
_logger.Error(e, "Can not read value of node '{nodeId}'", nodeId);
var errorMessage = string.Concat(e.Message, e.InnerException?.Message ?? "--", e?.StackTrace ?? "--");
return(errorMessage);
}
}
public async Task <ActionResult <string> > LogoutIdentity([FromBody] CredentialModel credential)
{
// Configurações iniciais
string url = "http://identity.sme.prefeitura.sp.gov.br/Account/Logout";
// Cria os dados necessários que compõe o corpo da requisição
Dictionary <string, string> data = new Dictionary <string, string>();
data.Add("logoutId", credential.Username); // Adiciona o nome de usuário
// Inicialização do cliente para requisições (GET)
using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url)
{
Content = new FormUrlEncodedContent(data)
}) // Encoda os dados no formato correto dentro da requisição
using (HttpClient client = new HttpClient())
using (HttpResponseMessage response = await client.SendAsync(request))
{
// Caso a requisição não ocorra corretamente, retorna 'Unauthorized'
if (!response.IsSuccessStatusCode)
{
return(Unauthorized());
}
else
{
return(Ok());
}
}
}
public async Task <IActionResult> Login([FromBody] CredentialModel credentials)
{
try
{
var identity = await GetClaimsIdentity(credentials.UserName, credentials.Password);
if (identity == null)
{
var error = new
{
message = "Invalid username or password"
};
var errroJson = JsonConvert.SerializeObject(error, _serializerSettings);
return(new BadRequestObjectResult(errroJson));
}
// Serialize and return the response
var response = new
{
id = identity.Claims.Single(c => c.Type == "id").Value,
token = await _jwtFactory.GenerateEncodedToken(credentials.UserName, identity),
expiresin = (int)_jwtOptions.ValidFor.TotalSeconds,
username = credentials.UserName,
email = "",
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <LoginTokenDataModel> AddExternalUser(ExternalUserModel addUserModel)
{
try
{
if (addUserModel != null)
{
List <KeyValuePair <string, object> > param = new List <KeyValuePair <string, object> >()
{
new KeyValuePair <string, object>("@dob", addUserModel.Dob),
new KeyValuePair <string, object>("@gender", addUserModel.Gender),
new KeyValuePair <string, object>("@firstName", addUserModel.FirstName),
new KeyValuePair <string, object>("@lastName", addUserModel.LastName),
new KeyValuePair <string, object>("@email", addUserModel.Email),
new KeyValuePair <string, object>("@mobile", addUserModel.Mobile),
new KeyValuePair <string, object>("@Provider", addUserModel.Provider),
new KeyValuePair <string, object>("@ProviderKey", addUserModel.ProviderKey)
};
SigninDetails signinDetails = new SigninDetails();
CredentialModel credentialModel = new CredentialModel()
{
isExternal = true, UserName = addUserModel.Email
};
DataExecutor.ExecuteScalar(UtilityConstant.Procedures.Mst_AddExternalUser, param);
return(signinDetails.CheckUserCredentials(credentialModel));
}
return(new LoginTokenDataModel());
}
catch (Exception ex)
{
return(new LoginTokenDataModel());
}
}
public async Task <ActionResult <string> > RefreshLoginJWT([FromBody] CredentialModel credential)
{
// Faz a pesquisa no banco de dados (smeManagementDB/LoggedUsers) se o usuário está listado como logado possuindo a mesma sessão e o mesmo refresh token
LoggedUser loggedUser = await Data.Business.Authentication.GetLoggedUser(credential.Username, credential.Session, credential.RefreshToken);
// Caso seja encontrado algum usuário com a combinação de username, sessão e refreshToken, verifica se o refresh token ainda é valido
if (loggedUser != null)
{
if ((loggedUser.ExpiresAt - DateTime.Now).Minutes > 0)
{
string newSession = Data.Functionalities.Cryptography.CreateHashKey(); // Cria a sessão
string newRefreshToken = Data.Functionalities.Cryptography.CreateHashKey(); // Cria o refresh token
await Data.Business.Authentication.LoginUser(credential.Username, newSession, newRefreshToken); // Salva as informações na tabela correspondente (LoggedUsers)
return(Ok(new
{
Token = CreateToken(credential.Username),
Session = newSession,
RefreshToken = newRefreshToken
}));
}
else // Caso não seja válido, remove o usuário da lista de usuários logados
{
await Data.Business.Authentication.LogoutUser(credential.Username, credential.Session); // Desloga o usuário
}
}
return(Unauthorized());
}
public void CreateToken()
{
// Arrange
IdentityModelEventSource.ShowPII = true;
var options = Substitute.For <IOptions <TokenData> >();
options.Value.Returns <TokenData>(new TokenData
{
Web = "Web",
Mobile = "Mobile",
Key = "ThisMustBeAtLeast16Characters",
Issuer = "Issuer",
Audience = "Audience"
});
var logger = Substitute.For <ILogger <AuthController> >();
var model = new CredentialModel
{
UserAgent = "Web"
};
using (var target = new AuthController(logger, options))
{
// Act
var result = target.CreateToken(model);
// Assert
Assert.IsType <OkObjectResult>(result);
}
}
public static IEnumerable <Bill> GetBills(CredentialModel credential)
{
IEnumerable <Bill> bills = null;
using (var client = Common.HelperClient.GetClient(credential.JwToken))
{
client.BaseAddress = new Uri(Constants.BASE_URI);
var responseTask = client.GetAsync(Constants.MY_BILL);
responseTask.Wait();
var result = responseTask.Result;
if (result.IsSuccessStatusCode)
{
var readTask = result.Content.ReadAsAsync <IList <Bill> >();
readTask.Wait();
bills = readTask.Result;
}
else //web api sent error response
{
//log response status here..
bills = Enumerable.Empty <Bill>();
}
}
return(bills);
}
public void CreateToken_CheckConfig_Mobile()
{
// Arrange
var options = Substitute.For <IOptions <TokenData> >();
options.Value.Returns <TokenData>(new TokenData
{
Web = "Web"
});
var logger = Substitute.For <ILogger <AuthController> >();
var model = new CredentialModel
{
UserAgent = "UnitTesting"
};
using (var target = new AuthController(logger, options))
{
// Act
var result = target.CreateToken(model);
// Assert
logger.Received().Log(
LogLevel.Warning,
Arg.Any <EventId>(),
Arg.Is <object>(o => o.ToString() == "Check server configuration"),
null,
Arg.Any <Func <object, Exception, string> >());
Assert.IsType <BadRequestResult>(result);
}
}
/// <summary>
/// Create node stream encoder
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="diagnostics"></param>
/// <param name="stream"></param>
/// <param name="contentType"></param>
/// <param name="logger"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
public BrowseStreamEncoder(IEndpointServices client, EndpointModel endpoint,
Stream stream, string contentType, DiagnosticsModel diagnostics, ILogger logger,
CredentialModel elevation = null, int priority = int.MaxValue) :
this(client, endpoint, diagnostics, logger, elevation, priority)
{
_encoder = new ModelEncoder(stream, contentType, PushNode);
}
public override async Task <TokenResponse> CreateToken(TokenRequest request, ServerCallContext context)
{
var creds = new CredentialModel
{
UserName = request.Username,
Passcode = request.Password
};
var response = await _jwtTokenValidationService.GenerateTokenModelAsync(creds);
if (response.Success)
{
return(new TokenResponse
{
Token = response.Token,
Expiration = Timestamp.FromDateTime(response.Expiration),
Success = true
});
}
return(new TokenResponse
{
Success = false
});
}
public override async Task <TokenResponse> GenerateToken(TokenRequest request, ServerCallContext context)
{
var creds = new CredentialModel()
{
UserName = request.Username,
Passcode = request.Password
};
var result = await _tokenService.GenerateTokenModelAsync(creds);
if (result.Success)
{
return(new TokenResponse()
{
Success = true,
Token = result.Token,
Expiration = Timestamp.FromDateTime(result.Expiration)
});
}
else
{
return(new TokenResponse()
{
Success = false
});
}
}
public IActionResult Index()
{
CredentialModel credential = JsonConvert.DeserializeObject <CredentialModel>(HttpContext.Session.GetString("vm"));
UserProfile profile = credential.Profile;
return(View(profile));
}
public ActionResult Login(CredentialModel model, string returnUrl)
{
if (TempData.ContainsKey("searchFinesModel"))
{
TempData.Remove("searchFinesModel");
}
ViewBag.ReturnUrl = returnUrl;
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
var authenticationService = new AuthenticationService();
var sessionModel = authenticationService.GetSession(model);
var userService = new UserService(sessionModel.SessionToken);
var userModel = userService.GetUser(sessionModel.EntityID);
var authenticatedUser = new AuthenticatedUser(model.UserName);
authenticatedUser.SessionData = sessionModel;
authenticatedUser.UserData = userModel;
var reportService = new ReportService(authenticatedUser.SessionToken);
var reportMetData = reportService.GetMetaData();
reportMetData.ApplyFilterAndOrder(authenticatedUser.UserData.SystemFunctions.Select(f => f.Name).ToArray());
authenticatedUser.ReportData = reportMetData;
var ticket = new FormsAuthenticationTicket(1, authenticatedUser.SessionToken, DateTime.Now, DateTime.Now.AddMinutes(UserCacheTimeMinutes), false, authenticatedUser.SessionToken);
var encTicket = FormsAuthentication.Encrypt(ticket);
var cookie = FormsAuthentication.GetAuthCookie(FormsAuthentication.FormsCookieName, true);
cookie.Value = encTicket;
HttpContext.Response.Cookies.Add(cookie);
if (MvcApplication.UserCache.Get(authenticatedUser.SessionToken) == null)
{
MvcApplication.UserCache.Set(
authenticatedUser.SessionToken,
authenticatedUser,
new CacheItemPolicy
{
AbsoluteExpiration = DateTime.Now + TimeSpan.FromMinutes(UserCacheTimeMinutes)
});
}
return(RedirectToLocal(authenticatedUser, returnUrl));
}
catch (GatewayException ge)
{
ModelState.AddModelError(string.Empty, ge.Message);
return(View(model));
}
catch (Exception ex)
{
ModelState.AddModelError(string.Empty, ex.Message);
return(View(model));
}
}
/// <inheritdoc/>
public Task <T> ExecuteServiceAsync <T>(ConnectionModel connection,
CredentialModel elevation, int priority, Func <Session, Task <T> > service,
TimeSpan?timeout, CancellationToken ct, Func <Exception, bool> handler)
{
if (connection.Endpoint == null)
{
throw new ArgumentNullException(nameof(connection));
}
if (string.IsNullOrEmpty(connection.Endpoint?.Url))
{
throw new ArgumentNullException(nameof(connection.Endpoint.Url));
}
var key = new ConnectionIdentifier(connection);
while (!_cts.IsCancellationRequested)
{
var client = GetOrCreateSession(key);
if (!client.Inactive)
{
var scheduled = client.TryScheduleServiceCall(elevation, priority,
service, handler, timeout, ct, out var result);
if (scheduled)
{
// Session is owning the task to completion now.
return(result);
}
}
// Create new session next go around
EvictIfInactive(key);
}
return(Task.FromCanceled <T>(_cts.Token));
}
public async Task Delete(CredentialModel credential)
{
using (var client = new HttpClient())
{
Initialize(client);
var response = await client.DeleteAsync(GetCredentialUrl(credential));
response.TryException();
}
}
public async Task Add(CredentialModel credential, AddApplicationModel data)
{
using (var client = new HttpClient())
{
Initialize(client);
var response = await client.PutAsync(GetCredentialUrl(credential), data, JsonFormatter);
response.TryException();
}
}
public async Task<AdminModel> Get(CredentialModel credential)
{
using (var client = new HttpClient())
{
Initialize(client);
var response = await client.GetAsync(GetCredentialUrl(credential));
response.TryException();
return await response.Content.ReadAsAsync<AdminModel>();
}
}
public static string GetNewKey(this UpdateCredentialModel model, CredentialModel current)
{
var currentName = model.Name;
if (string.IsNullOrEmpty(currentName))
{
currentName = current.Name;
}
return string.IsNullOrEmpty(model.Key)
? string.Concat(currentName, model.Password).GetKey()
: model.Key;
}
public static string GetError(this UpdateCredentialModel model, CredentialModel current)
{
if (!string.IsNullOrEmpty(model.Name) && AppSettings.InvalidChars.IsMatch(model.Name))
{
return "Name is contains invalid chars";
}
if (!string.IsNullOrEmpty(model.Password) && AppSettings.InvalidChars.IsMatch(model.Password))
{
return "Password is contains invalid chars";
}
if (string.IsNullOrEmpty(model.Key) &&
(string.IsNullOrEmpty(model.Password) ||
(string.IsNullOrEmpty(model.Name) &&
(string.IsNullOrEmpty(current.Name) || !string.IsNullOrEmpty(current.Key)))))
{
return "Credential is not correct";
}
return null;
}
protected string GetCredentialParams(CredentialModel credential)
{
return
$"key={credential.Key}&name={WebUtility.UrlEncode(credential.Name)}&password={WebUtility.UrlEncode(credential.Password)}";
}
protected string GetCredentialUrl(CredentialModel credential)
{
return $"{RoutePrefix}?{GetCredentialParams(credential)}";
}
