/// <summary> /// Insert the specified <paramref name="maintainables"/> to the mapping store. /// </summary> /// <param name="maintainables"> /// The maintainable. /// </param> /// <returns> /// The <see cref="IEnumerable{ArtefactImportStatus}"/>. /// </returns> public new IEnumerable <ArtefactImportStatus> Insert(IEnumerable <ICategorisationObject> maintainables) { var cache = new StructureCache(); foreach (var artefact in maintainables) { using (DbTransactionState state = DbTransactionState.Create(this.Database)) { ArtefactImportStatus artefactImportStatus; try { artefactImportStatus = this.InsertInternal(state, artefact, cache); state.Commit(); } catch (MappingStoreException e) { _log.Error(artefact.Urn.ToString(), e); state.RollBack(); artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e)); } catch (DbException e) { _log.Error(artefact.Urn.ToString(), e); state.RollBack(); artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e)); } yield return(artefactImportStatus); } } }
/// <summary> /// Insert or replace artefacts. /// </summary> /// <param name="maintainables"> /// The maintainables. /// </param> /// <typeparam name="T"> /// The <see cref="IMaintainableObject"/> based interface /// </typeparam> /// <returns> /// The <see cref="IEnumerable{ArtefactImportStatus}"/>. /// </returns> protected IEnumerable <ArtefactImportStatus> ReplaceOrInsert <T>(IEnumerable <T> maintainables) where T : IMaintainableObject { foreach (var artefact in maintainables) { using (DbTransactionState state = DbTransactionState.Create(this._database)) { ArtefactImportStatus artefactImportStatus; try { artefactImportStatus = this.ReplaceOrInsert(state, artefact); state.Commit(); } catch (MappingStoreException e) { _log.Error(artefact.Urn.ToString(), e); state.RollBack(); artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e)); } catch (DbException e) { _log.Error(artefact.Urn.ToString(), e); state.RollBack(); artefactImportStatus = new ArtefactImportStatus(-1, artefact.AsReference.GetErrorMessage(e)); } yield return(artefactImportStatus); } } }
/// <summary> /// Replace or insert the specified <paramref name="artefact"/> to MAPPING STORE /// </summary> /// <param name="state"> /// The state. /// </param> /// <param name="artefact"> /// The artefact. /// </param> /// <exception cref="ArgumentNullException"> /// <paramref name="state"/> is null /// -or- /// <paramref name="artefact"/> is null /// </exception> /// <returns> /// The <see cref="ArtefactImportStatus"/>. /// </returns> protected ArtefactImportStatus ReplaceOrInsert(DbTransactionState state, IMaintainableObject artefact) { if (state == null) { throw new ArgumentNullException("state"); } if (artefact == null) { throw new ArgumentNullException("artefact"); } var structureReference = artefact.AsReference; _log.DebugFormat(CultureInfo.InvariantCulture, "Replacing or Insert artefact = {0}", structureReference); var finalStatus = GetFinalStatus(state, structureReference); ArtefactImportStatus status; if (finalStatus == null || finalStatus.PrimaryKey < 0) { status = this.InsertArtefact(state, artefact); } else if (!finalStatus.IsFinal) { this.Delete(state, finalStatus.PrimaryKey); status = this.InsertArtefact(state, artefact); } else { status = new ArtefactImportStatus(finalStatus.PrimaryKey, this.GetCannotReplaceMessage(structureReference)); } return(status); }
/// <summary> /// Insert the specified <paramref name="maintainable"/> to mapping store <c>CATEGORISATION</c> table /// </summary> /// <param name="state"> /// The state. /// </param> /// <param name="maintainable"> /// The maintainable. /// </param> /// <param name="cache"> /// The cached Dataflow and Category Scheme /// </param> /// <returns> /// The <see cref="ArtefactImportStatus"/>. /// </returns> private ArtefactImportStatus InsertInternal(DbTransactionState state, ICategorisationObject maintainable, StructureCache cache) { var dataflowStatus = cache.GetStructure(state, maintainable.StructureReference); ArtefactImportStatus returnValue; if (dataflowStatus.FinalStatus.PrimaryKey > 0) { var categoryScheme = cache.GetStructure(state, maintainable.CategoryReference); if (categoryScheme.FinalStatus.PrimaryKey > 0 && categoryScheme.FinalStatus.IsFinal) { var categoryPrimaryKey = this.GetCategoryPrimaryKey(state, maintainable, categoryScheme); if (!ExistsCategorisation(state, dataflowStatus.FinalStatus.PrimaryKey, categoryPrimaryKey.SysID)) { var artefactStoredProcedure = _storedProcedures.InsertCategorisation; returnValue = this.InsertArtefactInternal( state, maintainable, artefactStoredProcedure, command => { artefactStoredProcedure.CreateArtIdParameter(command).Value = dataflowStatus.FinalStatus.PrimaryKey; artefactStoredProcedure.CreateCatIdParameter(command).Value = categoryPrimaryKey.SysID; }); string message = string.Format( CultureInfo.InvariantCulture, "Successfully categorized {0} with Category {1} of {2}\n", maintainable.StructureReference.GetAsHumanReadableString(), maintainable.CategoryReference.ChildReference.Id, maintainable.CategoryReference.GetAsHumanReadableString()); returnValue = new ArtefactImportStatus(returnValue.PrimaryKeyValue, new ImportMessage(ImportMessageStatus.Success, maintainable.AsReference, message)); } else { returnValue = BuildWarningMessage(maintainable, "Warning: Ignoring duplicate categorisation of {0} with {1}\n"); } } else if (!categoryScheme.FinalStatus.IsFinal) { returnValue = BuildWarningMessage(maintainable, "Failure: {0} is not Final so it cannot be referenced from {1}\n"); } else { returnValue = BuildWarningMessage(maintainable, "Failure: {0} does not exist so it cannot be referenced from {1}\n"); } } else { string message = string.Format(CultureInfo.InvariantCulture, "Failure: Cannot categorize {0}, because it does not exist\n", maintainable.StructureReference.GetAsHumanReadableString()); returnValue = new ArtefactImportStatus(-1, new ImportMessage(ImportMessageStatus.Warning, maintainable.AsReference, message)); } return(returnValue); }
/// <summary> /// Inserts the content constraint attachment. /// </summary> /// <param name="state"> /// The state. /// </param> /// <param name="maintainable"> /// The maintainable. /// </param> /// <param name="artefactStatus"> /// The artefact status. /// </param> private void InsertContentConstraintAttachment(DbTransactionState state, IContentConstraintObject maintainable, ArtefactImportStatus artefactStatus) { if (maintainable.ConstraintAttachment == null) { return; } var procedure = new InsertContentConstraintAttachmentProcedure(); var structureCache = new StructureCache(); using (var command = procedure.CreateCommand(state)) { procedure.CreateContentConstraintIdParameter(command, artefactStatus.PrimaryKeyValue); foreach (var crossReference in maintainable.ConstraintAttachment.StructureReference) { var itemSchemeFinalStatus = structureCache.GetStructure(state, crossReference); this._validateStatusEngine.ValidateFinalStatus(itemSchemeFinalStatus.FinalStatus, crossReference); procedure.CreateArtefactIdParameter(command, itemSchemeFinalStatus.FinalStatus.PrimaryKey); command.ExecuteNonQuery(); } } }
/// <summary> /// Inserts the cube region. /// </summary> /// <param name="state">The state.</param> /// <param name="cubeRegion">The cube region.</param> /// <param name="artefactStatus">The artefact status.</param> /// <param name="isInclude">if set to <c>true</c> [is include].</param> private static void InsertCubeRegion(DbTransactionState state, ICubeRegion cubeRegion, ArtefactImportStatus artefactStatus, bool isInclude) { var procedure = new InsertCubeRegionProcedure(); long cubeRegionPrimaryKey; using (var command = procedure.CreateCommand(state)) { procedure.CreateContentConstraintIdParameter(command, artefactStatus.PrimaryKeyValue); procedure.CreateIncludeParameter(command, isInclude); var outputParameter = procedure.CreateOutputParameter(command); command.ExecuteNonQuery(); cubeRegionPrimaryKey = (long)outputParameter.Value; } // handle dimensions var keyValuesWithId = InsertKeyValues(state, isInclude, cubeRegionPrimaryKey, cubeRegion.KeyValues, SdmxComponentType.Dimension); InsertValues(state, isInclude, keyValuesWithId); // handle attributes var attrValuesWithId = InsertKeyValues(state, isInclude, cubeRegionPrimaryKey, cubeRegion.AttributeValues, SdmxComponentType.Attribute); InsertValues(state, isInclude, attrValuesWithId); }
/// <summary> /// Insert the specified <paramref name="maintainable"/> as dataflow if <paramref name="maintainable"/> is final. /// </summary> /// <param name="state"> /// The state. /// </param> /// <param name="maintainable"> /// The <see cref="IDataStructureObject"/>. /// </param> /// <param name="artefactStatus"> /// The artefact status. /// </param> /// <remarks> /// This method inserts the specified data structure object (DSD) as dataflow. It is not an error. /// </remarks> private void InsertAsDataflow(DbTransactionState state, IDataStructureObject maintainable, ArtefactImportStatus artefactStatus) { if (maintainable.IsFinal.IsTrue) { var dataflowStoredProcedure = new StoredProcedures().InsertDataflow; var artefactFinalStatus = GetFinalStatus(state, new StructureReferenceImpl(maintainable.AsReference, SdmxStructureEnumType.Dataflow)); if (artefactFinalStatus.IsEmpty) { this.InsertArtefactInternal( state, maintainable, dataflowStoredProcedure, command => { dataflowStoredProcedure.CreateDsdIdParameter(command).Value = artefactStatus.PrimaryKeyValue; dataflowStoredProcedure.CreateMapSetIdParameter(command); }); } } }