/*
 * Copyright (C) 2007 by CERN/IT/GD/ITR
 * All rights reserved
 */

#ifndef lint
static char sccsid[] = "@(#)$RCSfile: dicomcopy_oracle_ifce.pc,v $ $Revision: 1.1 $ $Date: 2008/01/14 10:06:10 $ CERN IT-GD/ITR Jean-Philippe Baud";
#endif /* not lint */

#include <errno.h>
#include <sys/types.h>
#include <sqlca.h>
#ifndef USE_ORACLE
#define USE_ORACLE
#endif
#include "dicomcopy_server.h"
#include "dpm.h"
#include "dpm_backend.h"
#include "dpm_server.h"
#include "serrno.h"
extern void dpm_oracle_error(char *, char *, struct dpm_dbfd *, struct sqlca *sqlca);
extern sql_context dpm_oracle_ctx[];

#ifdef _THREAD_SAFE
	EXEC SQL CONTEXT USE :dpm_oracle_ctx[dbfd->idx];
#endif

dpm_delete_dfr_entry(dbfd, rec_addr)
struct dpm_dbfd *dbfd;
dpm_dbrec_addr *rec_addr;
{
	char func[21];
	char rowid_value[19];
	struct sqlca sqlca;

	strcpy (func, "dpm_delete_dfr_entry");
	memcpy (rowid_value, rec_addr, sizeof(rowid_value));
	EXEC SQL DELETE FROM dpm_dicom_filereq WHERE ROWID = :rowid_value;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "DELETE", dbfd, &sqlca);
		return (-1);
	}
	return (0);
}

dpm_delete_dicomreq_entry(dbfd, rec_addr)
struct dpm_dbfd *dbfd;
dpm_dbrec_addr *rec_addr;
{
	char func[26];
	char rowid_value[19];
	struct sqlca sqlca;

	strcpy (func, "dpm_delete_dicomreq_entry");
	memcpy (rowid_value, rec_addr, sizeof(rowid_value));
	EXEC SQL DELETE FROM dpm_dicom_req WHERE ROWID = :rowid_value;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "DELETE", dbfd, &sqlca);
		return (-1);
	}
	return (0);
}

dpm_get_dfr_by_fullid(dbfd, r_token, f_ordinal, dfr_entry, lock, rec_addr)
struct dpm_dbfd *dbfd;
char *r_token; 
int f_ordinal;
struct dpm_dicom_filereq *dfr_entry;
int lock;
dpm_dbrec_addr *rec_addr;
{
	char func[22];
	char rowid_value[19];
	struct sqlca sqlca;
	EXEC SQL DECLARE dfr_fullid_cursor4upd CURSOR FOR
                SELECT ROWID,
                 R_TOKEN, F_ORDINAL, SURL,
                 DICOM_FN, STATUS
                FROM dpm_dicom_filereq
                WHERE r_token = :r_token AND f_ordinal = :f_ordinal
                FOR UPDATE;

	strcpy (func, "dpm_get_dfr_by_fullid");
	EXEC SQL OPEN dfr_fullid_cursor4upd;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "OPEN CURSOR", dbfd, &sqlca);
		return (-1);
	}
	EXEC SQL FETCH dfr_fullid_cursor4upd INTO
	 :rowid_value,
	 :dfr_entry->r_token, :dfr_entry->f_ordinal, :dfr_entry->surl,
	 :dfr_entry->dicom_fn, :dfr_entry->status;
	switch (sqlca.sqlcode) {
	case 0:
		memcpy (rec_addr, rowid_value, sizeof(rowid_value));
		return (0);
	case 1403:
		serrno = ENOENT;
		break;
	default:
		dpm_oracle_error (func, "FETCH", dbfd, &sqlca);
	}
	return (-1);
}

dpm_get_dfr_by_surl(dbfd, r_token, surl, dfr_entry, lock, rec_addr)
struct dpm_dbfd *dbfd;
char *r_token;
char *surl;
struct dpm_dicom_filereq *dfr_entry;
int lock;
dpm_dbrec_addr *rec_addr;
{
	char func[20];
	char rowid_value[19];
	struct sqlca sqlca;
	EXEC SQL DECLARE dfr_surl_cursor4upd CURSOR FOR
                SELECT ROWID,
                 R_TOKEN, F_ORDINAL, SURL,
                 DICOM_FN, STATUS
                FROM dpm_dicom_filereq
                WHERE r_token = :r_token AND surl = :surl
                FOR UPDATE;

	strcpy (func, "dpm_get_dfr_by_surl");
	EXEC SQL OPEN dfr_surl_cursor4upd;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "OPEN CURSOR", dbfd, &sqlca);
		return (-1);
	}
	EXEC SQL FETCH dfr_surl_cursor4upd INTO
	 :rowid_value,
	 :dfr_entry->r_token, :dfr_entry->f_ordinal, :dfr_entry->surl,
	 :dfr_entry->dicom_fn, :dfr_entry->status;
	switch (sqlca.sqlcode) {
	case 0:
		memcpy (rec_addr, rowid_value, sizeof(rowid_value));
		return (0);
	case 1403:
		serrno = ENOENT;
		break;
	default:
		dpm_oracle_error (func, "FETCH", dbfd, &sqlca);
	}
	return (-1);
}

dpm_get_dicomreq_by_token(dbfd, token, dpm_req, lock, rec_addr)
struct dpm_dbfd *dbfd;
char *token;
struct dpm_backend_req *dpm_req;
int lock;
dpm_dbrec_addr *rec_addr;
{
	char func[26];
	char rowid_value[19];
	struct sqlca sqlca;
	short st_ind;	/* indicator variable for s_token column */
	EXEC SQL DECLARE d_req_token_cursor4upd CURSOR FOR
		SELECT ROWID,
		 R_ORDINAL, R_TOKEN, R_UID,
		 R_GID, CLIENT_DN, GROUPS,
		 CLIENTHOST, RETRYTIME, LIFETIME,
		 S_TOKEN, RET_POLICY, F_TYPE,
		 NBREQFILES, CTIME, STATUS
		FROM dpm_dicom_req
		WHERE r_token = :token
		FOR UPDATE;

	strcpy (func, "dpm_get_dicomreq_by_token");
	EXEC SQL OPEN d_req_token_cursor4upd;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "OPEN CURSOR", dbfd, &sqlca);
		return (-1);
	}
	EXEC SQL FETCH d_req_token_cursor4upd INTO
	 :rowid_value,
	 :dpm_req->r_ordinal, :dpm_req->r_token, :dpm_req->r_uid,
	 :dpm_req->r_gid, :dpm_req->client_dn, :dpm_req->groups,
	 :dpm_req->clienthost, :dpm_req->retrytime, :dpm_req->lifetime,
	 :dpm_req->s_token:st_ind, :dpm_req->ret_policy, :dpm_req->f_type,
	 :dpm_req->nbreqfiles, :dpm_req->ctime, :dpm_req->status;
	switch (sqlca.sqlcode) {
	case 0:
		if (lock)
			memcpy (rec_addr, rowid_value, sizeof(rowid_value));
		if (st_ind == -1)
			*dpm_req->s_token = '\0';
		return (0);
	case 1403:
		serrno = ENOENT;
		break;
	default:
		dpm_oracle_error (func, "FETCH", dbfd, &sqlca);
	}
	return (-1);
}

dpm_get_next_dicomreq(dbfd, status, dpm_req, lock, rec_addr)
struct dpm_dbfd *dbfd;
int status;
struct dpm_backend_req *dpm_req;
int lock;
dpm_dbrec_addr *rec_addr;
{
	char func[22];
	char rowid_value[19];
	struct sqlca sqlca;
	short st_ind;	/* indicator variable for s_token column */
	EXEC SQL DECLARE next_dicomreq_cursor4upd CURSOR FOR
		SELECT ROWID,
		 R_ORDINAL, R_TOKEN, R_UID,
		 R_GID, CLIENT_DN, GROUPS,
		 CLIENTHOST, RETRYTIME, LIFETIME,
		 S_TOKEN, RET_POLICY, F_TYPE,
		 NBREQFILES, CTIME, STATUS
		FROM dpm_dicom_req WHERE ROWID =
			(SELECT R FROM
				(SELECT ROWID R FROM dpm_dicom_req
				WHERE status = :status
				ORDER BY ctime, r_ordinal)
			 WHERE ROWNUM = 1)
		FOR UPDATE;

	strcpy (func, "dpm_get_next_dicomreq");
	EXEC SQL OPEN next_dicomreq_cursor4upd;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "OPEN CURSOR", dbfd, &sqlca);
		return (-1);
	}
	EXEC SQL FETCH next_dicomreq_cursor4upd INTO
	 :rowid_value,
	 :dpm_req->r_ordinal, :dpm_req->r_token, :dpm_req->r_uid,
	 :dpm_req->r_gid, :dpm_req->client_dn, :dpm_req->groups,
	 :dpm_req->clienthost, :dpm_req->retrytime, :dpm_req->lifetime,
	 :dpm_req->s_token:st_ind, :dpm_req->ret_policy, :dpm_req->f_type,
	 :dpm_req->nbreqfiles, :dpm_req->ctime, :dpm_req->status;
	switch (sqlca.sqlcode) {
	case 0:
		if (lock)
			memcpy (rec_addr, rowid_value, sizeof(rowid_value));
		if (st_ind == -1)
			*dpm_req->s_token = '\0';
		return (0);
	case 1403:
		serrno = ENOENT;
		break;
	default:
		dpm_oracle_error (func, "FETCH", dbfd, &sqlca);
	}
	return (-1);
}

dpm_insert_dfr_entry(dbfd, dfr_entry)
struct dpm_dbfd *dbfd;
struct dpm_dicom_filereq *dfr_entry;
{
	char func[21];
	struct sqlca sqlca;

	strcpy (func, "dpm_insert_dfr_entry");
	EXEC SQL INSERT INTO dpm_dicom_filereq
		(R_TOKEN, F_ORDINAL, SURL,
		 DICOM_FN, STATUS)
		VALUES
		(:dfr_entry->r_token, :dfr_entry->f_ordinal, :dfr_entry->surl,
		 :dfr_entry->dicom_fn, :dfr_entry->status);
	switch (sqlca.sqlcode) {
	case 0:
		return (0);
	case -1:
		serrno = EEXIST;
		break;
	case -1631:
	case -1632:
	case -1654:
		serrno = ENOSPC;
		break;
	default:
		dpm_oracle_error (func, "INSERT", dbfd, &sqlca);
	}
	return (-1);
}

dpm_insert_dicomreq_entry(dbfd, dpm_req)
struct dpm_dbfd *dbfd;
struct dpm_backend_req *dpm_req;
{
	char func[26];
	struct sqlca sqlca;

	strcpy (func, "dpm_insert_dicomreq_entry");
	EXEC SQL INSERT INTO dpm_dicom_req
		(R_ORDINAL, R_TOKEN, R_UID,
		 R_GID, CLIENT_DN, GROUPS,
		 CLIENTHOST, RETRYTIME, LIFETIME,
		 S_TOKEN, RET_POLICY, F_TYPE,
		 NBREQFILES, CTIME, STATUS)
		VALUES
		(:dpm_req->r_ordinal, :dpm_req->r_token, :dpm_req->r_uid,
		 :dpm_req->r_gid, :dpm_req->client_dn, :dpm_req->groups,
		 :dpm_req->clienthost, :dpm_req->retrytime, :dpm_req->lifetime,
		 :dpm_req->s_token, :dpm_req->ret_policy, :dpm_req->f_type,
		 :dpm_req->nbreqfiles, :dpm_req->ctime, :dpm_req->status);
	switch (sqlca.sqlcode) {
	case 0:
		return (0);
	case -1:
		serrno = EEXIST;
		break;
	case -1631:
	case -1632:
	case -1654:
		serrno = ENOSPC;
		break;
	default:
		dpm_oracle_error (func, "INSERT", dbfd, &sqlca);
	}
	return (-1);
}

dpm_list_dfr_by_surl(dbfd, bol, surl, dfr_entry, lock, rec_addr, endlist, dblistptr)
struct dpm_dbfd *dbfd;
int bol;
char *surl;
struct dpm_dicom_filereq *dfr_entry; 
int lock;
dpm_dbrec_addr *rec_addr;
int endlist;
DBLISTPTR *dblistptr;
{
	char func[21];
	char rowid_value[19];
	struct sqlca sqlca;
	EXEC SQL DECLARE list_dfr_surl_cursor CURSOR FOR 
		SELECT
		 R_TOKEN, F_ORDINAL, SURL,
		 DICOM_FN, STATUS
		FROM dpm_dicom_filereq
		WHERE surl = :surl;
	EXEC SQL DECLARE list_dfr_surl_cursor4upd CURSOR FOR 
		SELECT ROWID,
		 R_TOKEN, F_ORDINAL, SURL,
		 DICOM_FN, STATUS
		FROM dpm_dicom_filereq
		WHERE surl = :surl
		FOR UPDATE;

	strcpy (func, "dpm_list_dfr_by_surl");
	if (endlist)
		return (1);
	if (bol) {
		if (lock)
			EXEC SQL OPEN list_dfr_surl_cursor4upd;
		else
			EXEC SQL OPEN list_dfr_surl_cursor;
		if (sqlca.sqlcode) {
			dpm_oracle_error (func, "OPEN CURSOR", dbfd, &sqlca);
			return (-1);
		}
	}
	if (lock)
		EXEC SQL FETCH list_dfr_surl_cursor4upd INTO
		 :rowid_value,
		 :dfr_entry->r_token, :dfr_entry->f_ordinal, :dfr_entry->surl,
		 :dfr_entry->dicom_fn, :dfr_entry->status;
	else
		EXEC SQL FETCH list_dfr_surl_cursor INTO
		 :dfr_entry->r_token, :dfr_entry->f_ordinal, :dfr_entry->surl,
		 :dfr_entry->dicom_fn, :dfr_entry->status;
	switch (sqlca.sqlcode) {
	case 0:
		return (0);
	case 1403:
		return (1);
	default:
		dpm_oracle_error (func, "FETCH", dbfd, &sqlca);
		return (-1);
	}
}

dpm_list_pending_dicomreq(dbfd, bol, dpm_req, endlist, dblistptr)
struct dpm_dbfd *dbfd;
int bol;
struct dpm_backend_req *dpm_req; 
int endlist;
DBLISTPTR *dblistptr;
{
	char func[26];
	char rowid_value[19];
	struct sqlca sqlca;
	short st_ind;	/* indicator variable for s_token column */
	int status_queued = DPM_QUEUED;
	EXEC SQL DECLARE list_pending_dicom_cursor CURSOR FOR 
		SELECT
		 R_ORDINAL, R_TOKEN, R_UID,
		 R_GID, CLIENT_DN, GROUPS,
		 CLIENTHOST, RETRYTIME, LIFETIME,
		 S_TOKEN, RET_POLICY, F_TYPE,
		 NBREQFILES, CTIME, STATUS
		FROM dpm_dicom_req
		WHERE status = :status_queued;

	strcpy (func, "dpm_list_pending_dicomreq");
	if (endlist)
		return (1);
	if (bol) {
		EXEC SQL OPEN list_pending_dicom_cursor;
		if (sqlca.sqlcode) {
			dpm_oracle_error (func, "OPEN CURSOR", dbfd, &sqlca);
			return (-1);
		}
	}
	EXEC SQL FETCH list_pending_dicom_cursor INTO
	 :dpm_req->r_ordinal, :dpm_req->r_token, :dpm_req->r_uid,
	 :dpm_req->r_gid, :dpm_req->client_dn, :dpm_req->groups,
	 :dpm_req->clienthost, :dpm_req->retrytime, :dpm_req->lifetime,
	 :dpm_req->s_token:st_ind, :dpm_req->ret_policy, :dpm_req->f_type,
	 :dpm_req->nbreqfiles, :dpm_req->ctime, :dpm_req->status;
	switch (sqlca.sqlcode) {
	case 0:
		if (st_ind == -1)
			*dpm_req->s_token = '\0';
		return (0);
	case 1403:
		return (1);
	default:
		dpm_oracle_error (func, "FETCH", dbfd, &sqlca);
		return (-1);
	}
}

dpm_update_dfr_entry (dbfd, rec_addr, dfr_entry)
struct dpm_dbfd *dbfd;
dpm_dbrec_addr *rec_addr;
struct dpm_dicom_filereq *dfr_entry;
{
	char func[21];
	char rowid_value[19];
	struct sqlca sqlca;

	strcpy (func, "dpm_update_dfr_entry");
	memcpy (rowid_value, rec_addr, sizeof(rowid_value));
	EXEC SQL UPDATE dpm_dicom_filereq SET
		STATUS	= :dfr_entry->status
		WHERE ROWID = :rowid_value;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "UPDATE", dbfd, &sqlca);
		return (-1);
	}
	return (0);
}

dpm_update_dicomreq_entry (dbfd, rec_addr, dpm_req)
struct dpm_dbfd *dbfd;
dpm_dbrec_addr *rec_addr;
struct dpm_backend_req *dpm_req;
{
	char func[26];
	char rowid_value[19];
	struct sqlca sqlca;

	strcpy (func, "dpm_update_dicomreq_entry");
	memcpy (rowid_value, rec_addr, sizeof(rowid_value));
	EXEC SQL UPDATE dpm_dicom_req SET
		STATUS	= :dpm_req->status
		WHERE ROWID = :rowid_value;
	if (sqlca.sqlcode) {
		dpm_oracle_error (func, "UPDATE", dbfd, &sqlca);
		return (-1);
	}
	return (0);
}