prs/prs.shared/Posters/MYOB/CustomerMYOBPoster.cs

using Comal.Classes;
using FastReport.Data;
using InABox.Core;
using InABox.Core.Postable;
using InABox.Poster.MYOB;
using MYOB.AccountRight.SDK.Services;
using MYOB.AccountRight.SDK.Services.Contact;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Customer = Comal.Classes.Customer;
using MYOBCustomer = MYOB.AccountRight.SDK.Contracts.Version2.Contact.Customer;
using MYOBAddress = MYOB.AccountRight.SDK.Contracts.Version2.Contact.Address;
using MYOB.AccountRight.SDK.Contracts.Version2.Sale;
using InABox.Clients;
using InABox.Database;
using MYOB.AccountRight.SDK;

namespace PRS.Shared.Posters.MYOB;

public class CustomerMYOBPosterSettings : MYOBPosterSettings
{
    [TextBoxEditor(ToolTip = "The MYOB tax code which should be used when posting customers")]
    public string DefaultTaxCode { get; set; }
}

public static class ContactMYOBUtils
{
    public static void SplitName(string name, out string firstName, out string lastName)
    {
        var names = name.Split(' ', 2, StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
        firstName = names.Length > 0 ? names[0] : "";
        lastName = names.Length > 1 ? names[1] : "";
    }

    public static MYOBAddress ConvertAddress(Address address, int location, IContact contact)
    {
        return new MYOBAddress
        {
            Location = location,
            Street = address.Street.Truncate(255),
            City = address.City.Truncate(255),
            State = address.State.Truncate(255),
            PostCode = address.PostCode.Truncate(11),
            Phone1 = contact.Mobile.Truncate(21),
            Phone2 = contact.Telephone.Truncate(21),
            Email = contact.Email.Truncate(255),
            ContactName = contact.Name.Truncate(25)
        };
    }
}

public class CustomerMYOBAutoRefresher : IAutoRefresher<Customer>
{
    public bool ShouldRepost(Customer customer)
    {
        var shouldRepost = customer.HasOriginalValue(x => x.Name)
            || customer.HasOriginalValue(x => x.Code)
            || customer.HasOriginalValue(x => x.ABN)
            || customer.DefaultContact.HasOriginalValue(x => x.ID)
            || customer.Delivery.HasOriginalValue(x => x.Street)
            || customer.Delivery.HasOriginalValue(x => x.City)
            || customer.Delivery.HasOriginalValue(x => x.State)
            || customer.Delivery.HasOriginalValue(x => x.PostCode)
            || customer.Postal.HasOriginalValue(x => x.Street)
            || customer.Postal.HasOriginalValue(x => x.City)
            || customer.Postal.HasOriginalValue(x => x.State)
            || customer.Postal.HasOriginalValue(x => x.PostCode);
        if (shouldRepost)
        {
            return true;
        }

        if(customer.CustomerStatus.HasOriginalValue(x => x.ID))
        {
            var originalID = customer.CustomerStatus.GetOriginalValue(x => x.ID);
            var currentID = customer.CustomerStatus.ID;

            var statuses = DbFactory.Provider.Query<CustomerStatus>(
                new Filter<CustomerStatus>(x => x.ID).IsEqualTo(originalID).Or(x => x.ID).IsEqualTo(currentID),
                Columns.None<CustomerStatus>().Add(x => x.ID).Add(x => x.Active))
                .ToArray<CustomerStatus>();
            if (statuses.Length == 2 && statuses[0].Active != statuses[1].Active)
            {
                return true;
            }
        }
        return false;
    }

}

public class CustomerMYOBPoster : IMYOBPoster<Customer, CustomerMYOBPosterSettings>, IAutoRefreshPoster<Customer, CustomerMYOBAutoRefresher>
{
    public CustomerMYOBPosterSettings Settings { get; set; }
    public MYOBGlobalPosterSettings GlobalSettings { get; set; }

    public MYOBConnectionData ConnectionData { get; set; }

    public bool BeforePost(IDataModel<Customer> model)
    {
        foreach (var (_, table) in model.ModelTables)
        {
            table.IsDefault = false;
        }
        model.SetIsDefault<Customer>(true);
        model.SetColumns<Customer>(RequiredColumns());

        return true;
    }

    public static Columns<Customer> RequiredColumns()
    {
        return Columns.None<Customer>()
            .Add(x => x.ID)
            .Add(x => x.PostedReference)
            .Add(x => x.DefaultContact.Name)
            .Add(x => x.Name)
            .Add(x => x.Code)
            .Add(x => x.CustomerStatus.ID)
            .Add(x => x.CustomerStatus.Active)
            .Add(x => x.Delivery.Street)
            .Add(x => x.Delivery.City)
            .Add(x => x.Delivery.State)
            .Add(x => x.Delivery.PostCode)
            .Add(x => x.Postal.Street)
            .Add(x => x.Postal.City)
            .Add(x => x.Postal.State)
            .Add(x => x.Postal.PostCode)
            .Add(x => x.DefaultContact.Mobile)
            .Add(x => x.DefaultContact.Telephone)
            .Add(x => x.DefaultContact.Email)
            .Add(x => x.DefaultContact.Name)
            .Add(x => x.DefaultContact.Mobile)
            .Add(x => x.ABN);
    }

    public static Result<Exception> UpdateCustomer(MYOBConnectionData data, CustomerMYOBPosterSettings settings, Customer customer, MYOBCustomer myobCustomer, bool isNew)
    {
        // Documentation: https://developer.myob.com/api/myob-business-api/v2/contact/customer/

        // Since this might be called from some other poster, we need to ensure we have the right columns.
        Client.EnsureColumns(customer, RequiredColumns());

        ContactMYOBUtils.SplitName(customer.DefaultContact.Name, out var firstName, out var lastName);

        myobCustomer.CompanyName = customer.Name.Truncate(50);
        myobCustomer.FirstName = firstName.Truncate(30);
        myobCustomer.LastName = lastName.Truncate(20);
        myobCustomer.IsIndividual = false;
        myobCustomer.DisplayID = customer.Code.Truncate(15);
        // If there is not customer status, we will use default to Active = true.
        myobCustomer.IsActive = customer.CustomerStatus.ID == Guid.Empty || customer.CustomerStatus.Active;
        myobCustomer.Addresses =
        [
            ContactMYOBUtils.ConvertAddress(customer.Postal, 2, customer.DefaultContact),
            ContactMYOBUtils.ConvertAddress(customer.Delivery, 1, customer.DefaultContact)
        ];
        // Notes = 
        // PhotoURI =
        // RowVersion = 
        myobCustomer.SellingDetails ??= new();
        myobCustomer.SellingDetails.SaleLayout = InvoiceLayoutType.NoDefault;
        // myobCustomer.SellingDetails.PrintedFOrm = 
        myobCustomer.SellingDetails.InvoiceDelivery = DocumentAction.PrintAndEmail;
        // myobCustomer.SellingDetails.IncomeAccount = 
        // myobCustomer.SellingDetails.ReceiptMemo = 
        // myobCustomer.SellingDetails.SalesPerson = 
        // myobCustomer.SellingDetails.SaleComment = 
        // myobCustomer.SellingDetails.ShippingMethod = 
        // myobCustomer.SellingDetails.HourlyBillRate = 
        // myobCustomer.SellingDetails.ABNBranch = 
        myobCustomer.SellingDetails.ABN = customer.ABN.Truncate(14);

        if (isNew)
        {
            if (settings.DefaultTaxCode.IsNullOrWhiteSpace())
            {
                throw new PostFailedMessageException("Default tax code has not been set up.");
            }
            else if(data.GetMYOBTaxCodeUID(settings.DefaultTaxCode).Get(out var taxID, out var error))
            {
                if (taxID == Guid.Empty)
                {
                    return Result.Error(new Exception($"Failed to find TaxCode in MYOB with code '{settings.DefaultTaxCode}'"));
                }
                myobCustomer.SellingDetails.TaxCode ??= new();
                myobCustomer.SellingDetails.TaxCode.UID = taxID;
                myobCustomer.SellingDetails.FreightTaxCode ??= new();
                myobCustomer.SellingDetails.FreightTaxCode.UID = taxID;
            }
            else
            {
                CoreUtils.LogException("", error, $"Failed to find TaxCode in MYOB with code '{settings.DefaultTaxCode}'");
                return Result.Error(new Exception($"Failed to find TaxCode in MYOB with code '{settings.DefaultTaxCode}': {error.Message}", error));
            }
        }
        return Result.Ok();
    }

    /// <summary>
    /// Try to find a customer in MYOB which matches <paramref name="customer"/>, and if this fails, create a new one.
    /// </summary>
    /// <remarks>
    /// After this has finished, <paramref name="customer"/> will be updated with <see cref="Customer.PostedReference"/> set to the correct ID.
    /// <br/>
    /// <paramref name="customer"/> needs to have at least <see cref="Customer.Code"/> and <see cref="Customer.PostedReference"/> as loaded columns.
    /// </remarks>
    /// <param name="data"></param>
    /// <param name="customer">The customer to map to.</param>
    /// <returns>The UID of the MYOB customer.</returns>
    public static Result<Guid, Exception> MapCustomer(MYOBConnectionData data, Customer customer)
    {
        if(Guid.TryParse(customer.PostedReference, out var myobID))
        {
            return new Result<Guid, Exception>(myobID);
        }

        var service = new CustomerService(data.Configuration, null, data.AuthKey);
        var result = service.Query(data, new Filter<MYOBCustomer>(x => x.DisplayID).IsEqualTo(customer.Code), top: 1);
        return result.MapOk(customers =>
        {
            if(customers.Count == 0)
            {
                if(customer.Code.Length > 15)
                {
                    return Result.Error(new Exception("Customer code is longer than 15 characters"));
                }
                var myobCustomer = new MYOBCustomer();
                return UpdateCustomer(data, PosterUtils.LoadPosterSettings<Customer, CustomerMYOBPosterSettings>(), customer, myobCustomer, true)
                    .MapOk<Result<Guid, Exception>>(() =>
                    {
                        try
                        {
                            var result = service.UpdateEx(data.CompanyFile, myobCustomer, data.CompanyFileCredentials);
                            customer.PostedReference = result.UID.ToString();
                            return Result.Ok(result.UID);
                        }
                        catch(ApiCommunicationException e)
                        {
                            return Result.Error(new Exception(PRSMYOBPosterUtils.FormatApiException(e), e));
                        }
                        catch (Exception e)
                        {
                            CoreUtils.LogException("", e, $"Error while posting customer {customer.ID}");
                            return Result.Error(e);
                        }
                    }).Flatten();
            }
            else
            {
                customer.PostedReference = customers.Items[0].UID.ToString();
                return Result.Ok(customers.Items[0].UID);
            }
        }).Flatten();
    }

    public IPostResult<Customer> Process(IDataModel<Customer> model)
    {
        var results = new PostResult<Customer>();

        var service = new CustomerService(ConnectionData.Configuration, null, ConnectionData.AuthKey);

        var customers = model.GetTable<Customer>().ToArray<Customer>();
        
        foreach(var customer in customers)
        {
            if(customer.Code.Length > 15)
            {
                results.AddFailed(customer, "Code is longer than 15 characters.");
                continue;
            }

            bool isNew;
            MYOBCustomer myobCustomer;
            Exception? error;
            if(Guid.TryParse(customer.PostedReference, out var myobID))
            {
                if(!service.Get(ConnectionData, myobID).Get(out var newCustomer, out error))
                {
                    CoreUtils.LogException("", error, $"Failed to find Customer in MYOB with id {myobID}");
                    results.AddFailed(customer, $"Failed to find Customer in MYOB with id {myobID}: {error.Message}");
                    continue;
                }
                myobCustomer = newCustomer;
                isNew = false;
            }
            else
            {
                if(service.Query(ConnectionData, new Filter<MYOBCustomer>(x => x.DisplayID).IsEqualTo(customer.Code)).Get(out var myobCustomers, out error))
                {
                    if(myobCustomers.Items.Length > 0)
                    {
                        myobCustomer = myobCustomers.Items[0];
                        isNew = false;
                    }
                    else
                    {
                        myobCustomer = new MYOBCustomer();
                        isNew = true;
                    }
                }
                else
                {
                    CoreUtils.LogException("", error);
                    results.AddFailed(customer, error.Message);
                    continue;
                }
            }

            if(UpdateCustomer(ConnectionData, Settings, customer, myobCustomer, isNew).Get(out error))
            {
                try
                {
                    var result = service.Save(ConnectionData, myobCustomer);
                    customer.PostedReference = result.UID.ToString();
                    results.AddSuccess(customer);
                }
                catch(ApiCommunicationException e)
                {
                    results.AddFailed(customer, PRSMYOBPosterUtils.FormatApiException(e));
                }
                catch(Exception e)
                {
                    CoreUtils.LogException("", e, $"Error while posting customer {customer.ID}");
                    results.AddFailed(customer, e.Message);
                }
            }
            else
            {
                results.AddFailed(customer, error.Message);
            }
        }

        return results;
    }
}

public class CustomerMYOBPosterEngine<T> : MYOBPosterEngine<Customer, CustomerMYOBPosterSettings> { }