/// <summary>
/// Creates a new refesh token.
/// </summary>
/// <param name="context">The context.</param>
/// <returns><see cref="Task"/></returns>
public override async Task CreateAsync(AuthenticationTokenCreateContext context)
{
var ticket = context.Ticket;
var clientId = ticket.Properties.Dictionary[".client_id"];
if (string.IsNullOrEmpty(clientId))
{
return;
}
var refreshTokenId = IdentityUtil.NewId(2);
var refreshTokenLifeTime = context.OwinContext.Get <string>(OwinKeys.ClientRefreshTokenLifeTime);
var token = CreateRefreshToken(ticket, refreshTokenId, clientId, Convert.ToDouble(refreshTokenLifeTime));
token.ProtectedTicket = context.SerializeTicket();
var identityStore = GetIdentityStore();
var result = await identityStore.AddRefreshToken(token);
if (result)
{
context.SetToken(refreshTokenId);
}
}
protected override IEnumerable <INotification> CreateNotifications(IVssRequestContext requestContext, TFVC.CheckinNotification checkin, int maxLines)
{
var locationService = requestContext.GetService <ILocationService>();
string baseUrl = String.Format("{0}/{1}/",
locationService.GetAccessMapping(requestContext, "PublicAccessMapping").AccessPoint,
requestContext.ServiceHost.Name);
var teamNames = new HashSet <string>();
var projects = new Dictionary <string, string>();
var submittedItems = checkin.GetSubmittedItems(requestContext).ToList();
const string pattern = @"^\$\/([^\/]*)\/";
foreach (string item in submittedItems)
{
Match match = Regex.Match(item, pattern);
if (match.Success)
{
string projectName = match.Groups[1].Value;
if (projects.ContainsKey(projectName))
{
continue;
}
string projectUrl = baseUrl + projectName;
projects.Add(projectName, projectUrl);
foreach (var team in GetUserTeamsByProjectName(requestContext, projectName, checkin.ChangesetOwner.Descriptor))
{
teamNames.Add(team);
}
}
}
var notification = new CheckinNotification()
{
TeamProjectCollection = requestContext.ServiceHost.Name,
UniqueName = IdentityUtil.Convert(checkin.ChangesetOwner).UniqueName,
DisplayName = checkin.ChangesetOwner.DisplayName,
ChangesetUrl = $"{baseUrl}_versionControl/changeset/{checkin.Changeset}",
ChangesetId = checkin.Changeset,
Projects = projects,
Comment = TextHelper.Truncate(checkin.Comment, Settings.CommentMaxLength, true),
TeamNames = teamNames,
SubmittedItems = submittedItems
};
yield return(notification);
}
protected override Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
Model.Usuario user = null;
if (AuthorizationUtil.IsValid(request.Headers.Authorization, out user))
{
var roles = IdentityUtil.GetRoles(user);
var principal = new GenericPrincipal(new GenericIdentity(user.Nome), roles);
CurrentPrincipalUtil.SetPrincipal(principal);
}
return(base.SendAsync(request, cancellationToken));
}
public async Task <IActionResult> Authenticate([FromBody] LoginViewModel model)
{
string token = "";
ApplicationUser user = await _userManager.FindByEmailAsync(model.email);
if ((user != null))
{
if (user.EmailConfirmed == true)
{
var result = await _signInManager.PasswordSignInAsync(model.email, model.password, model.RememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
token = IdentityUtil.generateJwtToken(user, _appSettings.Secret);
var authenticationResultDto = new AuthenticationResultDTO
{
Status = "success",
ResponseCode = "00",
ResponseMessage = "User Authenticated",
Email = model.email,
Token = token
};
return(Ok(authenticationResultDto));
}
else
{
var authenticationResultDto = new AuthenticationResultDTO
{
Status = "failed",
ResponseCode = "01",
ResponseMessage = "Invalid Credential",
Email = model.email,
Token = null
};
return(BadRequest(authenticationResultDto));
}
}
}
var data = new
{
status = "fail, user does not exist",
user = "",
token = ""
};
return(new JsonResult(data));
}
private HttpResponseMessage RunRulesPost()
{
var value = Request.Content.ReadAsStringAsync().Result;
var startTime = DateTime.Now;
string json;
var errorMessages = new List <ExpandoObject>();
var destDataRows = new List <ExpandoObject>();
if (Request.Content.Headers.ContentType.ToString().ToLower() == "application/json")
{
json = value;
value = null;
}
else
{
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
ReasonPhrase = "This API accepts Content-Type [application/json] only."
};
throw new HttpResponseException(httpResponseMessage);
}
var activeRuleSets = RuleInstantiations.ParseRuleSets(ref json);
var count = GetRuleCount(activeRuleSets);
var ruleList = new RuleList {
RuleSets = activeRuleSets
};
var propertyObject = RuleInstantiations.ParseDataSet(ref json);
json = null;
IdentityUtil.AddIdentities(ref propertyObject);
destDataRows = IterateGeneralRules(ref propertyObject, ruleList, ref destDataRows, ref errorMessages);
destDataRows = IterateErrorCheckRules(ref destDataRows, ruleList, ref errorMessages);
IdentityUtil.RemoveIdentities(ref destDataRows);
var parsed = BuildResponse(ref errorMessages, ref destDataRows);
var response = Request.CreateResponse(HttpStatusCode.OK);
var endTime = DateTime.Now;
var diff = endTime - startTime;
response.Content = new StringContent(parsed.ToString(), Encoding.UTF8, "application/json");
AddHeaders(response, diff, ref propertyObject, ref destDataRows, count);
Debug.WriteLine("End of call to " + this.GetType().Name + ". " +
System.Reflection.MethodBase.GetCurrentMethod().Name + ".");
return(response);
}
/// <summary>
/// Receives the Refresh Token from the "refresh_token" grant.
/// </summary>
/// <param name="context">The context.</param>
/// <returns><see cref="Task"/></returns>
public override async Task ReceiveAsync(AuthenticationTokenReceiveContext context)
{
var owinContext = context.OwinContext;
var allowedOrigin = owinContext.Get <string>(OwinKeys.ClientAllowedOrigin) ?? "*";
owinContext.Response.Headers.Add("Access-Control-Allow-Origin", new[] { allowedOrigin });
var hashedTokenId = IdentityUtil.ComputeHash(context.Token);
var identityStore = GetIdentityStore();
var refreshToken = await identityStore.FindRefreshToken(hashedTokenId);
if (refreshToken != null)
{
context.DeserializeTicket(refreshToken.ProtectedTicket);
await identityStore.RemoveRefreshToken(hashedTokenId);
}
}
private static RefreshToken CreateRefreshToken([NotNull] AuthenticationTicket ticket, [NotNull] string refreshTokenId, [NotNull] string clientId, double expiresInMinutes)
{
Contract.Requires(!string.IsNullOrEmpty(refreshTokenId));
Contract.Requires(!string.IsNullOrEmpty(clientId));
var token = new RefreshToken
{
Id = IdentityUtil.ComputeHash(refreshTokenId),
ClientId = clientId,
Subject = ticket.Identity.Name,
IssuedUtc = DateTime.UtcNow,
ExpiresUtc = DateTime.UtcNow.AddMinutes(expiresInMinutes)
};
var props = ticket.Properties;
props.IssuedUtc = token.IssuedUtc;
props.ExpiresUtc = token.ExpiresUtc;
return(token);
}
public async Task <LoginResultDTO> LoginAsync(string email, string password, bool rememberMe)
{
string token = "";
ApplicationUser user = await _userManager.FindByEmailAsync(email);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(email, password, rememberMe, lockoutOnFailure : false);
if (result.Succeeded)
{
string secret = _appSettings.Secret;
token = IdentityUtil.generateJwtToken(user, secret);
UserSignInResultDTO customerResult = new UserSignInResultDTO
{
firstname = user.FirstName,
lastname = user.LastName,
email = user.Email,
phone = user.PhoneNumber,
token = token
};
LoginResultDTO loginResultDTO = new LoginResultDTO
{
Status = "success",
ResponseCode = "00",
ResponseMessage = "Sign in Successfully",
UserSignInResult = customerResult,
ErrorList = null
};
return(loginResultDTO);
}
else
{
LoginResultDTO loginResultDTO = new LoginResultDTO
{
Status = "fail",
ResponseCode = "01",
ResponseMessage = "Invalid Credentials",
UserSignInResult = null,
ErrorList = null
};
return(loginResultDTO);
}
}
else
{
LoginResultDTO loginResultDTO = new LoginResultDTO
{
Status = "fail",
ResponseCode = "01",
ResponseMessage = "User does not exist",
UserSignInResult = null,
ErrorList = null
};
return(loginResultDTO);
}
}
public async Task <RegistrationResultDTO> RegisterAsync(
string email, string password, bool rememberMe, string lastname, string firstname, string phonenumber)
{
var isAccountExisting = await this.VerifyAccountExist(email);
if (isAccountExisting)
{
RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
{
Status = "fail",
ResponseCode = "01",
ResponseMessage = "User registration failed. User already exists",
UserSignInResult = null,
ErrorList = null
};
return(registrationResultDTO);
}
ApplicationUser user = new ApplicationUser();
user.UserName = email;
user.Email = email;
user.FirstName = firstname;
user.LastName = lastname;
user.EmailConfirmed = true;
user.PhoneNumber = phonenumber;
IdentityResult result = _userManager.CreateAsync(user, password).Result;
if (result.Succeeded)
{
UserSignInResultDTO userSignInResult = new UserSignInResultDTO
{
firstname = firstname,
lastname = lastname,
email = email,
phone = phonenumber
};
_userManager.AddToRoleAsync(user, "Customer").Wait();
var signInResult = await _signInManager.PasswordSignInAsync(email, password, rememberMe, lockoutOnFailure : false);
if (signInResult.Succeeded)
{
string secret = _appSettings.Secret;
string token = IdentityUtil.generateJwtToken(user, secret);
userSignInResult.token = token;
RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
{
Status = "success",
ResponseCode = "00",
ResponseMessage = "User registered successfully",
UserSignInResult = userSignInResult,
ErrorList = null
};
return(registrationResultDTO);
}
else
{
RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
{
Status = "success",
ResponseCode = "00",
ResponseMessage = "User Registration Successful. Login to retrieve token",
UserSignInResult = userSignInResult,
ErrorList = null
};
return(registrationResultDTO);
}
}
else
{
RegistrationResultDTO registrationResultDTO = new RegistrationResultDTO
{
Status = "fail",
ResponseCode = "01",
ResponseMessage = "User Registration Failed. Please try again later",
UserSignInResult = null,
ErrorList = null
};
return(registrationResultDTO);
}
}
