public void GetUnit()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor propertyPourcentage = beanDefinition.Properties["Pourcentage"];
Assert.AreEqual(FormatterPercent.UnitPercentage, propertyPourcentage.Unit);
}
public void ConvertFromStringFormatteur()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor propertyDate = beanDefinition.Properties["Date"];
propertyDate.ConvertFromString("02/01/2007");
}
public void ConvertFromStringBadType()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor primaryKey = beanDefinition.PrimaryKey;
primaryKey.ConvertFromString("aaa");
}
public void IsReadonly()
{
BeanDefinition definition = BeanDescriptor.GetDefinition(new object());
ICollection <BeanPropertyDescriptor> coll = definition.Properties;
Assert.IsTrue(coll.IsReadOnly);
}
/// <summary>
/// Retourne si la collection contient l'élément.
/// </summary>
/// <param name="collection">Collection a traiter.</param>
/// <param name="pkValue">Valeur de la clef primaire.</param>
/// <returns>True si l'objet est inclus, False sinon.</returns>
/// <remarks>Utilisé dans Kinetix.WebControls.</remarks>
public static bool Contains(ICollection collection, object pkValue)
{
if (collection == null)
{
throw new ArgumentNullException("collection");
}
if (pkValue == null)
{
throw new ArgumentNullException("pkValue");
}
BeanDefinition definition = BeanDescriptor.GetCollectionDefinition(collection);
if (definition.PrimaryKey == null)
{
throw new NotSupportedException();
}
IEnumerator enumerator = collection.GetEnumerator();
while (enumerator.MoveNext())
{
object tmp = enumerator.Current;
if (pkValue.Equals(definition.PrimaryKey.GetValue(tmp)))
{
return(true);
}
}
return(false);
}
public void CheckValueTypeBadType()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor primaryKey = beanDefinition.PrimaryKey;
primaryKey.CheckValueType(String.Empty);
}
public void GetCollectionUnit()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor property = beanDefinition.Properties["RoleList"];
Assert.IsNull(property.Unit);
}
public void GetObjectUnit()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor property = beanDefinition.Properties["Child"];
Assert.IsNull(property.Unit);
}
public void ValidConstraintsError()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor property = beanDefinition.Properties["Libelle"];
property.ValidConstraints("0123456789012345678901234567890123456789", null);
}
public void CheckValueTypeUnsupportedGenericType()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor primaryKey = beanDefinition.PrimaryKey;
primaryKey.CheckValueType(new Generic <Bean>());
}
public void Clear()
{
BeanDefinition definition = BeanDescriptor.GetDefinition(new object());
ICollection <BeanPropertyDescriptor> coll = definition.Properties;
coll.Clear();
}
/// <summary>
/// Prend en charge l'alimentation de la classe pour les valeurs d'initialisation.
/// </summary>
/// <param name="classe">Classe concernée.</param>
/// <param name="item">Bean d'initialisation.</param>
protected void HandleCorrectInit(ModelClass classe, TableInit item)
{
if (!DictionaryItemInit.ContainsKey(classe))
{
DictionaryItemInit.Add(classe, item);
}
foreach (ItemInit itemInit in item.ItemInitList)
{
BeanDefinition definition = BeanDescriptor.GetDefinition(itemInit.Bean);
BeanPropertyDescriptor propertyDescriptor = GetReferenceKeyDescriptor(classe, definition);
object propertyValue = propertyDescriptor.GetValue(itemInit.Bean);
if (propertyDescriptor.PrimitiveType == typeof(string))
{
propertyValue = "\"" + propertyValue + "\"";
}
BeanPropertyDescriptor libelleDescriptor = GetLibelleDescriptor(classe, definition);
string libelle = null;
if (libelleDescriptor != null)
{
libelle = (string)libelleDescriptor.GetValue(itemInit.Bean);
}
else
{
libelle = itemInit.VarName;
}
classe.ConstValues.Add(itemInit.VarName, new StaticListElement()
{
Code = propertyValue, Libelle = libelle, CodeType = propertyDescriptor.PrimitiveType.ToString()
});
}
}
public void GetDefinitionPrimaryKey()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
Assert.IsNotNull(beanDefinition.PrimaryKey);
Assert.AreEqual("Id", beanDefinition.PrimaryKey.PropertyName);
}
public void GetDefinitionDynamic()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new BeanDynamic());
BeanPropertyDescriptorCollection coll = beanDefinition.Properties;
bool idOk = false;
bool otherIdOk = false;
foreach (BeanPropertyDescriptor prop in coll)
{
if ("Id".Equals(prop.PropertyName))
{
Assert.AreEqual("IDENTIFIANT", prop.DomainName);
Assert.AreEqual("BEA_ID", prop.MemberName);
Assert.IsTrue(prop.IsRequired);
idOk = true;
}
else if ("OtherId".Equals(prop.PropertyName))
{
Assert.AreEqual("IDENTIFIANT", prop.DomainName);
Assert.AreEqual("OTH_ID", prop.MemberName);
Assert.IsFalse(prop.IsRequired);
otherIdOk = true;
}
}
Assert.IsTrue(idOk);
Assert.IsTrue(otherIdOk);
}
public void GetDefinitionUnsupportedType()
{
BeanDefinition definition = BeanDescriptor.GetDefinition(new BeanInvalidUnsupportedType());
BeanPropertyDescriptor property = definition.Properties["OtherId"];
property.ValidConstraints(3, null);
}
public string GetReferenceValueByPrimaryKey(Type referenceType, object primaryKey, object dataSource, string defaultPropertyName = null)
{
BeanDefinition definition = BeanDescriptor.GetDefinition(referenceType);
BeanPropertyDescriptor primaryKeyProperty = definition.PrimaryKey;
BeanPropertyDescriptor valueProperty = string.IsNullOrEmpty(defaultPropertyName) ? definition.DefaultProperty : definition.Properties[defaultPropertyName];
ICollection dataSourceColl = (ICollection)dataSource;
if (dataSourceColl == null)
{
throw new NotSupportedException("DataSource must be an ICollection.");
}
object candidate = null;
foreach (object item in dataSourceColl)
{
if (primaryKeyProperty.GetValue(item).Equals(primaryKey))
{
candidate = item;
break;
}
}
if (candidate == null)
{
throw new NotSupportedException("The datasource does not contain an object with this primary key.");
}
return(valueProperty.ConvertToString(valueProperty.GetValue(candidate)));
}
/// <summary>
/// Prépare les colonnes à charger dans le cas de colonnes traduites, pour une propriété.
/// </summary>
/// <param name="commandText">Texte de commande.</param>
/// <param name="definition">Définition de l'objet à charger.</param>
/// <param name="property">Propriété à charger.</param>
private void PrepareTranslationColumn(StringBuilder commandText, BeanDefinition definition, BeanPropertyDescriptor property)
{
string refName = "ref" + property.PropertyName;
string langue = refName + "." + "LAN_CODE";
string valeur = refName + "." + "TDR_VALEUR";
string cultureUI = CultureInfo.CurrentUICulture.TwoLetterISOLanguageName.ToUpperInvariant();
IDictionary <string, string> valuesMap = new Dictionary <string, string>();
valuesMap.Add("'" + cultureUI + "'", valeur);
string caseWhenCondition = GetCaseWhen(langue, valuesMap, "'[' + " + langue + " + '] ' + " + valeur, null);
commandText.Append(GetIsNullSqlString(caseWhenCondition, "tab." + property.MemberName, property.MemberName));
commandText.Append(", ");
valuesMap.Clear();
valuesMap.Add("'" + cultureUI + "'", "1");
if (!valuesMap.ContainsKey("'EN'"))
{
valuesMap.Add("'EN'", "2");
}
IEnumerable <string> partitionList = new List <string>()
{
"tab." + definition.PrimaryKey.MemberName
};
IEnumerable <string> orderList = new List <string>()
{
langue
};
caseWhenCondition = GetCaseWhen(langue, valuesMap, GetRankOverPartitionSqlString(partitionList, orderList, null) + " + 2", "rg" + property.PropertyName);
commandText.Append(caseWhenCondition);
}
public void ConvertToStringFormatteur()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor propertyDate = beanDefinition.Properties["Date"];
propertyDate.ConvertToString(DateTime.Now);
}
public void Item()
{
BeanDefinition definition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor primaryKey = definition.PrimaryKey;
Assert.AreEqual(primaryKey, definition.Properties[primaryKey.PropertyName]);
}
/// <summary>
/// Applique le tri et le filtrage à la liste.
/// </summary>
/// <typeparam name="TSource">Type source.</typeparam>
/// <param name="list">Liste source.</param>
/// <returns>Liste triée.</returns>
public ICollection <TSource> Apply <TSource>(ICollection <TSource> list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (_sortList.Count != 1)
{
throw new NotImplementedException();
}
if (this.InlineCount)
{
QueryContext.InlineCount = list.Count;
}
string sortColumn = _sortList[0];
SortOrder sortOrder = _mapSort[sortColumn];
BeanDefinition beanDef = BeanDescriptor.GetDefinition(typeof(TSource));
BeanPropertyDescriptor propertyDescriptor = beanDef.Properties[FirstToUpper(sortColumn)];
if (sortOrder == SortOrder.Asc)
{
list = list.OrderBy(x => propertyDescriptor.GetValue(x)).ToList();
}
else
{
list = list.OrderByDescending(x => propertyDescriptor.GetValue(x)).ToList();
}
// If this.Limit == 0 we disable pagination.
return(list.Skip(this.Offset).Take(this.Limit > 0 ? this.Limit : list.Count).ToList());
}
public void Count()
{
BeanDefinition definition = BeanDescriptor.GetDefinition(new object());
ICollection <BeanPropertyDescriptor> coll = definition.Properties;
Assert.AreEqual(0, coll.Count);
}
public void Remove()
{
BeanDefinition definition = BeanDescriptor.GetDefinition(new object());
ICollection <BeanPropertyDescriptor> coll = definition.Properties;
coll.Remove(null);
}
/// <summary>
/// Ajoute comme nouveaux paramètres toutes les propriétés publiques primitives du bean considéré.
/// Le nom du paramètre correspond au nom de la propriété.
/// </summary>
/// <param name="bean">Le bean en question.</param>
/// <returns>La liste des paramètres ajoutés.</returns>
/// <exception cref="System.NotSupportedException">Si le bean contient une propriété non primitive.</exception>
public ICollection <SqlServerParameter> AddBeanProperties(object bean)
{
if (bean == null)
{
throw new ArgumentNullException("bean");
}
ICollection <SqlServerParameter> parameterList = new List <SqlServerParameter>();
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(bean);
foreach (BeanPropertyDescriptor property in
beanDefinition.Properties.Where(property => property.PropertyType != typeof(ChangeAction)))
{
if (property.PrimitiveType == null)
{
continue;
}
if (property.PrimitiveType.Name == "ICollection`1")
{
continue;
}
string parameterName = property.MemberName ?? property.PropertyName;
SqlServerParameter parameter = AddWithValue(parameterName, property.GetValue(bean, true));
parameterList.Add(parameter);
}
return(parameterList);
}
public void GetDefinitionContract()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
Assert.IsNotNull(beanDefinition.ContractName);
Assert.AreEqual("BEAN", beanDefinition.ContractName);
}
/// <summary>
/// Crée un dictionnaire { nom de la propriété => valeur } pour un item à insérer.
/// </summary>
/// <param name="modelClass">Modele de la classe.</param>
/// <param name="initItem">Item a insérer.</param>
/// <param name="isPrimaryKeyIncluded">True si le script d'insert doit comporter la clef primaire.</param>
/// <returns>Dictionnaire contenant { nom de la propriété => valeur }.</returns>
protected override Dictionary <string, string> CreatePropertyValueDictionary(ModelClass modelClass, ItemInit initItem, bool isPrimaryKeyIncluded)
{
Dictionary <string, string> nameValueDict = new Dictionary <string, string>();
BeanDefinition definition = BeanDescriptor.GetDefinition(initItem.Bean);
foreach (ModelProperty property in modelClass.PersistentPropertyList)
{
if (!property.DataDescription.IsPrimaryKey || isPrimaryKeyIncluded)
{
BeanPropertyDescriptor propertyDescriptor = definition.Properties[property.Name];
object propertyValue = propertyDescriptor.GetValue(initItem.Bean);
string propertyValueStr = propertyValue == null ? string.Empty : propertyValue.ToString();
if (property.DataType == "byte[]")
{
nameValueDict[property.DataMember.Name] = GetBulkColumn(propertyValueStr);
}
else if (propertyDescriptor.PrimitiveType == typeof(string))
{
nameValueDict[property.DataMember.Name] = "'" + propertyValueStr.Replace("'", "''") + "'";
}
else
{
nameValueDict[property.DataMember.Name] = propertyValueStr;
}
}
}
return(nameValueDict);
}
/// <summary>
/// Retourne la valeur d'une liste de référence à partir
/// de son identifiant.
/// </summary>
/// <param name="referenceType">Type de la liste de référence.</param>
/// <param name="primaryKey">Identifiant de la liste de référence.</param>
/// <param name="defaultPropertyName">Nom de la propriété par défaut à utiliser. Null pour utiliser la valeur définie au niveau de l'objet.</param>
/// <returns>Libellé de la liste de référence.</returns>
public string GetReferenceValueByPrimaryKey(Type referenceType, object primaryKey, string defaultPropertyName = null)
{
object reference = GetReferenceObjectByPrimaryKey(referenceType, primaryKey);
BeanDefinition definition = BeanDescriptor.GetDefinition(reference);
BeanPropertyDescriptor property = string.IsNullOrEmpty(defaultPropertyName) ? definition.DefaultProperty : definition.Properties[defaultPropertyName];
return(property.ConvertToString(property.GetValue(reference)));
}
public void ValidConstraints()
{
Bean b = new Bean();
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(b);
BeanPropertyDescriptor primaryKey = beanDefinition.PrimaryKey;
primaryKey.ValidConstraints(2, null);
}
public void ConvertFromString()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor primaryKey = beanDefinition.PrimaryKey;
object o = primaryKey.ConvertFromString("3");
Assert.AreEqual(3, o);
}
public void SetValueBadType()
{
Bean b = new Bean();
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(b);
BeanPropertyDescriptor primaryKey = beanDefinition.PrimaryKey;
primaryKey.SetValue(b, "test");
}
public void ConvertToString()
{
BeanDefinition beanDefinition = BeanDescriptor.GetDefinition(new Bean());
BeanPropertyDescriptor primaryKey = beanDefinition.PrimaryKey;
string text = primaryKey.ConvertToString(3);
Assert.AreEqual("3", text);
}
