static void TestGetUserInfo(string[] args)
{
// Step 1 - Defining the request
string method = "socialize.getUserInfo";
GSRequest request = new GSRequest(apiKey, secretKey, method, true);
// Step 2 - Adding parameters
request.SetParam("uid", "di1"); // set the "uid" parameter to user's ID
request.SetParam("enabledProviders", "*,testnetwork,testnetwork2");
request.SetParam("status", "I feel great 22222"); // set the "status" parameter to "I feel great"
// Step 3 - Sending the request
GSResponse response = request.Send();
bool validate = SigUtils.ValidateUserSignature(
response.GetString("UID", ""),
response.GetString("signatureTimestamp", ""), secretKey,
response.GetString("UIDSignature", ""));
// Step 4 - handling the request's response.
if (response.GetErrorCode() == 0)
{ // SUCCESS! response status = OK
Console.WriteLine("Success in setStatus operation.");
}
else
{ // Error
Console.WriteLine("Got error on setStatus: {0}", response.GetErrorMessage());
}
}
public async Task <bool> Login(string password)
{
// Step 1 - Defining the request
GSRequest request = getGigyaRequest("accounts.login");
// Step 2 - Adding parameters
request.SetParam("loginID", Email); // set the "uid" parameter to user's ID
request.SetParam("password", password); // set the "status" parameter to "I feel great"
// Step 3 - Sending the request
GSResponse response = await Task <GSResponse> .Factory.FromAsync(request.BeginSend, request.EndSend, TaskCreationOptions.None);
return(response.GetErrorCode() == 0);
}
/// <summary>
/// Fetch available public key representation validated by the "kid".
/// </summary>
/// <param name="kid">The keyId</param>
/// <param name="apiDomain">The api domain jwt was obtained, for example us1.gigya.com</param>
internal static string FetchPublicKey(string kid, string apiDomain)
{
var resourceUri = $"https://accounts.{apiDomain}/accounts.getJWTPublicKey?V2=true";
var request = (HttpWebRequest)WebRequest.Create(resourceUri);
request.Timeout = 30_000;
request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
request.Method = "GET";
request.KeepAlive = false;
request.ServicePoint.Expect100Continue = false;
GSResponse response;
using (var webResponse = (HttpWebResponse)request.GetResponse())
using (var sr = new StreamReader(webResponse.GetResponseStream(), Encoding.UTF8))
response = new GSResponse(method: request.Method, responseText: sr.ReadToEnd(), logSoFar: null);
if (response.GetErrorCode() == 0)
{
GSArray keys = response.GetArray("keys", null);
if (keys == null || keys.Length == 0)
{
return(null); // Failed to obtain JWK from response data OR data is empty
}
foreach (object key in keys)
{
if (key is GSObject)
{
string jwtKid = ((GSObject)key).GetString("kid", null);
if (jwtKid != null && jwtKid == kid)
{
return(((GSObject)key).ToJsonString());
}
}
}
}
return(null);
}
private void HandleGSResponse(GSResponse res, string format)
{
lblVerifiedSig.Text = "";
if (!format.Equals("xml", StringComparison.InvariantCultureIgnoreCase))
{
format = "txt";
}
var filename = Path.Combine(Path.GetTempPath(), "1." + format);
try {
if (res.GetErrorCode() > 0)
{
lblVerifiedSig.ForeColor = Color.Red;
lblVerifiedSig.Text = "Error !!!";
File.WriteAllText(filename, res.ToString());
}
else
{
if (verifySignature)
{
verifyResponseSignature(res, format);
}
else
{
lblVerifiedSig.Text = "Data is ready";
}
File.WriteAllText(filename, res.GetResponseText());
}
webBrowser1.Navigate(filename);
webBrowser1.Show();
}
catch (Exception ex) {
MessageBox.Show(ex.Message, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
btnSubmit.Text = "Submit";
btnSubmit.Enabled = true;
}
public async Task <bool> Register(string password)
{
// Step 1 - Defining the request
GSRequest initRequest = getGigyaRequest("accounts.initRegistration");
GSResponse initResponse = await Task <GSResponse> .Factory.FromAsync(initRequest.BeginSend, initRequest.EndSend, TaskCreationOptions.None);
if (initResponse.GetErrorCode() != 0)
{
return(false);
}
string regToken = initResponse.GetString("regToken", null);
GSRequest regRequest = getGigyaRequest("accounts.register");
// Step 2 - Adding parameters
//regRequest.SetParam("username", Email);
regRequest.SetParam("email", Email); // set the "uid" parameter to user's ID
regRequest.SetParam("password", password);
regRequest.SetParam("regToken", regToken);
regRequest.SetParam("finalizeRegistration", true);
// Step 3 - Sending the request
GSResponse regresponse = await Task <GSResponse> .Factory.FromAsync(regRequest.BeginSend, regRequest.EndSend, TaskCreationOptions.None);
// Step 4 - handling the request's response.
if (regresponse.GetErrorCode() == 0)
{ // SUCCESS! response status = OK
return(true);
}
else
{ // Error
return(false);
}
}
private GSResponse Send(GSRequest request, string apiMethod, GigyaModuleSettings 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);
}
private bool ValidateExchangeSignatureResponse(GSResponse response)
{
// if signature is invalid a null response is returned
return(response != null && response.GetErrorCode() == 0 && !string.IsNullOrEmpty(response.GetString(Constants.GigyaFields.UserId, 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);
}
private void PublishGigyaActions(User user, GSResponse res)
{
GigyaHelpers.setCookie(res, this.ControllerContext);
GigyaUserData userData = new GigyaUserData()
{
City = user.City,
CountryCode = user.CountryCode,
Email = user.EMail,
FirstName = user.FirstName,
LastName = user.LastName,
State = user.State
};
GigyaUserDataInfo userDataInfo = new GigyaUserDataInfo()
{
UID = user.UserId.ToString(),
data = Newtonsoft.Json.JsonConvert.SerializeObject(userData, Newtonsoft.Json.Formatting.None)
};
GSObject userDataInfoObj = new GSObject(Newtonsoft.Json.JsonConvert.SerializeObject(userDataInfo));
//res = GigyaHelpers.createAndSendRequest("gcs.setUserData", userDataInfoObj);
res = GigyaHelpers.createAndSendRequest("ids.setAccountInfo", userDataInfoObj);
var returnCode = res.GetErrorCode();
//Publish to Activity Feed
List<ActionLink> actionlinks = new List<ActionLink>();
actionlinks.Add(new ActionLink() { text = SNSTemplates.register_actionlink_text, href = String.Format("{0}{1}", GlobalConfig.baseUrl, SNSTemplates.register_actionlink_href) });
//mediaItem
List<MediaItem> mediaItems = new List<MediaItem>();
mediaItems.Add(new MediaItem() { type = SNSTemplates.register_mediaitem_type, src = String.Format("{0}{1}", GlobalConfig.AssetsBaseUrl, SNSTemplates.register_mediaitem_src), href = String.Format("{0}{1}", GlobalConfig.baseUrl, SNSTemplates.register_mediaitem_href) });
UserAction action = new UserAction()
{
actorUID = user.UserId.ToString(),
userMessage = SNSTemplates.register_usermessage,
title = SNSTemplates.register_title,
subtitle = String.Format("{0}{1}", GlobalConfig.baseUrl, SNSTemplates.register_subtitle),
linkBack = String.Format("{0}{1}", GlobalConfig.baseUrl, SNSTemplates.register_linkback),
description = String.Format(SNSTemplates.register_description, user.FirstName),
actionLinks = actionlinks,
mediaItems = mediaItems
};
GigyaMethods.PublishUserAction(action, user.UserId, "external");
action.userMessage = String.Empty;
action.title = String.Empty;
action.mediaItems = null;
GigyaMethods.PublishUserAction(action, user.UserId, "internal");
}