public static UserToken Login(IAuthenticationResponse resp)
{
if (resp == null)
{
return(null);
}
UserToken token = null;
if (resp.Status == AuthenticationStatus.Authenticated)
{
ClaimsResponse ProfileFields = resp.GetExtension <ClaimsResponse>();
User user = GetUserByOpenIDIdentifier(resp.ClaimedIdentifier);
if (user != null && user.Active)
{
token = user.ToToken();
}
}
Login(token, resp.ClaimedIdentifier);
return(token);
}
private void ParameterizedAXTest(AXAttributeFormats format)
{
var axInjected = new FetchRequest();
axInjected.Attributes.AddOptional(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.Alias, format));
axInjected.Attributes.AddRequired(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.FullName, format));
this.extensions.Add(axInjected);
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
Assert.AreSame(sreg, this.request.GetExtension <ClaimsRequest>());
Assert.AreEqual(DemandLevel.Request, sreg.Nickname);
Assert.AreEqual(DemandLevel.Require, sreg.FullName);
Assert.AreEqual(DemandLevel.NoRequest, sreg.Language);
var sregResponse = new ClaimsResponse {
Nickname = "andy",
};
this.request.AddResponseExtension(sregResponse);
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
var extensions = this.GetResponseExtensions();
var axResponse = extensions.OfType <FetchResponse>().Single();
Assert.AreEqual("andy", axResponse.GetAttributeValue(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.Alias, format)));
}
public static Dictionary <string, string> ToDictionary(this ClaimsResponse response)
{
var map = new Dictionary <string, string>();
if (response == null)
{
return(map);
}
if (response.BirthDate.HasValue)
{
map["BirthDate"] = response.BirthDate.Value.ToJsv();
}
if (!response.BirthDateRaw.IsNullOrEmpty())
{
map["BirthDateRaw"] = response.BirthDateRaw;
}
if (!response.Country.IsNullOrEmpty())
{
map["Country"] = response.Country;
}
if (response.Culture != null)
{
map["Culture"] = response.Culture.TwoLetterISOLanguageName;
}
if (!response.Email.IsNullOrEmpty())
{
map["Email"] = response.Email;
}
if (!response.FullName.IsNullOrEmpty())
{
map["FullName"] = response.FullName;
}
if (response.Gender.HasValue)
{
map["Gender"] = response.Gender.Value.ToString();
}
if (!response.Language.IsNullOrEmpty())
{
map["Language"] = response.Language;
}
if (response.MailAddress != null)
{
map["MailAddress"] = response.MailAddress.ToJsv();
}
if (!response.Nickname.IsNullOrEmpty())
{
map["Nickname"] = response.Nickname;
}
if (!response.PostalCode.IsNullOrEmpty())
{
map["PostalCode"] = response.PostalCode;
}
if (!response.TimeZone.IsNullOrEmpty())
{
map["TimeZone"] = response.TimeZone;
}
return(map);
}
public void UnifyExtensionsAsSregWithBothSregAndAX()
{
var sregInjected = new ClaimsRequest {
Nickname = DemandLevel.Request,
};
this.extensions.Add(sregInjected);
var axInjected = new FetchRequest();
axInjected.Attributes.AddOptional(WellKnownAttributes.Contact.Email);
this.extensions.Add(axInjected);
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
Assert.AreSame(sregInjected, sreg);
Assert.AreEqual(DemandLevel.Request, sreg.Nickname);
Assert.AreEqual(DemandLevel.NoRequest, sreg.Email);
var sregResponseInjected = new ClaimsResponse {
Nickname = "andy",
};
this.request.AddResponseExtension(sregResponseInjected);
var axResponseInjected = new FetchResponse();
axResponseInjected.Attributes.Add(WellKnownAttributes.Contact.Email, "*****@*****.**");
this.request.AddResponseExtension(axResponseInjected);
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
var extensions = this.GetResponseExtensions();
var sregResponse = extensions.OfType <ClaimsResponse>().Single();
Assert.AreEqual("andy", sregResponse.Nickname);
var axResponse = extensions.OfType <FetchResponse>().Single();
Assert.AreEqual("*****@*****.**", axResponse.GetAttributeValue(WellKnownAttributes.Contact.Email));
}
public void EmptyMailAddress()
{
ClaimsResponse response = new ClaimsResponse(Constants.sreg_ns);
response.Email = string.Empty;
Assert.IsNull(response.MailAddress);
}
private bool IsValidForUserCreation(OpenIdEventArgs e, ClaimsResponse claim)
{
bool result = true;
if (claim == null)
{
return(false);
}
if (String.IsNullOrEmpty(claim.Email))
{
return(false);
}
if (String.IsNullOrEmpty(claim.FullName))
{
return(false);
}
if (!Email.IsValidEmailAddressSyntax(claim.Email))
{
return(false);
}
mojoProfileConfiguration profileConfig = mojoProfileConfiguration.GetConfig();
if (profileConfig.HasRequiredCustomProperties())
{
result = false;
}
return(result);
}
public async Task <ClaimsResponse> GetClaimListByPaging(ListDTO listDTO)
{
ClaimsResponse claimsResponse = new ClaimsResponse();
var lst = (from a in Context.Set <Claims>()
select new ClaimsRow()
{
Id = a.Id, ActionName = a.ActionName, ActionTitleEn = a.ActionTitleEn,
ActionTitleFr = a.ActionTitleFr, ControlleEnTitile = a.ControlleEnTitile, ControlleFaTitile = a.ControlleFaTitile,
ControllerEntityID = a.ControllerEntityID, ControllerName = a.ControllerName
}).AsQueryable();
if (listDTO.Filter != null && listDTO.Filter.Trim().Length != 0)
{
lst = new LinqSearch().ApplyFilter(lst, listDTO.Filter);
}
if (listDTO.IsRequestCount)
{
claimsResponse.LstCount = await lst.CountAsync();
}
else
{
claimsResponse.Claims = await lst.Skip((listDTO.PageNum - 1) *listDTO.PageSize).Take(listDTO.PageSize).ToListAsync();
}
return(claimsResponse);
}
public void Birthdates()
{
var response = new ClaimsResponse();
// Verify that they both start out as null
Assert.IsNull(response.BirthDateRaw);
Assert.IsFalse(response.BirthDate.HasValue);
// Verify that null can be set.
response.BirthDate = null;
response.BirthDateRaw = null;
Assert.IsNull(response.BirthDateRaw);
Assert.IsFalse(response.BirthDate.HasValue);
// Verify that the strong-typed BirthDate property can be set and that it affects the raw property.
response.BirthDate = DateTime.Parse("April 4, 1984");
Assert.AreEqual(4, response.BirthDate.Value.Month);
Assert.AreEqual("1984-04-04", response.BirthDateRaw);
// Verify that the raw property can be set with a complete birthdate and that it affects the strong-typed property.
response.BirthDateRaw = "1998-05-08";
Assert.AreEqual("1998-05-08", response.BirthDateRaw);
Assert.AreEqual(DateTime.Parse("May 8, 1998", CultureInfo.InvariantCulture), response.BirthDate);
// Verify that an partial raw birthdate works, and sets the strong-typed property to null since it cannot be represented.
response.BirthDateRaw = "2000-00-00";
Assert.AreEqual("2000-00-00", response.BirthDateRaw);
Assert.IsFalse(response.BirthDate.HasValue);
}
protected void Yes_Click(Object sender, EventArgs e)
{
var sregRequest = ProviderEndpoint.PendingAuthenticationRequest.GetExtension <ClaimsRequest>();
ClaimsResponse sregResponse = null;
if (sregRequest != null)
{
sregResponse = profileFields.GetOpenIdProfileFields(sregRequest);
ProviderEndpoint.PendingAuthenticationRequest.AddResponseExtension(sregResponse);
}
var papeRequest = ProviderEndpoint.PendingAuthenticationRequest.GetExtension <PolicyRequest>();
PolicyResponse papeResponse = null;
if (papeRequest != null)
{
papeResponse = new PolicyResponse();
papeResponse.NistAssuranceLevel = NistAssuranceLevel.InsufficientForLevel1;
ProviderEndpoint.PendingAuthenticationRequest.AddResponseExtension(papeResponse);
}
ProviderEndpoint.PendingAuthenticationRequest.IsAuthenticated = true;
Debug.Assert(ProviderEndpoint.PendingAuthenticationRequest.IsResponseReady);
ProviderEndpoint.PendingAuthenticationRequest.Response.Send();
ProviderEndpoint.PendingAuthenticationRequest = null;
}
public void EmptyMailAddress()
{
ClaimsResponse response = new ClaimsResponse(Constants.TypeUris.Standard);
response.Email = string.Empty;
Assert.IsNull(response.MailAddress);
}
public async Task <ClaimsResponse> GetClaimsByRole(string roleId)
{
try
{
ClaimsResponse claimsResponse = new ClaimsResponse();
claimsResponse.Claims = new List <ClaimsRow>();
var claimsIds = await Context.RoleClaims.Where(a => a.RoleId == roleId).Select(a => int.Parse(a.ClaimValue)).ToListAsync();
var _claims = await Context.Claims.Where(a => claimsIds.Contains(a.Id)).Select(a => a).ToListAsync();
foreach (var item in _claims)
{
ClaimsRow claimsRow = new ClaimsRow();
item.CopyPropertiesTo(claimsRow);
claimsResponse.Claims.Add(claimsRow);
}
claimsResponse.LstCount = claimsResponse.Claims.Count();
claimsResponse.ToSuccess <ClaimsResponse>();
return(claimsResponse);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
private void ParameterizedTypeUriPreservedTest(string typeUri)
{
ClaimsRequest request = new ClaimsRequest(typeUri);
ClaimsResponse response = request.CreateResponse();
Assert.AreEqual(typeUri, ((IOpenIdMessageExtension)response).TypeUri);
}
internal static UniversalProfile ProfileFromOpenId(ClaimsResponse spprofile, FetchResponse fetchprofile, string claimedId)
{
var profile = new UniversalProfile
{
Link = claimedId,
Id = claimedId,
Provider = "openid",
};
if (spprofile != null)
{
//Fill
profile.BirthDay = spprofile.BirthDateRaw;
profile.DisplayName = spprofile.FullName;
profile.EMail = spprofile.Email;
profile.Name = spprofile.Nickname;
profile.Gender = spprofile.Gender.HasValue ? spprofile.Gender.Value.ToString() : "";
profile.TimeZone = spprofile.TimeZone;
profile.Locale = spprofile.Language;
}
if (fetchprofile != null)
{
profile.Name = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Alias);
profile.LastName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Last);
profile.FirstName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.First);
profile.DisplayName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.FullName);
profile.MiddleName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Middle);
profile.Salutation = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Prefix);
profile.Avatar = fetchprofile.GetAttributeValue(WellKnownAttributes.Media.Images.Default);
profile.EMail = fetchprofile.GetAttributeValue(WellKnownAttributes.Contact.Email);
profile.Gender = fetchprofile.GetAttributeValue(WellKnownAttributes.Person.Gender);
profile.BirthDay = fetchprofile.GetAttributeValue(WellKnownAttributes.BirthDate.WholeBirthDate);
}
return(profile);
}
/// <summary>
/// Called when an incoming positive assertion is received.
/// </summary>
/// <param name="assertion">The positive assertion.</param>
void IRelyingPartyBehavior.OnIncomingPositiveAssertion(IAuthenticationResponse assertion)
{
if (assertion.GetExtension <ClaimsResponse>() == null)
{
ClaimsResponse sreg = assertion.UnifyExtensionsAsSreg(true);
((PositiveAnonymousResponse)assertion).Response.Extensions.Add(sreg);
}
}
/// <summary>
/// Correctly calculate the unclaimed GAS from a claim response
/// </summary>
/// <param name="claims">The claim response object</param>
/// <returns>A proper decimal GAS amount</returns>
public static decimal GetUnclaimedGas(this ClaimsResponse claims)
{
if (claims == null || claims.TotalUnspentClaim == 0)
{
return(0);
}
return((decimal)claims.TotalUnspentClaim / 100000000);
}
private void addClaimInfo(ClaimsResponse claim, string identifier)
{
Email = claim.Email;
FullName = claim.FullName;
Nickname = claim.Nickname ?? claim.Email;
IsSignedByProvider = claim.IsSignedByProvider;
ClaimedIdentifier = identifier;
}
public async Task DualIdentifierNoMatchInAssertionVerificationByDefault()
{
PositiveAssertionResponse assertion = this.GetPositiveAssertion(true);
ClaimsResponse extension = new ClaimsResponse();
assertion.Extensions.Add(extension);
var rp = CreateRelyingParty();
await PositiveAuthenticationResponse.CreateAsync(assertion, rp, CancellationToken.None); // this will throw if it fails to find a match
}
public IActionResult Index()
{
ViewBag.lang = langcode;
var _paidclaims = GetPaidClaimsById();
var claimsResponse = new ClaimsResponse();
claimsResponse.PaidClaims = _paidclaims.OrderByDescending(c => c.POLICY_INC).ToList();
return(View(claimsResponse));
}
public IActionResult GetOSClaims()
{
ViewBag.lang = langcode;
var _osClaims = GetOSClaimsById();
var claimsResponse = new ClaimsResponse();
claimsResponse.OSClaims = _osClaims.OrderByDescending(c => c.POLICY_INC).ToList();
return(View(claimsResponse));
}
protected void Yes_Click(object sender, EventArgs e)
{
this.RegisterAsyncTask(
new PageAsyncTask(
async ct => {
if (!Page.IsValid || ProviderEndpoint.PendingRequest == null)
{
return;
}
if (this.OAuthPanel.Visible)
{
string grantedScope = null;
if (this.oauthPermission.Checked)
{
// This SIMPLE sample merely uses the realm as the consumerKey,
// but in a real app this will probably involve a database lookup to translate
// the realm to a known consumerKey.
grantedScope = string.Empty; // we don't scope individual access rights on this sample
}
OAuthHybrid.ServiceProvider.AttachAuthorizationResponse(ProviderEndpoint.PendingRequest, grantedScope);
}
var sregRequest = ProviderEndpoint.PendingRequest.GetExtension <ClaimsRequest>();
ClaimsResponse sregResponse = null;
if (sregRequest != null)
{
sregResponse = this.profileFields.GetOpenIdProfileFields(sregRequest);
ProviderEndpoint.PendingRequest.AddResponseExtension(sregResponse);
}
var papeRequest = ProviderEndpoint.PendingRequest.GetExtension <PolicyRequest>();
PolicyResponse papeResponse = null;
if (papeRequest != null)
{
papeResponse = new PolicyResponse();
papeResponse.NistAssuranceLevel = NistAssuranceLevel.InsufficientForLevel1;
ProviderEndpoint.PendingRequest.AddResponseExtension(papeResponse);
}
if (ProviderEndpoint.PendingAuthenticationRequest != null)
{
ProviderEndpoint.PendingAuthenticationRequest.IsAuthenticated = true;
}
else
{
ProviderEndpoint.PendingAnonymousRequest.IsApproved = true;
}
Debug.Assert(
ProviderEndpoint.PendingRequest.IsResponseReady, "Setting authentication should be all that's necessary.");
var provider = new ProviderEndpoint();
var response = await provider.PrepareResponseAsync();
await response.SendAsync();
}));
}
public void DualIdentifierNoMatchInAssertionVerificationByDefault()
{
PositiveAssertionResponse assertion = this.GetPositiveAssertion(true);
ClaimsResponse extension = new ClaimsResponse();
assertion.Extensions.Add(extension);
var rp = CreateRelyingParty();
new PositiveAuthenticationResponse(assertion, rp); // this will throw if it fails to find a match
}
public async Task DualIdentifierMatchesInAssertionVerification()
{
PositiveAssertionResponse assertion = this.GetPositiveAssertion(true);
ClaimsResponse extension = new ClaimsResponse();
assertion.Extensions.Add(extension);
var rp = CreateRelyingParty();
rp.SecuritySettings.AllowDualPurposeIdentifiers = true;
await PositiveAuthenticationResponse.CreateAsync(assertion, rp, CancellationToken.None); // this will throw if it fails to find a match
}
public void ResponseAlternateTypeUriTests()
{
var request = new ClaimsRequest(Constants.TypeUris.Variant10);
request.Email = DemandLevel.Require;
var response = new ClaimsResponse(Constants.TypeUris.Variant10);
response.Email = "*****@*****.**";
ExtensionTestUtilities.Roundtrip(Protocol.Default, new[] { request }, new[] { response });
}
public async Task ResponseAlternateTypeUriTests()
{
var request = new ClaimsRequest(Constants.TypeUris.Variant10);
request.Email = DemandLevel.Require;
var response = new ClaimsResponse(Constants.TypeUris.Variant10);
response.Email = "*****@*****.**";
await this.RoundtripAsync(Protocol.Default, new[] { request }, new[] { response });
}
void parameterizedPreserveVersionFromRequest(string versionTypeUri)
{
Dictionary <string, string> fields = new Dictionary <string, string> {
{ "optional", "nickname" },
};
var req = new ClaimsRequest();
Assert.IsTrue(((IExtensionRequest)req).Deserialize(fields, null, versionTypeUri));
Assert.AreEqual(DemandLevel.Request, req.Nickname);
ClaimsResponse resp = req.CreateResponse();
Assert.AreEqual(versionTypeUri, ((IExtensionResponse)resp).TypeUri);
}
public void XmlSerialization()
{
ClaimsResponse fields = this.GetFilledData();
MemoryStream ms = new MemoryStream();
XmlSerializer xs = new XmlSerializer(typeof(ClaimsResponse));
xs.Serialize(ms, fields);
ms.Position = 0;
ClaimsResponse fields2 = (ClaimsResponse)xs.Deserialize(ms);
Assert.AreEqual(fields, fields2);
}
public void BinarySerialization()
{
ClaimsResponse fields = this.GetFilledData();
MemoryStream ms = new MemoryStream();
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(ms, fields);
ms.Position = 0;
ClaimsResponse fields2 = (ClaimsResponse)formatter.Deserialize(ms);
Assert.AreEqual(fields, fields2);
}
static void Main()
{
init();
//initialization
GlobalState.is_positive_assertion = new PositiveAssertionResponse();
result = c.PrepareResponseAsync_CCP(Auth_resp);
//Check for extensions
ClaimsResponse sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg((IAuthenticationResponse)result, true);
GlobalState.actualExt = sreg;
//signature coverage -- returnTo and ClaimedIdentifier are protected by the signature
Contract.Assume(Auth_resp.ClaimedIdentifier == SignIn_req.ClaimedIdentifier);
//signature coverage -- returnTo and ClaimedIdentifier are protected by the signature
Contract.Assume(SignIn_req.ReturnTo == Auth_resp.ReturnTo);
CancellationToken x = default(CancellationToken);
result1 = rp.GetResponseAsync_ccp(SignIn_req, x);
sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(result1, true);
GlobalState.claimedExt = sreg;
//signature coverage
if (identity == Identity.Email)
{
Contract.Assume(GlobalState.actualExt.Email != null && GlobalState.claimedExt.Email == GlobalState.actualExt.Email);
}
//RP check: Does the final returnTo field match our origin?
//This is supplied by the developer of the convincee
Contract.Assert(Auth_resp.ReturnTo == HttpContext.Current.Request.Url);
//check for extension
if (identity == Identity.Email)
{
Contract.Assert(GlobalState.actualExt.Email != null && GlobalState.claimedExt.Email == GlobalState.actualExt.Email);
}
else if (identity == Identity.ClaimedId)
{
Contract.Assert(Auth_resp.ClaimedIdentifier == SignIn_req.ClaimedIdentifier);
}
//RP check: verify claimed id resolves to the correct endpoint
Contract.Assert(GlobalState.is_positive_assertion == null || GlobalState.claimedEndPoint == GlobalState.actualEndPoint);
//shuo's assertion
Contract.Assert(Get_ID_Assertion(auth_req_sessionID, auth_req_realm).ClaimedIdentifier == SignIn_req.ClaimedIdentifier);
Contract.Assert(Get_ID_Assertion(auth_req_sessionID, auth_req_realm).ReturnTo == HttpContext.Current.Request.Url);
Contract.Assert(Get_ID_Assertion(auth_req_sessionID, auth_req_realm).Recipient.Authority == HttpContext.Current.Request.Url.Authority);
}
private void LogUser(string openId, ClaimsResponse profileFields)
{
//recupero l'utente da db, oppure lo creo al volo se non esiste
MTBUser user = DBHelper.LoadUser(openId);
//non esiste? allora lo creo e lo metto nella sessione come NewUser, quindi
//rimando alla pagina User che, solo dopo aver inserito i dati obblicatori, lo metterà
//finalmente in sessione come User
if (user == null)
{
user = new MTBUser();
user.OpenId = openId;
user.Surname = "";
if (profileFields != null)
{
user.Name = profileFields.FullName;
user.EMail = profileFields.Email;
user.Nickname = profileFields.Nickname;
if (profileFields.Gender != null)
{
switch (profileFields.Gender.Value)
{
case Gender.Male:
user.Gender = MTBUser.GenderType.Male;
break;
case Gender.Female:
user.Gender = MTBUser.GenderType.Female;
break;
default:
break;
}
}
if (profileFields.BirthDate != null)
{
user.BirthDate = profileFields.BirthDate.Value;
}
}
LoginState.NewUser = user;
Response.Redirect("User.aspx");
}
else
{
LoginState.User = user;
FormsAuthentication.RedirectFromLoginPage("", false);
}
}
public async Task <ClaimsResponse> GetListAsync(ListDTO listDTO)
{
var response = new ClaimsResponse();
try
{
response = await _claimsRepository.GetClaimListByPaging(listDTO);
return(response.ToSuccess <ClaimsResponse>());
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
