public void Init()
{
var workStepRepository = new MemoryWorkStepRepository();
_workItemRepository = new MemoryWorkItemRepository();
var workflowRepository = new WorkflowRepository(_workItemRepository, workStepRepository);
_wp = new Workflow(workflowRepository);
_xmlRenderer = new XmlRenderer(_wp);
}
public void Init()
{
var workStepRepository = new MemoryWorkStepRepository();
_workItemRepository = new MemoryWorkItemRepository();
var workflowRepository = new WorkflowRepository(_workItemRepository, workStepRepository);
_wp = new Workflow(workflowRepository);
_xmlRenderer = new XmlRenderer(_wp);
}
public static XmlDocument RenderToXmlDocument(this XmlRenderer xmlRenderer, WorkStep workStep)
{
var doc = new XmlDocument();
using (var writeStream = new MemoryStream())
{
xmlRenderer.Render(writeStream, workStep);
var readStream = new MemoryStream(writeStream.ToArray());
doc.Load(readStream);
}
return(doc);
}
private string ConvertNodeToString(XmlNode node)
{
XmlNode newNode = node;
if (!IsTextNode(node))
{
// convert the node into a document in order to avoid inheriting any namespaces
// note, this should not remove inner namespaces in the content - may need to revisit
// this may be very inefficient - better to just search and replace namespaces after converting to string?
newNode = XmlRenderer.ObtainDocumentFromNode(node, true);
}
return(XmlRenderer.RenderNodeEscaped(newNode));
}
/// <summary>
/// Retrieves an XML representation of the documentation specified by <paramref name="entry"/>.
/// </summary>
/// <param name="entry">The Entry to obtain documentation for.</param>
/// <returns>An XmlDocument containing the documentation.</returns>
private string GetDocumentationFor(Entry entry)
{
if (null == entry)
{
throw new ArgumentNullException("The provided Entry was null.");
}
string stringOutput = string.Empty;
using (MemoryStream output = new MemoryStream())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
using (XmlWriter writer = XmlWriter.Create(output, settings))
{
XmlRenderer r = XmlRenderer.Create(entry, _baseDocument);
if (r == null)
{
return(null); // simply return a null reference if we cant find the renderer for the entry
}
r.Render(writer);
writer.Flush();
writer.Close();
// get memory stream contents as a string
output.Seek(0, SeekOrigin.Begin);
StreamReader s = new StreamReader(output);
stringOutput = s.ReadToEnd();
}
}
return(stringOutput);
}
static void Main(string[] args)
{
#if _DEBUG
args = "Common.Controllers.dll -t Controller".Split(' ');
//args = "WebApi.Example.Controllers.ProductsController.xml -r xslt -x iodocuments.xslt -o json".Split(' ');
//args = "WebApi.Example.Controllers.ProductsController.xml -r xslt -x apitester.xslt -o xml".Split(' ');
//args = "Common.Controllers.dll -r ctorxml -t Controller".Split(' ');
#endif
if (null == args || !args.Any())
{
DisplayUsage();
return;
}
var options = ParseCommandLine(string.Join(" ", args));
if (!options.Any() || !(options.ContainsKey("file") || options.ContainsKey("path")) ||
(options.ContainsKey("file") && !Parser.IsFile(options["file"])) ||
(options.ContainsKey("path") && !Parser.IsPath(options["path"])) ||
(options["render"] == "xslt" &&
options.ContainsKey("xsltfile") && !Parser.IsFile(options["xsltfile"]))
)
{
DisplayUsage();
return;
}
IRenderable renderer = null;
switch (options["render"])
{
case "text":
renderer = new CustomRenderer(
options.ContainsKey("file") ? options["file"] : options["path"],
options.ContainsKey("includeflag")
);
break;
case "xslt":
renderer = new XsltRenderer(
options["xsltfile"],
options.ContainsKey("outext") ? options["outext"] : "json",
options.ContainsKey("file") ? options["file"] : options["path"],
options.ContainsKey("includeflag")
);
break;
case "ctorxml":
renderer = new XmlCtorRenderer(
options.ContainsKey("file") ? options["file"] : options["path"],
options.ContainsKey("includeflag")
);
break;
case "text2xml":
renderer = new Text2XmlRenderer(options["file"]);
break;
default:
renderer = new XmlRenderer(
options.ContainsKey("file") ? options["file"] : options["path"],
options.ContainsKey("includeflag")
);
break;
}
var parser = new Parser(renderer);
System.Console.WriteLine("Rendering as " + options["render"] + "..." + Environment.NewLine);
System.Console.WriteLine(parser.Render(
options.ContainsKey("types") ? options["types"].Split(',') : null,
options.ContainsKey("methods") ? options["methods"].Split(','): null
));
}
public static XmlDocument RenderToXmlDocument(this XmlRenderer xmlRenderer)
{
return(RenderToXmlDocument(xmlRenderer, WorkStep.Root));
}
protected void Page_Load(object sender, EventArgs e)
{
this.RequirePermission(Affinity.RolePermission.SubmitOrders);
string id = NoNull.GetString(Request["id"]);
string keyAttribute = NoNull.GetString(Request["key"], "sp_id");
string format = NoNull.GetString(Request["format"], "hash");
string exportformat = "PFT";
if (!format.Equals("entire"))
{
Affinity.Request r = new Affinity.Request(this.phreezer);
r.Load(id);
// make sure this user has permission to make updates to this order
if (!r.Order.CanRead(this.GetAccount()))
{
this.Crash(300, "Permission denied.");
}
IBaseRenderer renderer = null;
// depending on the format requested, get the correct renderer object
switch (format)
{
case "entire":
break;
case "xml":
exportformat = "Generic XML";
renderer = new XmlRenderer(r, this.GetSystemSettings());
break;
case "rei":
exportformat = "REI XML";
renderer = new XmlREIRenderer(r, this.GetSystemSettings());
break;
case "change":
exportformat = "PFT (Changes Only)";
renderer = new PFTChangeRenderer(r, this.GetSystemSettings());
break;
case "TPS":
exportformat = "TPS";
renderer = new TPSServicePFTRenderer(r, this.GetSystemSettings());
break;
//case "special":
// renderer = new XmlSpecialRenderer(r, this.GetSystemSettings());
// break;
default:
renderer = new PFTRenderer(r, this.GetSystemSettings());
break;
}
Affinity.ExportLog exportlog = new Affinity.ExportLog(this.phreezer);
Affinity.Account account = this.GetAccount();
exportlog.AccountID = account.Id;
exportlog.OrderID = r.OrderId;
exportlog.RequestID = r.Id;
exportlog.ExportFormat = exportformat;
exportlog.Insert();
// output the results of the renderer
OutputRenderer(renderer, keyAttribute);
}
else
{
Affinity.RequestTypes rts = new Affinity.RequestTypes(this.phreezer);
Affinity.RequestTypeCriteria rtc = new Affinity.RequestTypeCriteria();
rtc.IsActive = 1;
rts.Query(rtc);
Object [] renderers = new Object[rts.Count];
IEnumerator i = rts.GetEnumerator();
int j = 0;
bool isClerkingServices = false;
Affinity.Account account = this.GetAccount();
exportformat = "Entire Order";
while (i.MoveNext())
{
Affinity.RequestType rt = (Affinity.RequestType)i.Current;
Affinity.Order order = new Affinity.Order(this.phreezer);
order.Load(id);
Affinity.RequestCriteria rc = new Affinity.RequestCriteria();
rc.RequestTypeCode = rt.Code;
order.GetOrderRequests(rc);
Affinity.Requests reqs = order.GetOrderRequests(rc);
Affinity.Request r = null;
if (reqs.Count > 0)
{
r = (Affinity.Request)reqs[0];
if (rt.Code.Equals("ClerkingRequest"))
{
isClerkingServices = true;
}
IBaseRenderer renderer = new PFTRenderer(r, this.GetSystemSettings());
renderers[j] = renderer;
j++;
}
if (r != null)
{
Affinity.ExportLog exportlog = new Affinity.ExportLog(this.phreezer);
exportlog.AccountID = account.Id;
exportlog.OrderID = r.OrderId;
exportlog.RequestID = r.Id;
exportlog.ExportFormat = exportformat;
exportlog.Insert();
}
}
OutputMultiRenderer(renderers, keyAttribute, isClerkingServices);
}
}
