protected virtual string GetDeclarationChamp_TypeAndLength(CInfoChampTable champ)
{
string strType = DataBaseTypesMappeur.GetStringDBTypeFromType(champ.TypeDonnee);
if (champ.TypeDonnee == typeof(string))
{
if (champ.IsLongString || (champ.Longueur > DataBaseTypesMappeur.MaxDBStringLength && AutoAdaptLongString))
{
strType = DataBaseTypesMappeur.DBLongStringDefinition;
}
else
{
strType += "(";
if (champ.Longueur > DataBaseTypesMappeur.MaxDBStringLength)
{
strType += DataBaseTypesMappeur.MaxDBStringLength.ToString();
}
else
{
strType += champ.Longueur.ToString();
}
strType += ")";
}
}
return(strType);
}
/// <summary>
/// Supprime les dépendances (DeleteChamp_Dependances)
/// Execute la requete d'update (GetRequeteUpdateChamp)
/// Créé l'index si existant (CreateIndex)
/// </summary>
/// <param name="strNomTable"></param>
/// <param name="champ"></param>
/// <param name="bNotNull"></param>
/// <param name="bLength"></param>
/// <param name="bType"></param>
/// <param name="bRelation"></param>
/// <returns></returns>
public virtual CResultAErreur UpdateChamp(string strNomTable, CInfoChampTable champ, bool bModifiedNotNull, bool bModifiedLength, bool bModifiedType)
{
//Suppression index
CResultAErreur result = DeleteIndex(strNomTable, champ.NomChamp);
//Mise à jour du champ
if (result)
{
result = Connection.RunStatement(GetRequeteUpdateChamp(strNomTable, champ, bModifiedNotNull, bModifiedLength, bModifiedType));
}
if (result)
{
AfterChangeChamps(strNomTable);
}
//Creation de l'index
if (result && champ.IsIndex)
{
result = CreateIndex(strNomTable, false, champ.NomChamp);
}
if (!result)
{
result.EmpileErreur(I.T("Error while fields updating of table @1|131", strNomTable));
}
return(result);
}
protected virtual bool Champ_ModifiedLength(CInfoChampTable champ, DataColumn colonne)
{
if (champ.IsLongString && colonne.MaxLength < DataBaseTypesMappeur.MinDBLongStringLength)
{
return(true);
}
if (AutoAdaptLongString && colonne.MaxLength > DataBaseTypesMappeur.MaxDBStringLength)
{
return(false);
}
if (champ.Longueur > DataBaseTypesMappeur.MaxDBStringLength && !champ.IsLongString)
{
if (colonne.MaxLength != DataBaseTypesMappeur.MaxDBStringLength)
{
return(true);
}
}
else
{
if (colonne.MaxLength != champ.Longueur && champ.TypeDonnee == typeof(string) && !champ.IsLongString)
{
return(true);
}
}
return(false);
}
public virtual CResultAErreur CreateChamp(string strNomTable, CInfoChampTable champ, bool bForcerNull)
{
CResultAErreur result = CheckNomColonne(strNomTable, champ.NomChamp);
if (!result.Result)
{
return(result);
}
string strRequeteUpdate = "ALTER TABLE " + strNomTable + " ADD ";
strRequeteUpdate += GetDeclarationChamp(champ, bForcerNull);
result = Connection.RunStatement(strRequeteUpdate);
if (result)
{
AfterChangeChamps(strNomTable);
}
if (!result)
{
result.EmpileErreur(I.T("Error while fields updating of table @1|131", strNomTable));
}
else if (champ.IsIndex)
{
result = CreateIndex(strNomTable, false, champ.NomChamp);
}
return(result);
}
////////////////////////////////////////////////////
protected override string GetNomParametreFor(CInfoChampTable champ, DataRowVersion version)
{
int nNumChamp = 0;
if (m_tableChampToNumero[champ.NomChamp] == null)
{
nNumChamp = m_nNumeroVariable++;
m_tableChampToNumero[champ.NomChamp] = nNumChamp;
}
else
nNumChamp = (int)m_tableChampToNumero[champ.NomChamp];
string strNom = m_connexion.GetNomParametre("A" + nNumChamp.ToString());
switch (version)
{
case DataRowVersion.Current:
strNom += "_NEW";
break;
case DataRowVersion.Original:
strNom += "_OLD";
break;
default:
strNom += (int)version;
break;
}
return strNom;
}
////////////////////////////////////////////////////
protected override IDbDataParameter GetParametreFor(IDbCommand commande, CInfoChampTable champ, DataRowVersion version, ParameterDirection direction)
{
//DbType dbType = m_connexion.GetDbType(champ.TypeDonnee);
IDbDataParameter parametre = commande.CreateParameter();
parametre.ParameterName = GetNomParametreFor(champ, version);
if (champ.IsLongString && champ.TypeDonnee == typeof(string))
{
if (parametre is OracleParameter)
{
((OracleParameter)parametre).OracleType = OracleType.NClob;
}
}
else
{
parametre.DbType = m_connexion.GetDbType(champ.TypeDonnee);
if (champ.TypeDonnee == typeof(string))
{
parametre.Size = champ.Longueur;
}
}
parametre.Direction = direction;
parametre.SourceColumn = champ.NomChamp;
parametre.SourceVersion = version;
return(parametre);
}
////////////////////////////////////////////
private void OnChangeExpression(string strTexte, ref C2iExpression expToSet, CComboboxAutoFilled combo)
{
CContexteAnalyse2iExpression ctx = new CContexteAnalyse2iExpression(ActionSynchronisme.Process, typeof(CProcess));
CResultAErreur result = new CAnalyseurSyntaxiqueExpression(ctx).AnalyseChaine(strTexte);
if (result)
{
ArrayList lstChamps = new ArrayList();
expToSet = (C2iExpression)result.Data;
Type tp = expToSet.TypeDonnee.TypeDotNetNatif;
CStructureTable structure = null;
try
{
structure = CStructureTable.GetStructure(tp);
ArrayList lst = new ArrayList();
foreach (CInfoChampTable champ in structure.Champs)
{
if (champ.TypeDonnee == typeof(DateTime) || champ.TypeDonnee == typeof(DateTime?))
{
lst.Add(champ);
}
}
//Cherche les champs custom
if (typeof(CElementAChamp).IsAssignableFrom(tp))
{
//Crée les infos champ custom pour le type
using (CContexteDonnee contexte = new CContexteDonnee(
CSessionClient.GetSessionUnique().IdSession,
true, false))
{
string strCodeRole = CRoleChampCustom.GetRoleForType(tp).CodeRole;
CListeObjetsDonnees listeChamps = CChampCustom.GetListeChampsForRole(
contexte, strCodeRole);
new CListeObjetsDonnees(contexte, typeof(CChampCustom));
listeChamps.Filtre = new CFiltreData(
CChampCustom.c_champType + "=@1",
(int)TypeDonnee.tDate);
foreach (CChampCustom champ in listeChamps)
{
CInfoChampTable info = new CInfoChampTable(
CSynchronismeDonnees.c_idChampCustom + champ.Id.ToString(),
typeof(DateTime),
0,
false,
false,
true,
false,
true);
info.NomConvivial = champ.Nom;
lst.Add(info);
}
}
}
combo.ListDonnees = lst;
}
catch
{
}
}
}
/// <summary>
/// Retourne la déclaration d'un champ pour le créer
/// </summary>
/// <param name="champ"></param>
/// <returns></returns>
protected virtual string GetDeclarationChamp(CInfoChampTable champ, bool bForcerNull)
{
string strDeclaration = champ.NomChamp + " ";
strDeclaration += GetDeclarationChamp_TypeAndLength(champ) + " ";
strDeclaration = bForcerNull || champ.NullAuthorized? strDeclaration += "NULL": strDeclaration += GetDeclarationChamp_NotNull(champ, false);
return(strDeclaration);
}
public override CResultAErreur CreateChamp(string strNomTable, CInfoChampTable champ)
{
CResultAErreur result = base.CreateChamp(strNomTable, champ);
if (result && !champ.NullAuthorized)
{
result = SetValeursParDefautAuxDonneesNulles(strNomTable, champ);
}
return(result);
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
protected virtual bool Champ_ModifiedIndex(string strNomTable, CInfoChampTable champ)
{
bool bIndexExists = IndexExists(strNomTable, champ.NomChamp);
if (bIndexExists != champ.IsIndex && !champ.IsId)
{
return(true);
}
return(false);
}
//Champs
public override CResultAErreur CreateChamp(string strNomTable, CInfoChampTable champ)
{
CResultAErreur result = base.CreateChamp(strNomTable, champ);
if (result && champ.IsAutoId && !SystemeAutoIncrementeExist(strNomTable, champ.NomChamp))
{
result = CreerSystemeAutoIncremente(strNomTable, champ.NomChamp);
}
return(result);
}
public override CResultAErreur UpdateChamp(string strNomTable, CInfoChampTable champ, bool bModifiedNotNull, bool bModifiedLength, bool bModifiedType)
{
CResultAErreur result = base.UpdateChamp(strNomTable, champ, bModifiedNotNull, bModifiedLength, bModifiedType);
if (bModifiedNotNull && !champ.NullAuthorized)
{
result = SetValeursParDefautAuxDonneesNulles(strNomTable, champ);
}
return(result);
}
protected override IDbDataParameter GetParametreFor(IDbCommand commande, CInfoChampTable champ, DataRowVersion version, ParameterDirection direction)
{
IDbDataParameter parametre = base.GetParametreFor(commande, champ, version, direction);
if (champ.IsLongString)
{
parametre.Size = -1;
}
return(parametre);
}
////////////////////////////////////////////////////
protected override IDbDataParameter GetParametreFor(IDbCommand commande, CInfoChampTable champ, DataRowVersion version, ParameterDirection direction)
{
//DbType dbType = m_connexion.GetDbType(champ.TypeDonnee);
IDbDataParameter parametre = commande.CreateParameter();
parametre.ParameterName = GetNomParametreFor(champ, version);
parametre.DbType = m_connexion.GetDbType(champ.TypeDonnee);
if (champ.TypeDonnee == typeof(string))
parametre.Size = champ.Longueur;
parametre.Direction = direction;
parametre.SourceColumn = champ.NomChamp;
parametre.SourceVersion = version;
return parametre;
}
////////////////////////////////////////////////////
protected virtual OleDbParameter GetParametreFor(CInfoChampTable champ, DataRowVersion version, ParameterDirection direction)
{
OleDbParameter parametre = new OleDbParameter(GetNomParametreFor(champ, version), COleDbTypeConvertor.GetTypeOleDbFromType(champ.TypeDonnee));
if ((parametre.DbType == DbType.String || parametre.DbType == DbType.AnsiString) && !champ.IsLongString)
{
parametre.Size = champ.Longueur;
}
parametre.Direction = direction;
parametre.SourceColumn = champ.NomChamp;
parametre.SourceVersion = version;
return(parametre);
}
/// <summary>
/// N'appelle pas GetDeclaration Champ mais GetDeclarationChamp_TypeAndLength puis
/// GetDeclarationChamp_NotNull si le null à changé (sous oracle le redéclaration du null
/// génère une erreur, sous SQL Serveur il n'est pas nécessaire de spécifier le null si ce
/// dernier n'as pas changé)
/// </summary>
/// <param name="strNomTable"></param>
/// <param name="champ"></param>
/// <param name="bNotNull"></param>
/// <param name="bLength"></param>
/// <param name="bType"></param>
/// <returns></returns>
protected virtual string GetRequeteUpdateChamp(string strNomTable, CInfoChampTable champ, bool bModifiedNotNull, bool bModifiedLength, bool bModifiedType)
{
string strRequeteUpdate = "ALTER TABLE " + strNomTable + " ";
strRequeteUpdate += "ALTER COLUMN " + champ.NomChamp + " ";
strRequeteUpdate += GetDeclarationChamp_TypeAndLength(champ) + " ";
if (!champ.NullAuthorized)
{
strRequeteUpdate += GetDeclarationChamp_NotNull(champ, true);
}
return(strRequeteUpdate);
}
//-------------------------------------------------
public CColumnDefinitionChampDeTable(
ITableDefinition tableDefinition,
CInfoChampTable info)
: this()
{
m_tableDefinition = tableDefinition;
m_strNomChamp = info.NomChamp;
m_strNomColonne = info.NomConvivial;
if (m_strNomColonne.Trim().Length == 0)
{
m_strNomColonne = info.NomChamp;
}
m_typeDonnee = info.TypeDonnee;
}
protected virtual bool Champ_ModifiedType(CInfoChampTable champ, DataColumn colonne)
{
if (champ.IsAutoId && !IsGoodDataColumnType(colonne, typeof(Int32)))
{
return(true);
}
else if (!champ.IsAutoId && !IsGoodDataColumnType(colonne, champ.TypeDonnee))
{
return(true);
}
else
{
return(false);
}
}
protected override string GetRequeteUpdateChamp(string strNomTable, CInfoChampTable champ, bool bNotNull, bool bLength, bool bType)
{
string rqt = "ALTER TABLE " + strNomTable + " MODIFY( " + champ.NomChamp + " ";
if (bType || bLength)
{
rqt += GetDeclarationChamp_TypeAndLength(champ) + " ";
}
if (bNotNull)
{
rqt += GetDeclarationChamp_NotNull(champ, true);
}
rqt += ")";
return(rqt);
}
protected virtual string GetDeclarationChamp_NotNull(CInfoChampTable champ, bool bUpdate)
{
if (champ.IsAutoId)
{
return("NOT NULL");
}
else if (!champ.NullAuthorized && !bUpdate)
{
return(GetDeclarationDefaultValueForType(champ.TypeDonnee) + " NOT NULL");
}
else if (!champ.NullAuthorized && bUpdate)
{
return("NOT NULL ");
}
else
{
return("NULL");
}
}
////////////////////////////////////////////////////
protected virtual string GetNomParametreFor(CInfoChampTable champ, DataRowVersion version)
{
string strNom = "@" + champ.NomChamp;
switch (version)
{
case DataRowVersion.Current:
strNom += "_NEW";
break;
case DataRowVersion.Original:
strNom += "_OLD";
break;
default:
strNom += (int)version;
break;
}
return(strNom);
}
//--------------------------------------------------------------------------------------
protected override bool Champ_ModifiedIndex(string strNomTable, CInfoChampTable champ)
{
bool bModifier = base.Champ_ModifiedIndex(strNomTable, champ);
if (bModifier && !champ.IsIndex)
{
//Si le champ fait partie d'une clé externe, c'est
//Normal qu'il y a ait un index dessus
List <CInfoRelation> lstRels = new List <CInfoRelation>();
GetRelationsExistantes(strNomTable, ref lstRels);
foreach (CInfoRelation rel in lstRels)
{
if (rel.ChampsFille.Length == 1 &&
rel.ChampsFille[0] == champ.NomChamp)
{
return(false);
}
}
}
return(bModifier);
}
/// <summary>
/// retourne l'objet donné sélectionné à partir de la valeur retournée
/// </summary>
/// <remarks>
/// Ne fonctionne pas toujours, ça ne fonctionne que si la valeur retournée
/// est un champ DOTNET de l'entité sélectionnée
/// </remarks>
/// <param name="valeurRetournee"></param>
/// <param name="contexte"></param>
/// <returns></returns>
public CReferenceObjetDonnee GetObjetFromValeurRetournee(object valeurRetournee)
{
if (valeurRetournee == null)
{
return(null);
}
C2iExpressionChamp exp = ExpressionRetournee as C2iExpressionChamp;
if (exp != null)
{
CDefinitionProprieteDynamique propDyn = exp.DefinitionPropriete;
CDefinitionProprieteDynamiqueDotNet defDotNet = propDyn as CDefinitionProprieteDynamiqueDotNet;
if (defDotNet != null)
{
CObjetDonnee objet = (CObjetDonnee)Activator.CreateInstance(m_filtreSelection.TypeElements, new object[] { CContexteDonneeSysteme.GetInstance() });
CStructureTable structure = CStructureTable.GetStructure(m_filtreSelection.TypeElements);
CInfoChampTable info = structure.GetChampFromPropriete(defDotNet.NomProprieteSansCleTypeChamp);
if (info != null)
{
CResultAErreur result = m_filtreSelection.GetFiltreData();
CFiltreData filtre = null;
if (result && result.Data is CFiltreData)
{
filtre = result.Data as CFiltreData;
}
filtre = CFiltreData.GetAndFiltre(filtre,
new CFiltreData(info.NomChamp + "=@1",
valeurRetournee));
if (objet.ReadIfExists(filtre))
{
return(new CReferenceObjetDonnee(objet));
}
}
}
}
return(null);
}
public CResultAErreur SetValeursParDefautAuxDonneesNulles(string strNomTable, CInfoChampTable champ)
{
if (!champ.NullAuthorized)
{
string strRequete = "Update " + strNomTable + " set " + champ.NomChamp + "=" +
GetStringValeurParDefaut(champ.TypeDonnee) + " where " + champ.NomChamp + " is null";
return(m_connection.RunStatement(strRequete));
}
return(CResultAErreur.True);
}
//----------------------------------
public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
{
List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();
lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();
lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;
if (!objet.ReadIfExists(vo.IdElement))
{
objet = null;
}
else
{
DesignationObjet = objet.DescriptionElement;
}
switch (vo.TypeOperation.Code)
{
case CTypeOperationSurObjet.TypeOperation.Ajout:
if (objet != null && objet.IsValide())
{
foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
{
string strNom = def.NomProprieteSansCleTypeChamp;
if (!def.IsReadOnly && strNom != "IsDeleted" && strNom != "Id" &&
strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
{
CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
if (resultVal)
{
object data = resultVal.Data;
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", def.Nom), true));
}
}
}
}
if (objet is CElementAChamp)
{
foreach (CRelationElementAChamp_ChampCustom rel in ((CElementAChamp)objet).RelationsChampsCustom)
{
object data = rel.Valeur;
if (data != null)
{
CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == rel.ChampCustom.Id);
if (defCust != null)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = defCust;
mv.Champ = defCust;
this.AddValeur(mv);
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
this.AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", rel.ChampCustom.Nom), true));
}
}
}
}
}
}
break;
case CTypeOperationSurObjet.TypeOperation.Suppression:
break;
case CTypeOperationSurObjet.TypeOperation.Modification:
CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
{
CDefinitionProprieteDynamique def = null;
IChampPourVersion champ = valeur.Champ;
if (champ is CChampPourVersionInDb)
{
string strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
CInfoChampTable infoChamp = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
{
string strNomPropriete = infoChamp.Propriete;
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
}
}
else if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
if (champCustom != null)
{
def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
((CDefinitionProprieteDynamiqueChampCustom)c).IdChamp == champCustom.Id);
}
}
if (def != null && !def.IsReadOnly)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (!FillMacroValeurWithValue(mv, valeur.GetValeur(), dicObjetToMacro))
{
result.EmpileErreur(new CErreurValidation(I.T("Can not use field @1 in macro|20052", valeur.NomChampConvivial), true));
}
else
{
AddValeur(mv);
}
}
}
break;
}
if (Valeurs.Count() == 0)
{
TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
}
return(result);
}
//----------------------------------
public CResultAErreur FillFromVersion(CVersionDonneesObjet vo, CContexteDonnee contexteEnVersion, Dictionary <CObjetDonneeAIdNumerique, CMacroObjet> dicObjetToMacro)
{
CStructureTable structure = CStructureTable.GetStructure(vo.TypeElement);
List <CDefinitionProprieteDynamique> lstChampsDotNet = new List <CDefinitionProprieteDynamique>();
lstChampsDotNet.AddRange(new CFournisseurProprietesDynamiqueDynamicField().GetDefinitionsChamps(vo.TypeElement, null));
List <CDefinitionProprieteDynamique> lstChampsCustom = new List <CDefinitionProprieteDynamique>();
lstChampsCustom.AddRange(new CFournisseurProprietesDynamiqueChampCustom().GetDefinitionsChamps(vo.TypeElement, null));
CResultAErreur result = CResultAErreur.True;
CObjetDonneeAIdNumerique objet = Activator.CreateInstance(vo.TypeElement, new object[] { contexteEnVersion }) as CObjetDonneeAIdNumerique;
if (!objet.ReadIfExists(vo.IdElement))
{
objet = null;
}
else
{
DesignationObjet = objet.DescriptionElement;
}
switch (vo.TypeOperation.Code)
{
case CTypeOperationSurObjet.TypeOperation.Ajout:
if (objet != null && objet.IsValide())
{
foreach (CDefinitionProprieteDynamique def in lstChampsDotNet)
{
string strNom = def.NomProprieteSansCleTypeChamp;
if (strNom != "IsDeleted" && strNom != "Id" &&
strNom != "ContexteDeModification" && strNom != "IdVersionDatabase")
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut ForceSetOnMacro, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(strNom);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length != 0)
{
bAdd = true;
}
}
if (bAdd)
{
CResultAErreur resultVal = CInterpreteurProprieteDynamique.GetValue(objet, def);
if (resultVal)
{
object data = resultVal.Data;
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", def.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
if (objet is IObjetDonneeAChamps)
{
foreach (CRelationElementAChamp_ChampCustom rel in ((IObjetDonneeAChamps)objet).RelationsChampsCustom)
{
object data = rel.Valeur;
if (data != null)
{
CDefinitionProprieteDynamique defCust = lstChampsCustom.FirstOrDefault(c => ((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == rel.ChampCustom.DbKey);
if (defCust != null)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = defCust;
mv.Champ = defCust;
if (FillMacroValeurWithValue(mv, data, dicObjetToMacro))
{
this.AddValeur(mv);
}
else
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of type @2 in macro", rel.ChampCustom.Nom,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
}
}
}
}
}
break;
case CTypeOperationSurObjet.TypeOperation.Suppression:
break;
case CTypeOperationSurObjet.TypeOperation.Modification:
CStructureTable structureObjet = CStructureTable.GetStructure(vo.TypeElement);
foreach (CVersionDonneesObjetOperation valeur in vo.ToutesLesOperations)
{
CDefinitionProprieteDynamique def = null;
IChampPourVersion champ = valeur.Champ;
if (champ is CChampPourVersionInDb)
{
string strNomChamp = ((CChampPourVersionInDb)champ).NomPropriete;
CInfoChampTable infoChamp = structureObjet.Champs.FirstOrDefault(c => c.NomChamp == strNomChamp);
if (infoChamp != null && infoChamp.NomChamp != CSc2iDataConst.c_champIdVersion &&
infoChamp.NomChamp != CSc2iDataConst.c_champIsDeleted &&
infoChamp.NomChamp != CObjetDonnee.c_champContexteModification)
{
string strNomPropriete = infoChamp.Propriete;
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == strNomPropriete);
}
if (def == null)
{
CInfoRelation relation = structureObjet.RelationsParentes.FirstOrDefault(i => i.ChampsFille.Length == 1 && i.ChampsFille[0] == strNomChamp);
if (relation != null)
{
def = lstChampsDotNet.FirstOrDefault(c => c.NomProprieteSansCleTypeChamp == relation.Propriete);
}
}
}
else if (champ is CChampCustomPourVersion)
{
CChampCustom champCustom = ((CChampCustomPourVersion)champ).ChampCustom;
if (champCustom != null)
{
def = lstChampsCustom.FirstOrDefault(c => c is CDefinitionProprieteDynamiqueChampCustom &&
((CDefinitionProprieteDynamiqueChampCustom)c).DbKeyChamp == champCustom.DbKey);
}
}
if (def != null)
{
bool bAdd = !def.IsReadOnly;
if (def.IsReadOnly)
{
//Si readonly mais a l'attribut TiagRelation, on l'ajoute quand même
PropertyInfo info = vo.TypeElement.GetProperty(def.NomProprieteSansCleTypeChamp);
if (info != null && info.GetCustomAttributes(typeof(TiagRelationAttribute), true).Length > 0)
{
bAdd = true;
}
}
if (bAdd)
{
CMacroObjetValeur mv = new CMacroObjetValeur(this);
mv.Champ = def;
object val = valeur.GetValeur();
if (val != null && typeof(CObjetDonneeAIdNumerique).IsAssignableFrom(def.TypeDonnee.TypeDotNetNatif) && valeur.TypeValeur == typeof(int))
{
CObjetDonneeAIdNumerique objetParent = Activator.CreateInstance(def.TypeDonnee.TypeDotNetNatif, new object[] { objet.ContexteDonnee }) as CObjetDonneeAIdNumerique;
if (objetParent.ReadIfExists((int)valeur.GetValeur()))
{
val = objetParent;
}
else
{
val = null;
}
}
if (!FillMacroValeurWithValue(mv, val, dicObjetToMacro))
{
result.EmpileErreur(new CErreurValidation(I.T("#Can not use field @1 of @2 in macro", valeur.NomChampConvivial,
DynamicClassAttribute.GetNomConvivial(vo.TypeElement)), true));
}
else
{
AddValeur(mv);
}
}
}
}
break;
}
if (Valeurs.Count() == 0)
{
TypeOperation = new CTypeOperationSurObjet(CTypeOperationSurObjet.TypeOperation.Aucune);
}
return(result);
}
public virtual CResultAErreur UpdateStructureTableRegistre()
{
CResultAErreur result = CResultAErreur.True;
//Cherche la table de registre
bool bExist = false;
foreach (string strNomTable in Connection.TablesNames)
{
if (strNomTable == CDatabaseRegistre.c_nomTable)
{
bExist = true;
break;
}
}
if (!bExist)
{ //C'est une initialisation initiale
return(result);
}
else
{
//Vérifie que toutes les colonnes existent
string[] strColonnes = Connection.GetColonnesDeTable(CDatabaseRegistre.c_nomTable);
Dictionary <string, bool> tableColonnes = new Dictionary <string, bool>();
foreach (string strColonne in strColonnes)
{
tableColonnes.Add(strColonne, true);
}
if (!tableColonnes.ContainsKey(CDatabaseRegistre.c_champCle))
{
CInfoChampTable info = new CInfoChampTable(
CDatabaseRegistre.c_champCle,
typeof(string),
255,
false,
true,
false,
false,
true);
result = CreateChamp(CDatabaseRegistre.c_nomTable, info);
if (!result)
{
return(result);
}
}
if (!tableColonnes.ContainsKey(CDatabaseRegistre.c_champValeur))
{
CInfoChampTable info = new CInfoChampTable(
CDatabaseRegistre.c_champValeur,
typeof(string),
255,
false,
false,
true,
false,
true);
result = CreateChamp(CDatabaseRegistre.c_nomTable, info);
if (!result)
{
return(result);
}
}
if (!tableColonnes.ContainsKey(CDatabaseRegistre.c_champBlob))
{
CInfoChampTable info = new CInfoChampTable(
CDatabaseRegistre.c_champBlob,
typeof(CDonneeBinaireInRow),
255,
false,
false,
true,
false,
true);
result = CreateChamp(CDatabaseRegistre.c_nomTable, info);
if (!result)
{
return(result);
}
}
}
return(result);
}
public virtual CResultAErreur CreateChamp(string strNomTable, CInfoChampTable champ)
{
return(CreateChamp(strNomTable, champ, false));
}
/// <summary>
/// Retourne la déclaration d'un champ pour le créer
/// </summary>
/// <param name="champ"></param>
/// <returns></returns>
protected virtual string GetDeclarationChamp(CInfoChampTable champ)
{
return(GetDeclarationChamp(champ, false));
}
protected virtual bool Champ_ModifiedNotNull(CInfoChampTable champ, DataColumn colonne, ArrayList champsAutorisesANull)
{
return(colonne.AllowDBNull != champ.NullAuthorized);
}