/// <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) { if (this.executionMode == 1) { repository.ExecuteOperations(changeset); } else { DBXml xml = new DBXml(); DBTable tab = xml.AddTable(this.MainObjectTag); foreach (var valuation in changeset.Table(this.MainObjectTag).Rows) { Guid?savepointName = null; var row = tab.AddRow(valuation); try { savepointName = Guid.NewGuid(); this.repository.CreateSavepoint(savepointName.ToString()); repository.ExecuteOperations(xml); } catch (SqlException) { if (savepointName.HasValue) { this.repository.RollbackToSavepoint(savepointName.ToString()); } } row.Remove(); } } }
/// <summary> /// Gets the number indicating previous version of bussiness object within database xml. /// </summary> /// <param name="dbXml">The database xml.</param> /// <returns>Previous version of bussiness object.</returns> public virtual Dictionary <string, string> GetPreviousVersion(DBXml dbXml) { var result = new Dictionary <string, string>(1); if (dbXml.Table(MainObjectTag).FirstRow().Action == DBRowState.Delete) { var ver = dbXml.Table(MainObjectTag).FirstRow().Element("version"); if (ver != null) { result.Add(String.Empty, dbXml.Table(MainObjectTag).FirstRow().Element("version").Value); } else { return(null); } } else if (dbXml.PreviousVersion != null) { result.Add(String.Empty, dbXml.PreviousVersion); } else { return(null); } return(result); }
/// <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) { this.repository.ExecuteOperations(changeset); List <string> indexedContractors = new List <string>(); XDocument xml = XDocument.Parse("<root businessObjectId=\"\" mode=\"\" />"); var mainItem = this.CurrentPackage.Xml.Root.Descendants("contractorId").FirstOrDefault(); if (mainItem != null) { xml.Root.Attribute("businessObjectId").Value = mainItem.Value; xml.Root.Attribute("mode").Value = DBRowState.Update.ToStateName(); this.repository.IndexContractor(xml); indexedContractors.Add(xml.Root.Attribute("businessObjectId").Value); } foreach (DBRow row in changeset.Table(MainObjectTag).Rows) { if (row.Action == DBRowState.Delete) { continue; } string id = row.Element("relatedContractorId").Value; if (indexedContractors.Contains(id) == true) { continue; } xml.Root.Attribute("businessObjectId").Value = id; xml.Root.Attribute("mode").Value = DBRowState.Update.ToStateName(); indexedContractors.Add(xml.Root.Attribute("businessObjectId").Value); this.repository.IndexContractor(xml); } }
public DepartmentStatistics GetDetailedStatistics(Guid branchId) { if (this.database.State != ConnectionState.Open) { this.database.Open(); } using (SqlCommand cmd = this.helper.CreateCommand(StoredProcedure.communication_p_getStatisticsDetails.ToProcedureName(), new SqlParameter("@branchId", SqlDbType.UniqueIdentifier), branchId)) { XDocument statisticsXml = this.helper.GetXmlDocument(cmd.ExecuteXmlReader()); DBRow statistics = new DBXml(statisticsXml).Table("statistics").FirstRow(); DepartmentStatistics branchStats = new DepartmentStatistics(); branchStats.CurrentTime = DateTime.Parse(statistics.Element("currentTime").Value).Round(DateTimeAccuracy.Second); branchStats.SystemTime = DateTime.Now.Round(DateTimeAccuracy.Second); if (statistics.Element("executionMessageTime") != null) { branchStats.LastExecutionMessage = new MessageData(statistics.Element("lastExecutionMessage").Value, DateTime.Parse(statistics.Element("executionMessageTime").Value).Round(DateTimeAccuracy.Second)); } if (statistics.Element("receiveMessageTime") != null) { branchStats.LastReceiveMessage = new MessageData(statistics.Element("lastReceiveMessage").Value, DateTime.Parse(statistics.Element("receiveMessageTime").Value).Round(DateTimeAccuracy.Second)); } if (statistics.Element("sentMessageTime") != null) { branchStats.LastSendMessage = new MessageData(statistics.Element("lastSentMessage").Value, DateTime.Parse(statistics.Element("sentMessageTime").Value).Round(DateTimeAccuracy.Second)); } SynchronizeStatisticTime(branchStats); return(branchStats); } }
/// <summary> /// Gets the number indicating previous version of bussiness object within database xml. /// </summary> /// <param name="dbXml">The database xml.</param> /// <returns>Previous version of bussiness object.</returns> public override Dictionary <string, string> GetPreviousVersion(DBXml dbXml) { if (dbXml.Table(MainObjectTag).Rows.Count() == 0) { return(null); } var result = new Dictionary <string, string>(dbXml.Table(MainObjectTag).Rows.Count()); var deletedRows = dbXml.Table(MainObjectTag).Rows.Where(r => r.Action == DBRowState.Delete); if (deletedRows.Count() > 0) { foreach (var row in deletedRows) { var ver = row.Element("previousVersion"); if (ver != null) { result.Add(row.Element("id").Value, ver.Value); } } } else if (dbXml.PreviousVersion != null) { result.Add(String.Empty, dbXml.PreviousVersion); } else { return(null); } return(result); }
private static bool IsSourceBranch(DBXml shiftDocument) { Guid branchId = Guid.Empty; if (IsOutcomeshift(shiftDocument) == true) { branchId = new Guid(shiftDocument.Table("warehouseDocumentHeader").FirstRow().Element("branchId").Value); } else { string targetWarehouseId = null; string oppositeWarehouseFieldId = DictionaryMapper.Instance.GetDocumentField(Makolab.Fractus.Kernel.Enums.DocumentFieldName.ShiftDocumentAttribute_OppositeWarehouseId).Id.Value.ToString().ToUpperInvariant(); targetWarehouseId = shiftDocument.Xml.Root.Element("documentAttrValue").Elements() .Where(row => row.Element("documentFieldId").Value.Equals(oppositeWarehouseFieldId)) .Select(row => row.Element("textValue").Value) .SingleOrDefault(); if (targetWarehouseId == null) { throw new InvalidDataException("Missing target warehouse id."); } Warehouse targetWarehouse = DictionaryMapper.Instance.GetWarehouse(new Guid(targetWarehouseId)); branchId = targetWarehouse.BranchId; } return(Makolab.Fractus.Kernel.Mappers.ConfigurationMapper.Instance.DatabaseId == DictionaryMapper.Instance.GetBranch(branchId).DatabaseId); }
/// <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) { if (this.IsHeadquarter == true && IsLocal(this.CurrentPackage) == false) { base.ExecuteChangeset(changeset); } }
//Added by Manjot on 08/Aug/2017 public ActionResult GetXMLPath(string FileName, int RecordID) { Ctx ct = Session["ctx"] as Ctx; DBXml _obj = new DBXml(); return(Json(JsonConvert.SerializeObject(_obj.CreateJDBCDataSourceXml(ct, FileName, RecordID)), JsonRequestBehavior.AllowGet)); }
///// <summary> ///// Check whether database xml from communication has correct version. ///// </summary> ///// <param name="commSnapshot">The snapshot from other branch.</param> ///// <param name="dbXml">The snapshot created from database.</param> ///// <returns><c>true</c> if database xml from communication has correct version; otherwise, <c>false</c>.</returns> //public virtual bool ValidateVersion(DBXml commSnapshot, DBXml dbXml) //{ // return GetPreviousVersion(commSnapshot)[null].Equals(dbXml.Table(MainObjectTag).FirstRow().Element("version").Value, // StringComparison.OrdinalIgnoreCase); //} /// <summary> /// Gets the number indicating previous version of bussiness object within database xml. /// </summary> /// <param name="dbXml">The database xml.</param> /// <returns>Previous version of bussiness object.</returns> public static Dictionary <string, string> GetPreviousVersion(DBXml dbXml, string mainObjectTag) { var result = new Dictionary <string, string>(); foreach (DBRow row in dbXml.Table(mainObjectTag).Rows) { if (row.Action == DBRowState.Delete) { var ver = row.Element("version"); if (ver != null) { result.Add(row.Element("id").Value, ver.Value); } } else if (row.PreviousVersion != null) { result.Add(row.Element("id").Value, row.PreviousVersion); } } if (result.Count == 0) { return(null); } else { return(result); } }
/// <summary> /// Extracts the payment package from another package. /// </summary> /// <param name="communicationXml">The communication XML.</param> /// <param name="communicationPackage">The communication package.</param> /// <returns>Extracted payment <c>CommunicationPackage</c> object if <b>communicationXml</b> has payment data; otherwise, <c>null</c>.</returns> public static CommunicationPackage ExtractPaymentPackage(DBXml communicationXml, ICommunicationPackage communicationPackage) { if (communicationXml.Table("payment") == null || communicationXml.Table("payment").HasRows == false) { return(null); } XDocument commXml = XDocument.Parse("<root/>"); commXml.Root.Add(communicationXml.Table("payment").Xml); var settlements = communicationXml.Table("paymentSettlement"); if (settlements != null && settlements.HasRows == true) { commXml.Root.Add(settlements.Xml); } XmlTransferObject commPkgData = new XmlTransferObject { DeferredTransactionId = communicationPackage.XmlData.DeferredTransactionId, Id = Guid.NewGuid(), LocalTransactionId = communicationPackage.XmlData.LocalTransactionId, XmlType = CommunicationPackageType.Payment.ToString(), Content = commXml.ToString(SaveOptions.DisableFormatting) }; return(new CommunicationPackage(commPkgData) { DatabaseId = communicationPackage.DatabaseId });; }
/// <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) { if (changeset != null) { repository.ExecuteOperations(changeset); } }
/// <summary> /// Generates the changeset - diff beetween two snapshots. /// </summary> /// <param name="commSnapshot">The snapshot from other branch.</param> /// <param name="dbSnapshot">The snapshot created from database.</param> /// <returns>Generated xml changeset.</returns> public override DBXml GenerateChangeset(DBXml commSnapshot, DBXml dbSnapshot) { var entries = commSnapshot.Tables.SelectMany(tab => tab.Rows); foreach (var entry in entries) { if (entry.Element("id") == null) { entry.AddElement("id", entry.Element("contractorId").Value); } } if (dbSnapshot != null) { entries = dbSnapshot.Tables.SelectMany(tab => tab.Rows); foreach (var entry in entries) { if (entry.Element("id") == null) { entry.AddElement("id", entry.Element("contractorId").Value); } } } this.currentContractor = dbSnapshot; return(base.GenerateChangeset(commSnapshot, dbSnapshot)); }
/// <summary> /// Gets xml representation of bussiness object with related objects. /// </summary> /// <param name="objectId">The object id.</param> /// <returns> /// <see cref="DBXml"/> from database with specified id. /// </returns> public override DBXml GetCurrentSnapshot(Guid objectId) { DBXml snapshot = this.repository.FindCommercialWarehouseValuations(new List <Guid> { objectId }); return(GetSnapshotOrNull(snapshot)); }
/// <summary> /// Gets xml representation of bussiness object with related objects. /// </summary> /// <param name="objectId">The object id.</param> /// <returns> /// <see cref="DBXml"/> from database with specified id. /// </returns> public override DBXml GetCurrentSnapshot(Guid objectId) { DBXml snapshot = this.repository.FindIncomeOutcomeRelation(new List <Guid> { objectId }); return(GetSnapshotOrNull(snapshot)); }
private static bool IsIncomeshift(DBXml shiftDocument) { DocumentType docType = DictionaryMapper.Instance.GetDocumentType(new Guid( shiftDocument.Table("warehouseDocumentHeader") .FirstRow().Element("documentTypeId").Value)); return(docType.WarehouseDocumentOptions.WarehouseDirection == Makolab.Fractus.Kernel.Enums.WarehouseDirection.IncomeShift); }
/// <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) { this.repository.ExecuteOperations(changeset); XDocument xml = XDocument.Parse("<root businessObjectId=\"\" mode=\"\" />"); xml.Root.Attribute("businessObjectId").Value = this.CurrentPackage.Table(this.MainObjectTag).FirstRow().Element("id").Value; xml.Root.Attribute("mode").Value = changeset.Table(this.MainObjectTag).FirstRow().Xml.Attribute("action").Value; this.repository.IndexContractor(xml); }
public static void SetPreviousVersion(DBXml dbXml, Dictionary <string, string> previousVersions, string mainObjectTag) { foreach (var element in previousVersions) { var row = dbXml.Table(mainObjectTag).FindRow(element.Key); if (row != null && row.Element("version") == null) { row.AddElement("version", element.Value); } } }
/// <summary> /// Executes the changeset. Operation is persisting changes to database. /// </summary> /// <param name="changeset">The changeset that is persisted.</param> public override void ExecuteChangeset(Makolab.Fractus.Communication.DBLayer.DBXml changeset) { //remove valuations that link to lines marked as deleted if (changeset.Table("warehouseDocumentValuation") != null && changeset.Table("warehouseDocumentLine") != null) { List <DBRow> deletedValuations = new List <DBRow>(); foreach (var line in changeset.Table("warehouseDocumentLine").Rows.Where(l => l.Action == DBRowState.Delete)) { foreach (var valuation in changeset.Table("warehouseDocumentValuation").Rows) { if (valuation.Element("incomeWarehouseDocumentLineId").Value.Equals(line.Element("id").Value, StringComparison.OrdinalIgnoreCase) || valuation.Element("outcomeWarehouseDocumentLineId").Value.Equals(line.Element("id").Value, StringComparison.OrdinalIgnoreCase)) { deletedValuations.Add(valuation); } } } deletedValuations.ForEach(v => v.Remove()); } //TODO kod dodany by wykorzystywac mechanizm savepointow, ale dziwia warunki na korekte pz/wz //TODO nalezy sprawdzi czy zmiana wycen rusza wersje obiektu glownego bo wyglda na to ze nie var docType = Makolab.Fractus.Kernel.Mappers.DictionaryMapper.Instance.GetDocumentType( new Guid(this.CurrentPackage.Table(this.MainObjectTag).FirstRow().Element("documentTypeId").Value)); if ((docType.DocumentCategory == Makolab.Fractus.Kernel.Enums.DocumentCategory.IncomeWarehouseCorrection || docType.DocumentCategory == Makolab.Fractus.Kernel.Enums.DocumentCategory.OutcomeWarehouseCorrection) && changeset.Table("warehouseDocumentValuation") != null) { var warehouseValuationTable = changeset.Table("warehouseDocumentValuation"); warehouseValuationTable.Remove(); DBXml valuationXml = new DBXml(); valuationXml.AddTable(warehouseValuationTable); this.Repository.ExecuteOperations(changeset); WarehouseDocumentValuation valuationProcessor = new WarehouseDocumentValuation(this.UnitOfWork, this.ExecutionController, this.IsHeadquarter); valuationProcessor.Log = this.Log; valuationProcessor.LocalTransactionId = this.LocalTransactionId; CommunicationPackage valuationPackage = new CommunicationPackage(new XmlTransferObject() { Content = valuationXml.Xml.ToString(SaveOptions.DisableFormatting) }); valuationPackage.DatabaseId = this.package.DatabaseId; valuationPackage.XmlData.LocalTransactionId = this.package.XmlData.LocalTransactionId; valuationPackage.XmlData.DeferredTransactionId = this.package.XmlData.DeferredTransactionId; valuationProcessor.ExecutePackage(valuationPackage, 0); } else { this.Repository.ExecuteOperations(changeset); } }
public void ExecuteOperations(Action <XDocument> action, DBXml operations) { if (this.isDeffered == true) { this.ChangesetBuffer.AddOrReplaceData(operations.Tables); } else { action.Invoke(operations.Xml); } }
/// <summary> /// Generates the changeset - diff beetween two snapshots. /// </summary> /// <param name="commSnapshot">The snapshot from other branch.</param> /// <param name="dbSnapshot">The snapshot created from database.</param> /// <returns>Generated xml changeset.</returns> public override DBXml GenerateChangeset(DBXml commSnapshot, DBXml dbSnapshot) { if (dbSnapshot == null) { return(base.GenerateChangeset(commSnapshot, null)); } else { return(null); } }
public static void RemoveDeletedRows(DBXml currentXml, DBXml dbXml, string mainObjectTag, ICommunicationLog log) { currentXml.Table(mainObjectTag).Rows .Where(r => r.Action == DBRowState.Delete) .Except(dbXml == null ? new List <DBRow>(0) : dbXml.Table(mainObjectTag).Rows, new DBRowIdComparer()) .ToList() .ForEach(row => { log.Info(mainObjectTag + " id=" + row.Element("id").Value + " is already deleted, skipping row"); row.Remove(); }); }
/// <summary> /// Removes the previous version number from database xml. /// </summary> /// <param name="dbXml">The db XML.</param> /// <returns>Specified database xml without previous version number.</returns> public static DBXml RemovePreviousVersion(DBXml dbXml) { foreach (var table in dbXml.Tables) { foreach (var row in table.Rows) { row.RemovePreviousVersion(); } } return(dbXml); }
public virtual void SetPreviousVersion(DBXml dbXml, Dictionary <string, string> previousVersions) { // TODO zamienic na jakis inny wyjatek if (previousVersions.ContainsKey(String.Empty) == false) { throw new Exception("Previous version is not present in collection uder null key"); } if (dbXml.Table(MainObjectTag).FirstRow().Element("version") == null) { dbXml.Table(MainObjectTag).FirstRow().AddElement("version", previousVersions[String.Empty]); } }
/// <summary> /// Process communication package persisting it's data to database. /// </summary> /// <param name="communicationPackage">The communication package to execute.</param> /// <returns> /// <c>true</c> if execution succeeded; otherwise, <c>false</c> /// </returns> public override bool ExecutePackage(ICommunicationPackage communicationPackage) { SessionManager.VolatileElements.DeferredTransactionId = communicationPackage.XmlData.DeferredTransactionId; SessionManager.VolatileElements.LocalTransactionId = this.LocalTransactionId; this.CurrentPackage = new DBXml(XDocument.Parse(communicationPackage.XmlData.Content)); List <Guid> relationsId = new List <Guid>(); foreach (DBRow row in this.CurrentPackage.Table(this.MainObjectTag).Rows) { Guid relationId = new Guid(row.Element("id").Value); relationsId.Add(relationId); } DBXml dbSnapshot = GetCurrentSnapshot(relationsId); try { // TODO conflict detection & resolution //// Conflict detection //if (dbSnapshot != null && ValidateVersion(CurrentPackage, dbSnapshot) == false) //{ // throw new ConflictException("Conflict detected while changing " + this.MainObjectTag + " id: " + mainObjectId.ToString()); //} PackageExecutionHelper.RemoveDeletedRows(this.CurrentPackage, dbSnapshot, this.MainObjectTag, this.Log); if (this.CurrentPackage.Table(MainObjectTag).HasRows == false) { return(true); } //else do the rest DBXml changeset = GenerateChangeset(CurrentPackage, dbSnapshot); ExecuteChangeset(changeset); } catch (SqlException e) { if (e.Number == 50012) // Conflict detection { throw new ConflictException("Conflict detected while changing " + this.MainObjectTag); } else { this.Log.Error("SnapshotScript:ExecutePackage " + e.ToString()); return(false); } } return(true); }
/// <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); //because if (changeset.Table(this.MainObjectTag) != null) { bool isNew = (changeset.Table(this.MainObjectTag).FirstRow().Action.Value == DBRowState.Insert) ? true : false; XDocument xml = XDocument.Parse("<root businessObjectId=\"\" mode=\"\" />"); xml.Root.Attribute("businessObjectId").Value = this.CurrentPackage.Table(this.MainObjectTag).FirstRow().Element("id").Value; xml.Root.Attribute("mode").Value = changeset.Table(this.MainObjectTag).FirstRow().Xml.Attribute("action").Value; this.repository.IndexDocument(xml, isNew); } }
public override void SetPreviousVersion(DBXml dbXml, Dictionary <string, string> previousVersions) { base.SetPreviousVersion(dbXml, previousVersions); foreach (var objectVersion in previousVersions) { if (objectVersion.Key.Length > 0) { var row = dbXml.FindRow(r => r.Element("_commReq") != null && r.Element("_commReq").Value == objectVersion.Key); if (row != null) { row.AddElement("version", objectVersion.Value); } } } }
public override void SetPreviousVersion(DBXml dbXml, Dictionary <string, string> previousVersions) { if (dbXml.Table(MainObjectTag).Rows.Count() == 0) { return; } if (dbXml.Table(MainObjectTag).Rows.Any(r => r.Action == DBRowState.Delete)) { PackageExecutionHelper.SetPreviousVersion(dbXml, previousVersions, this.MainObjectTag); } else { base.SetPreviousVersion(dbXml, previousVersions); } }
/// <summary> /// Gets the object snapshot or null when snapshot is empty. /// </summary> /// <param name="snapshot">The snapshot.</param> /// <returns>Snapshot if snapshot is not empty; otherwise, <c>null</c></returns> protected DBXml GetSnapshotOrNull(DBXml snapshot) { if (snapshot == null) { return(null); } if (snapshot != null && snapshot.Tables.Any(table => table.HasRows) == false) { return(null); } else { return(snapshot); } }
/// <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); } }
public Dictionary <string, string> GetBranchList() { if (this.database.State != ConnectionState.Open) { this.database.Open(); } using (SqlCommand cmd = this.helper.CreateCommand(StoredProcedure.dictionary_p_getBranches.ToProcedureName())) { XDocument branchXml = this.helper.GetXmlDocument(cmd.ExecuteXmlReader()); DBXml branches = new DBXml(branchXml); Dictionary <string, string> branchList = new Dictionary <string, string>(); foreach (var branch in branches.Table("branch").Rows) { branchList.Add(branch.Element("id").Value, branch.Element("xmlLabels").Element("labels").Element("label").Value); } return(branchList); } }