Partsource/PartSource.Automation/Jobs/UpdateFitment.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using PartSource.Automation.Services;
using PartSource.Data.Contexts;
using PartSource.Data.Models;
using Ratermania.Automation.Interfaces;
using Ratermania.Shopify;
using Ratermania.Shopify.Resources;

namespace PartSource.Automation.Jobs
{
    public class UpdateFitment : IAutomationJob
    {
        private readonly ILogger<UpdateFitment> _logger;
        private readonly ShopifyClient _shopifyClient;
        private readonly PartSourceContext _partSourceContext;
        private readonly FitmentContext _fitmentContext;
        private readonly VehicleFitmentService _vehicleFitmentService;

        public UpdateFitment(ILogger<UpdateFitment> logger, PartSourceContext partSourceContext, FitmentContext fitmentContext, ShopifyClient shopifyClient, VehicleFitmentService vehicleFitmentService)
        {
            _logger = logger;
            _partSourceContext = partSourceContext;
            _fitmentContext = fitmentContext;
            _shopifyClient = shopifyClient;
            _vehicleFitmentService = vehicleFitmentService;
        }

        public async Task Run(CancellationToken token, params string[] arguments)
        {

            IEnumerable<Product> products = null;

            try
            {
                products = await _shopifyClient.Products.Get(new Dictionary<string, object> { { "limit", 250 }, { "product_type", "CA111-SC250-FL25049_Entry Ball Joints" } });
                //products = new List<Product>
                //{
                //    await _shopifyClient.Products.GetById(4388919574575)
                //};
            }

            catch (Exception ex)
            {
                _logger.LogError("Failed to get products from Shopify", ex);
                throw;
            }

            int i = 1;

            while (products != null && products.Any())
            {
                foreach (Product product in products)
                {
                    ImportData importData = null;

                    try
                    {
                        IEnumerable<Metafield> metafields = await _shopifyClient.Metafields.Get(new Dictionary<string, object> { { "metafield[owner_id]", product.Id }, { "metafield[owner_resource]", "product" } });
                        importData = new ImportData
                        {
                            LineCode = metafields.FirstOrDefault(m => m.Key == "custom_label_0")?.Value ?? string.Empty,
                            PartNumber = metafields.FirstOrDefault(m => m.Key == "custom_label_1")?.Value ?? string.Empty,
                            VariantSku = product.Variants[0].Sku  // They know we can't do fitment for variants
                        };

                        bool isFitment = false;
                        string bodyHtml = product.BodyHtml.Substring(0, product.BodyHtml.IndexOf("</ul>") + "</ul>".Length);

                        IList<Vehicle> vehicles = _vehicleFitmentService.GetVehiclesForPart(importData.PartNumber, importData.LineCode);
                        IList<int> vehicleIdFitment = _vehicleFitmentService.GetVehicleIdFitment(vehicles);

                        if (vehicleIdFitment.Count > 0)
                        {
                            string vehicleIdString = string.Join(',', vehicleIdFitment.Select(j => $"v{j}"));

                            bodyHtml += $"<div id=\"vehicleIDs\" style=\"display:none;\">{vehicleIdString}</div>";

                            isFitment = true;

                            string json = JsonConvert.SerializeObject(vehicleIdFitment);
                            if (json.Length < 100000)
                            {
                                Metafield vehicleMetafield = new Metafield
                                {
                                    Namespace = "fitment",
                                    Key = "ids",
                                    Value = json,
                                    Type = "json_string",
                                    OwnerResource = "product",
                                    OwnerId = product.Id
                                };

                                await _shopifyClient.Metafields.Add(vehicleMetafield);
                            }

                            else
                            {
                                _logger.LogWarning($"Vehicle ID fitment data for SKU {importData.VariantSku} is too large for Shopify and cannot be added.");
                                continue;
                            }
                        }

                        IList<string> ymmFitment = _vehicleFitmentService.GetYmmFitment(vehicles);
                        if (ymmFitment.Count > 0)
                        {
                            isFitment = true;

                            StringBuilder stringBuilder = new StringBuilder();
                            stringBuilder.AppendLine("<table><tr><th colspan=\"2\">This Part Fits</th></tr>");

                            foreach (string fitment in ymmFitment)
                            {
                                try
                                {
                                    string[] parts = fitment.Split(' ', 2);

                                    stringBuilder.AppendLine($"<tr><td>{parts[1]}</td><td>{parts[0].Replace("-", ", ")}</td></tr>");
                                }

                                catch
                                {
                                    // This is still a POC at this point.  Oh well...
                                }
                            }

                            stringBuilder.AppendLine("</table>");

                            bodyHtml += $"<div id=\"seoData\">{stringBuilder.ToString()}</div>";

                            string json = JsonConvert.SerializeObject(ymmFitment);
                            if (json.Length < 100000)
                            {
                                Metafield ymmMetafield = new Metafield
                                {
                                    Namespace = "fitment",
                                    Key = "seo",
                                    Value = json,
                                    Type = "json_string",
                                    OwnerResource = "product",
                                    OwnerId = product.Id
                                };

                                await _shopifyClient.Metafields.Add(ymmMetafield);
                            }

                            else
                            {
                                _logger.LogWarning($"Year/make/model fitment data for SKU {importData.VariantSku} is too large for Shopify and cannot be added.");
                                continue;
                            }
                        }

                        Metafield isFitmentMetafield = new Metafield
                        {
                            Namespace = "Flags",
                            Key = "IsFitment",
                            Value = isFitment.ToString(),
                            Type = "string",
                            OwnerResource = "product",
                            OwnerId = product.Id
                        };

                        await _shopifyClient.Metafields.Add(isFitmentMetafield);

                        //Metafield lineCodeMetafield = new Metafield
                        //{
                        //	Namespace = "google",
                        //	Key = "custom_label_0",
                        //	Value = importData.LineCode,
                        //	Type = "string",
                        //	OwnerResource = "product",
                        //	OwnerId = product.Id
                        //};

                        //await _shopifyClient.Metafields.Add(lineCodeMetafield);

                        //Metafield partNumberMetafield = new Metafield
                        //{
                        //	Namespace = "google",
                        //	Key = "custom_label_1",
                        //	Value = importData.PartNumber,
                        //	Type = "string",
                        //	OwnerResource = "product",
                        //	OwnerId = product.Id
                        //};

                        //await _shopifyClient.Metafields.Add(partNumberMetafield);

                        List<string> tags = new List<string>();

                        for (int j = 0; j < vehicleIdFitment.Count; j += 25)
                        {
                            tags.Add(string.Join('-', vehicleIdFitment.Skip(j).Take(25).Select(j => $"v{j}")));
                        }

                        tags.AddRange(ymmFitment);

                        if (tags.Count > 249)
                        {
                            tags = tags.Take(249).ToList();
                        }

                        string zzzIsFitment = isFitment
                            ? "zzzIsFitment=true"
                            : "zzzIsFitment=false";

                        tags.Add(zzzIsFitment);

                        product.Tags = string.Join(',', tags);
                        product.BodyHtml = bodyHtml;
                        await _shopifyClient.Products.Update(product);

                        importData.IsFitment = isFitment;
                        importData.UpdatedAt = DateTime.Now;
                        importData.UpdateType = "Fitment";
                    }

                    catch (Exception ex)
                    {
                        _logger.LogError($"Failed to updated fitment data for SKU {importData?.VariantSku} - {ex.Message}", ex);
                    }

                }
                try
                {
                    Console.WriteLine(i);

                    _partSourceContext.SaveChanges();
                    products = await _shopifyClient.Products.GetNext();

                    i++;
                }

                catch (Exception ex)
                {
                    _logger.LogWarning(ex, "Failed to get the next set of products.  Retrying");
                    products = await _shopifyClient.Products.GetPrevious();
                }
            }
        }
    }
}