//-------------------------------------------------------------------------------
internal void Expand(CCustomizableListItem item)
{
using (CWaitCursor waiter = new CWaitCursor())
{
CSetupSmartImportItem si = item as CSetupSmartImportItem;
if (si != null && si.ChildItems.Count() == 0)
{
CSetupSmartImportChampEntiteItem root = si as CSetupSmartImportChampEntiteItem;
if (root != null)
{
CreateChilds(si, root.ValeursExemples, root.ConfigMappage);
}
CSetupSmartImportEntiteParentItem itemParent = si as CSetupSmartImportEntiteParentItem;
if (itemParent != null)
{
CreateChilds(
si,
itemParent.ValeursParent,
itemParent.MappageEntiteParente != null ? itemParent.MappageEntiteParente.ConfigEntiteParente : null);
}
CSetupSmartImportEntiteFilleItem itemFille = si as CSetupSmartImportEntiteFilleItem;
if (itemFille != null)
{
CreateChilds(itemFille);
}
}
if (si != null)
{
si.Expand();
}
Refresh();
}
}
//-------------------------------------------------------------------------------
public override bool HasConfigData()
{
if (MappageEntitesFilles != null)
{
if (MappageEntitesFilles.MappagesEntitesFilles.Count() > 0)
{
return(true);
}
foreach (CSetupSmartImportItem child in ChildItems)
{
CSetupSmartImportChampEntiteItem itemEntite = child as CSetupSmartImportChampEntiteItem;
if (itemEntite != null && itemEntite.Source != null)
{
return(true);
}
}
}
return(false);
}
//-------------------------------------------------------------------------------
public CResultAErreurType <CConfigMappagesSmartImport> GetConfigFinale()
{
MajChamps();
CResultAErreurType <CConfigMappagesSmartImport> resFinal = new CResultAErreurType <CConfigMappagesSmartImport>();
if (Items.Count() == 0 || !(Items[0] is CSetupSmartImportChampEntiteItem))
{
resFinal.EmpileErreur(I.T("Can not calculate import setup|20121"));
return(resFinal);
}
CSetupSmartImportChampEntiteItem root = Items[0] as CSetupSmartImportChampEntiteItem;
CConfigMappagesSmartImport config = new CConfigMappagesSmartImport();
CResultAErreur result = root.MajConfig(config);
if (!result)
{
resFinal.EmpileErreur(result.Erreur);
return(resFinal);
}
resFinal.DataType = config;
return(resFinal);
}
//-------------------------------------------------------------------------------
public override CResultAErreur MajConfig(CConfigMappagesSmartImport config)
{
CResultAErreur result = CResultAErreur.True;
CMappageEntitesFilles mappage = new CMappageEntitesFilles();
mappage.Propriete = MappageEntitesFilles.Propriete;
List <CMappageEntiteFille> lstMapsFilles = new List <CMappageEntiteFille>();
foreach (CSetupSmartImportItem child in ChildItems)
{
CSetupSmartImportChampEntiteItem itemEntite = child as CSetupSmartImportChampEntiteItem;
if (itemEntite != null)
{
if (itemEntite.Source != null)
{
CConfigMappagesSmartImport conf = new CConfigMappagesSmartImport();
result = itemEntite.MajConfig(conf);
if (!result)
{
return(result);
}
CMappageEntiteFille mapFille = new CMappageEntiteFille();
mapFille.ConfigMappage = conf;
mapFille.Source = itemEntite.Source;
lstMapsFilles.Add(mapFille);
}
}
}
mappage.MappagesEntitesFilles = lstMapsFilles;
if (lstMapsFilles.Count > 0)
{
List <CMappageEntitesFilles> lst = new List <CMappageEntitesFilles>(config.MappagesEntitesFilles);
lst.Add(mappage);
config.MappagesEntitesFilles = lst;
}
return(result);
}
//-------------------------------------------------------------------------------
private bool HighLight(string strIdsMappage, string strChampEnCours)
{
//Pas terminé, trucs plus urgents à faire
foreach (CCustomizableListItem item in Items)
{
CSetupSmartImportItem si = item as CSetupSmartImportItem;
if (si != null)
{
if (si.Highlight)
{
RefreshItem(si);
}
si.Highlight = false;
}
}
try
{
if (Items.Count() == 0)
{
return(false);
}
string[] strIds = strIdsMappage.Split('.');
if (strIds.Length == 0)
{
return(false);
}
CSetupSmartImportChampEntiteItem root = Items[0] as CSetupSmartImportChampEntiteItem;
if (root == null || root.ConfigMappage == null || root.ConfigMappage.IdMappage != strIds[0])
{
return(false);
}
}
finally
{
}
return(false);
}
//-------------------------------------------------------------------------------
private void CreateChilds(CSetupSmartImportEntiteFilleItem itemFille)
{
int nIndex = itemFille.Index;
int nColIndex = itemFille.ColorIndex;
HashSet <CDbKey> keysDone = new HashSet <CDbKey>();
if (itemFille.ValeursDeFilles != null)
{
foreach (CValeursProprietes val in itemFille.ValeursDeFilles)
{
CMappageEntiteFille mappage = itemFille.MappageEntitesFilles != null?
itemFille.MappageEntitesFilles.GetMappageForEntite(val.DbKeyObjet) :
null;
bool bCreate = true;
if (HideNullSources)
{
bCreate = mappage != null && mappage.Source != null;
}
if (bCreate)
{
nColIndex++;
if (CSetupSmartImportItem.GetCouleur(nColIndex) == itemFille.BackColor)
{
nColIndex++;
}
CSetupSmartImportChampEntiteItem item = new CSetupSmartImportChampEntiteItem(
itemFille,
val,
mappage != null ? mappage.Source : null,
mappage != null ? mappage.ConfigMappage : null,
nColIndex);
InsertItem(++nIndex, item, false);
if (val.DbKeyObjet != null)
{
keysDone.Add(val.DbKeyObjet);
}
}
}
}
if (itemFille.MappageEntitesFilles != null)
{
IEnumerable <CMappageEntiteFille> mapsFilles = itemFille.MappageEntitesFilles.MappagesEntitesFilles;
foreach (CMappageEntiteFille mapFille in mapsFilles)
{
if (mapFille.Source != null && mapFille.ConfigMappage != null)
{
CConfigMappagesSmartImport conf = mapFille.ConfigMappage;
if (conf.KeyEntite == null || !keysDone.Contains(conf.KeyEntite))
{
nColIndex++;
if (CSetupSmartImportItem.GetCouleur(nColIndex) == itemFille.BackColor)
{
nColIndex++;
}
CSetupSmartImportChampEntiteItem item = new CSetupSmartImportChampEntiteItem(
itemFille,
null,
mapFille.Source,
conf,
nColIndex);
InsertItem(++nIndex, item, false);
if (conf.KeyEntite != null)
{
keysDone.Add(conf.KeyEntite);
}
}
}
}
}
}