/// <summary>
        /// Retrieves the tax settings of the account. This method can only be called for accounts to which the managing account has access: either the managing account itself or sub-accounts if the managing account is a multi-client account.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/accounttax/get
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="accountId">The ID of the account for which to get/update account tax settings.</param>
        /// <returns>AccountTaxResponse</returns>
        public static AccountTax Get(ShoppingContentService service, string merchantId, string accountId)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (accountId == null)
                {
                    throw new ArgumentNullException(accountId);
                }

                // Make the request.
                return(service.Accounttax.Get(merchantId, accountId).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Accounttax.Get failed.", ex);
            }
        }
Beispiel #2
0
        public ShoppingContentService GetShoppingContentService()
        {
            if (_contentService == null)
            {
                string appPath = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath;
                var    key     = string.Format(@"{0}{1}{2}", appPath, Path.DirectorySeparatorChar, keyPath);

                var certificate = new X509Certificate2(key, "notasecret", X509KeyStorageFlags.Exportable);

                var credential = new ServiceAccountCredential(
                    new ServiceAccountCredential.Initializer(serviceAccountEmail)
                {
                    Scopes = new[] { ShoppingContentService.Scope.Content }
                }.FromCertificate(certificate));

                // Create the service.
                _contentService = new ShoppingContentService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName       = "VirtoCommerce shopping integration"
                });
            }

            return(_contentService);
        }
        /// <summary>
        /// Retrieves, inserts, and deletes multiple products in a single request. This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/products/custombatch
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="body">A valid ShoppingContent v2 body.</param>
        /// <param name="optional">Optional paramaters.</param>        /// <returns>ProductsCustomBatchResponseResponse</returns>
        public static ProductsCustomBatchResponse Custombatch(ShoppingContentService service, ProductsCustomBatchRequest body, ProductsCustombatchOptionalParms optional = null)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (body == null)
                {
                    throw new ArgumentNullException("body");
                }

                // Building the initial request.
                var request = service.Products.Custombatch(body);

                // Applying optional parameters to the request.
                request = (ProductsResource.CustombatchRequest)SampleHelpers.ApplyOptionalParms(request, optional);

                // Requesting data.
                return(request.Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Products.Custombatch failed.", ex);
            }
        }
Beispiel #4
0
        internal static void Main(string[] args)
        {
            Console.WriteLine("Content API for Shopping Command Line Sample");
            Console.WriteLine("============================================");

            var options = new Options();

            CommandLine.Parser.Default.ParseArgumentsStrict(args, options);

            if (options.ConfigPath == null)
            {
                options.ConfigPath = defaultPath;
            }

            MerchantConfig config = MerchantConfig.Load(options.ConfigPath);

            var initializer = Authenticator.authenticate(config, ShoppingContentService.Scope.Content);

            if (initializer == null)
            {
                Console.WriteLine("Failed to authenticate, so exiting.");
                return;
            }

            // Create the service.
            var service = new ShoppingContentService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = initializer,
                ApplicationName       = config.ApplicationName,
            });

            AccountsSample        accountsSample        = new AccountsSample(service);
            AccountstatusesSample accountstatusesSample =
                new AccountstatusesSample(service, MaxListPageSize);
            AccounttaxSample      accounttaxSample      = new AccounttaxSample(service);
            DatafeedsSample       datafeedsSample       = new DatafeedsSample(service);
            ProductsSample        productsSample        = new ProductsSample(service, MaxListPageSize);
            ProductstatusesSample productstatusesSample =
                new ProductstatusesSample(service, MaxListPageSize);
            ShippingsettingsSample   shippingsettingsSample   = new ShippingsettingsSample(service);
            MultiClientAccountSample multiClientAccountSample = new MultiClientAccountSample(service);

            if (!config.IsMCA)
            {
                // Non-MCA calls
                productsSample.RunCalls(config.MerchantId, config.WebsiteURL);
                productstatusesSample.RunCalls(config.MerchantId);
                datafeedsSample.RunCalls(config.MerchantId);
                accountstatusesSample.RunCalls(config.MerchantId);
                accountsSample.RunCalls(config.MerchantId, config.AccountSampleUser, config.AccountSampleAdWordsCID);
                accounttaxSample.RunCalls(config.MerchantId);
                shippingsettingsSample.RunCalls(config.MerchantId);
            }
            else
            {
                // MCA calls
                accountstatusesSample.RunMultiCalls(config.MerchantId);
                multiClientAccountSample.RunCalls(config.MerchantId);
            }
        }
Beispiel #5
0
        /// <summary>
        /// Retrieves an order using merchant order id. This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2sandbox/reference/orders/getbymerchantorderid
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="merchantOrderId">The merchant order id to be looked for.</param>
        /// <returns>OrdersGetByMerchantOrderIdResponseResponse</returns>
        public static OrdersGetByMerchantOrderIdResponse Getbymerchantorderid(ShoppingContentService service, string merchantId, string merchantOrderId)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (merchantOrderId == null)
                {
                    throw new ArgumentNullException(merchantOrderId);
                }

                // Make the request.
                return(service.Orders.Getbymerchantorderid(merchantId, merchantOrderId).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Orders.Getbymerchantorderid failed.", ex);
            }
        }
Beispiel #6
0
        internal bool retrieveMCAStatus(ShoppingContentService service, MerchantConfig config)
        {
            Console.WriteLine("Retrieving MCA status for configured account.");
            // The resource returned by Accounts.get() does not have the MCA status, but if
            // the authenticated user is directly listed as a user of the Merchant Center account
            // in question, we can see whether it is an MCA or not by calling Accounts.authinfo().
            var authinfo = service.Accounts.Authinfo().Execute();

            foreach (var accountId in authinfo.AccountIdentifiers)
            {
                if (config.MerchantId == accountId.AggregatorId)
                {
                    return(true);
                }
                if (config.MerchantId == accountId.MerchantId)
                {
                    return(false);
                }
            }
            // If the configured account wasn't listed in the authinfo response, then either
            // it is a sub-account of an MCA that was listed, or the authenticated user does
            // not have access. Check this by trying to call Accounts.get().
            try {
                service.Accounts.Get(config.MerchantId, config.MerchantId).Execute();
            } catch (Google.GoogleApiException) {
                throw new ArgumentException(String.Format(
                                                "Authenticated user does not have access to account {0}.", config.MerchantId));
            }
            // Sub-accounts cannot be MCAs.
            return(false);
        }
Beispiel #7
0
        /// <summary>
        /// Updates a shipment's status, carrier, and/or tracking ID. This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2sandbox/reference/orders/updateshipment
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="orderId">The ID of the order.</param>
        /// <param name="body">A valid ShoppingContent v2sandbox body.</param>
        /// <returns>OrdersUpdateShipmentResponseResponse</returns>
        public static OrdersUpdateShipmentResponse Updateshipment(ShoppingContentService service, string merchantId, string orderId, OrdersUpdateShipmentRequest body)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (body == null)
                {
                    throw new ArgumentNullException("body");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (orderId == null)
                {
                    throw new ArgumentNullException(orderId);
                }

                // Make the request.
                return(service.Orders.Updateshipment(body, merchantId, orderId).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Orders.Updateshipment failed.", ex);
            }
        }
Beispiel #8
0
        /// <summary>
        /// Sandbox only. Retrieves an order template that can be used to quickly create a new order in sandbox. This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2sandbox/reference/orders/gettestordertemplate
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="templateName">The name of the template to retrieve.</param>
        /// <returns>OrdersGetTestOrderTemplateResponseResponse</returns>
        public static OrdersGetTestOrderTemplateResponse Gettestordertemplate(ShoppingContentService service, string merchantId, string templateName)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (templateName == null)
                {
                    throw new ArgumentNullException(templateName);
                }

                // Make the request.
                return(service.Orders.Gettestordertemplate(merchantId, templateName).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Orders.Gettestordertemplate failed.", ex);
            }
        }
        /// <summary>
        /// Lists the statuses of the datafeeds in your Merchant Center account. This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/datafeedstatuses/list
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="optional">Optional paramaters.</param>        /// <returns>DatafeedstatusesListResponseResponse</returns>
        public static DatafeedstatusesListResponse List(ShoppingContentService service, string merchantId, DatafeedstatusesListOptionalParms optional = null)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }

                // Building the initial request.
                var request = service.Datafeedstatuses.List(merchantId);

                // Applying optional parameters to the request.
                request = (DatafeedstatusesResource.ListRequest)SampleHelpers.ApplyOptionalParms(request, optional);

                // Requesting data.
                return(request.Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Datafeedstatuses.List failed.", ex);
            }
        }
Beispiel #10
0
        /// <summary>
        /// Sandbox only. Moves a test order from state "inProgress" to state "pendingShipment". This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2sandbox/reference/orders/advancetestorder
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="orderId">The ID of the test order to modify.</param>
        /// <returns>OrdersAdvanceTestOrderResponseResponse</returns>
        public static OrdersAdvanceTestOrderResponse Advancetestorder(ShoppingContentService service, string merchantId, string orderId)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (orderId == null)
                {
                    throw new ArgumentNullException(orderId);
                }

                // Make the request.
                return(service.Orders.Advancetestorder(merchantId, orderId).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Orders.Advancetestorder failed.", ex);
            }
        }
        /// <summary>
        /// Retrieves the status of a datafeed from your Merchant Center account. This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/datafeedstatuses/get
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">NA</param>
        /// <param name="datafeedId">NA</param>
        /// <returns>DatafeedStatusResponse</returns>
        public static DatafeedStatus Get(ShoppingContentService service, string merchantId, string datafeedId)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (datafeedId == null)
                {
                    throw new ArgumentNullException(datafeedId);
                }

                // Make the request.
                return(service.Datafeedstatuses.Get(merchantId, datafeedId).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Datafeedstatuses.Get failed.", ex);
            }
        }
        public ShoppingContentService GetShoppingContentService()
        {
            if (_contentService == null)
            {
                string appPath = System.Web.Hosting.HostingEnvironment.ApplicationPhysicalPath;
                var key = string.Format(@"{0}{1}{2}", appPath, Path.DirectorySeparatorChar, keyPath);

                var certificate = new X509Certificate2(key, "notasecret", X509KeyStorageFlags.Exportable);

                var credential = new ServiceAccountCredential(
                    new ServiceAccountCredential.Initializer(serviceAccountEmail)
                    {
                        Scopes = new[] { ShoppingContentService.Scope.Content }
                    }.FromCertificate(certificate));

                // Create the service.
                _contentService = new ShoppingContentService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName = "VirtoCommerce shopping integration"
                });
            }

            return _contentService;
        }
Beispiel #13
0
 internal override void initializeService(BaseClientService.Initializer init)
 {
     service = new ShoppingContentService(init);
     // Retrieve whether the configured MC account is an MCA via the API.
     // The sandbox service only has access to Orders methods, so can't
     // use it for this.
     config.IsMCA = retrieveMCAStatus(service, config);
     createSandbox(init, new Uri(service.BaseUri));
 }
Beispiel #14
0
 /// <summary>
 /// Initializes a new instance of the <see cref="GoogleProductService"/> class.
 /// </summary>
 /// <param name="options"></param>
 /// <param name="contentService"></param>
 /// <param name="logger"></param>
 public GoogleProductService(
     IOptions <GoogleShoppingOptions> options,
     ShoppingContentService contentService,
     ILogger <GoogleProductService> logger)
 {
     _options        = options.Value;
     _contentService = contentService ?? throw new System.ArgumentNullException(nameof(contentService));
     _logger         = logger ?? throw new System.ArgumentNullException(nameof(logger));
 }
        public GoogleShoppingController(
            IShoppingSettings settingsManager, 
            IGoogleProductProvider productProvider,
			IPushNotificationManager pushNotificationManager, 
            IDateTimeProvider dateTimeProvider,
            IGoogleContentServiceProvider googleContentServiceProvider)
        {
            _settingsManager = settingsManager;
            _productProvider = productProvider;
			_pushNotificationManager = pushNotificationManager;
            _dateTimeProvider = dateTimeProvider;
            _contentService = googleContentServiceProvider.GetShoppingContentService();
        }
 public GoogleShoppingController(
     IShopping settingsManager, 
     IGoogleProductProvider productProvider, 
     INotifier notifier, 
     IDateTimeProvider dateTimeProvider,
     IGoogleContentServiceProvider googleContentServiceProvider)
 {
     _settingsManager = settingsManager;
     _productProvider = productProvider;
     _notifier = notifier;
     _dateTimeProvider = dateTimeProvider;
     _contentService = googleContentServiceProvider.GetShoppingContentService();
 }
 public GoogleShoppingController(
     IShoppingSettings settingsManager,
     IGoogleProductProvider productProvider,
     INotifier notifier,
     IDateTimeProvider dateTimeProvider,
     IGoogleContentServiceProvider googleContentServiceProvider)
 {
     _settingsManager  = settingsManager;
     _productProvider  = productProvider;
     _notifier         = notifier;
     _dateTimeProvider = dateTimeProvider;
     _contentService   = googleContentServiceProvider.GetShoppingContentService();
 }
Beispiel #18
0
        public ShoppingContentService GetShoppingContentService()
        {
            if (_contentService == null)
            {
                var credential = _credentialsProvider.GetCredential();

                // Create the service.
                _contentService = new ShoppingContentService(new BaseClientService.Initializer()
                {
                    HttpClientInitializer = credential,
                    ApplicationName       = "VirtoCommerce shopping integration"
                });
            }

            return(_contentService);
        }
        /// <summary>
        /// Returns information about the authenticated user.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/accounts/authinfo
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <returns>AccountsAuthInfoResponseResponse</returns>
        public static AccountsAuthInfoResponse Authinfo(ShoppingContentService service)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }

                // Make the request.
                return(service.Accounts.Authinfo().Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Accounts.Authinfo failed.", ex);
            }
        }
Beispiel #20
0
        private void createSandbox(BaseClientService.Initializer init, Uri u)
        {
            var pathParts = service.BasePath
                            .Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
            var basename = pathParts.Last();

            if (basename == "v2")
            {
                var newPath = "/"
                              + String.Join("/", pathParts.Take(pathParts.Count() - 1))
                              + "/v2sandbox/";
                sandboxService = new ShoppingContentServiceWithBaseUri(init, new Uri(u, newPath));
            }
            else
            {
                Console.WriteLine("Using same API endpoint for sandbox methods.");
                sandboxService = service;
            }
        }
        internal static void Main(string[] args)
        {
            Console.WriteLine("Content API for Shopping Command Line Sample");
            Console.WriteLine("============================================");

            GoogleWebAuthorizationBroker.Folder = "ShoppingContent.Sample";
            var credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                new ClientSecrets
                {
                    ClientId = CLIENT_ID,
                    ClientSecret = CLIENT_SECRET
                },
                new string[] { ShoppingContentService.Scope.Content},
                "user",
                CancellationToken.None).Result;

            // Create the service.
            var service = new ShoppingContentService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName = "Shopping Content Sample",

            });

            // Execute the calls.
            ShoppingContentApiConsumer shoppingContentApiConsumer =
                new ShoppingContentApiConsumer(service, MaxListPageSize);

            if (MCA_MERCHANT_ID == 0)
            {
                // Non-MCA calls
                shoppingContentApiConsumer.RunCalls(MERCHANT_ID, EMAIL_ADDRESS, ADWORDS_ACCOUNT_ID);
            }
            else
            {
                // MCA calls
                shoppingContentApiConsumer.RunMultiClientAccountCalls(MCA_MERCHANT_ID);
            }

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
Beispiel #22
0
        internal static void Main(string[] args)
        {
            Console.WriteLine("Content API for Shopping Command Line Sample");
            Console.WriteLine("============================================");

            GoogleWebAuthorizationBroker.Folder = "ShoppingContent.Sample";
            var credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
                new ClientSecrets
            {
                ClientId     = CLIENT_ID,
                ClientSecret = CLIENT_SECRET
            },
                new string[] { ShoppingContentService.Scope.Content },
                "user",
                CancellationToken.None).Result;

            // Create the service.
            var service = new ShoppingContentService(new BaseClientService.Initializer()
            {
                HttpClientInitializer = credential,
                ApplicationName       = "Shopping Content Sample",
            });

            // Execute the calls.
            ShoppingContentApiConsumer shoppingContentApiConsumer =
                new ShoppingContentApiConsumer(service, MaxListPageSize);


            if (MCA_MERCHANT_ID == 0)
            {
                // Non-MCA calls
                shoppingContentApiConsumer.RunCalls(MERCHANT_ID, EMAIL_ADDRESS, ADWORDS_ACCOUNT_ID);
            }
            else
            {
                // MCA calls
                shoppingContentApiConsumer.RunMultiClientAccountCalls(MCA_MERCHANT_ID);
            }

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();
        }
        /// <summary>
        /// Updates price and availability of a product in your Merchant Center account. This operation does not update the expiration date of the product. This method can only be called for non-multi-client accounts.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/inventory/set
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="storeCode">The code of the store for which to update price and availability. Use online to update price and availability of an online product.</param>
        /// <param name="productId">The ID of the product for which to update price and availability.</param>
        /// <param name="body">A valid ShoppingContent v2 body.</param>
        /// <param name="optional">Optional paramaters.</param>        /// <returns>InventorySetResponseResponse</returns>
        public static InventorySetResponse Set(ShoppingContentService service, string merchantId, string storeCode, string productId, InventorySetRequest body, InventorySetOptionalParms optional = null)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (body == null)
                {
                    throw new ArgumentNullException("body");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (storeCode == null)
                {
                    throw new ArgumentNullException(storeCode);
                }
                if (productId == null)
                {
                    throw new ArgumentNullException(productId);
                }

                // Building the initial request.
                var request = service.Inventory.Set(body, merchantId, storeCode, productId);

                // Applying optional parameters to the request.
                request = (InventoryResource.SetRequest)SampleHelpers.ApplyOptionalParms(request, optional);

                // Requesting data.
                return(request.Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Inventory.Set failed.", ex);
            }
        }
        /// <summary>
        /// NA
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/datafeedstatuses/custombatch
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="body">A valid ShoppingContent v2 body.</param>
        /// <returns>DatafeedstatusesCustomBatchResponseResponse</returns>
        public static DatafeedstatusesCustomBatchResponse Custombatch(ShoppingContentService service, DatafeedstatusesCustomBatchRequest body)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (body == null)
                {
                    throw new ArgumentNullException("body");
                }

                // Make the request.
                return(service.Datafeedstatuses.Custombatch(body).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Datafeedstatuses.Custombatch failed.", ex);
            }
        }
        /// <summary>
        /// Updates the tax settings of the account. This method can only be called for accounts to which the managing account has access: either the managing account itself or sub-accounts if the managing account is a multi-client account.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/accounttax/update
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="accountId">The ID of the account for which to get/update account tax settings.</param>
        /// <param name="body">A valid ShoppingContent v2 body.</param>
        /// <param name="optional">Optional paramaters.</param>        /// <returns>AccountTaxResponse</returns>
        public static AccountTax Update(ShoppingContentService service, string merchantId, string accountId, AccountTax body, AccounttaxUpdateOptionalParms optional = null)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (body == null)
                {
                    throw new ArgumentNullException("body");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (accountId == null)
                {
                    throw new ArgumentNullException(accountId);
                }

                // Building the initial request.
                var request = service.Accounttax.Update(body, merchantId, accountId);

                // Applying optional parameters to the request.
                request = (AccounttaxResource.UpdateRequest)SampleHelpers.ApplyOptionalParms(request, optional);

                // Requesting data.
                return(request.Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Accounttax.Update failed.", ex);
            }
        }
Beispiel #26
0
        /// <summary>
        /// Updates the shipping settings of the account. This method can only be called for accounts to which the managing account has access: either the managing account itself or sub-accounts if the managing account is a multi-client account. This method supports patch semantics.
        /// Documentation https://developers.google.com/shoppingcontent/v2/reference/shippingsettings/patch
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated ShoppingContent service.</param>
        /// <param name="merchantId">The ID of the managing account.</param>
        /// <param name="accountId">The ID of the account for which to get/update shipping settings.</param>
        /// <param name="body">A valid ShoppingContent v2 body.</param>
        /// <param name="optional">Optional paramaters.</param>        /// <returns>ShippingSettingsResponse</returns>
        public static ShippingSettings Patch(ShoppingContentService service, string merchantId, string accountId, ShippingSettings body, ShippingsettingsPatchOptionalParms optional = null)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (body == null)
                {
                    throw new ArgumentNullException("body");
                }
                if (merchantId == null)
                {
                    throw new ArgumentNullException(merchantId);
                }
                if (accountId == null)
                {
                    throw new ArgumentNullException(accountId);
                }

                // Building the initial request.
                var request = service.Shippingsettings.Patch(body, merchantId, accountId);

                // Applying optional parameters to the request.
                request = (ShippingsettingsResource.PatchRequest)SampleHelpers.ApplyOptionalParms(request, optional);

                // Requesting data.
                return(request.Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Shippingsettings.Patch failed.", ex);
            }
        }
 /// <summary>Initializes a new instance of the <see cref="ShoppingcontentApiConsumer"/> class.</summary>
 /// <param name="service">Content service object on which to run the requests.</param>
 /// <param name="maxListPageSize">The maximum page size to retrieve.</param>
 public ShoppingContentApiConsumer(ShoppingContentService service, int maxListPageSize)
 {
     this.service = service;
     this.maxListPageSize = maxListPageSize;
 }
 /// <summary>Initializes a new instance of the <see cref="DatafeedsSample"/> class.</summary>
 /// <param name="service">Content service object on which to run the requests.</param>
 public DatafeedsSample(ShoppingContentService service)
 {
     this.service = service;
 }
Beispiel #29
0
 internal override void initializeService(BaseClientService.Initializer init, Uri u)
 {
     service = new ShoppingContentServiceWithBaseUri(init, u);
     retrieveConfiguration(service, config);
     createSandbox(init, u);
 }
Beispiel #30
0
        // Retrieve the following configuration fields using the Content API:
        // - IsMCA
        // - WebsiteUrl
        // Also use the first Merchant Center account to which the authenticated user has access
        // if no Merchant Center ID was provided.
        internal void retrieveConfiguration(ShoppingContentService service, MerchantConfig config)
        {
            Console.WriteLine("Retrieving information for authenticated user.");
            var authinfo = service.Accounts.Authinfo().Execute();

            if (authinfo.AccountIdentifiers.Count == 0)
            {
                throw new ArgumentException(
                          "Authenticated user has no access to any Merchant Center accounts.");
            }
            if (config.MerchantId == null)
            {
                var firstAccount = authinfo.AccountIdentifiers[0];
                if (firstAccount.MerchantId == null)
                {
                    config.MerchantId = firstAccount.AggregatorId;
                }
                else
                {
                    config.MerchantId = firstAccount.MerchantId;
                }
                Console.WriteLine(
                    "Using Merchant Center {0} for running samples.", config.MerchantId.Value);
            }
            ulong merchantId = config.MerchantId.Value;

            // We detect whether the requested Merchant Center ID is an MCA by checking
            // Accounts.authinfo(). If it is an MCA, then the authenticated user must be
            // a user of that account, which means it'll be listed here, and it must
            // appear in the AggregatorId field of one of the AccountIdentifier entries.
            config.IsMCA = false;
            foreach (var accountId in authinfo.AccountIdentifiers)
            {
                if (merchantId == accountId.AggregatorId)
                {
                    config.IsMCA = true;
                    break;
                }
                if (merchantId == accountId.MerchantId)
                {
                    break;
                }
            }
            Console.WriteLine("Merchant Center {0} is{1} an MCA.",
                              merchantId,
                              config.IsMCA ? "" : " not");

            var account = service.Accounts.Get(merchantId, merchantId).Execute();

            if (!String.IsNullOrEmpty(account.WebsiteUrl))
            {
                config.WebsiteURL = account.WebsiteUrl;
                Console.WriteLine(
                    "Website for Merchant Center {0}: {1}",
                    merchantId,
                    config.WebsiteURL);
            }
            else
            {
                Console.WriteLine("Merchant Center {0} has no configured website.", merchantId);
            }
        }
Beispiel #31
0
 public OrdersSample(ShoppingContentService service)
 {
     this.service = service;
     this.prng    = new Random();
 }
 public ProductstatusesSample(ShoppingContentService service, int maxListPageSize)
 {
     this.service         = service;
     this.maxListPageSize = maxListPageSize;
 }
Beispiel #33
0
 /// <summary>Initializes a new instance of the <see cref="ShippingsettingsSample"/> class.</summary>
 /// <param name="service">Content service object on which to run the requests.</param>
 public ShippingsettingsSample(ShoppingContentService service)
 {
     this.service = service;
 }
Beispiel #34
0
 internal override void initializeService(BaseClientService.Initializer init, Uri u)
 {
     service      = new ShoppingContentServiceWithBaseUri(init, u);
     config.IsMCA = retrieveMCAStatus(service, config);
     createSandbox(init, u);
 }
 /// <summary>Initializes a new instance of the <see cref="AccountsSample"/> class.</summary>
 /// <param name="service">Content service object on which to run the requests.</param>
 public AccountsSample(ShoppingContentService service)
 {
     this.service = service;
 }