public static XElement GetNewStyleTargetElement(IEnumerable <XElement> propertyGroups)
{
var singleTarget = propertyGroups.Descendants().FirstOrDefault(node => node.Name.LocalName == "TargetFramework");
var multiTarget = propertyGroups.Descendants().FirstOrDefault(node => node.Name.LocalName == "TargetFrameworks");
return(singleTarget ?? multiTarget);
}
static void RemoveUnwantedElements(IEnumerable <XElement> members)
{
string[] tagsSupportedByIntellisense =
{
"summary",
"param",
"returns",
"exception",
};
string[] tagsToStrip =
{
"a",
"img",
};
RemoveElements(from member in members
from element in member.Elements()
where !tagsSupportedByIntellisense.Contains(element.Name.LocalName, StringComparer.OrdinalIgnoreCase)
select element);
RemoveElements(from element in members.Descendants()
where IsMarkedToSkip(element)
select element);
StripElements(from element in members.Descendants()
where tagsToStrip.Contains(element.Name.LocalName, StringComparer.OrdinalIgnoreCase)
select element);
}
public void btnSave_Click(object sender, EventArgs e)
{
if (tbTestName.Text == "")
{
MessageBox.Show("You must enter a test name");
}
else
{
string AutomationVersion = FileVersionInfo.GetVersionInfo(Process.GetCurrentProcess().MainModule.FileName).FileVersion;
SqlCommand SaveTest = new SqlCommand("INSERT INTO TestCase (Name,Type_ID) Values(@Name,@Type_ID); SELECT SCOPE_IDENTITY();", conn);
SaveTest.Parameters.AddWithValue("@Name", tbTestName.Text);
SaveTest.Parameters.AddWithValue("@Type_ID", SelectedTest_ID);
SqlCommand AutoVersion = new SqlCommand("SELECT AutoVer_ID FROM AutoVersion WHERE AutomationVersion = @FileVersion", conn);
AutoVersion.Parameters.AddWithValue("@FileVersion", AutomationVersion);
conn.Open();
Test_ID = Convert.ToInt32(SaveTest.ExecuteScalar());
SqlDataAdapter AutoDA = new SqlDataAdapter(AutoVersion);
AutoDA.Fill(AutomationIDs);
if (AutomationIDs.Rows.Count == 0)
{
SqlCommand AddAutoVersion = new SqlCommand("INSERT INTO AutoVersion (AutomationVersion) VALUES(@FileVersion); SELECT SCOPE_IDENTITY();", conn);
AddAutoVersion.Parameters.AddWithValue("@FileVersion", AutomationVersion);
AutoVer_ID = Convert.ToInt32(AddAutoVersion.ExecuteScalar());
}
else
{
AutoVer_ID = Convert.ToInt32(AutomationIDs.Rows[0][0]);
}
conn.Close();
foreach (var TestParameter in TestParameters.Descendants())
{
if (TestParameter.Name == "type")
{
TestParameter.Value = "performance";
}
if (TestParameter.Name == "test_ID")
{
TestParameter.Value = Test_ID.ToString();
}
if (TestParameter.Name == "autoVer_ID")
{
TestParameter.Value = AutoVer_ID.ToString();
}
}
xdoc.Save("test.config");
Global.IsPerformanceTest = true;
DataRowView vSelectedRow = (DataRowView)cbxTestType.SelectedItem;
DataRow SelectedRow = vSelectedRow.Row;
this.Close();
}
}
protected List <KeyValuePair <string, ArrayList> > ParseExecuteDVMXMLA(XDocument doc, string var1, string var2)
{
List <KeyValuePair <string, ArrayList> > keyValueList = new List <KeyValuePair <string, ArrayList> >();
XNamespace xmlnsa = "http://schemas.xmlsoap.org/soap/envelope/";
XNode xmlBody = doc.Descendants(xmlnsa + "Body").First().FirstNode;
doc = XDocument.Parse(xmlBody.ToString());
xmlnsa = "urn:schemas-microsoft-com:xml-analysis";
xmlBody = doc.Descendants(xmlnsa + "ExecuteResponse").First().FirstNode;
doc = XDocument.Parse(xmlBody.ToString());
xmlnsa = "urn:schemas-microsoft-com:xml-analysis:rowset";
XElement root = doc.Root;
IEnumerable <XElement> elements = root.Elements();
//ArrayList catalogList = new ArrayList();
IEnumerable <XElement> folderlist = from item in elements.Descendants(xmlnsa + var1) select item;
IEnumerable <XElement> measurelist = from item in elements.Descendants(xmlnsa + var2) select item;
var enumerator1 = folderlist.GetEnumerator();
var enumerator2 = measurelist.GetEnumerator();
XElement group, mValue;
string groupName, curValue, prevGroup;
prevGroup = "";
ArrayList valueList = new ArrayList();
while (enumerator1.MoveNext() && enumerator2.MoveNext())
{
group = enumerator1.Current;
mValue = enumerator2.Current;
groupName = group.Value.ToString();
groupName = groupName.Replace("[", "");
groupName = groupName.Replace("]", "");
curValue = mValue.Value.ToString();
if (prevGroup != groupName && prevGroup != "")
{
valueList.Sort();
keyValueList.Add(new KeyValuePair <string, ArrayList>(prevGroup, valueList));
valueList = new ArrayList();
}
valueList.Add(curValue);
prevGroup = groupName;
}
valueList.Sort();
keyValueList.Add(new KeyValuePair <string, ArrayList>(prevGroup, valueList));
//foreach (var entry in keyValueList)
//{
// System.Diagnostics.Debug.WriteLine("\n\tKey: " + entry.Key);
// foreach (var mes in entry.Value)
// System.Diagnostics.Debug.WriteLine("\t" + mes);
//}
return(keyValueList);
}
private static double GetTemperature(IEnumerable <XElement> actual)
{
//all mins for day
var minT = actual.Descendants("t").Descendants("min").Select(n => Convert.ToDouble(n.Value));
//all maxes for day
var maxT = actual.Descendants("t").Descendants("max").Select(n => Convert.ToDouble(n.Value)).ToList();
maxT.AddRange(minT);
return(maxT.Sum() / maxT.Count);
}
public static IEnumerable <XElement> Descendants(this IEnumerable <XContainer> container, XName name, bool ignoreNamespace)
{
if (ignoreNamespace)
{
return(container.Descendants().Where(e => e.Name.LocalName == name.LocalName));
}
else
{
return(container.Descendants(name));
}
}
static void Listing8_12()
{
Console.WriteLine("{0} : Begin", new StackTrace(0, true).GetFrame(0).GetMethod().Name);
XDocument xDocument = new XDocument(
new XElement("BookParticipants",
new XElement("BookParticipant",
new XAttribute("type", "Author"),
new XComment("This is a new author."),
new XElement("FirstName", "Joe"),
new XElement("LastName", "Rattz")),
new XElement("BookParticipant",
new XAttribute("type", "Editor"),
new XElement("FirstName", "Ewan"),
new XElement("LastName", "Buckingham"))));
IEnumerable <XElement> elements =
xDocument.Element("BookParticipants").Elements("BookParticipant");
// First, I will display the source elements.
foreach (XElement element in elements)
{
Console.WriteLine("Source element: {0} : value = {1}",
element.Name, element.Value);
}
// Now, I will display each source element's descendant elements.
foreach (XElement element in elements.Descendants("LastName"))
{
Console.WriteLine("Descendant element: {0}", element);
}
Console.WriteLine("{0} : End", new StackTrace(0, true).GetFrame(0).GetMethod().Name);
}
private void LookInModulesSection(String filename, XDocument configFile, out Boolean continueToNextFile)
{
// Find files with references in the Modules Section
continueToNextFile = false;
IEnumerable <XElement> modulesSectionElement = configFile.Descendants().Where(d => d.Name.LocalName == "ModulesSection");
foreach (XElement classElement in modulesSectionElement.Descendants().Elements().Where(x => x.Name.LocalName == "Class"))
{
XAttribute typeNameAttribute = classElement.Attributes()
.Where(x => x.Name.LocalName == "typeName")
.FirstOrDefault();
if (IsFrameworkAttribute(typeNameAttribute))
{
AddFileWithFrameworkReferences(filename);
continueToNextFile = true;
break;
}
if (continueToNextFile)
{
break;
}
}
}
public static void ProcessTasks(IEnumerable <XElement> section, ILog log)
{
log.Info("Processing tasks....");
foreach (var element in section.Descendants())
{
var definition = element.Attribute("definition").Value;
switch (definition)
{
case Constants.Performance.CPUUSAGETOTAL:
Performance.GetCpuUsage();
break;
case Constants.Performance.DISKUSUAGETOTAL:
Performance.GetDiskUsage();
break;
case Constants.Performance.RAMUSUAGETOTAL:
Performance.GetAvailableRam();
break;
default:
log.InfoFormat("Task type not implemented ({0}). Check the task list.", definition);
break;
}
}
}
private static IEnumerable <Ziel> getZiele(IEnumerable <XElement> zielliste)
{
List <Ziel> ziele = new List <Ziel>();
IEnumerable <XElement> de =
from el in zielliste.Descendants()
where el.Name.LocalName == "Text"
select el;
foreach (XElement el in de)
{
ziele.Add(new Ziel(el.Value));
}
Console.WriteLine("Ziele gefunden:");
foreach (Ziel currentziel in ziele)
{
Console.WriteLine(currentziel.getName());
}
return(ziele);
}
// Return the questions with quizID and quizType
//QuizType: Multiple Choice, Identification, Enumeration
public List <string> getQuestions(string quizID, string quizType)
{
List <string> questions = new List <string>();
XDocument xDoc = new XDocument();
xDoc = XDocument.Load(@"Quizzard.xml");
XElement root = XElement.Load(@"Quizzard.xml");
IEnumerable <XElement> address =
from el in root.Elements("Quiz")
where (string)el.Attribute("id") == quizID
where (string)el.Attribute("type") == quizType
select el;
foreach (XElement el in address.Descendants("Item").Elements())
{
if (el.Name == "Question")
{
questions.Add(el.Value);
}
}
return(questions);
}
//Returns the list of hints for Identification having provided the quizID
public List <string> getIdentifcationHints(string quizID)
{
List <string> answers = new List <string>();
XDocument xDoc = new XDocument();
xDoc = XDocument.Load(@"Quizzard.xml");
XElement root = XElement.Load(@"Quizzard.xml");
IEnumerable <XElement> address =
from el in root.Elements("Quiz")
where (string)el.Attribute("id") == quizID
where (string)el.Attribute("type") == "Identification"
select el;
//Get the Element Item
foreach (XElement el in address.Descendants("Item").Elements())
{
if (el.Name == "Hint")
{
answers.Add(el.Value);
}
}
return(answers);
}
//Returns a list of lists of alternate answers for identification
public List <List <string> > getIdentificationAlternateAnswers(string quizID)
{
List <List <string> > inAnswers = new List <List <string> >();
List <string> outAnswers = new List <string>();
XDocument xDoc = new XDocument();
xDoc = XDocument.Load(@"Quizzard.xml");
XElement root = XElement.Load(@"Quizzard.xml");
IEnumerable <XElement> address =
from el in root.Elements("Quiz")
where (string)el.Attribute("id") == quizID
where (string)el.Attribute("type") == "Identification"
select el;
//Get the Element of Quiz
foreach (XElement el in address.Descendants("Item"))
{
//Get the element of Item
foreach (XElement val in el.Elements())
{
if (val.Name == "Alternate-Answer")
{
outAnswers.Add(val.Value);
}
}
inAnswers.Add(outAnswers);
outAnswers = new List <string>();
}
return(inAnswers);
}
public string parse(string test, string propertyName)
{
IEnumerable <XElement> e = from el in doc.Descendants(test) select el;
string parseStr = e.Descendants(propertyName).First().Value;
if (parseStr.Length > 0)
{
switch (propertyName)
{
case "author":
author = parseStr;
break;
case "dateTime":
dateTime = parseStr;
break;
case "testDriver":
testDriver = parseStr;
break;
default:
break;
}
return(parseStr);
}
return("");
}
private bool AddStartListener(XElement extElem)
{
Type runListenerType = typeof(RuntimeAssigneeExecutionListener);
XElement startListener = (from x in extElem.Descendants(XName.Get(BpmnXMLConstants.ELEMENT_EXECUTION_LISTENER, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE))
where
BaseExecutionListenerFields.EVENTNAME_START.Equals(x.Attribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_EVENT)?.Value, StringComparison.OrdinalIgnoreCase) &&
(x.Attribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_CLASS)?.Value.Contains(runListenerType.FullName)).GetValueOrDefault()
select x).FirstOrDefault();
if (startListener != null)
{
return(false);
}
IEnumerable <XElement> eProps = extElem.Descendants(XName.Get(BpmnXMLConstants.ELEMENT_EXTENSIONS_PROPERTIES, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE));
XElement assignee = (from x in eProps.Descendants(XName.Get(BpmnXMLConstants.ELEMENT_EXTENSIONS_PROPERTY, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE))
where BpmnXMLConstants.ACTIITI_RUNTIME_ASSIGNEE.Equals(x.Attribute(BpmnXMLConstants.ATTRIBUTE_DATA_NAME)?.Value, StringComparison.OrdinalIgnoreCase)
select x).FirstOrDefault();
if (assignee != null && bool.TryParse(assignee.Attribute(BpmnXMLConstants.ELEMENT_DATA_VALUE)?.Value, out bool isRuntime) && isRuntime)
{
startListener = new XElement(XName.Get(BpmnXMLConstants.ELEMENT_EXECUTION_LISTENER, BpmnXMLConstants.ACTIVITI_EXTENSIONS_NAMESPACE),
new XAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_CLASS, $"{runListenerType.FullName},{runListenerType.Assembly.GetName().Name}"),
new XAttribute(BpmnXMLConstants.ATTRIBUTE_LISTENER_EVENT, BaseExecutionListenerFields.EVENTNAME_START));
extElem.Add(startListener);
return(true);
}
return(false);
}
private void Show_Click(object sender, RoutedEventArgs e)
{
//02-Jun-18 15:40:53
DateTime dateTimeStart = DateTime.ParseExact(textBoxStart.Text, "dd-MMM-yy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None);
DateTime dateTimeEnd = DateTime.ParseExact(textBoxEnd.Text, "dd-MMM-yy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None);
string path = "../../../AMS/bin/Debug/Controllers/ams.xml";
XDocument doc = XDocument.Load(path);
IEnumerable <XElement> elements = (from el in doc.Descendants("device") where (string)el.Attribute("code").Value == textBoxLD.Text.ToString() select el); //ovde su svi device
IEnumerable <XElement> values = (from el in elements.Descendants("value") select el); //ovde su sve vrednosti
foreach (XElement xe in values)
{
if (DateTime.ParseExact(xe.FirstAttribute.Value, "dd-MMM-yy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None) >= dateTimeStart && DateTime.ParseExact(xe.FirstAttribute.Value, "dd-MMM-yy HH:mm:ss", new CultureInfo("en-US"), DateTimeStyles.None) <= dateTimeEnd)
{
ListaVrednosti.Add("Value: " + xe.Value + " time: " + xe.FirstAttribute.Value); //ovde ubacujemo one vrednosti koje upadaju u vreme izmedju
}
}
textBoxReport.Text = String.Join(Environment.NewLine, ListaVrednosti);
ListaVrednosti.Clear();
doc.Save(path);
}
public XElement[] SortOrdersByDate(IEnumerable <XElement> elements)
{
var sortedItems = elements.Descendants("Order")
.OrderBy(item => DateTime.Parse(item.Element("OrderDate")?.Value)).ToArray();
return(sortedItems);
}
/// <summary>
/// Reads the element and converts it to a integer
/// </summary>
/// <param name="x"></param>
/// <param name="parent"></param>
/// <param name="element"></param>
/// <returns></returns>
private static int ConvertStringIntervalToInteger(ref IEnumerable <XElement> x, string parent, string element)
{
return(int.Parse(x.Descendants(parent)
.Elements(element)
.FirstOrDefault()
.Value));
}
private static void DoSubStructureInsertAfter(XElement[] structureElementsFound, Saetning saetning,
IEnumerable <XElement> aendringAktionChange)
{
foreach (var xElement in structureElementsFound)
{
var punktumPerCharMap = xElement.Descendants("Char")
.Select(charElement => new
{
Char = charElement,
NumberOfPunktum = charElement.Value.Count(c => c == '.')
});
int acc = 0;
XElement targetChar = null;
using (var enumerator = punktumPerCharMap.GetEnumerator())
{
while (acc <= saetning.NummerStrong && enumerator.MoveNext())
{
acc = acc + enumerator.Current.NumberOfPunktum;
targetChar = enumerator.Current.Char;
}
}
if (targetChar == null)
{
throw new ApplyAendringerException("No char elemenet is found. Something is wrong.");
}
var targetLinea = targetChar.Parent;
targetLinea.AddAfterSelf(aendringAktionChange.Descendants("Linea"));
}
}
/// <summary>
/// Прочитать конфиг файл
/// </summary>
/// <param name="document">XML документ</param>
/// <returns>Результат чтения</returns>
private XmlConfigReadingResult ReadConfigurationFile(XDocument document)
{
var readingResult = new XmlConfigReadingResult();
IEnumerable <XElement> directoryElements = document.Descendants("directory").ToList();
if (directoryElements.Any())
{
String directoryDimensionStr = directoryElements.First().AttributeSafe("dimension");
String directorySourceColorStr = directoryElements.First().AttributeSafe("sourceColor");
String directoryColorStr = directoryElements.First().AttributeSafe("color");
String directoryWidthStr = directoryElements.First().AttributeSafe("width");
String directoryHightStr = directoryElements.First().AttributeSafe("height");
String directoryUnitTypeStr = directoryElements.First().AttributeSafe("unitType");
readingResult.ConfigDirectoryInfo = new XmlConfigDirectoryInfo()
{
Dimension = directoryDimensionStr,
SourceColor = ParseColorStr(directorySourceColorStr),
Color = ParseColorStr(directoryColorStr),
Size = ParseSizeStr(directoryWidthStr, directoryHightStr),
SizeUnitType = ParseSizeUnitTypeStr(directoryUnitTypeStr)
};
IEnumerable <XElement> fileConfigElements = directoryElements.Descendants("file").ToList();
foreach (var fileConfigElement in fileConfigElements)
{
String fileNameStr = fileConfigElement.AttributeSafe("name");
String fileDimensionStr = fileConfigElement.AttributeSafe("dimension");
String fileSourceColorStr = fileConfigElement.AttributeSafe("sourceColor");
String fileColorStr = fileConfigElement.AttributeSafe("color");
String fileWidthStr = fileConfigElement.AttributeSafe("width");
String fileHightStr = fileConfigElement.AttributeSafe("height");
String fileUnitTypeStr = fileConfigElement.AttributeSafe("unitType");
if (!String.IsNullOrEmpty(fileNameStr))
{
readingResult.ConfigFileInfoCollection.Add(new XmlConfigFileInfo()
{
FileName = fileNameStr,
Dimension = fileDimensionStr,
SourceColor = ParseColorStr(fileSourceColorStr),
Color = ParseColorStr(fileColorStr),
Size = ParseSizeStr(fileWidthStr, fileHightStr),
SizeUnitType = ParseSizeUnitTypeStr(fileUnitTypeStr)
});
}
else
{
readingResult.ConfigErrorCollection.Add(new XmlConfigError(fileConfigElement.ToString(), "Ошибка разбора полей для файла"));
}
}
}
else
{
readingResult.ConfigErrorCollection.Add(new XmlConfigError(directoryElements.ToString(), "Ошибка разбора полей для директории"));
}
return(readingResult);
}
private void convertParameterValueCacheElement(IEnumerable <XElement> parameterValueCacheElement)
{
foreach (var percentilesListElement in parameterValueCacheElement.Descendants("DoubleList").ToList())
{
percentilesListElement.Name = Constants.Serialization.PERCENTILES;
}
}
static string getListOfValues(IEnumerable <XElement> list, string key, string subTag)
{
if (list.Count() == 0)
{
return("");
}
StringBuilder builder = new StringBuilder();
var epcs = list.Descendants(subTag);
if (epcs.Count() > 0)
{
builder.Append(key + "=");
}
int n = 0;
int tot = epcs.Count();
foreach (var epc in epcs)
{
builder.Append(ComputeSha256Hash(epc.Value));
if (n < (tot - 1))
{
builder.Append(",");
}
n++;
}
return(builder.ToString());
}
public void Load(IEnumerable <XElement> tilesToLoad)
{
var availableItems = AvailableItems.Instance;
var availableMobiles = AvailableMobiles.Instance;
Mobile mobile = null;
Item item = null;
foreach (XElement tile in tilesToLoad.Descendants("Tile"))
{
var top = Int32.Parse(tile.Element("Location").Element("Top").Value);
var left = Int32.Parse(tile.Element("Location").Element("Left").Value);
var tileTypeId = Int32.Parse(tile.Element("TypeId").Value);
mobile = null;
if (!string.IsNullOrEmpty(tile.Element("Mobile").Value))
{
mobile = availableMobiles.GetMobileById((Int32.Parse(tile.Element("Mobile").Element("TypeId").Value)));
mobile.Load(tile.Element("Mobile"));
}
item = null;
if (!string.IsNullOrEmpty(tile.Element("Item").Value))
{
item = availableItems.GetItemById((Int32.Parse(tile.Element("Item").Element("ItemId").Value)));
item.Load(tile.Element("Item"));
}
Tiles.Add(new Tile {
Location = new Location(left, top), TypeId = tileTypeId, Mobile = mobile, Item = item
});
}
}
/// <summary>
/// This method is used to verify the attributes of the xml file’s root element
/// </summary>
/// <returns>If the attributes match up. True or False</returns>
private bool processHeader()
{
bool validated = true;
try
{
long checkSumNumber = 0;
string today = DateTime.Today.ToShortDateString();
XDocument xmlFile = XDocument.Load(inputFileName);
XElement studentUpdate = xmlFile.Element("student_update");
IEnumerable <XElement> transactions = studentUpdate.Descendants().Where(x => x.Name == "transaction");
IEnumerable <XElement> studentNumbers = transactions.Descendants().Where(x => x.Name == "student_no");
foreach (XElement value in studentNumbers)
{
checkSumNumber += long.Parse(value.Value);
}
if (studentUpdate.Attributes().Count() != 3)
{
throw new Exception("There is not 3 attributes");
}
string date = studentUpdate.Attribute("date").Value;
DateTime time = DateTime.Parse(date);
if (date != today)
{
throw new Exception("The date does not match");
}
string xmlAcro = studentUpdate.Attribute("program").Value;
if (db.Programs.Where(x => x.ProgramAcronym.Equals(xmlAcro)).Count() != 1)
{
throw new Exception("The program acronym does not match");
}
string xmlCheckSum = studentUpdate.Attribute("checksum").Value;
if (long.Parse(xmlCheckSum) != checkSumNumber)
{
throw new Exception("The checksum numbers do not match");
}
}
catch (Exception ex)
{
logData += ex.Message;
validated = false;
}
return(validated);
}
private void saveDataToJsonFile(bool original, string filename, XDocument doc)
{
string path = (original) ? (FolderDispatcher.OriginalPath()) : (FolderDispatcher.TranslationPath());
System.IO.Stream stream;
stream = File.Open(path + filename, FileMode.Create);
var jsonWriter = JsonReaderWriterFactory.CreateJsonWriter(stream, Encoding.UTF8, true, true);
jsonWriter.WriteStartDocument();
jsonWriter.WriteStartElement("root");
jsonWriter.WriteAttributeString("type", "object");
IEnumerable <XElement> elements = doc.Root.Elements().ToList();
foreach (XElement chapter in elements)
{
jsonWriter.WriteStartElement(chapter.Name.ToString());
jsonWriter.WriteAttributeString("type", "object");
foreach (XElement element in elements.Descendants())
{
jsonWriter.WriteElementString(element.Name.ToString(), element.GetDefaultNamespace().ToString(), element.Value);
}
}
jsonWriter.WriteEndDocument();
jsonWriter.Flush();
stream.Close();
}
public static void labelingHospital(IEnumerable <XElement> traces)
{
//Labeling Hospital:
//If Name of any event in trace contains "spoed" (= "urgent") mark as urgent
foreach (var trace in traces)
{
int iTraceIsUrgent = 2;
var elems_EventName = trace.Elements("event").Elements().Where(x => (string)x.Attribute("key") == "concept:name");
foreach (var el in elems_EventName)
{
if (el.Attribute("value").Value.Contains("spoed"))
{
iTraceIsUrgent = 1;
break;
}
}
trace.SetAttributeValue("Label", iTraceIsUrgent.ToString());
}
var dateTranslation = traces.Descendants().Where(x => x.Name.LocalName == "date");
foreach (var dateTr in dateTranslation)
{
string val = dateTr.Attribute("value").Value;
val = val.Substring(0, 23).Replace('T', ' ');
DateTime myDate = DateTime.ParseExact(val, "yyyy-MM-dd HH:mm:ss.fff",
System.Globalization.CultureInfo.InvariantCulture);
dateTr.Attribute("value").Value = myDate.Ticks.ToString();
}
}
public ObservableCollection <CoreTeams> GetSelectedHomeTeams(string number)
{
ObservableCollection <CoreTeams> homeTeams = new ObservableCollection <CoreTeams>();
try
{
XElement root = XDocument.Load("Schedule.xml").Root;
IEnumerable <XElement> teams = root.Descendants("MatchUps");
var team = (from xml in teams.Descendants("Match")
where xml.Attribute("week").Value.Equals(number)
select xml);
foreach (CoreTeams away in team.
Select(t => CurrentSession.Teams.
FirstOrDefault(a => a.Tricode.Equals(t.Attribute("homeTeam").Value))))
{
homeTeams.Add(away);
}
return(homeTeams);
}
catch (Exception e)
{
//NotificationManager.Push("Error", "File cannot be found");
Console.WriteLine(e);
}
return(homeTeams);
}
protected void ParseDiscoverSchemaXMLA(XDocument doc)
{
XNamespace xmlnsa = "http://schemas.xmlsoap.org/soap/envelope/";
XNode xmlBody = doc.Descendants(xmlnsa + "Body").First().FirstNode;
doc = XDocument.Parse(xmlBody.ToString());
xmlnsa = "urn:schemas-microsoft-com:xml-analysis";
xmlBody = doc.Descendants(xmlnsa + "DiscoverResponse").First().FirstNode;
doc = XDocument.Parse(xmlBody.ToString());
xmlnsa = "urn:schemas-microsoft-com:xml-analysis:rowset";
XElement root = doc.Root;
IEnumerable <XElement> elements = root.Elements();
//ArrayList catalogList = new ArrayList();
catalogList = new ArrayList();
var list = from item in elements.Descendants(xmlnsa + "CATALOG_NAME") select item;
SchemaDropDownList.Items.Clear();
SchemaDropDownList.Items.Add("Choose");
foreach (var entry in list)
{
catalogList.Add(entry.Value.ToString());
//System.Diagnostics.Debug.WriteLine("\t"+entry.Value);
SchemaDropDownList.Items.Add(new ListItem(entry.Value.ToString()));
}
}
/// <summary>
/// Removes all <u [val=...]/> descendant elements from the <rPr [...]/> elements
/// and places a <pStyle val="CaptionFigure" /> on the <pPr [...]/> elements.
///
/// This method works on the existing <see cref="XElement"/> and returns a reference to it for a fluent syntax.
/// </summary>
/// <param name="element">The element to search for descendants.</param>
/// <returns>A reference to the existing <see cref="XElement"/>. This is returned for use with fluent syntax calls.</returns>
/// <exception cref="System.ArgumentException"/>
/// <exception cref="System.ArgumentNullException"/>
public static XElement ChangeUnderlineToFigureCaption(this XElement element)
{
IEnumerable <XElement> paragraphs =
element.Descendants(W + "u")
.Select(x => x.Parent)
.Where(x => x?.Name == W + "rPr")
.Select(x => x.Parent)
.Where(x => x?.Name == W + "r")
.Select(x => x.Parent)
.Where(x => x?.Name == W + "p")
.Where(x => (x.Next()?.DescendantsAndSelf().Any(y => y.Name == W + "drawing") ?? false) ||
(x.Next()?.Value.Contains('{') ?? false))
.Distinct()
.ToArray();
foreach (XElement item in paragraphs)
{
item.AddFigureCaption();
item.RemoveBy(W + "pStyle");
if (!item.Elements(W + "pPr").Any())
{
item.AddFirst(new XElement(W + "pPr"));
}
else
{
XElement pPr = item.Element(W + "pPr");
pPr?.Remove();
item.AddFirst(pPr);
}
item.Element(W + "pPr")?.AddFirst(new XElement(W + "pStyle", new XAttribute(W + "val", "CaptionFigure")));
}
paragraphs.Descendants(W + "u").Distinct().Remove();
return(element);
}
private void renameChartElementToCurveChart(IEnumerable <XElement> chartContainerElement)
{
foreach (var chartElement in chartContainerElement.Descendants("Chart").ToList())
{
rename(chartElement, "CurveChart");
}
}
protected Response GetBasicResponse(IEnumerable<XElement> root)
{
//populate the basic info
// and see if the response is successful
if (0 == root.Count()) {
root = _doc.Descendants(_namespace + "ErrorResponse");
}
var resultCode = root.Descendants(_namespace + "resultCode").First().Value;
var response = new Response
{
Success = resultCode == "Ok" ? true : false,
Message = root.Descendants(_namespace + "text").First().Value,
Code = root.Descendants(_namespace + "code").First().Value
};
return response;
}
protected XElement FindElementByAttributesFromElements(string attributeName, string attributeValue, IEnumerable<XElement> elements)
{
var descendants = elements
.Descendants();
var element = descendants
.Where(x => x.HasAttributes && x.Attribute(attributeName) != null)
.SingleOrDefault(x => x.Attribute(attributeName).Value == attributeValue);
return element;
}
public static string GetTableValue(IEnumerable<XElement> rows, string property)
{
string value;
XElement propertyCell = rows.Descendants("td").Where(cell => cell.Value == property).FirstOrDefault();
if (propertyCell != null)
{
var Row = propertyCell.Parent.Descendants("td").ElementAt(1);
return Row.Value.Trim();
}
else
{
return string.Empty;
}
}
private static void CopyComments(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs)
{
int number = 0;
XDocument oldComments = null;
XDocument newComments = null;
foreach (XElement comment in paragraphs.Descendants(ns + "commentReference"))
{
if (oldComments == null)
oldComments = oldDoc.MainDocumentPart.WordprocessingCommentsPart.GetXDocument();
if (newComments == null)
{
if (newDoc.MainDocumentPart.WordprocessingCommentsPart != null)
{
newComments = newDoc.MainDocumentPart.WordprocessingCommentsPart.GetXDocument();
var ids = newComments.Root.Elements(ns + "comment").Select(f => (int)f.Attribute(ns + "id"));
if (ids.Any())
number = ids.Max() + 1;
}
else
{
newDoc.MainDocumentPart.AddNewPart<WordprocessingCommentsPart>();
newComments = newDoc.MainDocumentPart.WordprocessingCommentsPart.GetXDocument();
newComments.Add(new XElement(ns + "comments", ns_attrs));
}
}
string id = (string)comment.Attribute(ns + "id");
XElement element = oldComments.Descendants().Elements(ns + "comment").Where(p => ((string)p.Attribute(ns + "id")) == id).First();
XElement newElement = new XElement(element);
newElement.Attribute(ns + "id").Value = number.ToString();
newComments.Root.Add(newElement);
comment.Attribute(ns + "id").Value = number.ToString();
XElement commentRange = paragraphs.Elements(ns + "commentRangeStart").Where(s => ((string)s.Attribute(ns + "id")) == id).FirstOrDefault();
if (commentRange != null)
commentRange.Attribute(ns + "id").Value = number.ToString();
commentRange = paragraphs.Elements(ns + "commentRangeEnd").Where(s => ((string)s.Attribute(ns + "id")) == id).FirstOrDefault();
if (commentRange != null)
commentRange.Attribute(ns + "id").Value = number.ToString();
number++;
}
}
private static void CopyHyperlinks(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs)
{
foreach (XElement hyperlink in paragraphs.Descendants(ns + "hyperlink"))
if (hyperlink.Attribute(ns_r + "id") != null)
{
string relId = hyperlink.Attribute(ns_r + "id").Value;
HyperlinkRelationship relLink = oldDoc.MainDocumentPart.HyperlinkRelationships.Where(rel => (rel.Id == relId)).FirstOrDefault();
HyperlinkRelationship newRelLink = newDoc.MainDocumentPart.AddHyperlinkRelationship(relLink.Uri, true);
hyperlink.Attribute(ns_r + "id").Value = newRelLink.Id;
}
foreach (XElement hyperlink in paragraphs.Descendants(ns_v + "imagedata"))
if (hyperlink.Attribute(ns_r + "href") != null)
{
string relId = hyperlink.Attribute(ns_r + "href").Value;
ExternalRelationship relLink = oldDoc.MainDocumentPart.ExternalRelationships.Where(rel => (rel.Id == relId)).FirstOrDefault();
ExternalRelationship newRelLink = newDoc.MainDocumentPart.AddExternalRelationship(relLink.RelationshipType, relLink.Uri);
hyperlink.Attribute(ns_r + "href").Value = newRelLink.Id;
}
}
private static void CopyEndnotes(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs)
{
int number = 0;
XDocument oldEndnotes = null;
XDocument newEndnotes = null;
foreach (XElement endnote in paragraphs.Descendants(ns + "endnoteReference"))
{
if (oldEndnotes == null)
oldEndnotes = oldDoc.MainDocumentPart.EndnotesPart.GetXDocument();
if (newEndnotes == null)
{
if (newDoc.MainDocumentPart.EndnotesPart != null)
{
newEndnotes = newDoc.MainDocumentPart.EndnotesPart.GetXDocument();
var ids = newEndnotes.Root.Elements(ns + "endnote").Select(f => (int)f.Attribute(ns + "id"));
if (ids.Any())
number = ids.Max() + 1;
}
else
{
newDoc.MainDocumentPart.AddNewPart<EndnotesPart>();
newEndnotes = newDoc.MainDocumentPart.EndnotesPart.GetXDocument();
newEndnotes.Add(new XElement(ns + "endnotes", ns_attrs));
}
}
string id = (string)endnote.Attribute(ns + "id");
XElement element = oldEndnotes.Descendants().Elements(ns + "endnote").Where(p => ((string)p.Attribute(ns + "id")) == id).First();
XElement newElement = new XElement(element);
newElement.Attribute(ns + "id").Value = number.ToString();
newEndnotes.Root.Add(newElement);
endnote.Attribute(ns + "id").Value = number.ToString();
number++;
}
}
private static void AppendDocument(this WordprocessingDocument doc, WordprocessingDocument source, IEnumerable<XElement> contents,
bool keepSection, bool lastKeepSection, List<ImageData> images)
{
FixRanges(source.MainDocumentPart.GetXDocument(), contents);
CopyReferences(source, doc, contents, images);
// Append contents
XDocument mainPart = doc.MainDocumentPart.GetXDocument();
XElement section = mainPart.Root.Element(ns + "body").Element(ns + "sectPr");
XElement newSection = contents.Last();
if (newSection.Name != ns + "sectPr")
newSection = null;
if (newSection == null)
keepSection = false;
bool newContainsSection = contents.Descendants(ns + "pPr").Descendants(ns + "sectPr").Any();
if (section != null)
{
section.Remove();
if (lastKeepSection)
{
if (newContainsSection || keepSection)
{
XElement paragraph = mainPart.Root.Element(ns + "body").Elements(ns + "p").Last();
XElement prop = paragraph.Element(ns + "pPr");
if (prop == null)
{
prop = new XElement(ns + "pPr");
paragraph.AddFirst(prop);
}
if (newContainsSection && !keepSection)
prop.Add(new XElement(section));
else
prop.Add(section);
}
}
else if (keepSection)
section = null;
}
mainPart.Root.Element(ns + "body").Add(contents);
if (!keepSection && section != null)
{
newSection = mainPart.Root.Element(ns + "body").Element(ns + "sectPr");
if (newSection != null)
newSection.Remove();
mainPart.Root.Element(ns + "body").Add(section);
}
}
private static void CopyCharts(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs)
{
foreach (XElement chartReference in paragraphs.Descendants(ns_c + "chart"))
{
string relId = chartReference.Attribute(ns_r + "id").Value;
ChartPart oldPart = (ChartPart)oldDoc.MainDocumentPart.GetPartById(relId);
XDocument oldChart = oldPart.GetXDocument();
ChartPart newPart = newDoc.MainDocumentPart.AddNewPart<ChartPart>();
XDocument newChart = newPart.GetXDocument();
newChart.Add(oldChart.Root);
chartReference.Attribute(ns_r + "id").Value = newDoc.MainDocumentPart.GetIdOfPart(newPart);
CopyChartObjects(oldPart, newPart);
}
}
private static void CopyEmbeddedObjects(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs)
{
foreach (XElement oleReference in paragraphs.Descendants(ns_o + "OLEObject"))
{
string relId = oleReference.Attribute(ns_r + "id").Value;
OpenXmlPart oldPart = oldDoc.MainDocumentPart.GetPartById(relId);
OpenXmlPart newPart = newDoc.MainDocumentPart.AddEmbeddedObjectPart(oldPart.ContentType);
using (Stream oldObject = oldPart.GetStream(FileMode.Open, FileAccess.Read))
using (Stream newObject = newPart.GetStream(FileMode.Create, FileAccess.ReadWrite))
{
int byteCount;
byte[] buffer = new byte[65536];
while ((byteCount = oldObject.Read(buffer, 0, 65536)) != 0)
newObject.Write(buffer, 0, byteCount);
}
oleReference.Attribute(ns_r + "id").Value = newDoc.MainDocumentPart.GetIdOfPart(newPart);
}
}
private static void CopyDiagrams(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs)
{
foreach (XElement diagramReference in paragraphs.Descendants(ns_dgm + "relIds"))
{
// dm attribute
string relId = diagramReference.Attribute(ns_r + "dm").Value;
OpenXmlPart oldPart = oldDoc.MainDocumentPart.GetPartById(relId);
OpenXmlPart newPart = newDoc.MainDocumentPart.AddNewPart<DiagramDataPart>();
newPart.GetXDocument().Add(oldPart.GetXDocument().Root);
diagramReference.Attribute(ns_r + "dm").Value = newDoc.MainDocumentPart.GetIdOfPart(newPart);
// lo attribute
relId = diagramReference.Attribute(ns_r + "lo").Value;
oldPart = oldDoc.MainDocumentPart.GetPartById(relId);
newPart = newDoc.MainDocumentPart.AddNewPart<DiagramLayoutDefinitionPart>();
newPart.GetXDocument().Add(oldPart.GetXDocument().Root);
diagramReference.Attribute(ns_r + "lo").Value = newDoc.MainDocumentPart.GetIdOfPart(newPart);
// qs attribute
relId = diagramReference.Attribute(ns_r + "qs").Value;
oldPart = oldDoc.MainDocumentPart.GetPartById(relId);
newPart = newDoc.MainDocumentPart.AddNewPart<DiagramStylePart>();
newPart.GetXDocument().Add(oldPart.GetXDocument().Root);
diagramReference.Attribute(ns_r + "qs").Value = newDoc.MainDocumentPart.GetIdOfPart(newPart);
// cs attribute
relId = diagramReference.Attribute(ns_r + "cs").Value;
oldPart = oldDoc.MainDocumentPart.GetPartById(relId);
newPart = newDoc.MainDocumentPart.AddNewPart<DiagramColorsPart>();
newPart.GetXDocument().Add(oldPart.GetXDocument().Root);
diagramReference.Attribute(ns_r + "cs").Value = newDoc.MainDocumentPart.GetIdOfPart(newPart);
}
}
private static void CopyCustomXml(WordprocessingDocument sourceDocument, WordprocessingDocument newDocument,
IEnumerable<XElement> newContent)
{
List<string> itemList = new List<string>();
foreach (string itemId in newContent
.Descendants(W.dataBinding)
.Select(e => e.Attribute(W.storeItemID).Value))
if (!itemList.Contains(itemId))
itemList.Add(itemId);
foreach (CustomXmlPart customXmlPart in sourceDocument.MainDocumentPart.CustomXmlParts)
{
OpenXmlPart propertyPart = customXmlPart
.Parts
.Select(p => p.OpenXmlPart)
.Where(p => p.ContentType == "application/vnd.openxmlformats-officedocument.customXmlProperties+xml")
.First();
XDocument propertyPartDoc = propertyPart.GetXDocument();
if (itemList.Contains(propertyPartDoc.Root.Attribute(DS.itemID).Value))
{
CustomXmlPart newPart = newDocument.MainDocumentPart.AddCustomXmlPart(customXmlPart.ContentType);
newPart.GetXDocument().Add(customXmlPart.GetXDocument().Root);
foreach (OpenXmlPart propPart in customXmlPart.Parts.Select(p => p.OpenXmlPart))
{
CustomXmlPropertiesPart newPropPart = newPart.AddNewPart<CustomXmlPropertiesPart>();
newPropPart.GetXDocument().Add(propPart.GetXDocument().Root);
}
}
}
}
/// <summary>
/// Reads the element and converts it to a integer
/// </summary>
/// <param name="x"></param>
/// <param name="parent"></param>
/// <param name="element"></param>
/// <returns></returns>
private static int ConvertStringIntervalToInteger(ref IEnumerable<XElement> x, string parent, string element)
{
return int.Parse(x.Descendants(parent)
.Elements(element)
.FirstOrDefault()
.Value);
}
private static void CopyFooters(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs, List<ImageData> images)
{
foreach (XElement footerReference in paragraphs.Descendants(ns + "footerReference"))
{
string relId = footerReference.Attribute(ns_r + "id").Value;
FooterPart oldPart = (FooterPart)oldDoc.MainDocumentPart.GetPartById(relId);
XDocument oldFooter = oldPart.GetXDocument();
FooterPart newPart = newDoc.MainDocumentPart.AddNewPart<FooterPart>();
XDocument newFooter = newPart.GetXDocument();
newFooter.Add(oldFooter.Root);
footerReference.Attribute(ns_r + "id").Value = newDoc.MainDocumentPart.GetIdOfPart(newPart);
CopyFooterShapes(oldPart, newPart, images);
CopyFooterEmbeddedObjects(oldPart, newPart);
CopyFooterImages(oldPart, newPart, images);
}
}
public void ResetNumbering(IEnumerable<XElement> elements)
{
var numPrs = elements.Descendants(W.numPr).Where(d=>d.Element(W.numId) != null);
foreach (var numPr in numPrs.GroupBy(e => (int)e.Element(W.numId).Attribute(W.val)))
{
var numId = numPr.Key;
var numIds = numPrs.Elements(W.numId).Attributes(W.val).Where(e => (int)e == numId);
var ilvl = int.Parse(numPr.First().Element(W.ilvl).Attribute(W.val).Value);
if (_lastNumIds.ContainsKey(ilvl))
{
var numElementPrototype = _numberingPart
.Descendants(W.num)
.FirstOrDefault(n => (int)n.Attribute(W.numId) == numId);
var abstractNumElementPrototype = _numberingPart
.Descendants(W.abstractNum)
.FirstOrDefault(e => e.Attribute(W.abstractNumId).Value ==
numElementPrototype
.Element(W.abstractNumId)
.Attribute(W.val).Value);
var lastNumElement = _numberingPart
.Descendants(W.num)
.OrderBy(n => (int)n.Attribute(W.numId))
.LastOrDefault();
if (lastNumElement == null) break;
var nextNumId = (int)lastNumElement.Attribute(W.numId) + 1;
var lastAbstractNumElement = _numberingPart.Descendants(W.abstractNum).Last();
var lastAbstractNumId = (int)lastAbstractNumElement.Attribute(W.abstractNumId);
var newAbstractNumElement = new XElement(abstractNumElementPrototype);
newAbstractNumElement.Attribute(W.abstractNumId).SetValue(lastAbstractNumId + 1);
var next = Random.Next(int.MaxValue);
var nsid = newAbstractNumElement.Element(W.nsid);
if (nsid != null)
nsid.Attribute(W.val).SetValue(next.ToString("X"));
lastAbstractNumElement.AddAfterSelf(newAbstractNumElement);
var newNumElement = new XElement(numElementPrototype);
newNumElement.Attribute(W.numId).SetValue(nextNumId);
newNumElement.Element(W.abstractNumId).Attribute(W.val).SetValue(lastAbstractNumId + 1);
lastNumElement.AddAfterSelf(newNumElement);
foreach (var xElement in numIds)
{
xElement.SetValue(nextNumId);
}
_lastNumIds[ilvl] = nextNumId;
}
else
{
_lastNumIds.Add(ilvl, numId);
}
}
}
/// <summary>
/// 지정된 컬럼의 값을 반환합니다.
/// </summary>
/// <param name="query"></param>
/// <param name="FieldName"></param>
/// <returns>double</returns>
private static IEnumerable<double> GetCoumnValue(IEnumerable<XElement> query, string FieldName)
{
var query2 =
from
oColumns in query.Descendants("Column")
where (string)oColumns.Element("ID") == FieldName &&
oColumns.Elements("Value").Any()
select
(double)oColumns.Element("Value");
return query2;
}
/// <summary>
/// XElement 형식을 DataTable로 변환합니다.
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
private static System.Data.DataTable XElementToDataTable(IEnumerable<XElement> x)
{
var all = from p in x.Descendants("Columns") select p;
XElement table = new XElement("Root");
foreach (XElement xe in all)
{
XElement Row1 = new XElement("Row");
foreach (XElement xe2 in xe.Descendants("Column"))
{
var row2 = (from p in xe2.Descendants()
select
new XElement(xe2.Element("ID").Value, xe2.Element("Value").Value)).First();
Row1.Add(row2);
}
table.Add(new XElement(Row1));
}
System.Data.DataTable dt = ToDataTable(table.ToString());
return dt;
}
private static void CopyNumbering(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs)
{
int number = 1;
int abstractNumber = 0;
XDocument oldNumbering = null;
XDocument newNumbering = null;
foreach (XElement numReference in paragraphs.Descendants(ns + "numPr"))
{
XElement idElement = numReference.Descendants(ns + "numId").FirstOrDefault();
if (idElement != null)
{
if (oldNumbering == null)
oldNumbering = oldDoc.MainDocumentPart.NumberingDefinitionsPart.GetXDocument();
if (newNumbering == null)
{
if (newDoc.MainDocumentPart.NumberingDefinitionsPart != null)
{
newNumbering = newDoc.MainDocumentPart.NumberingDefinitionsPart.GetXDocument();
var numIds = newNumbering.Root.Elements(ns + "num").Select(f => (int)f.Attribute(ns + "numId"));
if (numIds.Any())
number = numIds.Max() + 1;
numIds = newNumbering.Root.Elements(ns + "abstractNum").Select(f => (int)f.Attribute(ns + "abstractNumId"));
if (numIds.Any())
abstractNumber = numIds.Max() + 1;
}
else
{
newDoc.MainDocumentPart.AddNewPart<NumberingDefinitionsPart>();
newNumbering = newDoc.MainDocumentPart.NumberingDefinitionsPart.GetXDocument();
newNumbering.Add(new XElement(ns + "numbering", ns_attrs));
}
}
string numId = idElement.Attribute(ns + "val").Value;
if (numId != "0")
{
XElement element = oldNumbering.Descendants().Elements(ns + "num").Where(p => ((string)p.Attribute(ns + "numId")) == numId).First();
// Copy abstract numbering element, if necessary (use matching NSID)
string abstractNumId = element.Elements(ns + "abstractNumId").First().Attribute(ns + "val").Value;
XElement abstractElement = oldNumbering.Descendants().Elements(ns + "abstractNum").Where(p => ((string)p.Attribute(ns + "abstractNumId")) == abstractNumId).First();
string abstractNSID = abstractElement.Elements(ns + "nsid").First().Attribute(ns + "val").Value;
XElement newAbstractElement = newNumbering.Descendants().Elements(ns + "abstractNum").Where(p => ((string)p.Elements(ns + "nsid").First().Attribute(ns + "val")) == abstractNSID).FirstOrDefault();
if (newAbstractElement == null)
{
newAbstractElement = new XElement(abstractElement);
newAbstractElement.Attribute(ns + "abstractNumId").Value = abstractNumber.ToString();
abstractNumber++;
if (newNumbering.Root.Elements(ns + "abstractNum").Any())
newNumbering.Root.Elements(ns + "abstractNum").Last().AddAfterSelf(newAbstractElement);
else
newNumbering.Root.Add(newAbstractElement);
}
string newAbstractId = newAbstractElement.Attribute(ns + "abstractNumId").Value;
// Copy numbering element, if necessary (use matching element with no overrides)
XElement newElement = null;
if (!element.Elements(ns + "lvlOverride").Any())
newElement = newNumbering.Descendants().Elements(ns + "num").Where(p => !p.Elements(ns + "lvlOverride").Any() && ((string)p.Elements(ns + "abstractNumId").First().Attribute(ns + "val")) == newAbstractId).FirstOrDefault();
if (newElement == null)
{
newElement = new XElement(element);
newElement.Elements(ns + "abstractNumId").First().Attribute(ns + "val").Value = newAbstractId;
newElement.Attribute(ns + "numId").Value = number.ToString();
number++;
newNumbering.Root.Add(newElement);
}
idElement.Attribute(ns + "val").Value = newElement.Attribute(ns + "numId").Value;
}
}
}
}
static void RemoveUnwantedElements(IEnumerable<XElement> members)
{
string[] tagsSupportedByIntellisense =
{
"summary",
"param",
"returns",
"exception",
};
string[] tagsToStrip =
{
"a",
"img",
};
RemoveElements(from member in members
from element in member.Elements()
where !tagsSupportedByIntellisense.Contains(element.Name.LocalName, StringComparer.OrdinalIgnoreCase)
select element);
RemoveElements(from element in members.Descendants()
where IsMarkedToSkip(element)
select element);
StripElements(from element in members.Descendants()
where tagsToStrip.Contains(element.Name.LocalName, StringComparer.OrdinalIgnoreCase)
select element);
}
private static void CopyShapes(WordprocessingDocument oldDoc, WordprocessingDocument newDoc, IEnumerable<XElement> paragraphs, List<ImageData> images)
{
foreach (XElement shapeReference in paragraphs.Descendants(ns_v + "imagedata"))
{
string relId = shapeReference.Attribute(ns_r + "id").Value;
ImagePart oldPart = (ImagePart)oldDoc.MainDocumentPart.GetPartById(relId);
ImageData temp = ManageImageCopy(oldPart, images);
if (temp.ResourceID == null)
{
ImagePart newPart = newDoc.MainDocumentPart.AddImagePart(oldPart.ContentType);
temp.ResourceID = newDoc.MainDocumentPart.GetIdOfPart(newPart);
temp.WriteImage(newPart);
}
shapeReference.Attribute(ns_r + "id").Value = temp.ResourceID;
}
}
/// <summary>
/// 화면에 보이는 메트릭스 구조로 XML 태그를 변환합니다.
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
private static XElement GetGridConvertToXML(IEnumerable<XElement> x)
{
var all = from p in x.Descendants("Cells") select p;
XElement oXElement = new XElement("Root");
foreach (XElement xe in all)
{
XElement Row1 = new XElement("Row");
foreach (XElement xe2 in xe.Descendants("Cell"))
{
var row2 = (from p in xe2.Descendants()
select
new XElement(xe2.Element("ColumnUid").Value, xe2.Element("Value").Value)).First();
Row1.Add(row2);
}
oXElement.Add(new XElement(Row1));
}
return oXElement;
}
private static void UpdateContent(IEnumerable<XElement> newContent, XName elementToModify, string oldRid, string newRid)
{
foreach (var attributeName in RelationshipMarkup[elementToModify])
{
var elementsToUpdate = newContent
.Descendants(elementToModify)
.Where(e => (string)e.Attribute(attributeName) == oldRid);
foreach (var element in elementsToUpdate)
element.Attribute(attributeName).Value = newRid;
}
}
public void Load(IEnumerable<XElement> tilesToLoad)
{
var availableItems = AvailableItems.Instance;
var availableMobiles = AvailableMobiles.Instance;
Mobile mobile = null;
Item item = null;
foreach (XElement tile in tilesToLoad.Descendants("Tile"))
{
var top = Int32.Parse(tile.Element("Location").Element("Top").Value);
var left = Int32.Parse(tile.Element("Location").Element("Left").Value);
var tileTypeId = Int32.Parse(tile.Element("TypeId").Value);
mobile = null;
if (!string.IsNullOrEmpty(tile.Element("Mobile").Value))
{
mobile = availableMobiles.GetMobileById((Int32.Parse(tile.Element("Mobile").Element("TypeId").Value)));
mobile.Load(tile.Element("Mobile"));
}
item = null;
if (!string.IsNullOrEmpty(tile.Element("Item").Value))
{
item = availableItems.GetItemById((Int32.Parse(tile.Element("Item").Element("ItemId").Value)));
item.Load(tile.Element("Item"));
}
Tiles.Add(new Tile {Location = new Location(left, top), TypeId = tileTypeId, Mobile = mobile, Item = item });
}
}
