public ReservationDashBoardViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
{
this._logger = logger;
this._container = container;
this._reservationManager = reservationManager;
this._tableManager = tableManager;
this._messageBoxService = messageBoxService;
this._dialogBoxService = dialogBoxService;
this._reservationHours = new ObservableCollection<ReservationHour>();
this._reservations = new MappedValueCollection();
this.AddCommand = new DelegateCommand(this.OnAddCommand, () => { return this._noOfPersons > 0; });
this.BrowseCommand = new DelegateCommand(this.OnBrowseCommand);
this.ImportCommand = new DelegateCommand(this.OnImportCommand, () => { return !string.IsNullOrEmpty(this._tableXMLFile); });
this._tables = this._tableManager.GetAll();
// Assumption : Reservation duration is between 10 Am and 10 Pm
this._minFromHour = 10;
this._maxFromHour = 22;
for (int hour = this._minFromHour; hour <= this._maxFromHour; hour++)
{
this._reservationHours.Add(new ReservationHour(hour));
}
this.FromHour = this._minFromHour;
TableReservation.Common.ReservationsUpdatedEvent.Instance.Subscribe(this.ReservationsUpdated);
this.ReservationsUpdated(Guid.NewGuid());
}
/// <summary>
/// Internal, used by tests.
/// </summary>
public ErrorListTableDataSource(IErrorList errorList, ITableManager tableManager)
{
if (errorList == null)
{
throw new ArgumentNullException(nameof(errorList));
}
if (tableManager == null)
{
throw new ArgumentNullException(nameof(tableManager));
}
_initialized = true;
_errorList = errorList;
_tableManager = tableManager;
}
public ReservationViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
{
this._logger = logger;
this._container = container;
this._reservationManager = reservationManager;
this._tableManager = tableManager;
this._messageBoxService = messageBoxService;
this._dialogBoxService = dialogBoxService;
this.EditCommand = new DelegateCommand(this.OnEditCommand, () => { return this._selectedReservation != null; });
this.DeleteCommand = new DelegateCommand(this.OnDeleteCommand, () => { return this._selectedReservation != null; });
this.GetAllReservations();
TableReservation.Common.ReservationsUpdatedEvent.Instance.Subscribe(this.ReservationsUpdated);
}
private ErrorListDataSource()
{
CheckThread();
var compositionService = ServiceProvider.GlobalProvider.GetService(typeof(SComponentModel)) as IComponentModel;
compositionService.DefaultCompositionService.SatisfyImportsOnce(this);
ITableManager manager = TableManagerProvider.GetTableManager(StandardTables.ErrorsTable);
manager.AddSource(this, StandardTableColumnDefinitions.DetailsExpander,
StandardTableColumnDefinitions.ErrorSeverity, StandardTableColumnDefinitions.ErrorCode,
StandardTableColumnDefinitions.ErrorSource, StandardTableColumnDefinitions.BuildTool,
StandardTableColumnDefinitions.ErrorCategory,
StandardTableColumnDefinitions.Text, StandardTableColumnDefinitions.DocumentName,
StandardTableColumnDefinitions.Line, StandardTableColumnDefinitions.Column);
}
public StatisticsManager(
ITableManager tableManager,
Transaction transaction,
string tableCatalogName = "tblname",
string fieldCatalogName = "fldname",
int statisticCallsBeforeUpdateCount = 100)
{
_tableCatalogName = tableCatalogName;
_fieldCatalogName = fieldCatalogName;
_tableManager = tableManager;
_statisticCallsBeforeUpdateCount = statisticCallsBeforeUpdateCount;
_tableStats = new Dictionary <string, StatisticalInfo>();
RefreshStatistics(transaction);
}
public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
if (pguidCmdGroup == _vSStd97CmdIDGuid && nCmdID == (uint)VSConstants.VSStd97CmdID.GotoDefn)
{
TextView.TextBuffer.Properties.TryGetProperty <ITextDocument>(typeof(ITextDocument), out ITextDocument textDoc);
IWorkspace workspace = _workspaceManager.GetWorkspace(textDoc.FilePath);
List <Definition> definitions = workspace.ResolveDefinition(textDoc.FilePath, TextView.TextSnapshot.GetText(), TextView.Caret.Position.BufferPosition.Position);
if (definitions.Count == 1)
{
DTE dte = ServiceProvider.GlobalProvider.GetService(typeof(DTE)) as DTE;
dte.MainWindow.Activate();
using (var state = new NewDocumentStateScope(Microsoft.VisualStudio.Shell.Interop.__VSNEWDOCUMENTSTATE.NDS_Provisional, Guid.Parse(ProjectFileToolsPackage.PackageGuidString)))
{
EnvDTE.Window w = dte.ItemOperations.OpenFile(definitions[0].File, EnvDTE.Constants.vsViewKindTextView);
if (definitions[0].Line.HasValue)
{
((EnvDTE.TextSelection)dte.ActiveDocument.Selection).GotoLine(definitions[0].Line.Value, true);
}
}
return(VSConstants.S_OK);
}
else if (definitions.Count > 1)
{
IFindAllReferencesService farService = (IFindAllReferencesService)Package.GetGlobalService(typeof(SVsFindAllReferences));
FarDataSource dataSource = new FarDataSource(1);
dataSource.Snapshots[0] = new FarDataSnapshot(definitions);
IFindAllReferencesWindow farWindow = farService.StartSearch(definitions[0].Type);
ITableManager _farManager = farWindow.Manager;
_farManager.AddSource(dataSource);
dataSource.Sink.IsStable = false;
dataSource.Sink.AddSnapshot(dataSource.Snapshots[0]);
dataSource.Sink.IsStable = true;
return(VSConstants.S_OK);
}
}
return(Next?.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut) ?? (int)Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_NOTSUPPORTED);
}
public BindingPaneControl(IServiceProvider serviceProvider, BindingPaneViewModel viewModel)
{
IComponentModel componentModel = serviceProvider.GetService <SComponentModel, IComponentModel>();
ITableManagerProvider tableManagerProvider = componentModel.GetService <ITableManagerProvider>();
IWpfTableControlProvider tableControlProvider = componentModel.GetService <IWpfTableControlProvider>();
this.ViewModel = viewModel;
this.tableDataSource = new TableDataSource(this.ViewModel.Entries);
this.tableManager = tableManagerProvider.GetTableManager(Constants.TableManagerString);
this.tableManager.AddSource(this.tableDataSource, ColumnNames.DefaultSet.ToArray());
this.TableControl = tableControlProvider.CreateControl(this.tableManager, true,
ColumnNames.DefaultSet.Select(n => new ColumnState2(n, isVisible: true, width: 0)),
ColumnNames.DefaultSet.ToArray());
this.InitializeComponent();
this.tableHolder.Child = this.TableControl.Control;
}
private static int ShowInFar(string title, List <Definition> definitions)
{
IFindAllReferencesService farService = ServiceUtil.GetService <SVsFindAllReferences, IFindAllReferencesService>();
FarDataSource dataSource = new FarDataSource(1);
dataSource.Snapshots[0] = new FarDataSnapshot(definitions);
IFindAllReferencesWindow farWindow = farService.StartSearch(title);
ITableManager _farManager = farWindow.Manager;
_farManager.AddSource(dataSource);
dataSource.Sink.IsStable = false;
dataSource.Sink.AddSnapshot(dataSource.Snapshots[0]);
dataSource.Sink.IsStable = true;
return(VSConstants.S_OK);
}
internal virtual void RequestSubscr(ITableManager table, Lightstreamer.DotNet.Client.SubscribedTableKey subscrKey, BatchMonitor batch)
{
string winCode = subscrKey.KeyValue.ToString();
this.Check();
try
{
this.serverTranslator.CallTableRequest(this.serverInfo, winCode, table, batch);
}
catch (IOException exception)
{
throw new PushConnException(exception);
}
catch (WebException exception2)
{
throw new PushConnException(exception2);
}
this.Check();
}
public void SelectDateTime()
{
TableSchema schema = CreateSchema("test1");
ITableManager mgr = myScriptingInterface.GetManager(schema);
mgr.CreateTable();
// add some data
ScopedTable table = mgr.Query(0);
AddRow(table, 0, DateTime.Now, 25);
// select
var rows = mgr.Query(0, new DateClause(DateTime.Now)).Rows.ToList();
Assert.AreEqual(1, rows.Count);
Assert.AreEqual(25, rows[0]["value"]);
}
public EntityWithTable(
EntityClass entity,
ITableManager t,
bool isTopTable = true)
{
Entity = entity;
if (!Entity.NoSave)
{
Table = t.New(entity, isTopTable, !Entity.Lists.Any(), entity.PrimaryKeyIndex);
}
foreach (var e in entity.Lists)
{
Lists.Add(new EntityWithTable(e, t, false));
}
if (entity.AggregationFields.Any())
{
Aggregator = new Aggregator(entity.AggregationFields.ToArray(), entity.ParentEffectiveFieldCount);
}
}
internal HighlightInvalidKeyrefTaggerProvider([Import] ITableManagerProvider provider, [Import] ITextDocumentFactoryService textDocumentFactoryService, [Import] IClassifierAggregatorService classifierAggregatorService)
{
this.ErrorTableManager = provider.GetTableManager(StandardTables.ErrorsTable);
this.TextDocumentFactoryService = textDocumentFactoryService;
// this.ClassifierAggregatorService = classifierAggregatorService;
this.ErrorTableManager.AddSource(this, StandardTableColumnDefinitions.DetailsExpander,
StandardTableColumnDefinitions.ErrorSeverity, StandardTableColumnDefinitions.ErrorCode,
StandardTableColumnDefinitions.ErrorSource, StandardTableColumnDefinitions.BuildTool,
StandardTableColumnDefinitions.ErrorSource, StandardTableColumnDefinitions.ErrorCategory,
StandardTableColumnDefinitions.Text, StandardTableColumnDefinitions.DocumentName,
StandardTableColumnDefinitions.Line, StandardTableColumnDefinitions.Column);
if (Debugger.IsAttached)
{
AppDomain.CurrentDomain.FirstChanceException += (sender, ea) => Debug.Print(ea.Exception.ToString());
}
}
public TableViewModel(IMessageBoxService messageBoxService, Table table, ITableManager manager, IAreaManager areaManager) : base(messageBoxService, table, manager)
{
// do initialization
try
{
if (areaManager == null)
{
throw new ArgumentNullException("areaManager");
}
_areaManager = areaManager;
// populate the list of areas
this.AreaList = _areaManager.GetList();
this.DisplayName = "Edit Table: " + this.Item.Name;
}
catch (Exception ex)
{
this.MessageBoxService.ShowError(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
}
}
public SqlTable(
ITableManager tableManager,
EntityClass entity,
bool isTopTable,
bool isLeafTable,
int primaryKeyIndex,
int flushThreshold)
{
TableManager = tableManager;
_flushThreshold = flushThreshold;
Name = entity.TableName;
IsTopTable = isTopTable;
IsLeafTable = isLeafTable;
PrimaryKeyIndex = primaryKeyIndex;
Fields = entity.Fields.Where(_ => !_.NoSave).Select(_ => new NameAndType(_.ExternalName, _.FieldType)).ToList();
if (Fields.Any(_ => string.IsNullOrEmpty(_.Name)))
{
throw new ArgumentException($"Table {Name} contains empty column name");
}
_dataTable = new DataTable();
if (AutomaticPrimaryKey)
{
_dataTable.Columns.Add("_id_", typeof(Guid)).AllowDBNull = false;
}
if (!IsTopTable)
{
ForeignKeyName = entity.ForeignKeyName;
var dc = _dataTable.Columns.Add(ForeignKeyName, entity.ForeignKeyType);
if (entity.ForeignKeyType == typeof(string))
{
dc.MaxLength = 100;
}
dc.AllowDBNull = false;
}
foreach (var field in Fields)
{
var dc = _dataTable.Columns.Add(field.Name, LinkedFieldInfo.StripNullable(field.Type));
dc.AllowDBNull = field.Type == typeof(string) || field.Type == typeof(byte[]) || field.Type != LinkedFieldInfo.StripNullable(field.Type);
}
}
public ITableManager GetManager(TableSchema schema)
{
ITableManager mgr = null;
if (myManagers.ContainsKey(schema.Name))
{
mgr = myManagers[schema.Name];
}
else if (schema.IsPersistent)
{
mgr = new PersistentTableManager(myPersistentDB, schema);
myManagers.Add(schema.Name, mgr);
}
else
{
mgr = new InMemoryTableManager(myInMemoryDB, schema);
myManagers.Add(schema.Name, mgr);
}
return(mgr);
}
public ITableManager GetManager(string tableName)
{
ITableManager mgr = null;
if (myManagers.ContainsKey(tableName))
{
mgr = myManagers[tableName];
}
else if (myInMemoryDB.Tables.Contains(tableName))
{
mgr = new InMemoryTableManager(myInMemoryDB, myInMemoryDB.Tables[tableName]);
myManagers.Add(tableName, mgr);
}
else if (myPersistentDB.ExistsTable(tableName))
{
mgr = new PersistentTableManager(myPersistentDB, tableName);
myManagers.Add(tableName, mgr);
}
return(mgr);
}
public void CreateTable()
{
TableSchema schema = CreateSchema("test1");
Assert.AreEqual(ValidationResult.None, schema.Validate());
ITableManager mgr = myScriptingInterface.GetManager(schema);
Assert.IsNotNull(mgr);
Assert.That(mgr, Is.InstanceOf(myIsPersistent ? typeof(PersistentTableManager) : typeof(InMemoryTableManager)));
mgr.CreateTable();
// now we should be able to get the manager by name
mgr = myScriptingInterface.GetManager("test1");
Assert.IsNotNull(mgr);
Assert.AreEqual("test1", mgr.Name);
// but of course not using the wrong name
Assert.IsNull(myScriptingInterface.GetManager("test2"));
}
public void AddWithNoDate()
{
TableSchema schema = CreateSchema("test1");
ITableManager mgr = myScriptingInterface.GetManager(schema);
mgr.CreateTable();
// add some data
using (TransactionScope trans = new TransactionScope())
{
var table = mgr.Query(0);
AddRow(table, 0, new DateTime(2001, 1, 1), 1);
AddRow(table, 0, new DateTime(2002, 1, 1), 2);
// refetch
table = mgr.Query(0);
// add two times without date
DataRow row = table.NewRow();
row[table.Schema.OwnerIdColumn] = 0;
row["Value"] = 33;
table.Add(row);
row = table.NewRow();
row[table.Schema.OwnerIdColumn] = 0;
row["Value"] = 44;
table.Add(row);
trans.Complete();
}
// check modifications
var rows = mgr.Query(0).Rows.ToList();
Assert.AreEqual(4, rows.Count);
Assert.AreEqual(1, rows[0]["value"]);
Assert.AreEqual(2, rows[1]["value"]);
Assert.AreEqual(33, rows[2]["value"]);
Assert.AreEqual(44, rows[3]["value"]);
}
public TablesManagementViewModel(IMessageBoxService messageBoxService, IUIVisualizerService uiVisualizerService,
ITableManager tableManager, IAreaManager areaManager) : base(messageBoxService, uiVisualizerService, tableManager)
{
// do initialization
try
{
if (areaManager == null)
{
throw new ArgumentNullException("areaManager");
}
_areaManager = areaManager;
// get list
this.DisplayName = "Tables Management";
this.Items = new System.Collections.ObjectModel.ObservableCollection <Table>(GetItems());
AreaListViewModel = new AreaListViewModel(this.MessageBoxService, this.UIVisualizerService, _areaManager);
}
catch (Exception ex)
{
this.MessageBoxService.ShowError(this.GetType().FullName + System.Reflection.MethodBase.GetCurrentMethod().Name + ": " + ex.Message);
}
}
public void Modify()
{
TableSchema schema = CreateSchema("test1");
ITableManager mgr = myScriptingInterface.GetManager(schema);
mgr.CreateTable();
// add some data
var table = mgr.Query(0);
AddRow(table, 0, new DateTime(2001, 1, 1), 1);
AddRow(table, 0, new DateTime(2002, 1, 1), 2);
AddRow(table, 0, new DateTime(2003, 1, 1), 3);
AddRow(table, 1, new DateTime(2010, 1, 1), 2);
// modify some data
{
table = mgr.Query(0);
// modify
table.Rows.First()["value"] = 25;
// delete
var row1 = table.Rows.ElementAt(1);
var row2 = table.Rows.ElementAt(2);
row1.Delete();
row2.Delete();
// add
AddRow(table, 0, new DateTime(2004, 1, 1), 4);
}
// check modifications
var rows = mgr.Query(0).Rows.ToList();
Assert.AreEqual(2, rows.Count);
Assert.AreEqual(25, rows[0]["value"]);
Assert.AreEqual(4, rows[1]["value"]);
}
/// <summary>
/// create a new object with given attributes
/// </summary>
/// <param name="provider"></param>
/// <param name="fullTablename"></param>
/// <param name="useQuote"></param>
public TableManager(DatabaseProvider provider, string fullTablename, bool useQuote)
{
this.provider = provider;
switch (provider)
{
case DatabaseProvider.SqlClient:
case DatabaseProvider.OleDb:
tableConvention = new SqlClient.TableManager(string.Empty, useQuote);
break;
case DatabaseProvider.SQLite:
tableConvention = new SQLiteClient.TableManager(string.Empty, useQuote);
break;
default:
throw new ArgumentOutOfRangeException("unsupported : " + provider);
}
UseQuote = useQuote;
FullTablename = fullTablename;
}
public void ReadAfterDelete()
{
ITableManager mgr = myScriptingInterface.GetManager(CreateSchema("test1"));
mgr.CreateTable();
// add some data -> no commit
var table = mgr.Query(0);
AddRow(table, 0, new DateTime(2001, 1, 1), 1);
AddRow(table, 0, new DateTime(2002, 1, 1), 2);
AddRow(table, 0, new DateTime(2003, 1, 1), 3);
table.Rows.ElementAt(1).Delete();
// check modifications
var rows = table.Rows.ToList();
Assert.AreEqual(2, rows.Count);
Assert.AreEqual(1, rows[0]["value"]);
Assert.AreEqual(3, rows[1]["value"]);
}
public void AddOrUpdate()
{
TableSchema schema = CreateSchema("test1");
ITableManager mgr = myScriptingInterface.GetManager(schema);
mgr.CreateTable();
// add some data
using (TransactionScope trans = new TransactionScope())
{
var table = mgr.Query(0);
AddRow(table, 0, new DateTime(2001, 1, 1), 1);
AddRow(table, 0, new DateTime(2002, 1, 1), 2);
// add with same date
AddRow(table, 0, new DateTime(2002, 1, 1), 3);
// AddOrUpdate() with same date
var row = table.NewRow();
row[table.Schema.OwnerIdColumn] = 0;
row.SetDate(table.Schema, new DateTime(2002, 1, 1));
row["Value"] = 77;
table.AddOrUpdate(row);
trans.Complete();
}
// check modifications
var rows = mgr.Query(0).Rows.ToList();
Assert.AreEqual(3, rows.Count);
Assert.AreEqual(2001, rows[0].GetDate(schema).Year);
Assert.AreEqual(1, rows[0]["value"]);
Assert.AreEqual(2002, rows[1].GetDate(schema).Year);
Assert.AreEqual(77, rows[1]["value"]);
Assert.AreEqual(2002, rows[2].GetDate(schema).Year);
Assert.AreEqual(77, rows[2]["value"]);
}
protected void Initialize(IReadOnlyCollection <string> columns)
{
ThreadHelper.ThrowIfNotOnUIThread();
var compositionService = ServiceProvider.GlobalProvider.GetService(typeof(SComponentModel)) as IComponentModel;
// The composition service will only be null in unit tests.
if (compositionService == null)
{
return;
}
compositionService.DefaultCompositionService.SatisfyImportsOnce(this);
if (this.TableManagerProvider == null)
{
this.TableManagerProvider = compositionService.GetService <ITableManagerProvider>();
}
ITableManager manager = this.TableManagerProvider.GetTableManager(StandardTables.ErrorsTable);
manager.AddSource(this, columns);
}
internal static ErrorListManager RegisterProject(Microsoft.VisualStudio.Shell.IErrorList errorList, XSharpProjectNode project)
{
lock (_gate)
{
if (_provider == null)
{
_errorList = errorList;
_manager = errorList.TableControl.Manager;
_provider = new ErrorListProvider(_manager);
_errorList.PropertyChanged += _errorList_PropertyChanged;
}
}
if (!_projects.ContainsKey(project.ProjectIDGuid))
{
var entry = new ErrorListManager(project);
entry.Factory = new ErrorsFactory(_provider, project.ProjectIDGuid);
_provider.AddErrorListFactory(entry.Factory);
_projects.Add(project.ProjectIDGuid, entry);
return(entry);
}
return(_projects[project.ProjectIDGuid]);
}
public virtual void OnUpdate(ITableManager table, Lightstreamer.DotNet.Client.ServerUpdateEvent values)
{
IConnectionListener activeListener = this.enclosingInstance.GetActiveListener(this.currPhase);
if (activeListener != null)
{
try
{
table.DoUpdate(values);
}
catch (PushServerException exception)
{
LSClient.actionsLogger.Debug("Error in received values", exception);
try
{
activeListener.OnDataError(exception);
}
catch (Exception)
{
}
}
}
}
public LintCheckerProvider
(
[Import] ITableManagerProvider provider,
[Import] ITextDocumentFactoryService textDocumentFactoryService
)
{
this.TextDocumentFactoryService = textDocumentFactoryService;
this.ErrorTableManager = provider.GetTableManager(StandardTables.ErrorsTable);
this.ErrorTableManager.AddSource(this,
StandardTableColumnDefinitions.DetailsExpander,
StandardTableColumnDefinitions.ErrorSeverity,
StandardTableColumnDefinitions.ErrorCode,
StandardTableColumnDefinitions.ErrorSource,
StandardTableColumnDefinitions.BuildTool,
StandardTableColumnDefinitions.ErrorSource,
StandardTableColumnDefinitions.ErrorCategory,
StandardTableColumnDefinitions.Text,
StandardTableColumnDefinitions.DocumentName,
StandardTableColumnDefinitions.Line,
StandardTableColumnDefinitions.Column,
StandardTableColumnDefinitions.ProjectName
);
}
public void SelectFromTo()
{
TableSchema schema = CreateSchema("test1");
ITableManager mgr = myScriptingInterface.GetManager(schema);
mgr.CreateTable();
// add some data
ScopedTable table = mgr.Query(0);
AddRow(table, 0, new DateTime(2001, 1, 1), 1);
AddRow(table, 0, new DateTime(2002, 1, 1), 2);
AddRow(table, 0, new DateTime(2003, 1, 1), 3);
AddRow(table, 0, new DateTime(2004, 1, 1), 4);
AddRow(table, 0, new DateTime(2005, 1, 1), 5);
table = mgr.Query(1);
AddRow(table, 1, new DateTime(2005, 1, 1), 22);
// select
var rows = mgr.Query(0, new DateClause(new DateTime(2002, 1, 1), new DateTime(2005, 1, 1))).Rows.ToList();
Assert.AreEqual(4, rows.Count);
Assert.AreEqual(2002, rows[0].GetDate(schema).Year);
Assert.AreEqual(2003, rows[1].GetDate(schema).Year);
Assert.AreEqual(2004, rows[2].GetDate(schema).Year);
Assert.AreEqual(2005, rows[3].GetDate(schema).Year);
Assert.IsTrue(rows.All(r => r.RowState == DataRowState.Unchanged));
// select with swapped to and from to check robustnes
rows = mgr.Query(0, new DateClause(new DateTime(2005, 1, 1), new DateTime(2002, 1, 1))).Rows.ToList();
Assert.AreEqual(4, rows.Count);
Assert.AreEqual(2002, rows[0].GetDate(schema).Year);
Assert.AreEqual(2003, rows[1].GetDate(schema).Year);
Assert.AreEqual(2004, rows[2].GetDate(schema).Year);
Assert.AreEqual(2005, rows[3].GetDate(schema).Year);
}
// Lock before calling
private void EnsureInitialized()
{
if (!_initialized)
{
// Double check around locking since this is called often.
lock (_initLockObj)
{
if (!_initialized)
{
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await NuGetUIThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
// Get the error list service from the UI thread
_errorList = await _asyncServiceProvider.GetServiceAsync <SVsErrorList, IErrorList>();
_tableManager = _errorList.TableControl.Manager;
_tableManager.AddSource(this);
_initialized = true;
});
}
}
}
}
public TaggerProvider(
[Import] ITableManagerProvider tableManagerProvider,
[Import] ITextDocumentFactoryService textDocumentFactoryService,
[Import] IVisualLinterOptions options,
[Import] ILinter linter)
{
_tableManager = tableManagerProvider
.GetTableManager(StandardTables.ErrorsTable);
_textDocumentFactoryService = textDocumentFactoryService;
_linter = linter;
_optionsMap.Add(".html", () => options.EnableHtmlLanguageSupport);
_optionsMap.Add(".js", () => options.EnableJavaScriptLanguageSupport);
_optionsMap.Add(".jsx", () => options.EnableReactLanguageSupport);
_optionsMap.Add(".vue", () => options.EnableVueLanguageSupport);
_optionsMap.Add(".ts", () => options.EnableTypeScriptLanguageSupport);
_optionsMap.Add(".tsx", () => options.EnableTypeScriptReactLanguageSupport);
var columns = new[]
{
StandardTableColumnDefinitions.BuildTool,
StandardTableColumnDefinitions.Column,
StandardTableColumnDefinitions.DetailsExpander,
StandardTableColumnDefinitions.DocumentName,
StandardTableColumnDefinitions.ErrorCategory,
StandardTableColumnDefinitions.ErrorCode,
StandardTableColumnDefinitions.ErrorSeverity,
StandardTableColumnDefinitions.ErrorSource,
StandardTableColumnDefinitions.Line,
StandardTableColumnDefinitions.Text
};
_tableManager.AddSource(this, columns);
}
public virtual void OnUpdate(ITableManager table, Lightstreamer.DotNet.Client.ServerUpdateEvent values)
{
IConnectionListener activeListener = this.enclosingInstance.GetActiveListener(this.currPhase);
if (activeListener != null)
{
try
{
table.DoUpdate(values);
}
catch (PushServerException exception)
{
LSClient.actionsLogger.Debug("Error in received values", exception);
try
{
activeListener.OnDataError(exception);
}
catch (Exception)
{
}
}
}
}
internal virtual void CallTableRequest(PushServerProxy.PushServerProxyInfo pushInfo, string tableCode, ITableManager table, BatchMonitor batch)
{
IDictionary parameters = new Dictionary<string, string>();
parameters["LS_session"] = pushInfo.sessionId;
parameters["LS_op"] = "add";
parameters["LS_table"] = tableCode;
parameters["LS_id"] = table.Group;
parameters["LS_mode"] = table.Mode;
parameters["LS_schema"] = table.Schema;
if (table.DataAdapter != null)
{
parameters["LS_data_adapter"] = table.DataAdapter;
}
if (table.Selector != null)
{
parameters["LS_selector"] = table.Selector;
}
if (table.Snapshot)
{
if (table.DistinctSnapshotLength != -1)
{
parameters["LS_Snapshot"] = table.DistinctSnapshotLength.ToString();
}
else
{
parameters["LS_Snapshot"] = "true";
}
}
if (table.Start != -1)
{
parameters["LS_start"] = table.Start.ToString();
}
if (table.End != -1)
{
parameters["LS_end"] = table.End.ToString();
}
if (table.Unfiltered)
{
parameters["LS_requested_max_frequency"] = "unfiltered";
}
else if (!(table.MaxFrequency == -1.0))
{
parameters["LS_requested_max_frequency"] = table.MaxFrequency.ToString();
}
if (table.MaxBufferSize != -1)
{
parameters["LS_requested_buffer_size"] = table.MaxBufferSize.ToString();
}
this.DoControlRequest(pushInfo, parameters, batch);
}
public virtual bool OnUpdate(ITableManager table, Lightstreamer.DotNet.Client.ServerUpdateEvent values)
{
if (this.owner.GetActiveListener(this.currPhase) != null)
{
try
{
table.DoUpdate(values);
}
catch (PushServerException exception)
{
actionsLogger.Debug("Error in received values", exception);
this.OnDataError(exception);
}
return true;
}
return false;
}
internal virtual Lightstreamer.DotNet.Client.SubscribedTableKey SubscrTable(ITableManager table, bool batchable)
{
Lightstreamer.DotNet.Client.SubscribedTableKey subscrKey;
object CS$2$0002;
actionsLogger.Info(string.Concat(new object[] { "Adding ", table, " to session ", this.localPushServerProxy.SessionId }));
lock ((CS$2$0002 = this.tables.SyncRoot))
{
subscrKey = this.localPushServerProxy.TableCode;
this.tables[subscrKey.KeyValue] = table;
}
bool ok = false;
try
{
this.localPushServerProxy.RequestSubscr(table, subscrKey, batchable ? this.batchMonitor : null);
ok = true;
}
finally
{
if (!ok)
{
actionsLogger.Info(string.Concat(new object[] { "Undoing add of ", table, " to session ", this.localPushServerProxy.SessionId }));
lock ((CS$2$0002 = this.tables.SyncRoot))
{
this.tables.Remove(subscrKey.KeyValue);
}
}
}
return subscrKey;
}
internal virtual ITableManager[] DetachTables(Lightstreamer.DotNet.Client.SubscribedTableKey[] subscrKeys)
{
int i;
ITableManager[] infos = new ITableManager[subscrKeys.Length];
lock (this.tables.SyncRoot)
{
i = 0;
while (i < subscrKeys.Length)
{
if (subscrKeys[i].KeyValue != -1)
{
object tempObject = this.tables[subscrKeys[i].KeyValue];
this.tables.Remove(subscrKeys[i].KeyValue);
infos[i] = (ITableManager) tempObject;
}
else
{
infos[i] = null;
}
i++;
}
}
if (actionsLogger.IsInfoEnabled)
{
for (i = 0; i < subscrKeys.Length; i++)
{
actionsLogger.Info(string.Concat(new object[] { "Removed ", infos[i], " from session ", this.localPushServerProxy.SessionId }));
}
}
return infos;
}
public ReservationsController(ApplicationDbContext context, UserManager <ApplicationUser> userManager,
IOrderManager orderManager, IBusinessManager businessManager, IReservationManager reservationManager, ITableManager tableManager)
{
_context = context;
_orderManager = orderManager;
_businessManager = businessManager;
_reservationManager = reservationManager;
_userManager = userManager;
_tableManager = tableManager;
}
internal ErrorListProvider(ITableManager manager)
{
tableManager = manager;
this.AddSource();
}
internal virtual ITableManager[] DetachTables(Lightstreamer.DotNet.Client.SubscribedTableKey[] subscrKeys)
{
int num;
ITableManager[] managerArray = new ITableManager[subscrKeys.Length];
lock (this.tables.SyncRoot)
{
num = 0;
while (num < subscrKeys.Length)
{
if (subscrKeys[num].KeyValue != -1)
{
object obj2 = this.tables[subscrKeys[num].KeyValue];
this.tables.Remove(subscrKeys[num].KeyValue);
managerArray[num] = (ITableManager) obj2;
}
else
{
managerArray[num] = null;
}
num++;
}
}
if (actionsLogger.IsInfoEnabled)
{
for (num = 0; num < subscrKeys.Length; num++)
{
actionsLogger.Info(string.Concat(new object[] { "Removed ", managerArray[num], " from session ", this.localPushServerProxy.SessionId }));
}
}
return managerArray;
}
internal virtual Lightstreamer.DotNet.Client.SubscribedTableKey SubscrTable(ITableManager table, bool batchable)
{
Lightstreamer.DotNet.Client.SubscribedTableKey tableCode;
object obj2;
actionsLogger.Info(string.Concat(new object[] { "Adding ", table, " to session ", this.localPushServerProxy.SessionId }));
lock ((obj2 = this.tables.SyncRoot))
{
tableCode = this.localPushServerProxy.TableCode;
this.tables[tableCode.KeyValue] = table;
}
bool flag = false;
try
{
this.localPushServerProxy.RequestSubscr(table, tableCode, batchable ? this.batchMonitor : null);
flag = true;
}
finally
{
if (!flag)
{
actionsLogger.Info(string.Concat(new object[] { "Undoing add of ", table, " to session ", this.localPushServerProxy.SessionId }));
lock ((obj2 = this.tables.SyncRoot))
{
this.tables.Remove(tableCode.KeyValue);
}
}
}
return tableCode;
}
public override void SetUp()
{
base.SetUp();
myDB = myMockery.NewMock<IDatabaseSC>();
var serviceProvider = new ServiceProvider();
serviceProvider.RegisterService( "TOM Database", myDB );
myScriptingInterface = new ScriptingInterface();
myScriptingInterface.Init( serviceProvider );
// prepare data
mySchema = CreateSchema( "test1" );
myMgr = myScriptingInterface.GetManager( mySchema );
myMgr.CreateTable();
// add some data
ScopedTable table = myMgr.Query( 0 );
AddRow( table, 0, 0, new DateTime( 2001, 1, 1 ), 1 );
AddRow( table, 0, 0, new DateTime( 2002, 1, 1 ), 2 );
AddRow( table, 0, 1, new DateTime( 2002, 1, 1 ), 12 );
AddRow( table, 0, 0, new DateTime( 2003, 1, 1 ), 3 );
AddRow( table, 0, 1, new DateTime( 2003, 1, 1 ), 13 );
AddRow( table, 0, 2, new DateTime( 2003, 1, 1 ), 23 );
AddRow( table, 0, 0, new DateTime( 2004, 1, 1 ), 4 );
AddRow( table, 0, 1, new DateTime( 2005, 1, 1 ), 15 );
table = myMgr.Query( 1 );
AddRow( table, 1, 1, new DateTime( 2002, 1, 1 ), 112 );
}
public ReservationDetailsViewModel(IUnityContainer container, ILoggerFacade logger, IReservationManager reservationManager, ITableManager tableManager, IMessageBoxService messageBoxService, IDialogBoxService dialogBoxService)
{
this._logger = logger;
this._container = container;
this._reservationManager = reservationManager;
this._tableManager = tableManager;
this._messageBoxService = messageBoxService;
this._dialogBoxService = dialogBoxService;
var allTables = this._tableManager.GetAll().ToDictionary(tbl => tbl.TableId, tbl => tbl);
// Assumption : Reservation duration is between 10 Am and 10 Pm
this._minFromHour = 10;
this._maxFromHour = 22;
this._reservedTables = new ObservableCollection<Table>();
var currentReservation = this._container.Resolve(typeof(Reservation), "SelectedReservation");
if (currentReservation != null)
{
this.FromHour = (short)(currentReservation as Reservation).TimeFrom;
this.ToHour = (short)(currentReservation as Reservation).TimeTo;
this._currentReservation = currentReservation as Reservation;
this._currentReservation.PropertyChanged += _currentReservation_PropertyChanged;
foreach (var tableId in this._currentReservation.ReservedTableIds)
{
this._reservedTables.Add(allTables[tableId]);
}
this._availableTables = new ObservableCollection<Table>(this.GetAvailableTables((ushort)this._fromHour, (ushort)this._toHour));
if (this._availableTables != null && this._availableTables.Count > 0)
{
this._selectedAvailableTable = this._availableTables.First();
}
}
else
{
this.FromHour = this._minFromHour;
}
if (this._reservedTables != null && this._reservedTables.Count > 0)
{
this._selectedReservedTable = this._reservedTables.First();
}
this.SaveCommand = new DelegateCommand(this.OnSaveCommand, () =>
{
return this._currentReservation != null &&
this._reservedTables != null &&
this._reservedTables.Count > 0 &&
!string.IsNullOrEmpty(this._currentReservation.CustomerName) &&
!string.IsNullOrEmpty(this._currentReservation.ContactNumber);
});
this.CancelCommand = new DelegateCommand(this.OnCancelCommand, () => { return this._currentReservation != null; });
this.ReserveTableCommand = new DelegateCommand(this.OnReserveTableCommand, () =>
{
return this._currentReservation != null &&
this._selectedAvailableTable != null &&
this._currentReservation.NoOfPersons > this._reservedTables.Sum(tbl => tbl.MaxOccupancy);
});
this.UnreserveTableCommand = new DelegateCommand(this.OnUnreserveTableCommand, () =>
{
return this._currentReservation != null &&
this._selectedReservedTable != null;
});
}
internal virtual void RequestSubscr(ITableManager table, Lightstreamer.DotNet.Client.SubscribedTableKey subscrKey, BatchMonitor batch)
{
string winCode = subscrKey.KeyValue.ToString();
this.Check();
try
{
this.serverTranslator.CallTableRequest(this.serverInfo, winCode, table, batch);
}
catch (IOException exception)
{
throw new PushConnException(exception);
}
catch (WebException exception2)
{
throw new PushConnException(exception2);
}
this.Check();
}
