/// <summary>
/// Fetches all ds data using ds.search.
/// FetchDSCompleted event will not be fired.
/// </summary>
/// <param name="uid">The user Id.</param>
public ExpandoObject SearchAll(string uid)
{
if (_dsSettings == null)
{
return(null);
}
var model = new Dictionary <string, object>();
foreach (var mappingType in _dsSettings.MappingsByType)
{
var fields = mappingType.Value.Select(i => i.GigyaFieldName).Distinct();
var data = Search(uid, mappingType.Key, fields);
if (data != null)
{
// do some merge of the data
Dictionary <string, object> mappedDsResult = MapDataToDsType(mappingType.Key, data);
model = DynamicUtils.MergeToDictionary(model, mappedDsResult);
}
}
if (!model.Any())
{
return(null);
}
return(model.ToExpando());
}
private DAL.Image FillSliders()
{
DAL.Image data = new DAL.Image();
if (uplImage.HasFile)
{
try
{
if (uplImage.FileName.Split('.')[1].ToLower() == "jpeg" || uplImage.FileName.Split('.')[1].ToLower() == "jpg" || uplImage.FileName.Split('.')[1].ToLower() == "png" || uplImage.FileName.Split('.')[1].ToLower() == "gif")
{
DynamicUtils dUtils = new DynamicUtils();
string target = dUtils.uploadimage(uplImage);
Session["image"] = Path.GetFileName(uplImage.FileName);
data.Name = uplImage.FileName.Split('.')[0].ToLower();
data.Ext = uplImage.FileName.Split('.')[1].ToLower();
data.Desc = "Left Body";
data.FILE_LOCATION = target;
}
else
{
lblImage.Text = "Upload status: Only JPEG/JPG/PNG/GIF files are accepted!";
return(data);
}
}
catch (Exception ex)
{
lblImage.Text = "Upload status: The file could not be uploaded. The following error occured: " + ex.Message;
}
}
return(data);
}
/// <summary>
/// Fetches ds data using ds.get
/// FetchDSCompleted event will not be fired.
/// </summary>
/// <param name="uid">The user Id.</param>
/// <param name="settings">The mapping settings.</param>
/// <returns></returns>
public ExpandoObject GetAll(string uid)
{
if (_dsSettings == null)
{
return(null);
}
var model = new Dictionary <string, object>();
foreach (var mappingType in _dsSettings.MappingsByType)
{
var dsType = mappingType.Key;
foreach (var mapping in mappingType.Value.GroupBy(i => i.Custom.Oid))
{
var fields = mapping.Select(i => i.GigyaFieldName).Distinct();
var data = Get(uid, mapping.Key, dsType, fields);
if (data != null)
{
Dictionary <string, object> mappedDsResult = MapDataToDsType(mappingType.Key, data);
model = DynamicUtils.MergeToDictionary(model, mappedDsResult);
}
}
}
if (!model.Any())
{
return(null);
}
return(model.ToExpando());
}
//[TestMethod]
public void SpeedTestForArrayPropertyFromDynamic()
{
dynamic data = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json);
Gigya.Module.Core.Connector.Common.DynamicUtils.GetValue <long>(data, "profile.age");
DynamicUtils.GetValue <long>(data, "profile.age");
var stopwatch = new Stopwatch();
stopwatch.Start();
for (int i = 0; i < 20; i++)
{
var value = Gigya.Module.Core.Connector.Common.DynamicUtils.GetValue <long>(data, "profile.age");
}
var oldVersionMs = stopwatch.ElapsedMilliseconds;
stopwatch.Restart();
for (int i = 0; i < 20; i++)
{
var value = DynamicUtils.GetValue <long>(data, "profile.age");
}
var newVersionMs = stopwatch.ElapsedMilliseconds;
Assert.Inconclusive(string.Format("Old version: {0}, New version: {1}", oldVersionMs, newVersionMs));
}
private void ThrowTestingExceptionIfRequired(IGigyaModuleSettings settings, dynamic userInfo)
{
if (settings.DebugMode && DynamicUtils.GetValue <string>(userInfo, "profile.email") == Constants.Testing.EmailWhichThrowsException)
{
throw new ArgumentException("profile.email matches testing email which causes exception");
}
}
/// <summary>
/// Serializes the dynamic.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="value">The value.</param>
/// <param name="contract">The contract.</param>
private void SerializeDynamic(JsonWriter writer, IDynamicMetaObjectProvider value, JsonDynamicContract contract)
{
contract.InvokeOnSerializing(value, Serializer.Context);
SerializeStack.Add(value);
writer.WriteStartObject();
foreach (string memberName in value.GetDynamicMemberNames())
{
object memberValue;
if (DynamicUtils.TryGetMember(value, memberName, out memberValue))
{
string resolvedPropertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(memberName)
: memberName;
writer.WritePropertyName(resolvedPropertyName);
SerializeValue(writer, memberValue, GetContractSafe(memberValue), null, null);
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(value, Serializer.Context);
}
public void DefaultValueReturnedIfInvalidArrayIndex()
{
dynamic data = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json);
var value = DynamicUtils.GetValue <long>(data, "data.phoneNumbers[2].phone");
Assert.AreEqual(0, value);
}
public void TestAdd()
{
Assert.AreEqual("10a", DynamicUtils.BinaryOperation_Add(10, "a"));
Assert.AreEqual("a", DynamicUtils.BinaryOperation_Add(null, "a"));
Assert.AreEqual("a", DynamicUtils.BinaryOperation_Add("a", null));
Assert.AreEqual(null, DynamicUtils.BinaryOperation_Add(null, null));
Assert.AreEqual(21.5, DynamicUtils.BinaryOperation_Add(10, 11.5));
}
override public void WriteTo(ParserNodeContext Context)
{
Context.Write("DynamicUtils.BinaryOperation_" + DynamicUtils.GetOpName(Operator) + "(");
LeftNode.WriteTo(Context);
Context.Write(",");
RightNode.WriteTo(Context);
Context.Write(")");
}
public void TestCountArray()
{
Assert.AreEqual(0, DynamicUtils.CountArray(null));
Assert.AreEqual(0, DynamicUtils.CountArray(10));
Assert.AreEqual(0, DynamicUtils.CountArray("String"));
Assert.AreEqual(3, DynamicUtils.CountArray(new int[] { 1, 2, 3 }));
Assert.AreEqual(3, DynamicUtils.CountArray(new List <int>(new int[] { 1, 2, 3 })));
}
private DynamicMetaObject InvokeWorker(DynamicMetaObjectBinder /*!*/ callAction, DynamicMetaObject /*!*/[] args)
{
PerfTrack.NoteEvent(PerfTrack.Categories.Binding, "Method Invoke " + args.Length);
PerfTrack.NoteEvent(PerfTrack.Categories.BindingTarget, "Method");
CallSignature signature = BindingHelpers.GetCallSignature(callAction);
DynamicMetaObject self = Restrict(typeof(Method));
BindingRestrictions restrictions = self.Restrictions;
// restrict to non-null self (Method is immutable so this is an invariant test)
restrictions = restrictions.Merge(
BindingRestrictions.GetExpressionRestriction(
Ast.NotEqual(
GetSelfExpression(self),
AstUtils.Constant(null)
)
)
);
DynamicMetaObject[] newArgs = ArrayUtils.Insert(GetMetaFunction(self), GetMetaSelf(self), args);
var newSig = new CallSignature(ArrayUtils.Insert(new Argument(ArgumentType.Simple), signature.GetArgumentInfos()));
var call = new DynamicMetaObject(
DynamicExpression.Dynamic(
PythonContext.GetPythonContext(callAction).Invoke(
newSig
).GetLightExceptionBinder(callAction.SupportsLightThrow()),
typeof(object),
ArrayUtils.Insert(PythonContext.GetCodeContext(callAction), DynamicUtils.GetExpressions(newArgs))
),
BindingRestrictions.Empty
);
/*
* call = func.Invoke(
* new CallBinder(
* PythonContext.GetBinderState(callAction),
* newSig
* ),
* newArgs
* );*/
if (call.HasValue)
{
return(new DynamicMetaObject(
call.Expression,
restrictions.Merge(call.Restrictions),
call.Value
));
}
else
{
return(new DynamicMetaObject(
call.Expression,
restrictions.Merge(call.Restrictions)
));
}
}
public void CanGetNestedPropertyFromDynamic()
{
dynamic data = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json);
var firstName = DynamicUtils.GetValue <string>(data, "profile.firstName");
Assert.IsNotNull(firstName, "Value not found");
Assert.AreEqual(firstName, "Jason", "Value doesn't match");
}
public void CanGetPropertyFromDynamic()
{
dynamic data = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json);
var value = DynamicUtils.GetValue <string>(data, "socialProviders");
Assert.IsNotNull(value, "Value not found");
Assert.AreEqual(value, "site", "Value doesn't match");
}
public void CanGetNestedLongPropertyFromDynamic()
{
dynamic data = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json);
var value = DynamicUtils.GetValue <long>(data, "profile.age");
Assert.IsNotNull(value, "Value not found");
Assert.AreEqual(value, 1, "Value doesn't match");
}
public void CanGetNestedArrayPropertyFromDynamic()
{
dynamic data = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json);
var value = DynamicUtils.GetValue <long>(data, "data.phoneNumbers[1].phone");
Assert.IsNotNull(value, "Value not found");
Assert.AreEqual(4567, value, "Value doesn't match");
}
private GSResponse LogError(GSResponse response, string method, 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}.", method, gigyaCallId, gigyaError, gigyaErrorDetail), e);
return(response);
}
private DynamicExpression MakeDynamicInitInvoke(CodeContext context, DynamicMetaObject[] args, Expression initFunc, Expression codeContext)
{
return(DynamicExpression.Dynamic(
context.LanguageContext.Invoke(_signature),
typeof(object),
ArrayUtils.Insert(
codeContext,
initFunc,
DynamicUtils.GetExpressions(args)
)
));
}
public void CanMergeNestedJson()
{
dynamic data1 = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_jsonProfileAddress);
dynamic data2 = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_jsonProfileAddress2);
var result = DynamicUtils.Merge(data1, data2);
Assert.IsNotNull(result);
Assert.IsNotNull(result.profile);
Assert.AreEqual(result.profile.address.line1, "line 1", "profile.address.line1 doesn't contain expected values.");
Assert.AreEqual(result.profile.address.line2, "line 2", "profile.address.line2 doesn't contain expected values.");
}
public void TestConvertToBool()
{
Assert.AreEqual(true, DynamicUtils.ConvertToBool((float)7.1));
Assert.AreEqual(true, DynamicUtils.ConvertToBool((double)7.1));
Assert.AreEqual(true, DynamicUtils.ConvertToBool(7));
Assert.AreEqual(true, DynamicUtils.ConvertToBool(true));
Assert.AreEqual(true, DynamicUtils.ConvertToBool(new Object()));
Assert.AreEqual(false, DynamicUtils.ConvertToBool(0));
Assert.AreEqual(false, DynamicUtils.ConvertToBool((double)0.0));
Assert.AreEqual(false, DynamicUtils.ConvertToBool(false));
Assert.AreEqual(false, DynamicUtils.ConvertToBool(null));
}
public static void LogResponseIfRequired(Logger logger, IGigyaModuleSettings settings, string apiMethod, GSResponse response)
{
if (settings.DebugMode)
{
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 callId = DynamicUtils.GetValue <string>(gigyaModel, "callId");
logger.DebugFormat("API call: {0}. CallId: {1}. Error: {2}. Error Details: {3}.", apiMethod, callId, gigyaError, gigyaErrorDetail);
}
}
public void CanMergeJson()
{
dynamic data1 = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json);
dynamic data2 = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(_json2);
var result = DynamicUtils.Merge(data1, data2);
Assert.IsNotNull(result);
Assert.AreEqual(result.profile2.firstName, "new", "profile2.firstName doesn't contain expected values.");
// check old properties remain
Assert.AreEqual(result.profile.firstName, "Jason", "profile.firstName doesn't contain expected values.");
}
/// <summary>
/// Gets a Gigya value from the model.
/// </summary>
/// <param name="gigyaModel">Deserialized Gigya JSON object.</param>
/// <param name="gigyaFieldName">Gigya field name e.g. profile.age</param>
/// <returns></returns>
protected object GetGigyaValue(dynamic gigyaModel, string gigyaFieldName, string cmsFieldName)
{
var eventArgs = new MapGigyaFieldEventArgs
{
GigyaModel = gigyaModel,
GigyaFieldName = gigyaFieldName,
CmsFieldName = cmsFieldName,
Origin = "GetGigyaValue",
GigyaValue = DynamicUtils.GetValue <object>(gigyaModel, gigyaFieldName)
};
GettingGigyaValue?.Invoke(this, eventArgs);
return(eventArgs.GigyaValue);
}
/// <summary>
/// Merges the getAccountInfo model with the ds data and adds the DS mapping fields to <param name="mappingFields"></param>
/// </summary>
/// <param name="accountInfo"></param>
/// <returns></returns>
public dynamic Merge(dynamic accountInfo, List <MappingField> mappingFields)
{
// get ds data
var data = GetOrSearch(accountInfo.UID);
if (data == null)
{
return(accountInfo);
}
// merge with accountInfo
accountInfo = DynamicUtils.Merge(accountInfo, data);
AddMappingFields(mappingFields);
return(accountInfo);
}
/// <summary>
/// Gets a Gigya value from the model.
/// </summary>
/// <param name="gigyaModel">Deserialized Gigya JSON object.</param>
/// <param name="gigyaFieldName">Gigya field name e.g. profile.age</param>
/// <returns></returns>
protected virtual object GetGigyaValue(dynamic gigyaModel, string gigyaFieldName, string sitefinityFieldName)
{
var eventArgs = new MapGigyaFieldEvent
{
GigyaModel = gigyaModel,
GigyaFieldName = gigyaFieldName,
SitefinityFieldName = sitefinityFieldName,
Origin = "GetGigyaValue",
GigyaValue = DynamicUtils.GetValue <object>(gigyaModel, gigyaFieldName)
};
EventHub.Raise(eventArgs);
return(eventArgs.GigyaValue);
}
public void TestAccess()
{
Assert.AreEqual("Value", DynamicUtils.Access(new Hashtable()
{
{ "MyKey", "Value" }
}, "MyKey"));
Assert.AreEqual(10, DynamicUtils.Access(new ClassTestAccess(), "SampleField"));
Assert.AreEqual(20, DynamicUtils.Access(new ClassTestAccess(), "SampleProperty"));
Assert.AreEqual(30, DynamicUtils.Access(new ClassTestAccess(), "SampleMethod"));
Assert.AreEqual(null, DynamicUtils.Access(null, "Test"));
Assert.AreEqual(null, DynamicUtils.Access(null, null));
Assert.AreEqual(null, DynamicUtils.Access(10, "Test"));
Assert.AreEqual(null, DynamicUtils.Access("Test", "Test"));
Assert.AreEqual(2, DynamicUtils.Access(new int[] { 0, 1, 2, 3, 4 }, 2));
Assert.AreEqual(2, DynamicUtils.Access(new List <int>(new int[] { 0, 1, 2, 3, 4 }), 2));
}
public void TestCountArrayList()
{
Assert.AreEqual(3, DynamicUtils.CountArray(new List <Post> {
new Post()
{
Title = "Test1"
},
new Post()
{
Title = "Test2"
},
new Post()
{
Title = "Test3"
},
}));
}
private void Validate()
{
var del = _delegate as Delegate;
if (TargetNode == null || TargetNode.DataContext == null)
{
_delegate = Empty;
}
else if (del == null || !ReferenceEquals(del.Target, TargetNode.DataContext))
{
var targetObj = TargetNode.DataContext;
var targetType = targetObj.GetType();
var targetMethod = targetType.GetMethod(MethodName,
System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Static
);
if (targetMethod == null)
{
Console.WriteLine("[JankyMethod] Method '{0}' does not exist on '{1}' or is not public",
MethodName,
targetType.FullName
);
_delegate = Empty;
return;
}
try
{
_delegate = (targetMethod.IsStatic)
? DynamicUtils.MakeCompatibleDelegate <TDelegate>(targetMethod)
: DynamicUtils.MakeCompatibleDelegate <TDelegate>(targetMethod, targetObj);
}
catch
{
Console.WriteLine("[JankyMethod] Target Method '{0}' is not Compatible with '{1}'",
targetType + "." + targetMethod.Name,
typeof(TDelegate).ToString()
);
_delegate = Empty;
return;
}
}
}
public void TestConvertToIEnumerable()
{
CollectionAssert.AreEquivalent(
new object[] { },
DynamicUtils.ConvertToIEnumerable(null)
);
CollectionAssert.AreEquivalent(
new object[] { "1", 2, 3 },
DynamicUtils.ConvertToIEnumerable(new Dictionary <string, object> {
{ "Test1", "1" }, { "Test2", 2 }, { "Test3", 3 }
})
);
CollectionAssert.AreEquivalent(
new object[] { "1", 2, 3 },
DynamicUtils.ConvertToIEnumerable(new List <object> {
"1", 2, 3
})
);
}
public void MergeSameProperty()
{
dynamic data1 = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(@"{
""profile"": {
""firstName"": ""original"",
""age"": 1
}
}");
dynamic data2 = JsonConvert.DeserializeObject <System.Dynamic.ExpandoObject>(@"{
""profile"": {
""firstName"": ""new"",
""age"": 1
}
}");
var result = DynamicUtils.Merge(data1, data2);
Assert.AreEqual(result.profile.firstName, "new");
}
/// <summary>
/// Uses the Gigya ds.search API call to retrieve data.
/// FetchDSCompleted event will not be fired.
/// </summary>
/// <param name="uid">The user Id.</param>
/// <param name="dsType">The ds type that is passed in the type param.</param>
/// <param name="fields">A collection of field names or null to have them created from the settings.</param>
/// <returns></returns>
public dynamic Search(string uid, string dsType, IEnumerable <string> fields = null)
{
if (string.IsNullOrEmpty(uid))
{
throw new ArgumentException("uid");
}
if (string.IsNullOrEmpty(dsType))
{
throw new ArgumentException("dsType");
}
var query = GigyaDsSearchHelper.BuildQuery(uid, dsType, fields);
var response = _apiHelper.Search(_settings, query);
if (response == null)
{
return(null);
}
dynamic model = JsonConvert.DeserializeObject <ExpandoObject>(response.GetResponseText());
var modelDictionary = model as IDictionary <string, object>;
if (!modelDictionary.ContainsKey("results") || model.results.Count == 0)
{
return(null);
}
var mergedResults = new ExpandoObject();
foreach (var result in model.results)
{
var resultDictionary = result as IDictionary <string, object>;
if (resultDictionary.ContainsKey("data"))
{
mergedResults = DynamicUtils.Merge(mergedResults, result.data);
}
}
return(mergedResults);
}
