public UnitForm(IDatumProvider srcUnits, IDatum datum = null)
{
Assert(srcUnits != null);
Assert(datum == null || datum is Unit);
InitializeComponent();
m_ndxerUnits = new KeyIndexer(srcUnits);
if (datum != null)
{
m_datum = datum as Unit;
m_tsbReload.Click += delegate { FillForm(); };
m_ndxerUnits.DatumDeleted += UnitsIndexer_DatumChanged;
m_ndxerUnits.DatumReplaced += UnitsIndexer_DatumChanged;
FillForm();
}
m_tbName.TextChanged += delegate { UpdateUI(); };
m_tsbSave.Click += Save_Click;
ConnectAsync();
}
private static void Fetch(IDatumProvider provider, bool force)
{
if (RequiredDataAvailable(provider.Datum, force))
{
myLogger.Info("Seem to have all required data for: " + provider.Datum + " - skipping");
return;
}
myLogger.Info(string.Format("Fetching datum '{0}' for stock = '{1}'", provider.Datum, Interpreter.Context.Scope.Stock.Stock.Isin));
Engine.LogProgress(" Fetching datum '{0}' for stock = '{1}'", provider.Datum, Interpreter.Context.Scope.Stock.ToString());
if (provider == null)
{
throw new Exception(string.Format("No data provider found for {0}", provider.Datum));
}
var result = provider.Fetch();
if (result == null)
{
myLogger.Error("Unable to provide data for: {0}", provider.Datum);
}
else
{
Engine.LogProgress(" Importing '{0}' for '{1}' from '{2}'", provider.Datum, Interpreter.Context.Scope.Stock.ToString(), result.Sites.First().Name);
//result.Table.Dump();
MauiX.Import.Import(Interpreter.Context.Scope.Stock, result);
Engine.LogProgress(" Import finished");
}
}
void LoadDataUpdates()
{
Assert(!InvokeRequired);
//KeyIndexer ndxer = AppContext.AccessPath.GetKeyIndexer(InternalTablesID.INCREMENT);
//var dataInc = ndxer.Get(11) as UpdateIncrement;
//dataInc.PreDataGeneration = AppContext.Settings.AppSettings.DataGeneration;
//ndxer.Source.Replace(ndxer.IndexOf(11) , dataInc);
IDatumProvider dp = AppContext.AccessPath.GetDataProvider(InternalTablesID.INCREMENT);
m_lvDataUpdates.Items.Clear();
if (dp.Count > 0)
{
foreach (UpdateIncrement inc in dp.Enumerate())
{
var lvi = new ListViewItem(inc.Content)
{
Tag = inc
};
m_lvDataUpdates.Items.Add(lvi);
}
}
}
static void DeleteFuzzyData(IDatumProvider dp, int[] indices)
{
if (MessageBox.Show(ASK_DELETE, "Confirmation requise",
MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
int nbDeleted = 0;
try
{
for (int i = indices.Length - 1; i >= 0; --i)
{
int ndx = indices[i];
IDatum datum = dp.Get(ndx);
var item = datum as ITaggedRow;
item.Disabled = true;
dp.Replace(ndx, datum);
++nbDeleted;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
TextLogger.Info(string.Format("{0} élément(s) supprimé(s).", nbDeleted));
}
}
public UnitChecker(IDatumProvider dp)
{
Assert(dp != null);
m_srcUnits = dp;
m_srcUnits.Connect();
}
public ProductChecker(IDatumProvider srcProducts)
{
Assert(srcProducts != null);
m_srcProducts = srcProducts;
m_srcProducts.Connect();
}
public IKeyIndexer GetIndexer(uint sourceID)
{
lock (m_lock)
{
KeyIndexer ndxer = null;
Tuple <uint, KeyIndexer> tpl = m_indexers.Find(t => t.Item1 == sourceID);
if (tpl != null)
{
ndxer = tpl.Item2;
}
else
{
IDatumProvider dp = QueryProvider(sourceID);
ndxer = new KeyIndexer(dp);
if (m_indexers.Count >= m_maxSize)
{
CleanTables();
}
m_indexers.Add(Tuple.Create(sourceID, ndxer));
ndxer.Connect();
}
return(ndxer);
}
}
public SpotValueForm(IDatumProvider srcValues, IDatum datum)
{
Assert(datum is SpotValue);
Assert(srcValues != null);
InitializeComponent();
m_nudPrice.Maximum = decimal.MaxValue;
m_ndxerValues = new KeyIndexer(srcValues);
m_spotValue = datum as SpotValue;
m_nudPrice.DecimalPlaces = AppContext.Settings.AppSettings.PriceDecimalPlaces;
ConnectAsync();
m_nudPrice.Value = (decimal)m_spotValue.Price;
m_dtpSpotTime.Value = m_spotValue.SpotTime;
m_nudPrice.TextChanged += delegate { UpdateUI(); };
m_tsbReload.Click += delegate
{
m_nudPrice.Value = (decimal)m_spotValue.Price + 1; //si m_nudPrice.Value == m_spotValue.Price l'affichage
m_nudPrice.Value = (decimal)m_spotValue.Price; // n'est pas mis a jour
m_dtpSpotTime.Value = m_spotValue.SpotTime;
};
m_tsbSave.Click += delegate { Save(); };
m_ndxerValues.DatumDeleted += FreezeDialog;
m_ndxerValues.DatumReplaced += FreezeDialog;
}
private static void Fetch( IDatumProvider provider, bool force )
{
if ( RequiredDataAvailable( provider.Datum, force ) )
{
myLogger.Info( "Seem to have all required data for: " + provider.Datum + " - skipping" );
return;
}
myLogger.Info( string.Format( "Fetching datum '{0}' for stock = '{1}'", provider.Datum, Interpreter.Context.Scope.Stock.Stock.Isin ) );
Engine.LogProgress( " Fetching datum '{0}' for stock = '{1}'", provider.Datum, Interpreter.Context.Scope.Stock.ToString() );
if ( provider == null )
{
throw new Exception( string.Format( "No data provider found for {0}", provider.Datum ) );
}
var result = provider.Fetch();
if ( result == null )
{
myLogger.Error( "Unable to provide data for: {0}", provider.Datum );
}
else
{
Engine.LogProgress( " Importing '{0}' for '{1}' from '{2}'", provider.Datum, Interpreter.Context.Scope.Stock.ToString(), result.Sites.First().Name );
//result.Table.Dump();
MauiX.Import.Import( Interpreter.Context.Scope.Stock, result );
Engine.LogProgress( " Import finished" );
}
}
public ProductForm(IDatumProvider srcProduct, IDatum datum = null)
{
Assert(srcProduct != null);
Assert(datum == null || datum is Product);
InitializeComponent();
m_ndxerProducts = new KeyIndexer(srcProduct);
if (datum != null)
{
m_datum = datum as Product;
FillForm();
m_tsbReload.Click += delegate { FillForm(); };
}
//handlers
m_tsbSave.Click += Save_Click;
m_ndxerProducts.DatumDeleted += ProductsIndexer_DatumChanged;
m_ndxerProducts.DatumReplaced += ProductsIndexer_DatumChanged;
EventHandler txtChangedHandler = delegate { UpdateUI(); };
m_tbSubHeading.TextChanged += txtChangedHandler;
m_tbName.TextChanged += txtChangedHandler;
ConnectAsync();
}
public ValueContextChecker(IDatumProvider dp)
{
Assert(dp != null);
m_srcContext = dp;
m_srcContext.Connect();
}
public PlaceChecker(IDatumProvider srcPlaces)
{
Assert(srcPlaces != null);
m_srcPlaces = srcPlaces;
m_srcPlaces.Connect();
}
public SpotValueChecker(IDatumProvider srcValues)
{
Assert(srcValues != null);
m_srcSpotValues = srcValues;
m_srcSpotValues.Connect();
}
public CountryForm(IDatumProvider countryProvider, IDatum datum = null)
{
Assert(countryProvider != null);
Assert(datum == null || datum is Country);
InitializeComponent();
m_nudInternalCode.Maximum = CountryRow.MAX_INTERNAL_CODE;
m_ndxerCountries = new KeyIndexer(countryProvider);
if (datum != null)
{
m_datum = datum as Country;
m_ndxerCountries.DatumDeleted += Countries_DatumChanged;
m_ndxerCountries.DatumReplaced += Countries_DatumChanged;
m_tsbReload.Click += delegate { ShowDatum(); };
}
//handlers
EventHandler txtChanged = delegate
{
UpdateUI();
};
m_tbName.TextChanged += txtChanged;
m_nudInternalCode.TextChanged += txtChanged;
m_tsbSave.Click += delegate { SaveDatum(); };
}
public bool Check()
{
var logger = new TextLogger(LogSeverity.Warning);
logger.PutLine("*** Control d’intégrité ***");
logger.PutLine($"Table: {AppContext.TableManager.Countries.Name}");
logger.PutLine("Les élemnets suivants ont un numerà de géneration invalide:");
using (IDatumProvider dp = AppContext.TableManager.TablesGeneration.DataProvider)
{
dp.Connect();
bool anyErr = false;
if (dp.Count > 0)
{
foreach (FileGeneration d in dp.Enumerate())
{
if (d.Generation == 0)
{
logger.PutLine(d.ToString());
anyErr = true;
}
}
}
if (anyErr)
{
logger.Flush();
}
return(!anyErr);
}
}
public DataSupplierChecker(IDatumProvider dbSuppliers)
{
Assert(dbSuppliers != null);
m_srcSuppmiers = dbSuppliers;
m_srcSuppmiers.Connect();
}
public DatumProvider(IDatumProvider source, Predicate <IDatum> filter, //nothrow
AggregationMode_t aggMode = AggregationMode_t.Rejected)
{
Assert(source != null);
m_mapper = new ProviderMapper <IDatum>(source, filter, aggMode);
}
public TRVectorForm(IDatumProvider srcSpotValues, IDatum datum)
{
Assert(srcSpotValues != null);
Assert(datum != null);
Assert(datum is SpotValue);
InitializeComponent();
}
public ClientEventLogger(uint clID)
{
Dbg.Assert(clID != 0);
ClientID = clID;
m_tbl = new EventLogTable(AppPaths.GetClientLogPath(clID));
m_logProvider = m_tbl.DataProvider;
m_logProvider.Connect();
}
public DatumProvider(IDatumProvider source, Predicate <IDatum> filter,
AggregationMode_t mode = AggregationMode_t.Rejected)
{
Debug.Assert(source != null);
m_source = source;
m_filter = filter;
m_aggMode = mode;
m_mapper = new ProviderMapper <IDatum>(m_source, m_filter, m_aggMode);
}
public AttrIndexer(IDatumProvider provider, Func <IDatum, T> selector, IEqualityComparer <T> comparer)
{
Debug.Assert(provider != null);
Debug.Assert(selector != null);
Debug.Assert(comparer != null);
m_selector = selector;
m_dataProvider = provider;
m_ndxTable = new Dictionary <T, List <int> >(comparer);
}
static void PrepareTables()
{
const int NDX_LABEL = 0;
const int NDX_SPOT_VALUE = 1;
IDatumProvider dp = AppContext.AccessPath.GetDataProvider(InternalTablesID.TRANSACTION);
List <RowAction>[] actions = { new List <RowAction>(), new List <RowAction>() };
using (var pump = new DataPump(dp))
{
pump.Connect();
DataPump.Item item = pump.NextItem;
while (item != null)
{
var trans = item.Row as Transaction;
int ndx = trans.TableID == InternalTablesID.TR_LABEL ? NDX_LABEL :
trans.TableID == InternalTablesID.TR_SPOT_VALUE ? NDX_SPOT_VALUE : -1;
if (ndx != -1)
{
RowAction ra = actions[ndx].Find(a => a.RowID == trans.RowID);
if (ra == null)
{
actions[ndx].Add(new RowAction(trans.RowID, trans.Action));
}
else if (ra.ActionCode == ActionCode_t.AddRow && trans.Action == ActionCode_t.DeleteRow)
{
actions[ndx].Remove(ra);
}
else
{
ra.ActionCode = SelectAction(ra.ActionCode, trans.Action);
}
dp.Delete(item.Index);
}
item = pump.NextItem;
}
}
foreach (RowAction ra in actions[NDX_LABEL])
{
UpdateTextTable(ra.RowID, ra.ActionCode);
}
foreach (RowAction ra in actions[NDX_SPOT_VALUE])
{
UpdateSpotTable(ra.RowID, ra.ActionCode);
}
}
public AttrIndexer(IDatumProvider provider, Func <IDatum, T> selector, //noththrow
IEqualityComparer <T> comparer)
{
Assert(provider != null);
Assert(selector != null);
Assert(comparer != null);
m_selector = selector;
m_dataProvider = provider;
m_dataIndices = new Dictionary <T, List <int> >(comparer);
}
public ChooseCountryDialog(IDatumProvider provider)
{
Assert(provider != null);
InitializeComponent();
m_dpCountries = provider;
m_dpCountries.Connect();
m_cbCountries.DisplayMember = "Name";
m_cbCountries.Items.AddRange(m_dpCountries.Enumerate().ToArray());
}
//private:
static string Locate(IDatumProvider provider)
{
foreach (string key in m_tableProviders.Keys)
{
if (m_tableProviders[key].Contains(provider))
{
return(key);
}
}
return(null);
}
static bool IsProviderRegistered(IDatumProvider provider)
{
if (provider == null)
{
return(false);
}
lock (m_tableProviders)
{
return(Locate(provider) != null);
}
}
public DatumView(IDatumProvider dataProvider, string text)
{
Assert(dataProvider != null);
InitializeComponent();
m_dataProvider = dataProvider;
Text = text;
//handlers
m_lvData.SelectedIndexChanged += delegate { UpdateUI(); };
}
public static void UnregisterProvider(IDatumProvider provider)
{
if (provider != null)
{
lock (m_tableProviders)
{
string key = Locate(provider);
m_tableProviders[key].Remove(provider);
//EventLogger.Debug("Table: {0}, -dp , # of dps = {1}.", key, m_tableProviders[key].Count);
}
}
}
public ProfilesWindow()
{
InitializeComponent();
m_dpProfiles = AppContext.TableManager.Profiles.DataProvider;
m_ndxerProfiles = new KeyIndexer(m_dpProfiles);
m_ndxerMgmntMode = new KeyIndexer(AppContext.TableManager.ProfileManagementMode.DataProvider);
m_colSorters = new Dictionary <ColumnDataType_t, Func <int, IColumnSorter> >
{
{ ColumnDataType_t.Integer, ndxCol => new IntegerColumnSorter(ndxCol) },
{ ColumnDataType_t.Text, ndxCol => new TextColumnSorter(ndxCol) },
};
}
public ProfileForm(IDatumProvider dp, UserProfile datum = null)
{
Dbg.Assert(dp != null);
InitializeComponent();
m_ndxProfiles = new KeyIndexer(dp);
if (datum != null)
{
m_datum = datum;
m_tsbReload.Click += Reload_Click;
}
}
public SpotValueChecker(IDatumProvider spotValues, KeyIndexer labels, KeyIndexer prodMappings)
{
Assert(spotValues != null);
Assert(labels != null);
Assert(prodMappings != null);
m_srcSpotValues = spotValues;
m_srcSpotValues.Connect();
m_ProductMappings = prodMappings;
m_ProductMappings.Connect();
m_labels = labels;
m_labels.Connect();
}
