/// <summary>
/// Authenticates a user in Umbraco.
/// </summary>
protected virtual bool AuthenticateUser(string username, IGigyaModuleSettings settings, bool updateProfile, dynamic gigyaModel, List <MappingField> mappingFields)
{
FormsAuthentication.SetAuthCookie(username, false);
if (settings.DebugMode)
{
_logger.Debug(string.Concat("User [", username, "] successfully logged into Umbraco."));
}
if (updateProfile)
{
MapProfileFieldsAndUpdate(username, username, settings, gigyaModel, mappingFields);
}
return(true);
}
public static void ValidateAndLoginToGigyaIfRequired(HttpContext context, IGigyaModuleSettings settings = null)
{
if (context.Items.Contains(_checkedIfLoginRequiredKey))
{
return;
}
context.Items[_checkedIfLoginRequiredKey] = true;
var settingsHelper = new GigyaSettingsHelper();
var logger = LoggerFactory.Instance();
var membershipHelper = new GigyaMembershipHelper(new GigyaApiHelper(settingsHelper, logger), logger);
var accountHelper = new GigyaAccountHelper(settingsHelper, logger, membershipHelper, settings);
accountHelper.LoginToGigyaIfRequired();
}
/// <summary>
/// Creates a view model for use in a view.
/// </summary>
/// <param name="settings">The settings for the current site.</param>
/// <param name="urlHelper">UrlHelper for the current request.</param>
public virtual GigyaSettingsViewModel ViewModel(IGigyaModuleSettings settings, UrlHelper urlHelper, CurrentIdentity currentIdentity)
{
var model = new GigyaSettingsViewModel
{
ApiKey = settings.ApiKey,
DebugMode = settings.DebugMode,
GigyaScriptPath = UrlUtils.AddQueryStringParam(_pathUtilities.ToAbsolute(ClientScriptPath(settings, urlHelper)), "v=" + CmsVersion + ModuleVersion),
LoggedInRedirectUrl = settings.RedirectUrl,
LogoutUrl = settings.LogoutUrl,
IsLoggedIn = currentIdentity.IsAuthenticated,
Id = settings.Id,
DataCenter = settings.DataCenter,
IsGetInfoRequired = settings.SessionProvider == Enums.GigyaSessionProvider.CMS
};
model.Settings = !string.IsNullOrEmpty(settings.GlobalParameters) ? JsonConvert.DeserializeObject <ExpandoObject>(settings.GlobalParameters) : new ExpandoObject();
var settingsProperties = (IDictionary <string, object>)model.Settings;
if (!settingsProperties.ContainsKey("lang"))
{
model.Settings.lang = Language(settings);
}
if (settings.SessionProvider == Enums.GigyaSessionProvider.Gigya && settings.GigyaSessionMode == Enums.GigyaSessionMode.Sliding)
{
// client needs -1 to specify a sliding session
model.Settings.sessionExpiration = -1;
}
else if (settings.SessionProvider == Enums.GigyaSessionProvider.Gigya && settings.GigyaSessionMode == Enums.GigyaSessionMode.Forever)
{
// client needs -1 to specify a session that stays valid until the browser closes
model.Settings.sessionExpiration = -2;
}
else if (settings.SessionProvider == Enums.GigyaSessionProvider.Gigya && settings.GigyaSessionMode == Enums.GigyaSessionMode.Session)
{
// client needs 0 to specify a session cookie
model.Settings.sessionExpiration = 0;
}
else if (!settingsProperties.ContainsKey("sessionExpiration"))
{
model.Settings.sessionExpiration = settings.SessionTimeout;
}
model.SettingsJson = JsonConvert.SerializeObject(model.Settings);
return(model);
}
protected override string Language(IGigyaModuleSettings settings)
{
var languageHelper = new GigyaLanguageHelper();
var languageKey = CultureInfo.CurrentUICulture.Name.ToLowerInvariant();
var currentSite = SystemManager.CurrentContext.CurrentSite;
var cultures = currentSite.PublicContentCultures;
if (cultures != null && cultures.Length == 1 && !string.IsNullOrEmpty(currentSite.DefaultCulture))
{
languageKey = currentSite.DefaultCulture.ToLowerInvariant();
}
var culture = new CultureInfo(languageKey);
return(languageHelper.Language(settings, culture));
}
protected bool PersistentAuthRequired(IGigyaModuleSettings settings)
{
if (settings.SessionProvider == Enums.GigyaSessionProvider.CMS || settings.SessionProvider != Enums.GigyaSessionProvider.Gigya)
{
// legacy behaviour
return(false);
}
switch (settings.GigyaSessionMode)
{
case Enums.GigyaSessionMode.Session:
return(false);
default:
return(true);
}
}
/// <summary>
/// Calls ds.get to get ds data.
/// </summary>
/// <param name="settings">Current module settings.</param>
/// <param name="uid">The user Id.</param>
/// <param name="oid">The oid of the ds field.</param>
/// <param name="gigyaType">The ds type.</param>
/// <param name="fields">The fields to retrieve.</param>
public GSResponse Get(IGigyaModuleSettings settings, string uid, string oid, string gigyaType, IEnumerable <string> fields = null)
{
var request = NewRequest(settings, settings.ApplicationSecret, "ds.get");
request.SetParam("UID", uid);
request.SetParam("oid", oid);
request.SetParam("type", gigyaType);
if (fields != null && fields.Any())
{
var fieldsValue = string.Join(",", fields);
request.SetParam("fields", fieldsValue);
}
var response = Send(request, "ds.get", settings);
return(response);
}
private GigyaSettingsModel GetModel(int id, IGigyaModuleSettings data)
{
var model = Map(data);
model.Inherited = model.Id != id;
model.Id = id;
if (id > 0)
{
var node = new DynamicNode(id);
model.SiteName = node.Name;
}
else
{
model.SiteName = "Global";
}
ApplyDefaults(ref model, data);
return(model);
}
/// <summary>
/// Gets Gigya Module settings for <paramref name="id"/>.
/// </summary>
/// <param name="id">The Id of the site.</param>
/// <param name="decrypt">Whether to decrypt the application secret.</param>
public virtual IGigyaModuleSettings Get(object id, bool decrypt = false)
{
var cacheKey = string.Concat(_cacheKeyBase, id, decrypt);
IGigyaModuleSettings settings = null;
var context = HttpContext.Current;
if (context != null)
{
settings = context.Items[cacheKey] as IGigyaModuleSettings;
if (settings != null)
{
return(settings);
}
}
var siteSettingsAndGlobal = GetForSiteAndDefault(id);
settings = siteSettingsAndGlobal.OrderByDescending(i => i.Id).FirstOrDefault() ?? EmptySettings(id);
// decrypt application secret
if (decrypt && !string.IsNullOrEmpty(settings.ApplicationSecret))
{
settings.ApplicationSecret = Encryptor.Decrypt(settings.ApplicationSecret);
}
settings.MappedMappingFields = !string.IsNullOrEmpty(settings.MappingFields)
? JsonConvert.DeserializeObject <List <MappingField> >(settings.MappingFields) : new List <MappingField>();
MapOldDataCenter(ref settings);
if (context != null)
{
// cache for the rest of this request
context.Items[cacheKey] = settings;
}
return(settings);
}
/// <summary>
/// Gets the Gigya UID for the current logged in user. If the user isn't logged in, null is returned.
/// </summary>
/// <param name="settings">Current site settings.</param>
/// <returns>The UID value.</returns>
public string GetUidForCurrentUser(IGigyaModuleSettings settings)
{
// check user is logged in
var currentIdentity = ClaimsManager.GetCurrentIdentity();
if (!currentIdentity.IsAuthenticated)
{
return(null);
}
// get mapping field - hopefully the Sitefinity username field maps to Gigya's UID
var field = settings.MappedMappingFields.FirstOrDefault(i => i.GigyaFieldName == Constants.GigyaFields.UserId);
if (field == null || field.CmsFieldName == Constants.SitefinityFields.UserId)
{
return(currentIdentity.Name);
}
// get UID field from profile
UserProfileManager profileManager = UserProfileManager.GetManager();
UserManager userManager = UserManager.GetManager();
var user = userManager.GetUser(currentIdentity.Name);
if (user == null)
{
return(currentIdentity.Name);
}
var profile = profileManager.GetUserProfile <SitefinityProfile>(user);
if (profile == null)
{
return(currentIdentity.Name);
}
return(profile.GetValue <string>(field.CmsFieldName));
}
private GSResponse Send(GSRequest request, string apiMethod, IGigyaModuleSettings settings)
{
GSResponse response = null;
try
{
response = request.Send();
}
catch (Exception e)
{
return(LogError(response, apiMethod, e));
}
GigyaApiHelper.LogResponseIfRequired(_logger, settings, apiMethod, response);
if (response.GetErrorCode() != 0)
{
LogError(response, apiMethod, null);
return(null);
}
return(response);
}
/// <summary>
/// Gets the Gigya language to use.
/// </summary>
/// <returns>A culture code.</returns>
public string Language(IGigyaModuleSettings settings, CultureInfo currentCulture)
{
if (settings.Language != "auto")
{
return(settings.Language);
}
var language = currentCulture.Name.ToLowerInvariant();
if (Languages.ContainsKey(language))
{
return(language);
}
// attempt to find non specific culture
language = currentCulture.TwoLetterISOLanguageName.ToLowerInvariant();
if (Languages.ContainsKey(language))
{
return(language);
}
return(settings.LanguageFallback);
}
public bool ValidateSignature(string userId, IGigyaModuleSettings settings, GSResponse response, bool disableSignatureExchange = false)
{
return(SigUtils.ValidateUserSignature(userId, response.GetString(Constants.GigyaFields.SignatureTimestamp, null),
settings.ApplicationSecret, response.GetString(Constants.GigyaFields.UserIdSignature, null)));
}
/// <summary>
/// Sends a request to the Gigya API.
/// </summary>
/// <param name="request">Request object.</param>
/// <param name="apiMethod">The Gigya method to call.</param>
/// <param name="settings">The Gigya module settings.</param>
/// <param name="validateSignature">If set to true, the signature will be validated.</param>
/// <returns></returns>
private GSResponse Send(GSRequest request, string apiMethod, IGigyaModuleSettings settings, bool validateSignature)
{
if (apiMethod == "accounts.getAccountInfo")
{
var environment = new
{
cms_name = _settingsHelper.CmsName,
cms_version = _settingsHelper.CmsVersion,
gigya_version = _settingsHelper.ModuleVersion
};
request.SetParam("environment", JsonConvert.SerializeObject(environment));
}
if (!string.IsNullOrEmpty(settings.DataCenter))
{
request.APIDomain = settings.DataCenter;
}
LogRequestIfRequired(settings, apiMethod);
GSResponse response = null;
try
{
response = request.Send();
}
catch (Exception e)
{
dynamic gigyaModel = response != null?JsonConvert.DeserializeObject <ExpandoObject>(response.GetResponseText()) : new ExpandoObject();
var gigyaError = response != null?response.GetErrorMessage() : string.Empty;
var gigyaErrorDetail = DynamicUtils.GetValue <string>(gigyaModel, "errorDetails");
var gigyaCallId = DynamicUtils.GetValue <string>(gigyaModel, "callId");
_logger.Error(string.Format("API call: {0}. CallId: {1}. Error: {2}. Error Details: {3}.", apiMethod, gigyaCallId, gigyaError, gigyaErrorDetail), e);
return(response);
}
LogResponseIfRequired(settings, apiMethod, response);
if (response.GetErrorCode() != 0)
{
return(response);
}
var userId = response.GetString(Constants.GigyaFields.UserId, null);
if (string.IsNullOrEmpty(userId))
{
return(response);
}
// no need to validate server calls unless explicitly required e.g. for signature exchange
if (validateSignature && !ValidateSignature(userId, settings, response))
{
if (settings.DebugMode)
{
dynamic gigyaModel = response != null?JsonConvert.DeserializeObject <ExpandoObject>(response.GetResponseText()) : new ExpandoObject();
var gigyaCallId = DynamicUtils.GetValue <string>(gigyaModel, "callId");
_logger.DebugFormat("Invalid user signature for login request. API call: {0}. CallId: {1}.", apiMethod, gigyaCallId);
}
return(null);
}
return(response);
}
/// <summary>
/// Maps Gigya fields to a Sitefinity profile.
/// </summary>
/// <param name="profile">The profile to update.</param>
/// <param name="gigyaModel">Deserialized Gigya JSON object.</param>
/// <param name="settings">The Gigya module settings.</param>
protected virtual void MapProfileFields(SitefinityProfile profile, dynamic gigyaModel, IGigyaModuleSettings settings, List <MappingField> mappingFields)
{
if (mappingFields == null)
{
return;
}
profile.FirstName = GetMappedFieldWithFallback(gigyaModel, Constants.SitefinityFields.FirstName, Constants.GigyaFields.FirstName, mappingFields);
profile.LastName = GetMappedFieldWithFallback(gigyaModel, Constants.SitefinityFields.LastName, Constants.GigyaFields.LastName, mappingFields);
// map custom fields
foreach (var field in mappingFields)
{
// check if field is a custom one
switch (field.CmsFieldName)
{
case Constants.SitefinityFields.UserId:
case Constants.SitefinityFields.FirstName:
case Constants.SitefinityFields.LastName:
case Constants.SitefinityFields.Email:
continue;
}
if (!string.IsNullOrEmpty(field.CmsFieldName) && profile.DoesFieldExist(field.CmsFieldName))
{
object gigyaValue = GetGigyaValue(gigyaModel, field.GigyaFieldName, field.CmsFieldName);
if (gigyaValue != null)
{
try
{
profile.SetValue(field.CmsFieldName, gigyaValue);
}
catch (Exception e)
{
_logger.Error(string.Format("Couldn't set Sitefinity profile value for [{0}] and gigya field [{1}].", field.CmsFieldName, field.GigyaFieldName), e);
}
var profileValue = profile.GetValue(field.CmsFieldName);
if (profileValue == null || profileValue.ToString() != gigyaValue.ToString())
{
_logger.Error(string.Format("Sitefinity field [{0}] type doesn't match Gigya field [{1}] type. You may need to add a conversion using EventHub.Subscribe<IMapGigyaFieldEvent>", field.CmsFieldName, field.GigyaFieldName));
}
}
else if (settings.DebugMode)
{
_logger.DebugFormat("Gigya field \"{0}\" is null so profile field not updated.", field.GigyaFieldName);
}
}
else if (settings.DebugMode)
{
_logger.DebugFormat("Sitefinity field \"{0}\" not found.", field.CmsFieldName);
}
}
}
public GigyaSitefinityDsHelper(IGigyaModuleSettings settings, Logger logger, GigyaDsSettings dsSettings, GigyaDsApiHelper apiHelper = null) : base(settings, logger, dsSettings, apiHelper)
{
}
private static List <MappingField> GetMappingFields(IGigyaModuleSettings settings)
{
return(!string.IsNullOrEmpty(settings.MappingFields) ? JsonConvert.DeserializeObject <List <MappingField> >(settings.MappingFields) : new List <MappingField>());
}
public GigyaAccountHelperBase(GigyaSettingsHelper settingsHelper, Logger logger, IGigyaMembershipHelper membershipHelper, IGigyaModuleSettings settings = null)
{
_settings = settings ?? settingsHelper.GetForCurrentSite(true);
_logger = logger;
_settingsHelper = settingsHelper;
_membershipHelper = membershipHelper;
}
protected abstract string Language(IGigyaModuleSettings settings);
private GSRequest NewRequest(IGigyaModuleSettings settings, string method)
{
return(NewRequest(settings, settings.ApplicationSecret, method));
}
/// <summary>
/// Login or register a user.
/// </summary>
/// <param name="model">Details from the client e.g. signature and userId.</param>
/// <param name="settings">Gigya module settings.</param>
/// <param name="response">Response model that will be returned to the client.</param>
public virtual void LoginOrRegister(LoginModel model, IGigyaModuleSettings settings, ref LoginResponseModel response)
{
response.Status = ResponseStatus.Error;
if (!settings.EnableRaas)
{
if (settings.DebugMode)
{
_logger.Debug("RaaS not enabled so login aborted.");
}
return;
}
if (!_gigyaApiHelper.ValidateApplicationKeySignature(model.UserId, settings, model.SignatureTimestamp, model.Signature))
{
if (settings.DebugMode)
{
_logger.Debug("Invalid user signature for login request.");
}
return;
}
// get user info
var userInfoResponse = _gigyaApiHelper.GetAccountInfo(model.UserId, settings);
if (userInfoResponse == null || userInfoResponse.GetErrorCode() != 0)
{
_logger.Error("Failed to getAccountInfo");
return;
}
List <MappingField> mappingFields = GetMappingFields(settings);
var gigyaModel = GetAccountInfo(model.Id, settings, userInfoResponse, mappingFields);
ThrowTestingExceptionIfRequired(settings, gigyaModel);
// find what field has been configured for the CMS username
var username = GetCmsUsername(mappingFields, gigyaModel);
UserManager manager = UserManager.GetManager();
var userExists = manager.UserExists(username);
if (!userExists)
{
// user doesn't exist so create a new one
using (new ElevatedModeRegion(manager))
{
var createUserStatus = CreateUser(username, gigyaModel, settings, mappingFields);
if (createUserStatus != MembershipCreateStatus.Success)
{
return;
}
}
}
// user logged into Gigya so now needs to be logged into Sitefinity
var authenticated = AuthenticateUser(username, settings, userExists, gigyaModel, mappingFields);
response.Status = authenticated ? ResponseStatus.Success : ResponseStatus.Error;
if (authenticated)
{
response.RedirectUrl = settings.RedirectUrl;
var settingsHelper = new GigyaSettingsHelper();
var accountHelper = new GigyaAccountHelper(settingsHelper, _logger, this, settings);
accountHelper.UpdateSessionExpirationCookieIfRequired(HttpContext.Current, true);
}
}
private void MapOldDataCenter(ref IGigyaModuleSettings settings)
{
settings.DataCenter = MapOldDataCenter(settings.DataCenter);
}
/// <summary>
/// Updates the users Sitefinity profile.
/// </summary>
/// <param name="username">Id of the user to update.</param>
/// <param name="settings">Gigya module settings for this site.</param>
/// <param name="gigyaModel">Deserialized Gigya JSON object.</param>
protected virtual bool MapProfileFieldsAndUpdate(string currentUsername, string updatedUsername, IGigyaModuleSettings settings, dynamic gigyaModel, List <MappingField> mappingFields)
{
UserProfileManager profileManager = UserProfileManager.GetManager();
UserManager userManager = UserManager.GetManager();
using (new ElevatedModeRegion(userManager))
{
var user = userManager.GetUser(currentUsername);
user.Email = GetMappedFieldWithFallback(gigyaModel, Constants.SitefinityFields.Email, Constants.GigyaFields.Email, mappingFields);
if (user.UserName != updatedUsername)
{
user.SetUserName(updatedUsername);
}
SitefinityProfile profile = profileManager.GetUserProfile <SitefinityProfile>(user);
if (profile == null)
{
profile = profileManager.CreateProfile(user, Guid.NewGuid(), typeof(SitefinityProfile)) as SitefinityProfile;
// only set this on creation as it's possible to get 2 users with the same email address
profile.Nickname = user.Email;
}
// map any custom fields
MapProfileFields(profile, gigyaModel, settings, mappingFields);
try
{
userManager.SaveChanges();
profileManager.SaveChanges();
return(true);
}
catch (Exception e)
{
_logger.Error("Failed to update profile for userId: " + currentUsername, e);
}
}
return(false);
}
/// <summary>
/// Updates the users Umbraco profile.
/// </summary>
/// <param name="userId">Id of the user to update.</param>
/// <param name="settings">Gigya module settings for this site.</param>
/// <param name="gigyaModel">Deserialized Gigya JSON object.</param>
protected bool MapProfileFieldsAndUpdate(string currentUsername, string updatedUsername, IGigyaModuleSettings settings, dynamic gigyaModel, List <MappingField> mappingFields)
{
var memberService = U.Core.ApplicationContext.Current.Services.MemberService;
var user = memberService.GetByUsername(currentUsername);
var email = GetGigyaFieldFromCmsAlias(gigyaModel, Constants.CmsFields.Email, null, mappingFields);
if (string.IsNullOrEmpty(email))
{
email = GetGigyaValue(gigyaModel, Constants.GigyaFields.Email, Constants.CmsFields.Email);
}
user.Email = email;
if (user.Username != updatedUsername)
{
user.Username = updatedUsername;
}
// map any custom fields
MapProfileFields(user, gigyaModel, settings, mappingFields);
try
{
memberService.Save(user);
return(true);
}
catch (Exception e)
{
_logger.Error("Failed to update profile for userId: " + currentUsername, e);
}
return(false);
}
public bool LoginByUsername(string username, IGigyaModuleSettings settings)
{
FormsAuthentication.SetAuthCookie(username, false);
return(true);
}
private void LogResponseIfRequired(IGigyaModuleSettings settings, string apiMethod, GSResponse response)
{
LogResponseIfRequired(_logger, settings, apiMethod, response);
}
protected virtual string ClientScriptPath(IGigyaModuleSettings settings, UrlHelper urlHelper)
{
var scriptName = settings.DebugMode ? "gigya-cms.js" : "gigya-cms.min.js";
return(string.Concat("~/scripts/", scriptName));
}
private GSRequest NewRequest(IGigyaModuleSettings settings, string applicationSecret, string method)
{
return(new GSRequest(settings.ApiKey, applicationSecret, method, null, true, settings.ApplicationKey));
}
/// <summary>
/// Creates a new Sitefinity user from a Gigya user.
/// </summary>
/// <param name="username">The Id of the new user.</param>
/// <param name="gigyaModel">Deserialized Gigya JSON object.</param>
/// <param name="settings">Gigya module settings for the site.</param>
/// <returns></returns>
protected virtual MembershipCreateStatus CreateUser(string username, dynamic gigyaModel, IGigyaModuleSettings settings, List <MappingField> mappingFields)
{
UserManager userManager = UserManager.GetManager();
UserProfileManager profileManager = UserProfileManager.GetManager();
MembershipCreateStatus status;
var email = GetMappedFieldWithFallback(gigyaModel, Constants.SitefinityFields.Email, Constants.GigyaFields.Email, mappingFields);
var firstName = GetMappedFieldWithFallback(gigyaModel, Constants.SitefinityFields.FirstName, Constants.GigyaFields.FirstName, mappingFields);
var lastName = GetMappedFieldWithFallback(gigyaModel, Constants.SitefinityFields.LastName, Constants.GigyaFields.LastName, mappingFields);
User user = userManager.CreateUser(username, Guid.NewGuid().ToString(), email, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), true, null, out status);
SitefinityProfile profile = null;
switch (status)
{
case MembershipCreateStatus.Success:
profile = CreateProfile(gigyaModel, settings, userManager, profileManager, user, mappingFields);
break;
case MembershipCreateStatus.DuplicateEmail:
// insert fails if there is a duplicate email even though duplicate emails are allowed...strange huh
var dummyEmail = string.Concat(Guid.NewGuid(), "@gigya.com");
// try insert again with a dummy email and update it afterwards
user = userManager.CreateUser(username, Guid.NewGuid().ToString(), dummyEmail, Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), true, null, out status);
if (status == MembershipCreateStatus.Success)
{
user.Email = email;
profile = CreateProfile(gigyaModel, settings, userManager, profileManager, user, mappingFields);
}
break;
}
if (user == null)
{
return(status);
}
MapProfileFields(profile, gigyaModel, settings, mappingFields);
try
{
userManager.SaveChanges();
profileManager.SaveChanges();
}
catch (Exception e)
{
_logger.Error("Failed to update profile for userId: " + username, e);
}
return(status);
}
/// <summary>
/// Validates an application key signatures by calling accounts.exchangeUIDSignature and checking the response signature.
/// </summary>
public bool ValidateApplicationKeySignature(string userId, IGigyaModuleSettings settings, string signatureTimestamp, string signature)
{
var response = ExchangeSignature(userId, settings, signature, signatureTimestamp, settings.ApplicationKey);
return(ValidateExchangeSignatureResponse(response));
}
/// <summary>
/// Login or register a user.
/// </summary>
/// <param name="model">Details from the client e.g. signature and userId.</param>
/// <param name="settings">Gigya module settings.</param>
/// <param name="response">Response model that will be returned to the client.</param>
public virtual void LoginOrRegister(LoginModel model, IGigyaModuleSettings settings, ref LoginResponseModel response)
{
response.Status = ResponseStatus.Error;
if (!settings.EnableRaas)
{
if (settings.DebugMode)
{
_logger.Debug("RaaS not enabled so login aborted.");
}
return;
}
if (!_gigyaApiHelper.ValidateApplicationKeySignature(model.UserId, settings, model.SignatureTimestamp, model.Signature))
{
if (settings.DebugMode)
{
_logger.Debug("Invalid user signature for login request.");
}
return;
}
// get user info
var userInfoResponse = _gigyaApiHelper.GetAccountInfo(model.UserId, settings);
if (userInfoResponse == null || userInfoResponse.GetErrorCode() != 0)
{
_logger.Error("Failed to getAccountInfo");
return;
}
var gigyaModel = JsonConvert.DeserializeObject <ExpandoObject>(userInfoResponse.GetResponseText());
ThrowTestingExceptionIfRequired(settings, gigyaModel);
// find what field has been configured for the Umbraco username
List <MappingField> mappingFields = GetMappingFields(settings);
var username = GetUmbracoUsername(mappingFields, gigyaModel);
var memberService = U.Core.ApplicationContext.Current.Services.MemberService;
var userExists = memberService.Exists(username);
if (!userExists)
{
// user doesn't exist so create a new one
var user = CreateUser(username, gigyaModel, settings);
if (user == null)
{
return;
}
}
// user logged into Gigya so now needs to be logged into Umbraco
var authenticated = AuthenticateUser(username, settings, userExists, gigyaModel, mappingFields);
response.Status = authenticated ? ResponseStatus.Success : ResponseStatus.Error;
if (authenticated)
{
response.RedirectUrl = settings.RedirectUrl;
}
}
