/// <summary>
/// Serialize with a wrapper containing the serialized object, its hash sign and its type
/// </summary>
/// <param name="obj">Object to serialize</param>
/// <param name="shouldSign">To calculate the hash sign</param>
/// <returns>seialized string</returns>
public static string Serialize(object obj, bool shouldSign)
{
var type = obj.GetType();
var methodInfo = type.GetMethod("Serialize");
string serializedData;
if (methodInfo == null)
{
serializedData = Serialize(obj);
}
else
{
serializedData = (string)methodInfo.Invoke(obj, null);
}
var hash = shouldSign ? HashSigner.GetSignedHash(serializedData).GetHashCode() : 0;
var serializedProperties = IsJsonSerialized(serializedData)
? serializedData.Substring(1, serializedData.Length - 2)
: $@"""{ObjectKeyString}"":""{serializedData}""";
return("{" + serializedProperties
+ $@",""{TypeKeyString}"":""{GetSerializedTypeName(type)}"""
+ (shouldSign ? $@",""{HashKeyString}"":""{hash}""" : "")
+ "}");
}
public static IHtmlString RenderEditLink(this HtmlHelper helper, IPageTeaser teaser, string label)
{
if (DataScopeManager.CurrentDataScope != DataScopeIdentifier.Administrated)
{
return(helper.Raw(String.Empty));
}
var editWorkflowAttribute = teaser.DataSourceId.InterfaceType.GetCustomAttributes(true).OfType <EditWorkflowAttribute>().FirstOrDefault();
if (editWorkflowAttribute == null)
{
return(helper.Raw(String.Empty));
}
var page = PageManager.GetPageById(teaser.PageId);
var entityToken = new PageTeaserInstanceEntityToken(page, teaser);
var serializedEntityToken = EntityTokenSerializer.Serialize(entityToken, true);
var editActionToken = new WorkflowActionToken(editWorkflowAttribute.EditWorkflowType);
var serializedActionToken = ActionTokenSerializer.Serialize(editActionToken, true);
var html = String.Format("<a href=\"#\" data-providername=\"{0}\" data-entitytoken=\"{1}\" data-actiontoken=\"{2}\" data-piggybag=\"{3}\" data-piggybaghash=\"{4}\" onclick=\"executeAction(this)\">{5}</a>",
teaser.DataSourceId.ProviderName,
serializedEntityToken,
serializedActionToken,
String.Empty,
HashSigner.GetSignedHash(string.Empty).Serialize(),
label);
return(helper.Raw(html));
}
public static FlowToken Deserialize(string serialziedFlowToken, bool includeHashValue)
{
if (string.IsNullOrEmpty(serialziedFlowToken))
{
throw new ArgumentNullException("serialziedFlowToken");
}
Dictionary <string, string> dic = StringConversionServices.ParseKeyValueCollection(serialziedFlowToken);
if ((dic.ContainsKey("flowTokenType") == false) ||
(dic.ContainsKey("flowToken") == false) ||
((includeHashValue) && (dic.ContainsKey("flowTokenHash") == false)))
{
throw new ArgumentException("The serialziedFlowToken is not a serialized flowToken", "serialziedFlowToken");
}
string flowTokenTypeString = StringConversionServices.DeserializeValueString(dic["flowTokenType"]);
string flowTokenString = StringConversionServices.DeserializeValueString(dic["flowToken"]);
if (includeHashValue)
{
string flowTokenHash = StringConversionServices.DeserializeValueString(dic["flowTokenHash"]);
HashValue hashValue = HashValue.Deserialize(flowTokenHash);
if (HashSigner.ValidateSignedHash(flowTokenString, hashValue) == false)
{
throw new SecurityException("Serialized flow token is tampered");
}
}
Type flowType = TypeManager.GetType(flowTokenTypeString);
MethodInfo methodInfo = flowType.GetMethod("Deserialize", BindingFlags.Public | BindingFlags.Static);
if (methodInfo == null || !(typeof(FlowToken).IsAssignableFrom(methodInfo.ReturnType)))
{
throw new InvalidOperationException(string.Format("The flow token {0} is missing a public static Deserialize method taking a string as parameter and returning an {1}", flowType, typeof(FlowToken)));
}
FlowToken flowToken;
try
{
flowToken = (FlowToken)methodInfo.Invoke(null, new object[] { flowTokenString });
}
catch (Exception ex)
{
throw new InvalidOperationException(string.Format("The flow token {0} is missing a public static Deserialize method taking a string as parameter and returning an {1}", flowType, typeof(FlowToken)), ex);
}
if (flowToken == null)
{
throw new InvalidOperationException(string.Format("public static Deserialize method taking a string as parameter and returning an {1} on the flow token {0} did not return an object", flowType, typeof(FlowToken)));
}
return(flowToken);
}
protected void Page_Load(object sender, EventArgs e)
{
if (!UserValidationFacade.IsLoggedIn())
{
Response.Redirect("/Composite/Login.aspx?ReturnUrl=" + Request.Url.PathAndQuery);
return;
}
ScriptLoader.Render("sub");
rptCountryList.DataSource = DataFacade.GetData <Country>().Take(10)
.ToArray()
.Select(x =>
{
var editLink = new EditLink()
{
Label = x.Name
};
if (DataScopeManager.CurrentDataScope != DataScopeIdentifier.Administrated)
{
editLink.Link = String.Empty;
return(editLink);
}
var teaser = x;
//var editWorkflowAttribute = teaser.DataSourceId.InterfaceType.GetCustomAttributes(true).OfType<EditWorkflowAttribute>().FirstOrDefault();
//if (editWorkflowAttribute == null)
//{
// editLink.Link = string.Empty;
// return editLink;
//}
var page = PageManager.GetPageById(Guid.Parse("63ec1a73-b1ed-4ec8-923f-2840448c43ce"));
var entityToken = new PageTeaserInstanceEntityToken(page, teaser);
var serializedEntityToken = EntityTokenSerializer.Serialize(entityToken, true);
var editActionToken = new WorkflowActionToken(typeof(EditWorkflowAttribute));
var serializedActionToken = ActionTokenSerializer.Serialize(editActionToken, true);
var html = String.Format("<a href=\"#\" data-providername='{0}' data-entitytoken='{1}' data-actiontoken=\"{2}\" data-piggybag='{3}' data-piggybaghash='{4}' onclick=\"executeAction(this)\">{5}</a>",
teaser.DataSourceId.ProviderName,
serializedEntityToken,
serializedActionToken,
String.Empty,
HashSigner.GetSignedHash(string.Empty).Serialize(),
"edit");
editLink.Link = html;
return(editLink);
});
rptCountryList.DataBind();
}
/// <summary>
/// Deserialize strings into object with specified type from a hash signed wrapper
/// </summary>
/// <param name="str">Serialized string</param>
/// <param name="isSigned">Is signed</param>
/// <typeparam name="T">Type of returned object</typeparam>
/// <returns>The object</returns>
public static T Deserialize<T>(string str, bool isSigned)
{
var legacyStyleSerialized = str.StartsWith("{\"" + ObjectKeyString + "\":\"");
string obj;
var hash = 0;
var type = TypeManager.TryGetType(str.GetValue(TypeKeyString));
if (type == null)
{
throw new SerializationException();
}
if (isSigned)
{
if (!int.TryParse(str.GetValue(HashKeyString), out hash))
{
throw new SerializationException();
}
}
if (legacyStyleSerialized)
{
obj = str.GetValue(ObjectKeyString);
}
else
{
obj = "{" + str.Substring(1, str.LastIndexOf(TypeKeyString, StringComparison.InvariantCulture) - 3) + "}";
}
if (isSigned)
{
if (!HashSigner.ValidateSignedHash(obj, new HashValue(hash)))
{
throw new SecurityException($"Serialized {typeof(T).FullName} is tampered");
}
}
var methodInfo = type.GetMethod("Deserialize", BindingFlags.Public | BindingFlags.Static);
if (methodInfo == null)
{
return Deserialize<T>(obj);
}
if (!(typeof(T).IsAssignableFrom(methodInfo.ReturnType)))
{
var typeName = str.GetValue(TypeKeyString);
Log.LogWarning("CompositeJsonSerializer", $"The action {typeName} is missing a public static Deserialize method taking a string as parameter and returning an {typeof(T)}");
throw new InvalidOperationException($"The token {typeName} is missing a public static Deserialize method taking a string as parameter and returning an {typeof(T)}");
}
return (T)methodInfo.Invoke(null, new object[] { obj });
}
/// <exclude />
public static ClientElement GetClientElement(this Element element)
{
if (element.VisualData.Icon == null || element.Actions.Any(a => a.VisualData?.Icon == null))
{
throw new InvalidOperationException($"Unable to create ClientElement from Element with entity token '{element.ElementHandle.EntityToken.Serialize()}'. The element or one of its actions is missing an icon definition.");
}
string entityToken = EntityTokenSerializer.Serialize(element.ElementHandle.EntityToken, true);
string piggyBag = element.ElementHandle.SerializedPiggyback;
var clientElement = new ClientElement
{
ElementKey = $"{element.ElementHandle.ProviderName}{entityToken}{piggyBag}",
ProviderName = element.ElementHandle.ProviderName,
EntityToken = entityToken,
Piggybag = piggyBag,
PiggybagHash = HashSigner.GetSignedHash(piggyBag).Serialize(),
Label = element.VisualData.Label,
HasChildren = element.VisualData.HasChildren,
IsDisabled = element.VisualData.IsDisabled,
Icon = element.VisualData.Icon,
OpenedIcon = element.VisualData.OpenedIcon,
ToolTip = element.VisualData.ToolTip,
Actions = element.Actions.ToClientActionList(),
PropertyBag = element.PropertyBag.ToClientPropertyBag(),
TagValue = element.TagValue,
ContainsTaggedActions = element.Actions.Any(f => f.TagValue != null),
TreeLockEnabled = element.TreeLockBehavior == TreeLockBehavior.Normal,
ElementBundle = element.VisualData.ElementBundle,
BundleElementName = element.VisualData.BundleElementName
};
clientElement.ActionKeys =
(from clientAction in clientElement.Actions
select clientAction.ActionKey).ToList();
if (element.MovabilityInfo.DragType != null)
{
clientElement.DragType = element.MovabilityInfo.GetHashedTypeIdentifier();
}
List <string> apoptables = element.MovabilityInfo.GetDropHashTypeIdentifiers();
if (apoptables != null && apoptables.Count > 0)
{
clientElement.DropTypeAccept = apoptables;
}
clientElement.DetailedDropSupported = element.MovabilityInfo.SupportsIndexedPosition;
return(clientElement);
}
protected void Page_Load(object sender, EventArgs e)
{
string pageIdString = this.Request.QueryString["pageId"];
if (pageIdString == null)
{
throw new InvalidOperationException();
}
Guid pageId = new Guid(pageIdString);
//var editWorkflowAttribute = teaser.DataSourceId.InterfaceType.GetCustomAttributes(true).OfType<EditWorkflowAttribute>().FirstOrDefault();
//if (editWorkflowAttribute == null)
//{
// editLink.Link = string.Empty;
// return editLink;
//}
var pagex = PageManager.GetPageById(pageId);
var _entityToken = new PageDataEntityToken(pagex);
var serializedEntityToken = EntityTokenSerializer.Serialize(_entityToken, true);
var editActionToken = new WorkflowActionToken(typeof(EditDataWorkflow));
var token = new WorkflowActionToken(WorkflowFacade.GetWorkflowType(typeof(EditPageWorkflow).FullName));
var serializedActionToken = ActionTokenSerializer.Serialize(token, true);
//var m = ActionTokenSerializer.Deserialize(k);
var x = ActionTokenSerializer.Deserialize(serializedActionToken);
providerName = pagex.DataSourceId.ProviderName;
entityToken = serializedEntityToken;
actionToken = serializedActionToken;
piggybag = string.Empty;
piggybagHash = HashSigner.GetSignedHash(string.Empty).Serialize();
using (new DataScope(DataScopeIdentifier.Administrated, UserSettings.ActiveLocaleCultureInfo))
{
IPage page = PageManager.GetPageById(pageId);
this.MyPlaceHolder.Controls.Add(new LiteralControl("Title: " + page.Title + "<br />"));
}
}
/// <summary>
/// Deserialize strings into object with specified type from a hash signed wrapper
/// </summary>
/// <param name="str">Serilaized string</param>
/// <param name="isSigned">Is signed</param>
/// <typeparam name="T">Type of returned object</typeparam>
/// <returns>The object</returns>
public static T Deserialize <T>(string str, bool isSigned)
{
var legacyStyleSerilized = str.StartsWith("{\"" + ObjectKeyString + "\":\"");
string obj;
var hash = 0;
var type = TypeManager.TryGetType(str.GetValue(TypeKeyString));
if (type == null)
{
throw new SerializationException();
}
if (isSigned)
{
if (!int.TryParse(str.GetValue(HashKeyString), out hash))
{
throw new SerializationException();
}
}
if (legacyStyleSerilized)
{
obj = str.GetValue(ObjectKeyString);
}
else
{
obj = "{" + str.Substring(1, str.LastIndexOf(TypeKeyString, StringComparison.InvariantCulture) - 3) + "}";
}
if (isSigned)
{
if (!HashSigner.ValidateSignedHash(obj, new HashValue(hash)))
{
throw new SecurityException($"Serialized {typeof(T).FullName} is tampered");
}
}
MethodInfo methodInfo = type.GetMethod("Deserialize", BindingFlags.Public | BindingFlags.Static);
if (methodInfo == null)
{
return(Deserialize <T>(obj));
}
return((T)methodInfo.Invoke(null, new object[] { obj }));
}
public static string Serialize(FlowToken flowToken, bool includeHashValue)
{
if (flowToken == null)
{
throw new ArgumentNullException("flowToken");
}
StringBuilder sb = new StringBuilder();
StringConversionServices.SerializeKeyValuePair(sb, "flowTokenType", TypeManager.SerializeType(flowToken.GetType()));
string serializedFlowToken = flowToken.Serialize();
StringConversionServices.SerializeKeyValuePair(sb, "flowToken", serializedFlowToken);
if (includeHashValue)
{
StringConversionServices.SerializeKeyValuePair(sb, "flowTokenHash", HashSigner.GetSignedHash(serializedFlowToken).Serialize());
}
return(sb.ToString());
}
