Пример #1
0
        /// <summary>
        /// 点击某一项
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void ucs_Click(object sender, EventArgs e)
        {
            UCDevicesState uc   = (UCDevicesState)sender;
            MouseEventArgs args = (MouseEventArgs)e;
            IDevices       dev  = (IDevices)uc.Tag;

            if (selectedUCDev != null)
            {
                selectedUCDev.Select(false);
            }
            uc.Select(true);
            SelectedUCDev = uc;
            this.Device   = dev;
            if (args.Button == MouseButtons.Right)
            {
                contextMenuStrip1.Show(uc.PointToScreen(args.Location));
            }
            else
            {
                if (IsSelectedCloseFrom)
                {
                    this.DialogResult = DialogResult.OK;
                }
            }
        }
Пример #2
0
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='id'>
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <Device> GetDeviceAsync(this IDevices operations, string id, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.GetDeviceWithHttpMessagesAsync(id, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
Пример #3
0
        public DevicesTest()
        {
            this.registryMock     = new Mock <RegistryManager>();
            this.mockTenantHelper = new Mock <ITenantConnectionHelper>();
            this.mockTenantHelper.Setup(e => e.GetIotHubName()).Returns(this.ioTHubHostName);
            this.mockTenantHelper.Setup(e => e.GetRegistry()).Returns(this.registryMock.Object);
            MockIdentity.MockClaims("one");

            this.mockAsaManager = new Mock <IAsaManagerClient>();
            this.mockAsaManager
            .Setup(x => x.BeginDeviceGroupsConversionAsync())
            .ReturnsAsync(new BeginConversionApiModel());

            this.mockCache = new Mock <IDeviceQueryCache>();
            this.mockCache
            .Setup(x => x.GetCachedQueryResultAsync(It.IsAny <string>(), It.IsAny <string>()))
            .ReturnsAsync((DeviceServiceListModel)null);
            this.mockCache
            .Setup(
                x => x.SetTenantQueryResult(
                    It.IsAny <string>(),
                    It.IsAny <string>(),
                    It.IsAny <DeviceQueryCacheResultServiceModel>()));

            this.devices = new Devices(this.mockTenantHelper.Object, this.ioTHubHostName, this.mockAsaManager.Object, this.mockCache.Object);
        }
 /// <summary>
 /// Returns the device details.
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='deviceUdid'>
 /// The UDID of the device
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <object> DeviceDetailsAsync(this IDevices operations, string deviceUdid, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.DeviceDetailsWithHttpMessagesAsync(deviceUdid, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
 /// <summary>
 /// **Warning, this operation is not reversible.**
 ///
 /// A successful call to this API will permanently stop ingesting any logs
 /// received via SDK for the given installation ID, and cannot be restored. We
 /// advise caution when using this API, it is designed to permanently disable
 /// collection from a specific installation of the app on a device, usually
 /// following the request from a user.
 ///
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='installId'>
 /// The id of the device
 /// </param>
 /// <param name='ownerName'>
 /// The name of the owner
 /// </param>
 /// <param name='appName'>
 /// The name of the application
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <string> BlockLogsAsync(this IDevices operations, string installId, string ownerName, string appName, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.BlockLogsWithHttpMessagesAsync(installId, ownerName, appName, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
 /// <summary>
 /// Registers a user for an existing device
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='userId'>
 /// The ID of the user
 /// </param>
 /// <param name='body'>
 /// The device info.
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <object> RegisterUserForDeviceAsync(this IDevices operations, string userId, DeviceInfoRequest body, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.RegisterUserForDeviceWithHttpMessagesAsync(userId, body, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
 /// <summary>
 /// Returns all devices associated with the given distribution group
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='distributionGroupName'>
 /// The name of the distribution group.
 /// </param>
 /// <param name='ownerName'>
 /// The name of the owner
 /// </param>
 /// <param name='appName'>
 /// The name of the application
 /// </param>
 /// <param name='releaseId'>
 /// when provided, gets the provisioning state of the devices owned by users of
 /// this distribution group when compared to the provided release.
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <object> ListAsync(this IDevices operations, string distributionGroupName, string ownerName, string appName, double?releaseId = default(double?), CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.ListWithHttpMessagesAsync(distributionGroupName, ownerName, appName, releaseId, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
 /// <summary>
 /// Returns all devices associated with the given distribution group.
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='distributionGroupName'>
 /// The name of the distribution group.
 /// </param>
 /// <param name='ownerName'>
 /// The name of the owner
 /// </param>
 /// <param name='appName'>
 /// The name of the application
 /// </param>
 /// <param name='unprovisionedOnly'>
 /// when true, filters out provisioned devices
 /// </param>
 /// <param name='udids'>
 /// multiple UDIDs which should be part of the resulting CSV.
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <ErrorDetails> ListCsvFormatAsync(this IDevices operations, string distributionGroupName, string ownerName, string appName, bool?unprovisionedOnly = false, IList <string> udids = default(IList <string>), CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.ListCsvFormatWithHttpMessagesAsync(distributionGroupName, ownerName, appName, unprovisionedOnly, udids, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
 /// <summary>
 /// Returns the resign status to the caller
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='releaseId'>
 /// The ID of the release.
 /// </param>
 /// <param name='resignId'>
 /// The ID of the resign operation.
 /// </param>
 /// <param name='ownerName'>
 /// The name of the owner
 /// </param>
 /// <param name='appName'>
 /// The name of the application
 /// </param>
 /// <param name='includeProvisioningProfile'>
 /// A boolean value that indicates if the provisioning profile should be return
 /// in addition to the status. When set to true, the provisioning profile will
 /// be returned only when status is 'complete' or 'preparing_for_testers'.
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <object> GetReleaseUpdateDevicesStatusAsync(this IDevices operations, string releaseId, string resignId, string ownerName, string appName, bool?includeProvisioningProfile = default(bool?), CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.GetReleaseUpdateDevicesStatusWithHttpMessagesAsync(releaseId, resignId, ownerName, appName, includeProvisioningProfile, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
Пример #10
0
 public void Init(IDevices dirnx700)
 {
     nx700       = (DRI_CHEM_NX700iVC)dirnx700;
     log         = new Log(nx700.Info.Name);
     nx700config = (DRI_CHEM_NX700iVCConfig)nx700.Config;
     buffer      = new List <byte>();
 }
Пример #11
0
 public void Init(IDevices diridexx)
 {
     LockObj     = "lock";
     idexx       = (IDEXX_VetLab_Station)diridexx;
     log         = new Log(idexx.Info.Name);
     idexxConfig = (IDEXX_VetLab_StationConfig)idexx.Config;
 }
Пример #12
0
        public SimulationRunner(
            IRateLimitingConfig ratingConfig,
            IRateLimiting rateLimiting,
            ISimulationConcurrencyConfig simulationConcurrencyConfig,
            ILogger logger,
            IDiagnosticsLogger diagnosticsLogger,
            IDeviceModels deviceModels,
            IDeviceModelsGeneration deviceModelsOverriding,
            IDevices devices,
            ISimulations simulations,
            IFactory factory)
        {
            this.connectionLoopSettings = new ConnectionLoopSettings(ratingConfig);
            this.propertiesLoopSettings = new PropertiesLoopSettings(ratingConfig);

            this.simulationConcurrencyConfig = simulationConcurrencyConfig;
            this.log = logger;
            this.diagnosticsLogger      = diagnosticsLogger;
            this.deviceModels           = deviceModels;
            this.deviceModelsOverriding = deviceModelsOverriding;
            this.devices     = devices;
            this.simulations = simulations;
            this.factory     = factory;

            this.startLock    = new { };
            this.running      = false;
            this.starting     = false;
            this.rateLimiting = rateLimiting;

            this.deviceStateActors      = new ConcurrentDictionary <string, IDeviceStateActor>();
            this.deviceConnectionActors = new ConcurrentDictionary <string, IDeviceConnectionActor>();
            this.deviceTelemetryActors  = new ConcurrentDictionary <string, IDeviceTelemetryActor>();
            this.devicePropertiesActors = new ConcurrentDictionary <string, IDevicePropertiesActor>();
        }
Пример #13
0
        public MainPageViewModel(INavigationService navigationService, IDevices devices)
        {
            _navigationService = navigationService;
            _devices           = devices;

            DeviceID = _devices.GetID();
        }
Пример #14
0
        private static string Volume(string action, IDevices devices)
        {
            var device = GetDevice(devices, action);

            if (device == null)
            {
                return(errorDeviceNotFound);
            }

            var deviceVolume = action.Split('/')?.Length > 2 ? action.Split('/')[2] : null;

            if (string.IsNullOrEmpty(deviceVolume))
            {
                return(errorWrongVolume);
            }

            if (!int.TryParse(deviceVolume, out int level))
            {
                return(errorWrongVolume);
            }

            if (level < 0 || level > 100)
            {
                return(errorWrongVolume);
            }

            device.VolumeSet(level / 100.0f);

            var response = "{\"data\": { \"type\": \"done\", \"id\": \"1\", \"attributes\": { \"action\": \"/volume" + action + "\" } } }";

            return(response);
        }
        public async Task <bool> TryToStartDevicesCreationAsync(string simulationId, IDevices devices)
        {
            // Fetch latest record
            var simulation = await this.GetAsync(simulationId);

            // Edit the record only if required
            if (!simulation.DevicesCreationStarted)
            {
                try
                {
                    Dictionary <string, List <string> > deviceList = this.GetDeviceIdsByModel(simulation);
                    var deviceIds = deviceList.SelectMany(x => x.Value);
                    this.log.Info("Creating devices...", () => new { simulationId });

                    simulation.DeviceCreationJobId = await devices.CreateListUsingJobsAsync(deviceIds);

                    simulation.DevicesCreationStarted = true;

                    this.log.Info("Device import job created", () => new { simulationId, simulation.DeviceCreationJobId });

                    await this.SaveAsync(simulation, simulation.ETag);
                }
                catch (Exception e)
                {
                    this.log.Error("Failed to create device import job", e);
                    return(false);
                }
            }

            return(true);
        }
Пример #16
0
        private static string Start(string action, IDevices devices)
        {
            if (string.IsNullOrEmpty(action.Replace("/", "")))
            {
                var deviceList = devices.GetDeviceList();
                foreach (var device in deviceList)
                {
                    device.ResumePlaying();
                }
            }
            else
            {
                var device = GetDevice(devices, action);
                if (device == null)
                {
                    return(errorDeviceNotFound);
                }

                device.ResumePlaying();
            }

            var response = "{\"data\": { \"type\": \"done\", \"id\": \"1\", \"attributes\": { \"action\": \"/start" + action + "\" } } }";

            return(response);
        }
Пример #17
0
        public Deployments(
            AppConfig config,
            ILogger <Deployments> logger,
            IDeploymentEventLog deploymentLog,
            ITenantConnectionHelper tenantConnectionHelper,
            IConfigClient packagesConfigClient,
            IStorageAdapterClient client,
            IDevices devices,
            IStorageClient storageClient,
            IAppConfigurationClient appConfigurationClient)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            this.tenantHelper           = tenantConnectionHelper;
            this.deploymentLog          = deploymentLog;
            this.logger                 = logger;
            this.configClient           = packagesConfigClient;
            this.client                 = client;
            this.devices                = devices;
            this.config                 = config;
            this.storageClient          = storageClient;
            this.appConfigurationClient = appConfigurationClient;
        }
 /// <summary>
 /// Returns all devices associated with the given user.
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <object> UserDevicesListAsync(this IDevices operations, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.UserDevicesListWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
Пример #19
0
        public DeviceMonitor(
            [NotNull] ILogger logger,
            [NotNull] IScheduler scheduler,
            [NotNull] Func <ISubject <IDevice> > factory,
            [NotNull] IDevices devices,
            [NotNull] IWatcher watcher)
        {
            Guard.ArgumentNotNull(logger,
                                  nameof(logger));
            Guard.ArgumentNotNull(factory,
                                  nameof(factory));
            Guard.ArgumentNotNull(devices,
                                  nameof(devices));
            Guard.ArgumentNotNull(watcher,
                                  nameof(watcher));
            Guard.ArgumentNotNull(scheduler,
                                  nameof(scheduler));

            _logger    = logger;
            _scheduler = scheduler;
            _devices   = devices;
            _watcher   = watcher;

            _deviceUpdated     = factory.Invoke( );
            _deviceDiscovered  = factory.Invoke( );
            _deviceNameUpdated = factory.Invoke( );
        }
Пример #20
0
        private static IDevice GetDevice(IDevices devices, string action)
        {
            if (action.IndexOf("/") != 0)
            {
                return(null);
            }

            var deviceName = action.Split('/')?.Length > 0 ? action.Split('/')[1] : null;

            if (string.IsNullOrEmpty(deviceName))
            {
                return(null);
            }

            var deviceList = devices.GetDeviceList();

            foreach (var device in deviceList)
            {
                if (device.GetFriendlyName().ToLowerInvariant() == deviceName)
                {
                    return(device);
                }
            }

            return(null);
        }
Пример #21
0
 public UCQueue(IDevices dev)
 {
     InitializeComponent();
     dataGridView1.AutoGenerateColumns = false;
     this.Dock = DockStyle.Fill;
     _dev      = dev;
 }
Пример #22
0
        public void Initialize()
        {
            _scheduler = new TestScheduler();

            _logger = Substitute.For <ILogger>();

            _device = Substitute.For <IDevice>();
            _device.Name
            .Returns((string)null);

            _deviceNewName = Substitute.For <IDevice>();
            _deviceNewName.Name
            .Returns("New Name");

            _deviceOtherNewName = Substitute.For <IDevice>();
            _deviceOtherNewName.Name
            .Returns("Other New Name");

            _factory = Factory;

            _subjectStarted = new Subject <IDevice>();
            _subjectStopped = new Subject <IDevice>();
            _subjectUpdated = new Subject <IDevice>();

            _devices = new Devices(_logger);
            _watcher = Substitute.For <IWatcher>();

            _subjects = new Queue <ISubject <IDevice> >();
            _subjects.Enqueue(_subjectStarted);
            _subjects.Enqueue(_subjectStopped);
            _subjects.Enqueue(_subjectUpdated);
        }
Пример #23
0
 private void 设置ToolStripMenuItem_Click(object sender, EventArgs e)
 {
     if (selectedUCDev != null)
     {
         IDevices dev = (IDevices)selectedUCDev.Tag;
         dev.ShowConfigForm();
     }
 }
Пример #24
0
        public Agent(IDevices devices, IServicesConfig config)
        {
            this._devices = devices;
            this._config  = config;
            var system = ActorSystem.Create("sensewire");

            _deviceManager = system.ActorOf(Props.Create <DeviceManager>(), "device-manager");
        }
Пример #25
0
 private void 关闭ToolStripMenuItem_Click(object sender, EventArgs e)
 {
     if (selectedUCDev != null)
     {
         IDevices dev = (IDevices)selectedUCDev.Tag;
         dev.Close();
     }
 }
Пример #26
0
 public void Init(IDevices info)
 {
     timer          = new Timer(10000);
     timer.Elapsed += Timer_Elapsed;
     abaxisDevice   = (Abaxis_Fuse)info;
     log            = new Log(abaxisDevice.Info.Name);
     fuseConfig     = (FuseConfig)abaxisDevice.Config;
 }
Пример #27
0
        private async Task <DeviceServiceListModel> GetDeviceListAsync(string deploymentId, List <string> deviceIds, string tenantId)
        {
            string query           = string.Empty;
            int    iotHublimit     = 500;
            string deviceListValue = string.Empty;

            var deploymentDeviceTask = this.GetDeploymentDevicesAsync(deploymentId, tenantId);

            DeviceServiceListModel allDevices = new DeviceServiceListModel(new List <DeviceServiceModel>(), null);

            if (deviceIds?.Count > 0)
            {
                for (int i = 0; i < (deviceIds.Count / iotHublimit) + 1; i++)
                {
                    if (i != 0 && (deviceIds.Count % (i * iotHublimit)) <= 0)
                    {
                        break;
                    }

                    List <string> batchDeviceIds = deviceIds.Skip(i * iotHublimit).Take(iotHublimit).ToList();
                    if (batchDeviceIds != null && batchDeviceIds.Count > 0)
                    {
                        deviceListValue = string.Join(",", batchDeviceIds.Select(p => $"'{p}'"));
                    }

                    query = $" deviceId IN [{deviceListValue}]";

                    var devices = await this.devices.GetListFromIoTHubAsync(query, null);

                    allDevices.Items.AddRange(devices.Items);

                    while (!string.IsNullOrWhiteSpace(devices.ContinuationToken))
                    {
                        devices = await this.devices.GetListFromIoTHubAsync(query, null);

                        allDevices.Items.AddRange(devices.Items);
                    }
                }

                var deploymentDeviceHistory = await deploymentDeviceTask;
                if (deploymentDeviceHistory != null && deploymentDeviceHistory.Items.Count > 0)
                {
                    Parallel.ForEach(allDevices.Items, item =>
                    {
                        var twin = deploymentDeviceHistory.Items.FirstOrDefault(i => i.DeviceId == item.Id)?.Twin;

                        if (twin != null)
                        {
                            item.Twin = twin;
                        }

                        item.PreviousTwin = deploymentDeviceHistory.Items.FirstOrDefault(i => i.DeviceId == item.Id)?.PreviousFirmwareTwin;
                    });
                }
            }

            return(allDevices);
        }
Пример #28
0
 public AddComputer(IDevices device)
 {
     InitializeComponent();
     DataContext = device;
     if (device.GetType() == typeof(ViewModel.ComputerViewModel))
     {
         MessageBox.Show("Huraa to komputer");
     }
 }
Пример #29
0
 public DevicesTest()
 {
     this.registryMock = new Mock <RegistryManager>();
     this.tenantHelper = new Mock <ITenantConnectionHelper>();
     this.tenantHelper.Setup(e => e.GetIotHubName()).Returns(this.ioTHubHostName);
     this.tenantHelper.Setup(e => e.GetRegistry()).Returns(this.registryMock.Object);
     MockIdentity.MockClaims("one");
     this.devices = new Devices(this.tenantHelper.Object, this.ioTHubHostName);
 }
 public Connect(
     IDevices devices,
     IScriptInterpreter scriptInterpreter,
     ILogger logger)
 {
     this.log = logger;
     this.scriptInterpreter = scriptInterpreter;
     this.devices           = devices;
 }
Пример #31
0
 /// <summary>
 /// Runs the telemetry network. The boot-up code is called via ThreadPool
 /// </summary>
 public void Run()
 {
     Peripherals = new Devices();
     ThreadPool.QueueUserWorkItem(new WaitCallback(Bootup));
 }
Пример #32
0
 /// <summary>
 /// Runs the telemetry network. The boot-up code is called via ThreadPool
 /// </summary>
 public void Run()
 {
     Peripherals = new Devices();
     Bootup(string.Empty);
 }