public static Reconcile ReconcileFromRule(IReconcile rule,
                                                  EnvironmentConfig environmentConfig,
                                                  string projectId,
                                                  string scope,
                                                  string itemId)
        {
            if (environmentConfig == null)
            {
                throw new ArgumentNullException(nameof(environmentConfig));
            }
            if (string.IsNullOrWhiteSpace(projectId))
            {
                throw new ArgumentNullException(nameof(projectId));
            }
            if (string.IsNullOrWhiteSpace(scope))
            {
                throw new ArgumentNullException(nameof(scope));
            }
            if (string.IsNullOrWhiteSpace(itemId))
            {
                throw new ArgumentNullException(nameof(itemId));
            }

            return(rule != null
                ? new Reconcile
            {
                Url = new Uri(
                    $"https://{environmentConfig.FunctionAppHostname}/api/reconcile/{environmentConfig.Organization}/{projectId}/{scope}/{rule.GetType().Name}/{itemId}"),
                Impact = rule.Impact
            }
                : null);
        }
Esempio n. 2
0
        static void Main(string[] args)
        {
            _provider = BuildDependencies().BuildServiceProvider();

            var logger = _provider.GetService <ILoggerFactory>().CreateLogger <Program>();

            #region ObserverPattern

            logger.LogInformation("Observer");

            var product = new Product {
                Name = "Coffee", State = "Unavailable"
            };
            var loggerFactory = _provider.GetService <ILoggerFactory>();
            var o1            = new Observer(loggerFactory, product);
            var o2            = new Observer(loggerFactory, product);

            product.Attach(o1);
            product.Attach(o2);
            product.SetState("Available");
            product.DetachAll();

            #endregion


            var testEmpty = String.IsNullOrEmpty("This is a test string");
            logger.LogInformation(testEmpty.ToString());

            #region FactoryMethodPattern

            logger.LogInformation("FactoryMethod");

            var        reconObj = _provider.GetService <IReconObjectFactory>();
            IReconcile recTrade = reconObj.GetReconObject("Trades");
            recTrade.DoReconciliation();

            IReconcile recFixing = reconObj.GetReconObject("Fixings");
            recFixing.DoReconciliation();

            #endregion

            #region SingletonPattern

            logger.LogInformation("Singleton");

            var singleObj1 = SingletonService.GetInstance();
            singleObj1.PrintPattern();

            var singleObj2 = SingletonService.GetInstance();
            singleObj2.PrintPattern();

            #endregion

            Console.ReadLine();
        }
        public IReconcile GetReconObject(string ReconType)
        {
            IReconcile objReconcile = null;

            switch (ReconType)
            {
            case "Trades":
                objReconcile = new ReconcileTrades(_loggerFactory);
                break;

            case "Fixings":
                objReconcile = new ReconcileFixings(_loggerFactory);
                break;
            }
            return(objReconcile);
        }
Esempio n. 4
0
        public void ReturnCreatedObject()
        {
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddScoped <IReconObjectFactory, ReconObjectFactory>();
            serviceCollection.AddScoped <ILoggerFactory, LoggerFactory>();

            _serviceProvider = serviceCollection.BuildServiceProvider();
            var reconObj = _serviceProvider.GetService <IReconObjectFactory>();

            IReconcile recObj1 = reconObj.GetReconObject("Trades");

            Assert.IsType <ReconcileTrades>(recObj1);
            Assert.IsNotType <ReconcileFixings>(recObj1);

            IReconcile recObj2 = reconObj.GetReconObject("Fixings");

            Assert.IsType <ReconcileFixings>(recObj2);
            Assert.IsNotType <ReconcileTrades>(recObj2);
        }