public void EditCommon(object sender, EventArgs e)
{
RuleSet ruleSet = null;
XmlTextReader rulesReader = new XmlTextReader("Common.rules");
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
ruleSet = (RuleSet)serializer.Deserialize(rulesReader);
rulesReader.Close();
RuleSetDialog ruleSetDialog = new RuleSetDialog(typeof(keyHandlerState), null, ruleSet);
DialogResult result = ruleSetDialog.ShowDialog();
ruleSet = ruleSetDialog.RuleSet;
if (result == DialogResult.OK)
{
// Serialize to a .rules file
serializer = new WorkflowMarkupSerializer();
XmlWriter rulesWriter = XmlWriter.Create("Common.rules");
serializer.Serialize(rulesWriter, ruleSet);
rulesWriter.Close();
}
}
public void Get()
{
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => Assembly.Load(args.Name);
var ruleSet = RuleSetGateway.GetRuleSet(FileName);
var activityType = GetActivityType(TypeInfo);
Dialog = new RuleSetDialog(activityType, null, ruleSet);
Dialog.Save += DialogOnSave;
}
protected override void DoDefaultAction()
{
base.DoDefaultAction();
WorkflowDesignerLoader service = this.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if ((service != null) && service.InDebugMode)
{
throw new InvalidOperationException(Messages.DebugModeEditsDisallowed);
}
PolicyActivity activity = (PolicyActivity)base.Activity;
if (!System.Workflow.Activities.Common.Helpers.IsActivityLocked(activity))
{
RuleDefinitions definitions = ConditionHelper.Load_Rules_DT(this, System.Workflow.Activities.Common.Helpers.GetRootActivity(activity));
if (definitions != null)
{
RuleSetCollection ruleSets = definitions.RuleSets;
RuleSetReference ruleSetReference = activity.RuleSetReference;
RuleSet ruleSet = null;
string key = null;
if ((ruleSetReference != null) && !string.IsNullOrEmpty(ruleSetReference.RuleSetName))
{
key = ruleSetReference.RuleSetName;
if (ruleSets.Contains(key))
{
ruleSet = ruleSets[key];
}
}
else
{
key = ruleSets.GenerateRuleSetName();
}
using (RuleSetDialog dialog = new RuleSetDialog(activity, ruleSet))
{
if (DialogResult.OK == dialog.ShowDialog())
{
if (ruleSet != null)
{
ruleSets.Remove(key);
}
else
{
dialog.RuleSet.Name = key;
activity.RuleSetReference = new RuleSetReference(key);
}
ruleSets.Add(dialog.RuleSet);
ConditionHelper.Flush_Rules_DT(this, System.Workflow.Activities.Common.Helpers.GetRootActivity(activity));
}
}
}
TypeDescriptor.GetProperties(activity)["RuleSetReference"].SetValue(activity, activity.RuleSetReference);
}
}
private void DisplayRules()
{
RuleSetDialog ruleSetDialog = new RuleSetDialog(this.activityClassType, ruleSet, Settings.Default.assemblyLoadPaths.Split(new char[] { ';' }))
{
StartPosition = FormStartPosition.CenterParent
};
ruleSetDialog.ShowDialog();
if (ruleSetDialog.DialogResult == DialogResult.OK)
{
try
{
this.Refresh();
this.ruleSet = ruleSetDialog.RuleSet;
ValidateRules();
ListRules();
if (CanSave)
{
SaveRules();
}
ValidateSave();
ValidateNew();
}
catch (ArgumentException ex)
{
throw new ToolkitException(ex.Message, ex);
}
catch (UnauthorizedAccessException ex)
{
throw new ToolkitException(ex.Message, ex);
}
catch (IOException ex)
{
throw new ToolkitException(ex.Message, ex);
}
catch (System.Security.SecurityException ex)
{
throw new ToolkitException(ex.Message, ex);
}
catch (ObjectDisposedException ex)
{
throw new ToolkitException(ex.Message, ex);
}
catch (NotSupportedException ex)
{
throw new ToolkitException(ex.Message, ex);
}
}
}
/// <summary>
/// Opens RuleSet Editor
/// </summary>
/// <param name="type">Assembly Type to Edit</param>
/// <param name="ruleSet">Existing RuleSet</param>
/// <returns>Xml Format of Changed RuleSet object</returns>
public static string EditExpression(Type type, RuleSet ruleSet)
{
RuleSetDialog ruleSetDialog = new RuleSetDialog(type, null, ruleSet);
DialogResult result = ruleSetDialog.ShowDialog();
if (result == DialogResult.OK)
{
DefaultRuleSet.ActivityRuleSet = ruleSetDialog.RuleSet;
DefaultRuleSet.Name = string.Format("RuleSet{0}", ruleSets.IndexOf(_defaultRuleSet));
return(SerializeRuleSet(ruleSetDialog.RuleSet));
}
else
{
return(DefaultRuleSet.RuleSetDefinition);
}
}
static void SetupPatientRules()
{
patientRuleSet = GetRules(patientRuleFilePath);
// Create a RuleSet that works with Orders (just another .net Object)
RuleSetDialog ruleSetDialog = new RuleSetDialog(typeof(Patient), null, patientRuleSet);
// Show the RuleSet Editor
ruleSetDialog.ShowDialog();
// Get the RuleSet after editing
patientRuleSet = ruleSetDialog.RuleSet;
Console.WriteLine("Rule created :{0}", patientRuleSet.Rules.LastOrDefault().Condition);
SaveRules(patientRuleSet, patientRuleFilePath);
}
private void LstRulesSelectedIndexChanged(object sender, EventArgs e)
{
if (lstRules.SelectedIndex != -1)
{
var item = (BindItem)lstRules.SelectedItem;
if (item == null)
{
return;
}
var model = (RulesDomModel)item.Value;
var set = (RuleSet)model.ParentRuleSet;
using (var dialog = new RuleSetDialog(typeof(Activity), null, set))
{
dialog.ShowDialog();
}
}
}
private void button1_Click(object sender, RoutedEventArgs e)
{
// verifiy that TargetObject property has been configured
object input = ModelItem.Properties["Input"].ComputedValue;
if (input == null)
{
System.Windows.MessageBox.Show("Input argument needs to be configured before adding the rules");
return;
}
// verify that target object is correctly configured
InArgument arg = input as InArgument;
if (arg == null)
{
System.Windows.MessageBox.Show("Invalid value for Input argument");
return;
}
// open the ruleset editor
Type inputType = arg.ArgumentType;
RuleSet ruleSet = ModelItem.Properties["RuleSet"].ComputedValue as RuleSet;
if (ruleSet == null)
{
ruleSet = new RuleSet();
}
// popup the dialog for editing the rules
RuleSetDialog ruleSetDialog = new RuleSetDialog(inputType, null, ruleSet);
DialogResult result = ruleSetDialog.ShowDialog();
// update the model item
if (result == DialogResult.OK) //check if they cancelled
{
ModelItem.Properties["RuleSet"].SetValue(ruleSetDialog.RuleSet);
}
}
public void ManageProfile(object sender, EventArgs e)
{
var role = _game.GetProfileName(_process, _items.CurrentId());
RuleSet ruleSet = null;
if (File.Exists(role + ".rules"))
{
XmlTextReader rulesReader = new XmlTextReader(role + ".rules");
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
ruleSet = (RuleSet)serializer.Deserialize(rulesReader);
rulesReader.Close();
}
else
{
XmlTextReader rulesReader = new XmlTextReader("Common.rules");
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
ruleSet = (RuleSet)serializer.Deserialize(rulesReader);
rulesReader.Close();
}
RuleSetDialog ruleSetDialog = new RuleSetDialog(typeof(keyHandlerState), null, ruleSet);
DialogResult result = ruleSetDialog.ShowDialog();
ruleSet = ruleSetDialog.RuleSet;
if (result == DialogResult.OK)
{
// Serialize to a .rules file
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
XmlWriter rulesWriter = XmlWriter.Create(role + ".rules");
serializer.Serialize(rulesWriter, ruleSet);
rulesWriter.Close();
}
}
public void ViewProfile(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "rules (*.rules)|*.rules";
ofd.FilterIndex = 2;
ofd.RestoreDirectory = true;
if (ofd.ShowDialog() == DialogResult.OK)
{
RuleSet ruleSet = null;
if (File.Exists(ofd.FileName))
{
XmlTextReader rulesReader = new XmlTextReader(ofd.FileName);
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
ruleSet = (RuleSet)serializer.Deserialize(rulesReader);
rulesReader.Close();
RuleSetDialog ruleSetDialog = new RuleSetDialog(typeof(keyHandlerState), null, ruleSet);
ruleSetDialog.Height = 560;
ruleSetDialog.Show();
}
}
}
private void editRuleBtn_Click(object sender, EventArgs e)
{
Module temp = new Module();
temp.Application = FrontendApplication;
temp.Name = "temp";
UXAction action = uxActionService.GetUXActionByIdWithMap(UXAction.Id);
Type context = RuleContextFactory.CreateActionContext(action, temp);
using (RuleSetDialog ruleSetDialog = new RuleSetDialog(context, null, UXAction.RuleSet))
{
ruleSetDialog.Text += string.Format(" [{0}]", UXAction.Name);
if (ruleSetDialog.ShowDialog() == DialogResult.OK)
{
if (this.IsEditable)
{
if (ruleSetDialog.RuleSet.Rules.Count == 0)
{
UXAction.RuleSet = null;
}
else
{
UXAction.RuleSet = ruleSetDialog.RuleSet;
}
}
else
{
System.Windows.Forms.MessageBox.Show("Your changes will not be saved since the action is not locked for editing. Check out the action and try again");
return;
}
}
}
}
private void viewRuleSetButton_Click(object sender, RoutedEventArgs e)
{
// get the rulesFilePath property
object rulesFilePath = ModelItem.Properties["RulesFilePath"].Value;
rulesFilePath = ((ModelItem)rulesFilePath).GetCurrentValue();
// correct the rules file path (in case is a relative path)
string correctedRulesFilePath = GetRulesFilePath((string)rulesFilePath);
// verify that RulesFilePath property has been configured
if (rulesFilePath == null || !(rulesFilePath is string))
{
System.Windows.MessageBox.Show("Rules File Path needs to be configured before viewing or editing the rules");
return;
}
else if (!File.Exists(correctedRulesFilePath))
{
System.Windows.MessageBox.Show(string.Format("Rules File Path provided not found ({0})", correctedRulesFilePath));
return;
}
// verify that RuleSetName property has been configured
object ruleSetName = ModelItem.Properties["RuleSetName"].Value;
ruleSetName = ((ModelItem)ruleSetName).GetCurrentValue();
if (ruleSetName == null)
{
System.Windows.MessageBox.Show("RuleSet Name needs to be configured before viewing or editing the rules");
return;
}
// verify that TargetObject property has been configured
object targetObject = ModelItem.Properties["TargetObject"].Value;
targetObject = ((ModelItem)targetObject).GetCurrentValue();
if (targetObject == null)
{
System.Windows.MessageBox.Show("TargetObject needs to be configured before viewing or editing the rules");
return;
}
// verify that target object is correctly configured
InArgument targetObjArg = targetObject as InArgument;
if (targetObjArg == null)
{
System.Windows.MessageBox.Show("Invalid target object");
return;
}
// open the ruleset editor
Type targetObjectType = targetObjArg.ArgumentType;
WorkflowMarkupSerializer ser = new WorkflowMarkupSerializer();
RuleDefinitions ruleDefs = ser.Deserialize(new System.Xml.XmlTextReader((string)correctedRulesFilePath)) as RuleDefinitions;
RuleSet ruleSet = ruleDefs.RuleSets[(string)ruleSetName];
// popup the dialog for viewing the rules
RuleSetDialog ruleSetDialog = new RuleSetDialog(targetObjectType, null, ruleSet);
DialogResult result = ruleSetDialog.ShowDialog();
// update if they changed the Rules
if (result == DialogResult.OK) //If OK was pressed
{
for (int index = 0; index < ruleDefs.RuleSets.Count; index++)
{
if (ruleDefs.RuleSets[index].Name == (string)ruleSetName)
{
ruleDefs.RuleSets[index] = ruleSetDialog.RuleSet;
break;
}
}
try
{
ser.Serialize(new System.Xml.XmlTextWriter(correctedRulesFilePath, null), ruleDefs);
}
catch (UnauthorizedAccessException)
{
// File does not have write access. Make a local copy so user changes are not lost
FileInfo fileInfo = new FileInfo(correctedRulesFilePath);
// create local file by adding a random suffix to original filename
string localFileCopy = fileInfo.Name.Substring(0, fileInfo.Name.IndexOf('.')) + new Random().Next() + fileInfo.Extension;
ser.Serialize(new System.Xml.XmlTextWriter((string)localFileCopy, null), ruleDefs);
System.Windows.MessageBox.Show("Rules file is not writeable. Created copy of your changes in " + localFileCopy);
}
}
}
protected override void DoDefaultAction()
{
base.DoDefaultAction();
// Do not allow editing if in debug mode.
WorkflowDesignerLoader workflowDesignerLoader = this.GetService(typeof(WorkflowDesignerLoader)) as WorkflowDesignerLoader;
if (workflowDesignerLoader != null && workflowDesignerLoader.InDebugMode)
{
throw new InvalidOperationException(Messages.DebugModeEditsDisallowed);
}
// Do not allow editing if locked
PolicyActivity activity = (PolicyActivity)this.Activity;
if (Helpers.IsActivityLocked(activity))
{
return;
}
RuleDefinitions rules = ConditionHelper.Load_Rules_DT(this, Helpers.GetRootActivity(activity));
if (rules != null)
{
RuleSetCollection ruleSetCollection = rules.RuleSets;
RuleSetReference ruleSetReference = activity.RuleSetReference;
RuleSet ruleSet = null;
string ruleSetName = null;
if (ruleSetReference != null &&
!string.IsNullOrEmpty(ruleSetReference.RuleSetName))
{
ruleSetName = ruleSetReference.RuleSetName;
if (ruleSetCollection.Contains(ruleSetName))
{
ruleSet = ruleSetCollection[ruleSetName];
}
}
else
{
ruleSetName = ruleSetCollection.GenerateRuleSetName();
}
using (RuleSetDialog dlg = new RuleSetDialog(activity, ruleSet))
{
if (DialogResult.OK == dlg.ShowDialog())
{
if (ruleSet != null) // modifying
{
ruleSetCollection.Remove(ruleSetName);
}
else // creating
{
dlg.RuleSet.Name = ruleSetName;
activity.RuleSetReference = new RuleSetReference(ruleSetName);
}
ruleSetCollection.Add(dlg.RuleSet);
ConditionHelper.Flush_Rules_DT(this, Helpers.GetRootActivity(activity));
}
}
}
// force revalidation by setting a property
TypeDescriptor.GetProperties(activity)["RuleSetReference"].SetValue(activity, activity.RuleSetReference);
}
private void btnRuleSet_Click(object sender, EventArgs e)
{
RuleSet rs = null;
if (cmboExistingRulesets.SelectedItem.ToString() == "<New>")
{
if (
(txtRuleSetName.Text == null) ||
(txtRuleSetName.Text == string.Empty)
)
{
MessageBox.Show("Please specify a name for the RuleSet");
}
else
{
rs = new RuleSet(txtRuleSetName.Text);
}
}
else
{
string sFullURL = sSiteURL + "Rules/" + cmboExistingRulesets.SelectedItem + ".ruleset";
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
XmlUrlResolver resolver = new XmlUrlResolver();
System.Net.NetworkCredential myCredentials;
myCredentials = new System.Net.NetworkCredential("Administrator", "password", "MossRTM");
resolver.Credentials = myCredentials;
XmlReaderSettings settings = new XmlReaderSettings();
settings.XmlResolver = resolver;
XmlReader reader = XmlReader.Create(sFullURL, settings);
rs = (RuleSet)serializer.Deserialize(reader);
reader.Close();
}
if (rs != null)
{
RuleSetDialog ruleSetDialog = new RuleSetDialog(WFDataCollection[lbWorkflows.SelectedIndex].AssemblyType, null, rs);
DialogResult result = ruleSetDialog.ShowDialog();
WorkflowMarkupSerializer serializer = new WorkflowMarkupSerializer();
if (result == DialogResult.OK)
{
rs = ruleSetDialog.RuleSet;
if (rs.Rules.Count > 0)
{
MemoryStream ms = new MemoryStream();
string sFilename = rs.Name + ".ruleset";
XmlWriter writer2 = XmlWriter.Create(ms);
serializer.Serialize(writer2, rs);
writer2.Flush();
SPSite site = new SPSite(sSiteURL);
SPWeb web = site.OpenWeb();
SPDocumentLibrary dl = (SPDocumentLibrary)web.Lists["Rules"];
SPFile newfile = dl.RootFolder.Files.Add(sFilename, ms.ToArray(), true);
newfile.Item["WorkflowName"] = sWorkflowName;
newfile.Item.Update();
writer2.Close();
MessageBox.Show("RuleSet Saved");
cmboExistingRulesets.Items.Add(rs.Name);
cmboExistingRulesets.SelectedItem = rs.Name;
txtRuleSetName.Text = string.Empty;
}
}
}
}