Beispiel #1
0
        public static void EntscheidGesuchHinterlegenInternal(this AuftragStatus auftragStatus, EntscheidGesuch entscheid, DateTime datumEntscheid,
                                                              string interneBemerkung)
        {
            auftragStatus.Context.ThrowIfAuftragstypIsNot(new[]
            {
                OrderType.Einsichtsgesuch
            });

            if (entscheid == EntscheidGesuch.NichtGeprueft)
            {
                throw new Exception("Die Funktion EntscheidGesuchHinterlegen verlangt, dass ein Entscheid getroffen wird.");
            }

            auftragStatus.Context.OrderItem.EntscheidGesuch    = entscheid;
            auftragStatus.Context.OrderItem.DatumDesEntscheids = datumEntscheid;
            auftragStatus.Context.OrderItem.SachbearbeiterId   = auftragStatus.Context.CurrentUser.Id;
            auftragStatus.Context.OrderItem.InternalComment    = auftragStatus.Context.OrderItem.InternalComment.Prepend(interneBemerkung);

            auftragStatus.Context.OrderItem.Abschlussdatum = auftragStatus.Context.TransactionTimeStamp;
            auftragStatus.Context.SetNewStatus(AuftragStatusRepo.Abgeschlossen);

            if (!auftragStatus.Context.OrderItem.VeId.HasValue)
            {
                throw new Exception(
                          "Die Funktion EntscheidGesuchHinterlegen kann nur aufgerufen werden, wenn der Auftrag den Verweis auf eine Verzeichniseinheit enthält.");
            }

            UpdateIndivTokensHelper.RegisterActionForIndivTokensRefresh(auftragStatus);
        }
Beispiel #2
0
        public static void AbbrechenInternal(this AuftragStatus auftragStatus, Abbruchgrund abbruchgrund, string bemerkungZumDossier,
                                             string interneBemerkung)
        {
            if (abbruchgrund == Abbruchgrund.NichtGesetzt)
            {
                throw new Exception("Die Funktion Abbrechen verlangt, dass ein Abbruchgrund gesetzt wird.");
            }

            auftragStatus.Context.OrderItem.Abbruchgrund       = abbruchgrund;
            auftragStatus.Context.OrderItem.InternalComment    = auftragStatus.Context.OrderItem.InternalComment.Prepend(interneBemerkung);
            auftragStatus.Context.OrderItem.Comment            = auftragStatus.Context.OrderItem.Comment.Append(bemerkungZumDossier);
            auftragStatus.Context.OrderItem.Abschlussdatum     = auftragStatus.Context.TransactionTimeStamp;
            auftragStatus.Context.OrderItem.EntscheidGesuch    = EntscheidGesuch.NichtGeprueft;
            auftragStatus.Context.OrderItem.DatumDesEntscheids = null;
            auftragStatus.Context.SetNewStatus(AuftragStatusRepo.Abgebrochen);

            var expando = CreateEmailData(auftragStatus);

            switch (abbruchgrund)
            {
            case Abbruchgrund.DigitalisierungNichtMoeglich:
                auftragStatus.Context.MailPortfolio.AddFinishedMail <DigitalisierungNichtMoeglich>(expando);
                break;

            case Abbruchgrund.DossierMomentanNichtVerfuegbar:
                auftragStatus.Context.MailPortfolio.AddFinishedMail <DossierMomentanNichtVerfuegbar>(expando);
                break;
            }

            UpdateIndivTokensHelper.RegisterActionForIndivTokensRefresh(auftragStatus);
        }
        public static void AbbrechenInternal(this AuftragStatus auftragStatus, Abbruchgrund abbruchgrund, string bemerkungZumDossier,
                                             string interneBemerkung)
        {
            if (abbruchgrund == Abbruchgrund.NichtGesetzt)
            {
                throw new Exception("Die Funktion Abbrechen verlangt, dass ein Abbruchgrund gesetzt wird.");
            }

            auftragStatus.Context.OrderItem.Abbruchgrund       = abbruchgrund;
            auftragStatus.Context.OrderItem.InternalComment    = auftragStatus.Context.OrderItem.InternalComment.Prepend(interneBemerkung);
            auftragStatus.Context.OrderItem.Comment            = auftragStatus.Context.OrderItem.Comment.Append(bemerkungZumDossier);
            auftragStatus.Context.OrderItem.Abschlussdatum     = auftragStatus.Context.TransactionTimeStamp;
            auftragStatus.Context.OrderItem.EntscheidGesuch    = EntscheidGesuch.NichtGeprueft;
            auftragStatus.Context.OrderItem.DatumDesEntscheids = null;
            auftragStatus.Context.SetNewStatus(AuftragStatusRepo.Abgebrochen);

            dynamic expando   = CreateEmailData(auftragStatus);
            dynamic emailData = null;

            switch (abbruchgrund)
            {
            case Abbruchgrund.DigitalisierungNichtMoeglich:
                emailData = auftragStatus.Context.MailPortfolio.GetUnfinishedMailData <DigitalisierungNichtMoeglich>(auftragStatus.Context.Besteller.Id);
                if (emailData == null)
                {
                    auftragStatus.Context.MailPortfolio.BeginUnfinishedMail <DigitalisierungNichtMoeglich>(auftragStatus.Context.Besteller.Id, expando);
                }
                break;

            case Abbruchgrund.DossierMomentanNichtVerfuegbar:
                emailData = auftragStatus.Context.MailPortfolio.GetUnfinishedMailData <DossierMomentanNichtVerfuegbar>(auftragStatus.Context.Besteller.Id);
                if (emailData == null)
                {
                    auftragStatus.Context.MailPortfolio.BeginUnfinishedMail <DossierMomentanNichtVerfuegbar>(auftragStatus.Context.Besteller.Id, expando);
                }
                break;
            }

            if (emailData != null)
            {
                var builder = new DataBuilder(auftragStatus.Context.Bus, emailData);
                builder.AddAuftraege(new List <int> {
                    auftragStatus.Context.OrderItem.Id
                });

                // After a new Auftrag has been set, we get the collection of the orderings and
                // get their dates. Finally we set a property that is called Auftragsdaten.
                List <Auftrag> aufträge     = emailData.Aufträge;
                var            bestellungen = aufträge.Select(a => a.Bestellung);
                var            daten        = bestellungen.Select(o => o.Erfassungsdatum).Distinct();

                builder.AddValue("Auftragsdaten", string.Join(" / ", daten));
            }


            UpdateIndivTokensHelper.RegisterActionForIndivTokensRefresh(auftragStatus);
        }
        public static void ZuruecksetzenInternal(this AuftragStatus auftragStatus)
        {
            auftragStatus.Context.SetNewStatus(AuftragStatusRepo.NeuEingegangen);
            auftragStatus.Context.OrderItem.Ausgabedatum           = null;
            auftragStatus.Context.OrderItem.Abschlussdatum         = null;
            auftragStatus.Context.OrderItem.Abbruchgrund           = Abbruchgrund.NichtGesetzt;
            auftragStatus.Context.OrderItem.EntscheidGesuch        = EntscheidGesuch.NichtGeprueft;
            auftragStatus.Context.OrderItem.DatumDesEntscheids     = null;
            auftragStatus.Context.OrderItem.HasAufbereitungsfehler = false;
            /* Einige Parameter werden im NeuEingegangenStatus gesetzt und hier nicht geleert, weil sie sonst wieder überschrieben werden */

            UpdateIndivTokensHelper.RegisterActionForIndivTokensRefresh(auftragStatus);

            if (auftragStatus.Context.OrderItem.VeId.HasValue)
            {
                UpdateIndivTokensHelper.RegisterActionForIndivTokensRefresh(auftragStatus);
            }
        }
        public override void EntscheidFreigabeHinterlegen(ApproveStatus entscheid, DateTime?datumBewilligung, string interneBemerkung)
        {
            Context.ThrowIfAuftragstypIsNot(new[]
            {
                OrderType.Verwaltungsausleihe,
                OrderType.Lesesaalausleihen,
                OrderType.Digitalisierungsauftrag
            });

            if (entscheid == ApproveStatus.NichtGeprueft)
            {
                throw new BadRequestException("Die Funktion EntscheidFreigabeHinterlegen verlangt, dass ein Entscheid getroffen wird.");
            }

            if (entscheid == ApproveStatus.FreigegebenDurchSystem)
            {
                throw new BadRequestException(
                          $"Die Funktion EntscheidFreigabeHinterlegen kann nicht mit {nameof(ApproveStatus)} = {ApproveStatus.FreigegebenDurchSystem} aufgerufen werden.");
            }

            if (entscheid.VerlangtDatumsangabe() && !datumBewilligung.HasValue)
            {
                throw new BadRequestException(
                          $"Der Entscheid {entscheid.ToString()} verlangt die Angabe eines Datums. Es wurde aber kein Datum angegeben.");
            }

            if (!entscheid.VerlangtDatumsangabe() && datumBewilligung.HasValue)
            {
                throw new BadRequestException(
                          $"Der Entscheid {entscheid.ToString()} erlaubt nicht die Angabe eines Datums. Es wurde aber ein Datum angegeben.");
            }


            Context.SetApproveStatus(entscheid, Context.CurrentUser);
            Context.OrderItem.BewilligungsDatum = datumBewilligung;
            Context.OrderItem.InternalComment   = interneBemerkung; // überschreiben, nicht anhängen

            if (entscheid.IstFreigegeben())
            {
                if (VeLiegtDigitalVor(Context.OrderItem.VeId))
                {
                    this.AbschliessenInternal();
                }
                else
                {
                    switch (Context.Ordering.Type)
                    {
                    case OrderType.Digitalisierungsauftrag:
                        Context.SetNewStatus(AuftragStatusRepo.FuerDigitalisierungBereit);
                        break;

                    case OrderType.Verwaltungsausleihe:
                    case OrderType.Lesesaalausleihen:
                        Context.SetNewStatus(AuftragStatusRepo.FuerAushebungBereit);
                        break;
                    }
                }
            }
            else
            {
                Context.OrderItem.Abbruchgrund = Enum.TryParse(entscheid.ToString(), true, out Abbruchgrund abbruchgrund)
                    ? abbruchgrund
                    : Abbruchgrund.NichtGesetzt;
                Context.OrderItem.Abschlussdatum = Context.TransactionTimeStamp;
                Context.SetNewStatus(AuftragStatusRepo.Abgebrochen);
            }

            // Falls es der letzte Auftrag einer Bestellung war
            if (Context.Ordering.Items.All(item => item.Status != OrderStatesInternal.FreigabePruefen))
            {
                PrepareMailFreigabeKomplett();
                PrepareMailMitteilungBestellungMitTeilbewilligung();
            }

            if (Context.OrderItem.VeId.HasValue)
            {
                UpdateIndivTokensHelper.RegisterActionForIndivTokensRefresh(this);
            }
        }