/// <summary>
/// Fügt der Tabelle der diese Spalte zugeordnet ist eine weitere Spalte hinzu, die für jede Zeile den Wert ausgibt,
/// der sich aus der festgelegten Expression
/// ergibt.
/// </summary>
/// <typeparam name="TColumn">
/// Typ der Eigenschaft des <see cref="TGrid">Zeilen-Models</see>, welches in der Spalte
/// angezeigt wird.
/// </typeparam>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TGrid"></typeparam>
/// <param name="column"></param>
/// <param name="expression">Expression über die für jede Zeile der anzuzeigende Wert ermittelt wird.</param>
/// <param name="title">Titel der Spalte, der im Tabellenkopf angezeigt werden soll.</param>
/// <returns>Die Spalte.</returns>
public static GridColumn <TModel, TGrid, TColumn> ColumnFor <TModel, TGrid, TColumn>(this IGridColumn <TModel, TGrid> column,
Expression <Func <TGrid, TColumn> > expression)
{
string labelByresource = LabelHelper.GetLabelFromResourceByPropertyName <Resources_Domain>(typeof(TGrid), expression.ToString().Split('.').Last());
return(column.Grid.ColumnFor(expression, labelByresource));
}
public static string GetLabel(ModelMetadata modelMetaData, string label)
{
if (label != null)
{
/*Das Label wurde als Parameter übergeben => den Parameter verwenden*/
return(label);
}
else
{
if (!string.IsNullOrEmpty(modelMetaData.DisplayName))
{
/*Es wurde ein Display- bzw. ein DisplayNameAttribute am Property definiert*/
return(modelMetaData.DisplayName);
}
else
{
/*Label wird über die per Konvention definierte Resource versucht zu laden.*/
if (!string.IsNullOrWhiteSpace(modelMetaData.PropertyName))
{
return(LabelHelper.GetLabelFromResourceByPropertyName <Resources_Domain>(modelMetaData.ContainerType, modelMetaData.PropertyName));
}
}
}
return(string.Empty);
}
/// <summary>
/// Zeigt statischen Inhalt (der Wert im Model) mit Label an.
/// Der angezeigte Wert wird nicht gebunden!
/// </summary>
/// <param name="expression"></param>
/// <param name="placeholder">Der Wert der angezeigt wird, wenn der Wert null ist.</param>
/// <param name="label"></param>
/// <param name="formatString">Optionale Angabe zur Formatierung des Inhaltes.</param>
/// <returns></returns>
public MvcHtmlString Static <TProperty>(Expression <Func <TModel, TProperty> > expression, string label = null,
string placeholder = null, string formatString = null)
{
ModelMetadata modelMetadata = ModelMetadata.FromLambdaExpression(expression, Helper.ViewData);
if (modelMetadata.PropertyName != "DisplayName")
{
label = FormControlModel.GetLabel(modelMetadata, label);
}
else
{
string reducedExpression = expression.ToString().Replace(".DisplayName", "").Split(new[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries)[1];
ModelMetadata parentModelMetadata = ModelMetadata.FromStringExpression(reducedExpression, Helper.ViewData);
label = FormControlModel.GetLabel(parentModelMetadata, label);
}
object value;
if (modelMetadata.Model != null)
{
/*Wenn die Expression auf einen Wert ungleich NULL zeigt, zeige diesen als ToString an*/
value = modelMetadata.Model;
if (modelMetadata.ModelType.IsEnum)
{
string localizedEnumValue = LabelHelper.GetLabelFromResourceByPropertyName <Resources_Domain>(modelMetadata.ModelType, value.ToString());
if (!string.IsNullOrWhiteSpace(localizedEnumValue))
{
value = localizedEnumValue;
}
}
if (!string.IsNullOrWhiteSpace(formatString))
{
/*Es ist ein Format für die Ausgabe angegeben => Formatieren!*/
value = string.Format(formatString, value);
}
}
else
{
/*Wenn die Expression auf einen Wert zeigt der NULL ist, wird der Platzhalter-Text verwendet.*/
value = placeholder;
}
StaticControlModel model = new StaticControlModel(Helper, label, value);
return(Helper.Partial("EditorTemplates/Forms/Static", model));
}
/// <summary>
/// </summary>
/// <typeparam name="TPropertyAndEnum">>Der Typ der Enum, deren Member in der Auswahlbox angezeigt werden sollen.</typeparam>
/// <param name="expression"></param>
/// <param name="placeholder">
/// Der Placeholder gibt an, welcher Wert angezeigt wird, wenn keine Auswahl getroffen ist/wurde.
/// Ist der Platzhalter null, ist der erste Wert der Box vorausgewählt.
/// Wenn der Platzhalter gesetzt ist, symbolisiert dieser den Text, der angezeigt wird, wenn null ausgewählt ist.
/// </param>
/// <param name="label"></param>
/// <returns></returns>
public MvcHtmlString Select <TPropertyAndEnum>(Expression <Func <TModel, TPropertyAndEnum> > expression, string placeholder,
string label = null) /*where TPropertyAndEnum : struct, IConvertible*/
{
if (!typeof(TPropertyAndEnum).IsEnum && !(typeof(TPropertyAndEnum).IsValueType && typeof(TPropertyAndEnum).GenericTypeArguments[0].IsEnum))
{
throw new ArgumentException("T must be an enumerated type");
}
Type baseEnumType;
if (typeof(TPropertyAndEnum).IsEnum)
{
baseEnumType = typeof(TPropertyAndEnum);
}
else
{
baseEnumType = typeof(TPropertyAndEnum).GenericTypeArguments[0];
}
Array values = Enum.GetValues(baseEnumType);
IList selectableItems = new List <dynamic>();
foreach (object value in values)
{
object item = new {
Value = value,
Text = LabelHelper.GetLabelFromResourceByPropertyName <Resources_Domain>(
baseEnumType,
value.ToString())
};
selectableItems.Add(item);
}
ModelMetadata modelMetadata = ModelMetadata.FromLambdaExpression(expression, Helper.ViewData);
DropDownModel dropDownModel = new DropDownModel(Helper,
modelMetadata,
ExpressionHelper.GetExpressionText(expression),
selectableItems,
"Value",
"Text",
label,
placeholder);
return(Helper.Partial("EditorTemplates/Forms/Select", dropDownModel));
}
private static string GetEnumMemberText(Type baseEnumType, object value)
{
if (value == null)
{
return(null);
}
if (baseEnumType == typeof(Country))
{
/*Sonderbehandlung für Country-enum*/
return(Resources_Countries.ResourceManager.GetString(value.ToString()));
}
string labelFromResourceByPropertyName = LabelHelper.GetLabelFromResourceByPropertyName <Resources_Domain>(baseEnumType, value.ToString());
if (!string.IsNullOrEmpty(labelFromResourceByPropertyName))
{
return(labelFromResourceByPropertyName);
}
return(TypeHelper.GetEnumMemberDescription((Enum)value));
}
/// <summary>
/// Rendert den Wert eines Objektes oder liefert einen Platzhalter, wenn der Wert NULL ist.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public object ValueOrDefault(object value, string placeholder = "---")
{
if (value != null)
{
if (value.GetType().IsEnum)
{
// TODO: Funktioniert das bei Nullable<enum>
string localizedEnumValue = LabelHelper.GetLabelFromResourceByPropertyName <Resources_Domain>(value.GetType(), value.ToString());
if (!string.IsNullOrWhiteSpace(localizedEnumValue))
{
value = localizedEnumValue;
}
}
return(value);
}
else
{
return(placeholder);
}
}