← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/cadxcore/main/controllers/dcmtk/dicomservers.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/main/controllers/dcmtk/dicomservers.cpp
18
18
#include <wx/textfile.h>
19
19
#include <wx/dir.h>
20
20
#include <main/controllers/configurationcontroller.h>
 
21
#include <main/controllers/controladorpermisos.h>
21
22
#include <main/entorno.h>
22
23
#include <api/globals.h>
23
24
 
 
25
 
 
26
WLConfig::WLConfig()
 
27
{
 
28
        this->useAbortMessage = this->useCompletedMessage = this->useInProgressMessage = false;
 
29
        this->useDICOMMPPS = true;
 
30
 
 
31
        GNC::GCS::Permisos::EstadoPermiso perm = GNC::GCS::IControladorPermisos::Instance()->Get("gnkwl.messages", "inprogress");
 
32
        if (perm) {
 
33
                this->inProgressTemplate = perm.GetRawValue();
 
34
        }
 
35
        perm = GNC::GCS::IControladorPermisos::Instance()->Get("gnkwl.messages", "completed");
 
36
        if (perm) {
 
37
                this->completedTemplate = perm.GetRawValue();
 
38
        }
 
39
        perm = GNC::GCS::IControladorPermisos::Instance()->Get("gnkwl.messages", "abort");
 
40
        if (perm) {
 
41
                this->abortTemplate = perm.GetRawValue();
 
42
        }
 
43
}
 
44
 
 
45
WLConfig::WLConfig( const WLConfig& o)
 
46
{
 
47
        *this = o;      
 
48
}
 
49
 
 
50
WLConfig& WLConfig::operator=(const WLConfig& o)
 
51
{
 
52
        this->abortTemplate = o.abortTemplate;
 
53
        this->completedTemplate = o.completedTemplate;
 
54
        this->inProgressTemplate = o.inProgressTemplate;
 
55
        this->useAbortMessage = o.useAbortMessage;
 
56
        this->useCompletedMessage = o.useCompletedMessage;
 
57
        this->useInProgressMessage = o.useInProgressMessage;
 
58
        this->useDICOMMPPS = o.useDICOMMPPS;
 
59
        return *this;
 
60
}
 
61
 
 
62
WLConfig::~WLConfig()
 
63
{
 
64
}
 
65
 
 
66
 
 
67
 
 
68
DicomServer::DicomServer(const std::string& ID, const std::string& AET, const std::string& HostName, int port, int Lossy, bool isDefault, int PDU, bool useTLS, const std::string& pacsUser, const std::string& pacsPass, TRetrieveMethod retrieveMethod, const std::string& wadoURI, bool retrSeries, bool reuseConnection, bool verify, const std::string& cert, const std::string& key, const std::string& defaultCharset) {
 
69
        this->ID = ID;
 
70
        this->AET = AET;
 
71
        this->HostName = HostName;
 
72
        this->Port = port;
 
73
        this->Lossy = Lossy;
 
74
        this->isDefault = isDefault;
 
75
        this->PDU = PDU;
 
76
 
 
77
        this->reuseConnection = reuseConnection;
 
78
        this->retrieveSeries = retrSeries;
 
79
        this->retrieveMethod = retrieveMethod;
 
80
        this->wadoURI = wadoURI;
 
81
 
 
82
        this->useTLS    = useTLS;
 
83
        this->pacsUser = pacsUser;
 
84
        this->pacsPass = pacsPass;
 
85
        this->verifyCredentials = verify;
 
86
        this->certificate = cert;
 
87
        this->privateKey  = key;
 
88
        this->defaultCharset = defaultCharset;
 
89
}
 
90
 
 
91
/**local server constructor*/
 
92
DicomServer::DicomServer(const std::string& ID, const std::string& AET, const std::string& HostName, int port, int PDU) 
 
93
{
 
94
        this->ID = ID;
 
95
        this->AET = AET;
 
96
        this->HostName = HostName;
 
97
        this->Port = port;
 
98
        this->PDU = PDU;
 
99
}
 
100
/**
 
101
default constructor
 
102
*/
 
103
DicomServer::DicomServer()
 
104
{
 
105
        this->isDefault = false;
 
106
}
 
107
 
 
108
DicomServer::DicomServer( const DicomServer& o) {
 
109
        *this = o;
 
110
}
 
111
 
 
112
DicomServer::~DicomServer() 
 
113
{ }
 
114
 
 
115
DicomServer& DicomServer::operator=(const DicomServer& o)
 
116
{
 
117
        this->ID = o.ID;
 
118
        this->AET = o.AET;
 
119
        this->HostName = o.HostName;
 
120
        this->Port = o.Port;
 
121
        this->Lossy = o.Lossy;
 
122
        this->isDefault = o.isDefault;
 
123
        this->PDU = o.PDU;
 
124
        this->useTLS = o.useTLS;
 
125
        this->pacsUser = o.pacsUser;
 
126
        this->pacsPass = o.pacsPass;
 
127
        this->retrieveMethod = o.retrieveMethod;
 
128
        this->wadoURI = o.wadoURI;
 
129
        this->reuseConnection = o.reuseConnection;
 
130
        this->retrieveSeries = o.retrieveSeries;
 
131
        this->verifyCredentials = o.verifyCredentials;
 
132
        this->certificate = o.certificate;
 
133
        this->privateKey = o.privateKey;
 
134
        this->defaultCharset = o.defaultCharset;
 
135
        this->wlConfig = o.wlConfig;
 
136
        return *this;
 
137
}
 
138
 
 
139
const std::string& DicomServer::GetID()
 
140
{
 
141
        return ID;
 
142
}
 
143
 
 
144
const std::string& DicomServer::GetAET()
 
145
{
 
146
        return AET;
 
147
}
 
148
 
 
149
const std::string& DicomServer::GetHostName()
 
150
{
 
151
        return HostName;
 
152
}
 
153
 
 
154
int DicomServer::GetPort()
 
155
{
 
156
        return Port;
 
157
}
 
158
 
 
159
int DicomServer::GetLossy()
 
160
{
 
161
        return Lossy;
 
162
}
 
163
 
 
164
bool DicomServer::GetIsDefault() 
 
165
{
 
166
        return isDefault;
 
167
}
 
168
 
 
169
int DicomServer::GetPDU()
 
170
{
 
171
        return PDU;
 
172
}
 
173
 
 
174
bool DicomServer::GetUseTLS()
 
175
{
 
176
        return useTLS;
 
177
}
 
178
 
 
179
const std::string& DicomServer::GetPACSUser()
 
180
{
 
181
        return pacsUser;
 
182
}
 
183
 
 
184
const std::string& DicomServer::GetPACSPass()
 
185
{
 
186
        return pacsPass;
 
187
}
 
188
 
 
189
DicomServer::TRetrieveMethod DicomServer::GetRetrieveMethod()
 
190
{
 
191
        return retrieveMethod;
 
192
}
 
193
 
 
194
bool DicomServer::GetRetrieveSeries()
 
195
{
 
196
        return retrieveSeries;
 
197
}
 
198
 
 
199
bool DicomServer::GetReuseConnection()
 
200
{
 
201
        return reuseConnection;
 
202
}
 
203
 
 
204
bool DicomServer::GetverifyCredentials()
 
205
{
 
206
        return verifyCredentials;
 
207
}
 
208
 
 
209
const std::string& DicomServer::GetCertificate()
 
210
{
 
211
        return certificate;
 
212
}
 
213
 
 
214
const std::string& DicomServer::GetPrivateKey()
 
215
{
 
216
        return privateKey;
 
217
}
 
218
 
 
219
const std::string& DicomServer::GetDefaultCharset()
 
220
{
 
221
        return defaultCharset;
 
222
}
 
223
 
 
224
const std::string& DicomServer::GetWADOURI() {
 
225
        return wadoURI;
 
226
}
 
227
 
 
228
WLConfig& DicomServer::GetWlConfig()
 
229
{
 
230
        return wlConfig;
 
231
}
 
232
 
 
233
        
 
234
 
 
235
/////////////////////////////////////////////////////////////////////
 
236
 
 
237
 
 
238
 
24
239
DicomServerList* DicomServerList::m_pInstance = 0;
25
240
 
26
241
DicomServerList::DicomServerList()
27
242
{
28
 
        serverHolders = NULL;
29
 
        localServer = NULL;
30
 
        lastInsertedHolder = NULL;
31
243
        Reload();
32
 
        //std::cout << "DicomServerList construido" << std::endl;
33
244
}
34
245
 
35
246
DicomServerList::~DicomServerList()
36
247
{
37
 
        //std::cout << "DicomServerList destruyendose" << std::endl;
38
 
        DicomServerHolder* holder = NULL;
39
 
        DicomServerHolder* tempHolder = NULL;
40
 
        for (holder = serverHolders; holder != NULL;) {
41
 
                tempHolder = holder->next;
42
 
                holder->next = NULL;
43
 
                delete holder;
44
 
                holder = tempHolder;
45
 
        }
46
 
        if (localServer != NULL) {
47
 
                delete localServer;
48
 
                localServer = NULL;
49
 
        }
50
 
        serverHolders = NULL;
51
 
        lastInsertedHolder = NULL;
52
 
        //std::cout << "DicomServerList destruido" << std::endl;
 
248
        GNC::GCS::ILocker lock(this);
 
249
        ServerMap.clear();
53
250
}
54
251
 
55
252
DicomServerList* DicomServerList::Instance()
71
268
 
72
269
void DicomServerList::AddServer(const DicomServer& newServer, bool isDefault)
73
270
{
 
271
        GNC::GCS::ILocker lock(this);
74
272
        if (isDefault) {
75
 
                for (DicomServerHolder* sl = GetList(); sl != NULL; sl = sl->next) {
76
 
                        sl->server.isDefault = false;
 
273
                for (TServerMap::iterator it = ServerMap.begin(); it != ServerMap.end(); ++it) {
 
274
                        (*it).second->isDefault = false;
77
275
                }
78
276
        }
79
 
        if (TieneServer(newServer.ID)) {
80
 
                DicomServer* server = GetServer(newServer.ID);
81
 
                *server = newServer;
82
 
                server->isDefault = isDefault;
 
277
        if (ServerMap.find(newServer.ID) != ServerMap.end()) {
 
278
                *ServerMap[newServer.ID] = newServer;
 
279
                ServerMap[newServer.ID]->isDefault = isDefault;
83
280
        }
84
281
        else {
85
 
                DicomServerHolder* newServerHolder = new DicomServerHolder(newServer.ID, newServer.AET, newServer.HostName, newServer.Port, newServer.Lossy, newServer.isDefault, newServer.PDU, newServer.useTLS, newServer.pacsUser, newServer.pacsPass, newServer.retrieveWithMove, newServer.retrieveSeries, newServer.reuseConnection, newServer.verifyCredentials, newServer.certificate, newServer.privateKey, newServer.defaultCharset);
86
 
                newServerHolder->server.isDefault = isDefault;
87
 
                if (serverHolders == NULL) {
88
 
                        lastInsertedHolder = serverHolders = newServerHolder;
89
 
                } else {
90
 
                        lastInsertedHolder->next = newServerHolder;
91
 
                        lastInsertedHolder = lastInsertedHolder->next;
92
 
                }
 
282
                GNC::GCS::Ptr<DicomServer> pNewServer(new DicomServer(newServer));
 
283
                pNewServer->isDefault = isDefault;
 
284
                ServerMap[newServer.ID] = pNewServer;
93
285
        }
94
 
        
95
286
}
96
287
 
97
288
bool DicomServerList::TieneServer(const std::string& ID)
98
289
{
99
 
        DicomServerHolder* it;
100
 
 
101
 
        bool found = false;
102
 
 
103
 
        for (it = serverHolders; it != NULL && !found; it = it->next) {
104
 
                if (it->server.ID == ID) {
105
 
                        found = true;
106
 
                }
107
 
        }
108
 
 
109
 
        return found;
110
 
}
111
 
 
112
 
DicomServer* DicomServerList::GetServer(const std::string& ID)
113
 
{
114
 
        DicomServer* server = NULL;
115
 
 
116
 
        DicomServerHolder* it;
117
 
 
118
 
        bool found = false;
119
 
 
120
 
        for (it = serverHolders; it != NULL && !found; it = it->next) {
121
 
                if (it->server.ID == ID) {
122
 
                        found = true;
123
 
                        server = &it->server;
124
 
                }
125
 
        }
126
 
 
127
 
        if (server == NULL) {
128
 
                throw GinkgoNoServerFoundException();
129
 
        }
130
 
 
131
 
        return server;
132
 
}
133
 
 
134
 
DicomServer* DicomServerList::GetLocalServer()
135
 
{
136
 
        if (localServer == NULL) {
137
 
                throw GinkgoNoServerFoundException();
138
 
        }
139
 
        return localServer;
140
 
}
141
 
 
142
 
DicomServerHolder* DicomServerList::GetList()
143
 
{
144
 
        return serverHolders;
145
 
}
146
 
 
147
 
DicomServer* DicomServerList::GetDefaultServer()
148
 
{
149
 
        if (serverHolders != NULL) {
150
 
                for (DicomServerHolder* it = serverHolders; it != NULL; it = it->next) {
151
 
                        if (it->server.isDefault) {
152
 
                                return &it->server;
153
 
                        }
154
 
                }
155
 
        }
156
 
        if (serverHolders != NULL) {
157
 
                return &serverHolders->server;
158
 
        } else {
159
 
                return NULL;
 
290
        GNC::GCS::Ptr<DicomServer> server = GetServer(ID);
 
291
        return server.IsValid();
 
292
}
 
293
 
 
294
const GNC::GCS::Ptr<DicomServer>& DicomServerList::GetServer(const std::string& ID)
 
295
{
 
296
        GNC::GCS::ILocker lock(this);
 
297
        if (ServerMap.find(ID) != ServerMap.end()) {
 
298
                return ServerMap[ID];
 
299
        } else {
 
300
                GNC::GCS::Ptr<DicomServer> server;
 
301
                throw GinkgoNoServerFoundException();
 
302
        }
 
303
}
 
304
 
 
305
const GNC::GCS::Ptr<DicomServer>& DicomServerList::GetLocalServer()
 
306
{
 
307
        if (!LocalServer.IsValid()) {
 
308
                throw GinkgoNoServerFoundException();
 
309
        }
 
310
        return LocalServer;
 
311
}
 
312
 
 
313
bool DicomServerList::Empty()
 
314
{
 
315
        return ServerMap.empty();
 
316
}
 
317
 
 
318
DicomServerList::TServerList DicomServerList::GetServerList()
 
319
{
 
320
        GNC::GCS::ILocker lock(this);
 
321
        TServerList listOfServers;
 
322
        for (TServerMap::iterator it = ServerMap.begin(); it != ServerMap.end(); ++it) {
 
323
                listOfServers.push_back((*it).second);
 
324
        }
 
325
        return listOfServers;
 
326
}
 
327
 
 
328
const GNC::GCS::Ptr<DicomServer>& DicomServerList::GetDefaultServer()
 
329
{
 
330
        GNC::GCS::ILocker lock(this);
 
331
        for (TServerMap::iterator it = ServerMap.begin(); it != ServerMap.end(); ++it) {
 
332
                if ((*it).second->isDefault) {
 
333
                        return (*it).second;
 
334
                }
 
335
        }
 
336
        if (!ServerMap.empty()) {
 
337
                return (*ServerMap.begin()).second;
 
338
        } else {
 
339
                throw GinkgoNoServerFoundException();
160
340
        }
161
341
}
162
342
 
163
343
void DicomServerList::SetDefaultServer(const std::string& ID)
164
344
{
165
 
        if (serverHolders != NULL) {
166
 
                for (DicomServerHolder* it = serverHolders; it != NULL; it = it->next) {
167
 
                        if (it->server.ID == ID) {
168
 
                                it->server.isDefault = true;
169
 
                        } else {
170
 
                                it->server.isDefault = false;
171
 
                        }
 
345
        GNC::GCS::ILocker lock(this);
 
346
        for (TServerMap::iterator it = ServerMap.begin(); it != ServerMap.end(); ++it) {
 
347
                if ((*it).second->ID != ID) {
 
348
                        (*it).second->isDefault = false;
 
349
                } else {
 
350
                        (*it).second->isDefault = true;
172
351
                }
173
352
        }
174
353
}
175
354
 
176
 
DicomServer* DicomServerList::GetFirst()
177
 
{
178
 
        DicomServer* server = NULL;
179
 
        if (serverHolders != NULL) {
180
 
                server = &serverHolders->server;
181
 
        }
182
 
        return server;
183
 
}
184
 
 
185
 
DicomServer* DicomServerList::GetLast()
186
 
{
187
 
        return &lastInsertedHolder->server;
188
 
}
189
 
 
190
355
void DicomServerList::Reload()
191
356
{
192
 
        DicomServerHolder* holder = NULL;
193
 
        DicomServerHolder* tempHolder = NULL;
194
 
        for (holder = serverHolders; holder != NULL;) {
195
 
                tempHolder = holder->next;
196
 
                holder->next = NULL;
197
 
                delete holder;
198
 
                holder = tempHolder;
199
 
        }
200
 
        if (localServer != NULL) {
201
 
                delete localServer;
202
 
                localServer = NULL;
203
 
        }
204
 
        serverHolders = NULL;
205
 
        lastInsertedHolder = NULL;
206
 
 
 
357
        GNC::GCS::ILocker lock(this);
 
358
        ServerMap.clear();
 
359
        
207
360
        GNC::GCS::ConfigurationController::TListGroups servers;
208
361
        GNC::GCS::ConfigurationController::Instance()->readGroupGeneral("/GinkgoCore/PACS/Servidores", servers);
209
362
 
218
371
                values.readIntValue("Puerto", port);
219
372
                values.readIntValue("PDU", pdu, DEFAULT_PDU_LENGTH);
220
373
 
221
 
                DicomServer server(id, aet, host, port, 0, false, pdu, false, "", "", false, false, true, false, "", "", "");
222
 
                values.readBoolValue("isDefault",server.isDefault,false);
223
 
                values.readBoolValue("useTLS",server.useTLS,false);
224
 
                values.readStringValue("pacsUser", server.pacsUser);
225
 
                values.readStringValue("pacsPass", server.pacsPass);
226
 
                values.readBoolValue("verifyCredentials",server.verifyCredentials,false);
227
 
                values.readStringValue("certificate", server.certificate);
228
 
                values.readStringValue("privateKey", server.privateKey);
229
 
                values.readBoolValue("retrieveWithMove",server.retrieveWithMove,true);
230
 
                values.readBoolValue("reuseConnection", server.reuseConnection, false);
231
 
                values.readBoolValue("retrieveSeries",server.retrieveSeries,true);
232
 
                values.readStringValue("defaultCharset", server.defaultCharset, "ISO_IR 100");
233
 
 
234
 
                AddServer(server, server.isDefault);
235
 
                existDefault = existDefault || server.isDefault;
236
 
        }
237
 
 
238
 
        if (!existDefault) {
239
 
                if (serverHolders != NULL) {
240
 
                        serverHolders->server.isDefault = true;
 
374
                GNC::GCS::Ptr<DicomServer> server(new DicomServer(id, aet, host, port, pdu));
 
375
                values.readBoolValue("isDefault",server->isDefault,false);
 
376
                values.readBoolValue("useTLS",server->useTLS,false);
 
377
                values.readStringValue("pacsUser", server->pacsUser);
 
378
                values.readStringValue("pacsPass", server->pacsPass);
 
379
                values.readBoolValue("verifyCredentials",server->verifyCredentials,false);
 
380
                values.readStringValue("certificate", server->certificate);
 
381
                values.readStringValue("privateKey", server->privateKey);
 
382
                int tmpInt;
 
383
                if (values.readIntValue("retrieveMethod", tmpInt)) {
 
384
                        server->retrieveMethod = (DicomServer::TRetrieveMethod)tmpInt;
 
385
                } else {
 
386
                //retro compatibility
 
387
                        bool tmpBool;
 
388
                        values.readBoolValue("retrieveWithMove",tmpBool,true);
 
389
                        if (tmpBool) {
 
390
                                server->retrieveMethod = DicomServer::MOVE;
 
391
                        } else {
 
392
                                server->retrieveMethod = DicomServer::GET;
 
393
                        }
241
394
                }
 
395
                //
 
396
                values.readStringValue("wadoURI", server->wadoURI, "");
 
397
                values.readBoolValue("reuseConnection", server->reuseConnection, false);
 
398
                values.readBoolValue("retrieveSeries",server->retrieveSeries,true);
 
399
                values.readStringValue("defaultCharset", server->defaultCharset, "ISO_IR 100");
 
400
 
 
401
                //wl...
 
402
                values.readBoolValue("useDICOMMPPS",server->GetWlConfig().useDICOMMPPS, server->GetWlConfig().useDICOMMPPS);
 
403
                values.readBoolValue("useAbortMessage",server->GetWlConfig().useAbortMessage, server->GetWlConfig().useAbortMessage);
 
404
                values.readBoolValue("useCompletedMessage",server->GetWlConfig().useCompletedMessage, server->GetWlConfig().useCompletedMessage);
 
405
                values.readBoolValue("useInProgressMessage",server->GetWlConfig().useInProgressMessage, server->GetWlConfig().useInProgressMessage);
 
406
                values.readStringValue("abortTemplate",server->GetWlConfig().abortTemplate, server->GetWlConfig().abortTemplate);
 
407
                values.readStringValue("completedTemplate",server->GetWlConfig().completedTemplate, server->GetWlConfig().completedTemplate);
 
408
                values.readStringValue("inProgressTemplate",server->GetWlConfig().inProgressTemplate, server->GetWlConfig().inProgressTemplate);
 
409
                //
 
410
 
 
411
                ServerMap[server->ID] = server;
 
412
                existDefault = existDefault || server->isDefault;
 
413
        }
 
414
 
 
415
        if (!existDefault && !ServerMap.empty()) {
 
416
                ServerMap.begin()->second->isDefault = true;
242
417
        }
243
418
 
244
419
        //local server
247
422
        GNC::GCS::ConfigurationController::Instance()->readIntGeneral("/GinkgoCore/PACS/Local", "Puerto", port, 11112);
248
423
        std::string localAet = GNC::Entorno::Instance()->GetDicomLocalAET();
249
424
        
250
 
        localServer = new DicomServer("ginkgo",localAet, "localhost", port, 0, false, 16384,false, "", "", false, true,false, false, "", "", "");
251
 
        GNC::GCS::ConfigurationController::Instance()->readBoolGeneral("/GinkgoCore/PACS/Local", "useTLS", localServer->useTLS, false);
252
 
        GNC::GCS::ConfigurationController::Instance()->readBoolGeneral("/GinkgoCore/PACS/Local", "verifyCredentials", localServer->verifyCredentials, false);
 
425
        LocalServer = new DicomServer("ginkgo",localAet, "localhost", port, 16384);
 
426
        GNC::GCS::ConfigurationController::Instance()->readBoolGeneral("/GinkgoCore/PACS/Local", "useTLS", LocalServer->useTLS, false);
 
427
        GNC::GCS::ConfigurationController::Instance()->readBoolGeneral("/GinkgoCore/PACS/Local", "verifyCredentials", LocalServer->verifyCredentials, false);
253
428
#ifdef GINKGO_PRIVATE_KEY
254
 
        localServer->privateKey = GINKGO_PRIVATE_KEY;
 
429
        LocalServer->privateKey = GINKGO_PRIVATE_KEY;
255
430
#endif
256
 
        GNC::GCS::ConfigurationController::Instance()->readStringGeneral("/GinkgoCore/PACS/Local", "privateKey", localServer->privateKey);
 
431
        GNC::GCS::ConfigurationController::Instance()->readStringGeneral("/GinkgoCore/PACS/Local", "privateKey", LocalServer->privateKey);
257
432
 
258
433
#ifdef GINKGO_PUBLIC_KEY
259
 
        localServer->certificate = GINKGO_PUBLIC_KEY;
 
434
        LocalServer->certificate = GINKGO_PUBLIC_KEY;
260
435
#endif
261
 
        GNC::GCS::ConfigurationController::Instance()->readStringGeneral("/GinkgoCore/PACS/Local", "certificate", localServer->certificate);
 
436
        GNC::GCS::ConfigurationController::Instance()->readStringGeneral("/GinkgoCore/PACS/Local", "certificate", LocalServer->certificate);
262
437
}
263
438