Пример #1
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public static DocsPaVO.trasmissione.RagioneTrasmissione getRagioneTrasm(string idAmm, String tipoRagione)
        {
            logger.Debug("getRagioneTrasm");
            //DocsPa_V15_Utils.Database db=DocsPa_V15_Utils.dbControl.getDatabase();
            //DataSet ds=new DataSet();
            DataSet ds;

            DocsPaVO.trasmissione.RagioneTrasmissione rt = new DocsPaVO.trasmissione.RagioneTrasmissione();
            try
            {
                DocsPaDB.Query_DocsPAWS.Task obj = new DocsPaDB.Query_DocsPAWS.Task();
                obj.getRagTrasm(out ds, idAmm, tipoRagione);

                DataRow ragione = ds.Tables["RAGIONE"].Rows[0];
                rt.descrizione      = ragione["VAR_DESC_RAGIONE"].ToString();
                rt.risposta         = ragione["CHA_RISPOSTA"].ToString();
                rt.systemId         = ragione["SYSTEM_ID"].ToString();
                rt.tipo             = "N";
                rt.tipoDestinatario = (DocsPaVO.trasmissione.TipoGerarchia)DocsPaDB.Utils.HashTableManager.GetKeyFromValue(DocsPaVO.trasmissione.RagioneTrasmissione.tipoGerarchiaStringa, ragione["CHA_TIPO_DEST"].ToString());
                rt.tipoDiritti      = DocsPaVO.trasmissione.TipoDiritto.WRITE;
                rt.eredita          = ragione["CHA_EREDITA"].ToString();
            }
            catch (Exception e)
            {
                logger.Debug(e.ToString());
                //db.closeConnection();
                logger.Error("Errore nella gestione della visibilità del contributo. (getRagioneTrasm)", e);
                throw e;
            }
            return(rt);
        }
Пример #2
0
        private static DocsPaVO.trasmissione.Trasmissione ExecuteTransmission(DocsPaVO.documento.SchedaDocumento schedaDoc, string idGruppoDest, string idPeopleDest, DocsPaVO.utente.InfoUtente infoUtente)
        {
            DocsPaVO.trasmissione.Trasmissione trasm = new DocsPaVO.trasmissione.Trasmissione();

            DocsPaDB.Query_DocsPAWS.Utenti u = new DocsPaDB.Query_DocsPAWS.Utenti();

            trasm.ruolo  = u.GetRuoloByIdGruppo(infoUtente.idGruppo); //istanzaProcesso.RuoloProponente;
            trasm.utente = u.getUtenteById(infoUtente.idPeople);      //istanzaProcesso.UtenteProponente;
            DocsPaDB.Query_DocsPAWS.Documenti doc = new DocsPaDB.Query_DocsPAWS.Documenti();

            trasm.infoDocumento = schedaDoc.InfoDocumento;

            //INSERISCO LA RAGIONE DI TRASMISSIONE DI SISTEMA PER LIBRO FIRMA
            DocsPaVO.trasmissione.RagioneTrasmissione ragione = getRagioneTrasm(infoUtente.idAmministrazione, "D");

            //CREO LA TRASMISSIONE SINGOLA
            DocsPaVO.trasmissione.TrasmissioneSingola trasmSing = new DocsPaVO.trasmissione.TrasmissioneSingola();
            trasmSing.ragione   = ragione;
            trasmSing.tipoTrasm = "S";


            DocsPaDB.Query_DocsPAWS.Utenti utenti = new DocsPaDB.Query_DocsPAWS.Utenti();
            DocsPaVO.utente.Ruolo          ruolo  = utenti.GetRuoloByIdGruppo(idGruppoDest);
            trasmSing.corrispondenteInterno = ruolo;
            trasmSing.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.RUOLO;

            System.Collections.ArrayList             listaUtenti = new System.Collections.ArrayList();
            DocsPaVO.addressbook.QueryCorrispondente qc          = new DocsPaVO.addressbook.QueryCorrispondente();
            qc.codiceRubrica = ruolo.codiceRubrica;
            System.Collections.ArrayList registri = ruolo.registri;
            qc.tipoUtente = DocsPaVO.addressbook.TipoUtente.INTERNO;
            //qc.idRegistri = registri;
            qc.idAmministrazione = ruolo.idAmministrazione;
            qc.getChildren       = true;
            qc.fineValidita      = true;
            listaUtenti          = BusinessLogic.Utenti.addressBookManager.listaCorrispondentiIntMethod(qc);
            System.Collections.ArrayList trasmissioniUt = new System.Collections.ArrayList();

            for (int k = 0; k < listaUtenti.Count; k++)
            {
                DocsPaVO.trasmissione.TrasmissioneUtente trUt = new DocsPaVO.trasmissione.TrasmissioneUtente();
                trUt.utente       = (DocsPaVO.utente.Utente)listaUtenti[k];
                trUt.daNotificare = (listaUtenti[k] as DocsPaVO.utente.Utente).idPeople.Equals(idPeopleDest);
                trasmissioniUt.Add(trUt);
            }

            trasmSing.trasmissioneUtente = trasmissioniUt;
            trasm.trasmissioniSingole    = new System.Collections.ArrayList()
            {
                trasmSing
            };
            return(BusinessLogic.Trasmissioni.ExecTrasmManager.saveExecuteTrasmMethod("", trasm));
        }
Пример #3
0
        /// <summary>
        /// Prende la ragione di trasmissione per il protocollo interno
        /// tramite la system_id dell'amministrazione ed il tipo destinatario
        /// </summary>
        /// <param name="tipoDest">tipo del destinatario (TO o CC)</param>
        /// <param name="idAmm">system_id dell'amministrazione</param>
        /// <returns>Object Ragione</returns>
        public static DocsPaVO.trasmissione.RagioneTrasmissione GetRagione(string tipoDest, string idAmm)
        {
            logger.Debug("GetRagione");
            DocsPaVO.trasmissione.RagioneTrasmissione objRagione = new DocsPaVO.trasmissione.RagioneTrasmissione();
            string queryString = getQueryRagione(tipoDest, idAmm);

            logger.Debug(queryString);

            DocsPaDB.Query_DocsPAWS.Trasmissione strDB = new DocsPaDB.Query_DocsPAWS.Trasmissione();
            strDB.GetRag(queryString, ref objRagione);

            return(objRagione);
        }
Пример #4
0
        public static DocsPaVO.trasmissione.RagioneTrasmissione getRagioneByCodice(string idAmm, string codice)
        {
            logger.Debug("getRagione");
            DocsPaVO.trasmissione.RagioneTrasmissione objRagione = new DocsPaVO.trasmissione.RagioneTrasmissione();
            string queryString = getQueryRagioneByCodice(idAmm, codice);

            logger.Debug(queryString);

            DocsPaDB.Query_DocsPAWS.Trasmissione strDB = new DocsPaDB.Query_DocsPAWS.Trasmissione();
            strDB.GetRag(queryString, ref objRagione);

            return(objRagione);
        }
Пример #5
0
        public static DocsPaVO.trasmissione.RagioneTrasmissione getRagioneNotifica(string idAmm)
        {
            try
            {
                DocsPaDB.Query_DocsPAWS.Trasmissione      strDB      = new DocsPaDB.Query_DocsPAWS.Trasmissione();
                DocsPaVO.trasmissione.RagioneTrasmissione objRagione = new DocsPaVO.trasmissione.RagioneTrasmissione();

                strDB.getRagioneNotifica(idAmm, ref objRagione);
                return(objRagione);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }
Пример #6
0
        private static DocsPaVO.trasmissione.Trasmissione addTrasmissioneSingola(DocsPaVO.trasmissione.Trasmissione trasmissione, DocsPaVO.trasmissione.TrasmissioneSingola trasmSingolaTemplate, string idAmministrazione)
        {
            DocsPaVO.utente.Corrispondente corr = trasmSingolaTemplate.corrispondenteInterno;
            if (!Utenti.addressBookManager.isCorrispondenteValido(corr.systemId))
            {
                logger.Debug("Corrispondente: id:" + corr.systemId + " - desc:" + corr.descrizione + " non valido");
                return(trasmissione);
            }
            DocsPaVO.trasmissione.RagioneTrasmissione ragione = trasmSingolaTemplate.ragione;
            // Aggiungo la trasmissione singola
            DocsPaVO.trasmissione.TrasmissioneSingola trasmissioneSingola = new DocsPaVO.trasmissione.TrasmissioneSingola();
            trasmissioneSingola.tipoTrasm             = "S";
            trasmissioneSingola.corrispondenteInterno = corr;
            trasmissioneSingola.ragione = ragione;

            // Aggiungo la lista di trasmissioniUtente
            if (corr.GetType() == typeof(DocsPaVO.utente.Ruolo))
            {
                trasmissioneSingola.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.RUOLO;
                ArrayList listaUtenti = queryUtenti(corr.codiceRubrica, idAmministrazione);
                //ciclo per utenti se dest è gruppo o ruolo
                if (listaUtenti == null || listaUtenti.Count == 0)
                {
                    return(trasmissione);
                }
                for (int i = 0; i < listaUtenti.Count; i++)
                {
                    DocsPaVO.trasmissione.TrasmissioneUtente trasmissioneUtente = new DocsPaVO.trasmissione.TrasmissioneUtente();
                    trasmissioneUtente.utente = (DocsPaVO.utente.Utente)listaUtenti[i];
                    if (ragione.descrizione.Equals("RISPOSTA"))
                    {
                        trasmissioneUtente.idTrasmRispSing = trasmissioneSingola.systemId;
                    }
                    trasmissioneSingola.trasmissioneUtente.Add(trasmissioneUtente);
                }
            }
            else
            {
                trasmissioneSingola.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.UTENTE;
                DocsPaVO.trasmissione.TrasmissioneUtente trasmissioneUtente = new DocsPaVO.trasmissione.TrasmissioneUtente();
                trasmissioneUtente.utente = (DocsPaVO.utente.Utente)corr;
                trasmissioneSingola.trasmissioneUtente.Add(trasmissioneUtente);
            }
            trasmissione.trasmissioniSingole.Add(trasmissioneSingola);
            return(trasmissione);
        }
Пример #7
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="ragione"></param>
        /// <returns></returns>
        protected virtual DocsPaVO.trasmissione.RagioneTrasmissione GetRagioneTrasmissione(string ragione)
        {
            DocsPaVO.trasmissione.RagioneTrasmissione ragioneTrasmissione = null;

            if (string.IsNullOrEmpty(ragione))
            {
                string idRagioneDefault = BusinessLogic.Amministrazione.AmministraManager.AmmGetInfoAmmCorrente(this._infoUtente.idAmministrazione).IDRagioneCompetenza;

                // Reperimento ragione trasmissione predefinita
                ragioneTrasmissione = BusinessLogic.Trasmissioni.QueryTrasmManager.getRagioneById(idRagioneDefault);
            }
            else
            {
                // Reperimento della ragione trasmissione richiesta
                ragioneTrasmissione = BusinessLogic.Trasmissioni.RagioniManager.getRagioneByCodice(this._infoUtente.idAmministrazione, ragione);
            }

            return(ragioneTrasmissione);
        }
Пример #8
0
//		/// <summary>
//		/// </summary>
//		/// <param name="infoUtente"></param>
//		/// <returns></returns>
//		private static string getUserLogin(string idPeople)
//		{
//			logger.Debug("getUserLogin");
//			//DocsPa_V15_Utils.Database db=DocsPa_V15_Utils.dbControl.getDatabase();
//			bool dbOpen=false;
//			System.Data.DataSet ds=new System.Data.DataSet();
//			string userLogin=null;
//			try
//			{
//			   //db.openConnection();
//               dbOpen=true;
//
//				#region Codice Commentato
//				/*
//               string queryString="SELECT VAR_FAX_USER_LOGIN FROM DPA_CORR_GLOBALI WHERE ID_PEOPLE="+infoUtente.idPeople;
//               logger.Debug(queryString);
//			   userLogin=(string) db.executeScalar(queryString).ToString();
//			   */
//				#endregion
//
//				DocsPaDB.Query_DocsPAWS.Fax obj = new DocsPaDB.Query_DocsPAWS.Fax();
//				userLogin = obj.getFaxUserLogin(idPeople);
//
//			   //db.closeConnection();
//			   dbOpen=false;
//			   return userLogin;
//			}
//			catch(Exception e){
//			   logger.Debug(e.Message);
//				if(dbOpen){
//				  //db.closeConnection();
//				}
//
//				logger.Debug("Errore nella gestione dei fax (getUserLogin)",e);
//				throw e;
//			}
//		}
        #endregion

        /// <summary>
        /// </summary>
        /// <returns></returns>
        private static DocsPaVO.trasmissione.RagioneTrasmissione getRagioneTrasm()
        {
            logger.Debug("getRagioneTrasm");
            //DocsPa_V15_Utils.Database db=DocsPa_V15_Utils.dbControl.getDatabase();
            DataSet ds = new DataSet();

            DocsPaVO.trasmissione.RagioneTrasmissione rt = new DocsPaVO.trasmissione.RagioneTrasmissione();
            try
            {
                /*
                 * string queryString="SELECT * FROM DPA_RAGIONE_TRASM WHERE CHA_TIPO_RAGIONE='N' AND CHA_TIPO_DIRITTI='W'";
                 * db.fillTable(queryString,ds,"RAGIONE");
                 */
                DocsPaDB.Query_DocsPAWS.Fax obj = new DocsPaDB.Query_DocsPAWS.Fax();
                obj.getRagTrasm(out ds);

                DataRow ragione = ds.Tables["RAGIONE"].Rows[0];
                rt.descrizione = ragione["VAR_DESC_RAGIONE"].ToString();
                rt.risposta    = ragione["CHA_RISPOSTA"].ToString();
                rt.systemId    = ragione["SYSTEM_ID"].ToString();
                rt.tipo        = "N";
                logger.Debug("prima di tipo dest" + ragione["CHA_TIPO_DEST"].ToString() + " " + DocsPaDB.Utils.HashTableManager.GetKeyFromValue(DocsPaVO.trasmissione.RagioneTrasmissione.tipoGerarchiaStringa, ragione["CHA_TIPO_DEST"].ToString()).GetType());
                rt.tipoDestinatario = (DocsPaVO.trasmissione.TipoGerarchia)DocsPaDB.Utils.HashTableManager.GetKeyFromValue(DocsPaVO.trasmissione.RagioneTrasmissione.tipoGerarchiaStringa, ragione["CHA_TIPO_DEST"].ToString());

                rt.tipoDiritti = DocsPaVO.trasmissione.TipoDiritto.WRITE;

                rt.eredita = ragione["CHA_EREDITA"].ToString();
            }
            catch (Exception e)
            {
                logger.Debug(e.ToString());
                //db.closeConnection();

                logger.Debug("Errore nella gestione dei fax (getRagioneTrasm)", e);
                throw e;
            }

            return(rt);
        }
Пример #9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="idOggetto"></param>
        /// <param name="tipoOggetto"></param>
        /// <param name="ragione"></param>
        /// <returns></returns>
        protected string GetIdTrasmissione(string idOggetto,
                                           DocsPaVO.trasmissione.TipoOggetto tipoOggetto,
                                           string ragione)
        {
            string idTrasmissione = string.Empty;

            DocsPaVO.trasmissione.RagioneTrasmissione ragioneTrasmissione = this.GetRagioneTrasmissione(ragione);


            using (DocsPaDB.DBProvider dbProvider = new DocsPaDB.DBProvider())
            {
                string filtroOggetto = string.Empty;

                if (tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO)
                {
                    filtroOggetto = string.Format("T.ID_PROFILE = {0}", idOggetto);
                }
                else
                {
                    filtroOggetto = string.Format("T.ID_PROJECT = {0}", idOggetto);
                }

                string commandText =
                    string.Format(
                        "SELECT T.SYSTEM_ID, CG.ID_PEOPLE, CG.ID_GRUPPO " +
                        "FROM DPA_TRASMISSIONE T " +
                        "INNER JOIN DPA_TRASM_SINGOLA TS ON TS.ID_TRASMISSIONE = T.SYSTEM_ID " +
                        "INNER JOIN DPA_CORR_GLOBALI CG ON CG.SYSTEM_ID = TS.ID_CORR_GLOBALE " +
                        "WHERE {0} AND TS.ID_RAGIONE = '{1}'",
                        filtroOggetto, ragioneTrasmissione.systemId);

                dbProvider.ExecuteScalar(out idTrasmissione, commandText);
            }

            return(idTrasmissione);
        }
Пример #10
0
        public void filtra_trasmissioni(DocsPaVO.rubrica.ParametriRicercaRubrica qr, ref ArrayList ers)
        {
            ArrayList a = new ArrayList();
            ArrayList ruoli_autorizzati = new ArrayList();

            DocsPaVO.trasmissione.TipoOggetto tipo_oggetto;
            tipo_oggetto = (qr.ObjectType.StartsWith("F:")) ? DocsPaVO.trasmissione.TipoOggetto.FASCICOLO : DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO;
            string id_nodo_titolario = (tipo_oggetto == DocsPaVO.trasmissione.TipoOggetto.FASCICOLO) ? qr.ObjectType.Substring(2) : null;

            DocsPaVO.utente.Ruolo    r = BusinessLogic.Utenti.UserManager.getRuolo(qr.caller.IdRuolo);
            DocsPaDB.Utils.Gerarchia g = new DocsPaDB.Utils.Gerarchia();

            switch (qr.calltype)
            {
            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_MODELLI_TRASM_ALL:
            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_ALL:
                ruoli_autorizzati = g.getRuoliAut(r, qr.caller.IdRegistro, id_nodo_titolario, tipo_oggetto);
                break;

            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_MODELLI_TRASM_SUP:
            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_SUP:
                ruoli_autorizzati = g.getGerarchiaSup(r, qr.caller.IdRegistro, id_nodo_titolario, tipo_oggetto);
                break;

            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_MODELLI_TRASM_INF:
            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_INF:
                ruoli_autorizzati = g.getGerarchiaInf(r, qr.caller.IdRegistro, id_nodo_titolario, tipo_oggetto);
                break;

            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_MODELLI_TRASM_PARILIVELLO:
            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_PARILIVELLO:
                ruoli_autorizzati = g.getGerarchiaPariLiv(r, qr.caller.IdRegistro, id_nodo_titolario, tipo_oggetto);
                break;

            case DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_PROTO_INT_DEST:
                DocsPaVO.trasmissione.RagioneTrasmissione rTo = BusinessLogic.Trasmissioni.RagioniManager.GetRagione("TO", _user.idAmministrazione);
                DocsPaVO.trasmissione.TipoGerarchia       gTo = rTo.tipoDestinatario;

                switch (gTo)
                {
                case DocsPaVO.trasmissione.TipoGerarchia.INFERIORE:
                    ruoli_autorizzati = g.getGerarchiaInf(r, qr.caller.IdRegistro, id_nodo_titolario, tipo_oggetto);
                    break;

                case DocsPaVO.trasmissione.TipoGerarchia.PARILIVELLO:
                    ruoli_autorizzati = g.getGerarchiaPariLiv(r, qr.caller.IdRegistro, id_nodo_titolario, tipo_oggetto);
                    break;

                case DocsPaVO.trasmissione.TipoGerarchia.SUPERIORE:
                    ruoli_autorizzati = g.getGerarchiaSup(r, qr.caller.IdRegistro, id_nodo_titolario, tipo_oggetto);
                    break;

                case DocsPaVO.trasmissione.TipoGerarchia.TUTTI:
                    ruoli_autorizzati = g.getRuoliAut(r, qr.caller.IdRegistro, null, tipo_oggetto);
                    break;
                }
                break;

            default:
                return;
            }
            string[] c_ruoli_aut = new string[ruoli_autorizzati.Count];
            for (int i = 0; i < ruoli_autorizzati.Count; i++)
            {
                c_ruoli_aut[i] = ((DocsPaVO.utente.Ruolo)ruoli_autorizzati[i]).codiceRubrica;
            }

            Array.Sort(c_ruoli_aut);

            foreach (DocsPaVO.rubrica.ElementoRubrica er in ers)
            {
                try
                {
                    switch (er.tipo)
                    {
                    case "U":
                        if (uo_is_autorizzata((er.interno ? "I" : "E") + @"\" + er.codice, r, c_ruoli_aut) || (qr.ObjectType == "G"))
                        {
                            a.Add(er);
                        }
                        break;

                    case "R":
                        if (ruolo_is_autorizzato(er.codice, c_ruoli_aut) || (qr.ObjectType == "G"))
                        {
                            a.Add(er);
                        }
                        break;

                    case "P":
                        if (utente_is_autorizzato((er.interno ? "I" : "E") + @"\" + er.codice, c_ruoli_aut) || (qr.ObjectType == "G"))
                        {
                            a.Add(er);
                        }
                        break;

                    case "L":
                    case "F":
                        //if (utente_is_autorizzato ((er.interno ? "I" : "E") + @"\" + er.codice, c_ruoli_aut) || (qr.ObjectType == "G"))
                        a.Add(er);
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
            ers = a;
        }
Пример #11
0
        private static DocsPaVO.trasmissione.Trasmissione creaTrasmDaModello(DocsPaVO.documento.SchedaDocumento schedaDocumento, DocsPaVO.Modelli_Trasmissioni.ModelloTrasmissione modello, DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.utente.Ruolo ruolo)
        {
            DocsPaVO.trasmissione.Trasmissione trasmissione = new DocsPaVO.trasmissione.Trasmissione();

            try
            {
                DocsPaVO.documento.InfoDocumento infoDocumento = Documenti.DocManager.getInfoDocumento(schedaDocumento);
                trasmissione.infoDocumento = infoDocumento;

                DocsPaVO.utente.Utente utente = Utenti.UserManager.getUtente(infoUtente.idPeople);
                trasmissione.utente = utente;

                trasmissione.ruolo       = ruolo;
                trasmissione.tipoOggetto = DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO;

                trasmissione.noteGenerali = modello.VAR_NOTE_GENERALI;

                for (int i = 0; i < modello.RAGIONI_DESTINATARI.Count; i++)
                {
                    DocsPaVO.Modelli_Trasmissioni.RagioneDest ragDest = (DocsPaVO.Modelli_Trasmissioni.RagioneDest)modello.RAGIONI_DESTINATARI[i];
                    ArrayList destinatari = new ArrayList(ragDest.DESTINATARI);
                    for (int j = 0; j < destinatari.Count; j++)
                    {
                        DocsPaVO.Modelli_Trasmissioni.MittDest mittDest = (DocsPaVO.Modelli_Trasmissioni.MittDest)destinatari[j];

                        DocsPaVO.trasmissione.RagioneTrasmissione ragione = Trasmissioni.QueryTrasmManager.getRagioneById(mittDest.ID_RAGIONE.ToString());

                        DocsPaVO.utente.Corrispondente corr = Utenti.UserManager.getCorrispondenteBySystemID(mittDest.ID_CORR_GLOBALI.ToString());

                        if (corr != null) //corr nullo se non esiste o se è stato disabilitato
                        {
                            // Aggiungo la trasmissione singola
                            DocsPaVO.trasmissione.TrasmissioneSingola trasmissioneSingola = new DocsPaVO.trasmissione.TrasmissioneSingola();
                            trasmissioneSingola.tipoTrasm             = mittDest.CHA_TIPO_TRASM;
                            trasmissioneSingola.corrispondenteInterno = corr;
                            trasmissioneSingola.ragione     = ragione;
                            trasmissioneSingola.noteSingole = mittDest.VAR_NOTE_SING;

                            // RUOLO
                            if (corr is DocsPaVO.utente.Ruolo)
                            {
                                trasmissioneSingola.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.RUOLO;
                                ArrayList listaUtenti = queryUtenti(corr, modello.ID_AMM);
                                if (listaUtenti.Count == 0)
                                {
                                    trasmissioneSingola = null;
                                }

                                for (int ut = 0; ut < listaUtenti.Count; ut++)
                                {
                                    DocsPaVO.trasmissione.TrasmissioneUtente trasmissioneUtente = new DocsPaVO.trasmissione.TrasmissioneUtente();

                                    trasmissioneUtente.utente       = (DocsPaVO.utente.Utente)listaUtenti[ut];
                                    trasmissioneUtente.daNotificare = true;
                                    trasmissioneSingola.trasmissioneUtente.Add(trasmissioneUtente);
                                }
                            }

                            // UTENTE
                            if (corr is DocsPaVO.utente.Utente)
                            {
                                trasmissioneSingola.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.UTENTE;
                                DocsPaVO.trasmissione.TrasmissioneUtente trasmissioneUtente = new DocsPaVO.trasmissione.TrasmissioneUtente();

                                trasmissioneUtente.utente       = (DocsPaVO.utente.Utente)corr;
                                trasmissioneUtente.daNotificare = true;
                                trasmissioneSingola.trasmissioneUtente.Add(trasmissioneUtente);
                            }

                            if (trasmissioneSingola != null)
                            {
                                trasmissione.trasmissioniSingole.Add(trasmissioneSingola);
                            }
                        }
                    }
                }
            }
            catch
            {
                trasmissione = null;
            }

            return(trasmissione);
        }
Пример #12
0
        /// <summary>
        /// Trasmissione di notifica di conversione in PDF terminata (con successo o meno)
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="documentoConvertito"></param>
        /// <param name="noteGenerali">
        /// Note generali da inserire nella trasmissione
        /// </param>
        /// <param name="noteIndividuali"></param>
        private static void ExecuteTrasmissione(DocsPaVO.utente.InfoUtente infoUtente,
                                                DocsPaVO.documento.SchedaDocumento documentoConvertito,
                                                string noteGenerali)
        {
            try
            {
                if (documentoConvertito == null)
                {
                    throw new ApplicationException("Scheda Documento non disponibile per la trasmissione");
                }

                DocsPaVO.utente.Utente utente = BusinessLogic.Utenti.UserManager.getUtente(infoUtente.idPeople);

                //Effettuo una trasmissione all'utente per comunicare l'esito della conversione pdf
                DocsPaVO.trasmissione.Trasmissione trasmissione = new DocsPaVO.trasmissione.Trasmissione();

                trasmissione.utente       = utente;
                trasmissione.tipoOggetto  = DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO;
                trasmissione.noteGenerali = noteGenerali;

                string commandText = "(SELECT SYSTEM_ID FROM DPA_CORR_GLOBALI WHERE ID_GRUPPO = " + infoUtente.idGruppo + ")";
                trasmissione.ruolo         = BusinessLogic.Utenti.UserManager.getRuolo(commandText);
                trasmissione.infoDocumento = BusinessLogic.Documenti.DocManager.getInfoDocumento(documentoConvertito);

                DocsPaVO.trasmissione.RagioneTrasmissione ragione = BusinessLogic.Trasmissioni.RagioniManager.getRagioneNotifica(trasmissione.ruolo.idAmministrazione);
                DocsPaVO.utente.Corrispondente            corr    = null;
                string tipoNotify = "";
                if (!string.IsNullOrEmpty(System.Configuration.ConfigurationManager.AppSettings["PDF_CONVERT_SERVER_NOTIFY"].ToString()))
                {
                    tipoNotify = System.Configuration.ConfigurationManager.AppSettings["PDF_CONVERT_SERVER_NOTIFY"].ToString();
                }

                if (tipoNotify != "" || tipoNotify != "0")
                {
                    if (tipoNotify == "RS")
                    {
                        corr         = (DocsPaVO.utente.Corrispondente)BusinessLogic.Utenti.UserManager.getRuolo(commandText);
                        trasmissione = BusinessLogic.Trasmissioni.TrasmManager.addTrasmissioneSingola(trasmissione, corr, ragione, string.Empty, "S");
                    }
                    if (tipoNotify == "RT")
                    {
                        corr         = (DocsPaVO.utente.Corrispondente)BusinessLogic.Utenti.UserManager.getRuolo(commandText);
                        trasmissione = BusinessLogic.Trasmissioni.TrasmManager.addTrasmissioneSingola(trasmissione, corr, ragione, string.Empty, "T");
                    }
                    if (tipoNotify == "US")
                    {
                        //corr = (DocsPaVO.utente.Corrispondente) utente;
                        corr         = BusinessLogic.Utenti.UserManager.getCorrispondenteByIdPeople(utente.idPeople, DocsPaVO.addressbook.TipoUtente.INTERNO, infoUtente);
                        trasmissione = BusinessLogic.Trasmissioni.TrasmManager.addTrasmissioneSingola(trasmissione, corr, ragione, string.Empty, "S");
                    }

                    trasmissione = BusinessLogic.Trasmissioni.ExecTrasmManager.saveExecuteTrasmMethod(infoUtente.urlWA, trasmissione);
                    if (trasmissione == null)
                    {
                        throw new ApplicationException();
                    }
                }
            }
            catch (Exception ex)
            {
                string errorMessage = string.Format("Si è verificato un errore nell'invio della trasmissione di notifica all'utente '{0}' di conversione in PDF del documento. NoteGenerali di trasmissione: '{1}', Note individuali di trasmissione: '{2}'",
                                                    infoUtente.userId,
                                                    noteGenerali,
                                                    string.Empty);

                logger.Debug(errorMessage, ex);
            }
        }
Пример #13
0
        /// <summary>
        /// Tramissione di un fascicolo usando un modello di trasmissione
        /// Il parametro "idStato" puo' essere null o meno a seconda delle necessità
        /// </summary>
        /// <returns></returns>
        ///
        public static void effettuaTrasmissioneFascDaModello(
            DocsPaVO.utente.InfoUtente infoUtente,
            DocsPaVO.Modelli_Trasmissioni.ModelloTrasmissione modello,
            string idStato,
            DocsPaVO.fascicolazione.Fascicolo fascicolo)
        {
            DocsPaVO.trasmissione.Trasmissione trasmissione = new DocsPaVO.trasmissione.Trasmissione();

            trasmissione.noteGenerali  = modello.VAR_NOTE_GENERALI;
            trasmissione.tipoOggetto   = DocsPaVO.trasmissione.TipoOggetto.FASCICOLO;
            trasmissione.infoFascicolo = new DocsPaVO.fascicolazione.InfoFascicolo(fascicolo);
            trasmissione.utente        = BusinessLogic.Utenti.UserManager.getUtente(infoUtente.idPeople);
            trasmissione.ruolo         = BusinessLogic.Utenti.UserManager.getRuoloById(infoUtente.idCorrGlobali);

            if (modello != null)
            {
                trasmissione.NO_NOTIFY = modello.NO_NOTIFY;
            }

            //Parametri delle trasmissioni singole
            foreach (DocsPaVO.Modelli_Trasmissioni.RagioneDest ragioneDest in modello.RAGIONI_DESTINATARI)
            {
                foreach (DocsPaVO.Modelli_Trasmissioni.MittDest mittDest in ragioneDest.DESTINATARI)
                {
                    DocsPaVO.utente.Corrispondente corr = new DocsPaVO.utente.Corrispondente();

                    if (mittDest.CHA_TIPO_MITT_DEST == "D")
                    {
                        corr = BusinessLogic.Utenti.UserManager.getCorrispondenteByCodRubrica(mittDest.VAR_COD_RUBRICA, DocsPaVO.addressbook.TipoUtente.INTERNO, infoUtente);
                    }
                    else
                    {
                        corr = getCorrispondenti(infoUtente, mittDest.CHA_TIPO_MITT_DEST, fascicolo, trasmissione);
                    }

                    if (corr != null)
                    {
                        DocsPaVO.trasmissione.RagioneTrasmissione ragione = BusinessLogic.Trasmissioni.QueryTrasmManager.getRagioneById(mittDest.ID_RAGIONE.ToString());

                        trasmissione = addTrasmissioneSingola(infoUtente, trasmissione, corr, ragione, mittDest.VAR_NOTE_SING, mittDest.CHA_TIPO_TRASM, mittDest.SCADENZA);
                    }
                }
            }

            trasmissione = impostaNotificheUtentiDaModello(infoUtente, trasmissione, modello);
            trasmissione = BusinessLogic.Trasmissioni.ExecTrasmManager.saveExecuteTrasmMethod(string.Empty, trasmissione);

            string desc = "";

            string notify = "1";

            if (trasmissione.NO_NOTIFY != null && trasmissione.NO_NOTIFY.Equals("1"))
            {
                notify = "0";
            }
            else
            {
                notify = "1";
            }

            if (trasmissione != null)
            {
                // LOG per documento
                if (trasmissione.infoDocumento != null && !string.IsNullOrEmpty(trasmissione.infoDocumento.idProfile))
                {
                    foreach (DocsPaVO.trasmissione.TrasmissioneSingola single in trasmissione.trasmissioniSingole)
                    {
                        string method = "TRASM_DOC_" + single.ragione.descrizione.ToUpper().Replace(" ", "_");
                        if (trasmissione.infoDocumento.segnatura == null)
                        {
                            desc = "Trasmesso Documento : " + trasmissione.infoDocumento.docNumber.ToString();
                        }
                        else
                        {
                            desc = "Trasmesso Documento : " + trasmissione.infoDocumento.segnatura.ToString();
                        }

                        BusinessLogic.UserLog.UserLog.WriteLog(trasmissione.utente.userId, trasmissione.utente.idPeople, trasmissione.ruolo.idGruppo, trasmissione.utente.idAmministrazione, method, trasmissione.infoDocumento.docNumber, desc, DocsPaVO.Logger.CodAzione.Esito.OK, infoUtente.delegato, notify, single.systemId);
                    }
                }
                // LOG per fascicolo
                if (trasmissione.infoFascicolo != null && !string.IsNullOrEmpty(trasmissione.infoFascicolo.idFascicolo))
                {
                    foreach (DocsPaVO.trasmissione.TrasmissioneSingola single in trasmissione.trasmissioniSingole)
                    {
                        string method = "TRASM_FOLDER_" + single.ragione.descrizione.ToUpper().Replace(" ", "_");
                        desc = "Trasmesso Fascicolo ID: " + trasmissione.infoFascicolo.idFascicolo.ToString();
                        BusinessLogic.UserLog.UserLog.WriteLog(trasmissione.utente.userId, trasmissione.utente.idPeople, trasmissione.ruolo.idGruppo, trasmissione.utente.idAmministrazione, method, trasmissione.infoFascicolo.idFascicolo, desc, DocsPaVO.Logger.CodAzione.Esito.OK, infoUtente.delegato, notify, single.systemId);
                    }
                }
            }

            if (!string.IsNullOrEmpty(idStato))
            {
                BusinessLogic.DiagrammiStato.DiagrammiStato.salvaStoricoTrasmDiagrammiFasc(trasmissione.systemId, fascicolo.systemID, idStato);
            }
        }
Пример #14
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="trasmissione"></param>
        /// <param name="idDestinatari"></param>
        /// <returns></returns>
        protected virtual void UpdateTrasmissione(
            DocsPaVO.trasmissione.Trasmissione trasmissione,
            params string[] idDestinatari)
        {
            DocsPaVO.trasmissione.TrasmissioneSingola[] tsingole = (DocsPaVO.trasmissione.TrasmissioneSingola[])
                                                                   trasmissione.trasmissioniSingole.ToArray(typeof(DocsPaVO.trasmissione.TrasmissioneSingola));

            foreach (string idDest in idDestinatari)
            {
                if (tsingole.Count(e => e.corrispondenteInterno.systemId == idDest) == 0)
                {
                    string codiceDestinatario = string.Empty;

                    if (this._tipoTrasmissione == TipiTrasmissioneEnum.Utente)
                    {
                        DocsPaVO.utente.Utente utente = BusinessLogic.Utenti.UserManager.getUtenteById(idDest);

                        codiceDestinatario = utente.userId;
                    }
                    else
                    {
                        DocsPaVO.utente.Ruolo ruolo = null;

                        int idDestAsInt;
                        if (Int32.TryParse(idDest, out idDestAsInt))
                        {
                            // L'identificativo fornito è l'id del ruolo direttamente
                            ruolo = BusinessLogic.Utenti.UserManager.getRuoloById(idDest);

                            if (ruolo == null)
                            {
                                ruolo = BusinessLogic.Utenti.UserManager.getRuoloByIdGruppo(idDest);
                            }
                        }
                        else
                        {
                            // L'identificativo fornito è il codice del ruolo
                            ruolo = BusinessLogic.Utenti.UserManager.getRuoloByCodice(idDest);
                        }


                        codiceDestinatario = ruolo.codiceRubrica;
                    }

                    DocsPaVO.utente.Corrispondente corrispondenteDestinatario = BusinessLogic.Utenti.UserManager.getCorrispondenteByCodRubrica(
                        codiceDestinatario, DocsPaVO.addressbook.TipoUtente.INTERNO, this._infoUtente);

                    if (corrispondenteDestinatario != null)
                    {
                        // Reperimento ragione trasmissione di default
                        string idRagioneDefault = BusinessLogic.Amministrazione.AmministraManager.AmmGetInfoAmmCorrente(this._infoUtente.idAmministrazione).IDRagioneCompetenza;

                        DocsPaVO.trasmissione.RagioneTrasmissione ragione = BusinessLogic.Trasmissioni.QueryTrasmManager.getRagioneById(idRagioneDefault);

                        string tipoTrasm = (this._tipoTrasmissione == TipiTrasmissioneEnum.Utente ? "S" : "T");

                        trasmissione = AddTrasmissioneSingola(this._infoUtente,
                                                              trasmissione,
                                                              corrispondenteDestinatario,
                                                              ragione,
                                                              string.Empty,
                                                              tipoTrasm,
                                                              0);
                    }
                }
            }
        }
Пример #15
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="idOggetto"></param>
        /// <param name="tipoOggetto"></param>
        /// <param name="ragione"></param>
        /// <param name="noteGenerali"></param>
        /// <param name="idDestinatari"></param>
        /// <returns></returns>
        protected virtual DocsPaVO.trasmissione.Trasmissione PrepareTrasmissione(
            string idOggetto,
            DocsPaVO.trasmissione.TipoOggetto tipoOggetto,
            string ragione,
            string noteGenerali,
            bool notificaInToDoList,
            params string[] idDestinatari)
        {
            DocsPaVO.trasmissione.Trasmissione trasmissione = new DocsPaVO.trasmissione.Trasmissione();

            trasmissione.noteGenerali = noteGenerali;

            DocsPaVO.documento.SchedaDocumento schedaDocumento = null;
            DocsPaVO.fascicolazione.Fascicolo  schedaFascicolo = null;

            if (tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO)
            {
                trasmissione.tipoOggetto = DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO;

                schedaDocumento = BusinessLogic.Documenti.DocManager.getDettaglio(this._infoUtente, idOggetto, idOggetto);

                trasmissione.infoDocumento = new DocsPaVO.documento.InfoDocumento(schedaDocumento);
            }
            else if (tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.FASCICOLO)
            {
                trasmissione.tipoOggetto = DocsPaVO.trasmissione.TipoOggetto.FASCICOLO;

                schedaFascicolo = BusinessLogic.Fascicoli.FascicoloManager.getFascicoloById(idOggetto, this._infoUtente);

                trasmissione.infoFascicolo = new DocsPaVO.fascicolazione.InfoFascicolo(schedaFascicolo);
            }

            trasmissione.NO_NOTIFY = (notificaInToDoList ? "0" : "1");
            trasmissione.utente    = BusinessLogic.Utenti.UserManager.getUtente(this._infoUtente.idPeople);
            trasmissione.ruolo     = BusinessLogic.Utenti.UserManager.getRuoloById(this._infoUtente.idCorrGlobali);

            foreach (string idDest in idDestinatari)
            {
                string codiceDestinatario = string.Empty;

                if (this._tipoTrasmissione == TipiTrasmissioneEnum.Utente)
                {
                    DocsPaVO.utente.Utente utente = BusinessLogic.Utenti.UserManager.getUtenteById(idDest);

                    codiceDestinatario = utente.userId;
                }
                else
                {
                    DocsPaVO.utente.Ruolo ruolo = null;

                    int idDestAsInt;
                    if (Int32.TryParse(idDest, out idDestAsInt))
                    {
                        // L'identificativo fornito è l'id del ruolo direttamente
                        ruolo = BusinessLogic.Utenti.UserManager.getRuoloById(idDest);

                        if (ruolo == null)
                        {
                            ruolo = BusinessLogic.Utenti.UserManager.getRuoloByIdGruppo(idDest);
                        }
                    }
                    else
                    {
                        // L'identificativo fornito è il codice del ruolo
                        ruolo = BusinessLogic.Utenti.UserManager.getRuoloByCodice(idDest);
                    }

                    codiceDestinatario = ruolo.codiceRubrica;
                }

                DocsPaVO.utente.Corrispondente corrispondenteDestinatario = BusinessLogic.Utenti.UserManager.getCorrispondenteByCodRubrica(
                    codiceDestinatario, DocsPaVO.addressbook.TipoUtente.INTERNO, this._infoUtente);

                if (corrispondenteDestinatario != null)
                {
                    DocsPaVO.trasmissione.RagioneTrasmissione ragioneTrasmissione = this.GetRagioneTrasmissione(ragione);

                    string tipoTrasm = (this._tipoTrasmissione == TipiTrasmissioneEnum.Utente ? "S" : "T");

                    trasmissione = this.AddTrasmissioneSingola(this._infoUtente,
                                                               trasmissione,
                                                               corrispondenteDestinatario,
                                                               ragioneTrasmissione,
                                                               string.Empty,
                                                               tipoTrasm,
                                                               0);
                }
            }

            return(trasmissione);
        }
Пример #16
0
        public static void CambioStatoProcedimento(string idFascicolo, string tipoEvento, string idOggetto, DocsPaVO.utente.InfoUtente utente)
        {
            logger.Debug("BEGIN");
            DocsPaDB.Query_DocsPAWS.Procedimenti proc = new DocsPaDB.Query_DocsPAWS.Procedimenti();
            string idStato = proc.GetIdPerCambioStato(tipoEvento, idOggetto);

            if (!string.IsNullOrEmpty(idStato))
            {
                logger.Debug("Stato: " + idStato);
                DocsPaVO.ProfilazioneDinamica.Templates template = BusinessLogic.ProfilazioneDinamica.ProfilazioneFascicoli.getTemplateFascDettagli(idFascicolo);
                if (template != null)
                {
                    int idDiagram = BusinessLogic.DiagrammiStato.DiagrammiStato.getDiagrammaAssociatoFasc(template.ID_TIPO_FASC);
                    if (idDiagram != 0)
                    {
                        DocsPaVO.DiagrammaStato.DiagrammaStato stateDiagram = BusinessLogic.DiagrammiStato.DiagrammiStato.getDiagrammaById(idDiagram.ToString());
                        if (stateDiagram != null)
                        {
                            logger.DebugFormat("Trovato evento per cambio stato - stato={0} fascicolo={1} tipoevento={2}", idStato, idFascicolo, tipoEvento);
                            BusinessLogic.DiagrammiStato.DiagrammiStato.salvaModificaStatoFasc(idFascicolo, idStato, stateDiagram, utente.idPeople, utente, string.Empty);

                            // CABLATURA PER DEMO 21/11
                            if (tipoEvento.ToUpper() == "ACCETTAZIONE")
                            {
                                DocsPaVO.trasmissione.RagioneTrasmissione ragTrasm = BusinessLogic.Trasmissioni.RagioniManager.getRagione(idOggetto);
                                if (ragTrasm != null)
                                {
                                    if (template.ELENCO_OGGETTI != null && template.ELENCO_OGGETTI.Count > 0)
                                    {
                                        bool toUpdate = false;
                                        foreach (DocsPaVO.ProfilazioneDinamica.OggettoCustom ogg in template.ELENCO_OGGETTI)
                                        {
                                            if (ogg.DESCRIZIONE.ToUpper() == "RUOLO ASSEGNATARIO")
                                            {
                                                logger.Debug("Ruolo assegnatario - ID=" + utente.idCorrGlobali);
                                                ogg.VALORE_DATABASE = utente.idCorrGlobali;
                                                toUpdate            = true;
                                            }
                                            if (ogg.DESCRIZIONE.ToUpper() == "UTENTE ASSEGNATARIO")
                                            {
                                                DocsPaVO.utente.Corrispondente corr = BusinessLogic.Utenti.UserManager.getCorrispondenteByIdPeople(utente.idPeople, DocsPaVO.addressbook.TipoUtente.INTERNO, utente);
                                                if (corr != null)
                                                {
                                                    logger.Debug("Utente assegnatario - idPeople=" + utente.idPeople + " - idCorrGlobali=" + corr.systemId);
                                                    ogg.VALORE_DATABASE = corr.systemId;
                                                    toUpdate            = true;
                                                }
                                            }
                                        }
                                        if (toUpdate)
                                        {
                                            BusinessLogic.ProfilazioneDinamica.ProfilazioneFascicoli.salvaInserimentoUtenteProfDimFasc(template, idFascicolo);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            logger.Debug("END");
        }
Пример #17
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="infoUtente"></param>
        /// <param name="trasmissione"></param>
        /// <param name="corr"></param>
        /// <param name="ragione"></param>
        /// <param name="note"></param>
        /// <param name="tipoTrasm"></param>
        /// <param name="scadenza"></param>
        /// <returns></returns>
        public static DocsPaVO.trasmissione.Trasmissione addTrasmissioneSingola(
            DocsPaVO.utente.InfoUtente infoUtente,
            DocsPaVO.trasmissione.Trasmissione trasmissione,
            DocsPaVO.utente.Corrispondente corr,
            DocsPaVO.trasmissione.RagioneTrasmissione ragione,
            string note,
            string tipoTrasm,
            int scadenza)
        {
            if (trasmissione.trasmissioniSingole != null)
            {
                // controllo se esiste la trasmissione singola associata a corrispondente selezionato

                foreach (DocsPaVO.trasmissione.TrasmissioneSingola ts in trasmissione.trasmissioniSingole)
                {
                    if (ts.corrispondenteInterno.systemId.Equals(corr.systemId))
                    {
                        if (ts.daEliminare)
                        {
                            ts.daEliminare = false;
                            return(trasmissione);
                        }
                        else
                        {
                            return(trasmissione);
                        }
                    }
                }
            }

            // Aggiungo la trasmissione singola
            DocsPaVO.trasmissione.TrasmissioneSingola trasmissioneSingola = new DocsPaVO.trasmissione.TrasmissioneSingola();
            trasmissioneSingola.tipoTrasm             = tipoTrasm;
            trasmissioneSingola.corrispondenteInterno = corr;
            trasmissioneSingola.ragione     = ragione;
            trasmissioneSingola.noteSingole = note;
            //Imposto la data di scadenza
            if (scadenza > 0)
            {
                string          dataScadenza = "";
                System.DateTime data         = System.DateTime.Now.AddDays(scadenza);
                dataScadenza = data.Day + "/" + data.Month + "/" + data.Year;
                trasmissioneSingola.dataScadenza = dataScadenza;
            }

            // Aggiungo la lista di trasmissioniUtente
            if (corr is DocsPaVO.utente.Ruolo)
            {
                trasmissioneSingola.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.RUOLO;

                DocsPaVO.utente.Corrispondente[] listaUtenti = queryUtenti(infoUtente, corr);

                if (listaUtenti.Length == 0)
                {
                    trasmissioneSingola = null;
                }

                //ciclo per utenti se dest è gruppo o ruolo
                for (int i = 0; i < listaUtenti.Length; i++)
                {
                    DocsPaVO.trasmissione.TrasmissioneUtente trasmissioneUtente = new DocsPaVO.trasmissione.TrasmissioneUtente();
                    trasmissioneUtente.utente = (DocsPaVO.utente.Utente)listaUtenti[i];
                    trasmissioneSingola.trasmissioneUtente.Add(trasmissioneUtente);
                }
            }

            if (corr is DocsPaVO.utente.Utente)
            {
                trasmissioneSingola.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.UTENTE;
                DocsPaVO.trasmissione.TrasmissioneUtente trasmissioneUtente = new DocsPaVO.trasmissione.TrasmissioneUtente();
                trasmissioneUtente.utente = (DocsPaVO.utente.Utente)corr;
                trasmissioneSingola.trasmissioneUtente.Add(trasmissioneUtente);
            }

            if (corr is DocsPaVO.utente.UnitaOrganizzativa)
            {
                DocsPaVO.utente.UnitaOrganizzativa theUo = (DocsPaVO.utente.UnitaOrganizzativa)corr;
                DocsPaVO.addressbook.QueryCorrispondenteAutorizzato qca = new DocsPaVO.addressbook.QueryCorrispondenteAutorizzato();
                qca.ragione = trasmissioneSingola.ragione;
                qca.ruolo   = trasmissione.ruolo;

                System.Collections.ArrayList ruoli = BusinessLogic.Utenti.addressBookManager.getRuoliRiferimentoAutorizzati(qca, theUo);
                foreach (DocsPaVO.utente.Ruolo r in ruoli)
                {
                    trasmissione = addTrasmissioneSingola(infoUtente, trasmissione, r, ragione, note, tipoTrasm, scadenza);
                }

                return(trasmissione);
            }

            if (trasmissioneSingola != null)
            {
                trasmissione.trasmissioniSingole.Add(trasmissioneSingola);
            }

            return(trasmissione);
        }
Пример #18
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="serverName"></param>
        /// <param name="path"></param>
        /// <param name="messaggio"></param>
        /// <param name="infoUtente"></param>
        /// <param name="ruolo"></param>
        /// <param name="registro"></param>
        /// <param name="destinatario"></param>
        private static void processaMessaggio(string serverName, string path, ZfLib.Message messaggio, DocsPaVO.utente.InfoUtente infoUtente, DocsPaVO.utente.Ruolo ruolo, DocsPaVO.utente.Registro registro, DocsPaVO.utente.Corrispondente destinatario)
        {
            logger.Debug("processaMessaggio");
            System.IO.FileStream fs = null;
            bool daAggiornareUffRef = false;
            bool dbOpen             = false;
            bool fsOpen             = false;

            try
            {
                //informazioni sul fax
                string dataRic = messaggio.GetMsgHistories()[0].Date.ToString();
                logger.Debug(" @ dataric = " + dataRic);

                //accesso al file del fax
                fs = getFileStream(path + messaggio.GetMsgInfo().Body);              //=new System.IO.FileStream(path+messaggio.GetMsgInfo().Body+".G3N",System.IO.FileMode.Open,System.IO.FileAccess.ReadWrite,System.IO.FileShare.ReadWrite);

                logger.Debug(fs.CanRead.ToString() + "@ OK @");
                fsOpen = true;

                //creazione scheda documento
                DocsPaVO.documento.SchedaDocumento sd = new DocsPaVO.documento.SchedaDocumento();
                sd.idPeople = infoUtente.idPeople;

                logger.Debug("sd.idPeople = " + sd.idPeople.ToString());

                sd.userId = infoUtente.userId;
                logger.Debug("sd.userId = " + sd.userId.ToString());
                DocsPaVO.documento.Oggetto ogg = new DocsPaVO.documento.Oggetto();
                ogg.descrizione = "Fax ricevuto in data " + dataRic;              //DA COMPLETARE
                sd.oggetto      = ogg;
                sd.predisponiProtocollazione = true;
                sd.registro  = registro;
                sd.tipoProto = "A";
                sd.typeId    = "MAIL";

                //aggiunta protocollo entrata
                DocsPaVO.documento.ProtocolloEntrata protEntr = new DocsPaVO.documento.ProtocolloEntrata();
                DocsPaVO.utente.Corrispondente       mittente = new DocsPaVO.utente.Corrispondente();
                mittente.descrizione = messaggio.GetMsgInfo().Comment;
                logger.Debug(" @ mittente.descrizione = " + mittente.descrizione);               //"QUI SI METTONO INFORMAZIONI";
                protEntr.mittente = mittente;

                sd.protocollo = protEntr;
                protEntr.dataProtocollazione = System.DateTime.Today.ToString();
                sd.appId = "ACROBAT";
                sd       = BusinessLogic.Documenti.DocSave.addDocGrigia(sd, infoUtente, ruolo);
                logger.Debug("Salvataggio doc...");
                sd = BusinessLogic.Documenti.DocSave.save(infoUtente, sd, false, out daAggiornareUffRef, ruolo);
                logger.Debug("Salvataggio eseguito");
                DocsPaVO.documento.FileDocumento fd = new DocsPaVO.documento.FileDocumento();
                byte[] buffer = new byte[fs.Length];
                fs.Read(buffer, 0, (int)fs.Length);
                fd.content = buffer;
                fd.length  = buffer.Length;
                fd.name    = "fax.tif";

                BusinessLogic.Documenti.FileManager.putFile((DocsPaVO.documento.FileRequest)sd.documenti[0], fd, infoUtente);
                logger.Debug("Documento inserito");
                fs.Close();
                fsOpen = false;

                //TRASMISSIONE
                DocsPaVO.trasmissione.Trasmissione trasm = new DocsPaVO.trasmissione.Trasmissione();
                trasm.ruolo = ruolo;
                //db.openConnection();
                dbOpen       = true;
                trasm.utente = BusinessLogic.Utenti.UserManager.getUtente(infoUtente.idPeople);
                DocsPaVO.documento.InfoDocumento infoDoc = new DocsPaVO.documento.InfoDocumento();
                infoDoc.idProfile   = sd.systemId;
                infoDoc.docNumber   = sd.docNumber;
                infoDoc.oggetto     = sd.oggetto.descrizione;
                infoDoc.tipoProto   = "A";
                trasm.infoDocumento = infoDoc;
                //costruzione singole trasmissioni
                DocsPaVO.trasmissione.RagioneTrasmissione ragione = getRagioneTrasm();
                System.Collections.ArrayList dest = new System.Collections.ArrayList();
                dest.Add(destinatario);
                System.Collections.ArrayList trasmissioniSing = new System.Collections.ArrayList();

                for (int i = 0; i < dest.Count; i++)
                {
                    DocsPaVO.trasmissione.TrasmissioneSingola trSing = new DocsPaVO.trasmissione.TrasmissioneSingola();
                    trSing.ragione = ragione;
                    logger.Debug(dest[i].GetType().ToString());
                    if (dest[i].GetType().Equals(typeof(DocsPaVO.utente.Ruolo)))
                    {
                        logger.Debug("ruolo");
                        trSing.corrispondenteInterno = (DocsPaVO.utente.Ruolo)dest[i];
                    }
                    else
                    {
                        logger.Debug("utente");
                        trSing.corrispondenteInterno = (DocsPaVO.utente.Utente)dest[i];
                    }
                    logger.Debug("ok");
                    trSing.tipoTrasm = "S";
                    if (dest[i].GetType().Equals(typeof(DocsPaVO.utente.Ruolo)))
                    {
                        logger.Debug("caso ruolo");
                        trSing.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.RUOLO;
                        //ricerca degli utenti del ruolo
                        System.Collections.ArrayList             utenti = new System.Collections.ArrayList();
                        DocsPaVO.addressbook.QueryCorrispondente qc     = new DocsPaVO.addressbook.QueryCorrispondente();
                        qc.codiceRubrica = ((DocsPaVO.utente.Ruolo)dest[i]).codiceRubrica;
                        System.Collections.ArrayList registri = new System.Collections.ArrayList();
                        registri.Add(registro.systemId);
                        qc.idRegistri        = registri;
                        qc.idAmministrazione = registro.idAmministrazione;
                        qc.getChildren       = true;
                        utenti = BusinessLogic.Utenti.addressBookManager.listaCorrispondentiIntMethod(qc);
                        System.Collections.ArrayList trasmissioniUt = new System.Collections.ArrayList();
                        for (int k = 0; k < utenti.Count; k++)
                        {
                            DocsPaVO.trasmissione.TrasmissioneUtente trUt = new DocsPaVO.trasmissione.TrasmissioneUtente();
                            trUt.utente = (DocsPaVO.utente.Utente)utenti[k];
                            trasmissioniUt.Add(trUt);
                        }
                        trSing.trasmissioneUtente = trasmissioniUt;
                    }
                    else
                    {
                        logger.Debug("Caso utente");
                        trSing.tipoDest = DocsPaVO.trasmissione.TipoDestinatario.UTENTE;
                        System.Collections.ArrayList             trasmissioniUt = new System.Collections.ArrayList();
                        DocsPaVO.trasmissione.TrasmissioneUtente trUt           = new DocsPaVO.trasmissione.TrasmissioneUtente();
                        trUt.utente = (DocsPaVO.utente.Utente)dest[i];
                        trasmissioniUt.Add(trUt);
                        trSing.trasmissioneUtente = trasmissioniUt;
                    }
                    trasmissioniSing.Add(trSing);
                }

                trasm.trasmissioniSingole = trasmissioniSing;
                if (infoUtente.delegato != null)
                {
                    trasm.delegato = ((DocsPaVO.utente.InfoUtente)(infoUtente.delegato)).idPeople;
                }
                //BusinessLogic.Trasmissioni.TrasmManager.saveTrasmMethod(trasm);
                //BusinessLogic.Trasmissioni.ExecTrasmManager.executeTrasmMethod(serverName,trasm);
                BusinessLogic.Trasmissioni.ExecTrasmManager.saveExecuteTrasmMethod(serverName, trasm);
            }
            catch (Exception e)
            {
                logger.Debug(e.Message);
                if (fsOpen)
                {
                    fs.Close();
                }
                if (dbOpen)
                {
                    //db.closeConnection();
                }

                logger.Debug("Errore nella gestione dei fax (processaMessaggio)", e);
                throw e;
            }
        }
Пример #19
0
        /// <summary>
        /// Tramissione di un fascicolo usando un modello di trasmissione
        /// Il parametro "idStato" puo' essere null o meno a seconda delle necessità
        /// </summary>
        /// <returns></returns>
        private void EffettuaTrasmissioneDaModello(
            DocsPaVO.utente.InfoUtente infoUtente,
            DocsPaVO.Modelli_Trasmissioni.ModelloTrasmissione modello,
            string idOggetto,
            DocsPaVO.trasmissione.TipoOggetto tipoOggetto)
        {
            DocsPaVO.trasmissione.Trasmissione trasmissione = new DocsPaVO.trasmissione.Trasmissione();

            trasmissione.noteGenerali = modello.VAR_NOTE_GENERALI;

            DocsPaVO.documento.SchedaDocumento schedaDocumento = null;
            DocsPaVO.fascicolazione.Fascicolo  schedaFascicolo = null;

            if (tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO)
            {
                trasmissione.tipoOggetto = DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO;

                schedaDocumento = BusinessLogic.Documenti.DocManager.getDettaglio(infoUtente, idOggetto, idOggetto);

                trasmissione.infoDocumento = new DocsPaVO.documento.InfoDocumento(schedaDocumento);
            }
            else if (tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.FASCICOLO)
            {
                trasmissione.tipoOggetto = DocsPaVO.trasmissione.TipoOggetto.FASCICOLO;

                schedaFascicolo = BusinessLogic.Fascicoli.FascicoloManager.getFascicoloById(idOggetto, infoUtente);

                trasmissione.infoFascicolo = new DocsPaVO.fascicolazione.InfoFascicolo(schedaFascicolo);
            }

            trasmissione.utente = BusinessLogic.Utenti.UserManager.getUtente(infoUtente.idPeople);
            trasmissione.ruolo  = BusinessLogic.Utenti.UserManager.getRuoloById(infoUtente.idCorrGlobali);

            if (modello != null)
            {
                trasmissione.NO_NOTIFY = modello.NO_NOTIFY;
            }

            //Parametri delle trasmissioni singole
            foreach (DocsPaVO.Modelli_Trasmissioni.RagioneDest ragioneDest in modello.RAGIONI_DESTINATARI)
            {
                foreach (DocsPaVO.Modelli_Trasmissioni.MittDest mittDest in ragioneDest.DESTINATARI)
                {
                    DocsPaVO.utente.Corrispondente corr = new DocsPaVO.utente.Corrispondente();

                    if (mittDest.CHA_TIPO_MITT_DEST == "D")
                    {
                        corr = BusinessLogic.Utenti.UserManager.getCorrispondenteByCodRubrica(mittDest.VAR_COD_RUBRICA, DocsPaVO.addressbook.TipoUtente.INTERNO, infoUtente);
                    }
                    else
                    {
                        if (tipoOggetto == DocsPaVO.trasmissione.TipoOggetto.DOCUMENTO)
                        {
                            corr = GetCorrispondente(infoUtente,
                                                     mittDest.CHA_TIPO_MITT_DEST,
                                                     schedaDocumento.creatoreDocumento.idPeople,
                                                     schedaDocumento.creatoreDocumento.idCorrGlob_Ruolo,
                                                     schedaDocumento.creatoreDocumento.idCorrGlob_UO,
                                                     trasmissione);
                        }
                        else
                        {
                            corr = GetCorrispondente(infoUtente,
                                                     mittDest.CHA_TIPO_MITT_DEST,
                                                     schedaFascicolo.creatoreFascicolo.idPeople,
                                                     schedaFascicolo.creatoreFascicolo.idCorrGlob_Ruolo,
                                                     schedaFascicolo.creatoreFascicolo.idCorrGlob_UO,
                                                     trasmissione);
                        }
                    }

                    if (corr != null)
                    {
                        DocsPaVO.trasmissione.RagioneTrasmissione ragione = BusinessLogic.Trasmissioni.QueryTrasmManager.getRagioneById(mittDest.ID_RAGIONE.ToString());

                        trasmissione = AddTrasmissioneSingola(infoUtente, trasmissione, corr, ragione, mittDest.VAR_NOTE_SING, mittDest.CHA_TIPO_TRASM, mittDest.SCADENZA);
                    }
                }
            }

            trasmissione = ImpostaNotificheUtentiDaModello(infoUtente, trasmissione, modello);
            trasmissione = BusinessLogic.Trasmissioni.ExecTrasmManager.saveExecuteTrasmMethod(string.Empty, trasmissione);
        }
Пример #20
0
        /// <summary>
        /// MEV SMISTAMENTO
        /// Metodo per l'esecuzione della ricerca da mobile
        /// E' seguita la stessa logica della versione desktop
        /// </summary>
        /// <param name="descrizione"></param>
        /// <param name="infoUtente"></param>
        /// <param name="idRegistro"></param>
        /// <param name="idRuolo"></param>
        /// <param name="ragione"></param>
        /// <param name="numMaxResults"></param>
        /// <returns></returns>
        public static List <RicercaSmistamentoElement> GetListaCorrispondentiVeloce(string descrizione, InfoUtente infoUtente, string idRegistro, string idRuolo, string ragione, int numMaxResults)
        {
            DocsPaVO.rubrica.ParametriRicercaRubrica qco = new DocsPaVO.rubrica.ParametriRicercaRubrica();

            List <RicercaSmistamentoElement> elements = new List <RicercaSmistamentoElement>();

            qco.caller            = new DocsPaVO.rubrica.ParametriRicercaRubrica.CallerIdentity();
            qco.parent            = "";
            qco.caller.IdRuolo    = idRuolo;
            qco.caller.IdRegistro = idRegistro;
            qco.descrizione       = descrizione;

            #region RAGIONE DI TRASMISSIONE

            DocsPaVO.amministrazione.InfoAmministrazione amm = BusinessLogic.Amministrazione.AmministraManager.AmmGetInfoAmmCorrente(infoUtente.idAmministrazione);
            string idRagione = string.Empty;
            switch (ragione)
            {
            case "comp":
                idRagione = amm.IDRagioneCompetenza;
                break;

            case "con":
                idRagione = amm.IDRagioneConoscenza;
                break;
            }
            DocsPaVO.trasmissione.RagioneTrasmissione ragTrasm = BusinessLogic.Trasmissioni.QueryTrasmManager.getRagioneById(idRagione);
            switch (ragTrasm.tipoDestinatario.ToString("g").Substring(0, 1))
            {
            case "T":
                qco.calltype = DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_ALL;
                break;

            case "I":
                qco.calltype = DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_INF;
                break;

            case "S":
                qco.calltype = DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_SUP;
                break;

            case "P":
                qco.calltype = DocsPaVO.rubrica.ParametriRicercaRubrica.CallType.CALLTYPE_TRASM_PARILIVELLO;
                break;
            }
            #endregion

            bool       abilitazioneRubricaComune = BusinessLogic.RubricaComune.Configurazioni.GetConfigurazioni(infoUtente).GestioneAbilitata;
            Registro[] regTemp = (Registro[])BusinessLogic.Utenti.RegistriManager.getListaRegistriRfRuolo(idRuolo, "", "").ToArray(typeof(Registro));

            //Prendo soltanto i corrispondenti del mio registro e di tutti i miei rf se presenti
            #region registro
            Registro[] regOnliyTemp = null;
            if (regTemp != null && regTemp.Length > 0)
            {
                int countReg = 0;
                regOnliyTemp = new Registro[regTemp.Length];
                for (int y = 0; y < regTemp.Length; y++)
                {
                    if ((!string.IsNullOrEmpty(regTemp[y].chaRF) && regTemp[y].chaRF.Equals("1")) || regTemp[y].systemId.Equals(qco.caller.IdRegistro))
                    {
                        regOnliyTemp[countReg] = regTemp[y];
                        countReg++;
                    }
                }
            }
            string retValue = string.Empty;

            foreach (Registro item in regOnliyTemp)
            {
                if (item != null)
                {
                    retValue += " " + item.systemId + ",";
                }
            }
            if (retValue.EndsWith(","))
            {
                retValue = retValue.Remove(retValue.LastIndexOf(","));
            }

            qco.caller.filtroRegistroPerRicerca = retValue;
            #endregion

            qco.tipoIE          = DocsPaVO.addressbook.TipoUtente.INTERNO;
            qco.doRuoli         = true;
            qco.doUo            = true;
            qco.doUtenti        = true;
            qco.doListe         = true;
            qco.doRF            = false;
            qco.doRubricaComune = false;

            qco.ObjectType = string.Empty;

            string[] res = GetElementiRubricaVeloce(infoUtente, qco);
            int      i   = 0;

            //filtro i risultati cone nel frontend

            //response
            if (res != null && res.Count() > 0)
            {
                foreach (string s in res)
                {
                    RicercaSmistamentoElement el = new RicercaSmistamentoElement();
                    string desc     = s.Split('§')[0];
                    string sysId    = s.Split('§')[1];
                    string tipo     = s.Split('§')[2];
                    string idPeople = s.Split('§')[3];

                    // UTENTE
                    if (tipo.Equals("P"))
                    {
                        el = AggiungiElementoRicerca(idPeople, tipo, infoUtente, idRegistro);

                        if (el != null)
                        {
                            el.DescrizioneUtente = desc;
                            //el.IdUtente = sysId;
                            el.Type = SmistamentoNodeType.UTENTE;
                        }
                    }
                    // RUOLO
                    else if (tipo.Equals("R"))
                    {
                        el = AggiungiElementoRicerca(sysId, tipo, infoUtente, idRegistro);

                        if (el != null)
                        {
                            el.DescrizioneRuolo = desc;
                            //el.IdRuolo = sysId;
                            el.Type = SmistamentoNodeType.RUOLO;
                        }
                    }
                    // UO
                    else
                    {
                        if (el != null)
                        {
                            el.DescrizioneUO = desc;
                            el.IdUO          = sysId;
                            el.Type          = SmistamentoNodeType.UO;
                        }
                    }
                    if (i < numMaxResults)
                    {
                        if (el != null)
                        {
                            elements.Add(el);
                            i++;
                        }
                    }
                    else
                    {
                        break;
                    }
                }
            }

            return(elements);
        }