Exemple #1
0
        /// <summary>
        ///  Get magnifier settings by id.
        /// </summary>
        /// <param name="idValue">Identifier of the grid.</param>
        /// <returns></returns>
        public async Task <GridSettingsDto> GetMagnifierSettings(long idValue)
        {
            IMapper         mapper      = MapperField.GetMapper();
            GridSettingsDto settingsDto = new GridSettingsDto();

            if (_executorSql.State != ConnectionState.Open)
            {
                using (var dbConnection = _executorSql.OpenNewDbConnection())
                {
                    var dto = await dbConnection.GetAsync <GRID_SERIALIZATION>(idValue).ConfigureAwait(true);

                    if (dto != null)
                    {
                        settingsDto = mapper.Map <GRID_SERIALIZATION, GridSettingsDto>(dto);
                    }

                    return(settingsDto);
                }
            }

            var settings = await _executorSql.Connection.GetAsync <GRID_SERIALIZATION>(idValue);

            settingsDto = mapper.Map <GRID_SERIALIZATION, GridSettingsDto>(settings);
            return(settingsDto);
        }
Exemple #2
0
        public async Task <bool> SaveMagnifierSettings(GridSettingsDto settingsDto)
        {
            Contract.Requires(settingsDto != null);
            bool               value     = false;
            IMapper            mapper    = MapperField.GetMapper();
            GRID_SERIALIZATION serialize = mapper.Map <GridSettingsDto, GRID_SERIALIZATION>(settingsDto);

            Contract.Requires(serialize != null);
            value = await SaveOrUpdate(serialize).ConfigureAwait(false);

            return(value);
        }
        public void Should_ResizeGrid_Command()
        {
            ICommand resizeGrid = _karveViewModelBase.GridResizeCommand;

            Assert.NotNull(resizeGrid);
            KarveGridParameters param = LoadFileFromSettings("TestSettings.xml", 1);
            var baseSettings          = param.Xml;

            resizeGrid.Execute(param);
            GridSettingsDto dto     = _karveViewModelBase.GridSettings;
            var             setting = dto.XmlBase64;

            Assert.AreEqual(baseSettings, setting);
        }
        public void Should_Register_A_New_Grid()
        {
            ICommand registerCommand = _karveViewModelBase.GridRegisterCommand;

            Assert.NotNull(registerCommand);
            KarveGridParameters param = new KarveGridParameters();

            param.GridIdentifier = 1;
            param.GridName       = "Supplier_Grid";
            registerCommand.Execute(param);
            // here shall be present all the grids.
            ObservableCollection <GridSettingsDto> settingsDtos = _karveViewModelBase.CurrentGridSettings;
            GridSettingsDto settingsDto = settingsDtos.FirstOrDefault(x => x.GridIdentifier == param.GridIdentifier);

            Assert.NotNull(settingsDto);
        }
        private GridSettingsDto LoadFileFromSettings(string path, int id)
        {
            GridSettingsDto dto = new GridSettingsDto();

            using (FileStream stream = File.OpenRead(path))
            {
                long   fSize     = stream.Length;
                byte[] fileValue = new byte[fSize];
                stream.Read(fileValue, 0, fileValue.Length);
                // now we save into the setting
                var valueStringEncoded = Convert.ToBase64String(fileValue);
                dto.XmlBase64        = valueStringEncoded;
                dto.GridIdentifier   = id;
                dto.GridName         = "Suppliers";
                dto.User             = "******";
                dto.LastModification = DateTime.Now;
            }
            return(dto);
        }
        public async Task Should_UpdateOrInsert_GridSerialized()
        {
            byte[]          currentBytes    = { 0x10, 0xFF, 0x23, 0x25, 0x23, 0x80 };
            var             base64          = Convert.ToBase64String(currentBytes);
            IMapper         mapper          = MapperField.GetMapper();
            GridSettingsDto gridSettingsDto = new GridSettingsDto();

            gridSettingsDto.GridIdentifier = 0x800;
            gridSettingsDto.GridName       = "Not known";
            gridSettingsDto.XmlBase64      = @"<grid></grid>";


            try
            {
                var serialize = mapper.Map <GridSettingsDto, GRID_SERIALIZATION>(gridSettingsDto);
                using (IDbConnection connection = _sqlExecutor.OpenNewDbConnection())
                {
                    using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
                    {
                        var value = false;
                        if (!connection.IsPresent <GRID_SERIALIZATION>(serialize))
                        {
                            value = await connection.InsertAsync <GRID_SERIALIZATION>(serialize) > 0;
                        }
                        else
                        {
                            value = await connection.UpdateAsync <GRID_SERIALIZATION>(serialize);
                        }
                        Assert.IsTrue(value);
                        scope.Complete();
                    }
                }
            }
            catch (Exception e)
            {
                var ex = e;
                Assert.Fail(ex.Message);
            }
            // nowe we have to assert this.
        }
Exemple #7
0
 public Task <bool> SaveMagnifierSettings(GridSettingsDto settingsDto)
 {
     throw new NotImplementedException();
 }