/// <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);
}
private static ISet <ICategorisationObject> GetCategorisations(
IMaintainableObject maintainable, IEnumerable <ICategorisationObject> categorisations)
{
ISet <ICategorisationObject> returnSet = new HashSet <ICategorisationObject>();
if (maintainable.IsExternalReference.IsTrue)
{
return(returnSet);
}
/* foreach */
foreach (ICategorisationObject cat in categorisations)
{
if (cat.IsExternalReference.IsTrue)
{
continue;
}
if (cat.StructureReference.TargetReference.EnumType == maintainable.StructureType.EnumType)
{
if (MaintainableUtil <IMaintainableObject> .Match(maintainable, cat.StructureReference))
{
returnSet.Add(cat);
}
}
}
return(returnSet);
}
public MaintainableObjectBaseCore(IMaintainableObject maintainable) : base(maintainable) {
//TODO AgencyId should be full agency
this.builtFrom = maintainable;
this.agencyId = maintainable.AgencyId;
this.version = maintainable.Version;
this.isFinal = maintainable.IsFinal().IsTrue;
this.isStub = maintainable.Stub;
}
/// <summary>
/// The write structure.
/// </summary>
/// <param name="bean">
/// The maintainable object.
/// </param>
/// <exception cref="NotImplementedException">
/// SDMX EDI for structures is not implemented in this implementation.
/// </exception>
public virtual void WriteStructure(IMaintainableObject bean)
{
throw new NotImplementedException("SDMX EDI for structures is not implemented in this implementation.");
////ISdmxObjects beans = new SdmxObjectsImpl();
////beans.AddIdentifiable(bean);
////WriteStructures(beans);
}
private void PrintMaintainable(IMaintainableObject maintainableObject)
{
this._writer.WriteLine("<tr><td>{0}</td>", maintainableObject.AgencyId);
this._writer.WriteLine("<td>{0}</td>", maintainableObject.StructureType.StructureType);
this._writer.WriteLine("<td>{0}</td>", maintainableObject.Name);
this._writer.WriteLine("<td>{0}</td>", maintainableObject.IdentifiableComposites.Count);
this._writer.WriteLine("</tr>");
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECTS //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="MeasureListCore"/> class.
/// </summary>
/// <param name="measureList">
/// The measure list.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public MeasureListCore(IMeasureListMutableObject measureList, IMaintainableObject parent)
: base(measureList, parent)
{
if (measureList.PrimaryMeasure != null)
{
this.primaryMeasure = new PrimaryMeasureCore(measureList.PrimaryMeasure, this);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossReferencingTreeCore"/> class.
/// </summary>
/// <param name="maintainable">
/// The maintainable.
/// </param>
/// <param name="referencingObjects">
/// The referencing objects
/// </param>
public CrossReferencingTreeCore(
IMaintainableObject maintainable, IList<ICrossReferencingTree> referencingObjects)
{
this.referencingObjects = new List<ICrossReferencingTree>();
this.maintainableObject = maintainable;
if (referencingObjects != null)
{
this.referencingObjects = referencingObjects;
}
}
/// <summary>
/// Returns the set of cross referenced structures from this maintainable.
/// </summary>
/// <param name="retrievalManager">
/// The retrieval manager
/// </param>
/// <param name="maintainable">
/// The maintainable object
/// </param>
/// <returns>
/// The cross references set.
/// </returns>
public ISet<ICrossReference> GetCrossReferences(ISdmxObjectRetrievalManager retrievalManager, IMaintainableObject maintainable)
{
switch (maintainable.StructureType.EnumType)
{
case SdmxStructureEnumType.ContentConstraint:
return GetCrossReferences(retrievalManager, (IContentConstraintObject)maintainable);
default:
return maintainable.CrossReferences;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="MeasureListCore"/> class.
/// </summary>
/// <param name="measureList">
/// The measure list.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public MeasureListCore(MeasureListType measureList, IMaintainableObject parent)
: base(measureList, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.MeasureDescriptor), parent)
{
if (measureList.Component != null)
{
this.primaryMeasure =
new PrimaryMeasureCore(
(Org.Sdmx.Resources.SdmxMl.Schemas.V21.Structure.PrimaryMeasureType)
measureList.Component[0].Content,
this);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="AttributeListCore"/> class.
/// </summary>
/// <param name="attributeList">
/// The attributeObject list.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public AttributeListCore(AttributeListType attributeList, IMaintainableObject parent)
: base(attributeList, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.AttributeDescriptor), parent)
{
this.attributes = new List<IAttributeObject>();
if (attributeList.Attribute != null)
{
foreach (Attribute currentAttribute in attributeList.Attribute)
{
this.attributes.Add(new AttributeObjectCore(currentAttribute.Content, this));
}
}
}
/// <summary>
/// The assemble maintainable.
/// </summary>
/// <param name="builtObj">
/// The object to populate.
/// </param>
/// <param name="buildFrom">
/// The build from.
/// </param>
public void AssembleMaintainable(MaintainableType builtObj, IMaintainableObject buildFrom)
{
// Populate it from inherited super
this.AssembleNameable(builtObj, buildFrom);
// Populate it using this class's specifics
string str1 = buildFrom.AgencyId;
if (!string.IsNullOrWhiteSpace(str1))
{
builtObj.agencyID = buildFrom.AgencyId;
}
string str0 = buildFrom.Version;
if (!string.IsNullOrWhiteSpace(str0))
{
builtObj.version = buildFrom.Version;
}
if (buildFrom.StartDate != null)
{
builtObj.validFrom = buildFrom.StartDate.Date;
}
if (buildFrom.EndDate != null)
{
builtObj.validTo = buildFrom.EndDate.Date;
}
if (buildFrom.IsExternalReference.IsSet())
{
builtObj.isExternalReference = buildFrom.IsExternalReference.IsTrue;
}
if (buildFrom.IsFinal.IsSet())
{
builtObj.isFinal = buildFrom.IsFinal.IsTrue;
}
if (buildFrom.StructureUrl != null)
{
builtObj.structureURL = buildFrom.StructureUrl;
}
if (buildFrom.ServiceUrl != null)
{
builtObj.serviceURL = buildFrom.ServiceUrl;
}
}
/// <summary>
/// Run common artefact import command.
/// </summary>
/// <param name="artefact">
/// The artefact.
/// </param>
/// <param name="command">
/// The command.
/// </param>
/// <param name="artefactStoredProcedure">
/// The artefact stored procedure.
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
protected ArtefactImportStatus RunArtefactCommand(IMaintainableObject artefact, DbCommand command, ArtefactProcedurebase artefactStoredProcedure)
{
DbParameter versionParameter = artefactStoredProcedure.CreateVersionParameter(command);
versionParameter.Value = artefact.Version ?? (object)DBNull.Value;
DbParameter agencyParameter = artefactStoredProcedure.CreateAgencyParameter(command);
agencyParameter.Value = artefact.AgencyId ?? (object)DBNull.Value;
DbParameter validFromParameter = artefactStoredProcedure.CreateValidFromParameter(command);
if (artefact.StartDate != null)
{
validFromParameter.Value = artefact.StartDate.Date;
}
DbParameter validToParameter = artefactStoredProcedure.CreateValidToParameter(command);
if (artefact.EndDate != null)
{
validToParameter.Value = artefact.EndDate.Date;
}
DbParameter uriParameter = artefactStoredProcedure.CreateUriParameter(command);
if (artefact.Uri != null)
{
uriParameter.Value = artefact.Uri.ToString();
}
DbParameter isFinalParameter = artefactStoredProcedure.CreateIsFinalParameter(command);
isFinalParameter.Value = artefact.IsFinal.IsTrue ? 1 : 0;
var artID = this.RunNameableArtefactCommand(artefact, command, artefactStoredProcedure);
// "Inserted artefact with ID:" + artefactGetID + " VERSION:" + artefact.version + " AGENCY:" + artefact.agencyID + Environment.NewLine;
var structureReference = artefact.AsReference;
var importMessage = new ImportMessage(
ImportMessageStatus.Success,
structureReference,
string.Format("Success: {0} was inserted.{1}", structureReference.GetAsHumanReadableString(), Environment.NewLine));
return(new ArtefactImportStatus(artID, importMessage));
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="DimensionListCore"/> class.
/// </summary>
/// <param name="keyFamily">
/// The agencyScheme.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
/// <exception cref="SdmxSemmanticException"> Throws SdmxSemmanticException.
/// </exception>
public DimensionListCore(KeyFamilyType keyFamily, IMaintainableObject parent)
: base(
DimensionList.FixedId,
SdmxStructureType.GetFromEnum(SdmxStructureEnumType.DimensionDescriptor),
parent)
{
this.dimensions = new List<IDimension>();
int pos = 1;
ComponentsType components = keyFamily.Components;
try
{
if (components != null)
{
foreach (DimensionType currentDimension in components.Dimension)
{
this.dimensions.Add(new DimensionCore(currentDimension, this, pos));
pos++;
}
if (components.TimeDimension != null)
{
this.dimensions.Add(new DimensionCore(components.TimeDimension, this, pos));
}
}
}
catch (SdmxSemmanticException ex)
{
throw new SdmxSemmanticException(ex, ExceptionCode.ObjectStructureConstructionError, this.Urn);
}
catch (Exception th)
{
throw new SdmxException(th, ExceptionCode.ObjectStructureConstructionError, this.Urn);
}
this.ValidateDimensionList();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="DimensionListCore"/> class.
/// </summary>
/// <param name="dimensionList">
/// The dimension list.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
/// <exception cref="SdmxSemmanticException">
/// Throws Validate exception.
/// </exception>
public DimensionListCore(DimensionListType dimensionList, IMaintainableObject parent)
: base(dimensionList, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.DimensionDescriptor), parent)
{
this.dimensions = new List<IDimension>();
int pos = 1;
if (dimensionList.Dimension != null)
{
foreach (Dimension dimension in dimensionList.Dimension)
{
this.dimensions.Add(new DimensionCore(dimension.Content, this, pos));
pos++;
}
}
if (ObjectUtil.ValidCollection(dimensionList.MeasureDimension))
{
if (dimensionList.MeasureDimension.Count > 1)
{
throw new SdmxSemmanticException("Can not have more then one measure dimension");
}
this.dimensions.Add(new DimensionCore(dimensionList.MeasureDimension[0].Content, this, pos));
pos++;
}
if (ObjectUtil.ValidCollection(dimensionList.TimeDimension))
{
if (dimensionList.TimeDimension.Count > 1)
{
throw new SdmxSemmanticException("Can not have more then one time dimension");
}
this.dimensions.Add(new DimensionCore(dimensionList.TimeDimension[0].Content, this, pos));
}
this.ValidateDimensionList();
}
public MaintainableMutableObjectBaseCore(IMaintainableObject maintainable) : base(maintainable) {
this._agencyId = maintainable.AgencyId;
this._version = maintainable.Version;
this._isIsFinal = maintainable.IsFinal().IsTrue;
this._isStub = maintainable.Stub;
}
/// <summary>
/// Validates a structure is compliant to the 2.1 SDMX schema, by writing it out as SDMX and validating against the schema.
/// WARNING: This implementation writes temporary to memory.
/// </summary>
/// <param name="maintainableBean">
/// The maintainable object
/// </param>
public virtual void ValidateStructure(IMaintainableObject maintainableBean)
{
using (var memoryStream = new MemoryStream())
{
this._structureWritingManager.WriteStructure(maintainableBean, null, new SdmxStructureFormat(_outputFormat), memoryStream);
memoryStream.Position = 0;
using (IReadableDataLocation dataLocation = this._readableDataLocationFactory.GetReadableDataLocation(memoryStream.ToArray()))
{
this._structureParsingManager.ParseStructures(dataLocation);
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1.0 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="AttributeListCore"/> class.
/// </summary>
/// <param name="keyFamily">
/// The sdmxObject.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public AttributeListCore(
Org.Sdmx.Resources.SdmxMl.Schemas.V10.structure.KeyFamilyType keyFamily, IMaintainableObject parent)
: base(
AttributeListObject.FixedId,
SdmxStructureType.GetFromEnum(SdmxStructureEnumType.AttributeDescriptor),
parent)
{
this.attributes = new List<IAttributeObject>();
if (keyFamily.Components != null && keyFamily.Components.Attribute != null)
{
foreach (Org.Sdmx.Resources.SdmxMl.Schemas.V10.structure.AttributeType currentAttribute in
keyFamily.Components.Attribute)
{
this.attributes.Add(new AttributeObjectCore(currentAttribute, this));
}
}
}
/// <summary>
/// Generate a key using the following format AgencyID+ID+Version
/// </summary>
/// <param name="artefact">
/// The artefact to generate the key for
/// </param>
/// <returns>
/// The key
/// </returns>
public static string MakeKey(IMaintainableObject artefact)
{
return(MakeKey(artefact.Id, artefact.AgencyId, artefact.Version));
}
/// <summary>
/// Increments the version of the old maintainable
/// </summary>
/// <param name="currentMaint">
/// current maintainable
/// </param>
/// <param name="incrementFromVersion">
/// the increment from version
/// </param>
/// <param name="majorIncrement">
/// the major increment
/// </param>
/// <returns>
/// The mantainable object with incremented version
/// </returns>
private IMaintainableObject IncrmentVersion(
IMaintainableObject currentMaint, String incrementFromVersion, bool majorIncrement)
{
IMaintainableMutableObject mutable = currentMaint.MutableInstance;
String newVersion = VersionableUtil.IncrementVersion(incrementFromVersion, majorIncrement);
mutable.Version = newVersion;
IMaintainableObject newMaint = mutable.ImmutableInstance;
return newMaint;
}
private ISet<IProvisionAgreementObject> GetByReference(IMaintainableObject bean) {
ISet<IMaintainableObject> provisions = beans
.GetMaintinables(Org.Sdmxsource.Sdmx.Api.Constants.SdmxStructureType.GetFromEnum(SdmxStructureEnumType.ProvisionAgreement));
ISet<IProvisionAgreementObject> returnSet = new HashSet<IProvisionAgreementObject>();
/* foreach */
foreach (IMaintainableObject currentProvision in provisions) {
IProvisionAgreementObject provision = (IProvisionAgreementObject) currentProvision;
if (IsMatch(provision, bean)) {
returnSet.Add(provision);
}
}
return returnSet;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="MeasureListCore"/> class.
/// </summary>
/// <param name="primaryMeasure">
/// The primary measure.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public MeasureListCore(
Org.Sdmx.Resources.SdmxMl.Schemas.V10.structure.PrimaryMeasureType primaryMeasure,
IMaintainableObject parent)
: base(
MeasureList.FixedId,
SdmxStructureType.GetFromEnum(SdmxStructureEnumType.MeasureDescriptor),
parent)
{
this.primaryMeasure = new PrimaryMeasureCore(primaryMeasure, this);
}
/// <summary>
/// Insert the specified <paramref name="artefact"/> to MAPPING STORE
/// </summary>
/// <param name="state">
/// The Mapping Store connection and transaction state
/// </param>
/// <param name="artefact">
/// The artefact.
/// </param>
/// <returns>
/// The <see cref="ArtefactImportStatus"/>.
/// </returns>
protected override ArtefactImportStatus InsertArtefact(DbTransactionState state, IMaintainableObject artefact)
{
return(this.Insert(state, (T)artefact));
}
/// <summary>
/// The write structure.
/// </summary>
/// <param name="bean">
/// The bean.
/// </param>
public virtual void WriteStructure(IMaintainableObject bean)
{
ISdmxObjects beans = new SdmxObjectsImpl();
beans.AddIdentifiable(bean);
this.WriteStructures(beans);
}
public void WriteStructure(IMaintainableObject maintainableObject)
{
PrintMaintainable(maintainableObject);
Close();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="DimensionListCore"/> class.
/// </summary>
/// <param name="keyFamily">
/// The agencyScheme.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public DimensionListCore(
Org.Sdmx.Resources.SdmxMl.Schemas.V10.structure.KeyFamilyType keyFamily, IMaintainableObject parent)
: base(
DimensionList.FixedId,
SdmxStructureType.GetFromEnum(SdmxStructureEnumType.DimensionDescriptor),
parent)
{
this.dimensions = new List<IDimension>();
Org.Sdmx.Resources.SdmxMl.Schemas.V10.structure.ComponentsType components = keyFamily.Components;
int pos = 1;
if (components != null)
{
foreach (Org.Sdmx.Resources.SdmxMl.Schemas.V10.structure.DimensionType currentDimension in
components.Dimension)
{
this.dimensions.Add(new DimensionCore(currentDimension, this, pos));
pos++;
}
if (components.TimeDimension != null)
{
this.dimensions.Add(new DimensionCore(components.TimeDimension, this, pos));
}
}
this.ValidateDimensionList();
}
/// <summary>
/// Maps old versus new references.
/// </summary>
/// <param name="oldVersionNumber">
/// The old version number.
/// </param>
/// <param name="newVersion">
/// The new version object.
/// </param>
/// <param name="oldVsNew">
/// The old vs new map.
/// </param>
private void AddOldVsNewReferences(
String oldVersionNumber,
IMaintainableObject newVersion,
IDictionary<IStructureReference, IStructureReference> oldVsNew)
{
this.AddOldVsNewReferencesToMap(oldVersionNumber, newVersion, oldVsNew);
foreach (IIdentifiableObject composite in newVersion.IdentifiableComposites)
{
this.AddOldVsNewReferencesToMap(oldVersionNumber, composite, oldVsNew);
}
}
/// <summary>
/// Add <paramref name="maintainable"/> to map.
/// </summary>
/// <param name="maintainable">
/// The maintainable.
/// </param>
private void AddMaintainableToMap(IMaintainableObject maintainable)
{
if (!this._allIdentifiables.ContainsKey(maintainable.Urn))
{
this._allIdentifiables.Add(maintainable.Urn, maintainable);
foreach (IIdentifiableObject identifiableBean in maintainable.IdentifiableComposites)
{
if (identifiableBean.StructureType.EnumType == SdmxStructureEnumType.Agency)
{
var acy = (IAgency)identifiableBean;
this._agencies.Add(acy.FullId, acy);
}
this._allIdentifiables.Add(identifiableBean.Urn, identifiableBean);
}
}
}
/// <summary>
/// Gets organisation scheme type.
/// </summary>
/// <param name="buildFrom">
/// The build from.
/// </param>
/// <returns>
/// The <see cref="OrganisationSchemeType"/> .
/// </returns>
private OrganisationSchemeType GetOrganisationSchemeType(IMaintainableObject buildFrom)
{
var builtObj = new OrganisationSchemeType();
string value = buildFrom.AgencyId;
if (!string.IsNullOrWhiteSpace(value))
{
builtObj.agencyID = buildFrom.AgencyId;
}
string value1 = buildFrom.Id;
if (!string.IsNullOrWhiteSpace(value1))
{
builtObj.id = buildFrom.Id;
}
if (buildFrom.Uri != null)
{
builtObj.uri = buildFrom.Uri;
}
else if (buildFrom.StructureUrl != null)
{
builtObj.uri = buildFrom.StructureUrl;
}
else if (buildFrom.ServiceUrl != null)
{
builtObj.uri = buildFrom.StructureUrl;
}
if (ObjectUtil.ValidString(buildFrom.Urn))
{
builtObj.urn = buildFrom.Urn;
}
string value2 = buildFrom.Version;
if (!string.IsNullOrWhiteSpace(value2))
{
builtObj.version = buildFrom.Version;
}
if (buildFrom.StartDate != null)
{
builtObj.validFrom = buildFrom.StartDate.Date;
}
if (buildFrom.EndDate != null)
{
builtObj.validTo = buildFrom.EndDate.Date;
}
IList<ITextTypeWrapper> names = buildFrom.Names;
if (ObjectUtil.ValidCollection(names))
{
builtObj.Name = this.GetTextType(names);
}
IList<ITextTypeWrapper> descriptions = buildFrom.Descriptions;
if (ObjectUtil.ValidCollection(descriptions))
{
builtObj.Description = this.GetTextType(descriptions);
}
if (this.HasAnnotations(buildFrom))
{
builtObj.Annotations = this.GetAnnotationsType(buildFrom);
}
if (buildFrom.IsExternalReference.IsSet())
{
builtObj.isExternalReference = buildFrom.IsExternalReference.IsTrue;
}
if (buildFrom.IsFinal.IsSet())
{
builtObj.isFinal = buildFrom.IsFinal.IsTrue;
}
return builtObj;
}
/// <summary>
/// Writes the <paramref name="maintainableObject"/> out to the output location in the format specified by the implementation
/// </summary>
/// <param name="maintainableObject">
/// The maintainableObject.
/// </param>
public void WriteStructure(IMaintainableObject maintainableObject)
{
IMutableObjects mutableObjects = new MutableObjectsImpl();
mutableObjects.AddIdentifiable(maintainableObject.MutableInstance);
IRegistryInfo registry = new RegistryInfo();
registry.QueryStructureResponse = new QueryStructureResponseInfo { Structure = mutableObjects };
this.WriteRegistryInterface(registry);
}
/// <summary>
/// Writes the contents of the bean out to the output stream in the version specified.
/// </summary>
/// <param name="sdmxObject">
/// The sdmxObjects to write to the output stream
/// </param>
/// <param name="header">
/// can be null, if null will create a default header
/// </param>
/// <param name="outputFormat">
/// the output format of the message (required)
/// </param>
/// <param name="outputStream">
/// the stream to write to, the stream is NOT closed on completion, this can be null if not required (i.e the outputFormat may contain a writer)
/// </param>
public void WriteStructure(IMaintainableObject sdmxObject, IHeader header, IStructureFormat outputFormat, Stream outputStream)
{
_log.Debug("Write Structure '" + sdmxObject + "' as " + outputFormat);
GetStructureWritingEngine(outputFormat, outputStream).WriteStructure(sdmxObject);
}
/// <summary>
/// Saves the maintainable
/// </summary>
/// <param name="maintainable">
/// The <see cref="IMaintainableObject"/>
/// </param>
public void SaveStructure(IMaintainableObject maintainable)
{
ISdmxObjects objects = new SdmxObjectsImpl(maintainable);
this.SaveStructures(objects);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="MeasureListCore"/> class.
/// </summary>
/// <param name="primaryMeasure">
/// The primary measure.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public MeasureListCore(PrimaryMeasureType primaryMeasure, IMaintainableObject parent)
: base(
MeasureList.FixedId,
SdmxStructureType.GetFromEnum(SdmxStructureEnumType.MeasureDescriptor),
parent)
{
this.primaryMeasure = new PrimaryMeasureCore(primaryMeasure, this);
}
/// <summary>
/// Writes the <paramref name="maintainableObject"/> out to the output location in the format specified by the implementation
/// </summary>
/// <param name="maintainableObject">
/// The maintainableObject.
/// </param>
public void WriteStructure(IMaintainableObject maintainableObject)
{
IMutableObjects mutableObjects = new MutableObjectsImpl();
mutableObjects.AddIdentifiable(maintainableObject.MutableInstance);
this.WriteStructure(mutableObjects, null);
}
/// <summary>
/// Gets the reference from the specified <paramref name="dataStructureObject"/>
/// </summary>
/// <param name="dataStructureObject">
/// The maintainable reference
/// </param>
/// <returns>
/// The <see cref="string"/>.
/// </returns>
protected static string GetRef(IMaintainableObject dataStructureObject)
{
// TODO this also used in StartDataSet
return string.Format(
CultureInfo.InvariantCulture,
"{0}_{1}_{2}",
dataStructureObject.AgencyId,
dataStructureObject.Id,
dataStructureObject.Version.Replace('.', '_'));
}
private static ISet<ICategorisationObject> GetCategorisations(
IMaintainableObject maintainable, IEnumerable<ICategorisationObject> categorisations)
{
ISet<ICategorisationObject> returnSet = new HashSet<ICategorisationObject>();
if (maintainable.IsExternalReference.IsTrue)
{
return returnSet;
}
/* foreach */
foreach (ICategorisationObject cat in categorisations)
{
if (cat.IsExternalReference.IsTrue)
{
continue;
}
if (cat.StructureReference.TargetReference.EnumType == maintainable.StructureType.EnumType)
{
if (MaintainableUtil<IMaintainableObject>.Match(maintainable, cat.StructureReference))
{
returnSet.Add(cat);
}
}
}
return returnSet;
}
private bool IsMatch(IProvisionAgreementObject provision,
IMaintainableObject bean) {
/* foreach */
foreach (ICrossReference currentRef in provision.CrossReferences) {
if (currentRef.IsMatch(bean)) {
return true;
}
}
return false;
}
/// <summary> /// Insert the specified <paramref name="artefact"/> to MAPPING STORE /// </summary> /// <param name="state"> /// The Mapping Store connection and transaction state /// </param> /// <param name="artefact"> /// The artefact. /// </param> /// <returns> /// The <see cref="ArtefactImportStatus"/>. /// </returns> protected abstract ArtefactImportStatus InsertArtefact(DbTransactionState state, IMaintainableObject artefact);
