private void ConfigureWebApi(IAppBuilder appBuilder)
{
HttpConfiguration config = new HttpConfiguration();
bool bound = ObjectEx.GetAndReplace(ref _boundTypes, true);
if (bound == false)
{
_kernel.Bind <DefaultModelValidatorProviders>().ToConstant(new DefaultModelValidatorProviders(config.Services.GetServices(typeof(ModelValidatorProvider)).Cast <ModelValidatorProvider>()));
_kernel.Bind <DefaultFilterProviders>().ToConstant(new DefaultFilterProviders(new[] { new NinjectFilterProvider(_kernel) }.AsEnumerable()));
}
config.MapHttpAttributeRoutes();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var cors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*");
config.EnableCors(cors);
config.DependencyResolver = new Ninject.Web.WebApi.NinjectDependencyResolver(_kernel);
Formatters.ForEach(config.Formatters.Add);
config.Formatters.OfType <JsonMediaTypeFormatter>().ForEach(formatter =>
{
formatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
Converters.ForEach(formatter.SerializerSettings.Converters.Add);
});
appBuilder.UseWebApi(config);
}
private void UpdateDefinitions(Dictionary <string, SessionDefinition> currentDefinitions)
{
var previousDefinitions = ObjectEx.GetAndReplace(ref _definitions, currentDefinitions);
if (previousDefinitions != null && previousDefinitions.Any())
{
var addedDefinitions = currentDefinitions.Where(kvp => previousDefinitions.ContainsKey(kvp.Key) == false ||
previousDefinitions[kvp.Key].CreatedAt != kvp.Value.CreatedAt)
.Select(kvp => kvp.Value)
.OrderBy(definition => definition.CreatedAt)
.ToList();
var removedDefinitions = previousDefinitions.Where(kvp => currentDefinitions.ContainsKey(kvp.Key) == false ||
currentDefinitions[kvp.Key].CreatedAt != kvp.Value.CreatedAt)
.Select(kvp => kvp.Value)
.ToList();
if (addedDefinitions.Any() || removedDefinitions.Any())
{
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .Create(addedDefinitions, removedDefinitions));
}
}
else if (currentDefinitions.Any())
{
DefinitionsChanged?.Invoke(this, CollectionChangedEventArgs <SessionDefinition> .CreateForAddedCollection(currentDefinitions.Values.OrderBy(d => d.CreatedAt)));
}
}
public void Stop()
{
var subscription = ObjectEx.GetAndReplace(ref _subscription, null);
subscription?.Dispose();
State = ControlServiceState.Stopped;
}
private void Close()
{
ObjectEx.GetAndReplace(ref _deviceObserver, null);
if (_deviceObserver != null)
{
_observers.Disconnect(_deviceObserver);
}
}
public bool DisconnectDevice()
{
var hook = ObjectEx.GetAndReplace(ref _hook, null) as IDisposable;
if (hook != null)
{
hook.Dispose();
}
return(true);
}
private void CloseHostWindow()
{
var hostWindow = ObjectEx.GetAndReplace(ref _sessionHostWindow, null);
if (hostWindow != null)
{
hostWindow.Closed -= SessionHostWindow_Closed;
hostWindow.Close();
}
}
private void HideTray()
{
var tb = ObjectEx.GetAndReplace(ref icon, null);
if (tb != null && tb.IsDisposed == false)
{
//tb.HideBalloonTip();
tb.Dispose();
}
}
public async Task StopCalibrationAsync()
{
if (IsCalibrating)
{
var calibration = ObjectEx.GetAndReplace(ref _calibration, null);
await calibration.LeaveCalibrationModeAsync();
calibration.Dispose();
}
}
public void Stop()
{
ResetUpload();
bool wasEnabled = ObjectEx.GetAndReplace(ref isEnabled, false);
if (wasEnabled)
{
IsEnabledChanged?.Invoke(this, false);
}
}
public override SessionStepResult Complete()
{
// reset taskbar state to the previous value
var taskbar = ObjectEx.GetAndReplace(ref _taskbar, null);
if (taskbar != null)
{
Task.Run(() => taskbar.Reset()).Forget();
}
return(base.Complete());
}
// add enable, because auto start does not wait before upload - same call like from UI
public void Start()
{
bool wasEnabled = ObjectEx.GetAndReplace(ref isEnabled, true);
if (wasEnabled == false || IsWorking == false)
{
IsEnabledChanged?.Invoke(this, true);
_timeoutStepper.Reset();
StartUpload(false);
}
}
public bool DisconnectDevice()
{
var tracker = ObjectEx.GetAndReplace(ref _connectedTracker, null);
if (tracker != null)
{
DetachEventHandlers(tracker);
tracker.Dispose();
OnCanCalibrateChanged();
}
return(true);
}
public void Stop()
{
var server = ObjectEx.GetAndReplace(ref _server, null);
if (server != null)
{
server.Dispose();
}
bool bound = ObjectEx.GetAndReplace(ref _boundTypes, false);
if (bound)
{
_kernel.Unbind <DefaultModelValidatorProviders>();
_kernel.Unbind <DefaultFilterProviders>();
}
}
//private void Process_OutputDataReceived(object sender, DataReceivedEventArgs e)
//{
// _outputData.Append(e.Data);
//}
//private void Process_ErrorDataReceived(object sender, DataReceivedEventArgs e)
//{
// _errorData.Append(e.Data);
//}
public override SessionStepResult Complete()
{
var process = ObjectEx.GetAndReplace(ref _process, null);
try
{
if (process != null && _settings.KeepRunning == false)
{
process.Exited -= process_Exited;
_service.CloseProcess(process, _settings.ForceClose);
process.Dispose();
}
}
catch (Exception)
{
// TODO log exception
}
return(base.Complete());
}
private void CloseWindow()
{
var window = ObjectEx.GetAndReplace(ref _window, null);
window?.Close();
}
private void ClearEnumerator()
{
var enumerator = ObjectEx.GetAndReplace(ref _sequenceEnumerator, null);
enumerator?.Dispose();
}
public void Disconnect()
{
var connection = ObjectEx.GetAndReplace(ref _connection, null);
connection?.Dispose();
}
