private static void ParseStructuredTableElement(TableElement tableElement, string startTagName, string endTagName)
{
if (tableElement == null)
{
throw new NullReferenceException("TableElement cannot be null!");
}
tableElement.EndTag = FindEndTag(tableElement.StartTag, startTagName, endTagName);
tableElement.Expression = tableElement.StartTag.GetExpression();
tableElement.TagElements = MakeTableElement(tableElement.StartTag, tableElement.EndTag);
}
private static TableElement ToTableElement(XElement tagElement)
{
//TODO Make field constants
var tableElement = new TableElement
{
IsItem = tagElement.IsTag(ItemTextTagName),
IsIndex = tagElement.IsTag(ItemIndexTagName),
IsItemIf = tagElement.IsTag(ItemIfTagName),
IsItemRepeater = tagElement.IsTag(ItemRepeaterTagName),
IsItemHtmlContent = tagElement.IsTag(ItemHtmlContentTagName),
IsItemTable = tagElement.IsTag(ItemTableTagName),
IsCellColor = tagElement.IsTag(CellColorTagName),
StartTag = tagElement,
};
if (tableElement.IsItem || tableElement.IsItemHtmlContent || tableElement.IsCellColor)
{
tableElement.Expression = tagElement.GetExpression();
}
else if (tableElement.IsItemHtmlContent)
{
tableElement.Expression = tagElement.GetExpression();
}
else if (tableElement.IsItemIf)
{
ParseStructuredTableElement(tableElement, ItemIfTagName, EndItemIfTagName);
}
else if (tableElement.IsItemRepeater)
{
ParseStructuredTableElement(tableElement, ItemRepeaterTagName, EndItemRepeaterTagName);
}
else if (tableElement.IsItemTable)
{
ParseStructuredTableElement(tableElement, ItemTableTagName, EndItemTableTagName);
}
return tableElement;
}
protected override void Init()
{
AddSystem(new MenuBackgroundSystem());
CanPause = false;
BuildMenuButton("Back", 530, delegate(ElementEvent e)
{
CurrentGame.ShowTitleScreen();
});
Element title = BuildMenuButton("High Scores", 80, null);
title.ClassName += " MenuTitle";
HighScore[] scores = (HighScore[])Json.Parse((string)Window.LocalStorage[SpaceDinosGame.HighScoresKey]);
TableElement table = (TableElement)Document.CreateElement("TABLE");
table.ClassName = "HighScores";
_overlay.AppendChild(table);
Element tableBody = Document.CreateElement("TBODY");
table.AppendChild(tableBody);
TableRowElement row = (TableRowElement)Document.CreateElement("TR");
tableBody.AppendChild(row);
AddCell(row, "TH", string.Empty);
AddCell(row, "TH", "Score");
AddCell(row, "TH", "Level");
AddCell(row, "TH", "Name");
for (int i = 0; i < 10; i++)
{
row = (TableRowElement)Document.CreateElement("TR");
tableBody.AppendChild(row);
switch (i)
{
case 0:
AddCell(row, "TD", "1st");
break;
case 1:
AddCell(row, "TD", "2nd");
break;
case 2:
AddCell(row, "TD", "3rd");
break;
default:
AddCell(row, "TD", (i + 1) + "th");
break;
}
AddCell(row, "TD", scores[i].Score.ToString());
AddCell(row, "TD", scores[i].Level.ToString());
AddCell(row, "TD", scores[i].Name);
}
jQuery.FromElement(_overlay).Show();
}
/// <summary>
/// Gets the syntax for the creation of an anonymous type.
/// </summary>
/// <param name="tableElement">The description of a table.</param>
/// <param name="bodyStatements">The statements that appear in the body of the using block.</param>
/// <returns>An expression that builds an anonymous type from a table description.</returns>
public static List <StatementSyntax> GetSyntax(TableElement tableElement, IEnumerable <StatementSyntax> bodyStatements)
{
// Validate the argument.
if (tableElement == null)
{
throw new ArgumentNullException(nameof(tableElement));
}
// This is used to collect the statements.
List <StatementSyntax> statements = new List <StatementSyntax>();
// using (TransactionScope transactionScope = new TransactionScope())
UsingStatementSyntax usingStatement = SyntaxFactory.UsingStatement(
SyntaxFactory.Block(bodyStatements))
.WithDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("transactionScope"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName("TransactionScope"))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("TransactionScopeOption"),
SyntaxFactory.IdentifierName("RequiresNew"))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName("transactionTimeout"))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("TransactionScopeAsyncFlowOption"),
SyntaxFactory.IdentifierName("Enabled"))),
}))))))));
// using (var disposables = new DisposableList())
usingStatement = SyntaxFactory.UsingStatement(usingStatement)
.WithDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("disposables"))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
SyntaxFactory.ObjectCreationExpression(
SyntaxFactory.IdentifierName("DisposableList"))
.WithArgumentList(
SyntaxFactory.ArgumentList()))))));
// using (await this.domain.Accounts.Lock.WriteLockAsync())
// using (await this.domain.Accounts.AccountExternalKey.Lock.WriteLockAsync())
// using (await this.domain.Accounts.AccountKey.Lock.WriteLockAsync())
// using (await this.domain.Accounts.EntityAccountKey.Lock.WriteLockAsync())
foreach (ForeignKeyElement foreignKeyElement in tableElement.ParentKeys.AsEnumerable().Reverse())
{
// using (await this.Accounts.EntityAccountKey.Lock.WriteLockAsync())
usingStatement = SyntaxFactory.UsingStatement(usingStatement)
.WithExpression(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())),
SyntaxFactory.IdentifierName(foreignKeyElement.Table.Name.ToPlural())),
SyntaxFactory.IdentifierName(foreignKeyElement.Name)),
SyntaxFactory.IdentifierName("Lock")),
SyntaxFactory.IdentifierName("WriteLockAsync")))));
}
// Lock each of the unique key indices
foreach (UniqueKeyElement uniqueKeyElement in tableElement.UniqueKeys.AsEnumerable().Reverse())
{
// using (await this.domain.Accounts.AccountKey.Lock.WriteLockAsync())
usingStatement = SyntaxFactory.UsingStatement(usingStatement)
.WithExpression(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())),
SyntaxFactory.IdentifierName(uniqueKeyElement.Table.Name.ToPlural())),
SyntaxFactory.IdentifierName(uniqueKeyElement.Name)),
SyntaxFactory.IdentifierName("Lock")),
SyntaxFactory.IdentifierName("WriteLockAsync")))));
}
// Finally, lock the table.
// using (await this.domain.Accounts.Lock.WriteLockAsync())
usingStatement = SyntaxFactory.UsingStatement(usingStatement)
.WithExpression(
SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())),
SyntaxFactory.IdentifierName(tableElement.Name.ToPlural())),
SyntaxFactory.IdentifierName("Lock")),
SyntaxFactory.IdentifierName("WriteLockAsync")))));
// This puts all the other 'using' statements into a big block with the transaction as the first item. This order also insures that
// the transaction is also the last to be disposed.
// using (await this.Accounts.Lock.WriteLockAsync())
// using (await this.Accounts.AccountExternalKey.Lock.WriteLockAsync())
// using (await this.ManagedAccounts.AccountExternalKey.Lock.WriteLockAsync())
// using (var disposables = new DisposableList())
// using (var transactionScope = new TransactionScope())
// {
// <LoadDomain>
// }
statements.Add(usingStatement);
// This set of statement will enlist the indices and tables in the current transaction and acquire an exclusive lock.
return(statements);
}
public void TestProcess()
{
var tableTag = this.GetTableTag();
Func<XElement, IEnumerable<TableElement>> MakeTableElementCallback = element =>
{
var tags = element.Descendants(WordMl.SdtName).ToList();
var index =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("itemindex"));
var subject =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("itemtext") && e.Element(WordMl.SdtContentName).Value == "./Subject");
var issueDate =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("itemtext") && e.Element(WordMl.SdtContentName).Value == "./IssueDate");
var expireDate =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("itemtext") && e.Element(WordMl.SdtContentName).Value == "./ExpireDate");
var itemIf =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("itemif"));
var endItemIf =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("enditemif"));
IEnumerable<TableElement> tableElements = new TableElement[]
{
new TableElement
{
IsIndex = true,
IsItem = false,
IsItemIf = false,
StartTag = index,
},
new TableElement
{
IsItemIf = true,
IsIndex = false,
IsItem = false,
StartTag = itemIf,
EndTag = endItemIf,
Expression = "./HasSubject",
TagElements =
new TableElement[]
{
new TableElement
{
IsItem = true,
IsIndex = false,
IsItemIf = false,
StartTag = subject,
Expression = "./Subject"
}
}
},
new TableElement
{
IsItem = true,
IsIndex = false,
IsItemIf = false,
StartTag = issueDate,
Expression = "./IssueDate"
},
new TableElement
{
IsItem = true,
IsIndex = false,
IsItemIf = false,
StartTag = expireDate,
Expression = "./ExpireDate"
}
};
return tableElements;
};
tableTag.MakeTableElementCallback = MakeTableElementCallback;
var tableProcessor = new TableProcessor
{
TableTag = tableTag,
DataReader = this.dataReader
};
tableProcessor.Process();
Assert.IsFalse(this.documentRoot.Elements(WordMl.SdtName).Any(element => element.IsSdt()));
var expectedTableStructure = new[]
{
new[] { "#", "Certificate", "Date" },
new[] { string.Empty, string.Empty, "Issue", "Expiration" },
new[] { "1", "2", "3", "4" },
new[] { "1", "Subject1", "01.04.2014", "01.10.2015" },
new[] { "2", "Subject2", "01.03.2014", "01.09.2015" },
new[] { "3", "Subject3", "01.01.2011", "01.01.2012" },
new[] { "This", "row", "stays", "untouched" },
};
var rows = tableTag.Table.Elements(WordMl.TableRowName).ToList();
Assert.AreEqual(expectedTableStructure.Count(), rows.Count());
int rowIndex = 0;
foreach (var row in rows)
{
var expectedRow = expectedTableStructure[rowIndex];
var cellsInRow = row.Elements(WordMl.TableCellName).ToList();
Assert.AreEqual(expectedRow.Count(), cellsInRow.Count());
int cellIndex = 0;
foreach (var cell in cellsInRow)
{
Assert.AreEqual(expectedRow[cellIndex], cell.Value);
cellIndex++;
}
rowIndex++;
}
/*
var tagsBetween =
tableTag.TagTable.ElementsAfterSelf().Where(element => element.IsBefore(tableTag.TagContent));
Assert.IsFalse(tagsBetween.Any());
tagsBetween =
tableTag.TagEndContent.ElementsAfterSelf().Where(element => element.IsBefore(tableTag.TagEndTable));
Assert.IsFalse(tagsBetween.Any());*/
this.ValidateTagsRemoved(this.documentRoot);
}
/// <summary>
/// Initializes a new instance of the <see cref="BuildPage" /> class.
/// </summary>
/// <param name="parent">The parent.</param>
public BuildPage(UITestControl parent)
: base(parent)
{
MyPopulatedTable = new TableElement<HtmlRow>();
TableHashCode = MyPopulatedTable.GetHashCode();
}
public void WhenIBrowsingTableWithId(string id)
{
this.table = Browser.Current.Table(By.Id(id));
}
/// <summary>
/// Cleans all proxy references
/// </summary>
public void Cleanup()
{
lock (table)
{
if (table.Count > minElements)
{
Guid[] accessIds = new Guid[table.Count];
TableElement[] entries = new TableElement[table.Count];
table.Values.CopyTo(entries, 0);
table.Keys.CopyTo(accessIds, 0);
Array.Sort(entries, accessIds);
int nrToRemove = table.Count - minElements;
foreach (var key in accessIds)
{
table.Remove(key);
nrToRemove--;
if (nrToRemove == 0)
{
break;
}
}
foreach (var item in table.Values)
{
((TableElement)item).AccessCount = 0;
}
}
}
}
private ItemRepeaterTag GenerateItemRepeaterTag(TableElement itemRepeaterElement)
{
var tagResult = new ItemRepeaterTag()
{ StartItemRepeater = itemRepeaterElement.StartTag,
EndItemRepeater = itemRepeaterElement.EndTag,
NestedRepeaters = new List<ItemRepeaterTag>(),
Source = itemRepeaterElement.Expression
};
return tagResult;
}
private static bool Render(TableElement element, WordprocessingDocument document, Body body)
{
if (element.Table.Rows.Count == 0)
{
return(true);
//throw new Exception("The table is empty");
}
var table = new DocumentFormat.OpenXml.Wordprocessing.Table();
if (element.Headers.Count != 0)
{
var row = new DocumentFormat.OpenXml.Wordprocessing.TableRow();
foreach (var head in element.Headers)
{
var text = new DocumentFormat.OpenXml.Wordprocessing.Text(head.ToString());
var run = new DocumentFormat.OpenXml.Wordprocessing.Run(text);
var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph(run);
paragraph.ParagraphProperties = new DocumentFormat.OpenXml.Wordprocessing.ParagraphProperties
{
ParagraphStyleId = new DocumentFormat.OpenXml.Wordprocessing.ParagraphStyleId()
{
Val = WordStyleIdFromStyleName(document, element.HeaderStyle.Name)
},
WordWrap = new DocumentFormat.OpenXml.Wordprocessing.WordWrap {
Val = new OnOffValue {
Value = true
}
},
TextAlignment =
new DocumentFormat.OpenXml.Wordprocessing.TextAlignment
{
Val = DocumentFormat.OpenXml.Wordprocessing.VerticalTextAlignmentValues.Auto
},
};
var cell = new DocumentFormat.OpenXml.Wordprocessing.TableCell(paragraph);
DocumentFormat.OpenXml.Wordprocessing.TableCellProperties cellprop = WordCellProperties(element.HeaderStyle);
cell.Append(cellprop);
row.Append(cell);
}
table.Append(row);
}
for (int i = 0; i < element.Table.Rows.Count; i++)
{
var row = new DocumentFormat.OpenXml.Wordprocessing.TableRow();
for (int j = 0; j < element.Table.Columns.Count; j++)
{
var text = new DocumentFormat.OpenXml.Wordprocessing.Text(element.Table.Rows[i][j].ToString());
var run = new DocumentFormat.OpenXml.Wordprocessing.Run(text);
var paragraph = new DocumentFormat.OpenXml.Wordprocessing.Paragraph(run);
paragraph.ParagraphProperties = new DocumentFormat.OpenXml.Wordprocessing.ParagraphProperties
{
ParagraphStyleId = new DocumentFormat.OpenXml.Wordprocessing.ParagraphStyleId()
{
Val = WordStyleIdFromStyleName(document, element.TableStyle.Name)
},
WordWrap = new DocumentFormat.OpenXml.Wordprocessing.WordWrap {
Val = new OnOffValue {
Value = true
}
},
TextAlignment =
new DocumentFormat.OpenXml.Wordprocessing.TextAlignment
{
Val = DocumentFormat.OpenXml.Wordprocessing.VerticalTextAlignmentValues.Auto
},
};
var cell = new DocumentFormat.OpenXml.Wordprocessing.TableCell(paragraph);
var cellprop = WordCellProperties(element.TableStyle);
cell.Append(cellprop);
row.Append(cell);
}
table.Append(row);
}
body.AppendChild <DocumentFormat.OpenXml.Wordprocessing.Table>(table);
return(false);
}
public static bool Delete(string userName)
{
TableElement te = new TableElement("UserName", userName);
return(m_db.Delete(te));
}
public static Recipe Create(TableElement source)
{
#warning Create_Is_NotImpl
throw new NotImplementedException("Create is not implemented");
}
/// <summary>
/// Warning: this method uses System.Windows.Forms.MessageBox.
/// </summary>
/// <param name="element"></param>
static public void GetTableElementDictionary(this TableElement element)
{
element.conversionElements.Clear();
// ac_table
element.conversionElements.Add("TableType", element.DbType);
element.conversionElements.Add("tabletype", string.Format("{0}", element.DbType).ToLower());
// see the primary key related tags below
element.conversionElements.Add("PK", element.PrimaryKey);
element.conversionElements.Add("pk", element.PrimaryKey == null ? string.Empty : element.PrimaryKey.ToLower());
element.conversionElements.Add("PrimaryKey", element.PrimaryKey == null ? string.Empty : element.PrimaryKey);
element.conversionElements.Add("PrimaryKeyCleanC", element.PrimaryKey == null ? string.Empty : element.PrimaryKey.ToStringCapitolize().Clean());
element.conversionElements.Add("primarykey", element.PrimaryKey == null ? string.Empty : element.PrimaryKey.ToLower());
//
element.conversionElements.Add("Table", element.Name.Replace("-", "_"));
//
element.conversionElements.Add("TableName", element.Name);
element.conversionElements.Add("tablename", element.Name.ToLower());
//
element.conversionElements.Add("TableNameC", element.Name.ToStringCapitolize());
element.conversionElements.Add("TableNameClean", element.FriendlyName);
element.conversionElements.Add("tablenameclean", element.FriendlyName.ToLower());
element.conversionElements.Add("TableNameCClean", element.FriendlyName.ToStringCapitolize());
//
element.conversionElements.Add("TableCleanName", element.Name.Clean());
element.conversionElements.Add("TableCleanNameC", element.Name.Clean().ToStringCapitolize());
//
element.conversionElements.Add("AdapterNs", element.NsAdapter);
element.conversionElements.Add("AdapterT", element.TAdapter);
element.conversionElements.Add("AdapterNsT", element.TypeAdapter);
//
element.conversionElements.Add("CommandNs", element.NsCommand);
element.conversionElements.Add("CommandT", element.TCommand);
element.conversionElements.Add("CommandNsT", element.TypeCommand);
//
element.conversionElements.Add("ConnectionNs", element.NsConnection);
element.conversionElements.Add("ConnectionT", element.TConnection);
element.conversionElements.Add("ConnectionNsT", element.TypeConnection);
//
element.conversionElements.Add("ParameterT", element.TParameter);
//
element.conversionElements.Add("ReaderNs", element.NsReader);
element.conversionElements.Add("ReaderT", element.TReader);
element.conversionElements.Add("ReaderNsT", element.TypeReader);
//
element.conversionElements.Add("Date", DateTime.Now.ToString("MM/dd/yyyy"));
element.conversionElements.Add("Time", DateTime.Now.ToString("hh:mm.ss tt"));
element.conversionElements.Add("DateTime", string.Format("{0:MM/dd/yyyy} {1:hh:mm.ss tt}", DateTime.Now, DateTime.Now));
//
if (element.PrimaryKey == null)
{
System.Windows.Forms.MessageBox.Show("Table must provide a primary key", "Please check the table.");
return;
}
else if (element.PrimaryKey != string.Empty)
{
element.conversionElements.Add("PKDataName", element.PrimaryKeyElement.DataName);
element.conversionElements.Add("PKDataType", element.PrimaryKeyElement.DataType);
element.conversionElements.Add("PKDataTypeNative", element.PrimaryKeyElement.DataTypeNative);
element.conversionElements.Add("PKNativeNullType", NullableTypeUtility.GetNativeNullType(element.PrimaryKeyElement["Native"].ToString()));
element.conversionElements.Add("PKNativeNullValue", NullableTypeUtility.IsNativeNullable(element.PrimaryKeyElement["Native"].ToString()) ? ".Value" : "");
// Add("PKDataTypeNative", PrimaryKeyElement.DataTypeNative);
element.conversionElements.Add("PKDescription", element.PrimaryKeyElement.Description);
//
element.conversionElements.Add("PKDataNameC", element.PrimaryKeyElement.DataName.ToStringCapitolize());
element.conversionElements.Add("PKCleanName", element.PrimaryKeyElement.DataName.Replace("-", "_"));
element.conversionElements.Add("PKCleanName,Nodash", element.PrimaryKeyElement.DataName.Clean());
element.conversionElements.Add("PKFriendlyName", element.PrimaryKeyElement.DataName.Clean());
element.conversionElements.Add("PKFriendlyNameC", element.PrimaryKeyElement.DataName.Clean().ToStringCapitolize());
}
else
{
Global.statR(ResourceUtil.ResourceManager.GetString("TableElement_PrimaryKeyNotFound"), element.Name);
}
}
private void buttonCancel_Click(object sender, RoutedEventArgs e)
{
dialogRes = null;
Close();
}
/// <summary>
/// Gets the syntax for the creation of an anonymous type.
/// </summary>
/// <param name="tableElement">The description of a table.</param>
/// <returns>A set of expression that enlists the table in a transaction.</returns>
public static List <StatementSyntax> GetSyntax(TableElement tableElement)
{
// Validate the argument.
if (tableElement == null)
{
throw new ArgumentNullException(nameof(tableElement));
}
// This is used to collect the statements.
List <StatementSyntax> statements = new List <StatementSyntax>();
// transaction.EnlistVolatile(this.domain.Accounts, EnlistmentOptions.None);
statements.Add(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("transaction"),
SyntaxFactory.IdentifierName("EnlistVolatile")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())),
SyntaxFactory.IdentifierName(tableElement.Name.ToPlural()))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("EnlistmentOptions"),
SyntaxFactory.IdentifierName("None"))),
})))));
// Enlist each of the unique key indices in this transaction.
foreach (UniqueKeyElement uniqueKeyElement in tableElement.UniqueKeys)
{
// transaction.EnlistVolatile(this.domain.Accounts.AccountExternalKey, EnlistmentOptions.None);
statements.Add(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("transaction"),
SyntaxFactory.IdentifierName("EnlistVolatile")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())),
SyntaxFactory.IdentifierName(uniqueKeyElement.Table.Name.ToPlural())),
SyntaxFactory.IdentifierName(uniqueKeyElement.Name))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("EnlistmentOptions"),
SyntaxFactory.IdentifierName("None"))),
})))));
}
// Enlist each of the foreign key indices in this transaction.
foreach (ForeignKeyElement foreignKeyElement in tableElement.ParentKeys)
{
// transaction.EnlistVolatile(this.domain.Accounts.EntityAccountKey, EnlistmentOptions.None);
statements.Add(
SyntaxFactory.ExpressionStatement(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("transaction"),
SyntaxFactory.IdentifierName("EnlistVolatile")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
new SyntaxNodeOrToken[]
{
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.ThisExpression(),
SyntaxFactory.IdentifierName(tableElement.XmlSchemaDocument.Domain.ToVariableName())),
SyntaxFactory.IdentifierName(foreignKeyElement.Table.Name.ToPlural())),
SyntaxFactory.IdentifierName(foreignKeyElement.Name))),
SyntaxFactory.Token(SyntaxKind.CommaToken),
SyntaxFactory.Argument(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SyntaxFactory.IdentifierName("EnlistmentOptions"),
SyntaxFactory.IdentifierName("None"))),
})))));
}
// This set of statement will enlist the indices and tables in the current transaction and acquire an exclusive lock.
return(statements);
}
public static bool Delete(string orderID)
{
TableElement te = new TableElement("OrderID", orderID);
return(m_db.Delete(te));
}
public static string ReplaceValues(TableElement table, string tableTemplate)
{
table.InitializeDictionary();
return(table.Reformat(tableTemplate));
}
private void ProcessItemRepeaterElement(TableElement itemRepeaterElement, DataReader dataReader, int index,
XElement previous)
{
var expression = itemRepeaterElement.Expression;
var readers = dataReader.GetReaders(expression);
var itemRepeaterTag = GenerateItemRepeaterTag(itemRepeaterElement);
var generator = new ItemRepeaterGenerator();
generator.Generate(itemRepeaterTag, readers.ToList());
}
private void BuildTable()
{
for (int i = 0; i < CSet.Count; i++)
{
Table[i] = new Dictionary <IProductionElement, TableElement>();
}
for (int i = 0; i < CSet.Count; i++)
{
var node = CSet[i];
foreach (var element in node.Elements)
{
var rule = element.GrammarRule;
if (rule.DotPos < rule.ProductionElements.Count)
{
var pe = rule.ProductionElements[rule.DotPos];
if (pe is NonTerminalProduction)
{
continue;
}
var requiredState = new TableElement(TableCellState.Shift, node.Edges[pe].Index);
if (!Table[i].ContainsKey(pe) || Table[i][pe].Equals(requiredState))
{
Table[i][pe] = new TableElement(TableCellState.Shift, node.Edges[pe].Index);
}
else
{
throw new Exception("The grammar is not LALR");
}
}
else
{
if (rule.Nonterminal.Equals(grammarBuilder.StartNonTerminal))
{
var requiredState = new TableElement(TableCellState.Accept, -1);
if (!Table[i].ContainsKey(new EOFProduction()) || Table[i][new EOFProduction()].Equals(requiredState))
{
Table[i][new EOFProduction()] = requiredState;
}
else
{
throw new Exception("The grammar is not LALR");
}
}
else
{
foreach (var terminalProduction in element.TerminalProductions)
{
var requiredState = new TableElement(TableCellState.Reduce, rule.RuleIndex);
if (!Table[i].ContainsKey(terminalProduction) || Table[i][terminalProduction].Equals(requiredState))
{
Table[i][terminalProduction] = requiredState;
}
else
{
throw new Exception("The grammar is not LALR");
}
}
}
}
}
foreach (var nonterminal in grammarBuilder.NonTerminals.Values)
{
var pe = new NonTerminalProduction(nonterminal.Name);
if (node.Edges.ContainsKey(pe))
{
var requiredState = new TableElement(TableCellState.Goto, node.Edges[pe].Index);
if (!Table[i].ContainsKey(pe) || Table[i][pe].Equals(requiredState))
{
Table[i][pe] = requiredState;
}
else
{
throw new Exception("The grammar is not LR(1)");
}
}
}
}
}
private XElement ProcessItemIfElement(TableElement itemIfElement, DataReader dataReader, int index, XElement previous)
{
bool condition;
try
{
condition = bool.Parse(dataReader.ReadText(itemIfElement.Expression));
}
catch (FormatException)
{
condition = false;
}
catch (System.Xml.XPath.XPathException)
{
condition = false;
}
var currentCell = itemIfElement.StartTag.Ancestors().First(element => element.Name == WordMl.TableCellName);
if (condition)
{
this.ProcessElements(itemIfElement.TagElements, dataReader, index, previous, false);
itemIfElement.StartTag.Remove();
itemIfElement.EndTag.Remove();
if (previous != null && !previous.Equals(currentCell))
{
currentCell.Remove();
previous.AddAfterSelf(currentCell);
}
}
else
{
this.CleanUp(itemIfElement.StartTag, itemIfElement.EndTag);
if (!currentCell.Elements(WordMl.ParagraphName).Any())
{
currentCell.Add(new XElement(WordMl.ParagraphName));
}
if (previous != null && !previous.Equals(currentCell))
{
currentCell.Remove();
previous.AddAfterSelf(currentCell);
}
else if (previous == null)
{
var parentRow = currentCell.Parent;
currentCell.Remove();
parentRow.Add(currentCell);
}
}
return currentCell;
}
public DataTable(int pageNumber, string searchText, TableDTO tableDTO)
{
TableDiv = TableElement.ObjectToAdvancedTableElement(tableDTO.Headers, tableDTO.Rows);
}
private XElement ProcessCell(TableElement tableElement, XElement previous, string text)
{
var isInnerCell = tableElement.HasCell();
var currentCell = this.CurrentCell(tableElement);
previous = this.ProcessStaticCells(tableElement, previous);
var parent = isInnerCell ? currentCell: tableElement.StartTag.Parent;
var result = DocxHelper.CreateTextElement(
tableElement.StartTag,
parent,
text);
if (!isInnerCell)
{
tableElement.StartTag.AddAfterSelf(result);
}
else
{
if (currentCell.Elements(WordMl.ParagraphName).Any())
{
currentCell.Elements(WordMl.ParagraphName).Remove();
}
currentCell.Add(result);
}
if (previous != null && !previous.Equals(currentCell))
{
currentCell.Remove();
previous.AddAfterSelf(currentCell);
}
else if (previous == null)
{
var parentRow = isInnerCell ? tableElement.StartTag.Parent : currentCell.Parent;
currentCell.Remove();
parentRow.Add(currentCell);
}
return currentCell;
}
public void TestProcessWithStaticCells()
{
XElement root;
using (var docStream = AssemblyResourceHelper.GetResourceStream(this, "TableProcessorWithStaticCellsTest.xml"))
{
var document = XDocument.Load(docStream);
root = document.Root.Element(WordMl.BodyName);
}
var tableTag = this.GetTableTag(root);
Func<XElement, IEnumerable<TableElement>> MakeTableElementCallback = element =>
{
var tags = element.Descendants(WordMl.SdtName).ToList();
var index =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("itemindex"));
var issueDate =
tags.Find(
e =>
e.Element(WordMl.SdtPrName)
.Element(WordMl.TagName)
.Attribute(WordMl.ValAttributeName)
.Value.ToLower()
.Equals("itemtext") && e.Element(WordMl.SdtContentName).Value == "./IssueDate");
IEnumerable<TableElement> tableElements = new TableElement[]
{
new TableElement
{
IsIndex = true,
IsItem = false,
IsItemIf = false,
StartTag = index,
},
new TableElement
{
IsItem = true,
IsIndex = false,
IsItemIf = false,
StartTag = issueDate,
Expression = "./IssueDate"
},
};
return tableElements;
};
tableTag.MakeTableElementCallback = MakeTableElementCallback;
var tableProcessor = new TableProcessor
{
TableTag = tableTag,
DataReader = this.dataReader
};
tableProcessor.Process();
var expectedTableStructure = new[]
{
new[] { "#", "Certificate", "Date" },
new[] { string.Empty, string.Empty, "Issue", "Expiration" },
new[] { "1", "2", "3", "4" },
new[] { "1", "First static text", "01.04.2014", "Second static text" },
new[] { "2", "First static text", "01.03.2014", "Second static text" },
new[] { "3", "First static text", "01.01.2011", "Second static text" },
new[] { "This", "row", "stays", "untouched" },
};
var rows = tableTag.Table.Elements(WordMl.TableRowName).ToList();
Assert.AreEqual(expectedTableStructure.Count(), rows.Count());
int rowIndex = 0;
foreach (var row in rows)
{
var expectedRow = expectedTableStructure[rowIndex];
var cellsInRow = row.Elements(WordMl.TableCellName).ToList();
Assert.AreEqual(expectedRow.Count(), cellsInRow.Count());
int cellIndex = 0;
foreach (var cell in cellsInRow)
{
Assert.AreEqual(expectedRow[cellIndex], cell.Value);
cellIndex++;
}
rowIndex++;
}
this.ValidateTagsRemoved(root);
}
private XElement ProcessStaticCells(TableElement tableElement, XElement previous)
{
var currentElement = tableElement.HasCell()
? tableElement.StartTag
: this.CurrentCell(tableElement);
return ProcessStaticCells(currentElement, previous);
}
public void TestProcessItemIfCells()
{
XElement root;
using (var docStream = AssemblyResourceHelper.GetResourceStream(this, "TableItemIfsTest.xml"))
{
var document = XDocument.Load(docStream);
root = document.Root.Element(WordMl.BodyName);
}
var tableTag = this.GetTableTag(root);
XDocument data;
using (var docStream = AssemblyResourceHelper.GetResourceStream(this, "TableItemIfsData.xml"))
{
data = XDocument.Load(docStream);
}
Func<XElement, IEnumerable<TableElement>> MakeTableElementCallback = element =>
{
var cells = element.Descendants(WordMl.TableCellName).ToList();
ICollection<TableElement> tableElements = new Collection<TableElement>();
foreach (var cell in cells)
{
var cellTags = cell.Descendants(WordMl.SdtName).ToList();
var firtsIf = new TableElement
{
IsIndex = false,
IsItem = false,
IsItemIf = true,
StartTag = cellTags[0],
EndTag = cellTags[2],
Expression = cellTags[0].Value,
TagElements =
new TableElement[]
{
new TableElement
{
IsIndex = false,
IsItemIf = false,
IsItem = true,
StartTag = cellTags[1],
Expression = cellTags[1].Value,
}
}
};
var secondIf = new TableElement
{
IsIndex = false,
IsItem = false,
IsItemIf = true,
StartTag = cellTags[3],
EndTag = cellTags[5],
Expression = cellTags[3].Value,
TagElements =
new TableElement[]
{
new TableElement
{
IsIndex = false,
IsItemIf = false,
IsItem = true,
StartTag = cellTags[4],
Expression = cellTags[4].Value,
}
}
};
tableElements.Add(firtsIf);
tableElements.Add(secondIf);
}
return tableElements;
};
tableTag.MakeTableElementCallback = MakeTableElementCallback;
var tableProcessor = new TableProcessor
{
TableTag = tableTag,
DataReader = DataReaderFactory.CreateReader(data)
};
tableProcessor.Process();
var expectedTableStructure = new[]
{
new[] { "#", "Certificate", "Date" },
new[] { string.Empty, string.Empty, "Issue", "Expiration" },
new[] { "1", "2", "3", "4" },
new[] { "row1 - value1", "row1 - value2", "row1 - value3", "row1 - value4" },
new[] { "row2 - value1", "row2 - value2", "row2 - value3", "row2 - value4" },
new[] { "row3 - value1", "row3 - value2", "row3 - value3", "row3 - value4" },
new[] { "row4 - value1", "row4 - value2", "row4 - value3", "row4 - value4" },
new[] { "row5 - value1", "row5 - value2", "row5 - value3", "row5 - value4" },
new[] { "This", "row", "stays", "untouched" },
};
var rows = tableTag.Table.Elements(WordMl.TableRowName).ToList();
Assert.AreEqual(expectedTableStructure.Count(), rows.Count());
int rowIndex = 0;
foreach (var row in rows)
{
var expectedRow = expectedTableStructure[rowIndex];
var cellsInRow = row.Elements(WordMl.TableCellName).ToList();
Assert.AreEqual(expectedRow.Count(), cellsInRow.Count());
int cellIndex = 0;
foreach (var cell in cellsInRow)
{
Assert.AreEqual(expectedRow[cellIndex], cell.Value);
cellIndex++;
}
rowIndex++;
}
/*
var tagsBetween =
tableTag.TagTable.ElementsAfterSelf().Where(element => element.IsBefore(tableTag.TagContent));
Assert.IsFalse(tagsBetween.Any());
tagsBetween =
tableTag.TagEndContent.ElementsAfterSelf().Where(element => element.IsBefore(tableTag.TagEndTable));
Assert.IsFalse(tagsBetween.Any());*/
this.ValidateTagsRemoved(root);
}
private XElement CurrentCell(TableElement tableElement)
{
return tableElement.StartTag.Descendants(WordMl.TableCellName).FirstOrDefault()
?? tableElement.StartTag.Ancestors().First(element => element.Name == WordMl.TableCellName);
}
public void TableElementForValidElement()
{
var tableElement = new TableElement(_tableSearchFilterDemoPage.TaskTable);
tableElement.Should().NotBeNull();
}
public static IElement ParseElement(string localizedType, string designedId, string designedName, IElement parent)
{
IElement element = null;
switch (localizedType.ToLower())
{
case ElementBase.WINDOW:
element = new WindowElement();
element.Attributes.ElementType = ElementBase.WINDOW_TYPE;
break;
case ElementBase.DIALOG:
element = new WindowElement();
element.Attributes.ElementType = ElementBase.DIALOG_TYPE;
break;
case ElementBase.BUTTON:
element = new ButtonElement();
element.Attributes.ElementType = ElementBase.BUTTON_TYPE;
break;
case ElementBase.COMBO_BOX:
element = new ComboBoxElement();
element.Attributes.ElementType = ElementBase.COMBOBOX_TYPE;
break;
case ElementBase.TEXT:
element = new TextElement();
element.Attributes.ElementType = ElementBase.TEXT_TYPE;
break;
case ElementBase.PANE:
element = new ContainerElement();
element.Attributes.ElementType = ElementBase.CONTAINER_TYPE;
break;
case ElementBase.TITLE_BAR:
element = new TitleBarElement();
element.Attributes.ElementType = ElementBase.TITLEBAR_TYPE;
break;
case ElementBase.MENU_BAR:
element = new MenuBarElement();
element.Attributes.ElementType = ElementBase.MENUBAR_TYPE;
break;
case ElementBase.DOCUMENT:
element = new EditableTextElement();
element.Attributes.ElementType = ElementBase.EDITABLETEXT_TYPE;
break;
case ElementBase.TAB:
element = new TabPageElement();
element.Attributes.ElementType = ElementBase.TABPAGE_TYPE;
break;
case ElementBase.TAB_ITEM:
element = new TabItemElement();
element.Attributes.ElementType = ElementBase.TABITEM_TYPE;
break;
case ElementBase.SCROLL_BAR:
element = new ScrollBarElement();
element.Attributes.ElementType = ElementBase.SCROLLBAR_TYPE;
break;
//case THUMB:
case ElementBase.TREE:
element = new TreeViewElement();
element.Attributes.ElementType = ElementBase.TREEVIEW_TYPE;
break;
case ElementBase.TREE_VIEW:
element = new TreeViewElement();
element.Attributes.ElementType = ElementBase.TREEVIEW_TYPE;
break;
case ElementBase.TREE_ITEM:
element = new TreeItemElement();
element.Attributes.ElementType = ElementBase.TREEITEM_TYPE;
break;
case ElementBase.TABLE:
element = new TableElement();
element.Attributes.ElementType = ElementBase.TABLE_TYPE;
break;
//?
case ElementBase.HEADER:
element = new HeaderElement();
element.Attributes.ElementType = ElementBase.HEADER_TYPE;
break;
case ElementBase.ITEM:
if (parent != null && (parent is TableElement || parent is DatagridElement))
{
element = new RowElement();
element.Attributes.ElementType = ElementBase.ROW_TYPE;
}
break;
case ElementBase.LIST: //(listview or checkedlistbox)
element = new ListElement();
element.Attributes.ElementType = ElementBase.LIST_TYPE;
break;
case ElementBase.LIST_VIEW: //(listview or checkedlistbox)
element = new ListElement();
element.Attributes.ElementType = ElementBase.LIST_TYPE;
break;
case ElementBase.LIST_ITEM: //(table)
element = new ListItemElement();
element.Attributes.ElementType = ElementBase.LISTITEM_TYPE;
break;
case ElementBase.EDIT: //textbox
element = new EditableTextElement();
element.Attributes.ElementType = ElementBase.EDITABLETEXT_TYPE;
break;
case ElementBase.CHECK_BOX:
element = new CheckBoxElement();
element.Attributes.ElementType = ElementBase.CHECKBOX_TYPE;
break;
case ElementBase.RADIO_BUTTON:
element = new RadioButtonElement();
element.Attributes.ElementType = ElementBase.RADIO_BUTTON_TYPE;
break;
case ElementBase.CALENDAR:
element = new CalendarElement();
element.Attributes.ElementType = "Calendar";
break;
case ElementBase.CUSTOM:
element = new CustomElement();
element.Attributes.ElementType = "Custom";
break;
case ElementBase.DATAGRID:
element = new DatagridElement();
element.Attributes.ElementType = "DataGrid";
break;
case ElementBase.DATAGRID2:
element = new DatagridElement();
element.Attributes.ElementType = "DataGrid";
break;
case ElementBase.DATAITEM:
element = new DataitemElement();
element.Attributes.ElementType = "dataitem";
break;
case ElementBase.GROUP:
element = new GroupELement();
element.Attributes.ElementType = ElementBase.GROUP_TYPE;
break;
case ElementBase.HEADER_ITEM:
element = new HeaderItemElement();
element.Attributes.ElementType = "HeaderItem";
break;
case ElementBase.HYPERLINK:
element = new LinkElement();
element.Attributes.ElementType = "Hyperlink";
break;
case ElementBase.IMAGE:
element = new ImageElement();
element.Attributes.ElementType = "Image";
break;
case ElementBase.MENU:
element = new MenuElement();
element.Attributes.ElementType = "Menu";
break;
case ElementBase.PROGRESS_BAR:
element = new ProgressBarElement();
element.Attributes.ElementType = "ProgressBar";
break;
case ElementBase.SEPARATOR:
element = new SeparatorElement();
element.Attributes.ElementType = "Separator";
break;
case ElementBase.SLIDER:
element = new SliderElement();
element.Attributes.ElementType = "Slider";
break;
case ElementBase.SPINNER:
element = new SpinnerElement();
element.Attributes.ElementType = "Spinner";
break;
case ElementBase.SPLIT_BUTTON:
element = new SplitButtonElement();
element.Attributes.ElementType = "SplitButton";
break;
case ElementBase.STATUS_BAR:
element = new StatusBarElement();
element.Attributes.ElementType = "StatusBar";
break;
case ElementBase.TOOL_BAR:
element = new ToolBarElement();
element.Attributes.ElementType = "ToolBar";
break;
case ElementBase.TOOL_TIP:
element = new ToolTipElement();
element.Attributes.ElementType = "ToolTip";
break;
//?
case ElementBase.MENU_ITEM:
element = new MenuItemElement();
element.Attributes.ElementType = "MenuItem";
break;
case ElementBase.LINK:
element = new LinkElement();
element.Attributes.ElementType = ElementBase.LINK_TYPE;
break;
}
if (element == null)
{
if (parent is TableElement || parent is DatagridElement)
{
element = new RowElement();
element.Attributes.ElementType = ElementBase.ROW_TYPE;
}
else if (parent is RowElement)
{
element = new CellElement();
element.Attributes.ElementType = ElementBase.CELL_TYPE;
}
else
{
element = new UnknownELement();
element.Attributes.ElementType = ElementBase.UNKNOWN_TYPE;
}
}
element.Attributes.DesignedId = designedId;
return(element);
}
