using EleWise.ELMA.ComponentModel;
using EleWise.ELMA.Logging;
using EleWise.ELMA.Model.Managers;
using EleWise.ELMA.Runtime.NH.Listeners;
using Impeltech.Bank.Helpers;
using Impeltech.Bank.Managers;
using Impeltech.Bank.Models;
using Impeltech.Bank.Orchard;
using System;
using System.IO;
using System.Linq;
using EleWise.ELMA.Files;
using EleWise.ELMA.Model.Entities;
using Impeltech.Bank.Extensions;
using Impeltech.Bank.StopFactors;
using Impeltech.Kontur.Extenshions;
using NHibernate.Event;

namespace Impeltech.Bank.Components
{
    [Component]
    public class OrchardEntityEventListener : EntityEventsListener
    {
        #region Insert
        public override bool OnPreInsert(PreInsertEvent @event)
        {
            try
            {
                if (@event.Entity is ICustomer)
                {
                    var entity = @event.Entity as ICustomer;
                    try
                    {
                        if (entity.Req == null && entity.EgrDetailsRequest == null)
                        {
                            CustomerManager.Instance.UpdateKontur(entity);
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.Log.Error(ex.Message);
                    }
                    Update(entity);
                }
                if (@event.Entity is ISignedFile)
                {
                    var entity = @event.Entity as ISignedFile;
                    if (entity.RequestLimit?.Applicant != null)
                    {
                        entity.Subject = entity.RequestLimit.Applicant;
                    }
                    if (entity.Request?.Applicant != null)
                    {
                        entity.Subject = entity.Request.Applicant;
                    }
                    entity.UpdateName();
                }
                if (@event.Entity is ITaxForm)
                {
                    var entity = @event.Entity as ITaxForm;
                    Update(entity);
                }
                if (@event.Entity is IHelpBidType)
                {
                    var entity = @event.Entity as IHelpBidType;
                    Update(entity);
                }
                if (@event.Entity is IGuaranteeType)
                {
                    var entity = @event.Entity as IGuaranteeType;
                    Update(entity);
                }
                if (@event.Entity is IPrinciple)
                {
                    var entity = @event.Entity as IPrinciple;
                    Update(entity);
                }
                if (@event.Entity is IAwardApplication)
                {
                    var entity = @event.Entity as IAwardApplication;
                    Update(entity);
                }
                if (@event.Entity is IAgent)
                {
                    var entity = @event.Entity as IAgent;
                    Update(entity);
                }
                if (@event.Entity is IUserAgent)
                {
                    var entity = @event.Entity as IUserAgent;
                    Update(entity);
                }
                if (@event.Entity is ISubjectMSP)
                {
                    var entity = @event.Entity as ISubjectMSP;
                    Update(entity);
                }
                if (@event.Entity is IBankGuaranteeLimit)
                {
                    var entity = @event.Entity as IBankGuaranteeLimit;
                    Update(entity);
                }
                if (@event.Entity is IClientFixation)
                {
                    var entity = @event.Entity as IClientFixation;
                    Update(entity);
                }
                if (@event.Entity is IAwardApplicationAct)
                {
                    var entity = @event.Entity as IAwardApplicationAct;
                    entity.Name = entity.Agent == null ? "Свод" : $"Акт {entity.Agent.Name}"
                        + $" c {entity.PeriodS.ToShortDateString()} по {entity.PeriodPO.ToShortDateString()}";
                }
                if (@event.Entity is IStopFactor)
                {
                    var entity = @event.Entity as IStopFactor;
                    var handler = StopFactorHelper.Instance.GetStopFactorHandler(entity);
                    handler.SetDefaultSettings(entity);
                }
                if (@event.Entity is IReasonForCancel)
                {
                    var entity = @event.Entity as IReasonForCancel;
                    Update(entity);
                }
            }
            catch (Exception ex)
            {
                var message = $"Не удалось выполнить {nameof(OnPreInsert)}";
                Logger.Log.Error(message, ex);
                throw new Exception(message, ex); //Прервать событие
            }
            return false;
        }

        public override void OnPostInsert(PostInsertEvent @event)
        {
            try
            {
                if (@event.Entity is IHistoryStepItem)
                {
                    var historyStepItem = @event.Entity as IHistoryStepItem;
                    if (!string.IsNullOrWhiteSpace(historyStepItem.FullNameStep))
                    {
                        //определение и обработка похожих шагов
                        PrepareSimilarStepItem(historyStepItem);
                    }
                    if (historyStepItem.Request != null)
                    {
                        historyStepItem.Request.LastEvent = historyStepItem;
                        historyStepItem.Request.Save();
                    }
                }
            }
            catch (Exception ex)
            {
                var message = $"Не удалось выполнить {nameof(OnPostInsert)}";
                Logger.Log.Error(message, ex);
            }
            base.OnPostInsert(@event);
        }
        #endregion
        #region Update
        public override bool OnPreUpdate(PreUpdateEvent @event)
        {
            try
            {
                if (@event.Entity is ISubjectMSP)
                {
                    var entity = @event.Entity as ISubjectMSP;
                    Update(entity);
                }
                if (@event.Entity is IAwardApplication)
                {
                    var entity = @event.Entity as IAwardApplication;
                    Update(entity);
                }
                if (@event.Entity is ICustomer)
                {
                    var entity = @event.Entity as ICustomer;
                    Update(entity);
                }
                if (@event.Entity is ITaxForm)
                {
                    var entity = @event.Entity as ITaxForm;
                    Update(entity);
                }
                if (@event.Entity is IHelpBidType)
                {
                    var entity = @event.Entity as IHelpBidType;
                    Update(entity);
                }
                if (@event.Entity is IGuaranteeType)
                {
                    var entity = @event.Entity as IGuaranteeType;
                    Update(entity);
                }
                if (@event.Entity is IPrinciple)
                {
                    var entity = @event.Entity as IPrinciple;
                    Update(entity);
                }
                if (@event.Entity is IAgent)
                {
                    var entity = @event.Entity as IAgent;
                    Update(entity);
                }
                if (@event.Entity is IUserAgent)
                {
                    var entity = @event.Entity as IUserAgent;
                    Update(entity);
                }
                if (@event.Entity is IBankGuaranteeLimit)
                {
                    var entity = @event.Entity as IBankGuaranteeLimit;
                    entity.UpdateAmounts();
                    Update(entity);
                }
                if (@event.Entity is IClientFixation)
                {
                    var entity = @event.Entity as IClientFixation;
                    Update(entity);
                }
                if (@event.Entity is ISignedFile)
                {
                    var entity = @event.Entity as ISignedFile;
                    entity.UpdateName();
                    var numFile = Array.IndexOf(@event.Persister.PropertyNames, nameof(ISignedFile.File));
                    if (numFile >= 0)
                    {
                        var fileOld = (BinaryFile)@event.OldState[numFile];
                        var fileNew = (BinaryFile)@event.State[numFile];
                        //если файл изменен и он раньше существовал в орчарде - иначе нет смысла его туда отплавлять
                        if (fileOld != null && fileNew != null && !fileOld.Equals(fileNew))
                        {
                            // если файл существует
                            if (entity.File != null && File.Exists(entity.File?.ContentFilePath))
                            {
                                // проверим хэш
                                var newFileHash = SignedFileManager.GetHash(entity.File.ContentFilePath);
                                //если хеш не равен тому что уже есть
                                if (!newFileHash.Equals(entity.FileHash))
                                {
                                    //сохраним новый хеш
                                    entity.FileHash = newFileHash;
                                    //и отправим в орчард т.к. если хеш отличается значит файл изменилсяв нашей системе
                                    var request = entity.Request ?? entity.RequestLimit as IEntity;
                                    entity.FileId = OrchardHelper.Instance.UpdateOrCreateEncodedFile(
                                        new SignedFileContract(entity, request),
                                        File.ReadAllBytes(entity?.File?.ContentFilePath));
                                }
                            }
                        }
                    }
                }
                if (@event.Entity is IReasonForCancel)
                {
                    var entity = @event.Entity as IReasonForCancel;
                    Update(entity);
                }
            }
            catch (Exception ex)
            {
                var message = $"Не удалось выполнить {nameof(OnPreUpdate)}";
                Logger.Log.Error(message, ex);
                throw new Exception(message, ex); //Прервать событие
            }
            return false;
        }

        public override void OnPreUpdateCollection(PreCollectionUpdateEvent @event)
        {
            try
            {
                if (@event.AffectedOwnerOrNull is ICustomer)
                {
                    var entity = (ICustomer)@event.AffectedOwnerOrNull;
                    Update(entity);
                }
                if (@event.AffectedOwnerOrNull is IBankGuaranteeLimit)
                {
                    var entity = @event.AffectedOwnerOrNull as IBankGuaranteeLimit;
                    Update(entity);
                }
                if (@event.AffectedOwnerOrNull is IClientFixation)
                {
                    var entity = @event.AffectedOwnerOrNull as IClientFixation;
                    Update(entity);
                }
            }
            catch (Exception ex)
            {
                var message = $"Не удалось выполнить {nameof(OnPreUpdateCollection)}";
                Logger.Log.Error(message, ex);
            }
        }
        public override void OnPostUpdate(PostUpdateEvent @event)
        {
            try
            {
                if (@event.Entity is IAdditionalRequest)
                {
                    var numResponse = Array.IndexOf(@event.Persister.PropertyNames, "ReceivedResponse");
                    if (numResponse >= 0)
                    {
                        var responseStatusOld = (bool)@event.OldState[numResponse];
                        var responseStatusNew = (bool)@event.State[numResponse];
                        //если было нет а стало да то нужно запустить процесс
                        if (responseStatusOld == false && responseStatusNew)
                        {
                            var entity = (IAdditionalRequest)@event.Entity;
                            AdditionalRequestManager.Instance.StartProcessAdditionalRequestAnswerReceived(entity);
                        }
                    }
                }
                if (@event.Entity is IRequestBankGuarantee)
                {
                    var numStep = Array.IndexOf(@event.Persister.PropertyNames, nameof(IRequestBankGuarantee.Step));
                    var numFullNameStep = Array.IndexOf(@event.Persister.PropertyNames, nameof(IRequestBankGuarantee.FullNameStep));
                    if (numStep >= 0 && numFullNameStep >= 0)
                    {
                        var stepOld = (string)@event.OldState[numStep];
                        var stepNew = (string)@event.State[numStep];
                        var fullNameStepOld = (string)@event.OldState[numFullNameStep];
                        var fullNameStepNew = (string)@event.State[numFullNameStep];
                        var request = @event.Entity as IRequestBankGuarantee;
                        if (stepOld != stepNew ||
                            fullNameStepOld != fullNameStepNew ||
                            request.LastEvent == null && (!string.IsNullOrWhiteSpace(stepNew) || !string.IsNullOrWhiteSpace(fullNameStepNew)))
                        {

                            var historyElement = EntityManager<IHistoryStepItem>.Instance.Create();
                            historyElement.Step = stepNew;
                            historyElement.FullNameStep = fullNameStepNew;
                            historyElement.Request = request;
                            historyElement.Save();
                            if (stepOld != stepNew && stepNew == "#0")
                            {
                                request.Limit?.UpdateAmounts();
                            }
                        }
                    }
                    var numCanceled = Array.IndexOf(@event.Persister.PropertyNames, nameof(IRequestBankGuarantee.Canceled));
                    if (numCanceled >= 0)
                    {
                        var canceledOld = (bool)@event.OldState[numCanceled];
                        var canceledNew = (bool)@event.State[numCanceled];
                        if (canceledOld != canceledNew)
                        {
                            var request = @event.Entity as IRequestBankGuarantee;
                            request.Limit?.UpdateAmounts();
                        }
                    }
                    var numIssued = Array.IndexOf(@event.Persister.PropertyNames, nameof(IRequestBankGuarantee.Issued));
                    if (numIssued >= 0)
                    {
                        var issuedOld = (bool)@event.OldState[numIssued];
                        var issuedNew = (bool)@event.State[numIssued];
                        if (issuedOld != issuedNew)
                        {
                            var request = @event.Entity as IRequestBankGuarantee;
                            request.Limit?.UpdateAmounts();
                            if (issuedNew)
                            {
                                request.UpdateIssuedFixation();
                            }
                        }
                    }

                }
                if (@event.Entity is IRequestLimit)
                {
                    var numStep = Array.IndexOf(@event.Persister.PropertyNames, "Step");
                    var numFullNameStep = Array.IndexOf(@event.Persister.PropertyNames, "FullNameStep");
                    if (numStep >= 0 && numFullNameStep >= 0)
                    {
                        var stepOld = (string)@event.OldState[numStep];
                        var stepNew = (string)@event.State[numStep];
                        var fullNameStepOld = (string)@event.OldState[numFullNameStep];
                        var fullNameStepNew = (string)@event.State[numFullNameStep];
                        if (stepOld != stepNew || fullNameStepOld != fullNameStepNew)
                        {
                            var request = @event.Entity as IRequestLimit;
                            var historyElement = EntityManager<IHistoryStepItem>.Instance.Create();
                            historyElement.Step = stepNew;
                            historyElement.FullNameStep = fullNameStepNew;
                            historyElement.RequestLimit = request;
                            historyElement.Save();
                        }
                    }
                }

                var userExt = @event.Entity as IUserExt;
                if (userExt?.OrhardContentId > 0)
                {
                    OrchardHelper.Instance.CreateOrUpdateCurrentElmaUser(userExt);
                }
            }
            catch (Exception ex)
            {
                var message = $"Не удалось выполнить {nameof(OnPostUpdate)}";
                Logger.Log.Error(message, ex);
            }
            base.OnPostUpdate(@event);
        }
        #endregion
        #region Delete
        public override bool OnPreDelete(PreDeleteEvent @event)
        {
            try
            {
                if (@event.Entity is ICustomer)
                {
                    var entity = (ICustomer)@event.Entity;
                    {
                        var helper = new OrchardHelper();
                        return !helper.DeleteContentItem((int)entity.OrhardContentId);
                    }
                }
                if (@event.Entity is ITaxForm)
                {
                    var entity = (ITaxForm)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is IGuaranteeType)
                {
                    var entity = (IGuaranteeType)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is IRequestBankGuarantee)
                {
                    var entity = (IRequestBankGuarantee)@event.Entity;
                    var helper = new OrchardHelper();
                    return entity.RequestNumberInOrchard != null && !helper.DeleteContentItem((int)entity.RequestNumberInOrchard);
                }
                if (@event.Entity is IRequestLimit)
                {
                    var entity = (IRequestLimit)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is ISubjectMSP)
                {
                    var entity = (ISubjectMSP)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is IPrinciple)
                {
                    var entity = (IPrinciple)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is IAgent)
                {
                    var entity = (IAgent)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is IUserAgent)
                {
                    var entity = (IUserAgent)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem(new UserAgentContract(entity));
                }
                if (@event.Entity is IBankGuaranteeLimit)
                {
                    var entity = @event.Entity as IBankGuaranteeLimit;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is IClientFixation)
                {
                    var entity = @event.Entity as IClientFixation;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
                if (@event.Entity is IAdditionalRequest)
                {
                    var entity = (IAdditionalRequest)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.RemoveAdditionalRequest(entity.Uid);
                }
                if (@event.Entity is IHelpBidType)
                {
                    var entity = (IHelpBidType)@event.Entity;
                    var helper = new OrchardHelper();
                    return !helper.RemoveHelpBidType(entity.Id);
                }
                if (@event.Entity is IAwardApplication)
                {
                    var entity = (IAwardApplication)@event.Entity;
                    var helper = new OrchardHelper();
                    helper.RemoveAwardApplication(entity.OrhardContentId);
                }
                if (@event.Entity is IReasonForCancel)
                {
                    var entity = @event.Entity as IReasonForCancel;
                    var helper = new OrchardHelper();
                    return !helper.DeleteContentItem((int)entity.OrhardContentId);
                }
            }
            catch (Exception ex)
            {
                var message = $"Не удалось выполнить {nameof(OnPreDelete)}";
                Logger.Log.Error(message, ex);
                throw new Exception(message, ex); //Прервать событие
            }
            return false;
        }
        #endregion
        #region Helpers
        private static void PrepareSimilarStepItem(IHistoryStepItem historyStepItem)
        {
            if (historyStepItem.Request != null)
            {
                PrepareSimilarStepItem(historyStepItem, historyStepItem.Request.StepHistory);
            }
            if (historyStepItem.RequestLimit != null)
            {
                PrepareSimilarStepItem(historyStepItem, historyStepItem.RequestLimit.StepHistory);
            }
        }
        private static void PrepareSimilarStepItem(IHistoryStepItem historyStepItem, Iesi.Collections.Generic.ISet<IHistoryStepItem> stepHistory)
        {
            Func<IHistoryStepItem, bool> similarStepItem = c => c.FullNameStep == historyStepItem.FullNameStep;
            var countSimilarStepItem = stepHistory.Count(similarStepItem);
            if (countSimilarStepItem <= 0) return;
            var indexNumber = countSimilarStepItem + 1;
            historyStepItem.IndexNumber = indexNumber;
            if (countSimilarStepItem == 1)
            {
                var firstSimilarItem = stepHistory.FirstOrDefault(similarStepItem);
                if (firstSimilarItem != null)
                {
                    firstSimilarItem.IndexNumber = 1;
                    firstSimilarItem.Save();
                }
            }
            historyStepItem.Save();
        }
        #endregion

        #region Обновление

        public static void ExeuteIfHasChanges<T>(Action<T, string> action, T serializableContract, string oldHash)
        {
            var newHash = serializableContract.GetHashByJson();
            /*
             *для отладки хешей
             *
             *  var path = Path.Combine(HostingEnvironment.MapPath("~/")?? "C:\\", typeof(T).Name+".log");
              File.AppendAllText(path,
                  @"------------------" +
                  $@"{Environment.NewLine}" +
                  $@"new:{newHash} old:{oldHash ?? "null"} " +
                  $@"{Environment.NewLine}" +
                  $@"{Environment.NewLine}" +
                  $@"{JsonConvert.SerializeObject(serializableContract)}");*/
            if (string.IsNullOrWhiteSpace(oldHash) || !newHash.Equals(oldHash))
            {
                action.Invoke(serializableContract, newHash);
            }
        }

        private static void Update(IReasonForCancel entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.SaveRejectionReason(contract);
                },
                new ReasonForCancelContract(entity),
                entity.OutboundHash);
        }

        private static void Update(IClientFixation entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.SaveClientFixation(contract);
                },
                new ClientFixationContract(entity),
                entity.OutboundHash);
        }

        private static void Update(IBankGuaranteeLimit entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            entity.Name = $"Лимит {entity.Contragent?.ShortName}";
            entity.UpdateAmounts();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.SaveBankGuaranteeLimit(contract);
                },
                new BankGuaranteeLimitContract(entity),
                entity.OutboundHash);
        }

        private static void Update(ISubjectMSP entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            // если в орчарде его нет, нет закреплений, нет агент и он не в черном списке то не нужно его отправлять зря в орчардд
            if(!(entity.OrhardContentId > 0) && !entity.Fixations.Any() && entity.Agent == null && !entity.InBlackList) return;
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreateOrUpdateApplicant(contract);
                },
                new ApplicantContract(entity),
                entity.OutboundHash);
        }

        private static void Update(IUserAgent entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreateOrUpdateUserAgent(contract);
                },
                new UserAgentContract(entity),
                entity.OutboundHash);
        }

        private static void Update(IAgent entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreateOrUpdateAgent(contract);
                },
                new AgentContract(entity),
                entity.OutboundHash);
        }

        private static void Update(IAwardApplication entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreateOrUpdateAwardApplication(contract);
                },
                new AwardApplicationContract(entity),
                entity.OutboundHash);
        }

        private static void Update(IPrinciple entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreatePrinciple(entity.Uid, entity.Name);
                },
                entity.Name,
                entity.OutboundHash);
        }

        private static void Update(IGuaranteeType entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreateGuaranteeType(contract);
                },
                new GuaranteeTypeContract(entity),
                entity.OutboundHash);
        }

        private static void Update(IHelpBidType entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.SaveHelpBidType(contract);
                },
                new HelpBidTypeContract(entity),
                entity.OutboundHash);
        }

        private static void Update(ITaxForm entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreateTaxForm(entity.Uid, entity.Name);
                },
                entity.Name,
                entity.OutboundHash);
        }

        private static void Update(ICustomer entity)
        {
            if (entity.Uid == Guid.Empty)
                entity.Uid = Guid.NewGuid();
            ExeuteIfHasChanges(
                (contract, s) =>
                {
                    entity.OutboundHash = s;
                    entity.OrhardContentId = OrchardHelper.Instance.CreateOrUpdateCustomer(contract);
                },
                new CustomerContract(entity),
                entity.OutboundHash);
        }

        #endregion
    }
}