コード例 #1
0
ファイル: MissingRoles.aspx.cs プロジェクト: sebbalex/PITre
        private void InitializePage()
        {
            this.CallType = RubricaCallType.CALLTYPE_CORR_INT_NO_UO;
            int index = 0;

            foreach (string mr in this.MissingRolesList)
            {
                string reason = mr.Split('(')[1].Trim();
                reason = reason.Substring(0, reason.Length - 1);
                bool selectReason = false;

                if (reason.ToUpper() == "AUTHORIZER" || reason.ToUpper() == "PROPOSER")
                {
                    selectReason = false;
                }
                else
                {
                    RagioneTrasmissione checkReason = this.ListaRagioni.Where(x => x.descrizione == reason).FirstOrDefault();
                    if (checkReason == null)
                    {
                        selectReason = true;
                    }
                }

                this.InsertRole(mr, index, selectReason);
                index++;
            }
            //this.UpdMissingRolesGrid.Update();
        }
コード例 #2
0
        public TrasmissioneBuilder(InfoUtente infoUtente, Ruolo ruoloMittente, TrasmissioneVO trasmInfo)
        {
            this._trasmInfo     = trasmInfo;
            this._mittente      = UserManager.getUtente(infoUtente.idPeople);
            this._ruoloMittente = ruoloMittente;
            this._mittenteIU    = infoUtente;
            this._ragione       = RagioniManager.getRagioneByCodice(_mittente.idAmministrazione, _trasmInfo.Ragione);
            logger.Debug("Ricerca corrispondente con codice " + trasmInfo.CodiceCorrispondente);
            Corrispondente destinatario = UserManager.getCorrispondenteByCodRubrica(trasmInfo.CodiceCorrispondente, TipoUtente.INTERNO, infoUtente);

            if (destinatario == null)
            {
                logger.Debug("Corrispondente non trovato");
                throw new Exception();
            }
            _tsStrategy = TrasmissioneSingolaStrategy.GetStrategy(destinatario, this);
        }
コード例 #3
0
        public void addTrasmSingole(Corrispondente corr, RagioneTrasmissione ragione, string note, string tipoTrasm, int scadenza)
        {
            if (_trasmissioniSingole.ContainsKey(corr.systemId))
            {
                if (_trasmissioniSingole[corr.systemId].daEliminare)
                {
                    _trasmissioniSingole[corr.systemId].daEliminare = false;
                }
                return;
            }
            TrasmissioneSingola _trasmissioneSingola = new TrasmissioneSingola();

            buildBasicInfo(_trasmissioneSingola, corr, ragione, note, tipoTrasm, scadenza);
            if (corr is Ruolo)
            {
                _trasmissioneSingola.tipoDest = TipoDestinatario.RUOLO;
                ArrayList listaUtenti = queryUtenti(corr);
                if (listaUtenti.Count == 0)
                {
                    return;
                }
                foreach (Utente temp in listaUtenti)
                {
                    addTrasmissioneUtente(temp, _trasmissioneSingola);
                }
                _trasmissioniSingole.Add(corr.systemId, _trasmissioneSingola);
            }
            if (corr is Utente)
            {
                _trasmissioneSingola.tipoDest = TipoDestinatario.UTENTE;
                addTrasmissioneUtente((Utente)corr, _trasmissioneSingola);
                _trasmissioniSingole.Add(corr.systemId, _trasmissioneSingola);
            }
            if (corr is UnitaOrganizzativa)
            {
                UnitaOrganizzativa             theUo = (UnitaOrganizzativa)corr;
                QueryCorrispondenteAutorizzato qca   = new QueryCorrispondenteAutorizzato();
                qca.ragione = _trasmissioneSingola.ragione;
                qca.ruolo   = _ruolo;
                ArrayList ruoli = BusinessLogic.Utenti.addressBookManager.getRuoliRiferimentoAutorizzati(qca, theUo);
                foreach (Ruolo r in ruoli)
                {
                    addTrasmSingole(r, ragione, note, tipoTrasm, scadenza);
                }
            }
        }
コード例 #4
0
        private void init()
        {
            _trasm = new Trasmissione();
            _trasm.noteGenerali = _modello.VAR_NOTE_GENERALI;
            if (_isDoc)
            {
                _trasm.infoDocumento = BusinessLogic.Documenti.DocManager.GetInfoDocumento(_infoUtente, _id, null);
                _trasm.tipoOggetto   = TipoOggetto.DOCUMENTO;
            }
            else
            {
                Fascicolo fasc = BusinessLogic.Fascicoli.FascicoloManager.getFascicoloById(_id, _infoUtente);
                _trasm.infoFascicolo = this.getInfoFascicoloDaFascicolo(fasc);
                _trasm.tipoOggetto   = TipoOggetto.FASCICOLO;
            }
            _trasm.utente = BusinessLogic.Utenti.UserManager.getUtente(_infoUtente.idPeople);
            //aggiunta delegato
            if (_infoUtente.delegato != null)
            {
                _trasm.delegato = _infoUtente.delegato.idPeople;
            }

            _trasm.ruolo     = _ruolo;
            _trasm.NO_NOTIFY = _modello.NO_NOTIFY;
            TrasmSingoleBuilder trasmSingoleBuilder = new TrasmSingoleBuilder(_infoUtente, _ruolo, _modello);

            for (int i = 0; i < _modello.RAGIONI_DESTINATARI.Count; i++)
            {
                RagioneDest ragDest     = (RagioneDest)_modello.RAGIONI_DESTINATARI[i];
                ArrayList   destinatari = new ArrayList(ragDest.DESTINATARI);
                for (int j = 0; j < destinatari.Count; j++)
                {
                    MittDest       mittDest = (MittDest)destinatari[j];
                    Corrispondente corr     = getCorrispondente(mittDest);
                    if (corr != null)
                    {
                        RagioneTrasmissione ragione = BusinessLogic.Trasmissioni.QueryTrasmManager.getRagioneById("" + mittDest.ID_RAGIONE);
                        trasmSingoleBuilder.addTrasmSingole(corr, ragione, mittDest.VAR_NOTE_SING, mittDest.CHA_TIPO_TRASM, mittDest.SCADENZA);
                    }
                }
            }
            _trasm.trasmissioniSingole = trasmSingoleBuilder.TrasmissioniSingole;
        }
コード例 #5
0
 private static void buildBasicInfo(TrasmissioneSingola trasmissioneSingola, Corrispondente corr, RagioneTrasmissione ragione, string note, string tipoTrasm, int scadenza)
 {
     trasmissioneSingola.tipoTrasm             = tipoTrasm;
     trasmissioneSingola.corrispondenteInterno = corr;
     trasmissioneSingola.ragione     = ragione;
     trasmissioneSingola.noteSingole = note;
     if (scadenza > 0)
     {
         string          dataScadenza = "";
         System.DateTime data         = System.DateTime.Now.AddDays(scadenza);
         dataScadenza = data.Day + "/" + data.Month + "/" + data.Year;
         trasmissioneSingola.dataScadenza = dataScadenza;
     }
     trasmissioneSingola.trasmissioneUtente = new ArrayList();
 }
コード例 #6
0
        /// <summary>
        /// Metodo per la trasmissione del documento ai destinatari interni (utenti che si trovano in ruoli cui sono associate
        /// le microfunzioni relative all'IS)
        /// </summary>
        /// <param name="settings">Impostazioni relative all'interoperabilità semplificata per il registro su cui è stato creato il documento</param>
        /// <param name="document">Documento da trasmettere</param>
        /// <param name="userRole">Ruolo utilizzato per la trasmissione</param>
        /// <param name="user">Utente mittente della trasmissione</param>
        /// <param name="privateDocument">Flag utilizzato per indicare se il documento è stato ricevuto marcato come privato dal mittente della spedizione</param>
        /// <param name="receiversInfo">Informaizoni sui destinari da contattare</param>
        /// <returns>Lista dei destinatari per cui si è verificato un problema</returns>
        private static List <ReceiverInfo> TransmitDocument(InteroperabilitySettings settings, SchedaDocumento document, Ruolo userRole, Utente user, bool privateDocument, List <ReceiverInfo> receiversInfo)
        {
            logger.Debug("RAFFREDDORE - Start");
            logger.Debug("RAFFREDDORE - " + (document == null ? "Documento nullo" : document.systemId));
            // Recupero delle informazioni sui corrispondenti interni all'amministrazione che devono ricevere
            // la trasmissione del documento
            List <Corrispondente> corrs = null;

            // Lista dei destinatari della spedizione per cui non sono stati individuati destinatari
            List <ReceiverInfo> uneachableReceivers = new List <ReceiverInfo>();

            try
            {
                logger.Debug("RAFFREDDORE - prima del caricamento destinatari");
                corrs = InteroperabilitaSemplificataManager.LoadTransmissionReceivers(settings, privateDocument, receiversInfo, out uneachableReceivers);

                if (corrs == null || corrs.Count == 0)
                {
                    logger.Error("Nessun destinatario trovato per la trasmissione del documento");
                    throw new RetrivingTransmissionReceiverException("Nessun destinatario trovato per la trasmissione del documento");
                }
            }
            catch (Exception e)
            {
                SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(document.systemId, true, e.Message);
                throw new RetrivingTransmissionReceiverException(e.Message);
            }

            // Creazione dell'oggetto trasmissione
            Trasmissione transmission = new Trasmissione();

            transmission.ruolo         = userRole;
            transmission.utente        = user;
            transmission.noteGenerali  = receiversInfo.Select(r => r.Code).Aggregate((r1, r2) => String.Format("{0} {1}", r1, r2));
            transmission.infoDocumento = new InfoDocumento(document);

            // Creazione della ragione di trasmissione per interoperabilità semplificata
            RagioneTrasmissione reason = InteroperabilitaSegnatura.getRagioneTrasm(user.idAmministrazione, "S");

            if (reason != null && privateDocument)
            {
                reason.eredita = "0";
            }

            if (reason != null)
            {
                logger.DebugFormat("IS - Effettuato caricamento della ragione di trasmissione per interoperabilità. Id ragione: {0}; Eredita: {1}", reason.systemId, reason.eredita);
            }

            // Creazione delle trasmissioni singole
            transmission.trasmissioniSingole = new System.Collections.ArrayList();
            foreach (var corr in corrs)
            {
                // Creazione della trasmissione singola
                TrasmissioneSingola singleTransmission = new TrasmissioneSingola()
                {
                    ragione = reason,
                    corrispondenteInterno = corr,
                    tipoTrasm             = "S",
                    tipoDest = TipoDestinatario.RUOLO
                };

                // Caricamento degli utenti del ruolo
                singleTransmission.trasmissioneUtente = new System.Collections.ArrayList();

                // Caricamento utenti del ruolo
                QueryCorrispondente qc = new QueryCorrispondente();
                qc.codiceRubrica = ((DocsPaVO.utente.Ruolo)corr).codiceRubrica;
                qc.idRegistri    = new System.Collections.ArrayList();
                qc.idRegistri.Add(settings.RegistryId);
                qc.idAmministrazione = user.idAmministrazione;
                qc.getChildren       = true;
                qc.fineValidita      = true;
                ArrayList users = addressBookManager.listaCorrispondentiIntMethod(qc);

                // Costruzione delle trasmissioni utente
                foreach (Utente u in users)
                {
                    u.dst = user.dst;
                    singleTransmission.trasmissioneUtente.Add(new TrasmissioneUtente()
                    {
                        utente = u
                    });
                }

                transmission.trasmissioniSingole.Add(singleTransmission);
            }

            // Esecuzione della trasmissione
            try
            {
                // INCIDENT 104707
                // modifica PALUMBO per consentire invio mail di notifica in caso di trasmissione ricevuta per IS
                // necessaria chiave "URL_PATH_IS" webconfig ws .
                string path = String.Empty;
                if (System.Configuration.ConfigurationManager.AppSettings["URL_PATH_IS"] != null)
                {
                    path = System.Configuration.ConfigurationManager.AppSettings["URL_PATH_IS"].ToString();
                }

                logger.Debug("RAFFREDDORE - url path is " + path);
                //ExecTrasmManager.saveExecuteTrasmMethod(String.Empty, transmission);
                Trasmissione resultTrasm = ExecTrasmManager.saveExecuteTrasmMethod(path, transmission);
                logger.Debug("RAFFREDDORE - Trasmissione nulla? " + (resultTrasm == null?"Nulla":"NON nulla"));
                //traccio l'evento di trasmssione
                string method = string.Empty, desc = string.Empty;
                if (resultTrasm != null &&
                    resultTrasm.infoDocumento != null &&
                    !string.IsNullOrEmpty(resultTrasm.infoDocumento.docNumber))
                {
                    List <string> includedList = new List <string>();
                    string        idCorr       = string.Empty;

                    foreach (DocsPaVO.trasmissione.TrasmissioneSingola single in resultTrasm.trasmissioniSingole)
                    {
                        logger.Warn("DEBUG: WriteLog-IS- " + resultTrasm.utente.userId + " " +
                                    resultTrasm.infoDocumento.docNumber + " " + resultTrasm.utente.idPeople + " " + resultTrasm.ruolo.idGruppo + " " + resultTrasm.utente.idAmministrazione + " " +
                                    resultTrasm.utente.idPeople + " " + method + " " + desc + " " + single.systemId);
                        method = "TRASM_DOC_" + single.ragione.descrizione.ToUpper().Replace(" ", "_");
                        desc   = "Trasmesso Documento predisposto in arrivo : " + resultTrasm.infoDocumento.docNumber.ToString();
                        idCorr = single.corrispondenteInterno.systemId;
                        if (!includedList.Contains(idCorr))
                        {
                            BusinessLogic.UserLog.UserLog.WriteLog(resultTrasm.utente.userId, resultTrasm.utente.idPeople,
                                                                   resultTrasm.ruolo.idGruppo, resultTrasm.utente.idAmministrazione, method,
                                                                   resultTrasm.infoDocumento.docNumber, desc, DocsPaVO.Logger.CodAzione.Esito.OK, null, "1", single.systemId);
                            includedList.Add(idCorr);
                        }
                        else
                        {
                            BusinessLogic.UserLog.UserLog.WriteLog(resultTrasm.utente.userId, resultTrasm.utente.idPeople,
                                                                   resultTrasm.ruolo.idGruppo, resultTrasm.utente.idAmministrazione, method,
                                                                   resultTrasm.infoDocumento.docNumber, desc, DocsPaVO.Logger.CodAzione.Esito.OK, null, "0", single.systemId);
                        }
                        logger.Warn("DEBUG: WriteLog-IS- OK");
                    }
                }
            }
            catch (Exception e)
            {
                logger.Error("RAFFREDDORE - Errore durante la trasmissione del documento ai destinatari");
                SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(document.systemId, true, "Errore nella trasmissione del documento ai ruoli designati");
                throw new ExecuteTransmissionException("Errore durante la trasmissione del documento ai destinatari");
            }

            // Se si è arrivati fin qui la trasmissione è stata effettuata correttamente, quindi viene aggiunta
            // una voce al log
            SimplifiedInteroperabilityLogAndRegistryManager.InsertItemInLog(document.systemId, false,
                                                                            String.Format("Documento con id {0} trasmesso correttamente ai destinatari", document.systemId));

            // Restituzione dei corrispondenti non troviati
            return(uneachableReceivers);
        }