head	1.7;
access;
symbols;
locks
	cbbrowne:1.7; strict;
comment	@ * @;


1.7
date	2000.07.17.05.29.20;	author cbbrowne;	state Exp;
branches;
next	1.6;

1.6
date	2000.06.25.05.27.47;	author cbbrowne;	state Exp;
branches;
next	1.5;

1.5
date	2000.06.25.02.29.21;	author cbbrowne;	state Exp;
branches;
next	1.4;

1.4
date	2000.06.24.13.45.00;	author cbbrowne;	state Exp;
branches;
next	1.3;

1.3
date	2000.06.24.13.06.33;	author cbbrowne;	state Exp;
branches;
next	1.2;

1.2
date	2000.06.24.03.27.41;	author cbbrowne;	state Exp;
branches;
next	1.1;

1.1
date	2000.06.19.06.17.58;	author cbbrowne;	state Exp;
branches;
next	;


desc
@@


1.7
log
@*** empty log message ***
@
text
@/*
  DVD Store Application Reference API Implementation
  
  This file contains definitions of functions conforming
  to the DVD Store application database APIs.
 */
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include "dvd.h"
#include "dvdc.h"

static void open_factory_error (CORBA_Object interface, 
				char *interfacename);
/* CORBA structures */
static CORBA_Environment ev;
static CORBA_ORB orb;
static CORBA_Object dvd_client;
static DVD_MEMBERSHIP membership;
static DVD_TITLING titling;
static DVD_DISKS disks;
static DVD_RENTAL rental;
static DVD_RESERVATIONS reservations;
static DVD_UTILITIES utilities;

/* This function does the setup to establish the connection to
   ORBit. */

#define IORLOCATION "../server/dvd-server.ior"

void ConnectORB (int argc, char *argv[]) {
  FILE *ifp; 
  char *ior;
  char filebuffer[1024];
  /* Start up the exception handler */
  CORBA_exception_init(&ev);  
  /* Request a connection to ORBit */ 
  orb = CORBA_ORB_init(&argc, argv, "orbit-local-orb", &ev);  
  ifp = fopen(IORLOCATION,"r");
  if( ifp == NULL ) {
    printf("No dvd-server.ior file!");
    exit(-1);
  }
  fgets(filebuffer,1024,ifp);
  printf("%s\n", filebuffer);
  ior = g_strdup(filebuffer);
  fclose(ifp);
  dvd_client = CORBA_ORB_string_to_object(orb, ior, &ev);
  if (!dvd_client) {
    printf("Cannot bind to IOR: %s\n", ior);
    exit(-1);
  }
}
/* A logical extension at this point would be to insert some
   security validation, so that only those interfaces that the user
   is permitted to access are in fact set by this process. 
   
   We'd add an "authentication token" as an argument to each of
   these factory functions; the instantiations of interfaces would
   then fail as "needed" in that the server would refuse to return
   the interface reference. */

/* This "Factory" is used to get references to all of the CORBA
   interfaces used in this package. */

int Build_Factories(void) 
{
  /*  printf("Opening Factories...");  */
  membership = DVD_FACTORY_MEMBERSHIPFactory(dvd_client, &ev);
  open_factory_error(membership, "membership");
  if (ev._major != CORBA_NO_EXCEPTION) {
     printf("Got CORBA exception %d/%s\n", ev._major, 
       CORBA_exception_id(&ev));
    CORBA_exception_free(&ev);
    return DVD_ERR_CORBA_EXCEPTION;
  }
  titling = DVD_FACTORY_TITLINGFactory(dvd_client, &ev); 
  if (ev._major != CORBA_NO_EXCEPTION) {
     printf("Got CORBA exception %d/%s\n", ev._major, 
       CORBA_exception_id(&ev)); 
    CORBA_exception_free(&ev);
    return DVD_ERR_CORBA_EXCEPTION;
  }
  open_factory_error(titling, "titling");
  disks = DVD_FACTORY_DISKSFactory(dvd_client, &ev); 
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major, 
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev);
    return DVD_ERR_CORBA_EXCEPTION;
  }
  open_factory_error(disks, "disks");
  rental = DVD_FACTORY_RENTALFactory(dvd_client, &ev); 
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major, 
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev);
    return DVD_ERR_CORBA_EXCEPTION;
  }
  open_factory_error(rental, "rental");
  reservations = DVD_FACTORY_RESERVATIONSFactory(dvd_client, &ev); 
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major, 
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev);
    return DVD_ERR_CORBA_EXCEPTION;
  }
  open_factory_error(reservations, "reservations");
  utilities = DVD_FACTORY_UTILITIESFactory(dvd_client, &ev); 
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major, 
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev);
    return DVD_ERR_CORBA_EXCEPTION;
  }
  open_factory_error(utilities, "utilities");
  return DVD_SUCCESS;
}

int dvd_member_set(dvd_store_member *member)
{
  DVD_MEMBERSHIP_storemembers *memout;
  /*  printf("Set: dvd_store_member\n"); */
  if(member == NULL) {
    return DVD_ERR_NULL_POINTER;
  } else {
    memout= DVD_MEMBERSHIP_storemembers__alloc();
    memout->memberid = member->member_id;
    memout->memberno = member->member_no;
    memout->title = member->title;
    memout->fname = member->fname;
    memout->lname = member->lname;
    memout->houseflatref = member->house_flat_ref;
    memout->address1 = member->address1;
    memout->address2 = member->address2;
    memout->town = member->town;
    memout->state = member->state;
    memout->phone = member->phone;
    memout->zipcode = member->zipcode;
    DVD_MEMBERSHIP_set (membership, memout, &ev);
    if (ev._major != CORBA_NO_EXCEPTION) {
      printf("Got CORBA exception %d/%s\n", ev._major, 
	     CORBA_exception_id(&ev));
      return DVD_SUCCESS;
    }
  }
  return DVD_SUCCESS;
}

int dvd_member_get(int member_id, dvd_store_member *member)
{
  DVD_MEMBERSHIP_storemembers *cmember;
  int rc=0;
  if(member == NULL) {
    return DVD_ERR_NULL_POINTER;
  } else {
    DVD_MEMBERSHIP_get (membership, member_id, &cmember, &ev);
  }
  switch (ev._major) {
  case CORBA_NO_EXCEPTION: 
    rc = 0;
    break;
  case CORBA_SYSTEM_EXCEPTION:
    printf("Got CORBA exception %d/%d from DVD_MEMBERSHIP_get", 
	   ev._major,
	   (int) CORBA_exception_value(&ev));
    return DVD_ERR_NOT_FOUND;
    
  case CORBA_USER_EXCEPTION:
    printf("Error: %s\n", CORBA_exception_id(&ev));
    return DVD_ERR_NOT_FOUND;
  }
  if (rc != 0)   /* If we had an exception above... */
    return rc;
  /* If the retrieved member id is not as expected there
     may be an error, or the member may be deleted */
  if(member_id != cmember->memberid)
    return (int) DVD_ERR_NOT_FOUND;
  member->member_id = cmember->memberid; 
  strncpy(member->member_no, cmember->memberno, 6);
  strncpy(member->title, cmember->title, 4);
  strncpy(member->fname, cmember->fname, 26);
  strncpy(member->lname, cmember->lname, 26);
  strncpy(member->house_flat_ref, cmember->houseflatref, 26);
  strncpy(member->address1, cmember->address1, 51);
  strncpy(member->address2, cmember->address2, 51);
  strncpy(member->town, cmember->town, 51);
  strncpy(member->state, cmember->state, 3);
  strncpy(member->phone, cmember->phone, 31);
  strncpy(member->zipcode, cmember->zipcode, 11);
  /*  printf("Member: %d %s %s %s %s", member->member_id,
	 member->member_no, member->fname, member->lname,
	 member->zipcode); */
  return DVD_SUCCESS;
}

/* Make a new member record. The caller does not need to fill-in
   the member_id or member_no fields, these will be created before
   the member record is added to the database. The new meber_id
   is returned in the output parameter member_id. This must be
   use to retrieve the new member record to discover or set the
   member_no.
   */
int dvd_member_create(dvd_store_member *newrec, int *member_id)
{
  DVD_MEMBERSHIP_storemembers *memout;
  DVD_MEMBERSHIP_memberidt memberid;
  /*  printf("dvd_member_create\n"); */
  if(newrec == NULL)
    return DVD_ERR_NULL_POINTER;
  else {
    memout= DVD_MEMBERSHIP_storemembers__alloc();
    memout->memberid = newrec->member_id;
    memout->memberno = newrec->member_no;
    memout->title = newrec->title;
    memout->fname = newrec->fname;
    memout->lname = newrec->lname;
    memout->houseflatref = newrec->house_flat_ref;
    memout->address1 = newrec->address1;
    memout->address2 = newrec->address2;
    memout->town = newrec->town;
    memout->state = newrec->state;
    memout->phone = newrec->phone;
    memout->zipcode = newrec->zipcode;
  }
  /* Add the new member to the member and reservations file */
  DVD_MEMBERSHIP_create(membership, memout, &memberid, &ev);
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major, 
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev); 
    return DVD_ERR_BAD_WRITE;
  }
  *member_id = memberid;
  return DVD_SUCCESS;
}

int dvd_member_delete(int member_id)
{
  DVD_MEMBERSHIP_memberidt m;
  int rc=0;
  /*  printf("dvd_member_delete %d\n", member_id); */
  m = member_id;
  DVD_MEMBERSHIP_delete(membership, m, &ev);
  /* Note that we've got about 4 lines of declarations and other "real
     code," and about 12 lines of "exception handling."  THIS is why
     exception handling in C is ugly */
  switch (ev._major) {
  case CORBA_NO_EXCEPTION: 
    return DVD_SUCCESS;
  case CORBA_SYSTEM_EXCEPTION:
    printf("Got CORBA exception %d/%d from DVD_MEMBERSHIP_delete", ev._major,
	   (int) CORBA_exception_value(&ev));
    rc = DVD_ERR_NOT_FOUND;
    break;
  case CORBA_USER_EXCEPTION:
    if (strcmp(ex_DVD_MEMBERSHIP_NOSUCHMEMBER, CORBA_exception_id(&ev)))
      rc = DVD_ERR_NOT_FOUND;
  }
  CORBA_exception_free(&ev); 
  return rc;
}

int dvd_member_get_id_from_number(char *member_no, int *member_id)
{
  int rc = 0;
  DVD_MEMBERSHIP_memberidt cmemberid;
  /*  printf("dvd_member_get_id_from_number %s\n", member_no); */
  DVD_MEMBERSHIP_idfromnumber(membership, member_no, &cmemberid, &ev);
  switch (ev._major) {
  case CORBA_NO_EXCEPTION:
    *member_id = cmemberid;
    CORBA_exception_free(&ev); 
    /*    printf("result: %d\n", cmemberid); */
    rc = DVD_SUCCESS;
    break;
  case CORBA_SYSTEM_EXCEPTION:
    printf("Got CORBA exception %d/%d from DVD_MEMBERSHIP_delete", ev._major,
	   (int) CORBA_exception_value(&ev));
    rc = DVD_ERR_NOT_FOUND;
    break;
  case CORBA_USER_EXCEPTION:
    if (strcmp(ex_DVD_MEMBERSHIP_NOSUCHMEMBER, CORBA_exception_id(&ev))) {
      /*      CORBA_exception_free(&ev);  */
      printf("NOSUCHMEMBER Exception - %s\n", CORBA_exception_id(&ev));
      rc = DVD_ERR_NOT_FOUND;
      break;
    } else {
      printf("OTHER USER Exception! - %s\n", CORBA_exception_id(&ev));
      rc= DVD_ERR_NOT_FOUND;
      break;
    }
  }
  CORBA_exception_free(&ev); 
  if (rc != 0) 
    return rc;
  return DVD_SUCCESS;
}

int dvd_member_search(char *lname, int *result_ids[], int *count)
{
  DVD_MEMBERSHIP_memberidList *CList;
  int *results = NULL, i, rc=0;
  DVD_MEMBERSHIP_search(membership, lname, &CList, &ev);
  /* printf("Found... %d\n", CList->_length); */
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major,
	   CORBA_exception_id(&ev));
    rc = DVD_ERR_NOT_FOUND;
  }
  
  /* printf("No exception... Got some results...  Count: %d\n", CList->_length); */
  /* Alternatively, there _were_ good results in CList->.. */
  results=calloc(CList->_length, sizeof(int));  /* Hopefully something
						   later free()s the
						   contents of
						   results[] */ 
  /* printf("Allocated memory...\n"); */
  if (results == NULL) {
    return DVD_ERR_NO_MEMORY;
  }
  /* printf("Search results: "); */
  for (i = 0; i < CList->_length; i++) {
    /* printf(" %d %d ", i, CList->_buffer[i]); */
    results[i] = CList->_buffer[i];
  }
  CList->_release = TRUE;
  *result_ids = results;
  *count = CList->_length;
  CORBA_free(CList);
  return DVD_SUCCESS;
}

int dvd_title_set(dvd_title *inttl)
{
  DVD_TITLING_dvdtitles *ttlout;
  if(inttl == NULL)
    return DVD_ERR_NULL_POINTER;
 
  ttlout= DVD_TITLING_dvdtitles__alloc();
  ttlout->titleid = inttl->title_id;
  ttlout->titletext =inttl->title_text;
  ttlout->asin =inttl->asin;
  ttlout->director =inttl->director;
  ttlout->genre =inttl->genre;
  ttlout->classification =inttl->classification;
  ttlout->actor1 =inttl->actor1;
  ttlout->actor2 =inttl->actor2;
  ttlout->rentalcost = inttl->rental_cost;
  ttlout->releasedate = inttl->release_date;
  ttlout->image = inttl->image_ref;

  DVD_TITLING_set(titling, ttlout, &ev);
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major, 
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev); 
    return DVD_SUCCESS;
  }
  return DVD_SUCCESS;
}

int dvd_title_get(int title_id, dvd_title *ttlneeded)
{
  int rc = DVD_SUCCESS;
  DVD_TITLING_titlet ttlid;
  DVD_TITLING_dvdtitles *ttlin;

  if(ttlneeded == NULL)
    return DVD_ERR_NULL_POINTER;
  ttlid = title_id;
  DVD_TITLING_get(titling, ttlid, &ttlin, &ev);
  switch (ev._major) {
  case CORBA_NO_EXCEPTION: 
    rc = 0;
    break;
  case CORBA_SYSTEM_EXCEPTION:
    printf("Got CORBA exception %d/%d from DVD_TITLING_get", ev._major,
	   (int) CORBA_exception_value(&ev));
    rc = DVD_ERR_NOT_FOUND;
    break;
  case CORBA_USER_EXCEPTION:
    printf("Error: %s\n", CORBA_exception_id(&ev));
    rc = DVD_ERR_NOT_FOUND;
    break;
  }
  CORBA_exception_free(&ev); 
  if (rc != 0)   /* If we had an exception above... */
    return rc;
  /* If the retrieved title id is not as expected there
     may be an error, or the member may be deleted */
  if(title_id != ttlin->titleid)
    return (int) DVD_ERR_NOT_FOUND;
  
  ttlneeded->title_id =  ttlin->titleid;
  strncpy(ttlneeded->title_text,   ttlin->titletext, 61);
  strncpy(ttlneeded->asin,   ttlin->asin, 11);
  strncpy(ttlneeded->director,   ttlin->director, 51);
  strncpy(ttlneeded->genre,   ttlin->genre, 21);
  strncpy(ttlneeded->classification,   ttlin->classification, 11);
  strncpy(ttlneeded->actor1,   ttlin->actor1, 51);
  strncpy(ttlneeded->actor2,   ttlin->actor2, 51);
  strncpy(ttlneeded->rental_cost,   ttlin->rentalcost, 7);
  strncpy(ttlneeded->release_date,   ttlin->releasedate, 9);
  strncpy(ttlneeded->image_ref,   ttlin->image, 128);
  CORBA_free(ttlin);

  /* printf("Title: %d %s %s %s %s\n", ttlneeded->title_id,
	 ttlneeded->title_text, ttlneeded->director,
	 ttlneeded->genre, ttlneeded->classification); */
  return DVD_SUCCESS;
}

int dvd_title_create(dvd_title *newtitle, int *title_id)
{
  DVD_TITLING_dvdtitles *ctitle;
  DVD_TITLING_titlet cttlid;
  if (newtitle == NULL)
    return DVD_ERR_NULL_POINTER;
  ctitle = DVD_TITLING_dvdtitles__alloc();
  ctitle->titleid = newtitle->title_id;
  ctitle->titletext =newtitle->title_text;
  ctitle->asin =newtitle->asin;
  ctitle->director =newtitle->director;
  ctitle->genre =newtitle->genre;
  ctitle->classification =newtitle->classification;
  ctitle->actor1 =newtitle->actor1;
  ctitle->actor2 =newtitle->actor2;
  ctitle->rentalcost = newtitle->rental_cost;
  ctitle->releasedate = newtitle->release_date;
  ctitle->image = newtitle->image_ref;

  DVD_TITLING_create(titling, ctitle, &cttlid, &ev);
  CORBA_free(ctitle);
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major, 
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev); 
    return DVD_SUCCESS;
  }
  return DVD_SUCCESS;
}

int dvd_title_delete(int title_id)
{
  DVD_TITLING_titlet t;
  int rc=0;
  /* printf("dvd_titling_delete %d\n", title_id); */
  t = title_id;
  DVD_TITLING_delete(titling, t, &ev);
  /* Note that we've got about 4 lines of declarations and other "real
     code," and about 12 lines of "exception handling."  THIS is why
     exception handling in C is ugly */
  switch (ev._major) {
  case CORBA_NO_EXCEPTION: 
    rc = DVD_SUCCESS;
    break;
  case CORBA_SYSTEM_EXCEPTION:
    printf("Got CORBA exception %d/%d from DVD_TITLING_delete", ev._major,
	   (int) CORBA_exception_value(&ev));
    rc = DVD_ERR_NOT_FOUND;
    break;
  case CORBA_USER_EXCEPTION:
    if (strcmp(ex_DVD_TITLING_NOSUCHTITLE, CORBA_exception_id(&ev)))
      rc = DVD_ERR_NOT_FOUND;
  }
  CORBA_exception_free(&ev); 
  return rc;
}

int dvd_title_search(char *title, char *name, int *result_ids[], int *count)
{
  DVD_TITLING_titleList *CList;
  int *results = NULL, i;
  DVD_TITLING_search(titling, title, name, &CList, &ev);
  /* printf("Found... %d\n", CList->_length); */
  if (ev._major != CORBA_NO_EXCEPTION) {
    printf("Got CORBA exception %d/%s\n", ev._major,
	   CORBA_exception_id(&ev));
    CORBA_exception_free(&ev); 
    return DVD_ERR_NOT_FOUND;
  }
  /* printf("No exception... Got some results...  Count: %d\n", CList->_length); */
  /* Alternatively, there _were_ good results in CList->.. */
  results=calloc(CList->_length, sizeof(int));