/// <summary>
/// Creates communication xml for related versioned items of the specified <see cref="Item"/>.
/// </summary>
/// <param name="item"><see cref="Item"/> that may contains the related items.</param>
/// <param name="localTransactionId">Local transaction ID.</param>
/// <param name="deferredTransactionId">Deferred transaction ID.</param>
private void CreateCommunicationXmlForRelatedVersionedItems(Item item, Guid localTransactionId, Guid deferredTransactionId)
{
foreach (ItemRelation relation in item.Relations.Children)
{
IVersionedBusinessObject related = relation.RelatedObject as IVersionedBusinessObject;
if (related != null && (related.Status == BusinessObjectStatus.Modified || related.Status == BusinessObjectStatus.New ||
related.ForceSave == true))
{
ItemRelationType relationType = DictionaryMapper.Instance.GetItemRelationType(relation.ItemRelationTypeId);
string relatedObjectType = relationType.Metadata.Element("relatedObjectType").Value;
switch (relatedObjectType)
{
case "Item":
this.CreateCommunicationXmlForVersionedBusinessObject(related, localTransactionId, deferredTransactionId, StoredProcedure.communication_p_createItemPackage);
break;
case "Contractor":
this.CreateCommunicationXmlForVersionedBusinessObject(related, localTransactionId, deferredTransactionId, StoredProcedure.communication_p_createContractorPackage);
break;
}
}
}
}
/// <summary>
/// Recursively creates new children (BusinessObjects) and attaches them to proper xml elements.
/// </summary>
/// <param name="element">Xml element to attach.</param>
public override void Deserialize(XElement element)
{
base.Deserialize(element);
ItemRelationType relType = DictionaryMapper.Instance.GetItemRelationType(this.ItemRelationTypeId);
string relatedObjectType = relType.Metadata.Element("relatedObjectType").Value;
//update the relation type name
this.itemRelationTypeName = relType.TypeName;
IBusinessObject obj = BusinessObjectHelper.CreateRelatedBusinessObjectFromXmlElement((XElement)element.Element("relatedObject").FirstNode,
relatedObjectType);
this.RelatedObject = obj;
}
/// <summary>
/// Executes the changeset. Operation is persisting changes to database.
/// </summary>
/// <param name="changeset">The changeset that is persisted.</param>
public override void ExecuteChangeset(DBXml changeset)
{
repository.ExecuteOperations(changeset);
List <string> indexedItems = new List <string>();
XDocument xml = XDocument.Parse("<root businessObjectId=\"\" mode=\"\" />");
var mainItem = this.CurrentPackage.Xml.Root.Descendants("itemId").FirstOrDefault();
if (mainItem != null)
{
xml.Root.Attribute("businessObjectId").Value = mainItem.Value;
xml.Root.Attribute("mode").Value = DBRowState.Update.ToStateName();
this.repository.IndexItem(xml);
indexedItems.Add(xml.Root.Attribute("businessObjectId").Value);
}
foreach (DBRow row in changeset.Table(MainObjectTag).Rows)
{
if (row.Action == DBRowState.Delete)
{
continue;
}
string id = row.Element("relatedObjectId").Value;
if (indexedItems.Contains(id) == true)
{
continue;
}
xml.Root.Attribute("businessObjectId").Value = id;
xml.Root.Attribute("mode").Value = DBRowState.Update.ToStateName();
ItemRelationType relationType = DictionaryMapper.Instance.GetItemRelationType(new Guid(row.Element("itemRelationTypeId").Value));
string relatedObjectType = relationType.Metadata.Element("relatedObjectType").Value;
switch (relatedObjectType)
{
case "Item":
this.repository.IndexItem(xml);
break;
case "Contractor":
this.contractorRepository.IndexContractor(xml);
break;
}
indexedItems.Add(xml.Root.Attribute("businessObjectId").Value);
}
}
/// <summary>
/// Updates <see cref="IBusinessObject"/> dictionary index in the database.
/// </summary>
/// <param name="obj"><see cref="IBusinessObject"/> for which to update the index.</param>
public override void UpdateDictionaryIndex(IBusinessObject obj)
{
Item item = (Item)obj;
XDocument xml = XDocument.Parse("<root businessObjectId=\"\" mode=\"\" />");
//update main contractor
if (item.Status == BusinessObjectStatus.Modified || item.Status == BusinessObjectStatus.New ||
item.ForceSave == true)
{
xml.Root.Attribute("businessObjectId").Value = item.Id.ToUpperString();
xml.Root.Attribute("mode").Value = item.Status == BusinessObjectStatus.New ? "insert" : "update";
this.ExecuteStoredProcedure(StoredProcedure.item_p_updateItemDictionary, false, xml
, ConfigurationMapper.Instance.UpdateDictionaryIndexTimeout);
}
//update related items
foreach (ItemRelation relation in item.Relations.Children)
{
IVersionedBusinessObject bo = relation.RelatedObject as IVersionedBusinessObject;
if (bo != null && (bo.Status == BusinessObjectStatus.Modified || bo.Status == BusinessObjectStatus.New ||
bo.ForceSave == true))
{
xml.Root.Attribute("businessObjectId").Value = bo.Id.ToUpperString();
xml.Root.Attribute("mode").Value = bo.Status == BusinessObjectStatus.New ? "insert" : "update";
ItemRelationType relationType = DictionaryMapper.Instance.GetItemRelationType(relation.Id.Value);
string relatedObjectType = relationType.Metadata.Element("relatedObjectType").Value;
switch (relatedObjectType)
{
case "Item":
this.ExecuteStoredProcedure(StoredProcedure.item_p_updateItemDictionary, false, xml
, ConfigurationMapper.Instance.UpdateDictionaryIndexTimeout);
break;
case "Contractor":
this.ExecuteStoredProcedure(StoredProcedure.contractor_p_updateContractorDictionary, false, xml
, ConfigurationMapper.Instance.UpdateDictionaryIndexTimeout);
break;
}
}
}
}
/// <summary>
/// Converts ItemRelation table from database xml format to <see cref="BusinessObject"/>'s xml format.
/// </summary>
/// <param name="xml">Full xml with all tables in database format.</param>
/// <param name="id">Id of the currently processed <see cref="Item"/>.</param>
/// <param name="outXml">Output xml in <see cref="BusinessObject"/>'s xml format.</param>
private void ConvertItemRelationsFromDbToBoXmlFormat(XDocument xml, Guid id, XDocument outXml)
{
if (xml.Root.Element("itemRelation") != null)
{
XElement relations = new XElement("relations");
outXml.Root.Element("item").Add(relations);
var elements = from node in xml.Root.Element("itemRelation").Elements()
where node.Element("itemId").Value == id.ToUpperString()
orderby Convert.ToInt32(node.Element("order").Value, CultureInfo.InvariantCulture) ascending
select node;
foreach (XElement element in elements)
{
XElement relation = new XElement("relation");
relations.Add(relation);
foreach (XElement relElement in element.Elements())
{
if (relElement.Name.LocalName != "itemId" && relElement.Name.LocalName != "relatedObjectId")
{
relation.Add(relElement);
}
}
XElement relatedObject = new XElement("relatedObject");
relation.Add(relatedObject);
//get and nest the related object
Guid itemRelationTypeId = new Guid(relation.Element("itemRelationTypeId").Value);
ItemRelationType relType = DictionaryMapper.Instance.GetItemRelationType(itemRelationTypeId);
string relatedObjectType = relType.Metadata.Element("relatedObjectType").Value;
string relatedObjectId = element.Element("relatedObjectId").Value;
switch (relatedObjectType)
{
case "Contractor":
relatedObject.Add(from node in xml.Root.Element("contractor").Elements()
where node.Element("id").Value == relatedObjectId
select node);
XElement contractorElement = (XElement)relatedObject.FirstNode;
contractorElement.Name = XName.Get("contractor", String.Empty);
if (contractorElement.Element("isEmployee").Value == "1")
{
contractorElement.Add(new XAttribute("type", "Employee"));
}
else if (contractorElement.Element("isBank").Value == "1")
{
contractorElement.Add(new XAttribute("type", "Bank"));
}
else
{
contractorElement.Add(new XAttribute("type", "Contractor"));
}
break;
case "Item":
XDocument xdoc = this.ExecuteStoredProcedure(StoredProcedure.item_p_getItemData, true, "@itemId", relatedObjectId);
relatedObject.Add(from node in xdoc.Root.Element("item").Elements()
where node.Element("id").Value == relatedObjectId
select node);
XElement itemElement = (XElement)relatedObject.FirstNode;
itemElement.Name = XName.Get("item", String.Empty);
itemElement.Add(new XAttribute("type", "Item"));
break;
case "CustomXmlList":
string procName = relType.Metadata.Element("procedureName").Value;
StoredProcedure sp = (StoredProcedure)Enum.Parse(typeof(StoredProcedure), procName);
if (sp == StoredProcedure.item_p_getItemEquivalents)
{
XElement eqXml = this.GetItemEquivalents(id, new Guid(relatedObjectId));
eqXml.Add(new XElement("id", relatedObjectId));
eqXml.Add(new XElement("version", relatedObjectId));
relatedObject.Add(new XElement("customXmlList", eqXml.Elements())); //cloning
}
break;
}
//add attributes
XElement relationAttributes = this.ConvertItemRelationAttributesFromDbToBoXmlFormat(xml, new Guid(relation.Element("id").Value));
relation.Add(relationAttributes);
}
}
}
