Esempio n. 1
0
void
msg_status_cache::db_new_mail_notif()
{
  DBG_PRINTF(5, "We have NEW MAIL!");
  db_cnx db;
  try {
    sql_stream s("SELECT ms.mail_id,ms.status,sender,sender_fullname,subject,recipients FROM mail m JOIN mail_status ms USING(mail_id) WHERE ms.mail_id>:p1", db);
    s << m_max_mail_id;
    mail_id_t mail_id;
    int status;
    int count=0;
    while (!s.eos()) {
      QString sender,sender_fullname,subject,recipients;
      s >> mail_id >> status>> sender >> sender_fullname >> subject >> recipients;
      count++;
      DBG_PRINTF(5, "Seen mail_id %d with status %d", mail_id, status);
      if (!(status & mail_msg::statusRead)) {
	gl_pApplication->desktop_notify(tr("New mail"), QString("From: %1\nSubject: %2").arg(sender_fullname.isEmpty()?sender:sender_fullname).arg(subject));
      }
      update(mail_id, status);
      message_port::instance()->broadcast_new_mail(mail_id);
    }
    if (count>0 && get_config().get_bool("fetch/auto_incorporate_new_results", false)) {
      message_port::instance()->broadcast_list_refresh_request();
    }
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
  }
}
Esempio n. 2
0
bool
filter_log_list::fetch(mail_id_t mail_id)
{
  db_cnx db;
  m_mail_id=mail_id;
  try {
    /* If the filter has been deleted after the filter_log entry
       creation, then coalesce(e.expr_id,0) will be 0.
       Also if the filter has been modified since, hit_date-e.last_update will be <0
     */
    sql_stream s("SELECT f.expr_id, e.name, e.expression, to_char(hit_date,'YYYYMMDDHHMI'),coalesce(e.expr_id,0), SIGN(EXTRACT(epoch FROM (hit_date-e.last_update))) FROM filter_log f LEFT JOIN filter_expr e ON e.expr_id=f.expr_id WHERE f.mail_id=:id ORDER BY hit_date", db);
    s << mail_id;
    while (!s.isEmpty()) {
      filter_log_entry e;
      QString hit_date;
      int e_id, sign;
      s >> e.m_expr_id >> e.m_filter_name >> e.m_filter_expression >> hit_date >> e_id >> sign;
      e.m_deleted = (e_id==0);
      e.m_modified = (sign<0);
      e.m_hit_date = date(hit_date);
      this->append(e);
    }
  }
  catch (db_excpt p) {
    DBEXCPT(p);
    return false;
  }
  return true;
}
Esempio n. 3
0
// insert or update the address
bool
mail_address::store()
{
  db_cnx db;
  try {
    if (m_id) {
      sql_stream s("UPDATE addresses SET email_addr=:p1,name=:p2,notes=:p3,nickname=:p4,invalid=:p5 WHERE addr_id=:id", db);
      s << m_address << m_name << m_notes << m_nickname << m_invalid;
/*
      if (!m_date_last_sent.isEmpty())
	s << m_date_last_sent;
      else
	s << sql_null();
*/
      s << m_id;
    }
    else {
      if (!db.next_seq_val("seq_addr_id", &m_id))
	return false;
      sql_stream s("INSERT INTO addresses(addr_id,email_addr,name,notes,nickname,invalid) VALUES (:p1,:p2,:p3,:p4,:p5, :p6)", db);
      s << m_id << m_address << m_name << m_notes << m_nickname << m_invalid;
/*
      if (!m_date_last_sent.isEmpty())
	s << m_date_last_sent;
      else
	s << sql_null();
*/
    }
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
    return false;
  }
  return true;
}
Esempio n. 4
0
bool
message_tag::store()
{
  bool result=true;
  try {
    db_cnx db;
    if (m_tag_id<=0) {
      db.next_seq_val("seq_tag_id", &m_tag_id);
      sql_stream s("INSERT INTO tags(tag_id,name,parent_id) VALUES (:p1,:p2,:p3)", db);
      s << m_tag_id << m_name;
      if (m_parent_id)
	s << m_parent_id;
      else
	s << sql_null();
    }
    else {
      sql_stream s("UPDATE tags SET name=:p1, parent_id=:p3 where tag_id=:p2", db);
      s << m_name;
      if (m_parent_id)
	s << m_parent_id;
      else
	s << sql_null();
      s << m_tag_id;
    }
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
    result=false;
  }
  return result;
}
Esempio n. 5
0
/* Fill in the cache */
void
tags_repository::fetch()
{
  db_cnx db;
  try {
    /* The coalesce() converting parent_id from NULL to 0 is not technically
       necessary, because the sqlstream>>(int&) operator does it anyway,
       it's just for being explicit. */
    sql_stream s("SELECT tag_id,name,coalesce(parent_id,0) FROM tags", db);
    while (!s.eof()) {
      int id, parent_id;
      QString name;
      s >> id >> name >> parent_id;
      message_tag tag(id, name);
      if (parent_id)
	tag.set_parent_id(parent_id);
      m_tags_map[id] = tag;
    }
    m_tags_map_fetched=true;
  }
  catch(db_excpt& p) {
    m_tags_map.clear();
    m_tags_map_fetched=false;
    DBEXCPT(p);
  }
}
Esempio n. 6
0
bool
identities::fetch(bool force/*=false*/)
{
  if (!force && m_fetched)
    return true;

  db_cnx db;
  const QString default_email = get_config().get_string("default_identity");
  try {
    sql_stream s("SELECT identity_id, email_addr,username,xface,signature,root_tag,restricted FROM identities ORDER BY email_addr", db);
    while (!s.eos()) {
      mail_identity id;
      s >> id.m_identity_id;
      s >> id.m_email_addr >> id.m_name >> id.m_xface >> id.m_signature
	>> id.m_root_tag_id >> id.m_is_restricted;
      if (id.m_email_addr.isEmpty()) {
	// Ignore identities with no email to be safe. This shouldn't happen.
	continue;
      }
      id.m_fetched=true;
      id.m_orig_email_addr = id.m_email_addr;
      id.m_is_default = (id.m_email_addr == default_email);	
      (*this)[id.m_email_addr]=id;
    }
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
    clear();
    return false;
  }
  return true;
}
Esempio n. 7
0
void
db_cnx::handle_exception(db_excpt& e)
{
  if (m_alerts_enabled) {
    DBEXCPT(e);
  }
}
Esempio n. 8
0
bool
notepad::save()
{
  if (!m_we->document()->isModified())
    return true;

  const QString& t=m_we->toPlainText();
  db_cnx db;
  try {
    sql_stream s1("SELECT 1 FROM global_notepad", db);
    if (s1.eof()) {
      sql_stream s2("INSERT INTO global_notepad(contents,last_modified) VALUES(:p1, now())", db);
      s2 << t;
    }
    else {
      sql_stream s2("UPDATE global_notepad SET contents=:p1,last_modified=now()", db);
      s2 << t;
    }
  }
  catch (db_excpt& p) {
    DBEXCPT(p);
    return false;
  }
  disable_save();
  m_we->document()->setModified(false);
  return true;
}
Esempio n. 9
0
bool
db_cnx::next_seq_val(const char* seqName, unsigned int* id)
{
  try {
    QString query = QString("SELECT nextval('%1')").arg(seqName);
    sql_stream s(query, *this);
    s >> *id;
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
    return false;
  }
  return true;
}
void
role_perms_edit_dialog::set_checkboxes()
{
  db_ctxt dbc(true);
  try {
    if (m_role_oid > 0) {
      db_role role(m_role_oid);

      QList<db_obj_privilege> privs_for_read = db_obj_privilege::ability_privileges("read", &dbc);
      m_initial_privs[priv_read] = role.has_multiple_privileges(privs_for_read, &dbc);


      QList<db_obj_privilege> privs_for_update = db_obj_privilege::ability_privileges("update", &dbc);
      m_initial_privs[priv_update] = role.has_multiple_privileges(privs_for_update, &dbc);


      QList<db_obj_privilege> privs_for_trash = db_obj_privilege::ability_privileges("trash", &dbc);
      m_initial_privs[priv_trash] = role.has_multiple_privileges(privs_for_trash, &dbc);

      QList<db_obj_privilege> privs_for_delete = db_obj_privilege::ability_privileges("delete", &dbc);
      m_initial_privs[priv_delete] = role.has_multiple_privileges(privs_for_delete, &dbc);

      QList<db_obj_privilege> privs_for_compose = db_obj_privilege::ability_privileges("compose", &dbc);
      m_initial_privs[priv_compose] = role.has_multiple_privileges(privs_for_compose, &dbc);


      QList<db_obj_privilege> privs_for_basic_management = db_obj_privilege::ability_privileges("admin-level1", &dbc);
      m_initial_privs[priv_basic_management] = role.has_multiple_privileges(privs_for_basic_management, &dbc);
    }
    else {
      memset((void*)m_initial_privs, 0, sizeof(m_initial_privs));
    }

    m_perm_read->setChecked(m_initial_privs[priv_read]);
    m_perm_update->setChecked(m_initial_privs[priv_update]);
    m_perm_trash->setChecked(m_initial_privs[priv_trash]);
    m_perm_delete->setChecked(m_initial_privs[priv_delete]);
    m_perm_compose->setChecked(m_initial_privs[priv_compose]);
    m_perm_basic_management->setChecked(m_initial_privs[priv_basic_management]);

  }
  catch(db_excpt& p) {
    DBEXCPT (p);
  }
}
Esempio n. 11
0
bool
notepad::load()
{
  db_cnx db;
  try {
    sql_stream s ("SELECT contents FROM global_notepad", db);
    if (!s.eof()) {
      QString contents;
      s >> contents;
      set_contents(contents);
    }
  }
  catch (db_excpt& p) {
    DBEXCPT(p);
    return false;
  }
  return true;
}
Esempio n. 12
0
//static
QString
identities::email_from_id(int id)
{
  db_cnx db;
  try {
    QString res;
    sql_stream s("SELECT email_addr FROM identities WHERE identity_id=:p1", db);
    s << id;
    if (!s.eos()) {
      s >> res;
      return res;
    }
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
  }
  return QString();
}
Esempio n. 13
0
bool
db_cnx::next_seq_val(const char* seqName, int* id)
{
  try {
    begin_transaction();
    sql_stream update(QString("UPDATE sequence set value=value+1 where name='%1'").arg(seqName),
                      *this);
    sql_stream select(QString("SELECT value from sequence where name='%1'").arg(seqName),
                      *this);
    commit_transaction();
    select >> *id;
    -- *id;
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
    return false;
  }
  return true;
}
Esempio n. 14
0
bool
message_tag::remove()
{
  bool result=true;
  db_cnx db;
  try {
    DBG_PRINTF(5,"message_tag::remove(%u)\n", getId());
    db.begin_transaction();
    sql_stream s1("DELETE FROM mail_tags WHERE tag=:p1", db);
    s1 << getId();
    sql_stream s2("DELETE FROM tags WHERE tag_id=:p1", db);
    s2 << getId();
    db.commit_transaction();
  }
  catch(db_excpt& p) {
    db.rollback_transaction();
    DBEXCPT(p);
    result=false;
  }
  return result;
}
Esempio n. 15
0
db_listener::db_listener(db_cnx& db, const QString notif_name)
{
  m_socket_notifier = NULL;
  m_db = db.datab();
  try {
    /*sql_stream s1("SELECT quote_ident(:p1)", db);

    s1 << notif_name;
    if (!s1.isEmpty()) {
      s1 >> m_notif_name;
    }
    if (!m_notif_name.isEmpty()) {
      m_db->add_listener(this);
      setup_notification();
      setup_db();
    }*/
  }
  catch (db_excpt e)
  {
    DBEXCPT(e);
  }
}
// role_oid => list of identities that this role can access
QMap<int,bool>
role_perms_edit_dialog::accessible_identities(Oid role_oid, db_ctxt* dbc)
{
  db_cnx* db = dbc->m_db;
  QMap<int,bool> list;
  QString query = "SELECT identity_id FROM identities_permissions WHERE role_oid=:p1";
  try {
    sql_stream s(query, *db);
    s << role_oid;
    while (!s.eos()) {
      int id;
      s >> id;
      list.insert(id,true);
    }
  }
  catch(db_excpt& p) {
    if (dbc && dbc->propagate_exceptions)
      throw p;
    else
      DBEXCPT(p);
  }
  return list;
}
Esempio n. 17
0
/* Fill in the cache */
void
tags_repository::fetch()
{
  db_cnx db;
  try {
    sql_stream s("SELECT tag_id,name,coalesce(parent_id,0) FROM tags", db);
    while (!s.eof()) {
      int id, parent_id;
      QString name;
      s >> id >> name >> parent_id;
      message_tag tag(id, name);
      if (parent_id)
	tag.set_parent_id(parent_id);
      m_tags_map[id] = tag;
    }
    m_tags_map_fetched=true;
  }
  catch(db_excpt& p) {
    m_tags_map.clear();
    m_tags_map_fetched=false;
    DBEXCPT(p);
  }
}
Esempio n. 18
0
/*
  type="sent" or "recv"
*/
bool
mail_address::update_last_used(const QString type)
{
  db_cnx db;
  try {
    if (!m_id) {
      DBG_PRINTF(5,"warning: m_id=0\n");
      return false;
    }
    if (type=="sent") {
      sql_stream s("UPDATE addresses SET last_sent_to=:now:, nb_sent_to=1+coalesce(nb_sent_to,0) WHERE addr_id=:id", db);
      s << m_id;
    }
    else if (type=="recv") {
      sql_stream s("UPDATE addresses SET last_recv_from=:now: WHERE addr_id=:id", db);
      s << m_id;
    }
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
    return false;
  }
  return true;
}
void
user_edit_dialog::done(int r)
{
  bool success = false;
  if(QDialog::Accepted==r) {
    // ok was pressed
    if (check_valid()) {
      user u;
      get_user_fields(u);
      db_ctxt dbc;
      dbc.propagate_exceptions = true;
      try {
	dbc.m_db->begin_transaction();
	if (m_mode==new_user) {
	  success = create_new_user(u, &dbc);
	}
	else
	  success = update_user(u, &dbc);
	if (success)
	  success = update_granted_roles(u, &dbc);
	dbc.m_db->commit_transaction();
      }
      catch(db_excpt& p) {
	DBG_PRINTF(3, "exception caugth");
	dbc.m_db->rollback_transaction();
	success = false;
	DBEXCPT (p);
      }
      if (success)
	QDialog::done(r);
    }
  }
  else {
    QDialog::done(r);
  }
}
Esempio n. 20
0
bool
mail_identity::update_db()
{
  db_cnx db;
  try {
    sql_stream ss("SELECT 1 FROM identities WHERE email_addr=:p1", db);
    ss << m_orig_email_addr;
    if (!ss.eos()) {
      sql_stream su("UPDATE identities SET email_addr=:p1, username=:p2, xface=:p3, signature=:p4, restricted=:r, root_tag=nullif(:t,0) WHERE email_addr=:p5", db);
      su << m_email_addr << m_name << m_xface << m_signature << m_is_restricted << m_root_tag_id;
      su << m_orig_email_addr;
    }
    else {
      sql_stream si("INSERT INTO identities(email_addr,username,xface,signature,restricted,root_tag) VALUES (:p1,:p2,:p3,:p4,:p5,nullif(:p6,0))", db);
      si << m_email_addr << m_name << m_xface << m_signature << m_is_restricted << m_root_tag_id;
    }
    m_orig_email_addr = m_email_addr;
  }
  catch(db_excpt& p) {
    DBEXCPT(p);
    return false;
  }
  return true;
}
void
role_perms_edit_dialog::set_grants()
{
  db_ctxt dbc(true);
  struct { QCheckBox* checkbox; const char* ability; }
  mail_perms[] = {
    {m_perm_read, "read"},
    {m_perm_update, "update"},
    {m_perm_trash, "trash"},
    {m_perm_delete, "delete"},
    {m_perm_compose, "compose"},
    {m_perm_basic_management, "admin-level1"},
  };

  QString rolname = m_role_name->text().trimmed();

  try {
    dbc.m_db->begin_transaction();
    if (!m_role_oid) {
      // Create the new role
      user::create_db_user(rolname, QString(), false, &dbc);
      m_role_oid = user::oid_db_role(rolname, true);
      if (!m_role_oid) {
	QMessageBox::critical(this, tr("Error"), tr("The role could not be created."));
	return;
      }
    }

    db_role role(m_role_oid);
    role.fetch_properties(&dbc);

    if (rolname != role.name()) {
      // Rename it in the db
      role.rename(rolname, &dbc);
    }

    for (uint iperm=0; iperm<sizeof(mail_perms)/sizeof(mail_perms[0]); iperm++) {
      // Set or unset permissions to exercise ability on messages
      DBG_PRINTF(5, "processing permissions for ability: %s", mail_perms[iperm].ability);
      QList<db_obj_privilege> privs = db_obj_privilege::ability_privileges(mail_perms[iperm].ability, &dbc);
      for (int pi=0; pi < privs.size(); pi++) {
	if (mail_perms[iperm].checkbox->isChecked())
	  role.grant(privs.at(pi), &dbc);
	else
	  role.revoke(privs.at(pi), &dbc);
      }
    }

    if (dbc.m_db->datab()->has_row_level_security()) {
      QList<int> list_ids;  // list of checked private identities
      bool ids_changed = false;	// did any checkbox switch state?
      for (int row=0; row < m_list_idents->count(); row++) {
	QListWidgetItem* item = m_list_idents->item(row);
	int iid = item->data(Qt::UserRole).toInt(); // identity_id
	if ((item->checkState() == Qt::Checked) != m_a_ids.contains(iid)) // compare 2 states
	  ids_changed = true;
	if (item->checkState() == Qt::Checked)
	  list_ids.append(iid);
      }
      if (ids_changed) {
	// call set_identity_permissions(in_oid, in_identities int[], in_perms char[] = ['A']);
	sql_stream s("select set_identity_permissions(:o, :t, null)", *dbc.m_db);
	s << m_role_oid << list_ids;
      }
    }
    dbc.m_db->commit_transaction();
  }
  catch(db_excpt& p) {
    dbc.m_db->rollback_transaction();
    DBEXCPT (p);
  }
}