path: root/client/praxisd.cc

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            praxisd.cc
 *
 *  Tue Oct 11 15:20:18 CEST 2011
 *  Copyright 2011 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

/*
 *  This file is part of Pracro.
 *
 *  Pracro is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  Pracro is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Pracro; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "praxisd.h"

#include <stdio.h>

#include <QDomDocument>

#include <QNetworkReply>

#define DOCAVE(x) if(element.tagName() == #x) cave.x = element.text()
static CaveVector getCaveList(QByteArray data)
{
  QDomDocument doc;
  doc.setContent(data);

  CaveVector cavelist;

  QDomNode praxisd = doc.documentElement();
  QDomNodeList nodes = praxisd.childNodes();
  for(int i = 0; i < nodes.count(); i++) {
    QDomNode node = nodes.at(i);
    QDomElement element = node.toElement();
    if(element.tagName() == "div_cave") {

      cave_t cave;
      cave.sogenr = element.attribute("sogenr");

      QDomNodeList nodes = element.childNodes();
      for(int j = 0; j < nodes.count(); j++) {
        QDomNode node = nodes.at(j);
        QDomElement element = node.toElement();
        DOCAVE(cave);
        DOCAVE(bemaerkning1);
        DOCAVE(bemaerkning2);
        DOCAVE(bemaerkning3);
      }

      cavelist.push_back(cave);
    }
  }

  return cavelist;
}

#define DOPATIENT(x) if(element.tagName() == #x) patient.x = element.text()
static Patient getPatient(QByteArray data)
{
  QDomDocument doc;
  doc.setContent(data);

  Patient patient;

  QDomNode praxisd = doc.documentElement();
  QDomNode patnode = praxisd.firstChild();

  QDomElement patelement = patnode.toElement();
  patient.cpr = patelement.attribute("cpr");

  QDomNodeList nodes = patnode.childNodes();
  for(int i = 0; i < nodes.count(); i++) {
    QDomNode node = nodes.at(i);
    QDomElement element = node.toElement();

    DOPATIENT(fornavne);
    DOPATIENT(efternavn);
    DOPATIENT(stilling);
    DOPATIENT(gade);
    DOPATIENT(by);
    DOPATIENT(telefonnumre);
    DOPATIENT(sikringsgr);
    DOPATIENT(amtsnr);
    DOPATIENT(sygekontor);
    DOPATIENT(henvnr);
    DOPATIENT(frilinie1);
    DOPATIENT(frilinie2);
    DOPATIENT(frilinie3);
    DOPATIENT(frilinie4);
    DOPATIENT(frilinie5);

    if(element.tagName() == "sogeords") {
      sogeord_t sogeord;

      QDomNodeList nodes = element.childNodes();
      for(int j = 0; j < nodes.count(); j++) {
        QDomNode node = nodes.at(j);
        QDomElement element = node.toElement();
        sogeord.sogenr = element.attribute("sogenr");
        sogeord.sogedato = element.attribute("sogedato");
        sogeord.sogetxt = element.text();
      }

      patient.sogeord.push_back(sogeord);
    }

    DOPATIENT(ydernr);
    DOPATIENT(created);
    DOPATIENT(donottouch);
    DOPATIENT(visus);
    DOPATIENT(labkort);
    DOPATIENT(medkort);
    DOPATIENT(jlock);
    DOPATIENT(unknown1);
    DOPATIENT(henvdato);
    DOPATIENT(aarhund);
    DOPATIENT(fakturadato);
    DOPATIENT(fakturabelob);
    DOPATIENT(betaldato);
    DOPATIENT(betalbelob);
    DOPATIENT(jdato);
    DOPATIENT(unknown250);
    DOPATIENT(unknown251);
    DOPATIENT(jtime);
  }

  return patient;
}

#define DODOKMENU(x) if(element.tagName() == #x) dokmenu.x = element.text()
static DokMenuVector getDokMenu(QByteArray data)
{
  QDomDocument doc;
  doc.setContent(data);

  DokMenuVector dokmenus;

  QDomNode praxisd = doc.documentElement();
  QDomNodeList nodes = praxisd.childNodes();
  for(int i = 0; i < nodes.count(); i++) {
    QDomNode node = nodes.at(i);
    QDomElement element = node.toElement();
    if(element.tagName() == "dokmenu") {
      dokmenu_t dokmenu;
      dokmenu.cpr = element.attribute("cpr");

      QDomNodeList nodes = element.childNodes();
      for(int j = 0; j < nodes.count(); j++) {
        QDomNode node = nodes.at(j);
        QDomElement element = node.toElement();
        DODOKMENU(group);
        DODOKMENU(subject);
        if(element.tagName() == "filename") {
          dokmenu.filename = element.text();
          dokmenu.filesize = element.attribute("filesize").toUInt();
          dokmenu.date = element.attribute("date");
        }
      }

      dokmenus.push_back(dokmenu);
    }
  }

  return dokmenus;
}

Praxisd::Praxisd(QString host, unsigned short int port)
{
  qRegisterMetaType<CaveVector>("CaveVector");
  qRegisterMetaType<Patient>("Patient");
  qRegisterMetaType<DokMenuVector>("DokMenuVector");

  QUrl url;
  url.setHost(host);
  url.setPort(port);
  url.setScheme("http");

  request.setUrl(url);

  manager = new QNetworkAccessManager(this);
  connect(manager, SIGNAL(finished(QNetworkReply*)),
          this, SLOT(replyFinished(QNetworkReply*)));
}

void Praxisd::replyFinished(QNetworkReply *reply)
{
  if(reply->error() == QNetworkReply::NoError) {

    reply_t type = replytypes[reply];
    switch(type) {
    case journal:
      emit gotJournal(reply->readAll());
      break;

    case cavelist:
      emit gotCaveList(getCaveList(reply->readAll()));
      break;

    case patient:
      emit gotPatient(getPatient(reply->readAll()));
      break;

    case dokmenu:
      emit gotDokMenu(getDokMenu(reply->readAll()));
      break;

    case dokmenufile:
      emit gotDokMenuFile(reply->readAll(), reply->rawHeader("Content-Type"));
      break;
    }
  } else {
    emit networkError(reply->errorString());
  }
  replytypes.erase(replytypes.find(reply));
}

void Praxisd::makeTransfer(reply_t t, QString uri,
                           QMap<QString, QString> params)
{
  request.setRawHeader("User-Agent", "Pracro Client v"VERSION);

  QUrl url;
  url.setHost(request.url().host());
  url.setPort(request.url().port());
  url.setScheme(request.url().scheme());

  url.setPath(uri);

  QMap<QString, QString>::iterator i = params.begin();
  while(i != params.end()) {
    url.addQueryItem(i.key(), i.value());
    i++;
  }

  request.setUrl(url);

  QNetworkReply* r = manager->get(request);
  replytypes[r] = t;
}

void Praxisd::journal_get_by_cpr(QString cpr)
{
  QMap<QString, QString> params;
  params["cpr"] = cpr;
  makeTransfer(journal, "/praxisd/1.0/journal/get_by_cpr", params);
}

void Praxisd::diverse_get_cave(QString sogenr)
{
  QMap<QString, QString> params;
  params["sogenr"] = sogenr;
  makeTransfer(cavelist, "/praxisd/1.0/diverse/get_all_by_sogenr", params);
}

void Praxisd::patient_get_by_cpr(QString cpr)
{
  QMap<QString, QString> params;
  params["cpr"] = cpr;
  makeTransfer(patient, "/praxisd/1.0/patient/get_by_cpr", params);
}

void Praxisd::dokmenu_get_all_by_cpr(QString cpr)
{
  QMap<QString, QString> params;
  params["cpr"] = cpr;
  makeTransfer(dokmenu, "/praxisd/1.0/dokmenu/get_all_by_cpr", params);
}

void Praxisd::dokmenu_get_by_cpr_and_name(QString cpr, QString name)
{
  cpr = cpr;
  name = name;
  // uri = host + "/praxisd/1.0/dokmenu/get_by_cpr_and_name?cpr=" + cpr + "&name=" + name;
  QMap<QString, QString> params;
  params["cpr"] = cpr;
  params["name"] = name;
  makeTransfer(dokmenufile, "/praxisd/1.0/dokmenu/get_by_cpr_and_name", params);
}

PraxisdSync::PraxisdSync(QString host, unsigned short int port)
{
  this->host = host;
  this->port = port;
  this->running = true;

  start();
}

PraxisdSync::~PraxisdSync()
{
  this->running = false;
  wsem.release();
  wait();
}

void PraxisdSync::run()
{
  Praxisd praxisd(host, port);

  connect(&praxisd, SIGNAL(networkError(QString)),
          this, SLOT(networkError(QString)), Qt::DirectConnection);

  connect(&praxisd, SIGNAL(gotCaveList(CaveVector)),
          this, SLOT(gotCaveList(CaveVector)), Qt::DirectConnection);

  connect(&praxisd, SIGNAL(gotPatient(Patient)),
          this, SLOT(gotPatient(Patient)), Qt::DirectConnection);

  connect(&praxisd, SIGNAL(gotDokMenu(DokMenuVector)),
          this, SLOT(gotDokMenu(DokMenuVector)), Qt::DirectConnection);

  while(true) {
    wsem.acquire();

    // Reset error state
    error = false;
    errorStr = "";
    
    if(this->running == false) break;

    switch(request_type) {
    case Praxisd::journal:
      break;
    case Praxisd::cavelist:
      praxisd.diverse_get_cave(request_sogenr);
      break;
    case Praxisd::patient:
      praxisd.patient_get_by_cpr(request_cpr);
      break;
    case Praxisd::dokmenu:
      praxisd.dokmenu_get_all_by_cpr(request_cpr);
      break;
    case Praxisd::dokmenufile:
      break;
    }

    exec();
  }

  rsem.release();
}

bool PraxisdSync::hasError()
{
  return error;
}

QString PraxisdSync::errorString()
{
  return errorStr;
}

void PraxisdSync::networkError(QString err)
{
  error = true;
  errorStr = err;
  rsem.release();
  quit();
}

void PraxisdSync::gotCaveList(CaveVector cl)
{
  cavelist = cl;
  rsem.release();
  quit();
}

void PraxisdSync::gotPatient(Patient p)
{
  patient = p;
  rsem.release();
  quit();
}

void PraxisdSync::gotDokMenu(DokMenuVector d)
{
  dokmenu = d;
  rsem.release();
  quit();
}

QString PraxisdSync::journal_get_by_cpr(QString cpr)
{
  return cpr;
}

CaveVector PraxisdSync::diverse_get_cave(QString sogenr)
{
  request_type = Praxisd::cavelist;
  request_sogenr = sogenr;

  wsem.release();
  rsem.acquire();

  return cavelist;
}

Patient PraxisdSync::patient_get_by_cpr(QString cpr)
{
  cpr = "";
  return Patient();
}

DokMenuVector PraxisdSync::dokmenu_get_all_by_cpr(QString cpr)
{
  request_type = Praxisd::dokmenu;
  request_cpr = cpr;

  wsem.release();
  rsem.acquire();

  return dokmenu;
}

QString PraxisdSync::dokmenu_get_by_cpr_and_name(QString cpr, QString name)
{
  return cpr + name;
}