← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ginkgocadx/trusty

« back to all changes in this revision

Viewing changes to src/cadxcore/commands/comandopacs.cpp

  • Committer: Package Import Robot
  • Author(s): Dmitry Smirnov
  • Date: 2013-07-21 11:58:53 UTC
  • mfrom: (7.2.1 sid)
  • Revision ID: package-import@ubuntu.com-20130721115853-44e7n1xujqglu78e
Tags: 3.4.0.928.29+dfsg-1
* New upstream release [July 2013]
  + new B-D: "libjsoncpp-dev".
  + new patch "unbundle-libjsoncpp.patch" to avoid building bundled
    "libjsoncpp-dev".
  + new patch "fix-wx.patch" to avoid FTBFS due to missing
    "-lwx_gtk2u_html-2.8".
* Removed unnecessary versioned Build-Depends.
* Removed obsolete lintian override.
* Reference get-orig-source implementation for orig.tar clean-up and
  DFSG-repackaging.
* Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cadxcore/commands/comandopacs.cpp
12
12
*/
13
13
//#define _GINKGO_TRACE
14
14
 
15
 
/*
16
 
#include <wx/filename.h>
17
 
#include <wx/dir.h>
18
 
#include <wx/progdlg.h>
19
 
#include <wx/log.h>
20
 
#include <wx/msgdlg.h>
21
 
*/
 
15
#include <sstream>
 
16
#include <map>
 
17
 
22
18
#include <api/api.h>
23
19
#include <api/globals.h>
 
20
#include <api/ientorno.h>
24
21
 
 
22
#include <api/controllers/icontroladorlog.h>
 
23
#include <main/controllers/commandcontroller.h>
25
24
#include <api/controllers/ieventscontroller.h>
 
25
#include <api/controllers/icontroladorpermisos.h>
26
26
 
27
27
#include <eventos/mensajes.h>
28
28
 
29
 
#include <main/entorno.h>
30
 
#include <main/controllers/controladoreventos.h>
31
 
#include <main/controllers/controladorcomandos.h>
32
 
#include <main/controllers/controladorpermisos.h>
33
 
#include <main/controllers/pacscontroller.h>
34
 
#include <main/controllers/controladorlog.h>
35
29
#include <main/controllers/dcmtk/dicomservers.h>
36
 
#include <main/controllers/controladorvistas.h>
37
30
 
38
31
#include "comandopacs.h"
39
32
#include "comandoincluirhistorial.h"
40
33
 
41
 
#include <sstream>
42
 
#include <map>
43
34
 
44
35
 
45
36
#define IDC_PACS_BUSCAR                  61
46
37
#define IDC_PACS_DESCARGAR               62
47
 
#define IDC_PACS_ABORTAR_TODOS           63
48
38
#define IDC_PACS_SUBIR                           64
49
39
 
50
40
#define ID_REFRESCO_PROGRESO 1
54
44
// Singleton de persistencia
55
45
namespace GADAPI
56
46
{
 
47
        ComandoPACSParams::ComandoPACSParams(const std::string& pacienteID, const std::string& pacienteNombre, const std::string& studyUID,
 
48
                const std::string& estudioAccNumber, const std::string& estudioModalidad, const std::string& estudioFechaDesde,
 
49
                const std::string& estudioFechaHasta, const std::string& studyTimeFrom, const std::string& studyTimeTo, const std::string& serverSeleccionado,
 
50
                TipoAmbito ambito, GNC::GCS::Ptr<IModeloDicom> pModeloDicom, GADAPI::PACS::IComandoPACSNotificador* pNotificador) :
 
51
                m_pacienteID(pacienteID),
 
52
                m_pacienteNombre(pacienteNombre),
 
53
                m_studyUID(studyUID),
 
54
                m_accessionNumber(estudioAccNumber),
 
55
                m_estudioModalidad(estudioModalidad),
 
56
                m_estudioFechaDesde(estudioFechaDesde),
 
57
                m_estudioFechaHasta(estudioFechaHasta),
 
58
                m_studyTimeFrom(studyTimeFrom),
 
59
                m_studyTimeTo(studyTimeTo),
 
60
                m_pNotificador(pNotificador),
 
61
                m_pModelo(pModeloDicom),
 
62
                m_Ambito(ambito)
 
63
        {
 
64
                        
 
65
                if(serverSeleccionado == "") {
 
66
                        if(!DicomServerList::Instance()->Empty()) {
 
67
                                m_serverSeleccionado = DicomServerList::Instance()->GetDefaultServer()->ID;
 
68
                        } else {
 
69
                                throw GIL::DICOM::PACSException(_Std("There is not any Remote PACS configured"));
 
70
                        }
 
71
                } else {
 
72
                        m_serverSeleccionado = serverSeleccionado;
 
73
                }
 
74
                m_informar=true;
 
75
                m_error = "";
 
76
        }
 
77
 
 
78
        ComandoPACSParams::~ComandoPACSParams() {
 
79
                m_pNotificador = NULL;
 
80
        }
 
81
 
57
82
 
58
83
        ComandoPACS::ComandoPACS(ComandoPACSParams* pParams) : IComando(pParams)
59
84
        {
60
 
                GTRACE(">> ComandoPACS::ComandoPACS(): " << this);
61
85
                m_pPACSParams = pParams;
62
 
                switch (m_pPACSParams->m_TipoAccion) {
63
 
                        //no es posible hacer dos comandos de estos en paralelo dcmtk no es multithread
64
 
                        case GADAPI::PACS::TAC_Buscar :
65
 
                                SetId(IDC_PACS_BUSCAR);
66
 
#if !defined(PARALLEL)
67
 
                                EsperaA(IDC_PACS_BUSCAR);
68
 
                                EsperaA(IDC_PACS_DESCARGAR);
69
 
                                EsperaA(IDC_PACS_SUBIR);
70
 
#endif
71
 
                                AbortaSi(IDC_PACS_ABORTAR_TODOS);
72
 
                                break;
73
 
                        case GADAPI::PACS::TAC_Descargar :
74
 
                                SetId(IDC_PACS_DESCARGAR);
75
 
                                EsperaA(IDC_PACS_DESCARGAR);
76
 
#if !defined(PARALLEL)
77
 
                                EsperaA(IDC_PACS_BUSCAR);
78
 
                                EsperaA(IDC_PACS_DESCARGAR);
79
 
                                EsperaA(IDC_PACS_SUBIR);
80
 
#endif
81
 
                                AbortaSi(IDC_PACS_ABORTAR_TODOS);
82
 
                                break;
83
 
                }
84
 
 
85
 
                GTRACE("<< ComandoPACS::ComandoPACS(): " << this);
 
86
                
 
87
                SetId(IDC_PACS_BUSCAR);
 
88
#if !defined(PARALLEL)
 
89
                EsperaA(IDC_PACS_BUSCAR);
 
90
                EsperaA(IDC_PACS_DESCARGAR);
 
91
                EsperaA(IDC_PACS_SUBIR);
 
92
#endif                          
86
93
        }
87
94
 
88
95
        void ComandoPACS::Execute()
89
96
        {
90
 
                if(m_pPACSParams->m_TipoAccion == GADAPI::PACS::TAC_Buscar)
91
 
                {
92
 
                        Search();
93
 
                } else if(m_pPACSParams->m_TipoAccion == GADAPI::PACS::TAC_Descargar){
94
 
                        Download();
95
 
                }
96
 
        }
97
 
 
98
 
        void ComandoPACS::Update()
99
 
        {
100
 
                GTRACE("UPDATE " << this);
101
 
 
102
 
                if (EstaAbortado()) {
103
 
                    return;
104
 
                }
105
 
                
106
 
                if(m_pPACSParams->m_TipoAccion == GADAPI::PACS::TAC_Buscar) {
107
 
                        GTRACE("buscar... " << this);
108
 
                        if(m_pPACSParams->m_pNotificador!=NULL){
109
 
                                GTRACE("cargamos listado de:... "<< m_pPACSParams->m_pModelo->ListaPacientes().size()<< " pacientes " << this);
110
 
                                if(m_pPACSParams->m_error!="" && m_pPACSParams->m_pModelo->ListaPacientes().size() == 0){
111
 
                                        if (m_pPACSParams->m_informar) {
112
 
                                                GNC::GCS::ControladorEventos::Instance()->ProcesarEvento(new GNC::GCS::Events::EventoMensajes(NULL, _Std("Failed to perform search: ") + "\n" + m_pPACSParams->m_error, GNC::GCS::Events::EventoMensajes::PopUpMessage,false, GNC::GCS::Events::EventoMensajes::Error));
113
 
                                        }
114
 
                                        m_pPACSParams->m_pNotificador->PACSCargarListado(m_pPACSParams->m_pModelo);
115
 
                                } else {
116
 
                                        m_pPACSParams->m_pNotificador->PACSCargarListado(m_pPACSParams->m_pModelo);
117
 
                                }
118
 
                        } else {
119
 
                                GTRACE("no hay notificador... " << this);
120
 
                        }
121
 
                }
122
 
                else if(m_pPACSParams->m_TipoAccion == GADAPI::PACS::TAC_Descargar) {
123
 
                        GTRACE("descargar... " << this);
124
 
 
125
 
                        if(m_pPACSParams->m_error!=""){
126
 
                                LOG_ERROR("C-MOVE/C-GET", "Error Downloading study: " << m_pPACSParams->m_error);
127
 
                                if (m_pPACSParams->m_informar) {
128
 
                                        GNC::GCS::ControladorEventos::Instance()->ProcesarEvento(new GNC::GCS::Events::EventoMensajes(NULL, _Std("Error downloading study: ") + "\n" + m_pPACSParams->m_error, GNC::GCS::Events::EventoMensajes::PopUpMessage,false, GNC::GCS::Events::EventoMensajes::Error));
129
 
                                }
130
 
                                return ;
131
 
                        }
132
 
                        else {
133
 
 
134
 
                                std::list<std::string> rutas;
135
 
                                std::string rutaImagen;
136
 
                                if (m_pPACSParams->m_pModelo.IsValid()) {
137
 
                                        //listamos las imagenes que nos hemos bajado
138
 
                                        for (IModeloDicom::ListaPacientesType::const_iterator it = m_pPACSParams->m_pModelo->ListaPacientes().begin(); it != m_pPACSParams->m_pModelo->ListaPacientes().end(); ++it) {
139
 
                                                const IModeloPaciente& p = *it;
140
 
                                                for (IModeloPaciente::ListaEstudiosType::const_iterator it2 = p.ListaEstudios().begin(); it2 != p.ListaEstudios().end(); ++it2) {
141
 
                                                        const IModeloEstudio& e = *it2;
142
 
                                                        for (IModeloEstudio::ListaSeriesType::const_iterator it3 = e.ListaSeries().begin(); it3 != e.ListaSeries().end(); ++it3) {
143
 
                                                                const IModeloSerie& s = *it3;
144
 
                                                                for (IModeloSerie::ListaImagenesType::const_iterator it4 = s.ListaImagenes().begin(); it4 != s.ListaImagenes().end(); ++it4) {
145
 
                                                                        const IModeloImagen& im = *it4;
146
 
                                                                        if(GIL::DICOM::PACSController::Instance()->GetRutaImagenTemp(p.GetUID(),e.GetUID(),s.GetUID(),im.GetUID(), rutaImagen)){
147
 
                                                                                rutas.push_back(rutaImagen);
148
 
                                                                        }
149
 
                                                                }
150
 
                                                        }
151
 
                                                }
152
 
                                        }
153
 
                                }
154
 
 
155
 
                                //si ha descargado algo...
156
 
                                if(rutas.empty()){
157
 
                                        LOG_WARN("C-MOVE/C-GET", _Std("No results obtained. Maybe you have a wrong PACS server configuration"));
158
 
                                        if (m_pPACSParams->m_informar) {
159
 
                                                GNC::GCS::ControladorEventos::Instance()->ProcesarEvento(new GNC::GCS::Events::EventoMensajes(NULL, _Std("No results obtained in PACS retrieve.\nMaybe study doesn't exist or you have a wrong PACS server configuration."), GNC::GCS::Events::EventoMensajes::PopUpMessage,false, GNC::GCS::Events::EventoMensajes::Error));
160
 
                                        }
161
 
                                        return;
162
 
                                }
163
 
 
164
 
                                //se lanza un evento para incluir las imagenes en el historial
165
 
                                GADAPI::ComandoIncluirHistorial::ComandoIncluirHistorialParams* pParams = new GADAPI::ComandoIncluirHistorial::ComandoIncluirHistorialParams(rutas);
166
 
                                pParams->m_informar = m_pPACSParams->m_informar;
167
 
                                GADAPI::ComandoIncluirHistorial::ComandoIncluirHistorial * pCmd = new GADAPI::ComandoIncluirHistorial::ComandoIncluirHistorial(pParams);
168
 
                                GNC::GCS::IControladorComandos::Instance()->ProcessAsync(_Std("Including files..."),pCmd,NULL);
169
 
                        }
170
 
                }
171
 
        }
172
 
 
173
 
        void ComandoPACS::Search()
174
 
        {
175
 
                GTRACE("Consultando pacs... " << this);
176
 
                std::string tarea=_Std("PACS Consulting ...");
 
97
                std::string tarea=_Std("Querying PACS ...");
177
98
                if (!NotificarProgreso(0.0f,tarea)) {
178
99
                    return;
179
100
                }
180
101
                GIL::DICOM::IPACSController* pCI = NULL;
181
102
                try {
182
103
 
183
 
                        pCI = GNC::Entorno::Instance()->GetPACSController();
 
104
                        pCI = GNC::GCS::IEntorno::Instance()->GetPACSController();
184
105
 
185
106
                        pCI->GetConnection(this);
186
107
 
240
161
                                                                m_pPACSParams->m_pModelo,this
241
162
                                                        );
242
163
                                                }
243
 
                                                GNC::Entorno::Instance()->GetPACSController()->BuscarSeries(
 
164
                                                GNC::GCS::IEntorno::Instance()->GetPACSController()->BuscarSeries(
244
165
                                                        this,
245
166
                                                        m_pPACSParams->m_serverSeleccionado, // Server ID
246
167
                                                        m_pPACSParams->m_studyUID,
254
175
                        }
255
176
                        GTRACE(m_pPACSParams->m_pModelo);
256
177
                } catch (GinkgoNoServerFoundException& ) {
257
 
                        GTRACE("excepción no server found... " << this);
258
178
                        m_pPACSParams->m_error= _Std("Server ID not found. ID = ") + m_pPACSParams->m_serverSeleccionado;
259
179
                        m_pPACSParams->m_pModelo->Error = true;
260
180
                } catch (GIL::DICOM::PACSException& ex) {
261
 
                        GTRACE("excepción pacsexception: " << ex << "            " << this);
262
181
                        m_pPACSParams->m_error= _Std("Query error with PACS Id ") + m_pPACSParams->m_serverSeleccionado + "\n" + (const std::string)ex;
263
182
                        m_pPACSParams->m_pModelo->Error = true;
264
183
                } catch (GIL::DICOM::ModelException& ex) {
265
 
                        GTRACE("excepción pacsexception: " << ex << "            " << this);
266
184
                        m_pPACSParams->m_error= _Std("Query error with PACS Id ") + m_pPACSParams->m_serverSeleccionado + "\n" + (const std::string)ex;
267
185
                        m_pPACSParams->m_pModelo->Error = true;
268
186
                } catch (std::exception& ex) {
269
 
                        GTRACE("excepción stdexception: "<< ex.what()<<"            " << this);
270
187
                        m_pPACSParams->m_error= _Std("Query error with PACS Id ") + m_pPACSParams->m_serverSeleccionado + "\n" + ex.what();
271
188
                        m_pPACSParams->m_pModelo->Error = true;
272
189
                } catch ( ... ) {
281
198
                }
282
199
        }
283
200
 
284
 
        void ComandoPACS::Download()
 
201
        void ComandoPACS::Update()
285
202
        {
286
 
                GTRACE("descargando...... " << this);
287
 
                std::string tarea= _Std("Downloading files ...");
288
 
                if (!NotificarProgreso(0.0f,tarea)) {
 
203
 
 
204
                if (EstaAbortado()) {
289
205
                    return;
290
206
                }
291
 
 
292
 
                GIL::DICOM::IPACSController* pCI = NULL;
293
 
 
294
 
                try {
295
 
                        pCI = GNC::Entorno::Instance()->GetPACSController();
296
 
                        pCI->GetConnection(this);
297
 
                        pCI->QueryRetrieve(this, m_pPACSParams->m_serverSeleccionado, m_pPACSParams->m_pModelo, m_pPACSParams->m_base, this);
298
 
                }
299
 
                catch (GinkgoNoServerFoundException& ) {
300
 
                        GTRACE("excepcion no server found... " << this);
301
 
                        m_pPACSParams->m_error= _Std("Server ID not found. ID = ") + m_pPACSParams->m_serverSeleccionado;
302
 
                        m_pPACSParams->m_pModelo->Error = true;
303
 
                }
304
 
                catch (GIL::DICOM::PACSException& ex) {
305
 
                        GTRACE("excepcion en pacs: " << ex << "            " << this);
306
 
                        m_pPACSParams->m_error =  (const std::string)ex;
307
 
                        m_pPACSParams->m_pModelo->Error = true;
308
 
                }
309
 
                catch (std::exception& ex) {
310
 
                        GTRACE("excepcion en pacs: " << ex.what() << "            " << this);
311
 
                        m_pPACSParams->m_error= ex.what();
312
 
                        m_pPACSParams->m_pModelo->Error = true;
313
 
                }
314
 
                catch (...)
315
 
                {
316
 
                        GTRACE("excepcion en pacs: Error interno            " << this);
317
 
                        m_pPACSParams->m_error= _Std("Internal Error");
318
 
                        m_pPACSParams->m_pModelo->Error = true;
319
 
                }
320
 
                if (pCI) {
321
 
                        pCI->ReleaseConnection(this);
322
 
                }
323
 
                GTRACE(m_pPACSParams->m_pModelo);
324
 
                NotificarProgreso(1.0f,tarea);
 
207
                                
 
208
                if(m_pPACSParams->m_pNotificador != NULL){
 
209
                        if(!m_pPACSParams->m_error.empty()){
 
210
                                LOG_ERROR("C-FIND", "Error searching on PACS:\n"  << m_pPACSParams->m_error);
 
211
                                if (m_pPACSParams->m_informar) {
 
212
                                        GNC::GCS::IEventsController::Instance()->ProcesarEvento(new GNC::GCS::Events::EventoMensajes(NULL, _Std("Failed to perform search: ") + "\n" + m_pPACSParams->m_error, GNC::GCS::Events::EventoMensajes::PopUpMessage,false, GNC::GCS::Events::EventoMensajes::Error));
 
213
                                }
 
214
                                m_pPACSParams->m_informar = false;
 
215
                                m_pPACSParams->m_pNotificador->PACSCargarListado(m_pPACSParams->m_pModelo);
 
216
                        } else {
 
217
                                m_pPACSParams->m_pNotificador->PACSCargarListado(m_pPACSParams->m_pModelo);
 
218
                        }
 
219
                } else {
 
220
                        // There is no notifier specified
 
221
                }
 
222
                
325
223
        }
326
224
 
 
225
 
327
226
        bool ComandoPACS::NotificarProgreso(float progresoNormalizado,const std::string &texto) {
328
227
                if (EstaAbortado())
329
228
                {