public Task RegisterLocallyKnownMediaItemAspectTypeAsync(MediaItemAspectMetadata miam)
{
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>();
mediaLibrary.AddMediaItemAspectStorage(miam);
return(Task.CompletedTask);
}
private static void ShowMIAs(IDictionary <Guid, IList <MediaItemAspect> > aspects, IMediaItemAspectTypeRegistration registration)
{
foreach (Guid mia in aspects.Keys)
{
MediaItemAspectMetadata metadata = registration.LocallyKnownMediaItemAspectTypes[mia];
foreach (MediaItemAspect aspect in aspects[mia])
{
Console.WriteLine(" {0}:", metadata.Name);
int count = 0;
string sb = " ";
foreach (MediaItemAspectMetadata.AttributeSpecification spec in metadata.AttributeSpecifications.Values)
{
object value = aspect[spec];
if (value != null)
{
if (count > 0)
{
sb += ",";
}
if (value is IList)
{
sb += string.Format(" {0}({1}/{2})=[{3}]", spec.AttributeName, spec.AttributeType.Name, spec.Cardinality, string.Join(",", (IList)value));
}
else
{
sb += string.Format(" {0}={1}", spec.AttributeName, value.ToString());
}
count++;
}
}
Console.WriteLine(sb);
}
}
}
public void TestMultipleMIAM()
{
MultipleTestMIA src = TestCommonUtils.CreateMultipleMIA("Multiple", Cardinality.Inline, true, false);
TextWriter writer = new StringWriter();
XmlWriter serialiser = new XmlTextWriter(writer);
serialiser.WriteStartElement("Test");
src.Metadata.Serialize(serialiser);
serialiser.WriteEndElement();
Console.WriteLine("XML: {0}", writer);
XmlReader reader = XmlReader.Create(new StringReader(writer.ToString()));
reader.Read(); // Test tag
reader.Read(); // MIAM tag
MultipleMediaItemAspectMetadata dest = MediaItemAspectMetadata.Deserialize(reader) as MultipleMediaItemAspectMetadata;
Assert.IsNotNull(dest, "Dest");
Assert.AreEqual(src.Metadata.AspectId, dest.AspectId, "Aspect ID");
Assert.AreEqual(src.Metadata.AttributeSpecifications.Count, dest.AttributeSpecifications.Count, "Attribute spec count");
AssertMultipleMIAMSpec(src.Metadata.AttributeSpecifications.Values, dest.AttributeSpecifications.Values, src.ATTR_STRING);
Assert.IsNotNull(src.Metadata.UniqueAttributeSpecifications, "Source unique spec");
Assert.IsNotNull(dest.UniqueAttributeSpecifications, "Source unique spec");
Assert.AreEqual(src.Metadata.UniqueAttributeSpecifications.Count, dest.UniqueAttributeSpecifications.Count, "Attribute unique spec count");
AssertMultipleMIAMSpec(src.Metadata.UniqueAttributeSpecifications.Values, dest.UniqueAttributeSpecifications.Values, src.ATTR_ID);
}
protected override object DoDeserializeValue(XmlReader reader, bool isSimpleValue)
{
reader.ReadStartElement(); // Read start of enclosing element
MediaItemAspectMetadata result = MediaItemAspectMetadata.Deserialize(reader);
reader.ReadEndElement(); // End of enclosing element
return(result);
}
public async Task AddMediaItemAspectStorageAsync(MediaItemAspectMetadata miam)
{
CpAction action = GetAction("X_MediaPortal_AddMediaItemAspectStorage");
IList <object> inParameters = new List <object> {
miam
};
await action.InvokeAsync(inParameters);
}
public Task RegisterLocallySupportedReimportMediaItemAspectTypeAsync(MediaItemAspectMetadata miaType)
{
Console.WriteLine("Registering reimport support " + miaType.Name);
if (!_locallySupportedReimportMediaItemAspectTypes.ContainsKey(miaType.AspectId))
{
_locallySupportedReimportMediaItemAspectTypes.Add(miaType.AspectId, miaType);
}
return(Task.CompletedTask);
}
public void RegisterLocallyKnownMediaItemAspectType(MediaItemAspectMetadata miaType)
{
Console.WriteLine("Registering " + miaType.Name);
if (_locallyKnownMediaItemAspectTypes.ContainsKey(miaType.AspectId))
{
return;
}
_locallyKnownMediaItemAspectTypes.Add(miaType.AspectId, miaType);
}
public void AddMediaItemAspectStorage(MediaItemAspectMetadata miam)
{
CpAction action = GetAction("AddMediaItemAspectStorage");
IList <object> inParameters = new List <object> {
miam
};
action.InvokeAction(inParameters);
}
public bool Connect()
{
try
{
stateService = new SystemStateService();
ServiceRegistration.Set <ISystemStateService>(stateService);
stateService.SwitchSystemState(SystemState.Initializing, false);
logger.Info("Initialising core services");
ApplicationCore.RegisterVitalCoreServices(false);
ApplicationCore.RegisterCoreServices();
logger.Info("Starting localization");
ServiceRegistration.Set <ILocalization>(new NoLocalization());
logger.Info("Initialising system resolver");
ServiceRegistration.Set <ISystemResolver>(new SystemResolver());
ServerConnectionReceiver reciever = new ServerConnectionReceiver();
ServiceRegistration.Get <IMessageBroker>().RegisterMessageReceiver(ServerConnectionMessaging.CHANNEL, reciever);
logger.Info("Initialising server connection manger");
connectionManager = new ServerConnectionManager();
ServiceRegistration.Set <IServerConnectionManager>(connectionManager);
logger.Info("Starting up server connection manger");
connectionManager.Startup();
bool connected = reciever.Connect();
if (connected)
{
logger.Info("Initialising media item aspect type registration");
ServiceRegistration.Set <IMediaItemAspectTypeRegistration>(new MediaItemAspectTypeRegistration());
ICollection <Guid> types = GetAllManagedMediaItemAspectTypes();
foreach (Guid type in types)
{
MediaItemAspectMetadata metadata = GetMediaItemAspectMetadata(type);
logger.Info("Registering media item {0}...", metadata.Name);
ServiceRegistration.Get <IMediaItemAspectTypeRegistration>().RegisterLocallyKnownMediaItemAspectTypeAsync(metadata).Wait();
}
}
Connected = connected;
return(connected);
}
catch (Exception e)
{
logger.Error("Cannot connect", e);
return(false);
}
}
public Task RegisterLocallyKnownMediaItemAspectTypeAsync(MediaItemAspectMetadata miaType)
{
Console.WriteLine("Registering " + miaType.Name);
if (_locallyKnownMediaItemAspectTypes.ContainsKey(miaType.AspectId))
{
return(Task.CompletedTask);
}
_locallyKnownMediaItemAspectTypes.Add(miaType.AspectId, miaType);
return(Task.CompletedTask);
}
private static void ShowMediaItems(Client client, IFilter filter)
{
IMediaItemAspectTypeRegistration registration = ServiceRegistration.Get <IMediaItemAspectTypeRegistration>();
IList <MediaItem> items = client.GetContentDirectory().SearchAsync(new MediaItemQuery(null, registration.LocallyKnownMediaItemAspectTypes.Keys, filter), true, null, true).Result;
foreach (MediaItem item in items)
{
Console.WriteLine("\nItem {0}:", item.MediaItemId);
foreach (Guid mia in item.Aspects.Keys)
{
MediaItemAspectMetadata metadata = registration.LocallyKnownMediaItemAspectTypes[mia];
foreach (MediaItemAspect aspect in item.Aspects[mia])
{
Console.WriteLine(" {0}:", metadata.Name);
int count = 0;
string sb = " ";
foreach (MediaItemAspectMetadata.AttributeSpecification spec in aspect.Metadata.AttributeSpecifications.Values)
{
string valueStr = null;
if (spec.IsCollectionAttribute)
{
IEnumerable values = aspect.GetCollectionAttribute(spec);
if (values != null)
{
IList <string> list = new List <string>();
foreach (object value in values)
{
list.Add(GetValue(spec, value));
}
valueStr = string.Format("[{0}]", string.Join(",", list));
}
}
else
{
valueStr = GetValue(spec, aspect.GetAttributeValue(spec));
}
if (valueStr != null)
{
if (count > 0)
{
sb += ",";
}
//sb += string.Format(" {0}{1}{2}({3}/{4})={5}", spec.AttributeName, aspect is MultipleMediaItemAspect ? "," : "", aspect is MultipleMediaItemAspect ? ((MultipleMediaItemAspect)aspect).Index.ToString() : "", spec.AttributeType.Name, spec.Cardinality, valueStr);
sb += string.Format(" {0}={1}", spec.AttributeName, valueStr);
count++;
}
}
Console.WriteLine(sb);
}
}
}
}
public static void ShowMediaAspects(IDictionary <Guid, IList <MediaItemAspect> > aspects, IDictionary <Guid, MediaItemAspectMetadata> metadatas)
{
foreach (Guid mia in aspects.Keys)
{
MediaItemAspectMetadata metadata = metadatas[mia];
foreach (MediaItemAspect aspect in aspects[mia])
{
logger.Debug(" {0}:", metadata.Name);
int count = 0;
string sb = " ";
foreach (MediaItemAspectMetadata.AttributeSpecification spec in aspect.Metadata.AttributeSpecifications.Values)
{
string valueStr = null;
if (spec.IsCollectionAttribute)
{
IEnumerable values = aspect.GetCollectionAttribute(spec);
if (values != null)
{
IList <string> list = new List <string>();
foreach (object value in values)
{
list.Add(value.ToString());
}
valueStr = string.Format("[{0}]", string.Join(",", list));
}
}
else
{
object value = aspect.GetAttributeValue(spec);
if (value != null)
{
valueStr = value.ToString();
}
}
if (valueStr != null)
{
if (count > 0)
{
sb += ",";
}
//sb += string.Format(" {0}{1}{2}({3}/{4})={5}", spec.AttributeName, aspect is MultipleMediaItemAspect ? "," : "", aspect is MultipleMediaItemAspect ? ((MultipleMediaItemAspect)aspect).Index.ToString() : "", spec.AttributeType.Name, spec.Cardinality, valueStr);
sb += string.Format(" {0}={1}", spec.AttributeName, valueStr);
count++;
}
}
logger.Debug(sb);
}
}
}
public async Task RegisterLocallyKnownMediaItemAspectTypeAsync(MediaItemAspectMetadata miaType)
{
if (_locallyKnownMediaItemAspectTypes.ContainsKey(miaType.AspectId))
{
return;
}
_locallyKnownMediaItemAspectTypes.Add(miaType.AspectId, miaType);
IServerConnectionManager serverConnectionManager = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = serverConnectionManager?.ContentDirectory;
if (cd != null)
{
await cd.AddMediaItemAspectStorageAsync(miaType);
}
}
public void RegisterLocallyKnownMediaItemAspectType(MediaItemAspectMetadata miaType)
{
if (_locallyKnownMediaItemAspectTypes.ContainsKey(miaType.AspectId))
{
return;
}
_locallyKnownMediaItemAspectTypes.Add(miaType.AspectId, miaType);
IServerConnectionManager serverConnectionManager = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = serverConnectionManager == null ? null :
serverConnectionManager.ContentDirectory;
if (cd != null)
{
cd.AddMediaItemAspectStorage(miaType);
}
}
public Task RegisterLocallyKnownMediaItemAspectTypeAsync(MediaItemAspectMetadata miaType)
{
if (_locallyKnownMediaItemAspectTypes.ContainsKey(miaType.AspectId))
{
return(Task.CompletedTask);
}
_locallyKnownMediaItemAspectTypes.Add(miaType.AspectId, miaType);
IServerConnectionManager serverConnectionManager = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = serverConnectionManager == null ? null :
serverConnectionManager.ContentDirectory;
if (cd != null)
{
cd.AddMediaItemAspectStorageAsync(miaType).Wait();
}
return(Task.CompletedTask);
}
public static SingleTestMIA CreateSingleMIA(string table, Cardinality cardinality, bool createStringAttribute, bool createIntegerAttribute)
{
SingleTestMIA mia = new SingleTestMIA();
mia.ASPECT_ID = Guid.NewGuid();
IList <MediaItemAspectMetadata.SingleAttributeSpecification> attributes = new List <MediaItemAspectMetadata.SingleAttributeSpecification>();
if (createStringAttribute)
{
attributes.Add(mia.ATTR_STRING = MediaItemAspectMetadata.CreateSingleStringAttributeSpecification("ATTR_STRING", 10, cardinality, false));
}
if (createIntegerAttribute)
{
attributes.Add(mia.ATTR_INTEGER = MediaItemAspectMetadata.CreateSingleAttributeSpecification("ATTR_INTEGER", typeof(Int32), cardinality, true));
}
mia.Metadata = new SingleMediaItemAspectMetadata(mia.ASPECT_ID, table, attributes.ToArray());
return(mia);
}
public void TestSingleMIAM()
{
SingleTestMIA src = TestCommonUtils.CreateSingleMIA("Single", Cardinality.Inline, true, false);
TextWriter writer = new StringWriter();
XmlWriter serialiser = new XmlTextWriter(writer);
serialiser.WriteStartElement("Test"); // Wrapper around the albums
src.Metadata.Serialize(serialiser);
serialiser.WriteEndElement();
Console.WriteLine("XML: {0}", writer);
XmlReader reader = XmlReader.Create(new StringReader(writer.ToString()));
reader.Read(); // Test tag
reader.Read(); // MIAM tag
SingleMediaItemAspectMetadata dest = MediaItemAspectMetadata.Deserialize(reader) as SingleMediaItemAspectMetadata;
Assert.IsNotNull(dest);
Assert.AreEqual(src.Metadata.AspectId, dest.AspectId);
Assert.AreEqual(src.Metadata.AttributeSpecifications.Count, dest.AttributeSpecifications.Count);
MediaItemAspectMetadata.SingleAttributeSpecification srcSpec = src.Metadata.AttributeSpecifications[src.ATTR_STRING.AttributeName] as MediaItemAspectMetadata.SingleAttributeSpecification;
Assert.IsNotNull(srcSpec);
MediaItemAspectMetadata.SingleAttributeSpecification destSpec = dest.AttributeSpecifications[src.ATTR_STRING.AttributeName] as MediaItemAspectMetadata.SingleAttributeSpecification;
Assert.IsNotNull(destSpec);
Assert.AreEqual(srcSpec.AttributeName, destSpec.AttributeName);
Assert.AreEqual(srcSpec.AttributeType, destSpec.AttributeType);
Assert.AreEqual(srcSpec.Cardinality, destSpec.Cardinality);
Assert.AreEqual(srcSpec.IsCollectionAttribute, destSpec.IsCollectionAttribute);
Assert.AreEqual(srcSpec.IsIndexed, destSpec.IsIndexed);
Assert.AreEqual(srcSpec.MaxNumChars, destSpec.MaxNumChars);
}
/// <summary>
/// Creates a table query of the main media item aspect table of the given <paramref name="miaType"/>.
/// </summary>
/// <param name="miaManagement">MIA management instance.</param>
/// <param name="miaType">Type of the MIA to request.</param>
/// <returns>Table query for the given MIA.</returns>
public static TableQueryData CreateTableQueryOfMIATable(MIA_Management miaManagement,
MediaItemAspectMetadata miaType)
{
return(new TableQueryData(miaManagement.GetMIATableName(miaType)));
}
public BetweenFilter(MediaItemAspectMetadata.AttributeSpecification attributeType,
object value1, object value2) : base(attributeType)
{
_value1 = value1;
_value2 = value2;
}
public EmptyFilter(MediaItemAspectMetadata.AttributeSpecification attributeType) : base(attributeType) { }
public static void AddMediaItemAspectStorage(MediaItemAspectMetadata meta)
{
MANAGEMENT.AddMediaItemAspectStorage(meta);
}
public Task RegisterLocallySupportedReimportMediaItemAspectTypeAsync(MediaItemAspectMetadata miaType)
{
_locallySupportedReimportMediaItemAspectTypes.TryAdd(miaType.AspectId, miaType);
return(Task.CompletedTask);
}
public LikeFilter(MediaItemAspectMetadata.AttributeSpecification attributeType,
string expression, char? escapeChar, bool caseSensitive) : base(attributeType, expression, escapeChar)
{
_caseSensitive = caseSensitive;
}
public LikeFilter(MediaItemAspectMetadata.AttributeSpecification attributeType,
string expression, char? escapeChar) : this(attributeType, expression, escapeChar, true) { }
public void RegisterLocallyKnownMediaItemAspectType(MediaItemAspectMetadata miam)
{
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>();
mediaLibrary.AddMediaItemAspectStorage(miam);
}
protected void RequestSimpleAttribute(QueryAttribute queryAttribute,
IDictionary <object, TableQueryData> tableQueries, IList <TableJoin> tableJoins, string miaJoinType,
IDictionary <QueryAttribute, RequestedAttribute> requestedAttributes,
IDictionary <MediaItemAspectMetadata, TableQueryData> miaTypeTableQueries,
RequestedAttribute miaIdAttribute, out RequestedAttribute requestedAttribute)
{
if (requestedAttributes.TryGetValue(queryAttribute, out requestedAttribute))
{
// Already requested
return;
}
MediaItemAspectMetadata.AttributeSpecification spec = queryAttribute.Attr;
MediaItemAspectMetadata miaType = spec.ParentMIAM;
TableQueryData tqd;
switch (spec.Cardinality)
{
case Cardinality.Inline:
// For Inline queries, we request the Inline attribute's column name at the MIA main table, which gets joined
// with the MIA ID
if (!tableQueries.TryGetValue(miaType, out tqd))
{
tqd = tableQueries[miaType] = TableQueryData.CreateTableQueryOfMIATable(_miaManagement, miaType);
if (miaTypeTableQueries != null)
{
miaTypeTableQueries.Add(miaType, tqd);
}
tableJoins.Add(new TableJoin(miaJoinType, tqd, miaIdAttribute,
new RequestedAttribute(tqd, MIA_Management.MIA_MEDIA_ITEM_ID_COL_NAME)));
}
requestedAttribute = new RequestedAttribute(tqd, _miaManagement.GetMIAAttributeColumnName(queryAttribute.Attr));
break;
case Cardinality.ManyToOne:
// For MTO queries, we request both the MIA main table and the MTO table
TableQueryData miaTqd;
if (!tableQueries.TryGetValue(miaType, out miaTqd))
{
miaTqd = tableQueries[miaType] = TableQueryData.CreateTableQueryOfMIATable(_miaManagement, miaType);
if (miaTypeTableQueries != null)
{
miaTypeTableQueries.Add(miaType, miaTqd);
}
// Add MIA main table to list of table joins
tableJoins.Add(new TableJoin(miaJoinType, miaTqd, miaIdAttribute,
new RequestedAttribute(miaTqd, MIA_Management.MIA_MEDIA_ITEM_ID_COL_NAME)));
}
if (!tableQueries.TryGetValue(spec, out tqd))
{
tqd = tableQueries[spec] = TableQueryData.CreateTableQueryOfMTOTable(_miaManagement, spec);
// We must use left outer joins for MTO value tables, because if the value is null, the association FK is null
tableJoins.Add(new TableJoin("LEFT OUTER JOIN", tqd,
new RequestedAttribute(miaTqd, _miaManagement.GetMIAAttributeColumnName(queryAttribute.Attr)),
new RequestedAttribute(tqd, MIA_Management.FOREIGN_COLL_ATTR_ID_COL_NAME)));
}
requestedAttribute = new RequestedAttribute(tqd, MIA_Management.COLL_ATTR_VALUE_COL_NAME);
break;
default:
throw new IllegalCallException("Attributes of cardinality '{0}' cannot be queried via the {1}", spec.Cardinality, GetType().Name);
}
requestedAttributes.Add(queryAttribute, requestedAttribute);
}
public SortInformation(MediaItemAspectMetadata.AttributeSpecification attributeType, SortDirection sortDirection)
{
_attributeType = attributeType;
_sortDirection = sortDirection;
}
protected AbstractExpressionFilter(MediaItemAspectMetadata.AttributeSpecification attributeType,
string expression, char? escapeChar) : base(attributeType)
{
_expression = expression;
_escapeChar = escapeChar;
}
public RelationalFilter(MediaItemAspectMetadata.AttributeSpecification attributeType,
RelationalOperator op, object filterValue) : base(attributeType)
{
_operator = op;
_filterValue = filterValue;
}
protected override bool Include(MediaItemAspectMetadata miam)
{
return(true);
}
public static string GetMIATableIdentifier(MediaItemAspectMetadata miam)
{
return("T_" + SqlUtils.ToSQLIdentifier(miam.AspectId.ToString()).ToUpperInvariant());
}
public void RegisterMediaItemAspectRoleHierarchyChildCountAttribute(Guid childRole, Guid parentRole, MediaItemAspectMetadata parentMiaType, MediaItemAspectMetadata.AttributeSpecification childCountAttribute, bool includeVirtual)
{
}
public static string SerializeAttributeTypeReference(MediaItemAspectMetadata.AttributeSpecification attributeType)
{
return attributeType.ParentMIAM.AspectId + ":" + attributeType.AttributeName;
}
public void RegisterLocallyKnownMediaItemAspectType(MediaItemAspectMetadata miaType, MediaItemAspectMetadata.AttributeSpecification[] fkSpecs, MediaItemAspectMetadata refType, MediaItemAspectMetadata.AttributeSpecification[] refSpecs)
{
}
/// <summary>
/// Generates a statement to query the distinct values of the complex <see cref="QueryAttribute"/>, together with their
/// occurence count.
/// </summary>
/// <param name="queryAttributeFilter">Additional filter which is defined on the <see cref="QueryAttribute"/>.
/// That filter COULD be part of the <see cref="Filter"/> but this method can highly optimize a filter on the
/// query attribute, so a filter on that attribute should be given in this parameter and should not be part of the <see cref="Filter"/>.
/// </param>
/// <param name="valueAlias">Alias for the value column.</param>
/// <param name="groupSizeAlias">Alias for the column containing the number of items in each group.</param>
/// <param name="statementStr">Statement which was built by this method.</param>
/// <param name="bindVars">Bind variables to be inserted into placeholders in the returned <paramref name="statementStr"/>.</param>
public void GenerateSqlGroupByStatement(IAttributeFilter queryAttributeFilter,
out string valueAlias, out string groupSizeAlias, out string statementStr, out IList <BindVar> bindVars)
{
Namespace ns = new Namespace();
BindVarNamespace bvNamespace = new BindVarNamespace();
// Contains a mapping of each queried (=selected or filtered) attribute to its request attribute instance
// data (which holds its requested query table instance)
IDictionary <QueryAttribute, RequestedAttribute> requestedAttributes = new Dictionary <QueryAttribute, RequestedAttribute>();
// Dictionary containing as key the requested MIAM instance OR attribute specification of cardinality MTO,
// mapped to the table query data to request its contents.
IDictionary <object, TableQueryData> tableQueries = new Dictionary <object, TableQueryData>();
// Contains the same tables as the tableQueries variable, but in order and enriched with table join data
IList <TableJoin> tableJoins = new List <TableJoin>();
// First create the request table query data for the MIA main table and the request attribute for the MIA ID.
// We'll need the requested attribute as join attribute soon.
MediaItemAspectMetadata queryMIAM = _queryAttribute.ParentMIAM;
TableQueryData miaTableQuery = new TableQueryData(_miaManagement.GetMIATableName(queryMIAM));
tableQueries.Add(queryMIAM, miaTableQuery);
RequestedAttribute miaIdAttribute = new RequestedAttribute(miaTableQuery, MIA_Management.MIA_MEDIA_ITEM_ID_COL_NAME);
// Ensure that the tables for all necessary MIAs are requested first (INNER JOIN)
foreach (MediaItemAspectMetadata miaType in _necessaryRequestedMIAs)
{
TableQueryData tqd;
if (!tableQueries.TryGetValue(miaType, out tqd))
{
tqd = tableQueries[miaType] = TableQueryData.CreateTableQueryOfMIATable(_miaManagement, miaType);
}
if (miaType != queryMIAM)
{
tableJoins.Add(new TableJoin("INNER JOIN", tqd,
new RequestedAttribute(tqd, MIA_Management.MIA_MEDIA_ITEM_ID_COL_NAME), miaIdAttribute));
}
}
CompiledFilter compiledFilter = new CompiledFilter(_miaManagement, _filter, _subqueryFilter, ns, bvNamespace, miaIdAttribute.GetQualifiedName(ns), tableJoins);
// Build table query data for each Inline attribute which is part of a filter
// + compile query attribute
foreach (QueryAttribute attr in compiledFilter.RequiredAttributes)
{
if (attr.Attr.Cardinality != Cardinality.Inline && attr.Attr.Cardinality != Cardinality.ManyToOne)
{
continue;
}
// Tables of Inline and MTO attributes, which are part of a filter, are joined with main table
RequestedAttribute ra;
RequestSimpleAttribute(attr, tableQueries, tableJoins, "LEFT OUTER JOIN", requestedAttributes,
null, miaIdAttribute, out ra);
}
TableQueryData joinTableQuery;
RequestedAttribute valueAttribute;
// Build join table for value attribute
switch (_queryAttribute.Cardinality)
{
case Cardinality.OneToMany:
joinTableQuery = new TableQueryData(_miaManagement.GetMIACollectionAttributeTableName(_queryAttribute));
tableJoins.Add(new TableJoin("LEFT OUTER JOIN", joinTableQuery,
new RequestedAttribute(joinTableQuery, MIA_Management.FOREIGN_COLL_ATTR_ID_COL_NAME),
new RequestedAttribute(miaTableQuery, MIA_Management.MIA_MEDIA_ITEM_ID_COL_NAME)));
valueAttribute = new RequestedAttribute(joinTableQuery, MIA_Management.COLL_ATTR_VALUE_COL_NAME);
break;
case Cardinality.ManyToMany:
joinTableQuery = new TableQueryData(_miaManagement.GetMIACollectionAttributeNMTableName(_queryAttribute));
tableJoins.Add(new TableJoin("LEFT OUTER JOIN", joinTableQuery,
new RequestedAttribute(joinTableQuery, MIA_Management.MIA_MEDIA_ITEM_ID_COL_NAME),
new RequestedAttribute(miaTableQuery, MIA_Management.MIA_MEDIA_ITEM_ID_COL_NAME)));
TableQueryData collAttrTableQuery = new TableQueryData(_miaManagement.GetMIACollectionAttributeTableName(_queryAttribute));
tableJoins.Add(new TableJoin("LEFT OUTER JOIN", collAttrTableQuery,
new RequestedAttribute(joinTableQuery, MIA_Management.FOREIGN_COLL_ATTR_ID_COL_NAME),
new RequestedAttribute(collAttrTableQuery, MIA_Management.FOREIGN_COLL_ATTR_ID_COL_NAME)));
valueAttribute = new RequestedAttribute(collAttrTableQuery, MIA_Management.COLL_ATTR_VALUE_COL_NAME);
break;
default:
throw new IllegalCallException("Media item aspect attributes of cardinality '{0}' cannot be requested via the {1}",
_queryAttribute.Cardinality, GetType().Name);
}
// Selected attributes
string valueDeclaration = _selectProjectionFunction == null?
valueAttribute.GetDeclarationWithAlias(ns, out valueAlias) :
valueAttribute.GetDeclarationWithAlias(ns, _selectProjectionFunction, out valueAlias);
groupSizeAlias = "C";
StringBuilder result = new StringBuilder("SELECT COUNT(V.ID) ");
result.Append(groupSizeAlias);
result.Append(", V.");
result.Append(valueAlias);
result.Append(" FROM (");
result.Append("SELECT DISTINCT ");
result.Append(miaIdAttribute.GetQualifiedName(ns));
result.Append(" ID, ");
result.Append(valueDeclaration);
string whereStr = compiledFilter.CreateSqlFilterCondition(ns, requestedAttributes, out bindVars);
result.Append(" FROM ");
// Always request the mia table
result.Append(miaTableQuery.GetDeclarationWithAlias(ns));
result.Append(' ');
// Other joined tables
foreach (TableJoin tableJoin in tableJoins)
{
result.Append(tableJoin.GetJoinDeclaration(ns));
result.Append(' ');
}
if (!string.IsNullOrEmpty(whereStr) || queryAttributeFilter != null)
{
result.Append("WHERE ");
IList <string> filters = new List <string>(2);
if (!string.IsNullOrEmpty(whereStr))
{
filters.Add(whereStr);
}
if (queryAttributeFilter != null)
{
IList <object> resultParts = new List <object>();
CompiledFilter.BuildAttributeFilterExpression(queryAttributeFilter, valueAttribute.GetQualifiedName(ns), bvNamespace,
resultParts, bindVars);
string filterStr = CompiledFilter.CreateSimpleSqlFilterCondition(ns, resultParts, requestedAttributes);
filters.Add(filterStr);
}
result.Append(StringUtils.Join(" AND ", filters));
}
result.Append(") V GROUP BY V.");
result.Append(valueAlias);
statementStr = result.ToString();
}
protected override void DoSerializeValue(object value, bool forceSimpleValue, XmlWriter writer)
{
MediaItemAspectMetadata miam = (MediaItemAspectMetadata)value;
miam.Serialize(writer);
}
public void AddMediaItemAspectStorage(MediaItemAspectMetadata miam)
{
throw new NotImplementedException();
}
public InFilter(MediaItemAspectMetadata.AttributeSpecification attributeType,
IEnumerable<object> values) : base(attributeType)
{
_values = new List<object>(values);
}
protected AbstractAttributeFilter(MediaItemAspectMetadata.AttributeSpecification attributeType)
{
_attributeType = attributeType;
}
const string PROPERTY_CREATION_TEMPLATE_CONTROL = "{0} = new SProperty(typeof({1}));"; // Strong references allowed for Controls, but not for models
#endregion
/// <summary>
/// Creates a class that exposes <see cref="MediaItemAspectMetadata.AttributeSpecification"/> as properties that can be used from xaml.
/// This helper can create different class styles, depending on <paramref name="createAsControl"/>:
/// <para>
/// <c>false</c>: Create a standalone class using WProperty as property type (for models)
/// <c>true</c>: Create a class that derives from Control using SProperty as property type. This class can be used as custom control.
/// </para>
/// </summary>
/// <param name="aspectType">MediaAspect type.</param>
/// <param name="classNamespace">Namespace of generated class.</param>
/// <param name="createAsControl">Create a control (see remarks on class).</param>
/// <param name="exposeNullable">Internal value types are exposed as C# Nullable.</param>
/// <returns>Source code of created class.</returns>
public string BuildCodeTemplate(Type aspectType, string classNamespace, bool createAsControl, bool exposeNullable)
{
MediaItemAspectMetadata metadata = GetMetadata(aspectType);
_createAsControl = createAsControl;
_exposeNullable = exposeNullable;
string baseClass = _createAsControl ? ": Control" : "";
string aspectName = aspectType.Name;
IDictionary <string, MediaItemAspectMetadata.AttributeSpecification> attributeSpecifications = metadata.AttributeSpecifications;
foreach (KeyValuePair <string, MediaItemAspectMetadata.AttributeSpecification> attributeSpecification in attributeSpecifications)
{
MediaItemAspectMetadata.AttributeSpecification spec = attributeSpecification.Value;
string attrName = attributeSpecification.Key;
Type attrType = spec.AttributeType;
CreateProperty(attrName, attrType, spec.IsCollectionAttribute);
}
#region Copyright
// Copyright
_copyright.Add(@"/*
Copyright (C) 2007-2014 Team MediaPortal
http://www.team-mediaportal.com
This file is part of MediaPortal 2
MediaPortal 2 is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
MediaPortal 2 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with MediaPortal 2. If not, see <http://www.gnu.org/licenses/>.
*/");
#endregion
#region Headers
// Usings
_usings.Add("using System;");
_usings.Add("using System.Collections.Generic;");
_usings.Add("using MediaPortal.Common.General;");
_usings.Add("using MediaPortal.Common.MediaManagement;");
_usings.Add("using MediaPortal.Common.MediaManagement.DefaultItemAspects;");
if (_createAsControl)
{
_usings.Add("using MediaPortal.UI.SkinEngine.Controls.Visuals;");
}
// Constants
_consts.Add("public static readonly ICollection<string> EMPTY_STRING_COLLECTION = new List<string>().AsReadOnly();");
// Common properties
CreateProperty("MediaItem", typeof(MediaItem));
_propertyCreation.Add("_mediaItemProperty.Attach(MediaItemChanged);");
#endregion
// Construct source file
StringBuilder result = new StringBuilder();
AppendRegion(result, "Copyright (C) 2007-2014 Team MediaPortal", _copyright, false);
AppendRegion(result, null, _usings, false);
result.AppendLine();
result.AppendLine();
result.AppendFormat("namespace {0}\r\n{{\r\n", classNamespace); // Begin of namespace
result.AppendLine("/// <summary>");
result.AppendFormat("/// {0}Wrapper wraps the contents of <see cref=\"{0}\"/> into properties that can be bound from xaml controls.\r\n", aspectName);
result.AppendLine("/// Note: this code was automatically created by the MediaItemAspectModelBuilder helper tool under Resources folder.");
result.AppendLine("/// </summary>"); // Begin of class
result.AppendFormat("public class {0}Wrapper{1}\r\n{{\r\n", aspectName, baseClass); // Begin of class
AppendRegion(result, "Constants", _consts, false);
AppendRegion(result, "Fields", _fields, false);
AppendRegion(result, "Properties", _properties);
List <string> ctors = new List <string> {
string.Format("public {0}Wrapper()\r\n{{\r\n {1}\r\n}}", aspectName, string.Join("\r\n ", _propertyCreation.ToArray()))
};
AppendRegion(result, "Constructor", ctors);
_members.Add(@"private void MediaItemChanged(AbstractProperty property, object oldvalue)
{
Init(MediaItem);
}");
CreateMembers(aspectType, _members);
AppendRegion(result, "Members", _members);
result.AppendLine("}"); // End of class
result.AppendLine("\r\n}"); // End of namespace
return(result.ToString());
}
