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);
}
/// <summary>
/// Crée un nouveau reader.
/// </summary>
/// <param name="list">Liste interne.</param>
internal TestDbDataReader(IList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
_list = list;
_descriptorMap = BeanDescriptor.GetCollectionDefinition(list).Properties;
_descriptors = new List <BeanPropertyDescriptor>(_descriptorMap);
}
/// <summary>
/// Ajoute les paramètres de la requête select (noms des colonnes, clauses from, where et order by).
/// </summary>
/// <param name="commandText">Requête SQL à laquelle seront ajoutés les paramètres.</param>
/// <param name="tableName">Nom de la table.</param>
/// <param name="criteria">Critère de recherche.</param>
/// <param name="sortOrder">Ordre de tri.</param>
/// <param name="command">Commande d'appel à la base de données.</param>
protected void AppendSelectParameters(StringBuilder commandText, string tableName, FilterCriteria criteria, string sortOrder, SqlServerCommand command)
{
if (commandText == null)
{
throw new ArgumentNullException("commandText");
}
BeanPropertyDescriptorCollection properties = BeanDescriptor.GetDefinition(typeof(T)).Properties;
bool hasColumn = false;
foreach (BeanPropertyDescriptor property in properties)
{
if (string.IsNullOrEmpty(property.MemberName))
{
continue;
}
if (property.PropertyType == typeof(byte[]))
{
continue;
}
if (hasColumn)
{
commandText.Append(", ");
}
commandText.Append(property.MemberName);
hasColumn = true;
}
commandText.Append(" from ").Append(tableName);
PrepareFilterCriteria(criteria, command, commandText);
// Ajout du Order By si non-nul
if (!string.IsNullOrEmpty(sortOrder))
{
commandText.Append(" order by ");
commandText.Append(sortOrder);
}
}
public RuleContext(object obj, RuleConstants constants)
{
context = new Dictionary <string, string>();
BeanDefinition definition = BeanDescriptor.GetDefinition(obj.GetType());
BeanPropertyDescriptorCollection properties = definition.Properties;
foreach (BeanPropertyDescriptor bean in properties)
{
context[bean.PropertyName] = bean.GetValue(obj).ToString();
}
if (constants != null)
{
foreach (KeyValuePair <string, string> keyValue in constants.GetValues())
{
context.Add(keyValue);
}
}
}
/// <summary>
/// Renvoie à partir d'une collection de bean un dictionnaire associant à une position de colonne dans le fichier plat la propriété correspondante du bean.
/// </summary>
/// <param name="dataSource">Collection de bean.</param>
/// <returns>Dictionnaire des colonnes de fichiers plat indéxées par leur position.</returns>
private static IDictionary <int, EncodingFlatFile> BuildSortedDictionnary(IEnumerable dataSource)
{
BeanDefinition beanDefinition = BeanDescriptor.GetCollectionDefinition(dataSource);
BeanPropertyDescriptorCollection properties = beanDefinition.Properties;
IDictionary <int, EncodingFlatFile> propertyMapSortedByPosition = new SortedDictionary <int, EncodingFlatFile>(Comparer <int> .Default);
foreach (BeanPropertyDescriptor property in properties)
{
PropertyInfo basePropertyInfo = beanDefinition.BeanType.GetProperty(property.PropertyName);
object[] attrs = basePropertyInfo.GetCustomAttributes(typeof(FlatFileField), false);
if (attrs != null && attrs.Length > 0)
{
EncodingFlatFile encodingFlatFile = new EncodingFlatFile {
Property = property,
Attr = (FlatFileField)attrs[0]
};
propertyMapSortedByPosition.Add(encodingFlatFile.Attr.Position, encodingFlatFile);
}
}
if (propertyMapSortedByPosition.Count == 0)
{
throw new NotSupportedException("No exportable properties");
}
if (propertyMapSortedByPosition.Keys.Min() != 0)
{
throw new NotSupportedException("The position must start at 0");
}
if ((propertyMapSortedByPosition.Keys.Max() - propertyMapSortedByPosition.Keys.Min() + 1) != propertyMapSortedByPosition.Keys.Count)
{
throw new NotSupportedException("Inconsistency between the total number of exportable properties and the min and max position, there is some hole in your positions");
}
return(propertyMapSortedByPosition);
}
/// <summary>
/// Création d'un document CSV à partir d'une collection et de ses colonnes à exporter.
/// </summary>
/// <param name="colonnes">Colonnes à exporter.</param>
/// <param name="dataSourceList">Liste des données à exporter.</param>
/// <param name="headers">Liste des headers(si null alors on utilise les colonnes).</param>
/// <param name="showHeader">Affiche ou pas un header.</param>
/// <returns>Fichier binaire.</returns>
private static byte[] CreateCsvFile(IList <string> colonnes, object dataSourceList, IList <string> headers, bool showHeader = true)
{
if (dataSourceList == null)
{
throw new ArgumentNullException("dataSourceList");
}
if (colonnes == null)
{
throw new ArgumentNullException("colonnes");
}
StringBuilder sb = new StringBuilder();
BeanDefinition beanDefinition = BeanDescriptor.GetCollectionDefinition(dataSourceList);
BeanPropertyDescriptorCollection properties = beanDefinition.Properties;
if (showHeader)
{
bool first = true;
if (headers == null)
{
foreach (string colonne in colonnes)
{
BeanPropertyDescriptor descriptor = properties[colonne];
if (!first)
{
sb.Append(';');
}
sb.Append(descriptor.Description);
first = false;
}
}
else
{
if (headers.Count != colonnes.Count)
{
throw new ArgumentException("colonnes et headers n'ont pas la même taille");
}
foreach (string header in headers)
{
if (!first)
{
sb.Append(';');
}
sb.Append(header);
first = false;
}
}
sb.Append("\r\n");
}
foreach (object valeur in (ICollection)dataSourceList)
{
bool first = true;
foreach (string colonne in colonnes)
{
BeanPropertyDescriptor descriptor = properties[colonne];
if (!first)
{
sb.Append(';');
}
sb.Append(descriptor.GetValue(valeur));
first = false;
}
sb.Append("\r\n");
}
return(Encoding.Default.GetBytes(sb.ToString()));
}
/// <summary>
/// Execute une commande et retourne un reader.
/// </summary>
/// <param name="commandName">Nom de la commande.</param>
/// <param name="tableName">Nom de la table.</param>
/// <param name="criteria">Critère de recherche.</param>
/// <param name="maxRows">Nombre maximum d'enregistrements (BrokerManager.NoLimit = pas de limite).</param>
/// <param name="queryParameter">Paramètre de la requête.</param>
/// <returns>DataReader contenant le résultat de la commande.</returns>
protected override IReadCommand GetCommand(string commandName, string tableName, FilterCriteria criteria, int maxRows, QueryParameter queryParameter)
{
SqlServerCommand command = new SqlServerCommand(this.DataSourceName, commandName, CommandType.Text);
StringBuilder commandText = new StringBuilder("select ");
if (maxRows != BrokerManager.NoLimit)
{
commandText.Append("top(@top) ");
command.Parameters.AddWithValue("top", maxRows);
}
string order = null;
if (queryParameter != null && !string.IsNullOrEmpty(queryParameter.SortCondition))
{
order = queryParameter.SortCondition;
}
BeanDefinition definition = BeanDescriptor.GetDefinition(typeof(T));
BeanPropertyDescriptorCollection properties = definition.Properties;
bool hasColumn = false;
bool checkLanguage = false;
// Rank sur les langues trouvées.
var propTranslatableList = properties.Where(x => x.IsTranslatable);
if (propTranslatableList.Any())
{
checkLanguage = true;
commandText.Append(" * from (select *,");
IEnumerable <string> partitionList = new List <string>()
{
"temp." + definition.PrimaryKey.MemberName
};
ICollection <string> orderList = new List <string>();
foreach (BeanPropertyDescriptor property in propTranslatableList)
{
orderList.Add("rg" + property.PropertyName);
}
commandText.Append(GetRankOverPartitionSqlString(partitionList, orderList, "r"));
commandText.Append(" from (Select ");
}
hasColumn = false;
foreach (BeanPropertyDescriptor property in properties)
{
if (!IsPropertyToRetrieve(property))
{
continue;
}
if (hasColumn)
{
commandText.Append(", ");
}
if (property.IsTranslatable)
{
PrepareTranslationColumn(commandText, definition, property);
}
else
{
commandText.Append("tab.").Append(property.MemberName);
}
hasColumn = true;
}
commandText.Append(" from ").Append(tableName).Append(" tab ");
IDictionary <string, FilterCriteriaParam> criteriaMap = new Dictionary <string, FilterCriteriaParam>();
foreach (FilterCriteriaParam param in criteria.Parameters)
{
if (!criteriaMap.ContainsKey(param.ColumnName))
{
criteriaMap.Add(param.ColumnName, param);
}
}
IDictionary <string, string> propertyNameMap = new Dictionary <string, string>();
foreach (BeanPropertyDescriptor property in properties)
{
if (!IsPropertyToRetrieve(property))
{
continue;
}
if (property.IsTranslatable)
{
if (!propertyNameMap.ContainsKey(property.MemberName))
{
propertyNameMap.Add(property.MemberName, property.PropertyName);
}
string refTableName = definition.BeanType.FullName + "_." + property.PropertyName;
commandText.Append(" left join TRADUCTION_REFERENCE").Append(" ref").Append(property.PropertyName);
commandText.Append(" on ref").Append(property.PropertyName).Append(".").Append("TDR_TABLE").Append(" = '").Append(refTableName);
commandText.Append("' and ref").Append(property.PropertyName).Append(".").Append("TDR_CODE").Append(" = ").Append("tab.").Append(definition.PrimaryKey.MemberName);
}
}
PrepareFilterCriteria(criteria, command, commandText);
if (checkLanguage)
{
commandText.Append(" ) temp ) t where r = 1");
}
// Ajout du Order By si non-nul
if (order != null)
{
commandText.Append(" order by ");
commandText.Append(order);
}
// Set de la requête
command.CommandText = commandText.ToString();
return(command);
}
/// <summary>
/// Retourne l'instruction d'update de l'item dans la calsse ModelClass.
/// </summary>
/// <param name="modelClass">Table.</param>
/// <param name="initItem">Item.</param>
/// <returns>Nombre de lignes mises à jour.</returns>
private static string GetUpdateLine(ModelClass modelClass, ItemInit initItem)
{
StringBuilder sb = new StringBuilder();
sb.Append("UPDATE " + modelClass.DataContract.Name + " SET ");
BeanDefinition definition = BeanDescriptor.GetDefinition(initItem.Bean);
int persistentPropertyCount = definition.Properties.Count;
int idx = 0;
BeanPropertyDescriptorCollection propertyList = definition.Properties;
ModelProperty key = null;
foreach (ModelProperty property in modelClass.PersistentPropertyList)
{
if (propertyList.Contains(property.Name))
{
++idx;
if (property.DataDescription.IsPrimaryKey ||
(key == null && property.IsUnique))
{
key = property;
}
else
{
sb.Append(property.DataMember.Name);
sb.Append(" = ");
object propertyValue = propertyList[property.Name].GetValue(initItem.Bean);
string propertyValueStr = propertyValue == null ? string.Empty : propertyValue.ToString();
if (property.DataType == "byte[]")
{
sb.Append(GetBulkColumn(propertyValueStr));
}
else if (propertyList[property.Name].PrimitiveType == typeof(string))
{
sb.Append("'" + propertyValueStr.Replace("'", "''") + "'");
}
else
{
sb.Append(propertyValueStr);
}
if (idx < persistentPropertyCount)
{
sb.Append(", ");
}
}
}
}
sb.Append(" WHERE ");
sb.Append(key.DataMember.Name);
sb.Append(" = ");
if (propertyList[key.Name].PrimitiveType == typeof(string))
{
sb.Append("'" + propertyList[key.Name].GetValue(initItem.Bean).ToString().Replace("'", "''") + "'");
}
else
{
sb.Append(propertyList[key.Name].GetValue(initItem.Bean).ToString());
}
sb.Append(";");
return(sb.ToString());
}
