private void saveInfoCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var package = this.GetBinding <PackageInformation>("Package");
PackageCreatorFacade.SavePackageInformation(package);
if (!string.IsNullOrEmpty(Payload))
{
var type = StringConversionServices.DeserializeValueString(StringConversionServices.ParseKeyValueCollection(Payload)["ActionToken"]);
ActionToken actionToken = ActionTokenSerializer.Deserialize(type);
ActionExecutorFacade.Execute(package.GetEntityToken(), actionToken, WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId));
}
else
{
ActionExecutorFacade.Execute(
package.GetEntityToken(),
new SetActivePackageActionToken(),
WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId));
}
SpecificTreeRefresher treeRefresher = this.CreateSpecificTreeRefresher();
treeRefresher.PostRefreshMesseges(new PackageCreatorElementProviderEntityToken());
}
public static List <ClientAction> ToClientActionList(this IEnumerable <ElementAction> actions)
{
var clientActions =
from action in actions
orderby action.VisualData.ActionLocation.ActionGroup.Priority, action.VisualData.ActionLocation.ActionGroup.Name, action.VisualData.ActionLocation.ActionType
select new ClientAction
{
ActionToken = ActionTokenSerializer.Serialize(action.ActionHandle.ActionToken, true),
Label = action.VisualData.Label,
ToolTip = action.VisualData.ToolTip,
Disabled = action.VisualData.Disabled,
Icon = action.VisualData.Icon,
CheckboxStatus = GetCheckboxStatusString(action.VisualData.ActionCheckedStatus),
ActivePositions = (int)action.VisualData.ActivePositions,
TagValue = action.TagValue,
ActionCategory = new ClientActionCategory
{
GroupId = CalculateActionCategoryGroupId(action.VisualData.ActionLocation),
GroupName = action.VisualData.ActionLocation.ActionGroup.Name,
Name = action.VisualData.ActionLocation.ActionType.ToString(),
IsInFolder = action.VisualData.ActionLocation.IsInFolder,
IsInToolbar = action.VisualData.ActionLocation.IsInToolbar,
FolderName = action.VisualData.ActionLocation.FolderName,
ActionBundle = action.VisualData.ActionLocation.ActionBundle
}
};
return(clientActions.ToList());
}
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));
}
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();
}
private string GetShowFunction(EntityToken entityToken, ActionToken actionToken)
{
return(string.Format("VersioningReport.Show('{0}','{1}','{2}','{3}','{4}');",
providerName,
EntityTokenSerializer.Serialize(entityToken, true).SerializeToJs(),
ActionTokenSerializer.Serialize(actionToken, true).SerializeToJs(),
piggybag,
piggybagHash
));
}
public CreatePackageWorkflowActionToken(string name, ActionToken actionToken) :
base(typeof(CreatePackageWorkflow), new PermissionType[] { PermissionType.Administrate })
{
StringBuilder sb = new StringBuilder();
StringConversionServices.SerializeKeyValuePair(sb, "Name", name);
StringConversionServices.SerializeKeyValuePair(sb, "GroupName", String.Join(".", name.Split('.').Take(2)));
StringConversionServices.SerializeKeyValuePair(sb, "ReadMoreUrl", @"http://docs.composite.net/Composite.Localization.C1Console");
StringConversionServices.SerializeKeyValuePair(sb, "ActionToken", ActionTokenSerializer.Serialize(actionToken));
Payload = sb.ToString();
}
/// <exclude />
public static FlowToken ExecuteEntityTokenLocked(ActionToken lockedActionToken, EntityToken lockedEntityToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
EntityToken entityToken = new EntityTokenLockedEntityToken(
ActionLockingFacade.LockedBy(lockedEntityToken),
ActionTokenSerializer.Serialize(lockedActionToken),
EntityTokenSerializer.Serialize(lockedEntityToken)
);
WorkflowActionToken actionToken = new WorkflowActionToken(WorkflowFacade.GetWorkflowType("Composite.C1Console.Actions.Workflows.EntityTokenLockedWorkflow"));
return(Execute(entityToken, actionToken, flowControllerServicesContainer));
}
/// <exclude />
public static string GetInlineElementActionScriptCode(EntityToken entityToken, ActionToken actionToken, Dictionary <string, string> piggyBag)
{
StringBuilder sb = new StringBuilder();
StringConversionServices.SerializeKeyValuePair(sb, "EntityToken", EntityTokenSerializer.Serialize(entityToken, false));
StringConversionServices.SerializeKeyValuePair(sb, "ActionToken", ActionTokenSerializer.Serialize(actionToken, true));
StringConversionServices.SerializeKeyValuePair(sb, "PiggyBag", PiggybagSerializer.Serialize(piggyBag));
string scriptAction = string.Format(@"SystemAction.invokeInlineAction(""{0}"");", Convert.ToBase64String(Encoding.UTF8.GetBytes(sb.ToString())));
return(scriptAction);
}
internal static void RegisterNewFlowInformation(FlowToken flowToken, EntityToken entityToken, ActionToken actionToken, string consoleId)
{
IFlowInformation flowInformation = DataFacade.BuildNew <IFlowInformation>();
flowInformation.Id = Guid.NewGuid();
flowInformation.Username = UserSettings.Username;
flowInformation.ConsoleId = consoleId;
flowInformation.SerializedFlowToken = FlowTokenSerializer.Serialize(flowToken);
flowInformation.SerializedEntityToken = EntityTokenSerializer.Serialize(entityToken);
flowInformation.SerializedActionToken = ActionTokenSerializer.Serialize(actionToken);
flowInformation.TimeStamp = DateTime.Now;
DataFacade.AddNew <IFlowInformation>(flowInformation);
}
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 />"));
}
}
/// <exclude />
public static void ExecuteElementAction(string providerName, string serializedEntityToken, string piggybag, string serializedActionToken, string consoleId)
{
using (DebugLoggingScope.MethodInfoScope)
{
EntityToken entityToken = EntityTokenSerializer.Deserialize(serializedEntityToken);
if (!entityToken.IsValid())
{
ShowInvalidEntityMessage(consoleId);
return;
}
var elementHandle = new ElementHandle(providerName, entityToken, piggybag);
ActionToken actionToken = ActionTokenSerializer.Deserialize(serializedActionToken, true);
ActionHandle actionHandle = new ActionHandle(actionToken);
ActionExecutionMediator.ExecuteElementAction(elementHandle, actionHandle, consoleId);
}
}
public WorkflowInstance CreateNewWorkflow(Type workflowType, Dictionary <string, object> arguments)
{
GlobalInitializerFacade.EnsureSystemIsInitialized();
DoInitialize(0);
try
{
WorkflowInstance workflowInstance = _workflowRuntime.CreateWorkflow(workflowType, arguments);
SetWorkflowPersistingType(workflowType, workflowInstance.InstanceId);
if (arguments.TryGetValue("SerializedEntityToken", out var serializedEntityToken) &&
arguments.TryGetValue("SerializedActionToken", out var serializedActionToken))
{
ActionToken actionToken = ActionTokenSerializer.Deserialize((string)serializedActionToken);
if (!actionToken.IgnoreEntityTokenLocking)
{
AcquireLockIfNeeded(workflowType, workflowInstance.InstanceId, (string)serializedEntityToken);
}
}
return(workflowInstance);
}
catch (WorkflowValidationFailedException exp)
{
var errors = new StringBuilder();
foreach (ValidationError error in exp.Errors)
{
errors.AppendLine(error.ToString());
}
Log.LogError(LogTitle, errors.ToString());
throw;
}
}
/// <exclude />
public static FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer, TaskManagerEvent taskManagerEvent)
{
if (entityToken == null)
{
throw new ArgumentNullException("entityToken");
}
if (actionToken == null)
{
throw new ArgumentNullException("actionToken");
}
string username = UserValidationFacade.GetUsername();
#if NO_SECURITY
#else
HookingFacade.EnsureInitialization();
IEnumerable <UserPermissionDefinition> userPermissionDefinitions = PermissionTypeFacade.GetUserPermissionDefinitions(username);
IEnumerable <UserGroupPermissionDefinition> userGroupPermissionDefinitions = PermissionTypeFacade.GetUserGroupPermissionDefinitions(username);
SecurityResult securityResult = SecurityResolver.Resolve(UserValidationFacade.GetUserToken(), actionToken, entityToken, userPermissionDefinitions, userGroupPermissionDefinitions);
if (securityResult != SecurityResult.Allowed && !(entityToken is SecurityViolationWorkflowEntityToken))
{
return(ExecuteSecurityViolation(actionToken, entityToken, flowControllerServicesContainer));
}
#endif
bool ignoreLocking = actionToken.IsIgnoreEntityTokenLocking();
if (!ignoreLocking && ActionLockingFacade.IsLocked(entityToken))
{
return(ExecuteEntityTokenLocked(actionToken, entityToken, flowControllerServicesContainer));
}
IActionExecutor actionExecutor = ActionExecutorCache.GetActionExecutor(actionToken);
ActionEventSystemFacade.FireOnBeforeActionExecution(entityToken, actionToken);
FlowToken flowToken;
using (TaskContainer taskContainer = TaskManagerFacade.CreateNewTasks(entityToken, actionToken, taskManagerEvent))
{
ITaskManagerFlowControllerService taskManagerService = null;
if (flowControllerServicesContainer.GetService(typeof(ITaskManagerFlowControllerService)) == null)
{
taskManagerService = new TaskManagerFlowControllerService(taskContainer);
flowControllerServicesContainer.AddService(taskManagerService);
}
try
{
if (actionExecutor is IActionExecutorSerializedParameters)
{
string serializedEntityToken = EntityTokenSerializer.Serialize(entityToken);
string serializedActionToken = ActionTokenSerializer.Serialize(actionToken);
flowToken = Execute(actionExecutor as IActionExecutorSerializedParameters,
serializedEntityToken, serializedActionToken, actionToken,
flowControllerServicesContainer);
}
else
{
flowToken = Execute(actionExecutor, entityToken, actionToken,
flowControllerServicesContainer);
}
}
finally
{
if (taskManagerService != null)
{
flowControllerServicesContainer.RemoveService(taskManagerService);
}
}
taskContainer.SetOnIdleTaskManagerEvent(new FlowTaskManagerEvent(flowToken));
taskContainer.UpdateTasksWithFlowToken(flowToken);
taskContainer.SaveTasks();
}
ActionEventSystemFacade.FireOnAfterActionExecution(entityToken, actionToken, flowToken);
IManagementConsoleMessageService managementConsoleMessageService = flowControllerServicesContainer
.GetService <IManagementConsoleMessageService>();
if (managementConsoleMessageService != null)
{
FlowControllerFacade.RegisterNewFlowInformation(flowToken, entityToken, actionToken,
managementConsoleMessageService.CurrentConsoleId);
}
else
{
Log.LogWarning(nameof(ActionExecutorFacade), "Missing ManagementConsoleMessageService, can not register the flow");
}
return(flowToken);
}
public FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
return(Execute(EntityTokenSerializer.Serialize(entityToken), ActionTokenSerializer.Serialize(actionToken), actionToken, flowControllerServicesContainer));
}
void BuildReportTable(IQueryable <IGrouping <ITask, IActivity> > activities, EntityToken entityToken)
{
activities = activities.OrderByDescending(a => a.Key.StartTime).Take(int.Parse(Pager.Text));
XElement report = new XElement("Report",
activities
.Select(item => new XElement("Task",
item.Key.SerializeProperties(),
item.Where(d => d != null).OrderByDescending(d => d.ActivityTime).Select(activity =>
new XElement("Activity",
activity.SerializeProperties(),
new XAttribute("ShowAction", GetShowFunction(
entityToken,
new DataVersionActionToken(activity.Id, typeof(ShowDataVersionHandleFilter))
)
),
new XAttribute("ShowFileAction",
string.Format("VersioningReport.ShowFile('{0}');", activity.Id.ToString())),
new XAttribute("RollbackAction", GetShowFunction(
entityToken,
new DataVersionActionToken(activity.Id, typeof(RollbackDataVersionHandleFilter))
)
),
new XAttribute("CompareEntityToken",
EntityTokenSerializer.Serialize(new CompareEntityToken(activity.Id.ToString()),
true)),
new XAttribute("CompareToActionToken",
ActionTokenSerializer.Serialize(new CompareVersionActionToken(activity.Id), true)),
new XAttribute("Piggybag", Piggybag),
new XAttribute("PiggybagHash", _piggybagHash),
null
)
)
)
)
);
var sb = new StringBuilder();
var xws = new XmlWriterSettings
{
OmitXmlDeclaration = true
};
using (var writer = XmlWriter.Create(sb, xws))
{
var xslTransform = new XslCompiledTransform();
xslTransform.Load(Server.MapPath(Path.Combine(Page.TemplateSourceDirectory, "report.xslt")));
xslTransform.Transform(report.CreateReader(), writer);
}
Holder.Controls.Add(new LiteralControl(sb.ToString()));
}
