示例#1
0
        private void SaveAsXml(recordInformationPackage result)
        {
            var savefile = new SaveFileDialog();

            savefile.FileName = "export.xml";
            if (savefile.ShowDialog() == DialogResult.OK)
            {
                var encoding = Encoding.UTF8;//.GetEncoding("ISO-8859-1");
                using (var writer = new StreamWriter(savefile.FileName, false, encoding))
                {
                    var serializer = new XmlSerializer(typeof(recordInformationPackage));
                    serializer.Serialize(writer, result);
                    writer.Flush();
                }
            }
        }
示例#2
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="listOfDossiers"></param>
        /// <param name="maxBatchSize_bytes"></param>
        /// <returns> List recordInformationPackage: Is het complete TopX objectmodel, serializable naar xml</returns>
        public List <RIP.recordInformationPackage> ParseDataToTopx(List <Dossier> listOfDossiers, long maxBatchSize_bytes = 0)
        {
            var resultRecordInformationPackages = new List <RIP.recordInformationPackage>();

            if (!TestHealthyGlobals())
            {
                return(null);
            }

            _identificatieArchief = _globals.IdentificatieArchief;
            var datumArchief        = _globals.DatumArchief;
            var omschrijvingArchief = _globals.OmschrijvingArchief;
            var bronArchief         = _globals.BronArchief;
            var doelArchief         = _globals.DoelArchief;
            var naamArchief         = _globals.NaamArchief;

            long totalSize = 0;
            var  rip       = new recordInformationPackage
            {
                record = RipArchief(_identificatieArchief, naamArchief)
            };

            foreach (var dossier in listOfDossiers)
            {
                try
                {
                    if (!dossier.Records.Any())
                    {
                        ErrorMessage.AppendLine($"Dossier {dossier.IdentificatieKenmerk}: Geen records gevonden");
                    }

                    if (string.IsNullOrEmpty(dossier.Naam))
                    {
                        ErrorMessage.AppendLine($"Dossier {dossier.IdentificatieKenmerk}: Veld Naam is leeg");
                    }

                    if (!ValidateDossier(dossier))
                    {
                        continue;
                    }

                    rip.record.Add(RipBeschikkingAsDossier(dossier));

                    foreach (var record in dossier.Records)
                    {
                        rip.record.Add(RipOobjectAsRecord(dossier, record, $"{dossier.IdentificatieKenmerk}_{Path.GetFileNameWithoutExtension(record.Bestand_Formaat_Bestandsnaam)}"));
                        rip.record.Add(RipObjectAsBestand(record));
                    }
                }
                catch (Exception ex)
                {
                    _dataservice.Log(dossier.IdentificatieKenmerk, $"ERROR: {ex.Message}");
                    ErrorMessage.AppendLine($"Dossier {dossier.IdentificatieKenmerk}: ERROR: { ex.Message}");
                }

                var sizeOfDossier = dossier.Records.Sum(record => record.Bestand_Formaat_BestandsOmvang ?? 0);
                totalSize += sizeOfDossier;

                if (maxBatchSize_bytes > 0 && totalSize * 1.2 > maxBatchSize_bytes)  // Maxsize batch is bereikt, hou marge van 20%
                {
                    // Clone rip

                    resultRecordInformationPackages.Add(new recordInformationPackage
                    {
                        packageHeader = RipHeader(_identificatieArchief, (DateTime)datumArchief, omschrijvingArchief, bronArchief, doelArchief),
                        record        = rip.record
                    });

                    totalSize = 0;

                    // Clear rip voor de volgende batch
                    rip = new RIP.recordInformationPackage()
                    {
                        record = RipArchief(_identificatieArchief, naamArchief)
                    };
                }
            }

            resultRecordInformationPackages.Add(new recordInformationPackage
            {
                packageHeader = RipHeader(_identificatieArchief, (DateTime)datumArchief, omschrijvingArchief, bronArchief, doelArchief),
                record        = rip.record
            });
            return(resultRecordInformationPackages);
        }
示例#3
0
        public recordInformationPackage ParseCSV(int nrOfRecords = 0)
        {
            using (var entities = new TOPXEntities())
            {
                var identificatieArchief = "NL-0834-10002";
                var datumArchief         = Convert.ToDateTime(DateTime.Today);
                var omschrijvingArchief  = "Bouwvergunningen Gemeente Raamsdonk 1993 - 1996";
                var bronArchief          = "Digitale bouwvergunningen";
                var doelArchief          = "Bouwvergunningen om op te nemen in e-Depot";
                var naamArchief          = omschrijvingArchief;

                //var identificatieArchief = "NL-0779-10001";
                //var datumArchief = Convert.ToDateTime(DateTime.Today);
                //var omschrijvingArchief = "Bouwvergunningen Gemeente Geertruidenberg 1928 - 1975";
                //var bronArchief = "Digitale bouwvergunningen";
                //var doelArchief = "Bouwvergunningen om op te nemen in e-Depot";
                //var naamArchief = "Bouwvergunningen Gemeente Geertruidenberg 1928 - 1975";
                Rip = new recordInformationPackage()
                {
                    packageHeader =
                        RipHeader(identificatieArchief, datumArchief, omschrijvingArchief, bronArchief, doelArchief),
                    record = RipArchief(identificatieArchief, naamArchief)
                };

                var listOfDossiers = GetListOfDossiers(entities);
                var recordCounter  = 0;
                foreach (var dossier in listOfDossiers)
                {
                    try
                    {
                        var entries = (from d in entities.Source where d.C2_dn_Bestand.StartsWith(dossier) select d).ToList();
                        var dossiersZonderBeschikking =
                            (from d in entities.DossiersZonderBeschikking select d.DossierZonderBeschikking).ToList();

                        //var dossierEntry = (from d in entries
                        //                    where d.C19_1_DN_Tabnaam == "Beschikking"
                        //  || d.C2_dn_Bestand.Contains("GDB-0391")
                        //  || d.C2_dn_Bestand.Contains("GDB-1064")
                        //  || d.C2_dn_Bestand.Contains("GDB-0005-02")
                        //                    select d);
                        var dossierEntry = (from d in entries
                                            where
                                            d.C19_1_DN_Tabnaam == "Beschikking" || dossiersZonderBeschikking.Contains(d.C2_dn_Bestand.Substring(0, d.C2_dn_Bestand.Length - 3))
                                            select d).ToList();


                        if (!dossierEntry.Any())
                        {
                            Logger.Log(dossier, "ERROR - Geen beschikking gevonden");
                            continue;
                        }

                        var isExceptionGeenBeschikking = dossiersZonderBeschikking.Contains(dossierEntry[0].C2_dn_Bestand.Substring(0, dossierEntry[0].C2_dn_Bestand.Length - 3));

                        if (dossierEntry.Count() > 1 && !isExceptionGeenBeschikking)
                        {
                            Logger.Log(dossier, "Meer dan 2 beschikkingen in 1 dossier");
                            throw new Exception("Meer dan 2 beschikkingen in 1 dossier");
                        }
                        var source = dossierEntry.FirstOrDefault();

                        if (string.IsNullOrEmpty(source.Datum_vergunning) || string.IsNullOrEmpty(source.C91_zn_Datum_vergunning))
                        {
                            Logger.Log(source.C2_dn_Bestand, "ERROR - Datum vergunning leeg");
                            continue;
                        }
                        if (string.IsNullOrEmpty(source.OmschrijvingCompleet))
                        {
                            Logger.Log(source.C2_dn_Bestand, "OmschrijvingCompleet is leeg (Excel kolom: \"Omschrijving bouwvergunning, adres, huisnummer, plaatsnaam\" ");
                            continue;
                        }

                        if (source.Datum_vergunning.StartsWith("12"))
                        {
                            Logger.Log(source.C2_dn_Bestand, "Datum vergunning label onjuist, kan niet met een getal beginnen, waarschijnlijk meerdere kolommen onjuist");
                            continue;
                        }

                        var testForDoubles = from t in entities.Source
                                             where
                                             t.C2zn__Zaaknummer == source.C2zn__Zaaknummer &&
                                             t.C2_dn_Bestand.Substring(0, t.C2_dn_Bestand.Length - 3) != source.C2_dn_Bestand.Substring(0, source.C2_dn_Bestand.Length - 3)
                                             select t;

                        if (testForDoubles.Any())
                        {
                            Logger.Log(source.C2_dn_Bestand, $"Zaaknummer {source.C2zn__Zaaknummer} komt meer dan 1 keer voor bij verschillende dossiers.");
                            continue;
                        }

                        Rip.record.Add(RipBeschikkingAsDossier(source, dossier, identificatieArchief));
                        ZaaknummerMarkForDelivered.Add(dossier);

                        var bestandEntries = (from d in entries select d);
                        var count          = 0;
                        foreach (var bestandEntry in bestandEntries)
                        {
                            //double test2;
                            //if (!double.TryParse(bestandEntry.FileSize_Bytes.ToString(), out test2))
                            //{
                            //    throw new Exception("File size is not in correct format");

                            //}
                            var zaaknummer    = Extensions.GetZaakNummerWithYear(bestandEntry.C2zn__Zaaknummer);
                            var idRecordAsDoc = zaaknummer + "_" + bestandEntry.C2_dn_Bestand;


                            Rip.record.Add(RipOobjectAsDoc(bestandEntry, idRecordAsDoc, zaaknummer, entities));


                            var fileSize = (from f in entities.FileSizes where f.Bestandsnaam == bestandEntry.C2_dn_Bestand + ".pdf" select f).FirstOrDefault();
                            if (fileSize == null)
                            {
                                fileSize = new FileSizes()
                                {
                                    Bestandsnaam = "NIET GEVONDEN"
                                };
                                Logger.Log(bestandEntry.C2_dn_Bestand, $"Bestandsnaam niet gevonden in filesize tabel van file");
                            }

                            var fileChecksum = (from f in entities.checksum where f.Filename == fileSize.Bestandsnaam select f).FirstOrDefault();

                            if (fileChecksum == null)
                            {
                                Logger.Log(bestandEntry.C2_dn_Bestand, "Checksum niet gevonden van file");
                                fileChecksum = new checksum()
                                {
                                    Checksum1 = "NIET GEVONDEN"
                                };
                            }
                            Rip.record.Add(RipObjectAsBestand(bestandEntry, bestandEntry.C2_dn_Bestand, idRecordAsDoc, fileChecksum, fileSize, "fmt/18", "sha256"));
                            count += 1;
                        }
                    }
                    catch (Exception ex)
                    {
                        Logger.Log(dossier, $"ERROR: {ex.Message}");
                    }

                    recordCounter++;
                    if (nrOfRecords > 0)
                    {
                        if (recordCounter >= nrOfRecords)
                        {
                            return(Rip);
                        }
                    }
                }

                return(Rip); //.Serialize();
            }
        }