/// <summary>
/// Adds a translation for the TOM object based on the supplied AMOTranslation.
/// Creates the relevant culture if it does not exist.
/// </summary>
/// <param name="TOMDatabase">The TOM Database to add the Translation to</param>
/// <param name="TOMObject">The TOM Object the translation is being added for</param>
/// <param name="AMOTranslation">The AMO Translation being transferred to the TOM Database</param>
public static void AddTOMTranslation(TOM.Database TOMDatabase, TOM.MetadataObject TOMObject, AMO.Translation AMOTranslation)
{
string CultureName = TranslationHelper.GetCultureNameFromLCID(AMOTranslation.Language);
//Add Culture if it does not exist
if (!TOMDatabase.Model.Cultures.ContainsName(CultureName))
{
TOMDatabase.Model.Cultures.Add(new TOM.Culture {
Name = CultureName
});
}
//Get existing culture
TOM.Culture TOMCulture = TOMDatabase.Model.Cultures.Find(CultureName);
//Add the various translated properties to the translation
TOMCulture.ObjectTranslations.Add(
new TOM.ObjectTranslation {
Object = TOMObject, Property = TOM.TranslatedProperty.Caption, Value = AMOTranslation.Caption
}
);
TOMCulture.ObjectTranslations.Add(
new TOM.ObjectTranslation {
Object = TOMObject, Property = TOM.TranslatedProperty.Description, Value = AMOTranslation.Description
}
);
TOMCulture.ObjectTranslations.Add(
new TOM.ObjectTranslation {
Object = TOMObject, Property = TOM.TranslatedProperty.DisplayFolder, Value = AMOTranslation.DisplayFolder
}
);
}
public static string GetObjectPath(this TOM.MetadataObject obj)
{
switch (obj.ObjectType)
{
case TOM.ObjectType.Model:
return("Model");
case TOM.ObjectType.Measure:
case TOM.ObjectType.Table:
case TOM.ObjectType.Column:
case TOM.ObjectType.Hierarchy:
return(GetObjectPathTableObject(obj as TOM.NamedMetadataObject));
case TOM.ObjectType.Level:
var level = obj as TOM.Level;
return(GetObjectPathTableObject(level.Hierarchy) + "." + level.Name);
case TOM.ObjectType.KPI:
return(GetObjectPathTableObject((obj as TOM.KPI).Measure) + ".KPI");
case TOM.ObjectType.Variation:
return(GetObjectPathTableObject((obj as TOM.Variation).Column) + ".Variations." + QuotePath((obj as TOM.Variation).Name));
case TOM.ObjectType.Relationship:
case TOM.ObjectType.DataSource:
case TOM.ObjectType.Role:
case TOM.ObjectType.Expression:
case TOM.ObjectType.Perspective:
case TOM.ObjectType.Culture:
return(obj.ObjectType.ToString() + "." + QuotePath((obj as TOM.NamedMetadataObject).Name));
case TOM.ObjectType.Partition:
return("TablePartition." + QuotePath((obj as TOM.Partition).Table?.Name ?? "") + "." + QuotePath((obj as TOM.Partition).Name));
case TOM.ObjectType.RoleMembership:
var mrm = obj as TOM.ModelRoleMember;
return(GetObjectPath(mrm.Role) + "." + mrm.Name);
case TOM.ObjectType.CalculationGroup:
var cg = obj as TOM.CalculationGroup;
return(GetObjectPath(cg.Table) + ".CalculationGroup");
case TOM.ObjectType.TablePermission:
var tp = obj as TOM.TablePermission;
return(GetObjectPath(tp.Role) + "." + tp.Table.Name);
case TOM.ObjectType.CalculationItem:
var ci = obj as TOM.CalculationItem;
return(GetObjectPath(ci.CalculationGroup) + ".CalculationGroup." + ci.Name);
case TOM.ObjectType.AlternateOf:
var ao = obj as TOM.AlternateOf;
return(GetObjectPath(ao.Column) + ".AlternateOf");
default:
throw new NotSupportedException($"Cannot create reference for object of type {obj.ObjectType}.");
}
}
internal override void TOM_Remove(TOM.MetadataObject obj)
{
var groupByColumn = tomCollection?.FirstOrDefault(gbc => gbc.GroupingColumn == obj);
if (groupByColumn != null)
{
tomCollection.Remove(groupByColumn);
}
}
public static string GetObjectPath(this TOM.MetadataObject obj)
{
var name = (obj as TOM.NamedMetadataObject)?.Name ?? obj.ObjectType.ToString();
if (obj.Parent != null)
{
return(obj.Parent.GetObjectPath() + "." + name);
}
else
{
return(name);
}
}
internal override int IndexOf(TOM.MetadataObject value)
{
var ix = TOM_Collection.IndexOf(value as TOM.Column);
var rnIx = GetRnColIndex();
if (ix == rnIx)
{
throw new KeyNotFoundException();
}
if (ix > rnIx && rnIx > -1)
{
ix--;
}
return(ix);
}
internal override void TOM_Add(TOM.MetadataObject obj)
{
if (!(obj is TOM.Column column))
{
throw new ArgumentException("Object not of type Column", "obj");
}
if (tomCollection == null)
{
valueColumn.RelatedColumnDetails = new TOM.RelatedColumnDetails();
}
tomCollection.Add(new TOM.GroupByColumn {
GroupingColumn = column
});
}
/// <summary>
/// Creates a TabularObject representing the provided TOM MetadataObject.
/// </summary>
/// <param name="metadataObject"></param>
protected TabularObject(TOM.MetadataObject metadataObject)
{
if (metadataObject == null)
{
throw new ArgumentNullException("metadataObject");
}
_metadataObject = metadataObject;
Handler = TabularModelHandler.Singleton;
Handler.WrapperLookup[metadataObject] = this;
// Assign collection based on parent:
if (metadataObject.Parent != null)
{
Collection = (Handler.WrapperLookup[metadataObject.Parent] as TabularObject).GetCollectionForChild(this);
}
}
public static string GetObjectPath(this TOM.MetadataObject obj)
{
var name = (obj is TOM.Model) ? "Model" : (obj as TOM.NamedMetadataObject)?.Name ?? obj.ObjectType.ToString();
if (name.Contains("."))
{
name = "[" + name + "]";
}
if (obj.Parent != null)
{
return(obj.Parent.GetObjectPath() + "." + name);
}
else
{
return(name);
}
}
public static string GetObjectPath(this TOM.MetadataObject obj)
{
switch (obj.ObjectType)
{
case TOM.ObjectType.Model:
return("Model");
case TOM.ObjectType.Measure:
case TOM.ObjectType.Table:
case TOM.ObjectType.Column:
case TOM.ObjectType.Hierarchy:
case TOM.ObjectType.Level:
return(GetObjectPathTableObject(obj as TOM.NamedMetadataObject));
case TOM.ObjectType.KPI:
return(GetObjectPathTableObject((obj as TOM.KPI).Measure) + ".KPI");
case TOM.ObjectType.Variation:
return(GetObjectPathTableObject((obj as TOM.Variation).Column) + ".Variations." + QuotePath((obj as TOM.Variation).Name));
case TOM.ObjectType.Relationship:
case TOM.ObjectType.DataSource:
case TOM.ObjectType.Role:
case TOM.ObjectType.Expression:
case TOM.ObjectType.Perspective:
case TOM.ObjectType.Culture:
return(obj.ObjectType.ToString() + "." + QuotePath((obj as TOM.NamedMetadataObject).Name));
case TOM.ObjectType.Partition:
return("TablePartition." + QuotePath((obj as TOM.Partition).Table?.Name ?? "") + "." + QuotePath((obj as TOM.Partition).Name));
case TOM.ObjectType.RoleMembership:
var mrm = obj as TOM.ModelRoleMember;
return(GetObjectPath(mrm.Role) + "." + mrm.Name);
default:
throw new NotSupportedException($"Cannot create reference for object of type {obj.ObjectType}.");
}
}
public static AMO.Translation GetTranslation(TOM.Culture TOMCulture, TOM.MetadataObject TOMObject)
{
AMO.Translation AMOTranslation = new AMO.Translation
{
Language = GetLCIDFromCultureName(TOMCulture.Name)
};
//Caption (i.e. Name)
if (TOMCulture.ObjectTranslations[TOMObject, TOM.TranslatedProperty.Caption] != null)
{
AMOTranslation.Caption = TOMCulture.ObjectTranslations[TOMObject, TOM.TranslatedProperty.Caption].Value;
}
//Description
if (TOMCulture.ObjectTranslations[TOMObject, TOM.TranslatedProperty.Description] != null)
{
AMOTranslation.Description = TOMCulture.ObjectTranslations[TOMObject, TOM.TranslatedProperty.Description].Value;
}
//Display Folder
if (TOMCulture.ObjectTranslations[TOMObject, TOM.TranslatedProperty.DisplayFolder] != null)
{
AMOTranslation.DisplayFolder = TOMCulture.ObjectTranslations[TOMObject, TOM.TranslatedProperty.DisplayFolder].Value;
}
// If translation has no properties, it does not exist.
// As such, return null unless it has at least one valid property
if (AMOTranslation.Caption != null || AMOTranslation.Description != null || AMOTranslation.DisplayFolder != null)
{
return(AMOTranslation);
}
else
{
return(null);
}
}
protected abstract bool TOM_Contains(TOM.MetadataObject obj);
protected abstract void TOM_Remove(TOM.MetadataObject obj);
protected abstract void TOM_Add(TOM.MetadataObject obj);
public abstract int IndexOf(TOM.MetadataObject value);
internal abstract int IndexOf(TOM.MetadataObject value);
internal abstract void TOM_Add(TOM.MetadataObject obj);
internal override bool TOM_Contains(TOM.MetadataObject obj)
{
return(tomCollection?.Any(gbc => gbc.GroupingColumn == obj) ?? false);
}
internal abstract void TOM_Remove(TOM.MetadataObject obj);
internal override int IndexOf(TOM.MetadataObject value)
{
return(tomCollection == null ? -1 : tomCollection.Select(tc => tc.GroupingColumn).ToList().IndexOf(value as TOM.Column));
}
public TabularObject GetWrapperObject(TOM.MetadataObject obj)
{
return(WrapperLookup[obj]);
}
internal abstract bool TOM_Contains(TOM.MetadataObject obj);
