protected override XNode HandleOutputPath(XNode current)
{
XElement propertyGroup = _projectFile.NewPropertyGroup(Condition.TagNotDefined(SOLUTION_DIR_TAG)
, _projectFile.NewProperty(INTERMEDIATE_OUTPUT_TAG, CurrentSettings.ProjectIntermediateFolder, !ADD_IS_DEFINED));
current.AddAfterSelf(propertyGroup);
propertyGroup = _projectFile.NewPropertyGroup(Condition.TagDefined(SOLUTION_DIR_TAG)
, _projectFile.NewProperty(INTERMEDIATE_OUTPUT_TAG, CurrentSettings.SolutionIntermediateFolder, !ADD_IS_DEFINED));
current.AddAfterSelf(propertyGroup);
return(propertyGroup);
}
public void Normalize()
{
RemoveUnwantedNodes();
RemoveGeneratedNodes();
XElement commonPropertyGroup = _projectFile.PropertyGroups().First();
XNode start = commonPropertyGroup;
XComment regionMark = BuildGeneratedRegionMark();
start.AddAfterSelf(regionMark);
start = WithinRegion(regionMark);
start.AddAfterSelf(regionMark);
}
private XElement copySegmentElements(XElement startNode, XElement lastNode)
{
// make a new "root" node
XElement newRoot = new XElement("newroot");
// copy the input element as the first child of new root
XElement firstCopyChild = XUtils.WordProcessingMLUtils.CustomCopyElement_ver2(startNode);
//XUtils.WordProcessingMLUtils.DebugWriteXElementSiblings(firstCopyChild, "DebugTreeCopy.xml");
newRoot.Add(firstCopyChild);
XNode copyRunner = firstCopyChild;
XNode nextSibling = startNode.NextNode; // nextSibling starts at top child's sibling
XElement nextSiblingCopyXElem = null;
XNode nextSiblingCopyXNode = null;
do
{
if (nextSibling == null)
{
continue;
}
if (nextSibling.NodeType != XmlNodeType.Element)
{
nextSiblingCopyXNode = XUtils.WordProcessingMLUtils.getXNodeCopy(nextSibling);
copyRunner.AddAfterSelf(nextSiblingCopyXNode);
}
else
{
nextSiblingCopyXElem = XUtils.WordProcessingMLUtils.
CustomCopyElement_ver2((XElement)nextSibling);
copyRunner.AddAfterSelf(nextSiblingCopyXElem);
}
if (nextSibling == lastNode)
{
break;
}
copyRunner = copyRunner.NextNode; // adjust copy runner
nextSibling = nextSibling.NextNode; // adjust original runner
}while (nextSibling != null);
return(newRoot);
}
static public void export()
{
bool k = false;
try
{
var bank = new XDocument(new XElement("order", new XElement("name ", new XText("goodsname"), new XAttribute("number", "000"))));
XNode r = bank.FirstNode;
for (int i = 0; i < 10; i++)
{
if (!listflag[i])
{
for (int j = 1; j < list[i].det.nums; j++)
{
XElement child = new XElement(list[i].client, new XText(list[i].det.goodslist[j]), new XAttribute("number", list[i].det.num[j]));
r.AddAfterSelf(child);
}
}
}
StreamWriter w = new StreamWriter(new FileStream(@"d:\bank.xml", FileMode.Create), encoding.utf8);
bank.Save(w);
k = (w != null);
}
catch (System.CannotUnloadAppDomainException)
{
Console.WriteLine("file opening failed");
}
Assert.IsNotNull(k);
}
public void ExecuteXDocumentVariation()
{
XNode[] toAdd = Variation.Params[0] as XNode[];
XNode contextNode = Variation.Params[1] as XNode;
IEnumerable <XNode> toAddList = toAdd.OfType <XNode>();
XDocument xDoc = new XDocument(contextNode);
XDocument xDocOriginal = new XDocument(xDoc);
using (UndoManager undo = new UndoManager(xDoc))
{
undo.Group();
using (EventsHelper docHelper = new EventsHelper(xDoc))
{
using (EventsHelper nodeHelper = new EventsHelper(contextNode))
{
contextNode.AddAfterSelf(toAdd);
TestLog.Compare(toAddList.SequenceEqual(contextNode.NodesAfterSelf(), XNode.EqualityComparer), "Nodes not added correctly!");
nodeHelper.Verify(0);
}
docHelper.Verify(XObjectChange.Add, toAdd);
}
undo.Undo();
TestLog.Compare(XNode.DeepEquals(xDoc, xDocOriginal), "Undo did not work!");
}
}
public void ExecuteXElementVariation()
{
XNode[] toAdd = Variation.Params[0] as XNode[];
XNode contextNode = Variation.Params[1] as XNode;
IEnumerable <XNode> toAddList = toAdd.OfType <XNode>();
XElement xElem = new XElement("root", contextNode);
XElement xElemOriginal = new XElement(xElem);
using (UndoManager undo = new UndoManager(xElem))
{
undo.Group();
using (EventsHelper elemHelper = new EventsHelper(xElem))
{
using (EventsHelper nodeHelper = new EventsHelper(contextNode))
{
contextNode.AddAfterSelf(toAdd);
TestLog.Compare(toAddList.SequenceEqual(contextNode.NodesAfterSelf(), XNode.EqualityComparer), "Nodes not added correctly!");
nodeHelper.Verify(0);
}
elemHelper.Verify(XObjectChange.Add, toAdd);
}
undo.Undo();
TestLog.Compare(xElem.Nodes().SequenceEqual(xElemOriginal.Nodes(), XNode.EqualityComparer), "Undo did not work!");
TestLog.Compare(xElem.Attributes().EqualsAllAttributes(xElemOriginal.Attributes(), Helpers.MyAttributeComparer), "Undo did not work!");
}
}
public static void AddAfterSelfIndented(this XNode self, XElement addedElement)
{
string selfIndent;
if (TryGetElementIndent(self, out selfIndent))
{
IndentDescendantNodes(addedElement, selfIndent);
var newLineAndIndent = new XText("\n" + selfIndent);
self.AddAfterSelf(newLineAndIndent);
newLineAndIndent.AddAfterSelf(addedElement);
}
else
{
// Ignore indent
self.AddAfterSelf(addedElement);
}
}
////////////////////////////以下函数操作管理车辆XML文件的增删改//////////////////////////////////
//添加车辆
public bool AppendRobotInfo(List <RobotInfo> list)
{
Dictionary <string, RobotInfo> varDict = Collection.ToList().ToDictionary(key => key.EndPoint, value => value);
XDocument XDoc = XDocument.Load("RobotInfo.xml");
XElement rootNode = XDoc.Element("RobotInfo");
XNode xLastNode = rootNode.LastNode;
bool retval = false;
foreach (RobotInfo info in list)
{
if (varDict.ContainsKey(info.EndPoint))
{
continue;
}
info.NetId = -(ItemCount++);
Collection.Add(info);
try
{
XElement xEle = new XElement("item");
XAttribute xAttr = new XAttribute("name", info.Id.ToString());
xEle.Add(xAttr);
var endpoint = info.EndPoint.ToString().Split(':');
if (endpoint.Length != 2)
{
continue;
}
xAttr = new XAttribute("ip", endpoint[0]);
xEle.Add(xAttr);
xAttr = new XAttribute("port", endpoint[1]);
xEle.Add(xAttr);
xAttr = new XAttribute("fts", info.Fts.ToString());
xEle.Add(xAttr);
if (xLastNode != null)
{
xLastNode.AddAfterSelf(xEle);
xLastNode = xEle;
}
else
{
rootNode.AddFirst(xEle);
xLastNode = rootNode;
}
retval = true;
}
catch (Exception)
{
return(false);
}
}
XDoc.Save("RobotInfo.xml");
return(retval);
}
private XNode HandleImports(XNode start)
{
string sharedProperties = CurrentSettings.CommonPropsFile;
XElement imports = _projectFile.NewImport(sharedProperties,
Condition.And(Condition.TagDefined(SOLUTION_DIR_TAG),
Condition.Exists(sharedProperties)));
start.AddAfterSelf(imports);
return(imports);
}
//[Variation(Priority = 1, Desc = "XElement - Working on the text nodes 1.")]
public void WorkOnTextNodes1()
{
XElement elem = new XElement("A", "text2");
XNode n = elem.FirstNode;
using (UndoManager undo = new UndoManager(elem))
{
undo.Group();
using (EventsHelper eHelper = new EventsHelper(elem))
{
n.AddAfterSelf("text0");
TestLog.Compare(elem.Value, "text2text0", "Did not concat text nodes correctly");
n.AddAfterSelf("text1");
TestLog.Compare(elem.Value, "text2text0text1", "Did not concat text nodes correctly");
eHelper.Verify(new XObjectChange[] { XObjectChange.Value, XObjectChange.Value });
}
undo.Undo();
TestLog.Compare(elem.Value, "text2", "Undo did not work");
}
}
//[Variation(Priority = 1, Desc = "Working on the text nodes 1.")]
public void WorkOnTextNodes1()
{
runWithEvents = (bool)Params[0];
var elem = new XElement("A", new XElement("B"), "text0", new XElement("C"));
XNode n = elem.FirstNode.NextNode;
if (runWithEvents)
{
eHelper = new EventsHelper(elem);
}
n.AddAfterSelf("text1");
n.AddAfterSelf("text2");
if (runWithEvents)
{
eHelper.Verify(new[] { XObjectChange.Value, XObjectChange.Value });
}
TestLog.Compare(elem.Nodes().Count(), 3, "elem.Nodes().Count(), 3");
TestLog.Compare((n as XText).Value, "text0text1text2", "(n as XText).Value, text0text1text2");
}
public void XElementWorkOnTextNodes1()
{
XElement elem = new XElement("A", "text2");
XNode n = elem.FirstNode;
using (UndoManager undo = new UndoManager(elem))
{
undo.Group();
using (EventsHelper eHelper = new EventsHelper(elem))
{
n.AddAfterSelf("text0");
Assert.Equal("text2text0", elem.Value);
n.AddAfterSelf("text1");
Assert.Equal("text2text0text1", elem.Value);
eHelper.Verify(new XObjectChange[] { XObjectChange.Value, XObjectChange.Value });
}
undo.Undo();
Assert.Equal("text2", elem.Value);
}
}
protected virtual XNode HandleProperties(XNode current)
{
XElement propertyGroup = _projectFile.NewPropertyGroup();
HandlePlatformProperty(propertyGroup);
if (!propertyGroup.IsEmpty)
{
current.AddAfterSelf(propertyGroup);
current = propertyGroup;
}
return(current);
}
/// <summary>
/// An XDocument extension method that creates and attaches a new <see cref="XElement"/> for
/// serializing the specified object of type <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">Generic type parameter.</typeparam>
/// <param name="xdoc">The <see cref="XDocument"/> to act on.</param>
/// <param name="obj">The object of type <typeparamref name="T"/>.</param>
/// <param name="parent">(Optional) The parent <see cref="XNode"/> node.</param>
/// <returns>
/// A new XElement.
/// </returns>
public static XElement AttachNewElement <T>(this XDocument xdoc, T obj, XNode parent = null)
{
var xelem = new XElement(typeof(T).Name);
if (parent == null)
{
xdoc.Add(xelem);
}
else
{
parent.AddAfterSelf(xelem);
}
return(xelem);
}
public bool Visit(XNode node)
{
if (node.NodeType == XmlNodeType.Element)
{
node.AddBeforeSelf(new XText("\n"));
if (node.NodesAfterSelf().All(x => x.NodeType == XmlNodeType.Text))
{
node.AddAfterSelf(new XText("\n"));
}
}
return(false);
}
/// <summary>
/// Moves the element down.
/// </summary>
/// <param name="element">The element.</param>
/// <exception cref="System.ArgumentException">Nowhere to move element to!</exception>
public static void MoveElementDown(this XElement element)
{
// Walk backwards until we find an element - ignore text nodes
XNode nextNode = element.NextNode;
while (nextNode != null && !(nextNode is XElement))
{
nextNode = nextNode.NextNode;
}
if (nextNode == null)
{
throw new ArgumentException("Nowhere to move element to!");
}
element.Remove();
nextNode.AddAfterSelf(element);
}
/// <summary>
/// Ensures the whitespace separation for the first child element added to a node.
/// </summary>
/// <param name="element"></param>
private void EnsureFirstNodeWhitespaceSeparation(XNode element)
{
#if DEBUG
if (element.Parent != null)
{
Debug.Assert(element.Parent.Elements().Count() == 1, "Unexpected count of elements!");
}
else
{
// if first.Parent is null, then this is the root element in a document
Debug.Assert(element.Document.Root == element, "element had null parent, but is not the root element of the document");
}
#endif
var precedingNewLine = new XText(Environment.NewLine + new string(' ', GetIndentLevel() * 2));
var trailingNewLine = new XText(Environment.NewLine + new string(' ', Parent.GetIndentLevel() * 2));
element.AddBeforeSelf(precedingNewLine);
element.AddAfterSelf(trailingNewLine);
}
public static XElement MoveAfter(this XElement element, XNode target)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
if (element != target)
{
if (element.Parent != null)
{
element.Remove();
}
if (target.Parent != null)
{
target.AddAfterSelf(element);
}
}
return(element);
}
private void buttonAddSource_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "Scalable Vector Graphics(*.svg)|*.svg"; // |All files(*.*)|*.*
openFileDialog.CheckFileExists = true;
if (openFileDialog.ShowDialog() == true)
{
string path = openFileDialog.FileName;
string alias = String.Empty;
var aliasDialog = new AliasWindow(path);
if (aliasDialog.ShowDialog() == true)
{
alias = aliasDialog.ResponseText;
}
else
{
return;
}
XDocument xdoc = XDocument.Load(sourcesXml);
List <string> aliases = new List <string>();
foreach (XElement xe in xdoc.Element("sources").Elements("source"))
{
aliases.Add(xe.Attribute("alias").Value);
}
if (aliases.Contains(alias))
{
MessageBox.Show(
"A source with the name \"" + alias + "\" is already on the list. The selected source will not be added.",
"Error",
MessageBoxButton.OK,
MessageBoxImage.Error,
MessageBoxResult.OK,
MessageBoxOptions.DefaultDesktopOnly);
return;
}
XNode xLastSource = xdoc.Element("sources").LastNode;
XElement newxe = new XElement("source");
newxe.SetAttributeValue("alias", alias);
newxe.SetAttributeValue("path", path);
newxe.SetAttributeValue("enabled", true);
if (xLastSource == null)
{
xdoc.Element("sources").Add(newxe);
}
else
{
xLastSource.AddAfterSelf(newxe);
}
savePath = new DirectoryInfo(System.IO.Path.GetDirectoryName(path)).Parent.FullName;
textBoxSavePath.Text = savePath;
xdoc.Element("sources").SetAttributeValue("defaultSavePath", savePath);
xdoc.Save(sourcesXml);
listBoxSources.ItemsSource = getListBoxItemsSourceFromXmlFile(xdoc);
}
}
public void Insert(XNode node)
{
_insertPoint.AddAfterSelf(node);
_insertPoint = _insertPoint.NextNode;
}
public XDocument GetInvoice(int shopperID, int orderID)
{
shopper = rep.GetShopper(shopperID);
order = rep.GetShopperOrder(shopper.id, orderID);
requestID = rep.GetQuickBooksOrder(order.id).RequestID;
var lineItems = rep.GetInventoryItems(order.cartID);
foreach (var item in lineItems)
{
var shopInventory = rep.GetShopInventoryItems(shopper.clientID).Where(i => i.Name == item.InventoryName);
var exists = shopInventory.Any();
if (!exists)
{
itemsExist = false;
missingInventoryItem = item.InventoryName;
}
item.InventoryName = shopInventory.SingleOrDefault().QuickbooksInventoryID != null?shopInventory.SingleOrDefault().QuickbooksInventory.FullName : item.InventoryName;
}
if (itemsExist)
{
doc = new XDocument(
new XDeclaration("1.0", "utf-8", null),
new XProcessingInstruction("qbxml", "version=\"6.0\""),
new XElement("QBXML",
new XElement("QBXMLMsgsRq", new XAttribute("onError", "stopOnError"),
new XElement("InvoiceAddRq",
new XAttribute("requestID", requestID),
new XElement("InvoiceAdd",
new XElement("CustomerRef",
new XElement("FullName", Name)),
new XElement("TxnDate", String.Format("{0:yyyy-MM-dd}", DateTime.Now)),
new XElement("BillAddress",
new XElement("Addr1", FirstName + " " + LastName),
new XElement("Addr2", BillAddress1),
new XElement("Addr3", BillAddress2),
new XElement("City", BillCity),
new XElement("State", BillState),
new XElement("PostalCode", BillPostalCode),
new XElement("Country", BillCountry)),
new XElement("ShipAddress",
new XElement("Addr1", S_firstname + " " + S_lastname),
new XElement("Addr2", ShipAddress1),
new XElement("Addr3", ShipAddress2),
new XElement("City", ShipCity),
new XElement("State", ShipState),
new XElement("PostalCode", ShipPostalCode),
new XElement("Country", ShipCountry)),
new XElement("ItemSalesTaxRef")
)
)
)
)
);
var customerNode = doc.LastNode.Document.Descendants().Where(n => n.Name == "CustomerRef").SingleOrDefault();
var salesTaxNode = doc.LastNode.Document.Descendants().Where(n => n.Name == "ItemSalesTaxRef").SingleOrDefault();
if (order.orderTax != null && order.orderTax > 0)
{
salesTaxNode.Add(new XElement("FullName", TaxFullName));
}
foreach (var item in lineItems)
{
(lastLineItemNode == null ? salesTaxNode : lastLineItemNode).AddAfterSelf(
new XElement("InvoiceLineAdd",
new XElement("ItemRef",
new XElement("FullName", item.InventoryName)),
new XElement("Desc", item.Desc),
new XElement("Quantity", item.Quantity == null ? 1 : item.Quantity),
new XElement("Rate", ((decimal)item.Rate).ToString("N2")),
new XElement("Amount", ((decimal)item.Amount).ToString("N2"))
)
);
}
if (ClassRef != null && ClassRef != String.Empty)
{
customerNode.AddAfterSelf(
new XElement("ClassRef",
new XElement("FullName", ClassRef)
)
);
}
if (TemplateRef != null && TemplateRef != String.Empty)
{
var element = doc.LastNode.Document.Descendants().Where(n => n.Name == "ClassRef").SingleOrDefault() == null ? customerNode : doc.LastNode.Document.Descendants().Where(n => n.Name == "ClassRef").SingleOrDefault();
element.AddAfterSelf(
new XElement("TemplateRef",
new XElement("FullName", TemplateRef)
)
);
}
lastLineItemNode.AddAfterSelf(
new XElement("InvoiceLineAdd",
new XElement("ItemRef",
new XElement("FullName", ShippingFullName)),
new XElement("Desc", "Shipping"),
new XElement("Amount", Shipping)
)
);
}
else //Query Quickbooks to see if the inventory Item Exists
{
doc = Inventory.ItemQuery(requestID, missingInventoryItem);
}
return(doc);
}
/// <summary>
/// Copy all the elements in A that are not in B to B.
/// </summary>
/// <param name="A"></param>
/// <param name="B"></param>
public static void CopyTo(this XElement A, XElement B)
{
XNode lastB = null, nodeA = null, nodeB = null;
Action Copy_A_To_B = () =>
{
if (null == lastB)
{
B.AddFirst(nodeA);
}
else
{
lastB.AddAfterSelf(nodeA);
}
};
var listA = A.Nodes().ToList();
var listB = B.Nodes().ToList();
int a, b;
for (a = 0, b = 0; a < listA.Count && b < listB.Count; a++, b++)
{
nodeA = listA[a];
nodeB = listB[b];
XElement xA = nodeA as XElement,
xB = nodeB as XElement;
XText tA = nodeA as XText,
tB = nodeB as XText;
if (null != xA && null != xB)
{
if (xA.Name.LocalName == xB.Name.LocalName)
{
CopyTo(xA, xB);
}
else
{
Copy_A_To_B();
CopyTo(A, B); // Restart this iteration for various reasons such as
// the next nodeA might be the same as current nodeB
return;
}
}
else if (null != xA)
{
Copy_A_To_B();
}
else if (null != tA && null != tB)
{
if (tA.Value != tB.Value)
{
tB.Value = tA.Value;
}
}
else if (null != tA)
{
Copy_A_To_B();
}
lastB = nodeB;
}
for (; a < listA.Count; a++)
{
nodeA = listA[a];
Copy_A_To_B();
if (null == lastB)
{
lastB = B.FirstNode;
}
else
{
lastB = lastB.NextNode;
}
}
}
static void MergeChildNodes(XElement dst, XElement src)
{
var dstNodes = WorkList.Create(dst);
var srcNodes = WorkList.Create(src);
// First skip all _identical_ nodes
// (doesn't actually merge anything, just removes identical nodes from work list)
MergeNodesBothDirections(
dstNodes,
srcNodes,
DeepEquals);
// First merge all where name matches
MergeNodesBothDirections(
dstNodes,
srcNodes,
(dstNode, srcNode) =>
{
if (dstNode.NodeType != srcNode.NodeType)
{
return(false);
}
if (dstNode.NodeType == XmlNodeType.Element)
{
if (((XElement)dstNode).Name != ((XElement)srcNode).Name)
{
return(false);
}
}
Merge(dstNode, srcNode);
return(true);
});
// Then merge all where only node type matches
MergeNodesBothDirections(
dstNodes,
srcNodes,
(dstNode, srcNode) =>
{
if (dstNode.NodeType != srcNode.NodeType)
{
return(false);
}
Merge(dstNode, srcNode);
return(true);
});
while (!dstNodes.IsEmpty)
{
var node = dstNodes.Pop(Position.Tail);
node.Remove();
}
XNode dstInsertPoint = null;
while (!srcNodes.IsEmpty)
{
// We need to know where to insert this.
var srcNode = srcNodes.Pop(Position.Head);
var dstNode = CloneNode(srcNode);
if (dstInsertPoint == null)
{
var srcIndex = srcNode.NodeIndex();
if (srcIndex == 0)
{
dst.AddFirst(dstNode);
}
else
{
dstInsertPoint = dst.FirstNode;
// Insert point will be element before srcNode index
for (int dstIndex = 0; dstIndex < (srcIndex - 1); dstIndex++)
{
dstInsertPoint = dstInsertPoint.NextNode;
}
dstInsertPoint.AddAfterSelf(dstNode);
}
}
else
{
dstInsertPoint.AddAfterSelf(dstNode);
}
dstInsertPoint = dstNode;
}
}
private static void Import(string loc, string p)
{
//Outer key is filename, inner key is fieldname, inner value is translated text
Dictionary <string, Dictionary <string, CSVEntry> > values = ImportCSV(p, loc, e => e.Value.Trim().Length == 0 || e.Value == e.Origvalue);
if (Duplicati.Library.Utility.Utility.IsClientLinux)
{
Dictionary <string, Dictionary <string, CSVEntry> > remap = new Dictionary <string, Dictionary <string, CSVEntry> >();
foreach (string key in values.Keys)
{
remap[key.Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString())] = values[key];
}
values = remap;
}
string folder = System.IO.Path.Combine(Application.StartupPath, loc);
if (!System.IO.Directory.Exists(folder))
{
Create(loc);
}
else
{
Update(loc);
}
XNamespace xmlns = "";
foreach (ResXFileInfo inf in GetResXList(loc))
{
if (System.IO.File.Exists(inf.TargetFile) && values.ContainsKey(inf.TargetFile))
{
XDocument targetDoc = XDocument.Load(inf.TargetFile);
XNode insertTarget = targetDoc.Element("root").LastNode;
var targetVals = targetDoc.Element("root").Elements("data").ToSafeDictionary(c => c.Attribute("name").Value, inf.TargetFile);
var sourceVals = values[inf.TargetFile];
values.Remove(inf.TargetFile);
bool updated = false;
foreach (var item in sourceVals)
{
if (targetVals.ContainsKey(item.Key))
{
if (targetVals[item.Key].Element("value").Value.Replace("\r\n", "\n") != item.Value.Value.Replace("\r\n", "\n"))
{
updated = true;
targetVals[item.Key].Element("value").Value = item.Value.Value;
}
}
else
{
updated = true;
insertTarget.AddAfterSelf(new XElement("data",
new XAttribute("name", item.Key),
new XAttribute(xmlns + "space", "preserve"),
new XElement("value", item.Value.Value)
));
}
}
if (updated)
{
targetDoc.Save(inf.TargetFile);
}
}
}
if (values.Count != 0)
{
Console.WriteLine("The following files were translated but did not exist: " + string.Join(Environment.NewLine, values.Keys.ToArray()));
}
}
private static void Update(string cultures)
{
foreach (string culture in GetLocaleFolders(cultures))
{
foreach (ResXFileInfo inf in GetResXList(culture))
{
if (inf.IsForm)
{
System.IO.File.Copy(inf.SourceFile, inf.NetrualTargetFile, true); //Copy the updated resx
}
if (System.IO.File.Exists(inf.TargetFile))
{
//Merge, forms are auto-merged, in that they depend on the neutral .resx file
if (!inf.IsForm)
{
XDocument targetDoc = XDocument.Load(inf.TargetFile);
XNode insertTarget = targetDoc.Element("root").LastNode;
var sourceVals = XDocument.Load(inf.SourceFile).Element("root").Elements("data").ToSafeDictionary(c => c.Attribute("name").Value, inf.SourceFile);
var targetVals = targetDoc.Element("root").Elements("data").ToSafeDictionary(c => c.Attribute("name").Value, inf.TargetFile);
bool updated = false;
foreach (var item in sourceVals)
{
if (!targetVals.ContainsKey(item.Key))
{
updated = true;
insertTarget.AddAfterSelf(new XElement(item.Value));
}
}
if (updated)
{
targetDoc.Save(inf.TargetFile);
}
}
}
else
{
if (inf.IsForm)
{
using (System.IO.StreamWriter sw = new System.IO.StreamWriter(inf.TargetFile))
sw.Write(Properties.Resources.Empty_resx);
}
else
{
if (Duplicati.Library.Utility.Utility.IsClientLinux)
{
var doc = XDocument.Load(inf.SourceFile);
var entries = from x in doc.Element("root").Elements("data")
where
x.Attribute("type") != null
&&
x.Attribute("type").Value == "System.Resources.ResXFileRef, System.Windows.Forms"
select x;
foreach (var e in entries)
{
string name = e.Element("value").Value;
int ixpos = name.IndexOf(";");
string path = name.Substring(0, ixpos);
path = path.Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString());
e.Element("value").Value = path + name.Substring(ixpos);
}
doc.Save(inf.TargetFile);
}
else
{
System.IO.File.Copy(inf.SourceFile, inf.TargetFile);
}
}
}
foreach (var item in from y in
(from x in XDocument.Load(inf.SourceFile).Element("root").Elements("data")
where
x.Attribute("type") != null
&&
x.Attribute("type").Value == "System.Resources.ResXFileRef, System.Windows.Forms"
select x)
let relname = y.Element("value").Value.Substring(0, y.Element("value").Value.IndexOf(";"))
let sourceRes = System.IO.Path.GetFullPath(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(inf.SourceFile), relname)).Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString())
let targetRes = System.IO.Path.GetFullPath(System.IO.Path.Combine(System.IO.Path.GetDirectoryName(inf.TargetFile), relname)).Replace("\\", System.IO.Path.DirectorySeparatorChar.ToString())
select new { sourceRes, targetRes }
)
{
if (!System.IO.Directory.Exists(System.IO.Path.GetDirectoryName(item.targetRes)))
{
System.IO.Directory.CreateDirectory(System.IO.Path.GetDirectoryName(item.targetRes));
}
if (!System.IO.File.Exists(item.targetRes))
{
if (Duplicati.Library.Utility.Utility.IsClientLinux && !System.IO.File.Exists(item.sourceRes))
{
string basefolder = System.IO.Path.GetDirectoryName(item.sourceRes);
string sourcefile = System.IO.Directory.GetFiles(basefolder).FirstOrDefault(x => item.sourceRes.Equals(x, StringComparison.InvariantCultureIgnoreCase));
if (sourcefile == null)
{
Console.WriteLine("Source file not found: " + item.sourceRes);
}
else
{
System.IO.File.Copy(sourcefile, item.targetRes);
}
}
else
{
System.IO.File.Copy(item.sourceRes, item.targetRes);
}
}
}
}
string batchfilename = System.IO.Path.Combine(System.IO.Path.Combine(Application.StartupPath, culture), "gui update.bat");
System.IO.File.WriteAllText(batchfilename, Properties.Resources.Batchjob_bat, System.Text.Encoding.Default);
}
}
public XDocument GetInvoice(int customerID, int orderID)
{
customer = rep.GetCustomer(customerID);
order = rep.GetQuickBooksOrder(false, orderID);
requestID = order.RequestID;
List <KeyValuePair <int, string> > orderLineItem_itemNames = new List <KeyValuePair <int, string> >();
var lineItems = rep.GetOrderLineItems(orderID);
foreach (var item in lineItems)
{
var shopItem = rep.GetShopInventoryItems(order.ClientID).Where(i => i.Name == item.InventoryName).FirstOrDefault();
if (shopItem == null)
{
if (order.Client.IsContentEditsShop ?? false)
{
WebShopInventory.GetCeInventory(rep.GetUser(order.Client.webpages_Memberships.FirstOrDefault().UserID));
shopItem = rep.GetShopInventoryItems(order.ClientID).Where(i => i.Name == item.InventoryName).FirstOrDefault();
}
}
var exists = shopItem != null && shopItem.QuickbooksInventoryID != null;
if (!exists)
{
var qbItem = rep.GetQuickbooksInventoryItem(item.InventoryName, order.ClientID);
if (qbItem != null && shopItem != null)
{
shopItem.QuickbooksInventoryID = qbItem.QuickbooksInventoryID;
rep.Save();
orderLineItem_itemNames.Add(new KeyValuePair <int, string>(item.LineItemID, qbItem.FullName));
}
else
{
itemsExist = false;
missingInventoryItem = item.InventoryName;
}
}
else
{
orderLineItem_itemNames.Add(new KeyValuePair <int, string>(item.LineItemID, shopItem.QuickbooksInventory.FullName));
}
}
if (itemsExist)
{
doc = new XDocument(
new XDeclaration("1.0", "utf-8", null),
new XProcessingInstruction("qbxml", "version=\"6.0\""),
new XElement("QBXML",
new XElement("QBXMLMsgsRq", new XAttribute("onError", "stopOnError"),
new XElement("InvoiceAddRq",
new XAttribute("requestID", requestID),
new XElement("InvoiceAdd",
new XElement("CustomerRef",
new XElement("FullName", Name)),
new XElement("TxnDate", String.Format("{0:yyyy-MM-dd}", DateTime.Now)),
new XElement("BillAddress",
new XElement("Addr1", FirstName + " " + LastName),
new XElement("Addr2", BillAddress1),
new XElement("Addr3", BillAddress2),
new XElement("City", BillCity),
new XElement("State", BillState),
new XElement("PostalCode", BillPostalCode),
new XElement("Country", BillCountry)),
new XElement("ShipAddress",
new XElement("Addr1", S_firstname + " " + S_lastname),
new XElement("Addr2", ShipAddress1),
new XElement("Addr3", ShipAddress2),
new XElement("City", ShipCity),
new XElement("State", ShipState),
new XElement("PostalCode", ShipPostalCode),
new XElement("Country", ShipCountry)),
new XElement("ItemSalesTaxRef",
new XElement("FullName", TaxFullName)
)
)
)
)
)
);
var customerNode = doc.LastNode.Document.Descendants().Where(n => n.Name == "CustomerRef").SingleOrDefault();
var salesTaxNode = doc.LastNode.Document.Descendants().Where(n => n.Name == "ItemSalesTaxRef").SingleOrDefault();
foreach (var item in lineItems)
{
(lastLineItemNode == null ? salesTaxNode : lastLineItemNode).AddAfterSelf(
new XElement("InvoiceLineAdd",
new XElement("ItemRef",
new XElement("FullName", orderLineItem_itemNames.Where(o => o.Key == item.LineItemID).FirstOrDefault().Value)), //Mapped Value from Quickbooks Inventory//item.InventoryName)),
new XElement("Desc", item.FullDescription),
new XElement("Quantity", item == null ? 1 : item.Quantity),
new XElement("Rate", ((decimal)item.PriceEach).ToString("N2")),
new XElement("Amount", ((decimal)(item.Quantity * item.PriceEach)).ToString("N2"))
)
);
}
if (ClassRef != null && ClassRef != String.Empty)
{
customerNode.AddAfterSelf(
new XElement("ClassRef",
new XElement("FullName", ClassRef)
)
);
}
if (TemplateRef != null && TemplateRef != String.Empty)
{
var element = doc.LastNode.Document.Descendants().Where(n => n.Name == "ClassRef").SingleOrDefault() == null ? customerNode : doc.LastNode.Document.Descendants().Where(n => n.Name == "ClassRef").SingleOrDefault();
element.AddAfterSelf(
new XElement("TemplateRef",
new XElement("FullName", TemplateRef)
)
);
}
lastLineItemNode.AddAfterSelf(
new XElement("InvoiceLineAdd",
new XElement("ItemRef",
new XElement("FullName", ShippingFullName)),
new XElement("Desc", "Shipping"),
new XElement("Amount", Shipping)
)
);
}
else //Query Quickbooks to see if the inventory Item Exists
{
doc = Inventory.ItemQuery(requestID, missingInventoryItem);
}
order.RequestXML = doc.ToString();
rep.Save();
return(doc);
}
public static void ConvertToXml(FileStream animFile, FileStream xmlFile)
{
using (TextReader reader = new StreamReader(animFile))
{
XDocument XDoc = new XDocument(new XElement("AnimFile"));
XNode elem = XDoc.FirstNode;
string line;
bool nextLevel = false;
while ((line = reader.ReadLine()) != null)
{
if (string.IsNullOrEmpty(line) || string.IsNullOrWhiteSpace(line))
{
continue;
}
line = line.Trim();
if (line.StartsWith("//") || line.StartsWith("*/") || line.StartsWith("/*"))
{
if ((elem.Parent == null || nextLevel) && elem is XElement)
{
((XElement)elem).Add(new XComment(line));
}
else
{
elem.AddAfterSelf(new XComment(line));
elem = elem.NextNode;
}
}
else if (line == "{")
{
nextLevel = true;
}
else if (line == "}")
{
elem = elem.Parent;
}
else
{
int spaceIndex = line.IndexOf(' ');
string function;
string data = string.Empty;
if (spaceIndex == -1)
{
function = line;
}
else
{
function = line.Substring(0, spaceIndex);
data = line.Substring(++spaceIndex);
}
if ((elem.Parent == null || nextLevel) && elem is XElement)
{
((XElement)elem).Add(new XElement(function));
elem = ((XElement)elem).LastNode;
nextLevel = false;
}
else
{
elem.AddAfterSelf(new XElement(function));
elem = elem.NextNode;
}
if (spaceIndex == -1)
{
continue;
}
if (function.Equals("tag", StringComparison.InvariantCultureIgnoreCase) |
function.Equals("connect", StringComparison.InvariantCultureIgnoreCase) |
function.Equals("length", StringComparison.InvariantCultureIgnoreCase) |
function.Equals("replacetexture", StringComparison.InvariantCultureIgnoreCase) |
function.StartsWith("v", StringComparison.InvariantCultureIgnoreCase))
{
((XElement)elem).Value = data;
}
else
{
((XElement)elem).Add(new XAttribute("data", data));
}
}
}
XmlWriterSettings settings = new XmlWriterSettings
{
Indent = true,
IndentChars = AnimFile.IndentString,
};
using (XmlWriter writer = XmlWriter.Create(xmlFile, settings))
{
XDoc.Save(writer);
}
}
}
