Course material

{
  "taskId": "9c2e8895-6e1f-4848-ad60-0af45f1fba3b",
  "statusUri": "/tasks/9c2e8895-6e1f-4848-ad60-0af45f1fba3b/status",
  "resultUri": "/tasks/9c2e8895-6e1f-4848-ad60-0af45f1fba3b/result"
}

{
  "UniqueName": "Test"
}

ExternalBulkOperationWebhookPayload {
  operationName*          string
  productUniqueNames*     [string]
}

using Bizzkit.Sdk.Pim;
using System.Text;

// WARNING: This is DEMO code and is not intended for production use.
// Please review and modify before using in any production environment.
namespace Bizzkit.Academy
{
    public static class PimHelper
    {
        public static async Task<Guid> CreateGlobalList(string listName, DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            GlobalListCreateRequestModel request = new GlobalListCreateRequestModel()
            {
                SystemName = listName,
                ItemPimTypeName = "PString",
                UniqueValues = false
            };
            var responseGlobalLists_CreateAsync = await client.GlobalLists_CreateAsync(request);

            List<GlobalListItemsCreateRequestModel> items = new List<GlobalListItemsCreateRequestModel>();

            for (int i = 0; i < 10; i++)
            {
                items.Add(new GlobalListItemsCreateRequestModel
                {
                    SystemName = "ITEM" + i,
                    TemporaryIdentifier = Guid.NewGuid(),
                    Value = new PimTypeModel() { PimTypeName = "PString", ValueOrDefaultValue = new PimValueModel { Value = "Item #" + i } }
                });
            }
            var responseGlobalLists_Items_CreateAsync = await client.GlobalLists_Items_CreateAsync(responseGlobalLists_CreateAsync, items);
            return responseGlobalLists_CreateAsync;
        }

        public static async Task<Guid> GetAttributeId(string systemName, DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            return (await client.Attributes_ListAsync(1, 1000)).Items.First(i => i.SystemName == systemName).AttributeId;
        }

        public static async Task<BrandListResponseModel> GetBrands(DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            BrandListResponseModel result = await client.Brands_ListAsync(1, 1000);
            return result;
        }

        public static async Task<ChannelListResponseModel> GetChannels(DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            return await client.Channels_ListAsync(1, 100);
        }

        public static async Task<IEnumerable<ProductViewWrapper>> GetFrontEndModel(DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            ProductsViewSearchModel productsViewSearchModel = new ProductsViewSearchModel
            {
                PageNumber = 1,
                PageSize = 1000, // careful
                SegmentationId = null, // null = all
                UniqueNames = null,    // set to array if needed
            };
            IEnumerable<ProductViewWrapper> result = await client.ResolvedViews_Products_SearchAsync(productsViewSearchModel);
            return result;
        }

        // Warning - getting all items!!
        public static async Task<GlobalListsListResponseModel> GetGlobalLists(DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            GlobalListsListResponseModel result = await client.GlobalLists_ListAsync(1, 1000);
            return result;
        }

        public static async Task<SegmentationListResponseModel> GetSegmentations(DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            return await client.Segmentations_ListAsync(1, 100);
        }

        public static async Task<ListTranslationCulturesResult> GetTranslationCultures(DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            return await client.TranslationCultures_ListAsync(1, 100);
        }

        public static async Task<(EnqueuedTaskModel, StatusDescriptor)> ImportCsvFromFile(string file, DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            string csv = System.IO.File.ReadAllText(file);
            return await ImportCsvFromString(csv, config);
        }

        public static async Task<(EnqueuedTaskModel, StatusDescriptor)> ImportCsvFromString(string content, DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            byte[] byteArray = System.Text.Encoding.UTF8.GetBytes(content);
            MemoryStream stream = new MemoryStream(byteArray);
            FileParameter fileParameter = new FileParameter(stream);
            EnqueuedTaskModel response = await client.Products_Bundles_ImportFromCsvAsync(100, null, ProductBundlesImportJobPriority.Medium, fileParameter);
            StatusDescriptor status;
            int tryNo = 1;
            do
            {
                status = await client.Tasks_GetStatusAsync(response.TaskId);
                await Task.Delay(1000);
                if (tryNo > 25)
                    throw new ApplicationException("Something is wrong");
            } while (status.State != StatusDescriptorState.Finished);
            return (response, status);
        }

        public static async Task ImportProducts(string file, DomainConfig config)
        {
            string content = System.IO.File.ReadAllText(file);
            var client = await BizzkitHelper.GetPimClientFactory(config);
            byte[] byteArray = Encoding.UTF8.GetBytes(content);
            MemoryStream stream = new(byteArray);
            FileParameter fileParameter = new(stream);
            var result = await client.Products_ImportFromCsvAsync(
                batchSize: 50,
                csvFile: fileParameter,
                includedAttributes: ""
                );
            await WaitForResult(result, "Importing products from " + file, config);
        }

        public static async Task ImportProductsFromString(List<string> content, DomainConfig config)
        {
            if (content == null || content.Count == 0)
                return;
            foreach (var item in content)
                await ImportProductsFromString(item, config);
        }

        public static async Task ImportProductsFromString(string content, DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            byte[] byteArray = Encoding.UTF8.GetBytes(content);
            MemoryStream stream = new(byteArray);
            FileParameter fileParameter = new(stream);
            var result = await client.Products_ImportFromCsvAsync(
                batchSize: 50,
                csvFile: fileParameter,
                includedAttributes: ""
                );
            await WaitForResult(result, "Importing products from content...", config);
        }

        public static async Task<IEnumerable<ProductViewWrapper>> SearchProducts(int segmentationId, DomainConfig config, IEnumerable<string>? uniqueNames = null)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            return await client.ResolvedViews_Products_SearchAsync(new ProductsViewSearchModel
            {
                PageNumber = 1,
                PageSize = 1000,
                SegmentationId = segmentationId,
                UniqueNames = uniqueNames
            });
        }

        public static async Task WaitForResult(EnqueuedTaskModel enqueuedTaskModel, string txt, DomainConfig config)
        {
            var client = await BizzkitHelper.GetPimClientFactory(config);
            await ExecuteWithIntervalUntilConditionAsync(async () =>
            {
                var result = await client.Tasks_GetStatusAsync(enqueuedTaskModel.TaskId);
                if (result.State == StatusDescriptorState.Failed)
                {
                    Console.WriteLine("Task failed: " + result.ErrorMessage);
                    throw new Exception("Task failed: " + txt + " " + result.ErrorMessage);
                }
                return result.State == StatusDescriptorState.Finished;
            }, TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(120), txt);
        }

        private static async Task ExecuteWithIntervalUntilConditionAsync(
                                                                                    Func<Task<bool>> condition,
            TimeSpan interval,
            TimeSpan timeout,
            string logText)
        {
            var startTime = DateTime.UtcNow;
            while (true)
            {
                if (await condition())
                {
                    break;
                }
                var to = timeout.TotalSeconds - (DateTime.UtcNow - startTime).TotalSeconds;
                Console.WriteLine($"{logText} - {interval.TotalSeconds}s ({to.ToString("0")}s left)");
                if (DateTime.UtcNow - startTime > timeout)
                {
                    throw new TimeoutException("Operation timed out.");
                }

                await Task.Delay(interval);
            }
        }
    }
}