예제 #1
0
        public void TryLogMedlemIndTest_MedlemEksistererMedStatusAktivRegnskabsmedlemHarStatusGammel()
        {
            //NB: DENNE TEST SLETTER Medlem, Regnskabsmedlem og Begivenhed data
            MedlemmerManager medlemmerManager = null;
            RegnskabsmedlemsManagerUnitTest regnskabsmedlemsManager = null;
            LoggingManagerUnitTest          loggingManager          = null;

            InitierStubLogMedlemIndTest(out loggingManager, out regnskabsmedlemsManager, out medlemmerManager);

            int antalNyeEntiteter = 5;

            IndsaetNRegnskabsmedlemmerIRegnskabsmedlemsManagerOgSynkroniser(regnskabsmedlemsManager, antalNyeEntiteter, MedlemsstatusEnum.Aktiv);

            int arkID = UnitTestHelper.HentFoersteMedlemsArkID();

            UnitTestHelper.OpdaterMedlemStatus(arkID, MedlemsstatusEnum.Aktiv);
            Medlem medlemViProeverAtLoggeInd = null;

            using (ArkDatabase db = new ArkDatabase())
            {
                medlemViProeverAtLoggeInd = db.Medlems.First(medlemItem => medlemItem.ArkID == arkID);
            }
            int medlemID = medlemViProeverAtLoggeInd.ID;

            RegnskabsmedlemDTO regnskabsmedlem = regnskabsmedlemsManager.Regnskabsmedlemmer.First(medlemItem => medlemItem.ArkID == arkID);

            regnskabsmedlem.Status = MedlemsstatusEnum.Gammel;

            string noter = TryLogMedlemInd_TestResultat_ReturnerNotater(arkID, medlemID, MedlemLogindStatusEnum.RegnskabsmedlemstatusGammel, medlemmerManager, loggingManager);
        }
예제 #2
0
        public void SynkroniserRegnskabsmedlemmerOgMedlemmerTest_MedlemAktivTilGammel()
        {
            //NB: DENNE TEST SLETTER Medlem, Regnskabsmedlem og Begivenhed data
            LoggingManagerUnitTest          loggingManager          = null;
            RegnskabsmedlemsManagerUnitTest regnskabsmedlemsManager = null;

            InitierStubMedlemsopdatringerTest(out loggingManager, out regnskabsmedlemsManager);

            int antalNyeEntiteter = 5;

            IndsaetNRegnskabsmedlemmerIRegnskabsmedlemsManagerOgSynkroniser(regnskabsmedlemsManager, antalNyeEntiteter, MedlemsstatusEnum.Aktiv);

            string nytNavn = Guid.NewGuid().ToString();
            int    arkID   = UnitTestHelper.HentFoersteMedlemsArkID();

            UnitTestHelper.OpdaterMedlemStatus(arkID, MedlemsstatusEnum.Aktiv);

            //Aendre regnskabsmedlem i stubben
            RegnskabsmedlemDTO regnskabsmedlem = regnskabsmedlemsManager.Regnskabsmedlemmer.First(medlemItem => medlemItem.ArkID == arkID);

            regnskabsmedlem.Status = MedlemsstatusEnum.Gammel;
            regnskabsmedlem.Navn   = nytNavn;

            string notater = Synkroniser_TestResultat_ReturnerNotater(arkID, regnskabsmedlem, loggingManager, false, true);
        }
예제 #3
0
 internal static void OverskrivMedRegnskabsmedlemsdata(RegnskabsmedlemDTO regnskabsmedlem, Medlem medlem)
 {
     medlem.Adresse           = regnskabsmedlem.Adresse;
     medlem.AdresseBy         = regnskabsmedlem.AdresseBy;
     medlem.AdressePostNummer = regnskabsmedlem.AdressePostNummer;
     medlem.ArkID             = regnskabsmedlem.ArkID;
     medlem.EMailAdresse      = regnskabsmedlem.EMailAdresse;
     medlem.Foedselsdato      = regnskabsmedlem.Foedselsdato;
     medlem.Koen        = regnskabsmedlem.Koen;
     medlem.MobilNummer = regnskabsmedlem.MobilNummer;
     medlem.Navn        = regnskabsmedlem.Navn;
     medlem.Status      = regnskabsmedlem.Status;
 }
예제 #4
0
        private string Synkroniser_TestResultat_ReturnerNotater(
            int arkID,
            RegnskabsmedlemDTO regnskabsmedlem,
            LoggingManagerUnitTest loggingManager,
            bool medlemOgRegnskabsmeldemNavnSkalVaereEns,
            bool kendtRegnskabsmedlemOgRegnskabsmedlemNavnSkalVaereEns,
            MedlemsstatusEnum?medlemstatusHvisForskelligFraRegnskabsmedlemstatus = null)
        {
            loggingManager.Clear();
            (new MedlemmerManager()).SynkroniserRegnskabsmedlemmerOgMedlemmer(false);

            string notater = KomponentManager.LoggingManager.ToString();

            Assert.IsTrue(!String.IsNullOrEmpty(notater), notater);

            using (ArkDatabase db = new ArkDatabase())
            {
                Medlem          medlem = db.Medlems.First(medlemItem => medlemItem.ArkID == arkID);
                Regnskabsmedlem kendtRegnskabsmedlem = db.Regnskabsmedlems.First(medlemItem => medlemItem.ArkID == arkID);

                if (medlemstatusHvisForskelligFraRegnskabsmedlemstatus.HasValue)
                {
                    Assert.AreEqual(medlemstatusHvisForskelligFraRegnskabsmedlemstatus.Value, medlem.Status);
                }
                else
                {
                    Assert.AreEqual(regnskabsmedlem.Status, medlem.Status);
                }

                if (medlemOgRegnskabsmeldemNavnSkalVaereEns)
                {
                    Assert.AreEqual(regnskabsmedlem.Navn, medlem.Navn);
                }
                else
                {
                    Assert.AreNotEqual(regnskabsmedlem.Navn, medlem.Navn);
                }

                Assert.AreEqual(regnskabsmedlem.Status, kendtRegnskabsmedlem.Status);
                if (kendtRegnskabsmedlemOgRegnskabsmedlemNavnSkalVaereEns)
                {
                    Assert.AreEqual(regnskabsmedlem.Navn, kendtRegnskabsmedlem.Navn);
                }
                else
                {
                    Assert.AreNotEqual(regnskabsmedlem.Navn, kendtRegnskabsmedlem.Navn);
                }
            }
            return(notater);
        }
예제 #5
0
 internal static bool HarRegnskabsmedlemOgKendtRegnskabsmedlemSammeData(RegnskabsmedlemDTO regnskabsmedlem, Regnskabsmedlem kendtRegnskabsmedlem)
 {
     return
         (regnskabsmedlem.Adresse == kendtRegnskabsmedlem.Adresse &&
          regnskabsmedlem.AdresseBy == kendtRegnskabsmedlem.AdresseBy &&
          regnskabsmedlem.AdressePostNummer == kendtRegnskabsmedlem.AdressePostNummer &&
          regnskabsmedlem.ArkID == kendtRegnskabsmedlem.ArkID &&
          regnskabsmedlem.EMailAdresse == kendtRegnskabsmedlem.EMailAdresse &&
          regnskabsmedlem.Foedselsdato == kendtRegnskabsmedlem.Foedselsdato &&
          regnskabsmedlem.Koen == kendtRegnskabsmedlem.Koen &&
          regnskabsmedlem.MobilNummer == kendtRegnskabsmedlem.MobilNummer &&
          regnskabsmedlem.Navn == kendtRegnskabsmedlem.Navn &&
          regnskabsmedlem.Status == kendtRegnskabsmedlem.Status);
 }
예제 #6
0
        private List <RegnskabsmedlemDTO> KonverterRegnskabsmedlemmerFraXmlDocument(XmlDocument document)
        {
            List <RegnskabsmedlemDTO> regnskabsmedlemmer = new List <RegnskabsmedlemDTO>();
            XmlNodeList medlemsnoder = document.SelectNodes(XML_DOKUMENT_MEDLEMMERSNODENAVN);

            foreach (XmlNode medlemsnode in medlemsnoder)
            {
                try
                {
                    RegnskabsmedlemDTO regnskabsMedlem = KonverterRegnskabsmedlemFraXmlNode(medlemsnode);
                    regnskabsmedlemmer.Add(regnskabsMedlem);
                }
                catch (Exception exception)
                {
                    KomponentManager.LoggingManager.LogException(MethodInfo.GetCurrentMethod().DeclaringType.Name + "." + MethodInfo.GetCurrentMethod().Name, exception);
                }
            }
            return(regnskabsmedlemmer);
        }
        public RegnskabsmedlemDTO LavNytRegnskabsmedlem(MedlemsstatusEnum?forceretStatus = null)
        {
            RegnskabsmedlemDTO medlem = new RegnskabsmedlemDTO()
            {
                Adresse           = "Adresse" + _regnskabsmedlemNummer,
                AdresseBy         = "By" + _regnskabsmedlemNummer,
                AdressePostNummer = _regnskabsmedlemNummer.ToString(),
                ArkID             = _regnskabsmedlemNummer,
                EMailAdresse      = "EMail" + _regnskabsmedlemNummer,
                Foedselsdato      = new DateTime(1977 + _regnskabsmedlemNummer, 1, 1),
                Koen        = (_regnskabsmedlemNummer % 2 == 0 ? KoenEnum.Mand : KoenEnum.Kvinde),
                MobilNummer = (22220000 + _regnskabsmedlemNummer).ToString(),
                Navn        = "Navn" + _regnskabsmedlemNummer,
                Status      = (forceretStatus.HasValue ? forceretStatus.Value : (MedlemsstatusEnum)((_regnskabsmedlemNummer % 3) + 2))
            };

            _regnskabsmedlemNummer++;
            Regnskabsmedlemmer.Add(medlem);
            return(medlem);
        }
예제 #8
0
        internal RegnskabsmedlemDTO HentRegnskabsmedlem(int arkID)
        {
            RegnskabsmedlemDTO regnskabsmedlem = null;

            try
            {
                WebRequest      forespoergsel = WebRequest.Create(HentMedlemsforespoergsel(arkID));
                HttpWebResponse svar          = (HttpWebResponse)forespoergsel.GetResponse();
                Stream          svarStream    = svar.GetResponseStream();
                XmlDocument     xmlDocument   = new XmlDocument();
                xmlDocument.Load(svarStream);
                regnskabsmedlem = KonverterRegnskabsmedlemFraXmlDocument(xmlDocument);
            }
            catch (Exception exception)
            {
                KomponentManager.LoggingManager.LogException(MethodInfo.GetCurrentMethod().DeclaringType.Name + "." + MethodInfo.GetCurrentMethod().Name, exception);
                throw new Exception("Rethrown", exception);
            }
            return(regnskabsmedlem);
        }
        public void HentRegnskabsmedlemTest()
        {
            LoggingManagerUnitTest loggingManager = new LoggingManagerUnitTest();

            KomponentManager.LoggingManager = loggingManager;

            List <RegnskabsmedlemDTO> medlemmer = KomponentManager.RegnskabsmedlemsManager.HentRegnskabsmedlemmer();

            Assert.IsTrue(medlemmer.Count > 10);
            RegnskabsmedlemDTO medlemTilAtHente = medlemmer[10];
            int arkID = medlemTilAtHente.ArkID;

            loggingManager.Clear();

            RegnskabsmedlemDTO hentetMedlem = KomponentManager.RegnskabsmedlemsManager.HentRegnskabsmedlem(arkID);

            string notater = loggingManager.ToString();

            Assert.IsNotNull(hentetMedlem, notater);
            Assert.AreEqual <string>(hentetMedlem.Navn, medlemTilAtHente.Navn, notater);
        }
예제 #10
0
        private RegnskabsmedlemDTO KonverterRegnskabsmedlemFraXmlDocument(XmlDocument document)
        {
            RegnskabsmedlemDTO regnskabsmedlem = null;
            XmlNodeList        medlemsnoder    = document.SelectNodes(XML_DOKUMENT_MEDLEMSNODENAVN);

            if (medlemsnoder.Count > 1)
            {
                throw new Exception("Conventus returnerede multiple entiteter på single <id/>");
            }
            foreach (XmlNode medlemsnode in medlemsnoder)
            {
                try
                {
                    regnskabsmedlem = KonverterRegnskabsmedlemFraXmlNode(medlemsnode);
                }
                catch (Exception exception)
                {
                    KomponentManager.LoggingManager.LogException(MethodInfo.GetCurrentMethod().DeclaringType.Name + "." + MethodInfo.GetCurrentMethod().Name, exception);
                }
            }
            return(regnskabsmedlem);
        }
예제 #11
0
        public void SynkroniserRegnskabsmedlemmerOgMedlemmer(bool validerLaesteRegnskabsmedlemmer = true)
        {
            StringBuilder logBeskedBygger = new StringBuilder();

            //¤¤¤ Tegnforklaring
            //¤¤¤ Tekst som står efter '//¤¤¤' er en kommentar
            //¤¤¤ Tekst som står efter '//' skal konverteres til kode

            //¤¤¤ Tre entiteter er vigtige i denne sammenhæng:
            //¤¤¤ Regnskabsmedlem: Læst direkte i regnskabssystemet
            //¤¤¤ KendtRegnskabsmedlem: Persisteret data fra siste gang regnskabssystemet leverede et opdateret Regnskabsmedlem
            //¤¤¤ Medlem: Brugeren (aktiveret eller ej) af websitet.
            //¤¤¤
            //¤¤¤ Disse tre entiteter har datafelter til fælles som defineret i ARK.Website.Common.RegnskabsmedlemDTO
            //¤¤¤ At to entiteter er ens betyder at datafelterne alle har samme værdi

            //¤¤¤ Status er vigtig i denne sammenhæng (ARK.Website.Common.Enum.MedlemsstatusEnum)
            //¤¤¤ Værdi IkkeAktiveret: Bruger som kan tilgå logbog og kan ses på websitet, men som aldrig har været logget på websitet
            //¤¤¤ Værdi Aktiv: Bruger som kan tilgå logbog og website
            //¤¤¤ Værdi Inaktiv: Bruger som kan tilgå website men ikke skrive til logbog (kan ikke få lov at ro/padle)
            //¤¤¤ Værdi Gammel: Bruger som kan tilgå hverken website eller logbog, men som stadig figurerer i rostatistik og website historik

            List <RegnskabsmedlemDTO> regnskabsmedlemmer = new List <RegnskabsmedlemDTO>();

            try
            {
                regnskabsmedlemmer = KomponentManager.RegnskabsmedlemsManager.HentRegnskabsmedlemmer();
            }
            catch (Exception exception)
            {
                logBeskedBygger.AppendLine("Læsning af regnskabsmedlemmer fejlede: " + exception.ToString() + Environment.NewLine);
            }

            //¤¤¤ Valider regnskabsmedlemmer så forfejlede retursvar ikke fortsætter. Kunne eksempelvis være antallet af læste aktive regnskabsmedlemmer
            int  antalAktiveRegnskabsmedlemmer     = regnskabsmedlemmer.Count(medlemsItem => medlemsItem.Status == Common.Enum.MedlemsstatusEnum.Aktiv);
            bool erRegnskabsmedlemmerLaesningValid = true;

            if (validerLaesteRegnskabsmedlemmer)
            {
                ErRegnskabsmedlemmerLaesningValid(regnskabsmedlemmer);
            }
            logBeskedBygger.AppendLine("Regnskabsmedlemmer læst: [Valid læsning:" + erRegnskabsmedlemmerLaesningValid + ";Antal:" + regnskabsmedlemmer.Count + ";Medlemsstatus-Aktiv:" + antalAktiveRegnskabsmedlemmer + "]" + Environment.NewLine);

            StringBuilder opdateretMedlemsbesked = new StringBuilder();

            if (erRegnskabsmedlemmerLaesningValid)
            {
                using (ARK.Website.EntityFramework.Main.ArkDatabase db = new EntityFramework.Main.ArkDatabase())
                {
                    List <Medlem>          medlemmer = db.Medlems.ToList();
                    List <Regnskabsmedlem> kendteRegnskabsmedlemmer = db.Regnskabsmedlems.ToList();

                    foreach (RegnskabsmedlemDTO regnskabsmedlem in regnskabsmedlemmer)
                    {
                        bool erOpdateret = false;
                        opdateretMedlemsbesked.Clear();
                        int arkID = regnskabsmedlem.ArkID;
                        opdateretMedlemsbesked.AppendLine("Regnskabsmedlem ArkID = " + arkID);
                        try
                        {
                            Regnskabsmedlem kendtRegnskabsmedlem = kendteRegnskabsmedlemmer.FirstOrDefault(regnskabsmedlemItem => regnskabsmedlemItem.ArkID == arkID);
                            Medlem          medlem = medlemmer.FirstOrDefault(medlemItem => medlemItem.ArkID == arkID);

                            if (medlem == null || kendtRegnskabsmedlem == null)
                            {
                                if (medlem != null || kendtRegnskabsmedlem != null)
                                {
                                    throw new Exception("Fejl i modellen [ArkID=" + arkID + "]: Medlem = " + (medlem == null ? "Null" : "Not Null") + "; KendtRegnskabsmedlem = " + (kendtRegnskabsmedlem == null ? "Null" : "Not Null"));
                                }
                            }

                            if (medlem != null)
                            {
                                //¤¤¤ Endnu ikke aktiverede medlemmer holdes synkrone med regnskabssystemet
                                //¤¤¤ Gamle medlemmer, som kommmer tilbage i systemet, bliver behandlet som nye

                                MedlemsstatusEnum oprindeligMedlemsstatus = medlem.Status;
                                MedlemsstatusEnum oprindeligKendtRegnskabsmedlemsstatus = kendtRegnskabsmedlem.Status;
                                bool medlemsdataOverskrevet = false;
                                bool kendtRegnskabsmedlemsdataOverskrevet = false;
                                bool regnskabsmedlemDataEns = HarRegnskabsmedlemOgKendtRegnskabsmedlemSammeData(regnskabsmedlem, kendtRegnskabsmedlem);
                                if (!regnskabsmedlemDataEns)
                                {
                                    #region Opdatering af eksisterende Medlem og KendtRegnskabsmedlem data
                                    switch (regnskabsmedlem.Status)
                                    {
                                    case MedlemsstatusEnum.Aktiv:
                                    {
                                        switch (oprindeligMedlemsstatus)
                                        {
                                        case MedlemsstatusEnum.Aktiv:
                                        {
                                            //Håndteret af bruger logon
                                        } break;

                                        case MedlemsstatusEnum.Inaktiv:
                                        {
                                            //Status i Regnskabsmedlem - tabellen skal opdateres
                                            //Resten af ændringer i regnskabsmedlemsdata skal håndteres af bruger logon
                                            kendtRegnskabsmedlem.Status = regnskabsmedlem.Status;
                                            medlem.Status = regnskabsmedlem.Status;
                                        } break;

                                        case MedlemsstatusEnum.IkkeAktiveret:
                                        case MedlemsstatusEnum.Gammel:
                                        {
                                            OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, kendtRegnskabsmedlem);
                                            OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, medlem);
                                            medlem.Status = MedlemsstatusEnum.IkkeAktiveret;

                                            medlemsdataOverskrevet = true;
                                            kendtRegnskabsmedlemsdataOverskrevet = true;
                                        } break;

                                        default:
                                        {
                                            throw new NotSupportedException("Medlem.Status = " + oprindeligMedlemsstatus);
                                        }
                                        }
                                    } break;

                                    case MedlemsstatusEnum.Inaktiv:
                                    {
                                        switch (oprindeligMedlemsstatus)
                                        {
                                        case MedlemsstatusEnum.Inaktiv:
                                        {
                                            //Håndteret af bruger logon
                                        } break;

                                        case MedlemsstatusEnum.Aktiv:
                                        {
                                            //Status i Regnskabsmedlem - tabellen skal opdateres
                                            //Resten af ændringer i regnskabsmedlemsdata skal håndteres af bruger logon
                                            kendtRegnskabsmedlem.Status = regnskabsmedlem.Status;
                                            medlem.Status = regnskabsmedlem.Status;
                                        } break;

                                        case MedlemsstatusEnum.IkkeAktiveret:
                                        case MedlemsstatusEnum.Gammel:
                                        {
                                            OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, kendtRegnskabsmedlem);
                                            OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, medlem);
                                            medlem.Status = MedlemsstatusEnum.IkkeAktiveret;

                                            medlemsdataOverskrevet = true;
                                            kendtRegnskabsmedlemsdataOverskrevet = true;
                                        } break;

                                        default:
                                        {
                                            throw new NotSupportedException("Medlem.Status = " + oprindeligMedlemsstatus);
                                        }
                                        }
                                    } break;

                                    case MedlemsstatusEnum.Gammel:
                                    {
                                        switch (oprindeligMedlemsstatus)
                                        {
                                        case MedlemsstatusEnum.IkkeAktiveret:
                                        {
                                            OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, kendtRegnskabsmedlem);
                                            OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, medlem);

                                            medlemsdataOverskrevet = true;
                                            kendtRegnskabsmedlemsdataOverskrevet = true;
                                        } break;

                                        case MedlemsstatusEnum.Aktiv:
                                        case MedlemsstatusEnum.Inaktiv:
                                        case MedlemsstatusEnum.Gammel:
                                        {
                                            OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, kendtRegnskabsmedlem);
                                            medlem.Status = regnskabsmedlem.Status;

                                            kendtRegnskabsmedlemsdataOverskrevet = true;
                                        } break;

                                        default:
                                        {
                                            throw new NotSupportedException("Medlem.Status = " + oprindeligMedlemsstatus);
                                        }
                                        }
                                    } break;

                                    default:
                                    {
                                        throw new NotSupportedException("Regnskabsmedlem.Status = " + regnskabsmedlem.Status);
                                    }
                                    }
                                    #endregion
                                }

                                #region Logbesked generering
                                if (medlemsdataOverskrevet)
                                {
                                    opdateretMedlemsbesked.AppendLine("EKSISTERENDE MEDLEM OVERSKREVET FRA REGNSKABSSYSTEMET");
                                    erOpdateret = true;
                                }

                                if (medlem.Status != oprindeligMedlemsstatus)
                                {
                                    opdateretMedlemsbesked.AppendLine("MEDLEMSSTATUS ÆNDRET " + oprindeligMedlemsstatus + "=>" + medlem.Status);
                                    erOpdateret = true;
                                }

                                if (kendtRegnskabsmedlemsdataOverskrevet)
                                {
                                    opdateretMedlemsbesked.AppendLine("KENDT REGNSKABSMEDLEM OVERSKREVET FRA REGNSKABSSYSTEMET");
                                    erOpdateret = true;
                                }


                                if (kendtRegnskabsmedlem.Status != oprindeligKendtRegnskabsmedlemsstatus &&
                                    !kendtRegnskabsmedlemsdataOverskrevet)
                                {
                                    opdateretMedlemsbesked.AppendLine("KENDT REGNSKABSMEDLEM STATUS ÆNDRET " + oprindeligKendtRegnskabsmedlemsstatus + "=>" + kendtRegnskabsmedlem.Status);
                                    erOpdateret = true;
                                }
                                #endregion
                            }
                            else
                            {
                                #region Oprettelse af nyt Medlem og tilhørende KendtRegnskabsmedlem
                                medlem             = new Medlem();
                                medlem.Rostatistik = new Rostatistik();
                                db.Medlems.Add(medlem);

                                kendtRegnskabsmedlem = new Regnskabsmedlem();
                                db.Regnskabsmedlems.Add(kendtRegnskabsmedlem);

                                OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, medlem);
                                OverskrivMedRegnskabsmedlemsdata(regnskabsmedlem, kendtRegnskabsmedlem);

                                if (regnskabsmedlem.Status != MedlemsstatusEnum.Gammel)
                                {
                                    medlem.Status = MedlemsstatusEnum.IkkeAktiveret;
                                }
                                else
                                {
                                    medlem.Status = MedlemsstatusEnum.Gammel;
                                }
                                #endregion

                                erOpdateret = true;
                                opdateretMedlemsbesked.AppendLine("NYT MEDLEM - STATUS = " + medlem.Status);
                            }

                            if (erOpdateret)
                            {
                                logBeskedBygger.AppendLine(opdateretMedlemsbesked.ToString());
                            }
                            db.SaveChanges();
                        }
                        catch (Exception exception)
                        {
                            logBeskedBygger.AppendLine("Fejl under kørsel af medlem ArkID = " + arkID + Environment.NewLine + exception.ToString() + Environment.NewLine);
                        }
                    }

                    try
                    {
                        //¤¤¤ de medlemmer som ikke længere får returneret et tilhørende regnskabsmedlem overgår til status gammel.
                        foreach (Medlem medlem in medlemmer.Where(medlemItem => medlemItem.Status != MedlemsstatusEnum.Gammel))
                        {
                            int arkID = medlem.ArkID;
                            RegnskabsmedlemDTO regnskabsmedlem = regnskabsmedlemmer.FirstOrDefault(regnskabsmedlemItem => regnskabsmedlemItem.ArkID == arkID);
                            if (regnskabsmedlem == null)
                            {
                                MedlemsstatusEnum oprindeligMedlemsstatus = medlem.Status;
                                medlem.Status = MedlemsstatusEnum.Gammel;
                                opdateretMedlemsbesked.AppendLine("Regnskabsmedlem ArkID = " + arkID);
                                opdateretMedlemsbesked.AppendLine("Regnskabsmedlem ikke eksisterende");
                                opdateretMedlemsbesked.AppendLine("MEDLEMSSTATUS ÆNDRET " + oprindeligMedlemsstatus + "=>" + medlem.Status);
                            }
                        }
                        db.SaveChanges();
                    }
                    catch (Exception exception)
                    {
                        logBeskedBygger.AppendLine("Fejl ved ændring af medlemmer status Gammel ved manglende regnskabsmedlem" + Environment.NewLine + exception.ToString() + Environment.NewLine);
                    }
                }
            }

            KomponentManager.LoggingManager.LogBesked(SYNKRONISERING_REGNSKAB_OG_MEDLEMMER_NOEGLEORD, logBeskedBygger.ToString());
        }
예제 #12
0
        private RegnskabsmedlemDTO KonverterRegnskabsmedlemFraXmlNode(XmlNode medlemsnode)
        {
            RegnskabsmedlemDTO regnskabsmedlem = new RegnskabsmedlemDTO();

            #region ID - Conventus is expected to return an int value (non null) for all members - THROWS EXCEPTION
            int?ID = XmlNodeValueToNullableInt(medlemsnode, MEDLEMSFELT_ID);
            if (ID.HasValue)
            {
                regnskabsmedlem.ArkID = ID.Value;
            }
            else
            {
                throw new Exception("Medlemsnode: Intet <" + MEDLEMSFELT_ID + ">" + Environment.NewLine + medlemsnode.InnerText);
            }
            #endregion

            #region Status - TODO - THROWS EXCEPTION
            bool?slettet = XmlNodeValueToNullableBoolean(medlemsnode, MEDLEMSFELT_SLETTET);
            if (!slettet.HasValue)
            {
                throw new Exception(HentBesked(regnskabsmedlem.ArkID, "Felt ikke valid", MEDLEMSFELT_SLETTET, medlemsnode.InnerText));
            }
            else
            {
                //TODO: Refine
                if (slettet.Value)
                {
                    regnskabsmedlem.Status = MedlemsstatusEnum.Gammel;
                }
                else
                {
                    regnskabsmedlem.Status = MedlemsstatusEnum.Aktiv;
                }
            }
            #endregion

            #region Adresse - We will only use one address on the website. A Conventus member is only valid if such is provided. - THROWS EXCEPTION
            string adresse1 = XmlNodeValueToString(medlemsnode, MEDLEMSFELT_ADRESSE1);
            string adresse2 = XmlNodeValueToString(medlemsnode, MEDLEMSFELT_ADRESSE2);
            if (adresse1 != null)
            {
                regnskabsmedlem.Adresse = adresse1;
            }
            else if (adresse2 != null)
            {
                regnskabsmedlem.Adresse = adresse2;
            }
            else
            {
                throw new Exception(HentBesked(regnskabsmedlem.ArkID, "Ingen valid adresse", MEDLEMSFELT_ADRESSE1 + "> eller <" + MEDLEMSFELT_ADRESSE2, medlemsnode.InnerXml));
            }

            regnskabsmedlem.AdressePostNummer = XmlNodeValueToString(medlemsnode, MEDLEMSFELT_POSTNR);
            if (regnskabsmedlem.AdressePostNummer == null)
            {
                throw new Exception(HentBesked(regnskabsmedlem.ArkID, "Intet valid postnummer", MEDLEMSFELT_POSTNR, medlemsnode.InnerXml));
            }

            regnskabsmedlem.AdresseBy = XmlNodeValueToString(medlemsnode, MEDLEMSFELT_POSTNRBY);
            if (regnskabsmedlem.AdresseBy == null)
            {
                throw new Exception(HentBesked(regnskabsmedlem.ArkID, "Ingen valid by", MEDLEMSFELT_POSTNRBY, medlemsnode.InnerXml));
            }
            #endregion

            #region LOGGER ADVARSEL
            regnskabsmedlem.Navn = XmlNodeValueToString(medlemsnode, MEDLEMSFELT_NAVN);
            if (regnskabsmedlem.Navn == null)
            {
                KomponentManager.LoggingManager.LogAdvarsel(MethodInfo.GetCurrentMethod().DeclaringType.Name + "." + MethodInfo.GetCurrentMethod().Name, HentBesked(regnskabsmedlem.ArkID, "Inget valid navn", MEDLEMSFELT_NAVN));
            }

            regnskabsmedlem.EMailAdresse = XmlNodeValueToString(medlemsnode, MEDLEMSFELT_EMAIL);
            if (regnskabsmedlem.EMailAdresse == null)
            {
                KomponentManager.LoggingManager.LogAdvarsel(MethodInfo.GetCurrentMethod().DeclaringType.Name + "." + MethodInfo.GetCurrentMethod().Name, HentBesked(regnskabsmedlem.ArkID, "Ingen valid e-mail adresse", MEDLEMSFELT_EMAIL));
            }
            #endregion

            regnskabsmedlem.Foedselsdato = XmlNodeValueToNullableDateTime(medlemsnode, MEDLEMSFELT_BIRTH);
            regnskabsmedlem.Koen         = XmlNodeValueToKoenEnum(medlemsnode, MEDLEMSFELT_KOEN);
            regnskabsmedlem.MobilNummer  = XmlNodeValueToString(medlemsnode, MEDLEMSFELT_MOBIL);

            //TODO: Ignorerede felter
            //private const string MEDLEMSFELT_ALT_ID = "alt_id";
            //private const string MEDLEMSFELT_OFF_TLF = "off_tlf";
            //private const string MEDLEMSFELT_OFF_EMAIL = "off_email";
            //private const string MEDLEMSFELT_OFF_MOBIL = "off_mobil";
            //private const string MEDLEMSFELT_OFF_NAVN = "off_navn";
            //private const string MEDLEMSFELT_TLF = "tlf";

            return(regnskabsmedlem);
        }