コード例 #1
0
 public ApplicationDomain2(ApplicationDomain domain)
 {
     Id           = domain.Id;
     Idle         = domain.Idle;
     PhysicalPath = domain.PhysicalPath;
     VirtualPath  = domain.VirtualPath;
 }
コード例 #2
0
        /// <summary>
        /// Called when the application starts.
        /// </summary>
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            FilterConfig.RegisterGlobalMvcFilters(GlobalFilters.Filters);
            FilterConfig.RegisterWebApiFilters(GlobalConfiguration.Configuration.Filters);

            // configure the web portal client application
            string portalConfigurationPath = ApplicationConfiguration.WebPortalConfigurationFilePath;

            if (string.IsNullOrWhiteSpace(portalConfigurationPath))
            {
                throw new ConfigurationErrorsException("WebPortalConfigurationPath setting not found in web.config");
            }

            // create the web portal configuration manager
            IWebPortalConfigurationFactory webPortalConfigFactory = new WebPortalConfigurationFactory();

            ApplicationConfiguration.WebPortalConfigurationManager = webPortalConfigFactory.Create(portalConfigurationPath);

            // setup the application assets bundles
            ApplicationConfiguration.WebPortalConfigurationManager.UpdateBundles(Bundler.Instance).Wait();

            // intialize our application domain
            ApplicationDomain.InitializeAsync().Wait();
        }
コード例 #3
0
ファイル: Users.cs プロジェクト: tmrconsultweb/TMRC-CSP
        public async Task <IEnumerable <CustomerUser> > Get(string CustomerId)
        {
            CustomerId.AssertNotEmpty(nameof(CustomerId));

            CustomerPrincipal principal;
            CustomerUser      user;
            Guid              correlationId;
            IPartner          operations;
            IExplorerProvider provider;

            correlationId = Guid.NewGuid();

            operations = await ApplicationDomain.GetUserOperationsAsync(correlationId).ConfigureAwait(false);


            // get customer users collection
            //var customerUsers = ApplicationDomain.userCenterClient.Customers.ById(CustomerId).Users.Get();
            principal = new CustomerPrincipal(ClaimsPrincipal.Current);

            if (
                //principal.CustomerId.Equals(provider.Configuration.PartnerCenterAccountId, StringComparison.InvariantCultureIgnoreCase) ||
                principal.CustomerId.Equals(CustomerId, StringComparison.InvariantCultureIgnoreCase))
            {
                //var customer = await ApplicationDomain.userCenterClient.Customers.ById(CustomerId).Users.GetAsync().ConfigureAwait(false);
                var customer = await operations.Customers.ById(CustomerId).Users.GetAsync().ConfigureAwait(false);
            }
            return(null);
        }
コード例 #4
0
        /// <summary>
        /// Creates a new instance of <see cref="EmitConstantData"/>.
        /// </summary>
        /// <param name="domain">The application domain of the script being compiled.</param>
        /// <param name="assembly">The <see cref="AssemblyBuilder"/></param>
        public EmitConstantData(ApplicationDomain domain, AssemblyBuilder assembly)
        {
            m_containerType = assembly.defineType(
                new TypeName(NameMangler.INTERNAL_NAMESPACE, "ConstData"),
                TypeAttributes.Public | TypeAttributes.Sealed | TypeAttributes.Abstract | TypeAttributes.BeforeFieldInit
                );

            FieldBuilder defineField(string name, Type type, bool initOnly = true)
            {
                return(m_containerType.defineField(
                           name,
                           assembly.metadataContext.getTypeSignature(type),
                           FieldAttributes.Public | FieldAttributes.Static | (initOnly ? FieldAttributes.InitOnly : 0)
                           ));
            }

            m_classesArrayField = defineField("classes", typeof(Class[]));
            m_traitsArrayField  = defineField("traits", typeof(Trait[]));
            m_nsArrayField      = defineField("nss", typeof(Namespace[]));
            m_xnsArrayField     = defineField("xnss", typeof(ASNamespace[]));
            m_qnameArrayField   = defineField("qnames", typeof(QName[]));
            m_xqnameArrayField  = defineField("xqnames", typeof(ASQName[]));
            m_nssetArrayField   = defineField("nssets", typeof(NamespaceSet[]));
            m_regexpArrayField  = defineField("regexps", typeof(ASRegExp[]));
            m_globalObjField    = defineField("global", typeof(ASObject), initOnly: false);
            m_appDomainField    = defineField("domain", typeof(ApplicationDomain), initOnly: false);

            m_domain = domain;
        }
コード例 #5
0
        protected void Application_Start()
        {
            IExplorerProvider provider;

            try
            {
                AreaRegistration.RegisterAllAreas();
                GlobalConfiguration.Configure(WebApiConfig.Register);
                FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
                RouteConfig.RegisterRoutes(RouteTable.Routes);
                BundleConfig.RegisterBundles(BundleTable.Bundles);

                System.Web.Helpers.AntiForgeryConfig.UniqueClaimTypeIdentifier = ClaimTypes.NameIdentifier;

                // intialize our application domain PartnerCenterClient and PortalLocalization
                Task.Run(() => ApplicationDomain.BootstrapAsync()).Wait();


                // intialize our User domain PartnerCenterClient and PortalLocalization
                //Task.Run(() => ApplicationDomain.UserAsync()).Wait();


                Database.SetInitializer <ViewModel.Context.ConnectionStringsContext>(null);


                provider = UnityConfig.Container.Resolve <IExplorerProvider>();

                // intialize our application domain
                Task.Run(() => ApplicationDomain.InitializeAsync()).Wait();
            }
            finally
            {
                provider = null;
            }
        }
コード例 #6
0
        public void Start()
        {
            if (isActivated)
            {
                throw new InvalidOperationException("activated");
            }

            isActivated = true;
            @namespace  = conf.GetString(NamespaceProperty);
            var references = conf.GetStringArray(ReferencesProperty);

            foreach (var re in references)
            {
                var reference = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, re);
                AddSysReferencedAssembly(reference);
            }

            var scriptBaseDirectory = Path.Combine(BaseDirectory, AppScriptDomain.AssemblyName);

            if (!Directory.Exists(scriptBaseDirectory))
            {
                Directory.CreateDirectory(scriptBaseDirectory);
            }

            appScriptDomain   = new AppScriptDomain(this, scriptBaseDirectory);
            applicationDomain = new ApplicationDomain(this, scriptBaseDirectory);
            var handleScript = new HandleScriptDomain(this, BaseDirectory);
            var windowScript = new WindowScriptDomain(this, BaseDirectory);

            invokeScriptDomains[handleScript.Extension] = handleScript;
            invokeScriptDomains[windowScript.Extension] = windowScript;

            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
        }
コード例 #7
0
        public ApplicationDomainDTO(ApplicationDomain ad)
        {
            ApplicationDomainId = ad.ApplicationDomainId;

            ApplicationDomainName  = ad.ApplicationDomainName;
            ApplicationDomainDescr = ad.ApplicationDomainDescr;
        }
コード例 #8
0
        /// <summary>
        /// Initializes a new instance of the <see cref="CommerceOperations"/> class.
        /// </summary>
        /// <param name="applicationDomain">An application domain instance.</param>
        /// <param name="customerId">The customer ID who owns the transaction.</param>
        /// <param name="paymentGateway">A payment gateway to use for processing payments resulting from the transaction.</param>
        public CommerceOperations(ApplicationDomain applicationDomain, string customerId, IPaymentGateway paymentGateway) : base(applicationDomain)
        {
            customerId.AssertNotEmpty(nameof(customerId));
            paymentGateway.AssertNotNull(nameof(paymentGateway));

            CustomerId     = customerId;
            PaymentGateway = paymentGateway;
        }
コード例 #9
0
ファイル: ScriptTraits.cs プロジェクト: jfd16/Mariana
 internal ScriptField(
     ABCTraitInfo traitInfo, Class?declClass, ApplicationDomain domain, bool isStatic, Class?fieldType)
     : base(traitInfo.name, declClass, domain, isStatic)
 {
     setIsReadOnly(traitInfo.kind == ABCTraitFlags.Const);
     setMetadata(traitInfo.metadata);
     setFieldType(fieldType);
 }
コード例 #10
0
        /// <summary>
        /// Initializes a new instance of the <see cref="PayPalGateway" /> class.
        /// </summary>
        /// <param name="applicationDomain">The ApplicationDomain</param>
        /// <param name="description">The description which will be added to the Payment Card authorization call.</param>
        public PayPalGateway(ApplicationDomain applicationDomain, string description) : base(applicationDomain)
        {
            description.AssertNotEmpty(nameof(description));
            this.paymentDescription = description;

            this.payerId   = string.Empty;
            this.paymentId = string.Empty;
        }
コード例 #11
0
        /// <summary>
        /// creates a payment gateway instance
        /// </summary>
        /// <param name="applicationDomain">Application domain</param>
        /// <param name="description">the description</param>
        /// <returns>returns payment gateway instance</returns>
        public static IPaymentGateway GetPaymentGatewayInstance(ApplicationDomain applicationDomain, string description)
        {
            if (countryCode.Equals("IN"))
            {
                return(new PayUGateway(applicationDomain, description));
            }

            return(new PayPalGateway(applicationDomain, description));
        }
コード例 #12
0
        /// <summary>
        /// creates a payment gateway instance
        /// </summary>
        /// <param name="applicationDomain">Application domain</param>
        /// <param name="description">the description</param>
        /// <returns>returns payment gateway instance</returns>
        public static IPaymentGateway GetPaymentGatewayInstance(ApplicationDomain applicationDomain, string description)
        {
            if (countryCode.Equals("in", StringComparison.InvariantCultureIgnoreCase))
            {
                return(new PayUGateway(applicationDomain, description));
            }

            return(new PayPalGateway(applicationDomain, description));
        }
コード例 #13
0
        public ActionResult <ApplicationDomainDTO> AddProject([FromBody] ApplicationDomainDTO dto)
        {
            ApplicationDomain ad = new ApplicationDomain {
                ApplicationDomainName  = dto.ApplicationDomainName,
                ApplicationDomainDescr = dto.ApplicationDomainDescr
            };

            _applicationDomains.Add(ad);
            _applicationDomains.SaveChanges();

            return(new ApplicationDomainDTO(ad));
        }
コード例 #14
0
 public static ApplicationDto MapToDtoModel(this ApplicationDomain app)
 {
     return(new ApplicationDto
     {
         Id = app.Id,
         EGN = Encrypt.DecryptData(app.EGN),
         Name = Encrypt.DecryptData(app.Name),
         Status = app.Status,
         PhoneNumber = Encrypt.DecryptData(app.PhoneNumber),
         UserId = app.UserId
     });
 }
コード例 #15
0
        private void ApplicationDomainCreationFinishedCallback(ApplicationDomainCreationFinished arg)
        {
            var applicationDomain = new ApplicationDomain
            {
                InternalId = arg.InternalId,
                Name       = arg.Name,
                ProcessId  = arg.ProcessId
            };

            AddApplicationDomain(applicationDomain);

            Threads.GetByOsThreadId(applicationDomain.ProcessId).Events
            .Add(CreateEvent(applicationDomain, _globalTimeMilliseconds, EventType.CreationFinished));
        }
コード例 #16
0
        /// <summary>
        /// Initializes a new instance of the <see cref="PayPalGateway" /> class.
        /// </summary>
        /// <param name="applicationDomain">The ApplicationDomain</param>
        /// <param name="paymentCard">The Payment Card used in this commerce operation.</param>
        /// <param name="description">The description which will be added to the Payment Card authorization call.</param>
        public PayPalGateway(ApplicationDomain applicationDomain, Models.PaymentCard paymentCard, string description) : base(applicationDomain)
        {
            paymentCard.AssertNotNull(nameof(paymentCard));
            description.AssertNotEmpty(nameof(description));

            // clean up credit card number input.
            string cardNumber = paymentCard.CreditCardNumber;

            cardNumber = cardNumber.Replace(" ", string.Empty); // remove empty spaces in the string.
            cardNumber = cardNumber.Replace("-", string.Empty); // remove dashes.
            paymentCard.CreditCardNumber = cardNumber;

            this.creditCard         = paymentCard;
            this.paymentDescription = description;
        }
コード例 #17
0
        /// <summary>
        /// Initializes a new instance of the <see cref="MicrosoftOfferLogoIndexer"/> class.
        /// </summary>
        /// <param name="applicationDomain">An application domain instance.</param>
        public MicrosoftOfferLogoIndexer(ApplicationDomain applicationDomain) : base(applicationDomain)
        {
            // register offer logo matchers
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "azure", "active directory" }, "/Content/Images/Plugins/ProductLogos/azure-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "dynamics", "crm" }, "/Content/Images/Plugins/ProductLogos/dynamics-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "exchange" }, "/Content/Images/Plugins/ProductLogos/exchange-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "intune" }, "/Content/Images/Plugins/ProductLogos/intune-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "onedrive" }, "/Content/Images/Plugins/ProductLogos/onedrive-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "project" }, "/Content/Images/Plugins/ProductLogos/project-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "sharepoint" }, "/Content/Images/Plugins/ProductLogos/sharepoint-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "skype" }, "/Content/Images/Plugins/ProductLogos/skype-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "visio" }, "/Content/Images/Plugins/ProductLogos/visio-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "office", "365" }, "/Content/Images/Plugins/ProductLogos/office-logo.png"));
            this.offerLogoMatchers.Add(new OfferLogoMatcher(new string[] { "yammer" }, "/Content/Images/Plugins/ProductLogos/yammer-logo.png"));

            // we will default the logo if all the above matchers fail to match the given offer
            this.offerLogoMatchers.Add(new DefaultLogoMatcher());
        }
コード例 #18
0
 /// <summary>
 /// Creates a new LoaderContext object, with the specified settings.
 /// </summary>
 public LoaderContext(bool checkPolicyFile, ApplicationDomain applicationDomain)
 {
 }
コード例 #19
0
        /// <summary>
        /// Initializes a new instance of the <see cref="OrderNormalizer"/> class.
        /// </summary>
        /// <param name="applicationDomain">An application domain instance.</param>
        /// <param name="order">The order which will be normalized.</param>
        public OrderNormalizer(ApplicationDomain applicationDomain, OrderViewModel order) : base(applicationDomain)
        {
            order.AssertNotNull(nameof(order));

            Order = order;
        }
コード例 #20
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PartnerCenterCustomersRepository"/> class.
 /// </summary>
 /// <param name="applicationDomain">An application domain instance.</param>
 public PartnerCenterCustomersRepository(ApplicationDomain applicationDomain) : base(applicationDomain)
 {
 }
コード例 #21
0
 public ApplicationUnderTest(ApplicationDomain appDomain)
 {
     assemblies = new Assemblies(appDomain);
     namespaces = new Namespaces();
     AddNamespace(GetType().Namespace);
 }
コード例 #22
0
 public Assemblies(ApplicationDomain appDomain)
 {
     this.appDomain = appDomain;
     assemblies = new List<Types>();
 }
コード例 #23
0
 /// <summary>
 /// Initializes a new instance of the <see cref="OrdersRepository"/> class.
 /// </summary>
 /// <param name="applicationDomain">An instance of the application domain.</param>
 public OrdersRepository(ApplicationDomain applicationDomain) : base(applicationDomain)
 {
 }
コード例 #24
0
 public Assemblies(Assemblies other)
 {
     appDomain = other.appDomain;
     assemblies = new List<Types>(other.assemblies);
 }
コード例 #25
0
        ///// <summary>
        ///// Gets the summary of subscriptions for a portal customer.
        ///// </summary>
        ///// <param name="customerId">The customer Id.</param>
        ///// <returns>Subscription Summary.</returns>
        //private async Task<SubscriptionsSummary> GetSubscriptionSummaryAsync(string customerId)
        //{
        //    DateTime startTime = DateTime.Now;
        //    IEnumerable<CustomerSubscriptionEntity> customerSubscriptions = await ApplicationDomain.Instance.CustomerSubscriptionsRepository.RetrieveAsync(customerId).ConfigureAwait(false);
        //    IEnumerable<CustomerPurchaseEntity> customerSubscriptionsHistory = await ApplicationDomain.Instance.CustomerPurchasesRepository.RetrieveAsync(customerId).ConfigureAwait(false);
        //    IEnumerable<PartnerOffer> allPartnerOffers = await ApplicationDomain.Instance.OffersRepository.RetrieveAsync().ConfigureAwait(false);
        //    IEnumerable<MicrosoftOffer> currentMicrosoftOffers = await ApplicationDomain.Instance.OffersRepository.RetrieveMicrosoftOffersAsync().ConfigureAwait(false);

        //    // start building the summary.
        //    decimal summaryTotal = 0;

        //    // format all responses to client using portal locale.
        //    CultureInfo responseCulture = new CultureInfo(ApplicationDomain.Instance.PortalLocalization.Locale);
        //    List<SubscriptionViewModel> customerSubscriptionsView = new List<SubscriptionViewModel>();

        //    // iterate through and build the list of customer's subscriptions.
        //    foreach (CustomerSubscriptionEntity subscription in customerSubscriptions)
        //    {
        //        decimal subscriptionTotal = 0;
        //        int licenseTotal = 0;
        //        List<SubscriptionHistory> historyItems = new List<SubscriptionHistory>();

        //        // collect the list of history items for this subcription.
        //        IOrderedEnumerable<CustomerPurchaseEntity> subscriptionHistoryList = customerSubscriptionsHistory
        //            .Where(historyItem => historyItem.SubscriptionId == subscription.SubscriptionId)
        //            .OrderBy(historyItem => historyItem.TransactionDate);

        //        // iterate through and build the SubsriptionHistory for this subscription.
        //        foreach (CustomerPurchaseEntity historyItem in subscriptionHistoryList)
        //        {
        //            decimal orderTotal = Math.Round(historyItem.SeatPrice * historyItem.SeatsBought, responseCulture.NumberFormat.CurrencyDecimalDigits);
        //            historyItems.Add(new SubscriptionHistory()
        //            {
        //                OrderTotal = orderTotal.ToString("C", responseCulture),                                 // Currency format.
        //                PricePerSeat = historyItem.SeatPrice.ToString("C", responseCulture),                    // Currency format.
        //                SeatsBought = historyItem.SeatsBought.ToString("G", responseCulture),                   // General format.
        //                OrderDate = historyItem.TransactionDate.ToLocalTime().ToString("d", responseCulture),   // Short date format.
        //                OperationType = GetOperationType(historyItem.PurchaseType)                         // Localized Operation type string.
        //            });

        //            // Increment the subscription total.
        //            licenseTotal += historyItem.SeatsBought;

        //            // Increment the subscription total.
        //            subscriptionTotal += orderTotal;
        //        }

        //        PartnerOffer partnerOfferItem = allPartnerOffers.FirstOrDefault(offer => offer.Id == subscription.PartnerOfferId);
        //        string subscriptionTitle = partnerOfferItem.Title;
        //        string portalOfferId = partnerOfferItem.Id;
        //        decimal portalOfferPrice = partnerOfferItem.Price;

        //        DateTime subscriptionExpiryDate = subscription.ExpiryDate.ToUniversalTime();
        //        int remainingDays = (subscriptionExpiryDate.Date - DateTime.UtcNow.Date).Days;
        //        bool isRenewable = remainingDays <= 30;
        //        bool isEditable = DateTime.UtcNow.Date <= subscriptionExpiryDate.Date;

        //        // TODO :: Handle Microsoft offer being pulled back due to EOL.

        //        // Temporarily mark this partnerOffer item as inactive and dont allow store front customer to manage this subscription.
        //        MicrosoftOffer alignedMicrosoftOffer = currentMicrosoftOffers.FirstOrDefault(offer => offer.Offer.Id == partnerOfferItem.MicrosoftOfferId);
        //        if (alignedMicrosoftOffer == null)
        //        {
        //            partnerOfferItem.IsInactive = true;
        //        }

        //        if (partnerOfferItem.IsInactive)
        //        {
        //            // in case the offer is inactive (marked for deletion) then dont allow renewals or editing on this subscription tied to this offer.
        //            isRenewable = false;
        //            isEditable = false;
        //        }

        //        // Compute the pro rated price per seat for this subcription & return for client side processing during updates.
        //        decimal proratedPerSeatPrice = Math.Round(CommerceOperations.CalculateProratedSeatCharge(subscription.ExpiryDate, portalOfferPrice), responseCulture.NumberFormat.CurrencyDecimalDigits);

        //        SubscriptionViewModel subscriptionItem = new SubscriptionViewModel()
        //        {
        //            SubscriptionId = subscription.SubscriptionId,
        //            FriendlyName = subscriptionTitle,
        //            PortalOfferId = portalOfferId,
        //            PortalOfferPrice = portalOfferPrice.ToString("C", responseCulture),
        //            IsRenewable = isRenewable,                                                              // IsRenewable is true if subscription is going to expire in 30 days.
        //            IsEditable = isEditable,                                                                // IsEditable is true if today is lesser or equal to subscription expiry date.
        //            LicensesTotal = licenseTotal.ToString("G", responseCulture),                            // General format.
        //            SubscriptionTotal = subscriptionTotal.ToString("C", responseCulture),                   // Currency format.
        //            SubscriptionExpiryDate = subscriptionExpiryDate.Date.ToString("d", responseCulture),    // Short date format.
        //            SubscriptionOrderHistory = historyItems,
        //            SubscriptionProRatedPrice = proratedPerSeatPrice
        //        };

        //        // add this subcription to the customer's subscription list.
        //        customerSubscriptionsView.Add(subscriptionItem);

        //        // Increment the summary total.
        //        summaryTotal += subscriptionTotal;
        //    }

        //    // Capture the request for the customer summary for analysis.
        //    Dictionary<string, string> eventProperties = new Dictionary<string, string> { { "CustomerId", customerId } };

        //    // Track the event measurements for analysis.
        //    Dictionary<string, double> eventMetrics = new Dictionary<string, double> { { "ElapsedMilliseconds", DateTime.Now.Subtract(startTime).TotalMilliseconds }, { "NumberOfSubscriptions", customerSubscriptionsView.Count } };

        //    ApplicationDomain.Instance.TelemetryService.Provider.TrackEvent("GetSubscriptionSummaryAsync", eventProperties, eventMetrics);

        //    // Sort List of subscriptions based on portal offer name.
        //    return new SubscriptionsSummary()
        //    {
        //        Subscriptions = customerSubscriptionsView.OrderBy(subscriptionItem => subscriptionItem.FriendlyName),
        //        SummaryTotal = summaryTotal.ToString("C", responseCulture)      // Currency format.
        //    };
        //}


        /// <summary>
        /// Initializes a new instance of the <see cref="CreateOrder"/> class.
        /// </summary>
        /// <param name="context">The scenario context.</param>
        public Subscriptions(ApplicationDomain applicationDomain) : base(applicationDomain)
        {
        }
コード例 #26
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CustomerSubscriptionsRepository"/> class.
 /// </summary>
 /// <param name="applicationDomain">An application domain instance.</param>
 public CustomerSubscriptionsRepository(ApplicationDomain applicationDomain) : base(applicationDomain)
 {
 }
コード例 #27
0
 public ApplicationUnderTest(ApplicationDomain appDomain)
 {
     assemblies = new Assemblies(appDomain);
     namespaces = new Namespaces();
     AddNamespace(GetType().Namespace);
 }
コード例 #28
0
 public Assemblies(ApplicationDomain appDomain)
 {
     this.appDomain = appDomain;
     assemblies     = new List <Types>();
 }
コード例 #29
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PreApprovalGateway" /> class.
 /// </summary>
 /// <param name="applicationDomain">The ApplicationDomain.</param>
 /// <param name="description">The Payment description.</param>
 public PreApprovalGateway(ApplicationDomain applicationDomain, string description) : base(applicationDomain)
 {
 }
コード例 #30
0
 /// <summary>
 /// Initializes a new instance of the <see cref="DomainObject"/> class.
 /// </summary>
 /// <param name="applicationDomain">An application domain instance.</param>
 protected DomainObject(ApplicationDomain applicationDomain)
 {
     applicationDomain.AssertNotNull(nameof(applicationDomain));
     this.ApplicationDomain = applicationDomain;
 }
コード例 #31
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PartnerOffersRepository"/> class.
 /// </summary>
 /// <param name="applicationDomain">An application domain instance.</param>
 public PartnerOffersRepository(ApplicationDomain applicationDomain) : base(applicationDomain)
 {
 }
コード例 #32
0
        public void Correctly_Determines_Base_Folder()
        {
            IApplicationDomain domain = new ApplicationDomain();

            Assert.That(domain.GetBaseFolder().Length, Is.GreaterThan(5));
        }
コード例 #33
0
        public DummyApplicationDbContext()
        {
            Product testP1 = new Product
            {
                ProductId   = 1,
                ProductName = "Karton",
                Description = "Karton beschrijving",
                Price       = 5
            };

            Product testP2 = new Product
            {
                ProductId   = 2,
                ProductName = "Plastiek",
                Description = "plastiek beschrijving",
                Price       = 20
            };

            Product testP3 = new Product
            {
                ProductId   = 3,
                ProductName = "Lijm",
                Description = "Lijm beschrijving",
                Price       = 8.5
            };

            Product testP4 = new Product
            {
                ProductId   = 4,
                ProductName = "Plakband",
                Description = "Plakband beschrijving",
                Price       = 15
            };

            OrderItem testOrderItem1 = new OrderItem
            {
                OrderItemId = 1,
                Product     = testP1,
                Amount      = 2,
                ProductId   = 1
            };

            OrderItem testOrderItem2 = new OrderItem
            {
                OrderItemId = 2,
                Product     = testP2,
                Amount      = 1,
                ProductId   = 2
            };

            OrderItem testOrderItem3 = new OrderItem
            {
                OrderItemId = 3,
                Product     = testP3,
                Amount      = 3,
                ProductId   = 3
            };

            testOrderItem = new OrderItem
            {
                OrderItemId = 4,
                Product     = testP4,
                Amount      = 5,
                ProductId   = 4
            };

            testOrder = new Order
            {
                OrderId    = 1,
                Approved   = false,
                Submitted  = false,
                OrderItems = new List <OrderItem>
                {
                    testOrderItem1,
                    testOrderItem2,
                    testOrderItem3
                }
            };
            ApplicationDomain applicationDomainTest = new ApplicationDomain
            {
                ApplicationDomainId    = 1,
                ApplicationDomainName  = "naam",
                ApplicationDomainDescr = "niet veel speciaals"
            };

            testGroup = new Group
            {
                GroupId   = 1,
                GroupName = "groepsnaam",
                Order     = testOrder
            };

            testProject = new Project
            {
                ProjectName         = "testproject",
                ProjectDescr        = "ceci est une beschrijving",
                ProjectImage        = "url",
                ProjectBudget       = 20,
                ESchoolGrade        = ESchoolGrade.ALGEMEEN,
                Closed              = false,
                ApplicationDomainId = 1
            };

            projectTemplate1 = new ProjectTemplate
            {
                ProjectName                     = "DitIsEenTest",
                ProjectDescr                    = "Dit is een test voor rojecttemplate",
                ProjectImage                    = "ceci n'est pas une url",
                AddedByGO                       = true,
                ApplicationDomainId             = 1,
                ApplicationDomain               = applicationDomainTest,
                ProductTemplateProjectTemplates = new List <ProductTemplateProjectTemplate>()
            };
            projectTemplate2 = new ProjectTemplate
            {
                ProjectName         = "DitIsEenAndereTest",
                ProjectDescr        = "Dit is 2e een test voor projecttemplate",
                ProjectImage        = "ceci n'est aussie pas une url",
                AddedByGO           = false,
                ApplicationDomainId = 2
            };
            producttemplate1 = new ProductTemplate
            {
                ProductName  = "DitIsEenProductTemplateTest",
                Description  = "dit is een beschrijving voor een producttemplate",
                ProductImage = "dit is ook geen url",
                AddedByGO    = true
            };
            producttemplate2 = new ProductTemplate
            {
                ProductName  = "DitIsEentweedeProductTemplateTest",
                Description  = "dit is een beschrijving voor een andere producttemplate",
                ProductImage = "dit is ook geen url, zot eh",
                AddedByGO    = false
            };
        }
コード例 #34
0
 public Assemblies(Assemblies other)
 {
     appDomain  = other.appDomain;
     assemblies = new List <Types>(other.assemblies);
 }