示例#1
0
        protected void Page_Load(object sender, EventArgs e)
        {
            _service = new biz.archiva.servizi.ArchivaASP {Timeout = 60*60*1000};

            long mRsaKeyLength = 0;

            //=========================================================================
            // OGGETTI PER CRITTOGRAFIA
            //=========================================================================
            // ottengo la chiave pubblica del server
            var sKey = "";
            if (_service.GetKey(ref sKey, ref mRsaKeyLength) != 0)
                return;

            // creo il servizio RSA per il server
            _mRsaServer = new RSACryptoServiceProvider((int)mRsaKeyLength);
            var serverKey = (ArchivaASP_KEY)ArchivaASP_SERIALIZER.DeserializeObject(sKey, typeof(ArchivaASP_KEY));
            var serverParameters = new RSAParameters {Exponent = serverKey.Exp, Modulus = serverKey.Mod};
            _mRsaServer.ImportParameters(serverParameters);

            //=========================================================================
            // LOGIN
            //=========================================================================

            // creo il servizio RSA per il client
            _mRsaClient = new RSACryptoServiceProvider((int)mRsaKeyLength);
            var rsaParam = _mRsaClient.ExportParameters(false);
            _mUserKey = new ArchivaASP_KEY {Mod = rsaParam.Modulus, Exp = rsaParam.Exponent};

            // creo la struttura dei parametri
            _mUserSession = new ArchivaASP_LOGIN { SessionId = 0, Application = "STUDIOZENITHWEB", User = "******", Password = "******" };

            // creo una index list vuota
            var indexList = new ArchivaASP_INDEXLIST();

            // Crypto service
            var crypto = new ArchivaASP_CRY();

            // cripto la descrizione XML dei parametri
            byte[] abXmlUserSession = crypto.EncryptXML(_mUserSession, _mUserSession.GetType(), _mRsaServer);
            // cripto la chiave del client XML dei parametri
            byte[] abXmlUserKey = crypto.EncryptXML(_mUserKey, _mUserKey.GetType(), _mRsaServer);

            byte[] abXmlIndexList;

            // effettuo il login
            long lLoginError = _service.Login(ref abXmlUserSession, abXmlUserKey, out abXmlIndexList);

            // decripto le info di login
            if (lLoginError == 0)
            {
                _mUserSession = (ArchivaASP_LOGIN)crypto.DecryptXML(abXmlUserSession, typeof(ArchivaASP_LOGIN), _mRsaClient);
                indexList = (ArchivaASP_INDEXLIST)crypto.DecryptXML(abXmlIndexList, typeof(ArchivaASP_INDEXLIST), _mRsaClient);
            }

            //=========================================================================
            // ESECUZIONE DELLA RICERCA - I PARAMETRI DEVONO SELEZIONARE UN SOLO DOCUMENTO
            //=========================================================================

            // cripto la descrizione XML dei parametri
            abXmlUserSession = crypto.EncryptXML(_mUserSession, typeof(ArchivaASP_LOGIN), _mRsaServer);
            // cripto la index list XML dei parametri
            indexList.Indexes.Clear();
            indexList.Indexes.Add("CONTRATTI");
            abXmlIndexList = crypto.EncryptXML(indexList, typeof(ArchivaASP_INDEXLIST), _mRsaServer);

            // campi da visualizzare
            var fieldList = new ArchivaASP_FIELDLIST();
            fieldList.Fields.Add("IDENTIFICATIVO UNIVOCO");

            // TODO: Impostare qui i parametri di ricerca
            string parameters = "=(IDENTIFICATIVO UNIVOCO, #ZETH0000200005#)";

            // cripto la condizione XML dei parametri
            byte[] abXmlFieldCondition = crypto.EncryptXML(parameters, typeof(String), _mRsaServer);
            // cripto la lista dei campi fornibili XML dei parametri
            byte[] abXmlFieldName = crypto.EncryptXML(fieldList, typeof(ArchivaASP_FIELDLIST), _mRsaServer);

            byte[] abXmlResultNum;

            var lSearchError = _service.SearchDocument(abXmlUserSession, abXmlIndexList, abXmlFieldCondition, abXmlFieldName, out abXmlResultNum);

            //=========================================================================
            // LETTURA DEL CODICE DOCUMENTO CHE DEVE ESSERE APERTO
            //=========================================================================
            
            // numero di documenti per pagina
            const int nPageSize = 10;
            // numero di pagina
            const int nPageNum = 0;


            // campi risultanti
            var FieldResult = new ArchivaASP_FIELDVALUE();

            // cripto la descrizione XML dei parametri
            abXmlUserSession = crypto.EncryptXML(_mUserSession, typeof(ArchivaASP_LOGIN), _mRsaServer);
            // cripto la index list XML dei parametri
            byte[] abXmlPageNum = crypto.EncryptXML(nPageNum, typeof(Int32), _mRsaServer);
            // cripto la condizione XML dei parametri
            byte[] abXmlPageSize = crypto.EncryptXML(nPageSize, typeof(Int32), _mRsaServer);

            byte[] abXmlFieldResult;

            lSearchError = _service.GetSearchDocument(abXmlUserSession, abXmlPageNum, abXmlPageSize, out abXmlFieldResult);
            
            string sError = ""; 
            if (lSearchError != 0)
            {
                _service.GetErrorDescription(lSearchError, ref sError);
                string errore = sError;
            }

            // decripto le info 
            FieldResult = (ArchivaASP_FIELDVALUE)crypto.DecryptXML(abXmlFieldResult, typeof(ArchivaASP_FIELDVALUE), _mRsaClient);

            var codDoc = (string)((ArchivaASP_FIELDLIST)FieldResult.FieldValues[0]).Fields[0];

            //=========================================================================
            // LETTURA DOCUMENTO
            //=========================================================================

            byte[] abDocumentBuffer;

            // creo una index list con la lista selezionata
            indexList.Indexes.Clear();
            indexList.Indexes.Add("CONTRATTI");

            // cripto la descrizione XML dei parametri
            abXmlUserSession = crypto.EncryptXML(_mUserSession, typeof(ArchivaASP_LOGIN), _mRsaServer);
            // cripto il codice del documento in XML
            var abXmlDocumentCode = crypto.EncryptXML(codDoc, typeof(String), _mRsaServer);
            // cripto la index list XML dei parametri
            abXmlIndexList = crypto.EncryptXML(indexList, typeof(ArchivaASP_INDEXLIST), _mRsaServer);

            lSearchError = _service.GetDocument(abXmlUserSession, abXmlDocumentCode, out abDocumentBuffer);

            if (!_service.DocumentAccessibility(abXmlUserSession, abXmlDocumentCode))
                return;

            if (lSearchError != 0)
            {
                sError = "";
                _service.GetErrorDescription(lSearchError, ref sError);

                return;
            }
            // decripto le info 
            abDocumentBuffer = (byte[])crypto.DecryptXML(abDocumentBuffer, abDocumentBuffer.GetType(), _mRsaClient);

            Response.Clear();
            Response.ContentType = "application/pdf";
            Response.BinaryWrite(abDocumentBuffer);
            Response.End();
        }
示例#2
0
        private void btnGetPage_Click(object sender, EventArgs e)
        {
            long lSearchError;

            if (lstIndex.Items.Count == 0)
                return;

            try
            {
                // numero di documenti per pagina
                Int32 nPageSize = Int32.Parse(txtPageSize.Text);
                // numero di pagina
                Int32 nPageNum = Int32.Parse(txtPageNum.Text);

                // creo il crypto service
                ArchivaASP_CRY Crypto = new ArchivaASP_CRY();

                // campi risultanti
                ArchivaASP_FIELDVALUE FieldResult = new ArchivaASP_FIELDVALUE();

                // cripto la descrizione XML dei parametri
                byte[] abXmlUserSession = Crypto.EncryptXML(m_UserSession, typeof(ArchivaASP_LOGIN), m_RSA_Server);
                // cripto la index list XML dei parametri
                byte[] abXmlPageNum = Crypto.EncryptXML(nPageNum, typeof(Int32), m_RSA_Server);
                // cripto la condizione XML dei parametri
                byte[] abXmlPageSize = Crypto.EncryptXML(nPageSize, typeof(Int32), m_RSA_Server);

                byte[] abXmlFieldResult = null;

                this.Cursor = Cursors.WaitCursor;
                lSearchError = m_ArchivaASP.GetSearchDocument(abXmlUserSession, abXmlPageNum, abXmlPageSize, out abXmlFieldResult);
                this.Cursor = Cursors.Default;
                if (lSearchError != 0)
                {
                    string sError = "";
                    m_ArchivaASP.GetErrorDescription(lSearchError, ref sError);

                    MessageBox.Show(sError, "GetSearchDocument Fault", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }
                else
                {
                    // decripto le info 
                    this.Cursor = Cursors.WaitCursor;
                    FieldResult = (ArchivaASP_FIELDVALUE)Crypto.DecryptXML(abXmlFieldResult, typeof(ArchivaASP_FIELDVALUE), m_RSA_Client);

                    // layout
                    lstResult.Clear();
                    lstResult.Columns.Clear();
                    for (int i = 0; i < FieldResult.FieldNames.Fields.Count; i++)
                    {
                        ColumnHeader chTmp = new ColumnHeader();

                        chTmp.Text = (String)FieldResult.FieldNames.Fields[i];
                        chTmp.TextAlign = HorizontalAlignment.Left;
                        //chTmp.Width = lstResult.Width / FieldResult.FieldName.Fields.Count;
                        chTmp.Width = 100;

                        lstResult.Columns.Add(chTmp);
                    }

                    // visualizzo i record
                    lstResult.Items.Clear();
                    for (int l = 0; l < FieldResult.FieldValues.Count; l++)
                    {
                        ArchivaASP_FIELDLIST tmp = (ArchivaASP_FIELDLIST)FieldResult.FieldValues[l];

                        string[] sValues = new string[FieldResult.FieldNames.Fields.Count];
                        for (int u = 0; u < FieldResult.FieldNames.Fields.Count; u++)
                            sValues[u] = (string)tmp.Fields[u];

                        lstResult.Items.Add(new ListViewItem(sValues));
                    }
                    this.Cursor = Cursors.Default;
                }
            }
            catch (Exception)
            {
                MessageBox.Show("GetSearchDocument Exception", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
        }