// GET: Rekeningen/Delete/5
        public async Task <IActionResult> Delete(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var rekening = await _rekeningenService.GetSingleOrDefaultAsync(id.Value);

            if (rekening == null)
            {
                return(NotFound());
            }

            ViewBag.DisableForm = false;
            if (await _rekeningenService.HasTransactiesAsync(rekening))
            {
                ModelState.AddModelError(string.Empty, "De rekening heeft nog transacties en kan daardoor niet verwijderd worden.");
                ViewBag.DisableForm = true;
            }
            var instellingen = await _instellingenService.GetSingleAsync();

            if (rekening == instellingen.PortemonneeRekening)
            {
                ModelState.AddModelError(string.Empty, "De rekening is ingesteld als de portemonnee rekening en kan daardoor niet verwijderd worden.");
                ViewBag.DisableForm = true;
            }
            await SetSaldoAsync(rekening, null);

            return(View(rekening));
        }
Beispiel #2
0
        // GET: Transacties
        public async Task <IActionResult> Index(int?afterId, bool?hasCategorie, DateTime?startDatum, DateTime?eindDatum, DateTime?nearDatum, decimal?vanafBedrag)
        {
            var instellingen = await _instellingenService.GetSingleAsync();

            ViewBag.TransactiesAnchorAction = instellingen.TransactieMeteenBewerken ? "Edit" : "Details";
            ViewBag.NearDatum = nearDatum;
            return(View(await _transactiesService.GetListWithFilterAsync(afterId, hasCategorie, startDatum, eindDatum, nearDatum, vanafBedrag)));
        }
        private async Task SetTransactiesAnchorAction()
        {
            var instellingen = await _instellingenService.GetSingleAsync();

            ViewBag.TransactiesAnchorAction = instellingen.TransactieMeteenBewerken ? "Edit" : "Details";
        }
 // GET: Instellingen
 public async Task <IActionResult> Index()
 {
     return(View(await _instellingenService.GetSingleAsync()));
 }
        private async Task <List <string> > ImportTransactiesRabobankCsv2013Async(List <List <string> > importRows)
        {
            var messages = new List <string>();

            //Massa import, laad alle rekeningen en instellingen van te voren in.
            var rekeningenTask   = _rekeningenService.GetListAsync();
            var instellingenTask = _instellingenService.GetSingleAsync();
            await Task.WhenAll(rekeningenTask, instellingenTask);

            var rekeningen   = rekeningenTask.Result;
            var instellingen = instellingenTask.Result;

            var importedTransacties = new List <Transactie>();

            for (var rowIndex = 0; rowIndex < importRows.Count; rowIndex++)
            {
                var importRow = importRows[rowIndex];

                var errorMessages = new List <string>();
                var infoMessages  = new List <string>();

                var eigenRekeningnummer = importRow[0].Trim();

                var datumImportValue = importRow[2].Trim();
                if (!DateTime.TryParseExact(datumImportValue, "yyyyMMdd", CultureInfo.CurrentCulture, DateTimeStyles.None, out DateTime datum))
                {
                    errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, '{datumImportValue}' is geen geldige datum.");
                }

                var isBijschrijving            = false;
                var isBijschrijvingImportValue = importRow[3].Trim();
                if (isBijschrijvingImportValue.Equals("C", StringComparison.InvariantCultureIgnoreCase))
                {
                    isBijschrijving = true;
                }
                else if (!isBijschrijvingImportValue.Equals("D", StringComparison.InvariantCultureIgnoreCase))
                {
                    errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, '{isBijschrijvingImportValue}' is geen geldige waarde voor is bijschrijving.");
                }

                //Bedragen met een punt, gebruik InvariantCulture
                var bedragImportValue = importRow[4].Trim();
                if (!decimal.TryParse(bedragImportValue, NumberStyles.Number, CultureInfo.InvariantCulture, out decimal bedrag))
                {
                    errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, '{bedragImportValue}' is geen geldig bedrag.");
                }

                var tegenRekeningnummer = importRow[5].Trim();
                var tegenRekeningNaam   = importRow[6].Trim();
                var boekcode            = importRow[8].Trim();

                var skipOmschrijving1 = false;
                if (boekcode == "ba" || boekcode == "bc")
                {
                    //Betaalautomaat, Betalen contactloos
                    //In deze gevallen is er geen tegenrekening, en staat de naam in Omschrijving1
                    if (tegenRekeningnummer != string.Empty || tegenRekeningNaam != string.Empty)
                    {
                        infoMessages.Add($"Transactie op regel {rowIndex + 1} heeft boekcode '{boekcode}' en zou daarom geen tegen rekeningnummer '{tegenRekeningnummer}' of tegen rekening naam '{tegenRekeningNaam}' moeten hebben. Deze zijn overschreven met omschrijving1.");
                        tegenRekeningnummer = string.Empty;
                    }

                    tegenRekeningNaam = importRow[10].Trim();
                    skipOmschrijving1 = true;
                }

                var omschrijvingSb = new StringBuilder();
                if (!skipOmschrijving1)
                {
                    omschrijvingSb.AppendLine(importRow[10].Trim());
                }
                omschrijvingSb.AppendLine(importRow[11].Trim());
                omschrijvingSb.AppendLine(importRow[12].Trim());
                omschrijvingSb.AppendLine(importRow[13].Trim());
                omschrijvingSb.AppendLine(importRow[14].Trim());
                omschrijvingSb.AppendLine(importRow[15].Trim());
                var omschrijving = omschrijvingSb.ToString().Trim();

                var eigenRekening = FindRekeningByRekeningnummer(rekeningen, eigenRekeningnummer);
                if (eigenRekening == null)
                {
                    errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, eigen rekening '{eigenRekeningnummer}' is niet gevonden.");
                }

                Rekening tegenRekening = null;
                if (boekcode == "kh" || boekcode == "ga" || boekcode == "gb")
                {
                    //Kasafhandeling, Geldautomaat Euro, Geldautomaat VV
                    tegenRekening = instellingen.PortemonneeRekening;
                    if (tegenRekening == null)
                    {
                        errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, er is geen portemonnee ingesteld.");
                    }
                }
                else
                {
                    (var rekening, var rekeningErrorMessages) = FindOrImportRekening(rekeningen, tegenRekeningnummer, tegenRekeningNaam);
                    tegenRekening = rekening;
                    foreach (var rekeningErrorMessage in rekeningErrorMessages)
                    {
                        errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, {rekeningErrorMessage}");
                    }
                }

                Transactie transactie = null;
                if (!errorMessages.Any())
                {
                    //De waarden zijn succesvol geparsed. Maak de transactie
                    transactie = new Transactie
                    {
                        Datum        = datum,
                        Bedrag       = bedrag,
                        VanRekening  = isBijschrijving ? tegenRekening : eigenRekening,
                        NaarRekening = isBijschrijving ? eigenRekening : tegenRekening,
                        Omschrijving = string.IsNullOrWhiteSpace(omschrijving) ? null : omschrijving
                    };

                    //Validatie werkt op Id, zet voor nu expliciet (voor o.a. de Unlike validator)
                    transactie.VanRekeningId  = transactie.VanRekening.RekeningId;
                    transactie.NaarRekeningId = transactie.NaarRekening.RekeningId;

                    await _transactiesService.DetermineCategorieAsync(transactie);

                    var validationResults = new List <ValidationResult>();
                    Validator.TryValidateObject(transactie, new ValidationContext(transactie, null, null), validationResults, true);
                    foreach (var validationResult in validationResults)
                    {
                        errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, {validationResult.ErrorMessage}");
                    }

                    if (importedTransacties.Any(t =>
                                                t.Datum == transactie.Datum &&
                                                t.Bedrag == transactie.Bedrag &&
                                                t.VanRekening == transactie.VanRekening &&
                                                t.NaarRekening == transactie.NaarRekening &&
                                                t.Omschrijving == transactie.Omschrijving))
                    {
                        errorMessages.Add($"Transactie op regel {rowIndex + 1} is overgeslagen, er is in dit bestand al een andere transactie op {transactie.Datum:ddd d/M/yyyy} met {transactie.Bedrag:C} van '{transactie.VanRekening.Naam}' naar '{transactie.NaarRekening.Naam}' met omschrijving '{transactie.Omschrijving}'.");
                    }
                }

                if (errorMessages.Any())
                {
                    messages.AddRange(errorMessages);
                }
                else
                {
                    messages.AddRange(infoMessages);
                    _transactiesService.Add(transactie);
                    importedTransacties.Add(transactie);
                }
            }

            await _transactiesService.SaveChangesAsync();

            return(messages);
        }