// Simple scenario to show how an agent could execute a WS described using // DAML private object DemoExecuteService(DamlProcess process, DAMLParameter zipcode) { object objRes = null; // Ensure zipcode.Type matches to System.String in .NET world if (zipcode.Type == enuDAMLType.stringType && process.Inputs[0].Range.IndexOf("#string") != -1) { DynamicPxy.WeatherRetriever wr = new DynamicPxy.WeatherRetriever(); Type PxyType = wr.GetType(); // Even though we pass zipcode.data which is an object it is // dynamically cast to string MethodInfo mInfo = PxyType.GetMethod(process.Name); if (mInfo != null) { objRes = mInfo.Invoke(wr, new object[] { zipcode.Data }); } } else { MessageBox.Show("Input type mismatch on process execute"); } return(objRes); }
// Hook into combo box selection change event // to retrieve details on process private void cmbProcess_TextChanged(object sender, System.EventArgs e) { string strEvent = e.ToString(); // If no text selected then exit if (this.cmbProcess.Text == "") { return; } // otherwise go get data and display DamlProcess process = new DamlProcess(); enuProcessType processType = enuProcessType.AtomicProcess; if (rdoAtomic.Checked) { processType = enuProcessType.AtomicProcess; } else if (rdoSimple.Checked) { processType = enuProcessType.SimpleProcess; } else { processType = enuProcessType.CompositeProcess; } // Do query process = m_processModel.GetProcessData(cmbProcess.Text, processType); LoadProcessData(process, ref tvwDetails); }
public frmMain() { m_demoProcess = new DamlProcess(); // Can only execute Atomic processes m_demoProcess.ProcessType = enuProcessType.AtomicProcess; m_demoProcess.Name = "GetWeather"; // Inputs necessary RdfProperty input = new RdfProperty(); input.Name = "zipcode"; input.Domain = "#WeatherRetriever"; input.Range = "http://www.w3.org/2000/10/XMLSchema#string"; input.SubPropertyOf = "http://www.daml.org/services/daml-s/2001/10/Process.daml#input"; input.SameValueAs = ""; m_demoProcess.AddInput(input); // Conditional output // WS returns complex type (class instance) this maps to DAML "Thing" RdfProperty condOutput = new RdfProperty(); condOutput.Name = "CurrentWeather"; condOutput.Domain = "#WeatherRetriever"; condOutput.Range = "http://www.daml.org/2001/03/daml+oil#Thing"; condOutput.SubPropertyOf = "http://www.daml.org/services/daml-s/2001/10/Process.daml#conditionalOutput"; m_demoProcess.AddConditionalOutput(condOutput); // // Required for Windows Form Designer support // InitializeComponent(); // // TODO: Add any constructor code after InitializeComponent call // }
public static string GenerateDaml(string strWsdlUrl) { // Read in Service Description from url ServiceDescription svcDesc = ServiceDescription.Read(Wsdl2DamlGen.GetHttpStream(strWsdlUrl)); ServiceCollection svcColl = svcDesc.Services; // Get the services in the service Description collection // Expect only one // for the first one create a DamlProcess instance (atomic process) // for each method in the web service if (svcColl.Count == 0) { return(""); } Service svc = svcColl[0]; // Generate assembly in memory representing web service proxy // use reflection on it to get method data, inputs, outputs etc // For each method we create a Daml atomic process // and add data for its inputs, and outputs at least // no provision to add data on preconditions etc. // since more information would be needed than we get from // the wsdl Assembly proxyAssembly = GenerateAssembly(ref svcDesc); if (proxyAssembly == null) { throw new Exception("Error generating in memory web service proxy assembly"); } string strServiceName = Wsdl2DamlGen.AUTO_GEN_NAMESPACE + "." + svc.Name; DamlProcessModelWriter damlWriter = new DamlProcessModelWriter(); // Get all the types defined in the assembly Type[] arrTypes = proxyAssembly.GetTypes(); // Get the type representing the web service Type proxyType = proxyAssembly.GetType(strServiceName, true); // Ask for all its methods, these are our daml atomic process // We only want the public instance methods declared at this type's level // we are not interested in any inherited methods MethodInfo[] arrMethods = proxyType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); for (int i = 0; i < arrMethods.Length; i++) { // Get the current method MethodInfo currMethod = arrMethods[i]; // Get the parameters expected by this method ParameterInfo[] arrParams = currMethod.GetParameters(); // Get the return type of this method Type returnType = currMethod.ReturnType; // Flags whether we ignore or process this method bool bIgnoreMethod = false; // Ignore constructors and async methods if (currMethod.IsConstructor || currMethod.ReturnType == typeof(System.IAsyncResult)) { continue; } for (int j = 0; j < arrParams.Length; j++) { if (arrParams[j].ParameterType == typeof(System.IAsyncResult)) { bIgnoreMethod = true; break; } } if (bIgnoreMethod) { continue; } // We do not want any of the async methods // filter based on paramters // Basically any method that expects or returns // System.IAsyncResult // neither do we want the constructor(s) DamlProcess process = new DamlProcess(); process.Name = currMethod.Name; // Get the input and output types and add them to the process for (int x = 0; x < arrParams.Length; x++) { RdfProperty input = new RdfProperty(); // Set the name of the input input.Name = arrParams[x].Name; // Set domain - name of methd input.Domain = process.Name; // Set subproperty - set as a subProperty of Process Inputs input.SubPropertyOf = DamlConstants.PROCESS_INPUT_URI; // Map .NET type to DamlTypes - strings, decimals, daml+oil#Thing input.Range = "http://www.daml.org/2001/03/daml+oil#Thing"; process.AddInput(input); // Create input restriction DamlRestriction restriction = new DamlRestriction(); // Set the cardinality restriction.Cardinality = 1; // Set the owner restriction.Owner = input.Domain; // Specify the property to which the restriction applies restriction.OnProperty = "#" + input.Name; // Add restriction to process process.AddRestriction(enuIOPEType.Input, new DamlRestriction[] { restriction }); } // Add output to process if (returnType.FullName != (typeof(void).FullName)) { RdfProperty output = new RdfProperty(); // Set the name of the input output.Name = process.Name + "Out"; // Set domain - name of methd output.Domain = process.Name; // Set subproperty - set as a subProperty of Process Inputs output.SubPropertyOf = DamlConstants.PROCESS_OUTPUT_URI; // Map .NET type to DamlTypes - strings, decimals, daml+oil#Thing output.Range = "http://www.daml.org/2001/03/daml+oil#Thing"; process.AddOutput(output); } // Add the process to the process model writer damlWriter.AddDamlProcess(process); } return(damlWriter.ToXml()); }
private void LoadProcessData(DamlProcess process, ref TreeView tview) { // Clear treeview tview.Nodes.Clear(); if (!process.HasData) { tview.Nodes.Add("No Details"); return; } // Add nodes... // Inputs... if (process.HasInputs) { TreeNode Node = new TreeNode("Inputs"); RdfProperty[] arrData = process.Inputs; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasParameters) { TreeNode Node = new TreeNode("Parameters"); RdfProperty[] arrData = process.Parameters; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasOutputs) { TreeNode Node = new TreeNode("Outputs"); RdfProperty[] arrData = process.Outputs; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasConditionalOutputs) { TreeNode Node = new TreeNode("ConditionalOutputs"); RdfProperty[] arrData = process.ConditionalOutputs; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasCoOutputs) { TreeNode Node = new TreeNode("CoOutputs"); RdfProperty[] arrData = process.CoOutputs; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasEffects) { TreeNode Node = new TreeNode("Effects"); RdfProperty[] arrData = process.Effects; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasCoConditions) { TreeNode Node = new TreeNode("CoConditions"); RdfProperty[] arrData = process.CoConditions; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasPreconditions) { TreeNode Node = new TreeNode("Preconditions"); RdfProperty[] arrData = process.Preconditions; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].Range); } tview.Nodes.Add(Node); } if (process.HasSubProcesses) { TreeNode Node = new TreeNode("SubProcesses"); DamlProcess[] arrData = process.SubProcesses; for (int i = 0; i < arrData.Length; i++) { Node.Nodes.Add(arrData[i].Name + " -> " + arrData[i].ProcessType.ToString()); } tview.Nodes.Add(Node); } // Expand inputs tview.Nodes[0].Expand(); }