public ConnectionTests()
{
_typesContainer =
new TypesContainer(Program.GetApp().Container.Resolve(typeof(IUnityContainer)) as IUnityContainer);
_device = Program.GetDevice();
_configuration = _device.DeviceFragments.First(fragment => fragment.StrongName == "Configuration") as
IDeviceConfiguration;
_shell = _typesContainer.Resolve <ShellViewModel>();
_deviceViewModelFactory = _typesContainer.Resolve <IDeviceViewModelFactory>();
var deviceMemory = new DeviceMemory();
_typesContainer.Resolve <IDevicesContainerService>()
.AddConnectableItem(_device);
_device.DeviceMemory = deviceMemory;
_deviceViewModel = _shell.ProjectBrowserViewModel.DeviceViewModels[0];
_configurationFragmentViewModel = null;
_configurationFragmentViewModel = _shell.ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "Configuration") as
RuntimeConfigurationViewModel;
_measuringMonitorViewModel = _shell.ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "MeasuringMonitor") as
MeasuringMonitorViewModel;
_readCommand = _configurationFragmentViewModel.FragmentOptionsViewModel.FragmentOptionGroupViewModels
.First(model => model.NameKey == "Device").FragmentOptionCommandViewModels
.First(model => model.TitleKey == ApplicationGlobalNames.UiCommandStrings.READ_STRING_KEY)
.OptionCommand as RelayCommand;
}
public IFragmentPaneViewModel GetFragmentPaneViewModel(IFragmentViewModel fragmentViewModel,
IEnumerable <IDeviceViewModel> deviceViewModels)
{
IFragmentPaneViewModel fragmentPaneViewModel = _fragmentPaneViewModelgettingFunc();
fragmentPaneViewModel.FragmentViewModel = fragmentViewModel;
IDeviceViewModel deviceViewModel = GetParentDevice(deviceViewModels, fragmentViewModel);
//событие изменения подписи устройства
void OnDeviceViewModelOnPropertyChanged(object s, PropertyChangedEventArgs e)
{
if (s is IDeviceViewModel)
{
IDeviceViewModel dvm = s as IDeviceViewModel;
if (e.PropertyName == nameof(dvm.DeviceSignature))
{
SetPaneTitle(fragmentPaneViewModel, fragmentViewModel, dvm);
}
}
}
deviceViewModel.PropertyChanged += OnDeviceViewModelOnPropertyChanged;
LocalizeDictionary.Instance.PropertyChanged += (o, e) =>
{
SetPaneTitle(fragmentPaneViewModel, fragmentViewModel, deviceViewModel);
};
SetPaneTitle(fragmentPaneViewModel, fragmentViewModel, deviceViewModel);
return(fragmentPaneViewModel);
}
private void UpdateFilterString()
{
ContentViewState currentContentViewState = this.controller.MainViewModel.CurrentContentViewState;
switch (this.controller.MainViewModel.CurrentViewState)
{
case MainViewState.PhoneTab:
{
IDeviceViewModel deviceViewModel = this.controller.MainViewModel.DeviceViewModel;
switch (currentContentViewState)
{
case ContentViewState.MusicPanel:
this.FilterString = deviceViewModel.MusicFilterString;
return;
case ContentViewState.PhotosVideosPanel:
this.FilterString = deviceViewModel.PhotosVideosFilterString;
return;
case ContentViewState.MoviesTVPanel:
this.FilterString = deviceViewModel.MoviesTVSeriesFilterString;
return;
case ContentViewState.PodcastsPanel:
this.FilterString = deviceViewModel.PodcastsFilterString;
return;
}
return;
}
case MainViewState.PCTab:
{
IMediaContentViewModel contentViewModel = this.controller.MainViewModel.ContentViewModel;
switch (currentContentViewState)
{
case ContentViewState.MusicPanel:
this.FilterString = contentViewModel.MusicFilterString;
return;
case ContentViewState.PhotosVideosPanel:
this.FilterString = contentViewModel.PhotosVideosFilterString;
return;
case ContentViewState.MoviesTVPanel:
this.FilterString = contentViewModel.MoviesTVSeriesFilterString;
return;
case ContentViewState.PodcastsPanel:
this.FilterString = contentViewModel.PodcastsFilterString;
return;
case ContentViewState.RingtonesPanel:
this.FilterString = contentViewModel.RingtonesFilterString;
return;
}
return;
}
}
}
public static IDeviceViewModel ResolveIDeviceViewModel(IMainController controller)
{
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel(controller);
}
return(deviceViewModel);
}
public async Task LoadAllFromDeviceJournal()
{
Program.CleanProject();
var serializerService = Program.GetApp().Container.Resolve <ISerializerService>();
var device = serializerService.DeserializeFromFile <IDevice>("FileAssets/МР301_JA.json") as DefaultDevice;
StaticContainer.Container.Resolve <IDevicesContainerService>()
.AddConnectableItem(device);
var shell = StaticContainer.Container.Resolve <ShellViewModel>();
var queryDefinitions = await QueryUtils.ReadQueryMockDefinitionFromFile("FileAssets/logFileForMR301JS.txt");
await StaticContainer.Container.Resolve <IDevicesContainerService>()
.ConnectDeviceAsync(device, new MockConnectionWithSetup(queryDefinitions));
var journalViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0].FragmentViewModels
.First(model => model.NameForUiKey == "UniconJournal(Журнал системы)") as
UniconJournalViewModel;
IDeviceViewModel deviceViewModel = shell.ProjectBrowserViewModel.DeviceViewModels[0];
var serializerServiceMock = new SerializerServiceMock();
var loadAllViewModel =
new LoadAllFromDeviceWindowViewModelFactory(StaticContainer.Container.Resolve <ILoadAllService>(),
serializerServiceMock)
.CreateLoadAllFromDeviceWindowViewModel(
device,
deviceViewModel);
Assert.True(loadAllViewModel.LoadFragmentViewModels.Count == 3);
loadAllViewModel.PathToFolderToSave = Directory.GetCurrentDirectory();
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerServiceMock.SerializedObjects.Count == 0);
loadAllViewModel.LoadFragmentViewModels.First(model => model.FragmentName == "UniconJournal(Журнал системы)").IsSelectedForLoading = true;
loadAllViewModel.SaveToFolderCommand.Execute(null);
await TestsUtils.WaitUntil(() => loadAllViewModel.SaveToFolderCommand.CanExecute(null));
Assert.True(serializerServiceMock.SerializedObjects.Count == 1);
Assert.True(((UniconJournal)serializerServiceMock.SerializedObjects[0]).JournalRecords.Count == 511);
}
/// <summary> Connects a device. </summary>
/// <param name="serialNo"> The serial no. </param>
private void ConnectDevice(string serialNo)
{
// unload device if not desired type
if (_genericDevice != null)
{
if (_genericDevice.CoreDevice.DeviceID == serialNo)
{
return;
}
DisconnectDevice();
}
// create new device
IGenericCoreDeviceCLI device = DeviceFactory.CreateDevice(serialNo);
GenericDeviceHolder devices = new GenericDeviceHolder(device);
_genericDevice = devices[1];
if (_genericDevice == null)
{
MessageBox.Show("Unknown Device Type");
return;
}
// connect device
try
{
_genericDevice.CoreDevice.Connect(serialNo);
// wait for settings to be initialized
_genericDevice.Device.WaitForSettingsInitialized(5000);
}
catch (DeviceException ex)
{
MessageBox.Show(ex.Message);
return;
}
// create view via factory
// get factory
IUIFactory factory = DeviceManager.GetUIFactory(_genericDevice.CoreDevice.DeviceID);
// create and initialize view model for device
IDeviceViewModel viewModel = factory.CreateViewModel(DisplayTypeEnum.Full, _genericDevice);
viewModel.Initialize();
// create view and attach to our display
_contentControl.Content = factory.CreateLargeView(viewModel);
}
public RoomViewModel(RoomModel roomModel)
{
RoomModel = roomModel;
Background = GetImage();
DeviceViewModels = new ObservableCollection <IDeviceViewModel>();
SelectDeviceCommand = new Command <string>((string deviceId) => {
if (deviceId == null)
{
return;
}
var deviceEnumerator = DeviceViewModels.Where((IDeviceViewModel deviceViewModel) => {
return(deviceViewModel.Id.Equals(deviceId));
});
SelectedDeviceViewModel = deviceEnumerator.First();
});
foreach (IDeviceModel deviceModel in RoomModel.Devices)
{
DeviceViewModels.Add(DeviceLinker.GetDeviceViewModelForModel(deviceModel));
}
}
public LoadAllFromDeviceWindowViewModel CreateLoadAllFromDeviceWindowViewModel(IDevice device,
IDeviceViewModel deviceViewModel)
{
var loadFragmentViewModels = new List <ILoadFragmentViewModel>();
List <(ILoadFragmentViewModel loadFragmentViewModel, Func <string, Task <bool> > loadFragment)> loadFragmentsInfo =
new List <(ILoadFragmentViewModel loadFragmentViewModel, Func <string, Task <bool> > loadFragment)>();
foreach (var fragmentViewModel in deviceViewModel.FragmentViewModels)
{
var loadHandler = _loadAllService.LoadFragmentHandler(
fragmentViewModel.StrongName);
loadHandler.OnSuccess(handler =>
{
var loadFragmentViewModel = new DefaultLoadFragmentViewModel()
{
FragmentName = StaticContainer.Container.Resolve <ILocalizerService>().GetLocalizedString(fragmentViewModel.NameForUiKey),
UiName = StaticContainer.Container.Resolve <ILocalizerService>().GetLocalizedString(fragmentViewModel.NameForUiKey)
};
Task <bool> GetLoadFragmentTask(string pathToFolder) => LoadFragment(loadFragmentViewModel, fragmentViewModel, handler, pathToFolder);
loadFragmentsInfo.Add((loadFragmentViewModel,
GetLoadFragmentTask));
loadFragmentViewModels.Add(loadFragmentViewModel);
});
}
Func <string, Task <LoadingResult> > loader = async(pathToFolder) =>
{
Directory.CreateDirectory(pathToFolder + "\\" + device.DeviceSignature);
var results = new List <bool>();
foreach (var loadFragmentInfo in loadFragmentsInfo)
{
results.Add(await loadFragmentInfo.loadFragment(pathToFolder + "\\" + deviceViewModel.DeviceSignature));
}
if (results.All(b => b))
{
return(LoadingResult.Success);
}
if (results.All(b => !b))
{
return(LoadingResult.Fail);
}
if (results.Any(b => !b))
{
return(LoadingResult.SuccessWithIssues);
}
return(LoadingResult.Fail);
};
return(new LoadAllFromDeviceWindowViewModel(loadFragmentViewModels, loader, deviceViewModel.DeviceSignature));
}
public static IDeviceViewModel ResolveIDeviceViewModel(IMainController controller)
{
if (deviceViewModel == null)
{
deviceViewModel = new DeviceViewModel(controller);
}
return deviceViewModel;
}
private void SetPaneTitle(IFragmentPaneViewModel fragmentPaneViewModel, IFragmentViewModel fragmentViewModel, IDeviceViewModel deviceViewModel)
{
if (!(_localizerService.TryGetLocalizedString(fragmentViewModel.NameForUiKey, out string title)))
{
title = fragmentViewModel.NameForUiKey;
}
fragmentPaneViewModel.FragmentTitle =
title +
" (" + deviceViewModel.DeviceSignature + ")";
}
public async Task <Result <IDeviceViewModel> > CreateDeviceViewModel(IDevice device)
{
IDeviceViewModel deviceViewModel = _deviceViewModelGettingFunc();
if (device.DeviceMemory == null)
{
device.DeviceMemory = _container.Resolve <IDeviceMemory>();
}
var deviceLevelPublisher = new FragmentLevelEventsDispatcher();
DeviceContext context = new DeviceContext(device.DeviceMemory,
deviceLevelPublisher, device.DeviceSignature,
device, device.DeviceSharedResources);
if (device.DeviceFragments != null)
{
foreach (IDeviceFragment deviceFragment in device.DeviceFragments)
{
IFragmentViewModel fragmentViewModel =
_container.Resolve <IFragmentViewModel>(deviceFragment.StrongName +
ApplicationGlobalNames.CommonInjectionStrings
.VIEW_MODEL);
if (fragmentViewModel is IDeviceContextConsumer deviceContextConsumer)
{
deviceContextConsumer.DeviceContext = context;
}
var res = await fragmentViewModel.Initialize(deviceFragment);
if (!res.IsSuccess)
{
if (res.Exception != null)
{
return(Result <IDeviceViewModel> .CreateWithException(res.Exception));
}
Result <IDeviceViewModel> .Create(false);
}
deviceViewModel.FragmentViewModels.Add(fragmentViewModel);
}
}
deviceViewModel.TransactionCompleteSubscription = new TransactionCompleteSubscription(context,
device.ConnectionState, deviceViewModel.ConnectionStateViewModel, _container, () =>
{
if (_container.Resolve <IApplicationGlobalCommands>().AskUserGlobal(
_container.Resolve <ILocalizerService>()
.GetLocalizedString(ApplicationGlobalNames.StatusMessages.CONNECTION_LOST_GO_OFFLINE),
deviceViewModel.DeviceSignature))
{
_container.Resolve <IDevicesContainerService>().ConnectDeviceAsync(device,
_container.Resolve <IDeviceConnectionFactory>(ApplicationGlobalNames
.OFFLINE_CONNECTION_FACTORY_NAME).CreateDeviceConnection());
(deviceViewModel.TransactionCompleteSubscription as TransactionCompleteSubscription)
?.ResetOnConnectionRetryCounter(false);
}
});
deviceViewModel.TransactionCompleteSubscription.Execute();
deviceViewModel.Model = device;
return(Result <IDeviceViewModel> .Create(deviceViewModel, true));
}
