Example #1
0
        public static IEntityFactory <T> BuildFactory <T>()
            where T : EntityBase
        {
            IEntityFactory <T> factory = null;
            string             key     = typeof(T).Name;

            if (EntityFactoryBuilder.factories.ContainsKey(key))
            {
                factory = EntityFactoryBuilder.factories[key] as
                          IEntityFactory <T>;
            }
            else
            {
                EntitySettings settings = (EntitySettings)ConfigurationManager.
                                          GetSection(EntityMappingConstants.
                                                     EntityMappingsConfigurationSectionName);

                Type entityFactoryType = Type.GetType(settings.EntityMappings[key]
                                                      .EntityFullTypeName);

                factory = Activator.CreateInstance(entityFactoryType)
                          as IEntityFactory <T>;

                EntityFactoryBuilder.factories[key] = factory;
            }
            return(factory);
        }
Example #2
0
        public void SaveSettings()
        {
            if (_settings == null)
            {
                return;
            }

            Task.Run(() =>
            {
                try
                {
                    EntitySettings set = new EntitySettings()
                    {
                        Theme = _settings.CurrentTheme.Name
                    };
                    lock (_lock)
                    {
                        _repositorySettings.SaveSettings(set);
                    }
                }
                catch (Exception ex)
                {
                    // тут будет логер когда нибудь
                }
            });
        }
 public OneTimePinsClient(IEncentivizeRestClient restClient)
 {
     var createOneTimePinRequestSettings = new EntitySettings("One Time Pin", "One Time Pins", "Otp");
     _createOneTimePinRequestService = new EntityCreationService<CreateOneTimePinRequest>(restClient, createOneTimePinRequestSettings);
     var passwordResetSettings = new EntitySettings("One Time Pin Password Reset", "One Time Pin Password Resets", "OtpPasswordReset");
     _passwordResetCreationService = new EntityCreationService<OneTimePinPasswordResetInput>(restClient, passwordResetSettings);
 }
        public void EntitySettingsInstantiation()
        {
            var systemUnderTest = new EntitySettings();

            systemUnderTest.UnmarkedAttributes.Should().NotBeNull();
            systemUnderTest.Filter.Should().BeNullOrEmpty();
        }
 public SupportTicketsClient(IEncentivizeRestClient restClient)
 {
     var entitySettings = new EntitySettings(typeof(SupportTicket));
     _entityUpdateService = new EntityUpdateService<EditSupportTicketInput, SupportTicket>(restClient, entitySettings);
     _entityRetrievalService = new EntityRetrievalService<SupportTicket>(restClient, entitySettings);
     _entityCreationService = new EntityCreationService<SupportTicketInput, SupportTicket>(restClient, entitySettings);
 }
        public static IEntityFactory <T> BuildFactory <T>() where T : IEntity
        {
            IEntityFactory <T> factory = null;

            // Get the key from the Generic parameter passed in
            string key = typeof(T).Name;

            // See if the factory is in the cache
            if (EntityFactoryBuilder.factories.ContainsKey(key))
            {
                // It was there, so retrieve it from the cache
                factory = EntityFactoryBuilder.factories[key] as IEntityFactory <T>;
            }
            else
            {
                // Create the factory

                // Get the entityMappingsConfiguration config section

                EntitySettings settings = (EntitySettings)ConfigurationManager.GetSection(EntityMappingConstants.EntityMappingsConfigurationSectionName);

                // Get the type to be created using reflection
                Type entityFactoryType = Type.GetType(settings.EntityMappings[key].EntityFactoryFullTypeName);

                // Create the factory using reflection
                factory = Activator.CreateInstance(entityFactoryType) as IEntityFactory <T>;

                // Put the newly created factory in the cache
                EntityFactoryBuilder.factories[key] = factory;
            }

            // Return the factory
            return(factory);
        }
        protected RabbitMqEntitySettings(EntitySettings settings)
        {
            Durable = settings.Durable;
            AutoDelete = settings.AutoDelete;

            ExchangeArguments = new Dictionary<string, object>(settings.ExchangeArguments);
        }
        protected RabbitMqEntitySettings(EntitySettings settings)
        {
            Durable    = settings.Durable;
            AutoDelete = settings.AutoDelete;

            ExchangeArguments = new Dictionary <string, object>(settings.ExchangeArguments);
        }
Example #9
0
        public void SaveSettings()
        {
            if (_settings == null)
            {
                return;
            }

            Task.Run(() =>
            {
                try
                {
                    EntitySettings set = new EntitySettings()
                    {
                        Theme           = _settings.CurrentTheme.Name,
                        ApiKeyFssp      = _settings.ApiKeyFssp,
                        TypeGrid        = _settings.TypeGrid.TypeGridViewItem.ToString(),
                        CanMemorizeMenu = _settings.CanMemorizeMenu,
                        LastMenu        = _settings.LastMenu
                    };
                    lock (_lock)
                    {
                        _repositorySettings.SaveSettings(set);
                    }
                }
                catch (Exception ex)
                {
                    // тут будет логер когда нибудь
                }
            });
        }
 public void TestDefaultConstructor(Type type, string expectedNameSingular, string expectedNamePlural, string expectedBaseRoute)
 {
     var entitySettings = new EntitySettings(type);
     Assert.AreEqual(expectedNameSingular, entitySettings.EntityNameSingular);
     Assert.AreEqual(expectedNamePlural, entitySettings.EntityNamePlural);
     Assert.AreEqual(expectedBaseRoute, entitySettings.BaseRoute);
 }
        public DeadLetterSettings GetDeadLetterSettings(EntitySettings settings)
        {
            var deadLetterSetting = new QueueDeadLetterSettings(settings, BuildEntityName(settings.EntityName, "_skipped"));

            ConfigureDeadLetterSettings?.Invoke(deadLetterSetting);

            return(deadLetterSetting);
        }
        public ErrorSettings GetErrorSettings(EntitySettings settings)
        {
            var errorSettings = new QueueErrorSettings(settings, BuildEntityName(settings.EntityName, "_error"));

            ConfigureErrorSettings?.Invoke(errorSettings);

            return(errorSettings);
        }
 public OneTimePinConfigurationsClient(IEncentivizeRestClient restClient)
 {
     var entitySettings = new EntitySettings().Populate<OneTimePinConfiguration>();
     _entityUpdateService = new EntityUpdateService<OneTimePinConfigurationInput, OneTimePinConfiguration>(restClient, entitySettings);
     _entityRetrievalService = new EntityRetrievalService<OneTimePinConfiguration>(restClient, entitySettings);
     _entityCreationService = new EntityCreationService<OneTimePinConfigurationInput, OneTimePinConfiguration>(restClient, entitySettings);
     _entityDeletionService = new EntityDeletionService<OneTimePinConfigurationInput, OneTimePinConfiguration>(restClient, entitySettings);
 }
 public GroupsClient(IEncentivizeRestClient restClient)
 {
     var entitySettings = new EntitySettings().Populate<Group>();
     _entityUpdateService = new EntityUpdateService<GroupInput, Group>(restClient, entitySettings);
     _entityRetrievalService = new EntityRetrievalService<Group>(restClient, entitySettings);
     _entityCreationService = new EntityCreationService<GroupInput, Group>(restClient, entitySettings);
     _entityDeletionService = new EntityDeletionService<GroupInput, Group>(restClient, entitySettings);
 }
 public AchievementCategoriesClient(IEncentivizeRestClient restClient)
 {
     var entitySettings = new EntitySettings().Populate<AchievementCategory>();
     _entityUpdateService = new EntityUpdateService<AchievementCategoryInput, AchievementCategory>(restClient, entitySettings);
     _entityRetrievalService = new EntityRetrievalService<AchievementCategory>(restClient, entitySettings);
     _entityCreationService = new EntityCreationService<AchievementCategoryInput, AchievementCategory>(restClient, entitySettings);
     _entityDeletionService = new EntityDeletionService<AchievementCategoryInput, AchievementCategory>(restClient, entitySettings);
 }
Example #16
0
        public DeadLetterSettings GetDeadLetterSettings(EntitySettings settings)
        {
            var deadLetterSetting = new RabbitMqDeadLetterSettings(settings, settings.ExchangeName + "_skipped");

            ConfigureDeadLetterSettings?.Invoke(deadLetterSetting);

            return(deadLetterSetting);
        }
        public ErrorSettings GetErrorSettings(EntitySettings settings)
        {
            var errorSettings = new ActiveMqErrorSettings(settings, settings.EntityName + "_error");

            ConfigureErrorSettings?.Invoke(errorSettings);

            return(errorSettings);
        }
        public DeadLetterSettings GetDeadLetterSettings(EntitySettings settings)
        {
            var deadLetterSetting = new ActiveMqDeadLetterSettings(settings, settings.EntityName + "_skipped");

            ConfigureDeadLetterSettings?.Invoke(deadLetterSetting);

            return(deadLetterSetting);
        }
Example #19
0
        public ErrorSettings GetErrorSettings(EntitySettings settings)
        {
            var errorSettings = new RabbitMqErrorSettings(settings, settings.ExchangeName + "_error");

            ConfigureErrorSettings?.Invoke(errorSettings);

            return(errorSettings);
        }
        public void ThrowArgumentNullExceptionIfNullSucceeds()
        {
            string         message      = "Test message";
            EntitySettings testVariable = new EntitySettings();

            FluentActions.Invoking(() => testVariable.ThrowArgumentNullExceptionIfNull(nameof(testVariable), message))
            .Should()
            .NotThrow();
        }
        public void ThrowIfNullForNonNullObject()
        {
            string         message      = "Test message";
            EntitySettings testVariable = new EntitySettings();

            FluentActions.Invoking(() => testVariable.ThrowIfNull <Exception>(message))
            .Should()
            .NotThrow();
        }
        public void ThrowArgumentNullExceptionIfNullReturnsDefaultMessage()
        {
            string         message      = "input parameter should not be null!";
            EntitySettings testVariable = null;

            FluentActions.Invoking(() => testVariable.ThrowArgumentNullExceptionIfNull(nameof(testVariable)))
            .Should()
            .Throw <ArgumentNullException>()
            .Where(a => a.Message.Contains(message) && a.Message.Contains(nameof(testVariable)));
        }
        public void ThrowIfNullForNullObject()
        {
            string         message      = "Test message";
            EntitySettings testVariable = null;

            FluentActions.Invoking(() => testVariable.ThrowIfNull <Exception>(message))
            .Should()
            .Throw <Exception>()
            .WithMessage(message);
        }
        private static EntitySettings EnsureConfigForEntity(Type entityType)
        {
            if (CurrentConfig.TryGetValue(entityType, out EntitySettings value))
            {
                return(value);
            }

            CurrentConfig[entityType] = new EntitySettings();
            return(CurrentConfig[entityType]);
        }
        public void ThrowArgumentNullExceptionIfNull()
        {
            string         message      = "Test message";
            EntitySettings testVariable = null;

            FluentActions.Invoking(() => testVariable.ThrowArgumentNullExceptionIfNull(nameof(testVariable), message))
            .Should()
            .Throw <ArgumentNullException>()
            .Where(a => a.Message.Contains(message) && a.Message.Contains(nameof(testVariable)));
        }
        public RabbitMqErrorSettings(EntitySettings source, string name)
            : base(name, source.ExchangeType, source.Durable, source.AutoDelete)
        {
            QueueName = name;

            foreach (KeyValuePair <string, object> argument in source.ExchangeArguments)
            {
                SetExchangeArgument(argument.Key, argument.Value);
            }
        }
Example #27
0
 private void Awake()
 {
     if (entity != null)
     {
         Destroy(gameObject);
     }
     else
     {
         entity = this;
     }
 }
Example #28
0
        public void OrganisationsEntitySettings()
        {
            var key1 = "item1";

            Organisations systemUnderTest     = new Organisations();
            var           sampleEntitySetting = new EntitySettings();

            sampleEntitySetting.Filter = "Testfilter";

            var item = new Item <string, EntitySettings>(key1, sampleEntitySetting);

            systemUnderTest.Entities.Add(new Item <string, EntitySettings>("item2", new EntitySettings()));
            systemUnderTest.Entities.Add(item);
            systemUnderTest.Entities.Add(new Item <string, EntitySettings>("item3", new EntitySettings()));

            var actual = systemUnderTest[key1];

            actual.Filter.Should().Be("Testfilter");
        }
Example #29
0
        public void OrganisationsNpnExistingEntitySettings()
        {
            var key1 = "item1";

            Organisations systemUnderTest     = new Organisations();
            var           sampleEntitySetting = new EntitySettings();

            sampleEntitySetting.Filter = "Testfilter";

            var item = new Item <string, EntitySettings>(key1, sampleEntitySetting);

            systemUnderTest.Entities.Add(new Item <string, EntitySettings>("item2", new EntitySettings()));
            systemUnderTest.Entities.Add(item);
            systemUnderTest.Entities.Add(new Item <string, EntitySettings>("item3", new EntitySettings()));

            var actual = systemUnderTest["item4"];

            actual.Filter.Should().BeNullOrEmpty();
            actual.UnmarkedAttributes.Count.Should().Be(0);
        }
Example #30
0
        public static void Start(bool toExcelPlain, bool excelReport, bool excelAttachment)
        {
            if (Navigator.Manager.NotDefined(MethodInfo.GetCurrentMethod()))
            {
                ToExcelPlain = toExcelPlain;
                ExcelReport = excelReport;

                Navigator.RegisterArea(typeof(ExcelClient));

                if (excelReport)
                {
                    if (!Navigator.Manager.EntitySettings.ContainsKey(typeof(EmbeddedFileEntity)))
                        throw new InvalidOperationException("Call EmbeddedFileEntity first");

                    if (!Navigator.Manager.EntitySettings.ContainsKey(typeof(QueryEntity)))
                        Navigator.Manager.EntitySettings.Add(typeof(QueryEntity), new EntitySettings<QueryEntity>());

                    
                    Navigator.AddSetting(new EntitySettings<ExcelReportEntity> { PartialViewName = _ => ViewPrefix.FormatWith("ExcelReport") });
                        }

                if (toExcelPlain || excelReport)
                    ButtonBarQueryHelper.RegisterGlobalButtons(ButtonBarQueryHelper_GetButtonBarForQueryName); 

                if (excelAttachment)
                {
                    var es = new EntitySettings<ExcelAttachmentEntity>
                    {
                        PartialViewName = _ => ViewPrefix.FormatWith("ExcelAttachment")
                    };

                    es.MappingMain = es.MappingLine = new EntityMapping<ExcelAttachmentEntity>(true)
                        .SetProperty(etm => etm.Template, ctx =>
                        {
                            return (EmailTemplateEntity)ctx.Parent.Parent?.Parent.Parent.UntypedValue;
                        });

                    Navigator.AddSetting(es);
                }
            }
        }
Example #31
0
 public void SaveSettings()
 {
     Task.Factory.StartNew(() =>
     {
         try
         {
             EntitySettings set = new EntitySettings()
             {
                 Theme = _settings.CurrentTheme.Name
             };
             lock (_lock)
             {
                 _repositorySettings.SaveSettings(set);
             }
         }
         catch (Exception ex)
         {
             // тут будет логер когда нибудь
         }
     });
 }
 public QueueErrorSettings(EntitySettings source, string queueName)
     : base(queueName, source.Durable, source.AutoDelete)
 {
     QueueTags = source.Tags?.ToDictionary(x => x.Key, x => x.Value);
 }
 public SupportTicketCategoriesClient(IEncentivizeRestClient restClient)
 {
     var entitySettings = new EntitySettings(typeof(SupportTicketCategory));
     _entityRetrievalService = new EntityRetrievalService<SupportTicketCategory>(restClient, entitySettings);
 }
Example #34
0
 public DeadLetterSettings GetDeadLetterSettings(EntitySettings settings)
 {
     return(new QueueDeadLetterSettings(settings, settings.EntityName + "_skipped"));
 }
Example #35
0
 public ErrorSettings GetErrorSettings(EntitySettings settings)
 {
     return(new QueueErrorSettings(settings, settings.EntityName + "_error"));
 }
 public ErrorSettings GetErrorSettings(EntitySettings settings)
 {
     return(new QueueErrorSettings(settings, BuildEntityName(settings.EntityName, "_error")));
 }
 public OneTimePinTypesClient(IEncentivizeRestClient restClient)
 {
     var entitySettings = new EntitySettings(typeof(OneTimePinType));
     _entityRetrievalService = new EntityRetrievalService<OneTimePinType>(restClient, entitySettings);
 }
 protected BaseRetrievalService(IEncentivizeRestClient restClient, EntitySettings entitySettings)
     : base(restClient, entitySettings)
 {
     QueryStringBuilder = new QueryStringBuilder(propertiesToExclude: new[] { "PageNumber", "PageSize" });
 }
 public EntityService(IEncentivizeRestClient restClient, EntitySettings entitySettings)
 {
     RestClient = restClient;
     EntitySettings = entitySettings;
 }
Example #40
0
 public ErrorSettings GetErrorSettings(EntitySettings settings)
 {
     return(new AmazonSqsErrorSettings(settings, settings.EntityName + "_error"));
 }
Example #41
0
 public QueueDeadLetterSettings(EntitySettings source, string queueName)
     : base(queueName, source.Durable, source.AutoDelete)
 {
     QueueTags = source.Tags;
 }
Example #42
0
 public DeadLetterSettings GetDeadLetterSettings(EntitySettings settings)
 {
     return(new RabbitMqDeadLetterSettings(settings, settings.ExchangeName + "_skipped"));
 }