src/flbase/FLSqlCursor.h

Ir a la documentación de este archivo.

/***************************************************************************
                      FLSqlCursor.h  -  description
                         -------------------
begin                : Fri Jul 27 2001
copyright            : (C) 2001-2005 by InfoSiAL S.L.
email                : mail@infosial.com
***************************************************************************/
/***************************************************************************
 *   This program 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; version 2 of the License.               *
 ***************************************************************************/
/***************************************************************************
   Este  programa es software libre. Puede redistribuirlo y/o modificarlo
   bajo  los  términos  de  la  Licencia  Pública General de GNU   en  su
   versión 2, publicada  por  la  Free  Software Foundation.
 ***************************************************************************/

#ifndef FLSQLCURSOR_H
#define FLSQLCURSOR_H

#include <qvaluelist.h>
#include <qvariant.h>
#include <qsqlcursor.h>
#include <qsqlindex.h>
#include <qobject.h>
#include <qmessagebox.h>
#include <qdatetime.h>
#include <qregexp.h>
#include <qptrstack.h>
#include <qptrqueue.h>
#include <qdict.h>
#include <qvaluestack.h>
#include <qlabel.h>

class FLTableMetaData;
class FLRelationMetaData;
class FLAction;
class FLSqlSavePoint;
class FLSqlDatabase;
class FLSqlCursor;
class FLAccessControl;

class FLSqlCursorPrivate
{
public:

  FLSqlCursorPrivate();
  ~FLSqlCursorPrivate();

  QSqlRecord *buffer_;

  QSqlRecord *bufferCopy_;

  FLTableMetaData *metadata_;

  int modeAccess_;

  FLSqlCursor *cursorRelation_;

  FLRelationMetaData *relation;

  bool edition;

  bool browse;

  QString mainFilter_;

  const FLAction *action_;

  bool askForCancelChanges_;

  bool activatedCheckIntegrity_;

  bool activatedCommitActions_;

  QObject *ctxt_;

  QTimer *timer;

  bool populated_;

  QString query_;

  QString queryOrderBy_;

  FLSqlDatabase *db_;

  QMap < QString, int > mapPosByPK;

  QValueStack < int > transactionsOpened;

  QString persistentFilter_;

  FLSqlCursor *cursor_;

  bool inLoopRisksLocks_;
  bool inRisksLocks_;
  QLabel *modalRisksLocks_;
  QTimer *timerRisksLocks_;

  void doAcl();
  void undoAcl();
  FLAccessControl *acTable_;
  QString acPermTable_;
  QString acPermBackupTable_;
  QStringList acosTable_;
  QStringList acosBackupTable_;
  QString acosCondName_;
  int acosCond_;
  QVariant acosCondVal_;
  int lastAt_;
  bool aclDone_;
  QStringList fieldsNamesUnlock_;
  int idAc_, idAcos_, idCond_;
  QString id_;
  bool isQuery_;
  bool isSysTable_;
};

class FL_EXPORT FLSqlCursor: public QObject, public QSqlCursor
{

  Q_OBJECT

public:

  FLSqlCursor(const QString &name = QString::null, bool autopopulate = true,
              const QString &connectionName = "default", FLSqlCursor *cR = 0,
              FLRelationMetaData *r = 0, QObject *parent = 0);

  FLSqlCursor(const QString &name, bool autopopulate, QSqlDatabase *db, FLSqlCursor *cR = 0,
              FLRelationMetaData *r = 0, QObject *parent = 0);

  ~FLSqlCursor();

  enum Mode {
    INSERT = 0,
    EDIT = 1,
    DEL = 2,
    BROWSE = 3
  };

  enum AcosConditionEval {
    VALUE = 0,
    REGEXP = 1,
    FUNCTION = 2
  };

  FLTableMetaData *metadata() const {
    return d->metadata_;
  }

  int modeAccess() const {
    return d->modeAccess_;
  }

  QString mainFilter() const {
    return d->mainFilter_;
  }

  const FLAction *action() const {
    return d->action_;
  }

  void setAction(const FLAction *a) {
    d->action_ = a;
  }

  void setMainFilter(const QString &f);

  void setModeAccess(const int m) {
    d->modeAccess_ = m;
  }

  void setAtomicValueBuffer(const QString &fN, const QString &functionName);

  void setValueBuffer(const QString &fN, const QVariant &v);

  QVariant valueBuffer(const QString &fN);

  QVariant valueBufferCopy(const QString &fN) const;

  void setEdition(bool b);
  void setBrowse(bool b);

  void setContext(QObject *c);

  QObject *context() const {
    return d->ctxt_;
  }

  bool fieldDisabled(const QString &fN);

  static bool inTransaction();

  bool transaction(bool lock = false);

  bool rollback();

  bool commit(bool notify = true);

  void openFormInMode(int m, bool cont = true);

  void updateBufferCopy();

  bool isModifiedBuffer();

  void setAskForCancelChanges(bool a) {
    d->askForCancelChanges_ = a;
  }

  void setActivatedCheckIntegrity(bool a) {
    d->activatedCheckIntegrity_ = a;
  }

  void setActivatedCommitActions(bool a) {
    d->activatedCommitActions_ = a;
  }

  QString msgCheckIntegrity();

  bool checkIntegrity(bool showError = true);

  FLSqlCursor *cursorRelation() const {
    return d->cursorRelation_;
  }
  FLRelationMetaData *relation() const {
    return d->relation;
  }

  void setUnLock(const QString &fN, bool v);

  bool isLocked();

  bool bufferIsNull(int i) const;

  bool bufferIsNull(const QString &name) const;

  void bufferSetNull(int i) const;

  void bufferSetNull(const QString &name) const;

  bool bufferCopyIsNull(int i) const;

  bool bufferCopyIsNull(const QString &name) const;

  void bufferCopySetNull(int i) const;

  void bufferCopySetNull(const QString &name) const;

  int atFrom();

  int atFromBinarySearch(const QString &fN, const QString &v, bool orderAsc = true);

  bool exec(const QString &query);

#ifdef FL_DEBUG
  static long countRefCursor;
#endif

  FLSqlDatabase *db() const {
    return d->db_;
  }

protected:

  QVariant calculateField(const QString &name);

  void afterSeek();

public slots:

  void refresh(const QString &fN = QString::null);

  void refreshDelayed(int msec = 50);

  bool refreshBuffer();

  bool setEditMode();

  bool seek(int i, bool relative = false, bool emite = false);

  bool next(bool emite = true);

  bool prev(bool emite = true);

  bool first(bool emite = true);

  bool last(bool emite = true);

  int del(bool invalidate = true);

  bool select(const QString &filter, const QSqlIndex &sort = QSqlIndex());

  void setSort(const QSqlIndex &sort);

  QString baseFilter();

  QString curFilter();

  void setFilter(const QString &filter);

  void insertRecord();

  void editRecord();

  void browseRecord();

  void deleteRecord();

  void copyRecord();

  void chooseRecord();

  bool commitBuffer(bool emite = true, bool checkLocks = false);

  bool commitBufferCursorRelation();

  static int transactionLevel();

  QStringList transactionsOpened();

  void rollbackOpened(int count = -1, const QString &msg = QString::null);

  void commitOpened(int count = -1, const QString &msg = QString::null);

  void checkRisksLocks(bool terminate = false);

  void setAcTable(const QString &ac);

  void setAcosTable(const QStringList &acos);

  void setAcosCondition(const QString &condName, AcosConditionEval cond, const QVariant &condVal);

  QStringList concurrencyFields();

private:

  FLSqlCursorPrivate *d;

  static int transaction_;

  static QPtrStack < FLSqlSavePoint > * stackSavePoints;

  static QPtrQueue < FLSqlSavePoint > * queueSavePoints;

  static FLSqlSavePoint *currentSavePoint;

  void populateCursor();

  void setNotGenerateds();

  void clearMapPosByPK();

signals:

  void newBuffer();

  void bufferChanged(const QString &);

  void cursorUpdated();

  void recordChoosed();

  void currentChanged(int);

  void autoCommit();

  void bufferCommited();

private slots:

  void clearPersistentFilter();
};

#endif