BeWoPlaner/Service/DCEntityMapper/GkvAbrechnungDC_GkvAbrechnung.cs

using BeWo.Data.Access;
using BeWo.Data.Entities;
using BS.Shared.Core;
using BS.Shared.DataContracts;
using BS.Shared.DataContracts.GkvAbrechnung;
using BS.Shared.Extensions;
using NHibernate.Linq;
using System.Collections.Generic;
using System.Linq;

namespace BeWo.Service.DCEntityMapper
{
    public class GkvAbrechnungDC_GkvAbrechnung : AbstractIDCEntityMapper<GkvAbrechnung, GkvAbrechnungDC>
    {
        public override GkvAbrechnungDC MergeWithDC(GkvAbrechnung pEntity, GkvAbrechnungDC pDataContract)
        {
            if(pEntity.InvoiceBases == null || !pEntity.InvoiceBases.Any())
            {

            }
            var orga = pEntity.GetOrganisation();

            pDataContract.GkvAbrechnungOid = pEntity.Oid;
            pDataContract.GkvAbrechnungVersion = pEntity.Version;
            pDataContract.Notice = pEntity.Notice;

            pDataContract.AbrechnungsZeitraumStart = pEntity.AbrechnungsZeitraumStart;
            pDataContract.AbrechnungsZeitraumEnde = pEntity.AbrechnungsZeitraumEnde;

            pDataContract.Betrag = pEntity.Betrag;
            pDataContract.Bezahlt = pEntity.Bezahlt;
            pDataContract.UrbelegeGesendet = pEntity.UrbelegeGesendet;
            pDataContract.ErstelltAm = pEntity.ErstelltAm;
            pDataContract.Verfahrensstufe = pEntity.Verfahrensstufe;

            pDataContract.InvoiceBases = MapperFactory.InvoiceBaseDC_InvoiceBase.MapToNewDCs(pEntity.InvoiceBases);

            pDataContract.Organisation = MapperFactory.OrganisationDC_OrganisationMapper.MapToNewDC(orga);

            pDataContract.TransferProtokolle = MapperFactory.GkvTransferProtokollDC_GkvTransferprotokoll.MapToNewDCs(pEntity.GkvTransferProtokolle);

            bool isReady = false;
            string tooltip = "unknown error";

            var state = pDataContract.GetState();

			switch (state)  
			{
				case BS.Shared.GkvState.NoSend:
                    isReady = true;
					tooltip = "Senden";
					break;
				case BS.Shared.GkvState.ErrorSoft:
                    isReady = true;
                    tooltip = "Erneut senden";
                    break;
				case BS.Shared.GkvState.ErrorFatal:
                    isReady = false;
                    tooltip = "Fataler Fehler";
                    break;
                case BS.Shared.GkvState.ErrorFolgefehler:
                    isReady = false;
                    tooltip = "Folgefehler";
                    break;
                case BS.Shared.GkvState.Paid:
                    isReady = false;
                    tooltip = "Bereits bezahlt";
                    break;
				case BS.Shared.GkvState.WaitingForDakota:
                    isReady = false;
                    tooltip = "Warte auf Übertragung";
                    break;
				case BS.Shared.GkvState.WaitingForKrankenkasse:
                    isReady = false;
                    tooltip = "Warte auf Gkv";
					break;
				case BS.Shared.GkvState.WaitingForKrankenkasseTooLong:
                    isReady = false;
                    tooltip = "Informieren sie sich bei der jeweiligen Gkv";
                    break;
				case BS.Shared.GkvState.WaitingForUrbelege:
                    isReady = false;
                    tooltip = "Urbelege noch nicht gesendet";
                    break;
				default:
					break;
			}

			if (isReady)
			{
                if(!Validator.IsOrganisationInformationValid(orga.IKDatenannahmestelle, orga.IKKostentrager, orga.IKKrankenkasse, orga.BezDatenannahmestelle))
                {
                    isReady = false;
                    tooltip = "Organisation fehlen Informationen";
                }
            }

            pDataContract.IsReady2Send = isReady;
            pDataContract.SendTooltip = tooltip; 

            return pDataContract;
        }

        public override GkvAbrechnung MergeWithEntity(GkvAbrechnungDC pDataContract, GkvAbrechnung pEntity)
        {
            this.ConcurrencyCheck(pDataContract.GkvAbrechnungVersion, pEntity);

            pEntity.Oid = pDataContract.GkvAbrechnungOid;
            pEntity.Version = pDataContract.GkvAbrechnungVersion;
            pEntity.Notice = pDataContract.Notice;

            pEntity.AbrechnungsZeitraumStart = pDataContract.AbrechnungsZeitraumStart;
            pEntity.AbrechnungsZeitraumEnde = pDataContract.AbrechnungsZeitraumEnde;

            pEntity.Betrag = pDataContract.Betrag;
            pEntity.Bezahlt = pDataContract.Bezahlt;
            pEntity.UrbelegeGesendet = pDataContract.UrbelegeGesendet;
            pEntity.Verfahrensstufe = pDataContract.Verfahrensstufe;

            pEntity.ErstelltAm = pDataContract.ErstelltAm;

            if (pEntity.GkvTransferProtokolle is null)
                pEntity.GkvTransferProtokolle = new List<GkvTransferProtokoll>();

            MapperFactory.GkvTransferProtokollDC_GkvTransferprotokoll.MergeWithEntitys(pDataContract.TransferProtokolle, pEntity.GkvTransferProtokolle);

            if (pEntity.InvoiceBases is null)
                pEntity.InvoiceBases = new List<InvoiceBase>();

            pEntity.InvoiceBases = DAOFactory.GenericDAO.LoadByIDs<InvoiceBase>(pDataContract.InvoiceBases.Select(x => x.InvoiceBaseOid.Value));

            //MapperFactory.InvoiceBaseDC_InvoiceBase.MergeWithEntitys(pDataContract.InvoiceBases, pEntity.InvoiceBases);

            return pEntity;
        }

        protected override bool AreDCAndEntityEqual(GkvAbrechnungDC pDC, GkvAbrechnung pEntity)
        {
            if (pDC.GkvAbrechnungOid == null)
            {
                return false;
            }

            return pDC.GkvAbrechnungOid == pEntity.Oid;
        }
    }
}