/// <summary>
/// Returns a new stub <see cref="IMaintainableMutableObject"/> object based on the specified <paramref name="maintainable"/>.
/// The new object is a shallow copy.
/// </summary>
/// <typeparam name="TInterface">The maintainable type (interface).</typeparam>
/// <typeparam name="TImplementation">The maintainable type (concrete implementation).</typeparam>
/// <param name="maintainable">The maintainable.</param>
/// <returns>A new stub <see cref="IMaintainableMutableObject"/> object based on the specified <paramref name="maintainable"/>; otherwise if <paramref name="maintainable"/> is null it returns null.</returns>
public static TInterface CloneAsStub <TInterface, TImplementation>(this TInterface maintainable) where TInterface : IMaintainableMutableObject
where TImplementation : TInterface, new()
{
if (maintainable.IsDefault())
{
return(default(TInterface));
}
var stub = new TImplementation
{
Id = maintainable.Id,
AgencyId = maintainable.AgencyId,
Version = maintainable.Version,
StructureURL = _defaultUri,
StartDate = maintainable.StartDate,
EndDate = maintainable.EndDate,
FinalStructure = maintainable.FinalStructure,
ServiceURL = maintainable.ServiceURL,
Uri = maintainable.Uri,
ExternalReference = TertiaryBool.ParseBoolean(true),
// TODO following line when we remove when sync to CAPI v1.0
Stub = true
};
stub.Annotations.AddAll(maintainable.Annotations);
stub.Names.AddAll(maintainable.Names);
return(stub);
}
/// <summary>
/// Retrieve cross sectional attachments.
/// </summary>
/// <param name="dataReader">
/// The data reader.
/// </param>
/// <param name="crossDataSet">
/// The list of components attached to cross-sectional data set.
/// </param>
/// <param name="conceptRef">
/// The concept id.
/// </param>
/// <param name="crossGroup">
/// The list of components attached to cross-sectional group.
/// </param>
/// <param name="crossSection">
/// The list of components attached to cross-sectional section.
/// </param>
/// <param name="crossObs">
/// The list of components attached to cross-sectional observation level
/// </param>
private static void RetrieveCrossSectionalAttachments(IDataRecord dataReader, ISet <string> crossDataSet, string conceptRef, ISet <string> crossGroup, ISet <string> crossSection, ISet <string> crossObs)
{
TertiaryBool crossSectionalAttachDataSet = DataReaderHelper.GetTristate(dataReader, "XS_ATTLEVEL_DS");
if (crossSectionalAttachDataSet.IsTrue)
{
crossDataSet.Add(conceptRef);
}
TertiaryBool crossSectionalAttachGroup = DataReaderHelper.GetTristate(dataReader, "XS_ATTLEVEL_GROUP");
if (crossSectionalAttachGroup.IsTrue)
{
crossGroup.Add(conceptRef);
}
TertiaryBool crossSectionalAttachSection = DataReaderHelper.GetTristate(dataReader, "XS_ATTLEVEL_SECTION");
if (crossSectionalAttachSection.IsTrue)
{
crossSection.Add(conceptRef);
}
TertiaryBool crossSectionalAttachObservation = DataReaderHelper.GetTristate(dataReader, "XS_ATTLEVEL_OBS");
if (crossSectionalAttachObservation.IsTrue)
{
crossObs.Add(conceptRef);
}
}
/// <summary>
/// Create a ImmutableInstance of DataStructure (Keyfamily in sdmx 2.0)
/// </summary>
/// <param name="components">list of IComponentMutableObject that compose dsd</param>
/// <param name="Groups">list of Groups (ever Null for OnTheFly version 1.0)</param>
/// <param name="AgencyId">Agency Id</param>
/// <param name="Version">Artefact Version</param>
/// <returns>DataStructureObjectImpl</returns>
public DataStructureObjectImpl BuildDataStructure(List <IComponentMutableObject> components, List <IGroupMutableObject> Groups, string AgencyId, string Version)
{
try
{
DataStructureObjectImpl dsd = new DataStructureObjectImpl();
dsd._Concepts = this._Concepts;
dsd.AgencyId = AgencyId;
dsd.Version = Version;
dsd.Id = this.Code;
foreach (var nomi in this.Names)
{
dsd.AddName(nomi.Lingua, nomi.Name);
}
if (!this.ParsingObject.ReturnStub)
{
foreach (IComponentMutableObject comp in components)
{
if (comp.StructureType.EnumType == SdmxStructureEnumType.PrimaryMeasure)
{
dsd.AddPrimaryMeasure(comp.ConceptRef);
}
else if (comp is IAttributeMutableObject)
{
dsd.AddAttribute((IAttributeMutableObject)comp);
}
else if (comp is IDimensionMutableObject)
{
dsd.AddDimension((IDimensionMutableObject)comp);
}
}
if (Groups != null)
{
foreach (GroupMutableCore group in Groups)
{
dsd.AddGroup(group);
}
}
}
dsd.FinalStructure = TertiaryBool.ParseBoolean(true);
if (this.ParsingObject.isReferenceOf || this.ParsingObject.ReturnStub)
{
dsd.ExternalReference = TertiaryBool.ParseBoolean(true);
dsd.StructureURL = RetreivalStructureUrl.Get(this, dsd.Id, dsd.AgencyId, dsd.Version);
}
dsd.Immutated = dsd.ImmutableInstance;
return(dsd);
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
/// <summary>
/// Convert the <paramref name="facetValue"/> to <see cref="TertiaryBool"/>
/// </summary>
/// <param name="facetValue">
/// The facet value.
/// </param>
/// <returns>
/// the <paramref name="facetValue"/> as <see cref="TertiaryBool"/>
/// </returns>
private static TertiaryBool FacetToTristateBool(string facetValue)
{
if (string.IsNullOrWhiteSpace(facetValue))
{
return(TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset));
}
return(TertiaryBool.ParseBoolean(XmlConvert.ToBoolean(facetValue.ToLowerInvariant())));
}
/// <summary>
/// Add facet to the specified <paramref name="facets"/>
/// </summary>
/// <param name="value">
/// The value.
/// </param>
/// <param name="name">
/// The name.
/// </param>
/// <param name="facets">
/// The facets.
/// </param>
private void AddFacet(TertiaryBool value, string name, Stack <KeyValuePair <long, string> > facets)
{
long id;
if (value.IsSet() && this._facetMap.TryGetValue(name, out id))
{
facets.Push(new KeyValuePair <long, string>(id, XmlConvert.ToString(value.IsTrue)));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ComplexAnnotationReferenceCore"/> class.
/// </summary>
/// <param name="returnLatest">
/// The return latest.
/// </param>
/// <param name="version">
/// The version.
/// </param>
/// <param name="validFrom">
/// The valid from.
/// </param>
/// <param name="validTo">
/// The valid to.
/// </param>
public ComplexVersionReferenceCore(TertiaryBool returnLatest, string version, ITimeRange validFrom, ITimeRange validTo)
{
if (returnLatest != null)
{
this._returnLatest = returnLatest;
}
this._version = version;
this._validFrom = validFrom;
this._validTo = validTo;
}
/// <summary>
/// Create a ImmutableInstance of Categorisation
/// </summary>
/// <param name="DataflowCode">Dataflow Code</param>
/// <param name="DataflowAgency">Dataflow Agency Id</param>
/// <param name="DataflowVersion">Dataflow Version</param>
/// <param name="CategoryParent">list of category parent, from hightLevel parent to low level child category</param>
/// <returns>ICategorisationObject</returns>
public ICategorisationObject BuildCategorisation(string DataflowCode, string DataflowAgency, string DataflowVersion, List <string> CategoryParent)
{
try
{
ICategorisationMutableObject ca = new CategorisationMutableCore();
ca.AgencyId = this.CategorySchemeAgencyId;
ca.Version = this.CategorySchemeVersion;
string IDName = string.Format("{0}@{1}@{2}@{3}@{4}@{5}",
DataflowCode, DataflowAgency, DataflowVersion.Replace(".", ""),
this.Code, this.CategorySchemeVersion.Replace(".", ""), CategoryParent[CategoryParent.Count - 1]);
ca.Id = IDName;
ca.AddName("en", IDName);
//IAnnotationMutableObject ann = new AnnotationMutableCore();
//ann.Type="CategoryScheme_node_order";
//ann.Text.Add(new TextTypeWrapperMutableCore("en", (CategoryParent.Count).ToString()));
//ca.AddAnnotation(ann);
//ca.Id = string.Format(FlyConfiguration.CategorisationFormat, DataflowCode);
//foreach (SdmxObjectNameDescription item in this.Names)
// ca.AddName(item.Lingua, item.Name);
if (!this.ParsingObject.ReturnStub)
{
if (this.VersionTypeResp == SdmxSchemaEnumType.VersionTwo)
{
ca.CategoryReference = ReferenceBuilder.CreateCategoryReference(this.Code, this.CategorySchemeAgencyId, this.CategorySchemeVersion, CategoryParent.ToArray());
}
else
{
ca.CategoryReference = ReferenceBuilder.CreateCategoryReference(this.Code, this.CategorySchemeAgencyId, this.CategorySchemeVersion, CategoryParent != null && CategoryParent.Count > 0 ? new string[1] {
CategoryParent[CategoryParent.Count - 1]
} : CategoryParent.ToArray());
}
ca.StructureReference = ReferenceBuilder.CreateDataflowReference(DataflowCode, DataflowAgency, DataflowVersion);
}
ca.FinalStructure = TertiaryBool.ParseBoolean(true);
//if (this.ParsingObject.isReferenceOf || this.ParsingObject.ReturnStub)
//{
// ca.ExternalReference = TertiaryBool.ParseBoolean(true);
// ca.StructureURL = RetreivalStructureUrl.Get(this, ca.Id, ca.AgencyId, ca.Version);
//}
return(ca.ImmutableInstance);
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
private void GetCategorisationDataflow()
{
_dtCategorisationDataflow = DbAccess.ExecutetoTable(DBOperationEnum.GetCategorisationDataflow, null);
if (_dtCategorisationDataflow.Rows.Count <= 0)
{
return;
}
ReferencesObject.Categorisation = new List <ICategorisationObject>();
string DFID, DFAgency, DFVersion, CSID, CSAgency, CSVersion, CatCode, IDCAT, IDDataFlow;
DataView viewCSDF = new DataView(_dtCategorisationDataflow);
DataTable dtCSDF = viewCSDF.ToTable(true, "IDDataFlow", "DFID", "DFAgency", "DFVersion", "CSID",
"CSAgency", "CSVersion", "CatCode", "IDCAT");
DataTable dtCatNames = viewCSDF.ToTable(true, "IDCAT", "CubeLang", "CubeName", "IDDataFlow");
ICategorisationMutableObject categorisation;
foreach (DataRow row in dtCSDF.Rows)
{
IDDataFlow = row["IDDataFlow"].ToString();
DFID = row["DFID"].ToString();
DFAgency = row["DFAgency"].ToString();
DFVersion = row["DFVersion"].ToString();
CSID = row["CSID"].ToString();
CSAgency = row["CSAgency"].ToString();
CSVersion = row["CSVersion"].ToString();
CatCode = row["CatCode"].ToString();
IDCAT = row["IDCAT"].ToString();
categorisation = new CategorisationMutableCore()
{
Id = DFID,
AgencyId = DFAgency,
Version = DFVersion,
FinalStructure = TertiaryBool.ParseBoolean(true),
};
IStructureReference structureRef = new StructureReferenceImpl(DFAgency, DFID, DFVersion,
SdmxStructureEnumType.Dataflow);
IStructureReference categoryRef = new StructureReferenceImpl(CSAgency, CSID, CSVersion,
SdmxStructureEnumType.Category, CatCode);
categorisation.StructureReference = structureRef;
categorisation.CategoryReference = categoryRef;
SetNames(dtCatNames.Select("IDCat = " + IDCAT + " AND IDDataFlow = " + IDDataFlow), categorisation);
ReferencesObject.Categorisation.Add(categorisation.ImmutableInstance);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataAttributeMutableCore"/> class.
/// </summary>
/// <param name="objTarget">
/// The obj target.
/// </param>
public MetadataAttributeMutableCore(IMetadataAttributeObject objTarget)
: base(objTarget)
{
this._metadataAttributes = new List<IMetadataAttributeMutableObject>();
this._presentational = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
this._minOccurs = objTarget.MinOccurs;
this._maxOccurs = objTarget.MaxOccurs;
this._presentational = objTarget.Presentational;
if (objTarget.MetadataAttributes != null)
{
foreach (IMetadataAttributeObject currentMetadatAttribute in objTarget.MetadataAttributes)
{
this._metadataAttributes.Add(new MetadataAttributeMutableCore(currentMetadatAttribute));
}
}
}
/// <summary>
/// Add item to codelist whitout generate a duplicate items
/// </summary>
/// <param name="codelist">codelist from which to copy the items</param>
public void AddItemto(ICodelistMutableObject codelist)
{
try
{
List <string> Idduples = new List <string>();
try
{//ci sono i duplicati ID sotto padri diversi e SDMX scoppia....
if (CodesObjects != null)
{
Idduples = (from c in CodesObjects
where CodesObjects.Count(comp => comp.Id == c.Id) > 1
select c.Id).Distinct().ToList();
}
}
catch (Exception)
{
//Errore nella ricerca dei duplicati ma non fa niente
}
if (!this.ParsingObject.ReturnStub)
{
foreach (ICodeMutableObject cl in CodesObjects)
{
if (!Idduples.Contains(cl.Id) && codelist.Items.Count(presentCode => presentCode.Id == cl.Id) == 0)
{
codelist.AddItem(cl);
}
}
codelist.FinalStructure = TertiaryBool.ParseBoolean(true);
}
if (this.ParsingObject.isReferenceOf || this.ParsingObject.ReturnStub)
{
codelist.ExternalReference = TertiaryBool.ParseBoolean(true);
codelist.StructureURL = RetreivalStructureUrl.Get(this, codelist.Id, codelist.AgencyId, codelist.Version);
}
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
/// <summary>
/// Create a ImmutableInstance of Dataflow
/// </summary>
/// <param name="AgencyId">Agency Id</param>
/// <param name="Version">Artefact Version</param>
/// <returns>IDataflowObject</returns>
public IDataflowObject BuildDataflow(string AgencyId, string Version)
{
try
{
IDataflowMutableObject df = new DataflowMutableCore();
df.AgencyId = AgencyId;
df.Version = Version;
df.Id = this.Code;
if (this.Names != null)
{
foreach (SdmxObjectNameDescription nome in this.Names)
{
df.AddName(nome.Lingua, nome.Name);
}
}
if (!this.ParsingObject.ReturnStub)
{
if (this.DataStrunctureRef != null)
{
df.DataStructureRef = this.DataStrunctureRef;
}
else
{
df.DataStructureRef = ReferenceBuilder.CreateDSDStructureReference(this.Code);//Creo una struttura di riferimento
}
}
df.FinalStructure = TertiaryBool.ParseBoolean(true);
if (this.ParsingObject.isReferenceOf || this.ParsingObject.ReturnStub)
{
df.ExternalReference = TertiaryBool.ParseBoolean(true);
df.StructureURL = RetreivalStructureUrl.Get(this, df.Id, df.AgencyId, df.Version);
}
return(df.ImmutableInstance);
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
/// <summary>
/// Create a ImmutableInstance of CategoryScheme
/// </summary>
/// <param name="CategoryObjects">List of CategoryObject</param>
/// <returns>ICategorySchemeObject</returns>
public ICategorySchemeObject BuildCategorySchemeObject(List <ICategoryMutableObject> CategoryObjects)
{
try
{
ICategorySchemeMutableObject ca = new CategorySchemeMutableCore();
ca.AgencyId = this.CategorySchemeAgencyId;
ca.Id = this.Code;
ca.Version = this.categorySchemeVersion;
foreach (SdmxObjectNameDescription item in this.Names)
{
ca.AddName(item.Lingua, item.Name);
}
//IAnnotationMutableObject ann = new AnnotationMutableCore();
//ann.Type = "CategoryScheme_node_order";
//ann.Text.Add(new TextTypeWrapperMutableCore("en", "0"));
//ca.AddAnnotation(ann);
if (!this.ParsingObject.ReturnStub)
{
foreach (ICategoryMutableObject item in CategoryObjects)
{
ca.AddItem(item);
}
ca.FinalStructure = TertiaryBool.ParseBoolean(true);
}
if (this.ParsingObject.isReferenceOf || this.ParsingObject.ReturnStub)
{
ca.ExternalReference = TertiaryBool.ParseBoolean(true);
ca.StructureURL = RetreivalStructureUrl.Get(this, ca.Id, ca.AgencyId, ca.Version);
}
return(ca.ImmutableInstance);
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
/// <summary>
/// Converts the specified <paramref name="crossDsd"/> to stub.
/// </summary>
/// <param name="crossDsd">The cross DSD.</param>
public static void ConvertToStub(this ICrossSectionalDataStructureMutableObject crossDsd)
{
crossDsd.Stub = true;
crossDsd.ExternalReference = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.True);
crossDsd.StructureURL = _defaultUri;
// remove components
crossDsd.AttributeList = null;
crossDsd.DimensionList = new DimensionListMutableCore();
crossDsd.Dimensions.Clear();
crossDsd.Groups.Clear();
crossDsd.MeasureList = null;
crossDsd.CrossSectionalAttachDataSet.Clear();
crossDsd.CrossSectionalAttachGroup.Clear();
crossDsd.CrossSectionalAttachSection.Clear();
crossDsd.CrossSectionalAttachObservation.Clear();
crossDsd.CrossSectionalMeasures.Clear();
crossDsd.MeasureDimensionCodelistMapping.Clear();
crossDsd.AttributeToMeasureMap.Clear();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECT //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="MetadataAttributeObjectCore"/> class.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="itemMutableObject">
/// The sdmxObject.
/// </param>
/// <exception cref="SdmxSemmanticException">
/// Throws Validate exception.
/// </exception>
public MetadataAttributeObjectCore(IIdentifiableObject parent, IMetadataAttributeMutableObject itemMutableObject)
: base(itemMutableObject, parent)
{
this.metadataAttributes = new List<IMetadataAttributeObject>();
this.presentational = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
try
{
if (itemMutableObject.MetadataAttributes != null)
{
foreach (IMetadataAttributeMutableObject currentMa in itemMutableObject.MetadataAttributes)
{
this.metadataAttributes.Add(new MetadataAttributeObjectCore(this, currentMa));
}
}
if (itemMutableObject.MinOccurs != null)
{
this.minOccurs = itemMutableObject.MinOccurs;
}
if (itemMutableObject.MaxOccurs != null)
{
this.maxOccurs = itemMutableObject.MaxOccurs;
}
this.presentational = itemMutableObject.Presentational;
}
catch (Exception th)
{
throw new SdmxSemmanticException("IsError creating structure: " + this, th);
}
try
{
this.Validate();
}
catch (SdmxSemmanticException e)
{
throw new SdmxSemmanticException(e, ExceptionCode.FailValidation, this);
}
}
/// <summary>
/// Create a ImmutableInstance of ConceptScheme
/// </summary>
/// <param name="AgencyId">Agency Id</param>
/// <param name="Version">Artefact Version</param>
/// <returns>IConceptSchemeObject</returns>
public IConceptSchemeObject BuildConceptScheme(string AgencyId, string Version)
{
try
{
IConceptSchemeMutableObject cs = new ConceptSchemeMutableCore();
cs.AgencyId = AgencyId;
cs.Version = Version;
cs.Id = this.Code;
if (this.Names != null)
{
foreach (SdmxObjectNameDescription item in this.Names)
{
cs.AddName(item.Lingua, item.Name);
}
}
if (!this.ParsingObject.ReturnStub)
{
foreach (IConceptMutableObject _dim in Concepts)
{
cs.AddItem(_dim);
}
}
cs.FinalStructure = TertiaryBool.ParseBoolean(true);
if (this.ParsingObject.isReferenceOf || this.ParsingObject.ReturnStub)
{
cs.ExternalReference = TertiaryBool.ParseBoolean(true);
cs.StructureURL = RetreivalStructureUrl.Get(this, cs.Id, cs.AgencyId, cs.Version);
}
return(cs.ImmutableInstance);
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataAttributeMutableCore" /> class.
/// </summary>
public MetadataAttributeMutableCore()
: base(SdmxStructureType.GetFromEnum(SdmxStructureEnumType.MetadataAttribute))
{
this._metadataAttributes = new List<IMetadataAttributeMutableObject>();
this._presentational = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="MetadataAttributeObjectCore"/> class.
/// </summary>
/// <param name="parent">
/// The parent.
/// </param>
/// <param name="metadataAttribute">
/// The metadata attributeObject.
/// </param>
/// <exception cref="SdmxSemmanticException">
/// Throws Validate exception.
/// </exception>
public MetadataAttributeObjectCore(
IIdentifiableObject parent,
Org.Sdmx.Resources.SdmxMl.Schemas.V20.structure.MetadataAttributeType metadataAttribute)
: base(
metadataAttribute,
SdmxStructureType.GetFromEnum(SdmxStructureEnumType.MetadataAttribute),
metadataAttribute.Annotations,
metadataAttribute.TextFormat,
metadataAttribute.representationSchemeAgency,
metadataAttribute.representationScheme,
metadataAttribute.RepresentationSchemeVersionEstat,
metadataAttribute.conceptSchemeAgency,
metadataAttribute.conceptSchemeRef,
GetConceptSchemeVersion(metadataAttribute),
metadataAttribute.conceptAgency,
metadataAttribute.conceptRef,
parent)
{
this.metadataAttributes = new List<IMetadataAttributeObject>();
this.presentational = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
if (metadataAttribute.usageStatus != null)
{
if (metadataAttribute.usageStatus == UsageStatusTypeConstants.Mandatory)
{
this.minOccurs = 1;
this.maxOccurs = 1;
}
else
{
this.minOccurs = 0;
}
}
if (metadataAttribute.MetadataAttribute != null)
{
foreach (Org.Sdmx.Resources.SdmxMl.Schemas.V20.structure.MetadataAttributeType currentMa in
metadataAttribute.MetadataAttribute)
{
this.metadataAttributes.Add(new MetadataAttributeObjectCore(this, currentMa));
}
}
try
{
this.Validate();
}
catch (SdmxSemmanticException e)
{
throw new SdmxSemmanticException(e, ExceptionCode.FailValidation, this);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="MetadataAttributeObjectCore"/> class.
/// </summary>
/// <param name="metadataAttribute">
/// The metadata attributeObject.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
/// <exception cref="SdmxSemmanticException">
/// Throws Validate exception.
/// </exception>
public MetadataAttributeObjectCore(MetadataAttributeType metadataAttribute, IIdentifiableObject parent)
: base(metadataAttribute, SdmxStructureType.GetFromEnum(SdmxStructureEnumType.MetadataAttribute), parent)
{
this.metadataAttributes = new List<IMetadataAttributeObject>();
this.presentational = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
this.minOccurs = (metadataAttribute.minOccurs < int.MaxValue) ? decimal.ToInt32(metadataAttribute.minOccurs) : (int?)null;
if (metadataAttribute.maxOccurs != null)
{
long res;
if (long.TryParse(metadataAttribute.maxOccurs.ToString(), out res))
{
this.maxOccurs = Convert.ToInt32(res);
}
else
{
this.maxOccurs = null; // unbounded
}
}
if (metadataAttribute.isPresentational)
{
this.presentational = TertiaryBool.ParseBoolean(metadataAttribute.isPresentational);
}
if (metadataAttribute.MetadataAttribute != null)
{
foreach (MetadataAttribute currentMaType in metadataAttribute.MetadataAttribute)
{
this.metadataAttributes.Add(new MetadataAttributeObjectCore(currentMaType.Content, this));
}
}
try
{
this.Validate();
}
catch (SdmxSemmanticException e)
{
throw new SdmxSemmanticException(e, ExceptionCode.FailValidation, this);
}
}
/// <summary>
/// Create a ImmutableInstance of Codelist
/// </summary>
/// <param name="AgencyId">Agency Id</param>
/// <param name="Version">Artefact Version</param>
/// <returns>ICodelistObject</returns>
public ICodelistMutableObject BuildCodelist(string AgencyId, string Version)
{
try
{
ICodelistMutableObject codelist = new CodelistMutableCore();
codelist.Id = this.Code;
codelist.AgencyId = AgencyId;
codelist.Version = Version;
if (this.Names == null)
{
this.Names = new List <SdmxObjectNameDescription>();
this.Names.Add(new SdmxObjectNameDescription()
{
Lingua = "en", Name = Code
});
}
else
{
foreach (SdmxObjectNameDescription item in this.Names)
{
codelist.AddName(item.Lingua, item.Name);
}
}
if (!this.ParsingObject.ReturnStub)
{
Dictionary <string, int> Idduples = new Dictionary <string, int>();
//List<string> Idduples = new List<string>();
//try
//{//ci sono i duplicati ID sotto padri diversi e SDMX scoppia....
// if (CodesObjects != null)
// Idduples = (from c in CodesObjects
// where CodesObjects.Count(comp => comp.Id == c.Id) > 1
// select c.Id).Distinct().ToList();
//}
//catch (Exception)
//{
// //Errore nella ricerca dei duplicati ma non fa niente
//}
foreach (ICodeMutableObject cl in CodesObjects)
{
if (!Idduples.ContainsKey(cl.Id))
{
Idduples[cl.Id] = 1;
}
else
{
Idduples[cl.Id]++;
}
if (Idduples[cl.Id] == 1)// && codelist.Items.Count(presentCode => presentCode.Id == cl.Id) == 0)
{
codelist.AddItem(cl);
}
}
codelist.FinalStructure = TertiaryBool.ParseBoolean(true);
codelist.IsPartial = true;
}
if (this.ParsingObject.isReferenceOf || this.ParsingObject.ReturnStub)
{
codelist.ExternalReference = TertiaryBool.ParseBoolean(true);
codelist.StructureURL = RetreivalStructureUrl.Get(this, codelist.Id, codelist.AgencyId, codelist.Version);
}
return(codelist);
}
catch (SdmxException) { throw; }
catch (Exception ex)
{
throw new SdmxException(this, FlyExceptionObject.FlyExceptionTypeEnum.CreateImmutable, ex);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="TextFormatObjectCore"/> class.
/// </summary>
/// <param name="textFormat">
/// The text format.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public TextFormatObjectCore(
Org.Sdmx.Resources.SdmxMl.Schemas.V20.structure.TextFormatType textFormat, ISdmxObject parent)
: base(_textFormatType, parent)
{
this._isSequence = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
this.multilingual = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
if (textFormat.textType != null)
{
string textType = textFormat.textType;
switch (textType)
{
// TODO java 0.9.9 bug. No Integer case
// http://www.metadatatechnology.com/mantis/view.php?id=1425
case TextTypeTypeConstants.BigInteger:
this._textType = TextType.GetFromEnum(TextEnumType.BigInteger);
break;
case TextTypeTypeConstants.Boolean:
this._textType = TextType.GetFromEnum(TextEnumType.Boolean);
break;
case TextTypeTypeConstants.Count:
this._textType = TextType.GetFromEnum(TextEnumType.Count);
break;
case TextTypeTypeConstants.Date:
this._textType = TextType.GetFromEnum(TextEnumType.Date);
break;
case TextTypeTypeConstants.DateTime:
this._textType = TextType.GetFromEnum(TextEnumType.DateTime);
break;
case TextTypeTypeConstants.Day:
this._textType = TextType.GetFromEnum(TextEnumType.Day);
break;
case TextTypeTypeConstants.Decimal:
this._textType = TextType.GetFromEnum(TextEnumType.Decimal);
break;
case TextTypeTypeConstants.Double:
this._textType = TextType.GetFromEnum(TextEnumType.Double);
break;
case TextTypeTypeConstants.Duration:
this._textType = TextType.GetFromEnum(TextEnumType.Duration);
break;
case TextTypeTypeConstants.ExclusiveValueRange:
this._textType = TextType.GetFromEnum(TextEnumType.ExclusiveValueRange);
break;
case TextTypeTypeConstants.Float:
this._textType = TextType.GetFromEnum(TextEnumType.Float);
break;
case TextTypeTypeConstants.InclusiveValueRange:
this._textType = TextType.GetFromEnum(TextEnumType.InclusiveValueRange);
break;
case TextTypeTypeConstants.Incremental:
this._textType = TextType.GetFromEnum(TextEnumType.Incremental);
break;
case TextTypeTypeConstants.Integer:
this._textType = TextType.GetFromEnum(TextEnumType.Integer);
break;
case TextTypeTypeConstants.Long:
this._textType = TextType.GetFromEnum(TextEnumType.Long);
break;
case TextTypeTypeConstants.Month:
this._textType = TextType.GetFromEnum(TextEnumType.Month);
break;
case TextTypeTypeConstants.MonthDay:
this._textType = TextType.GetFromEnum(TextEnumType.MonthDay);
break;
case TextTypeTypeConstants.ObservationalTimePeriod:
this._textType = TextType.GetFromEnum(TextEnumType.ObservationalTimePeriod);
break;
case TextTypeTypeConstants.Short:
this._textType = TextType.GetFromEnum(TextEnumType.Short);
break;
case TextTypeTypeConstants.String:
this._textType = TextType.GetFromEnum(TextEnumType.String);
break;
case TextTypeTypeConstants.Time:
this._textType = TextType.GetFromEnum(TextEnumType.Time);
break;
case TextTypeTypeConstants.Timespan:
this._textType = TextType.GetFromEnum(TextEnumType.Timespan);
break;
case TextTypeTypeConstants.URI:
this._textType = TextType.GetFromEnum(TextEnumType.Uri);
break;
case TextTypeTypeConstants.Year:
this._textType = TextType.GetFromEnum(TextEnumType.Year);
break;
case TextTypeTypeConstants.YearMonth:
this._textType = TextType.GetFromEnum(TextEnumType.YearMonth);
break;
}
if (textFormat.isSequence.HasValue)
{
this._isSequence = TertiaryBool.ParseBoolean(textFormat.isSequence);
}
if (textFormat.maxLength.HasValue)
{
this._maxLength = (long?)textFormat.maxLength;
}
if (textFormat.minLength.HasValue)
{
this._minLength = (long?)textFormat.minLength;
}
if (textFormat.startValue.HasValue)
{
this._startValue = (decimal)textFormat.startValue.Value;
}
if (textFormat.endValue.HasValue)
{
this._endValue = new decimal(textFormat.endValue.Value);
}
if (textFormat.interval.HasValue)
{
this._interval = new decimal(textFormat.interval.Value);
}
if (textFormat.timeInterval != null)
{
this._timeInterval = textFormat.timeInterval.ToString();
}
if (textFormat.decimals.HasValue)
{
this._decimals = (long)textFormat.decimals.Value;
}
if (!string.IsNullOrEmpty(textFormat.pattern))
{
this._pattern = textFormat.pattern;
}
}
this.Validate();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM V2.1 SCHEMA //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Initializes a new instance of the <see cref="TextFormatObjectCore"/> class.
/// </summary>
/// <param name="textFormatType">
/// The text format type.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public TextFormatObjectCore(TextFormatType textFormatType, ISdmxObject parent)
: base(_textFormatType, parent)
{
this._isSequence = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
this.multilingual = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
if (textFormatType.textType != null)
{
this._textType = TextTypeUtil.GetTextType(textFormatType.textType);
}
if (textFormatType.isMultiLingual)
{
this.multilingual = TertiaryBool.ParseBoolean(textFormatType.isMultiLingual);
}
if (textFormatType.isSequence != null && textFormatType.isSequence.Value)
{
this._isSequence = TertiaryBool.ParseBoolean(textFormatType.isSequence.Value);
}
if (textFormatType.maxLength.HasValue)
{
this._maxLength = (long?)textFormatType.maxLength;
}
if (textFormatType.minLength != null)
{
this._minLength = (long?)textFormatType.minLength;
}
if (textFormatType.startValue.HasValue)
{
this._startValue = textFormatType.startValue.Value;
}
if (textFormatType.endValue.HasValue)
{
this._endValue = textFormatType.endValue.Value;
}
if (textFormatType.maxValue.HasValue)
{
this._maxValue = textFormatType.maxValue.Value;
}
if (textFormatType.minValue.HasValue)
{
this._minValue = (long)textFormatType.minValue.Value;
}
if (textFormatType.interval.HasValue)
{
this._interval = textFormatType.interval.Value;
}
if (textFormatType.timeInterval != null)
{
this._timeInterval = textFormatType.timeInterval.ToString();
}
if (textFormatType.decimals.HasValue)
{
this._decimals = (long)textFormatType.decimals.Value;
}
if (!string.IsNullOrEmpty(textFormatType.pattern))
{
this._pattern = textFormatType.pattern;
}
if (textFormatType.endTime != null)
{
this._endTime = new SdmxDateCore(textFormatType.endTime.ToString());
}
if (textFormatType.startTime != null)
{
this._startTime = new SdmxDateCore(textFormatType.startTime.ToString());
}
this.Validate();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
////////////BUILD FROM MUTABLE OBJECT //////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="TextFormatObjectCore"/> class.
/// </summary>
/// <param name="textFormatMutable">
/// The text format mutable.
/// </param>
/// <param name="parent">
/// The parent.
/// </param>
public TextFormatObjectCore(ITextFormatMutableObject textFormatMutable, ISdmxObject parent)
: base(textFormatMutable, parent)
{
this._isSequence = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
this.multilingual = TertiaryBool.GetFromEnum(TertiaryBoolEnumType.Unset);
this._textType = textFormatMutable.TextType;
if (textFormatMutable.Sequence != null)
{
this._isSequence = textFormatMutable.Sequence;
}
this._maxLength = textFormatMutable.MaxLength;
this._minLength = textFormatMutable.MinLength;
this._startValue = textFormatMutable.StartValue;
this._endValue = textFormatMutable.EndValue;
this._maxValue = textFormatMutable.MaxValue;
this._minValue = textFormatMutable.MinValue;
this._interval = textFormatMutable.Interval;
this._timeInterval = textFormatMutable.TimeInterval;
this._decimals = textFormatMutable.Decimals;
this._pattern = textFormatMutable.Pattern;
this.Validate();
}
/// <summary>
/// Write the attribute if it's value is not null
/// </summary>
/// <param name="attribute">
/// The attribute name
/// </param>
/// <param name="value">
/// The attribute value
/// </param>
protected void TryWriteAttribute(AttributeNameTable attribute, TertiaryBool value)
{
if (value != null)
{
this.TryWriteAttribute(NameTableCache.GetAttributeName(attribute), value.EnumType);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TextFormatMutableCore"/> class.
/// </summary>
/// <param name="textFormat">
/// The itxt.
/// </param>
public TextFormatMutableCore(ITextFormat textFormat)
: base(textFormat)
{
this.textType = textFormat.TextType;
this.isSequence = textFormat.Sequence;
this.maxLength = textFormat.MaxLength;
this.minLength = textFormat.MinLength;
this.startValue = textFormat.StartValue;
this.endValue = textFormat.EndValue;
this.interval = textFormat.Interval;
this.maxValue = textFormat.MaxValue;
this.minValue = textFormat.MinValue;
this.isMultilingual = textFormat.Multilingual;
if (textFormat.TimeInterval != null)
{
this.timeInterval = textFormat.TimeInterval;
}
this.decimals = textFormat.Decimals;
this.pattern = textFormat.Pattern;
}
