public async Task Initialize()
{
mServer.Start();
OnStatusChanged("Initializing database...");
await mRepo.Initialize();
var theLastUser = mSettings.LastUser;
mCurrentUser = mRepo.UserFromName(theLastUser);
if (mCurrentUser == null)
{
mCurrentUser = mRepo.AllUsers().FirstOrDefault();
}
OnStatusChanged("Updating items...");
await UpdateItems();
OnStatusChanged("Updating prices...");
await UpdatePrices();
mRepo.ItemsChanged += HandleItemsChanged;
InitializationCompleted?.Invoke(this, new EventArgs());
}
public void InitializeTrackVariant(int variantId)
{
if (CurrentTrackVariantId == variantId)
{
// Already initialized
return;
}
IndexTrackVariantInformation();
if (!_trackVariantLookup.TryGetValue(variantId, out TrackVariant variant))
{
// Variant not valid
return;
}
DisableAllVariantObstacles();
DisableAllVariantCheckpoints();
SetVariantObstaclesEnabled(variant, true);
SetVariantCheckpointsEnabled(variant, true);
_checkpointLookup.Clear();
for (int i = 0; i < variant.Checkpoints.Length; i++)
{
variant.Checkpoints[i].Init(i, i == variant.Checkpoints.Length - 1);
_checkpointLookup.Add(i, variant.Checkpoints[i]);
if (variant.Checkpoints[i].IsSectorCheckpoint || variant.Checkpoints[i].IsFinishLine)
{
_sectorLookup.Add(variant.Checkpoints[i].CheckpointIndex, _sectorLookup.Count + 1);
}
}
CurrentTrackVariantId = variantId;
InitializationCompleted?.Invoke(variant);
}
private async Task UpdateErrorBarAsync()
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
try
{
var projects = await _solutionManager.GetNuGetProjectsAsync();
foreach (var project in projects)
{
await project.GetInstalledPackagesAsync(CancellationToken.None);
}
ErrorBar.Visibility = Visibility.Collapsed;
}
catch (Exception ex)
{
ErrorMessage.Text = ex.Message;
ErrorBar.Visibility = Visibility.Visible;
}
finally
{
InitializationCompleted?.Invoke(this, EventArgs.Empty);
}
}
private async Task InitializeCache()
{
_accounts = await _orderFields.GetAccounts();
_brokers = await _orderFields.GetBrokers();
_securities = await _orderFields.GetSecurities();
InitializationCompleted?.Invoke(this, null);
}
private void Context_UpdateCompleted(IArkUpdateableContext sender, bool successful, bool cancelled)
{
// When all server contexts have completed one update successfully trigger the InitializationCompleted-event.
if (!IsFullyInitialized && Servers.All(x => x.IsInitialized) && Clusters.All(x => x.IsInitialized))
{
IsFullyInitialized = true;
InitializationCompleted?.Invoke();
}
UpdateCompleted?.Invoke(sender, successful, cancelled);
}
private void Context_UpdateCompleted(IArkUpdateableContext sender, bool successful, bool cancelled)
{
// Force an immediate garbage collection because it seems more effective (extraction process requires a great deal of memory)
GC.Collect();
// When all server contexts have completed one update successfully trigger the InitializationCompleted-event.
if (!IsFullyInitialized && Servers.All(x => x.IsInitialized) && Clusters.All(x => x.IsInitialized))
{
IsFullyInitialized = true;
InitializationCompleted?.Invoke();
}
UpdateCompleted?.Invoke(sender, successful, cancelled);
}
private void Initialize()
{
if (_isInitialized)
{
return;
}
InitializationStarted?.Invoke(this, EventArgs.Empty);
using (var com = new ComObjectManager())
{
var outlook = com.Get(() => new OutlookApplication());
var session = com.Get(() => outlook.Session);
var globalAddressList = com.Get(() => session.GetGlobalAddressList());
var addressEntries = com.Get(() => globalAddressList.AddressEntries);
var people = new List <Person>(3000);
people.AddRange(addressEntries
.Cast <AddressEntry>()
.Select(ae => com.Get(() => ae))
.Select(ae => GetPerson(com, ae))
.Where(p => p != null));
foreach (var group in people.GroupBy(p => p.LastName))
{
PeopleByLastName.Add(group.Key, group.ToList());
}
foreach (var group in people.GroupBy(p => p.EmailAddress))
{
PeopleByEmailAddress.Add(group.Key, group.ToList());
}
}
InitializationCompleted?.Invoke(this, EventArgs.Empty);
_isInitialized = true;
}
private async Task InitializeCache()
{
List <OrderModel> orders = await _orderEndpoint.GetAll();
StringBuilder clOrderIds = new StringBuilder();
foreach (OrderModel order in orders)
{
if (order.InternalOrderType == (int)InternalOrderType.Stage)
{
_stageOrders.Add(order);
}
else
{
_subOrders.Add(order);
clOrderIds.Append(order.ClOrderId + ',');
}
}
//clOrderIds.Length--;
_fills = await _fillEndpoint.GetAll();
InitializationCompleted?.Invoke(this, null);
}
private void RaiseInitializationCompletedEvent(Exception exception = null)
{
InitializationCompleted?.Invoke(this, new ServiceHandlerConnectionChangedEventArgs(this, Status, exception));
}
public void OnDone(bool completed)
{
InitializationCompleted?.Invoke(completed);
}
private void m_model_ModelInitializing(IModel model, object userData)
{
lock (_token){
m_generation++;
IList dependentList = m_gs.GetServiceSequenceList();
IList independentList = m_zeroDependencyInitializers;
if (m_generation == 0)
{
ValidateModel(dependentList);
}
Clear();
InitializationBeginning?.Invoke(m_generation);
// First call into the ones that don't need it.
foreach (object[] oa in independentList)
{
Initializer initializer = (Initializer)oa[0];
object[] parameters = (object[])oa[1];
InitializationAction?.Invoke(initializer, parameters);
initializer(model, parameters);
}
// Next walk through the ones that do, in an appropriate sequence.
try {
foreach (Dv dv in dependentList)
{
InitializationAction?.Invoke(dv.Initializer, dv.Parameters);
dv.PerformInitialization(model);
}
} catch (GraphCycleException gce) {
IList cycleMembers = (ArrayList)gce.Members;
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for (int i = 0; i < cycleMembers.Count; i++)
{
if (i != 0)
{
sb.Append("->");
}
object target = ((Dv)cycleMembers[i]).Initializer.Target;
Type mbrType = target.GetType();
string name = null;
System.Reflection.PropertyInfo nameProp = mbrType.GetProperty("Name");
if (nameProp == null)
{
name = "(unknown " + cycleMembers[i].GetType().Name + ")";
}
else
{
name = (string)nameProp.GetValue(target, new object[] {});
}
sb.Append(name);
}
throw new ApplicationException("Failure to initialize due to a cyclical dependency involving [...->" + sb + "->...].");
//string cycle = FindCycle(cyclist);
//Console.WriteLine("Cycle is " + cycle + ".");
}
// If more initializers have been added during this generation, run another generation of initialization.
if (m_gs.GetServiceSequenceList().Count > 0 || m_zeroDependencyInitializers.Count > 0)
{
m_model_ModelInitializing(model, userData);
}
if (m_generation == 0)
{
InitializationCompleted?.Invoke(m_generation);
}
m_generation--;
} // End of lock.
// When all initialization iterations have completed...
}
public void OnDone(bool p0)
{
InitializationCompleted?.Invoke(p0);
}
private async Task InitializeCache()
{
_tabWiseData = await _watchlistData.GetAllTabsData();
InitializationCompleted?.Invoke(this, null);
}
