path: root/server/src/journalwriter.cc

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; coding: utf-8  -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            journalwriter.cc
 *
 *  Tue Jan  5 15:52:54 CET 2010
 *  Copyright 2010 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 "journalwriter.h"

#include "debug.h"
#include "journal_commit.h"

static inline bool iswhitespace(char c)
{
  return c == ' ' || c == '\n' || c == '\t' || c == '\r';
}

/**
 * Remove all spaces, tabs and newline trailing the string.
 */
static std::string stripTrailingWhitepace(const std::string &str)
{
  if(str == "") return str;

  ssize_t end = str.size() - 1;

  while(end >= 0 && iswhitespace(str[end])) end--;
  end++;

  return str.substr(0, end);
}

static bool isInsideUTF8(const std::string &str, size_t idx)
{
  // Two byte character
  if(idx > 0 &&
     (str[idx] & 0xC0 ) == 0x80 &&
     (str[idx - 1] & 0xE0) == 0xC0)
    return true;

  // Three byte character
  if(idx > 1 &&
     (str[idx] & 0xC0 ) == 0x80 &&
     (str[idx - 1] & 0xC0 ) == 0x80 &&
     (str[idx - 2] & 0xF0) == 0xE0)
    return true;

  if(idx > 0 &&
     (str[idx] & 0xC0 ) == 0x80 &&
     (str[idx - 1] & 0xF0) == 0xE0)
    return true;

  // Four byte character
  if(idx > 2 &&
     (str[idx] & 0xC0 ) == 0x80 &&
     (str[idx - 1] & 0xC0 ) == 0x80 &&
     (str[idx - 2] & 0xC0 ) == 0x80 &&
     (str[idx - 3] & 0xF8) == 0xF0)
    return true;

  if(idx > 1 &&
     (str[idx] & 0xC0 ) == 0x80 &&
     (str[idx - 1] & 0xC0 ) == 0x80 &&
     (str[idx - 2] & 0xF8) == 0xF0)
    return true;

  if(idx > 0 &&
     (str[idx] & 0xC0 ) == 0x80 &&
     (str[idx - 1] & 0xF8) == 0xF0)
    return true;

  return false;
}

static size_t UTF8Length(const std::string &str)
{
  size_t size = 0;
  for(size_t i = 0; i < str.size(); i++) {
    if(!isInsideUTF8(str, i)) size++;
  }
  return size;
}

/**
 * Find all lines longer than 'width', and insert a newline in the
 * first backward occurring space. Force split any lines without a space.
 */
static std::string addNewlines(const std::string &str, size_t width)
{
  std::string output;
  size_t len = 0;
  for(size_t i = 0; i < str.size(); i++) {
    char c = str[i];

    /*
    fprintf(stderr, "i: %d, char: '%c', width: %d, len: %d, output: '%s'\n",
            i, c, width, len, output.c_str());
    */

    output += c;

    if(isInsideUTF8(str, i)) continue;

    len++;
    if(c == '\n') len = 0;

    // Try to split line at whitespace.
    if(len > width) {
      size_t p = 0;
      while(p < width) {
        p++;

        size_t pos = output.size() - p;

        if(isInsideUTF8(output, pos)) continue;

        if(iswhitespace(output[pos])) {
          output[pos] = '\n';
          len = UTF8Length(output.substr(pos+1));
          break;
        }
      }
    }

    // Force split line at current pos.
    if(len > width) {
      // replace last char with a newline, and append the character again, after the newline.
      output[output.size()-1] = '\n';
      output += c;
      len = 1;
    }
  }

  return output;
}

JournalWriter::JournalWriter(std::string host, unsigned short int port)
{
  this->host = host;
  this->port = port;
}

void JournalWriter::addEntry(Transaction &transaction, Commit &commit,
                             std::string resume, Template *templ)
{
  size_t index = 0;
  std::vector< Macro >::iterator i = templ->macros.begin();
  while(i != templ->macros.end()) {
    Macro &m = *i;
    if(commit.macro == m.attributes["name"]) break;
    index++;
    i++;
  }

  if(index >= templ->macros.size()) {
    PRACRO_ERR(journal, "Could not find macro %s in template %s\n",
               commit.macro.c_str(), templ->attributes["name"].c_str());
    //      return;
  } else {
    PRACRO_DEBUG(journal, "Found macro %s as index %u in template %s\n",
                 commit.macro.c_str(), index, templ->attributes["name"].c_str());
  }

  // First run - initialize username and cpr.
  if(currentuser == "" && entrylist.size() == 0) currentuser = transaction.user;
  if(currentcpr == "" && entrylist.size() == 0) currentcpr = transaction.cpr;

  PRACRO_DEBUG(journal, "addEntry: template(%s)\n", templ->attributes["name"].c_str());

  // Add the template resume as the header (ie. first entry) of the journal entry.
  if(entrylist.size() == 0 && templ->attributes["name"] != "") {
    std::string template_resume = templ->attributes["resume"];
    
    PRACRO_DEBUG(journal, "TemplateResume: %s\n", template_resume.c_str());
    
    if(template_resume != "") {
      ResumeEntry re;
      re.resume = template_resume;
      re.macro = "template_header"; 
      entrylist[-1] = re; // Make sure it comes first.
    }
  }

  // Test if the username or the cpr has changed... if so, commit and clear the list.
  if(currentuser != transaction.user || currentcpr != transaction.cpr) {
    this->commit();
    entrylist.clear();
  }

  // Strip trailing whitespace, and add newlines.
  std::string r = stripTrailingWhitepace(addNewlines(resume, 60));
  std::string m = commit.macro;

  ResumeEntry re;
  re.resume = r;
  re.macro = m;
  entrylist[index] = re;
}

void JournalWriter::commit()
{
  std::string resume;
  
  // Iterate through all resumes, and create a string containing them all.
  std::map< int, ResumeEntry >::iterator i = entrylist.begin();
  while(i != entrylist.end()) {
    if(resume != "") resume += "\n\n";
    //    resume += i->macro + "\n";
    resume += i->second.resume;
    i++;
  }

  if(resume == "") return;

  // Connect to praxisuploadserver and commit all resumes in one bulk.
  journal_commit(currentcpr.c_str(), currentuser.c_str(),
                 host.c_str(), port,
                 resume.c_str(), resume.size());
}

#ifdef TEST_JOURNALWRITER
//deps: debug.cc journal_commit.cc
//cflags: -I..
//libs:
#include "test.h"

#define LONG "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do\neiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.           \n\n    \t";

TEST_BEGIN;

TEST_EQUAL_STR(stripTrailingWhitepace
               ("Lorem ipsum dolor sit amet.           \n\n    \t"),
                "Lorem ipsum dolor sit amet.", "Test wspace remover.");

TEST_EQUAL_STR(stripTrailingWhitepace(""), "", "Test wspace remover on empty string.");

TEST_EQUAL_STR(stripTrailingWhitepace("\n\t "), "", "Test wspace remover on wspace-only string.");

TEST_EQUAL_STR(stripTrailingWhitepace("\n"), "", "Test wspace remover on newline only.");
TEST_EQUAL_STR(stripTrailingWhitepace("\t"), "", "Test wspace remover on tab only.");
TEST_EQUAL_STR(stripTrailingWhitepace("\r"), "", "Test wspace remover on space only.");
TEST_EQUAL_STR(stripTrailingWhitepace(" "), "", "Test wspace remover on space only.");

TEST_EQUAL_STR(stripTrailingWhitepace("ø "), "ø", "Test wspace remover on utf-8 char.");
TEST_EQUAL_STR(stripTrailingWhitepace("ø"), "ø", "Test wspace remover on utf-8 char only.");

TEST_EQUAL_STR(stripTrailingWhitepace("a "), "a", "Test wspace remover on single char only.");
TEST_EQUAL_STR(stripTrailingWhitepace("a"), "a", "Test wspace remover on single char only.");

TEST_EQUAL_STR(addNewlines
               ("Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do.", 60),
                "Lorem ipsum dolor sit amet, consectetur adipisicing elit,\nsed do.",
               "Test single linesplit.");

TEST_EQUAL_STR(addNewlines
               ("Lorem ipsum dolor sit amet, consectetur adipisicing elit, øsed do.", 60),
                "Lorem ipsum dolor sit amet, consectetur adipisicing elit,\nøsed do.",
               "Test single linesplit around utf-8 char.");

TEST_EQUAL_STR(addNewlines
               ("Lorem ipsum dolor sit amet, consectetur adipisicing elitø, sed do.", 60),
                "Lorem ipsum dolor sit amet, consectetur adipisicing elitø,\nsed do.",
               "Test single linesplit around utf-8 char.");

TEST_EQUAL_STR(addNewlines
               ("Lorem\nipsum dolor sit amet.", 12),
                "Lorem\nipsum dolor\nsit amet.",
               "Test single linesplit with contained newline.");

TEST_EQUAL_STR(addNewlines
               ("Lorem ipsum dolor sitan met.", 11),
                "Lorem ipsum\ndolor sitan\nmet.",
               "Test single linesplit on exact border.");

TEST_EQUAL_STR(addNewlines
               ("Loremipsum", 6),
                "Loremi\npsum",
               "Test single linesplit inside word.");

TEST_EQUAL_STR(addNewlines
               ("abc Loremipsum", 6),
                "abc\nLoremi\npsum",
               "Test single linesplit inside word.");

TEST_TRUE(isInsideUTF8("ø", 1), "Test positive utf8 match.");
TEST_TRUE(isInsideUTF8("aæb", 2), "Test positive utf8 match.");
TEST_TRUE(isInsideUTF8("aøb", 2), "Test positive utf8 match.");
TEST_TRUE(isInsideUTF8("aåb", 2), "Test positive utf8 match.");
TEST_TRUE(isInsideUTF8("aÆb", 2), "Test positive utf8 match.");
TEST_TRUE(isInsideUTF8("aØb", 2), "Test positive utf8 match.");
TEST_TRUE(isInsideUTF8("aÅb", 2), "Test positive utf8 match.");
TEST_FALSE(isInsideUTF8("ø", 0), "Test negative utf8 match.");
TEST_FALSE(isInsideUTF8("aæøb", 3), "Test negative utf8 match (between two utf8 chars).");
TEST_FALSE(isInsideUTF8("aøb", 0), "Test negative utf8 match (before utf8 char).");

TEST_FALSE(isInsideUTF8("𤭢", 0), "Test positive utf8 match, len 4.");
TEST_TRUE(isInsideUTF8("𤭢", 1), "Test positive utf8 match, len 4.");
TEST_TRUE(isInsideUTF8("𤭢", 2), "Test positive utf8 match, len 4.");
TEST_TRUE(isInsideUTF8("𤭢", 3), "Test positive utf8 match, len 4.");

TEST_FALSE(isInsideUTF8("€", 0), "Test positive utf8 match, len 3.");
TEST_TRUE(isInsideUTF8("€", 1), "Test positive utf8 match, len 3.");
TEST_TRUE(isInsideUTF8("€", 2), "Test positive utf8 match, len 3.");

TEST_FALSE(isInsideUTF8("¢", 0), "Test positive utf8 match, len 2.");
TEST_TRUE(isInsideUTF8("¢", 1), "Test positive utf8 match, len 2.");

TEST_EQUAL_INT(UTF8Length("ø"), 1, "Test utf8 string length.");
TEST_EQUAL_INT(UTF8Length("æø"), 2, "Test utf8 string length.");
TEST_EQUAL_INT(UTF8Length(""), 0, "Test utf8 string length.");
TEST_EQUAL_INT(UTF8Length("a"), 1, "Test utf8 string length.");
TEST_EQUAL_INT(UTF8Length("aø"), 2, "Test utf8 string length.");
TEST_EQUAL_INT(UTF8Length("aøb"), 3, "Test utf8 string length.");

TEST_EQUAL_INT(UTF8Length("a𤭢€¢ø𤭢€¢øa"), 10, "Test utf8 string length, combi.");

TEST_EQUAL_STR(stripTrailingWhitepace(addNewlines("", 60)), "", "Test on empty input.");

TEST_END;

#endif/*TEST_JOURNALWRITER*/