Exemple #1
0
        private async Task CreateBuyers(EnvironmentSeed seed, string token)
        {
            seed.Buyers.Add(new HSBuyer
            {
                Name   = "Default HeadStart Buyer",
                Active = true,
                xp     = new BuyerXp
                {
                    MarkupPercent = 0
                }
            });
            foreach (var buyer in seed.Buyers)
            {
                var superBuyer = new SuperHSBuyer()
                {
                    Buyer  = buyer,
                    Markup = new BuyerMarkup()
                    {
                        Percent = 0
                    }
                };

                var exists = await BuyerExistsAsync(buyer.Name, token);

                if (!exists)
                {
                    await _buyerCommand.Create(superBuyer, token, isSeedingEnvironment : true);
                }
            }
        }
 private async Task CreateBuyers(EnvironmentSeed seed, VerifiedUserContext user)
 {
     seed.Buyers.Add(new HSBuyer
     {
         ID     = "Default_HeadStart_Buyer",
         Name   = "Default HeadStart Buyer",
         Active = true,
         xp     = new BuyerXp
         {
             MarkupPercent = 0
         }
     });
     foreach (var buyer in seed.Buyers)
     {
         var superBuyer = new SuperHSBuyer()
         {
             Buyer  = buyer,
             Markup = new BuyerMarkup()
             {
                 Percent = 0
             }
         };
         await _buyerCommand.Create(superBuyer, user, isSeedingEnvironment : true);
     }
 }
        private async Task CreateBuyers(EnvironmentSeed seed, string token)
        {
            var defaultBuyer = SeedConstants.DefaultBuyer();

            seed.Buyers.Add(defaultBuyer);
            foreach (var buyer in seed.Buyers)
            {
                var superBuyer = new SuperHSBuyer()
                {
                    Buyer  = buyer,
                    Markup = new BuyerMarkup()
                    {
                        Percent = 0
                    }
                };

                var exists = await BuyerExistsAsync(buyer.Name, token);

                if (exists == null || exists.Count == 0)
                {
                    var createdBuyer = await _buyerCommand.Create(superBuyer, token, _oc);

                    if (createdBuyer.Buyer.Name == defaultBuyer.Name && seed.AnonymousShoppingBuyerID == null)
                    {
                        seed.AnonymousShoppingBuyerID = createdBuyer.Buyer.ID;
                    }
                }
                else
                {
                    seed.AnonymousShoppingBuyerID = exists.FirstOrDefault().ID;
                }
            }
        }
        private async Task CreateOnlyOnceAnonBuyerConfig(EnvironmentSeed seed, string token)
        {
            // validate AnonymousShoppingBuyerID or provide fallback if none is defined
            var allBuyers = await _oc.Buyers.ListAllAsync(accessToken : token);

            if (seed.AnonymousShoppingBuyerID != null)
            {
                if (!allBuyers.Select(b => b.ID).Contains(seed.AnonymousShoppingBuyerID))
                {
                    throw new Exception("The buyer defined by AnonymousShoppingBuyerID does not exist");
                }
            }
            else
            {
                seed.AnonymousShoppingBuyerID = SeedConstants.DefaultBuyerID;
            }

            //create and assign initial buyer location
            await _buyerLocationCommand.Save(seed.AnonymousShoppingBuyerID,
                                             $"{seed.AnonymousShoppingBuyerID}-{SeedConstants.DefaultLocationID}",
                                             SeedConstants.DefaultBuyerLocation(), token, _oc);

            // create user
            var anonBuyerUser = await _oc.Users.SaveAsync(seed.AnonymousShoppingBuyerID, SeedConstants.AnonymousBuyerUser().ID, SeedConstants.AnonymousBuyerUser(), token);

            // save assignment between user and buyergroup (location)
            var assignment = new UserGroupAssignment()
            {
                UserGroupID = $"{seed.AnonymousShoppingBuyerID}-{SeedConstants.DefaultLocationID}",
                UserID      = anonBuyerUser.ID
            };
            await _oc.UserGroups.SaveUserAssignmentAsync(seed.AnonymousShoppingBuyerID, assignment, accessToken : token);
        }
        private async Task AssignSecurityProfiles(EnvironmentSeed seed, string orgToken)
        {
            // assign buyer security profiles
            var buyerSecurityProfileAssignmentRequests = seed.Buyers.Select(b =>
            {
                return(_oc.SecurityProfiles.SaveAssignmentAsync(new SecurityProfileAssignment
                {
                    BuyerID = b.ID,
                    SecurityProfileID = CustomRole.HSBaseBuyer.ToString()
                }, orgToken));
            });
            await Task.WhenAll(buyerSecurityProfileAssignmentRequests);

            // assign seller security profiles to seller org
            var sellerSecurityProfileAssignmentRequests = SeedConstants.SellerHsRoles.Select(role =>
            {
                return(_oc.SecurityProfiles.SaveAssignmentAsync(new SecurityProfileAssignment()
                {
                    SecurityProfileID = role.ToString()
                }, orgToken));
            });
            await Task.WhenAll(sellerSecurityProfileAssignmentRequests);

            // assign full access security profile to default admin user
            var defaultAdminUser = (await _oc.AdminUsers.ListAsync(accessToken: orgToken)).Items.First(u => u.Username == SeedConstants.SellerUserName);
            await _oc.SecurityProfiles.SaveAssignmentAsync(new SecurityProfileAssignment()
            {
                SecurityProfileID = SeedConstants.FullAccessSecurityProfile,
                UserID            = defaultAdminUser.ID
            }, orgToken);
        }
Exemple #6
0
        private async Task CreateDefaultSellerUsers(EnvironmentSeed seed, string token)
        {
            // the middleware api client will use this user as the default context user
            var middlewareIntegrationsUser = new User
            {
                ID        = "MiddlewareIntegrationsUser",
                Username  = _sellerUserName,
                Email     = "*****@*****.**",
                Active    = true,
                FirstName = "Default",
                LastName  = "User"
            };
            await _oc.AdminUsers.SaveAsync(middlewareIntegrationsUser.ID, middlewareIntegrationsUser, token);

            // used to log in immediately after seeding the organization
            var initialAdminUser = new User
            {
                ID        = "InitialAdminUser",
                Username  = seed.InitialAdminUsername,
                Password  = seed.InitialAdminPassword,
                Email     = "*****@*****.**",
                Active    = true,
                FirstName = "Initial",
                LastName  = "User"
            };
            await _oc.AdminUsers.SaveAsync(initialAdminUser.ID, initialAdminUser, token);
        }
        public async Task CreateSecurityProfiles(EnvironmentSeed seed, string accessToken)
        {
            var profiles = DefaultSecurityProfiles.Select(p =>
                                                          new SecurityProfile()
            {
                Name        = p.CustomRole.ToString(),
                ID          = p.CustomRole.ToString(),
                CustomRoles = p.CustomRoles == null ? new List <string>()
                {
                    p.CustomRole.ToString()
                } : p.CustomRoles.Append(p.CustomRole).Select(r => r.ToString()).ToList(),
                Roles = p.Roles
            }).ToList();

            profiles.Add(new SecurityProfile()
            {
                Roles = new List <ApiRole> {
                    ApiRole.FullAccess
                },
                Name = _fullAccessSecurityProfile,
                ID   = _fullAccessSecurityProfile
            });

            var profileCreateRequests = profiles.Select(p => _oc.SecurityProfiles.CreateAsync(p, accessToken));
            await Task.WhenAll(profileCreateRequests);
        }
 private async Task CreateSuppliers(VerifiedUserContext user, EnvironmentSeed seed, string token)
 {
     // Create Suppliers and necessary user groups and security profile assignments
     foreach (HSSupplier supplier in seed.Suppliers)
     {
         await _supplierCommand.Create(supplier, user, isSeedingEnvironment : true);
     }
 }
Exemple #9
0
        private async Task CreateOnlyOnceApiClients(EnvironmentSeed seed, string token)
        {
            var existingClients = await _oc.ApiClients.ListAllAsync(accessToken : token);

            await CreateOrGetBuyerClient(existingClients, SeedConstants.BuyerClient(seed), seed, token);
            await CreateOrGetApiClient(existingClients, SeedConstants.IntegrationsClient(), token);
            await CreateOrGetApiClient(existingClients, SeedConstants.SellerClient(), token);
            await CreateOrGetApiClient(existingClients, SeedConstants.BuyerLocalClient(seed), token);
        }
Exemple #10
0
 public static MessageSender SuplierEmails(EnvironmentSeed seed)
 {
     return(new MessageSender()
     {
         ID = "SupplierEmails",
         Name = "Supplier Emails",
         MessageTypes = new[] {
             MessageType.ForgottenPassword,
         },
         URL = seed.MiddlewareBaseUrl + "/messagesenders/{messagetype}",
         SharedKey = seed.OrderCloudSettings.WebhookHashKey
     });
 }
        private async Task CreateSuppliers(EnvironmentSeed seed, string token)
        {
            // Create Suppliers and necessary user groups and security profile assignments
            foreach (HSSupplier supplier in seed.Suppliers)
            {
                var exists = await SupplierExistsAsync(supplier.Name, token);

                if (!exists)
                {
                    await _supplierCommand.Create(supplier, token, isSeedingEnvironment : true);
                }
            }
        }
Exemple #12
0
 public static ApiClient BuyerLocalClient(EnvironmentSeed seed)
 {
     return(new ApiClient()
     {
         AppName = BuyerLocalApiClientName,
         Active = true,
         AllowAnyBuyer = true,
         AllowAnySupplier = false,
         AllowSeller = false,
         AccessTokenDuration = 600,
         RefreshTokenDuration = 43200,
         DefaultContextUserName = seed.EnableAnonymousShopping ? AnonymousBuyerUser().ID : null,
         IsAnonBuyer = seed.EnableAnonymousShopping
     });
 }
        private async Task CreateMessageSenders(EnvironmentSeed seed, string accessToken)
        {
            var defaultMessageSenders = new List <MessageSender>()
            {
                SeedConstants.BuyerEmails(_settings),
                SeedConstants.SellerEmails(_settings),
                SeedConstants.SuplierEmails(_settings)
            };

            foreach (var sender in defaultMessageSenders)
            {
                var messageSender = await _oc.MessageSenders.SaveAsync(sender.ID, sender, accessToken);

                if (messageSender.ID == "BuyerEmails")
                {
                    foreach (var buyer in seed.Buyers)
                    {
                        await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                        {
                            MessageSenderID = messageSender.ID,
                            BuyerID         = buyer.ID
                        }, accessToken);
                    }
                }
                else if (messageSender.ID == "SellerEmails")
                {
                    try
                    {
                        await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                        {
                            MessageSenderID = messageSender.ID
                        }, accessToken);
                    } catch (Exception ex) { }
                }
                else if (messageSender.ID == "SupplierEmails")
                {
                    foreach (var supplier in seed.Suppliers)
                    {
                        await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                        {
                            MessageSenderID = messageSender.ID,
                            SupplierID      = supplier.ID
                        }, accessToken);
                    }
                }
            }
        }
        public async Task <string> Seed(EnvironmentSeed seed)
        {
            if (string.IsNullOrEmpty(_settings.OrderCloudSettings.ApiUrl))
            {
                throw new Exception("Missing required app setting OrderCloudSettings:ApiUrl");
            }
            if (string.IsNullOrEmpty(_settings.OrderCloudSettings.WebhookHashKey))
            {
                throw new Exception("Missing required app setting OrderCloudSettings:WebhookHashKey");
            }
            if (string.IsNullOrEmpty(_settings.EnvironmentSettings.BaseUrl))
            {
                throw new Exception("Missing required app setting EnvironmentSettings:BaseUrl");
            }

            var portalUserToken = await _portal.Login(seed.PortalUsername, seed.PortalPassword);

            await VerifyOrgExists(seed.SellerOrgID, portalUserToken);

            var orgToken = await _portal.GetOrgToken(seed.SellerOrgID, portalUserToken);

            await CreateDefaultSellerUser(orgToken);
            await CreateApiClients(orgToken);
            await CreateSecurityProfiles(seed, orgToken);
            await AssignSecurityProfiles(seed, orgToken);

            var apiClients = await GetApiClients(orgToken);

            await CreateWebhooks(new string[] { apiClients.BuyerUiApiClient.ID }, apiClients.AdminUiApiClient.ID, orgToken);
            await CreateMessageSenders(orgToken);
            await CreateIncrementors(orgToken);             // must be before CreateBuyers

            var userContext = await GetVerifiedUserContext(apiClients.MiddlewareApiClient);

            await CreateBuyers(seed, userContext);
            await CreateXPIndices(orgToken);
            await CreateAndAssignIntegrationEvents(new string[] { apiClients.BuyerUiApiClient.ID }, apiClients.BuyerLocalUiApiClient.ID, orgToken);
            await CreateSuppliers(userContext, seed, orgToken);
            await CreateContentDocSchemas(userContext);
            await CreateDefaultContentDocs(userContext);

            return(orgToken);
        }
        private async Task CreateConfigureAnonBuyer(EnvironmentSeed seed, string token)
        {
            var anonBuyer    = SeedConstants.AnonymousBuyerUser();
            var defaultBuyer = SeedConstants.DefaultBuyer();

            //create anonymous buyer user
            var createUser = _oc.Users.SaveAsync(seed.AnonymousShoppingBuyerID, anonBuyer.ID, anonBuyer, token);

            //create and assign initial buyer location
            var createBuyerLocation = _buyerLocationCommand.Save(seed.AnonymousShoppingBuyerID,
                                                                 $"{seed.AnonymousShoppingBuyerID}-{SeedConstants.DefaultLocationID}",
                                                                 SeedConstants.DefaultBuyerLocation(), token, true);

            var assignment = new UserGroupAssignment()
            {
                UserGroupID = $"{seed.AnonymousShoppingBuyerID}-{SeedConstants.DefaultLocationID}",
                UserID      = anonBuyer.ID
            };
            var saveAssignment = _oc.UserGroups.SaveUserAssignmentAsync(seed.AnonymousShoppingBuyerID, assignment, token);
            await Task.WhenAll(createUser, createBuyerLocation, saveAssignment);
        }
Exemple #16
0
 public static MessageSender BuyerEmails(EnvironmentSeed seed)
 {
     return(new MessageSender()
     {
         ID = "BuyerEmails",
         Name = "Buyer Emails",
         MessageTypes = new[] {
             MessageType.ForgottenPassword,
             MessageType.NewUserInvitation,
             MessageType.OrderApproved,
             MessageType.OrderDeclined,
             // MessageType.OrderSubmitted, this is currently being handled in PostOrderSubmitCommand, possibly move to message senders
             MessageType.OrderSubmittedForApproval,
             // MessageType.OrderSubmittedForYourApprovalHasBeenApproved, // too noisy
             // MessageType.OrderSubmittedForYourApprovalHasBeenDeclined, // too noisy
             // MessageType.ShipmentCreated this is currently being triggered in-app possibly move to message senders
         },
         URL = seed.MiddlewareBaseUrl + "/messagesenders/{messagetype}",
         SharedKey = seed.OrderCloudSettings.WebhookHashKey
     });
 }
        private async Task CreateOnlyOnceBuyers(EnvironmentSeed seed, string token)
        {
            // create default buyer if it does not exist
            // default buyer will have a well-known ID we can use to query with
            var defaultBuyer = await GetBuyerByID(SeedConstants.DefaultBuyerID, token);

            if (defaultBuyer == null)
            {
                var superBuyer = new SuperHSBuyer()
                {
                    Buyer  = SeedConstants.DefaultBuyer(),
                    Markup = new BuyerMarkup()
                    {
                        Percent = 0
                    }
                };
                await _buyerCommand.Create(superBuyer, token, _oc);
            }

            // create seed buyers if they don't exist
            // seed buyers may not have ID defined, we are relying on Name instead
            foreach (var buyer in seed.Buyers)
            {
                var seedBuyer = await GetBuyerByName(buyer.Name, token);

                if (seedBuyer == null)
                {
                    var superBuyer = new SuperHSBuyer()
                    {
                        Buyer  = buyer,
                        Markup = new BuyerMarkup()
                        {
                            Percent = 0
                        }
                    };
                    await _buyerCommand.Create(superBuyer, token, _oc);
                }
            }
        }
        private async Task CreateOrUpdateSecurityProfileAssignments(EnvironmentSeed seed, string orgToken)
        {
            // assign buyer security profiles
            var buyerSecurityProfileAssignmentRequests = seed.Buyers.Select(b =>
            {
                return(_oc.SecurityProfiles.SaveAssignmentAsync(new SecurityProfileAssignment
                {
                    BuyerID = b.ID,
                    SecurityProfileID = CustomRole.HSBaseBuyer.ToString()
                }, orgToken));
            });
            await Task.WhenAll(buyerSecurityProfileAssignmentRequests);

            // assign seller security profiles to seller org
            var sellerSecurityProfileAssignmentRequests = SeedConstants.SellerHsRoles.Select(role =>
            {
                return(_oc.SecurityProfiles.SaveAssignmentAsync(new SecurityProfileAssignment()
                {
                    SecurityProfileID = role.ToString()
                }, orgToken));
            });
            await Task.WhenAll(sellerSecurityProfileAssignmentRequests);

            // assign full access security profile to default admin user
            var adminUsersList = await _oc.AdminUsers.ListAsync(filters : new { Username = SeedConstants.SellerUserName }, accessToken : orgToken);

            var defaultAdminUser = adminUsersList.Items.FirstOrDefault();

            if (defaultAdminUser == null)
            {
                throw new Exception($"Unable to find default admin user (username: {SeedConstants.SellerUserName}");
            }
            await _oc.SecurityProfiles.SaveAssignmentAsync(new SecurityProfileAssignment()
            {
                SecurityProfileID = SeedConstants.FullAccessSecurityProfile,
                UserID            = defaultAdminUser.ID
            }, orgToken);
        }
Exemple #19
0
        private async Task CreateMessageSenders(EnvironmentSeed seed, string accessToken)
        {
            foreach (var sender in DefaultMessageSenders())
            {
                var messageSender = await _oc.MessageSenders.SaveAsync(sender.ID, sender, accessToken);

                if (messageSender.ID == "BuyerEmails")
                {
                    foreach (var buyer in seed.Buyers)
                    {
                        await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                        {
                            MessageSenderID = messageSender.ID,
                            BuyerID         = buyer.ID
                        }, accessToken);
                    }
                }
                else if (messageSender.ID == "SellerEmails")
                {
                    await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                    {
                        MessageSenderID = messageSender.ID
                    }, accessToken);
                }
                else if (messageSender.ID == "SupplierEmails")
                {
                    foreach (var supplier in seed.Suppliers)
                    {
                        await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                        {
                            MessageSenderID = messageSender.ID,
                            SupplierID      = supplier.ID
                        }, accessToken);
                    }
                }
            }
        }
        private async Task CreateOrUpdateAndAssignIntegrationEvents(string token, EnvironmentSeed seed = null)
        {
            var storefrontApiClientIDs = await GetStoreFrontClientIDs(token);

            var apiClients = await GetApiClients(token);

            var localBuyerClientID = apiClients.BuyerLocalUiApiClient.ID;

            // this gets called by both the /seed command and the post-staging restore so we need to handle getting settings from two sources
            var middlewareBaseUrl = seed != null ? seed.MiddlewareBaseUrl : _settings.EnvironmentSettings.MiddlewareBaseUrl;
            var webhookHashKey    = seed != null ? seed.OrderCloudSettings.WebhookHashKey : _settings.OrderCloudSettings.WebhookHashKey;
            var checkoutEvent     = SeedConstants.CheckoutEvent(middlewareBaseUrl, webhookHashKey);
            await _oc.IntegrationEvents.SaveAsync(checkoutEvent.ID, checkoutEvent, token);

            var localCheckoutEvent = SeedConstants.LocalCheckoutEvent(webhookHashKey);
            await _oc.IntegrationEvents.SaveAsync(localCheckoutEvent.ID, localCheckoutEvent, token);

            await _oc.ApiClients.PatchAsync(localBuyerClientID, new PartialApiClient { OrderCheckoutIntegrationEventID = "HeadStartCheckoutLOCAL" }, token);

            await Throttler.RunAsync(storefrontApiClientIDs, 500, 20, clientID =>
                                     _oc.ApiClients.PatchAsync(clientID, new PartialApiClient {
                OrderCheckoutIntegrationEventID = "HeadStartCheckout"
            }, token));
        }
        private async Task CreateMessageSenders(EnvironmentSeed seed, string accessToken)
        {
            var defaultMessageSenders = new List <MessageSender>()
            {
                SeedConstants.BuyerEmails(seed),
                SeedConstants.SellerEmails(seed),
                SeedConstants.SuplierEmails(seed)
            };

            foreach (var sender in defaultMessageSenders)
            {
                var messageSender = await _oc.MessageSenders.SaveAsync(sender.ID, sender, accessToken);

                if (messageSender.ID == "BuyerEmails")
                {
                    foreach (var buyer in seed.Buyers)
                    {
                        try
                        {
                            await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                            {
                                MessageSenderID = messageSender.ID,
                                BuyerID         = buyer.ID
                            }, accessToken);
                        }
                        catch (OrderCloudException ex)
                        {
                            if (ex.HttpStatus != HttpStatusCode.Conflict) // this is a bug in the api https://four51.atlassian.net/browse/EX-2210
                            {
                                throw ex;
                            }
                        }
                    }
                }
                else if (messageSender.ID == "SellerEmails")
                {
                    try
                    {
                        await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                        {
                            MessageSenderID = messageSender.ID
                        }, accessToken);
                    }
                    catch (OrderCloudException ex)
                    {
                        if (ex.HttpStatus != HttpStatusCode.Conflict) // this is a bug in the api https://four51.atlassian.net/browse/EX-2210
                        {
                            throw ex;
                        }
                    }
                }
                else if (messageSender.ID == "SupplierEmails")
                {
                    foreach (var supplier in seed.Suppliers)
                    {
                        try
                        {
                            await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                            {
                                MessageSenderID = messageSender.ID,
                                SupplierID      = supplier.ID
                            }, accessToken);
                        }
                        catch (OrderCloudException ex)
                        {
                            if (ex.HttpStatus != HttpStatusCode.Conflict) // this is a bug in the api https://four51.atlassian.net/browse/EX-2210
                            {
                                throw ex;
                            }
                        }
                    }
                }
            }
        }
Exemple #22
0
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, UserSeed userSeed, RoleSeed roleSeed, LevelSeed levelSeed, EnvironmentSeed environmentSeed, LogSeed logSeed, EventSeed eventSeed)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                userSeed.Populate();
                roleSeed.Populate();
                levelSeed.Populate();
                environmentSeed.Populate();
                logSeed.Populate();
                eventSeed.Populate();
            }

            app.UseSwaggerSetup();

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseCors(c =>
            {
                c.AllowAnyHeader();
                c.AllowAnyMethod();
                c.AllowAnyOrigin();
            });

            app.UseAuthentication();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }
Exemple #23
0
        /// <summary>
        /// This seeding function can be used to initially seed an marketplace
        /// it is also meant to be safe to call after an marketplace has been seeded (by including seed.MarketplaceID)
        /// If a method starts with CreateOrUpdate it will update the resource every time its called based on what has been defined in SeedConstants.cs
        /// If a method starts with CreateOnlyOnce it will only create the resource once and then ignore thereafter
        /// The CreateOnlyOnce resources are likely to change after initial creation so we ignore to avoid overwriting desired changes that happen outside of seeding
        /// </summary>
        public async Task <EnvironmentSeedResponse> Seed(EnvironmentSeed seed)
        {
            OcEnv requestedEnv = validateEnvironment(seed.OrderCloudSettings.Environment);

            if (requestedEnv.environmentName == OrderCloudEnvironments.Production.environmentName && seed.MarketplaceID == null)
            {
                throw new Exception("Cannot create a production environment via the environment seed endpoint. Please contact an OrderCloud Developer to create a production marketplace.");
            }

            // lets us handle requests to multiple api environments
            _oc = new OrderCloudClient(new OrderCloudClientConfig
            {
                ApiUrl  = requestedEnv.apiUrl,
                AuthUrl = requestedEnv.apiUrl
            });

            var portalUserToken = await _portal.Login(seed.PortalUsername, seed.PortalPassword);

            var marketplace = await GetOrCreateMarketplace(portalUserToken, requestedEnv.environmentName, seed.MarketplaceName, seed.MarketplaceID);

            var marketplaceToken = await _portal.GetMarketplaceToken(marketplace.Id, portalUserToken);

            await CreateOrUpdateDefaultSellerUser(seed, marketplaceToken);

            await CreateOnlyOnceIncrementors(marketplaceToken);                       // must be before CreateBuyers
            await CreateOrUpdateMessageSendersAndAssignments(seed, marketplaceToken); // must be before CreateBuyers and CreateSuppliers

            await CreateOrUpdateSecurityProfiles(marketplaceToken);
            await CreateOnlyOnceBuyers(seed, marketplaceToken);

            await CreateOnlyOnceApiClients(seed, marketplaceToken);
            await CreateOrUpdateSecurityProfileAssignments(seed, marketplaceToken);

            await CreateOrUpdateXPIndices(marketplaceToken);
            await CreateOrUpdateAndAssignIntegrationEvents(marketplaceToken, seed);
            await CreateOrUpdateSuppliers(seed, marketplaceToken);

            await CreateOrUpdateProductFacets(marketplaceToken);

            if (seed?.StorageAccountSettings?.ConnectionString != null && seed?.StorageAccountSettings?.ContainerNameTranslations != null)
            {
                await UpdateTranslations(seed.StorageAccountSettings.ConnectionString, seed.StorageAccountSettings.ContainerNameTranslations);
            }

            var apiClients = await GetApiClients(marketplaceToken);

            return(new EnvironmentSeedResponse
            {
                Comments = "Success! Your environment is now seeded. The following clientIDs & secrets should be used to finalize the configuration of your application. The initial admin username and password can be used to sign into your admin application",
                MarketplaceName = marketplace.Name,
                MarketplaceID = marketplace.Id,
                OrderCloudEnvironment = requestedEnv.environmentName,
                ApiClients = new Dictionary <string, dynamic>
                {
                    ["Middleware"] = new
                    {
                        ClientID = apiClients.MiddlewareApiClient.ID,
                        ClientSecret = apiClients.MiddlewareApiClient.ClientSecret
                    },
                    ["Seller"] = new
                    {
                        ClientID = apiClients.AdminUiApiClient.ID
                    },
                    ["Buyer"] = new
                    {
                        ClientID = apiClients.BuyerUiApiClient.ID
                    }
                }
            });
        }
        public async Task <EnvironmentSeedResponse> Seed(EnvironmentSeed seed)
        {
            if (string.IsNullOrEmpty(_settings.OrderCloudSettings.ApiUrl))
            {
                throw new Exception("Missing required app setting OrderCloudSettings:ApiUrl");
            }
            if (string.IsNullOrEmpty(_settings.OrderCloudSettings.WebhookHashKey))
            {
                throw new Exception("Missing required app setting OrderCloudSettings:WebhookHashKey");
            }
            if (string.IsNullOrEmpty(_settings.EnvironmentSettings.MiddlewareBaseUrl))
            {
                throw new Exception("Missing required app setting EnvironmentSettings:MiddlewareBaseUrl");
            }

            var portalUserToken = await _portal.Login(seed.PortalUsername, seed.PortalPassword);

            await VerifyOrgExists(seed.SellerOrgID, portalUserToken);

            var orgToken = await _portal.GetOrgToken(seed.SellerOrgID, portalUserToken);

            await CreateDefaultSellerUsers(seed, orgToken);

            await CreateIncrementors(orgToken);         // must be before CreateBuyers
            await CreateMessageSenders(seed, orgToken); // must be before CreateBuyers and CreateSuppliers

            await CreateSecurityProfiles(orgToken);
            await CreateBuyers(seed, orgToken);
            await CreateConfigureAnonBuyer(seed, orgToken);

            await CreateApiClients(orgToken);
            await AssignSecurityProfiles(seed, orgToken);

            var apiClients = await GetApiClients(orgToken);

            await CreateXPIndices(orgToken);
            await CreateAndAssignIntegrationEvents(new string[] { apiClients.BuyerUiApiClient.ID }, apiClients.BuyerLocalUiApiClient.ID, orgToken);
            await CreateSuppliers(seed, orgToken);

            // populates exchange rates into blob container name: settings.BlobSettings.ContainerNameExchangeRates or "currency" if setting is not defined
            await _exhangeRates.Update();

            // populate default english translations into blob container name: settings.BlobSettings.ContainerNameTranslations or "ngx-translate" if setting is not defined
            // provide other language files to support multiple languages
            var currentDirectory        = Directory.GetCurrentDirectory();
            var englishTranslationsPath = Path.GetFullPath(Path.Combine(currentDirectory, @"..\Headstart.Common\Assets\english-translations.json"));
            await _translationsBlob.Save("i18n/en.json", File.ReadAllText(englishTranslationsPath));

            return(new EnvironmentSeedResponse
            {
                Comments = "Success! Your environment is now seeded. The following clientIDs & secrets should be used to finalize the configuration of your application. The initial admin username and password can be used to sign into your admin application",
                ApiClients = new Dictionary <string, dynamic>
                {
                    ["Middleware"] = new
                    {
                        ClientID = apiClients.MiddlewareApiClient.ID,
                        ClientSecret = apiClients.MiddlewareApiClient.ClientSecret
                    },
                    ["Seller"] = new
                    {
                        ClientID = apiClients.AdminUiApiClient.ID
                    },
                    ["Buyer"] = new
                    {
                        ClientID = apiClients.BuyerUiApiClient.ID
                    }
                }
            });
        }
        private async Task CreateOrUpdateMessageSendersAndAssignments(EnvironmentSeed seed, string accessToken)
        {
            var defaultMessageSenders = new List <MessageSender>()
            {
                SeedConstants.BuyerEmails(seed),
                SeedConstants.SellerEmails(seed),
                SeedConstants.SuplierEmails(seed)
            };
            var existingMessageSenders = await _oc.MessageSenders.ListAllAsync(accessToken : accessToken);

            foreach (var sender in defaultMessageSenders)
            {
                var messageSender = await GetOrCreateMessageSender(existingMessageSenders, sender, accessToken);

                if (messageSender.ID == "BuyerEmails")
                {
                    var allBuyers = await _oc.Buyers.ListAllAsync(accessToken : accessToken);

                    foreach (var buyer in allBuyers)
                    {
                        try
                        {
                            await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                            {
                                MessageSenderID = messageSender.ID,
                                BuyerID         = buyer.ID
                            }, accessToken);
                        }
                        catch (OrderCloudException ex)
                        {
                            // this is a bug in the api PUTs should never return 409s so ignore those errors
                            // https://four51.atlassian.net/browse/EX-2210
                            if (ex.HttpStatus != HttpStatusCode.Conflict)
                            {
                                throw ex;
                            }
                        }
                    }
                }
                else if (messageSender.ID == "SellerEmails")
                {
                    try
                    {
                        await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                        {
                            MessageSenderID = messageSender.ID
                        }, accessToken);
                    }
                    catch (OrderCloudException ex)
                    {
                        // this is a bug in the api PUTs should never return 409s so ignore those errors
                        // https://four51.atlassian.net/browse/EX-2210
                        if (ex.HttpStatus != HttpStatusCode.Conflict)
                        {
                            throw ex;
                        }
                    }
                }
                else if (messageSender.ID == "SupplierEmails")
                {
                    var allSuppliers = await _oc.Suppliers.ListAllAsync(accessToken : accessToken);

                    foreach (var supplier in allSuppliers)
                    {
                        try
                        {
                            await _oc.MessageSenders.SaveAssignmentAsync(new MessageSenderAssignment
                            {
                                MessageSenderID = messageSender.ID,
                                SupplierID      = supplier.ID
                            }, accessToken);
                        }
                        catch (OrderCloudException ex)
                        {
                            // this is a bug in the api PUTs should never return 409s so ignore those errors
                            // https://four51.atlassian.net/browse/EX-2210
                            if (ex.HttpStatus != HttpStatusCode.Conflict)
                            {
                                throw ex;
                            }
                        }
                    }
                }
            }
        }
        private async Task <ApiClient> CreateOrGetBuyerClient(List <ApiClient> existingClients, ApiClient client, EnvironmentSeed seed, string token)
        {
            var match = existingClients.FirstOrDefault(c => c.AppName == client.AppName);

            if (match == null)
            {
                await CreateOnlyOnceAnonBuyerConfig(seed, token);

                var apiClient = await _oc.ApiClients.CreateAsync(client, token);

                return(apiClient);
            }
            return(match);
        }
Exemple #27
0
 public async Task Seed([FromBody] EnvironmentSeed seed)
 {
     await _command.Seed(seed);
 }
        public async Task <EnvironmentSeedResponse> Seed(EnvironmentSeed seed)
        {
            OcEnv requestedEnv = validateEnvironment(seed.OrderCloudSettings.Environment);

            if (requestedEnv.environmentName == OrderCloudEnvironments.Production.environmentName && seed.SellerOrgID == null)
            {
                throw new Exception("Cannot create a production environment via the environment seed endpoint. Please contact an OrderCloud Developer to create a production org.");
            }

            // lets us handle requests to multiple api environments
            _oc = new OrderCloudClient(new OrderCloudClientConfig
            {
                ApiUrl  = requestedEnv.apiUrl,
                AuthUrl = requestedEnv.apiUrl
            });

            var portalUserToken = await _portal.Login(seed.PortalUsername, seed.PortalPassword);

            var sellerOrg = await GetOrCreateOrg(portalUserToken, requestedEnv.environmentName, seed.SellerOrgName, seed.SellerOrgID);

            var orgToken = await _portal.GetOrgToken(sellerOrg.Id, portalUserToken);

            await CreateDefaultSellerUsers(seed, orgToken);

            await CreateIncrementors(orgToken);         // must be before CreateBuyers
            await CreateMessageSenders(seed, orgToken); // must be before CreateBuyers and CreateSuppliers

            await CreateSecurityProfiles(orgToken);
            await CreateBuyers(seed, orgToken);
            await CreateConfigureAnonBuyer(seed, orgToken);

            await CreateApiClients(orgToken);
            await AssignSecurityProfiles(seed, orgToken);

            var apiClients = await GetApiClients(orgToken);

            await CreateXPIndices(orgToken);
            await CreateAndAssignIntegrationEvents(new string[] { apiClients.BuyerUiApiClient.ID }, apiClients.BuyerLocalUiApiClient.ID, orgToken, seed);
            await CreateSuppliers(seed, orgToken);

            // populate default english translations into blob container name: settings.BlobSettings.ContainerNameTranslations or "ngx-translate" if setting is not defined
            // provide other language files to support multiple languages

            var englishTranslationsPath = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "Assets", "english-translations.json"));

            if (seed?.BlobSettings?.ConnectionString != null && seed?.BlobSettings?.ContainerNameTranslations != null)
            {
                var translationsConfig = new BlobServiceConfig()
                {
                    ConnectionString = seed.BlobSettings.ConnectionString,
                    Container        = seed.BlobSettings.ContainerNameTranslations,
                    AccessType       = BlobContainerPublicAccessType.Container
                };
                var translationsBlob = new OrderCloudIntegrationsBlobService(translationsConfig);
                await translationsBlob.Save("i18n/en.json", File.ReadAllText(englishTranslationsPath));
            }

            return(new EnvironmentSeedResponse
            {
                Comments = "Success! Your environment is now seeded. The following clientIDs & secrets should be used to finalize the configuration of your application. The initial admin username and password can be used to sign into your admin application",
                OrganizationName = sellerOrg.Name,
                OrganizationID = sellerOrg.Id,
                OrderCloudEnvironment = requestedEnv.environmentName,
                ApiClients = new Dictionary <string, dynamic>
                {
                    ["Middleware"] = new
                    {
                        ClientID = apiClients.MiddlewareApiClient.ID,
                        ClientSecret = apiClients.MiddlewareApiClient.ClientSecret
                    },
                    ["Seller"] = new
                    {
                        ClientID = apiClients.AdminUiApiClient.ID
                    },
                    ["Buyer"] = new
                    {
                        ClientID = apiClients.BuyerUiApiClient.ID
                    }
                }
            });
        }
 public async Task <EnvironmentSeedResponse> Seed([FromBody] EnvironmentSeed seed)
 {
     return(await _command.Seed(seed));
 }
Exemple #30
0
        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, UserSeed userSeed, LogLevelSeed levelSeed, EnvironmentSeed environmentSeed)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                userSeed.Populate();
                levelSeed.Populate();
                environmentSeed.Populate();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseCors(x => x
                        .AllowAnyOrigin()
                        .AllowAnyMethod()
                        .AllowAnyHeader());

            app.UseAuthentication();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });

            app.UseSwagger();
            app.UseSwaggerUI(options => options.SwaggerEndpoint("/swagger/v1/swagger.json", "CadeOErro API"));
        }