#include "stdafx.h"


#include <stdio.h>
#include <stdlib.h>

#include "TSServer.h"
#include "TSField.h"
#include "da.h" /* Debugging allocator -- GDR 2000-09-01 */


/*
 * Global Error status functions.
 */
static int TSErrorCode = TS_OK;
void TSSetLastError( int errorCode )
{
  TSErrorCode = errorCode;
}
int TSGetLastError()
{
  return TSErrorCode;
}
void TSClearLastError()
{
  TSSetLastError( TS_OK );
}


/*
 * Methods for the Schema class.
 */
TSSchema::~TSSchema()
{
  fieldList.EmptyAndDestroyList();
}
TSObject* TSSchema::NewObject()
{
  return new TSSchema;
}
TSObject* TSSchema::Duplicate()
{
  TSSchema* obj = new TSSchema();

  obj->tableId = tableId;
  obj->name = name;
  obj->userDefinedFields = userDefinedFields;
  fieldList.Duplicate( &obj->fieldList );

  return obj;
}
// Copy the contents of obj into this.
void TSSchema::Copy( TSObject* obj )
{
  TSSchema* sch = ( TSSchema* ) obj;

  tableId = sch->tableId;
  name = sch->name;
  sch->fieldList.Copy( &fieldList );
}
TSString TSSchema::StringDump( int /*recursive*/, TSString indentation )
{
  char tmp[24];
  TSString s = indentation;

  s += "tableId = ";
  sprintf( tmp, "%ld", tableId );
  s += tmp;
  s += "\n";
  s += indentation;
  s += "name = ";
  s += name;
  s += "\n";
  if ( userDefinedFields )
  {
    s += "Has User Defined Fields\n";
  }
  else
  {
    s += "Does Not Have User Defined Fields\n";
  }
  return s;
}
int TSSchema::SocketString( TSString &/*str*/ )
{
  // Not needed for a schema since it's a client side only
  // object.
  return TS_ERROR;
}



/*
 *
 * Methods for the Server class.
 *
 */
TSServer::TSServer()
        :errorMsg( "" )
{
}
TSServer::~TSServer()
{
  schemaCache.EmptyAndDestroyList();
}
const char* TSServer::GetLastErrorMessage()
{
  if ( errorMsg.Length() == 0 ) return NULL;
  else return errorMsg.GetBuffer();
}
int TSServer::Connect( const char* userName,
                       const char* password,
                       const char* serverAddress )
{

  if ( password == NULL || userName == NULL )
  {
    TSSetLastError( TS_INVALID_USER );
    return TS_INVALID_USER;
  }
  if ( serverAddress == NULL )
  {
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  authentication = userName;
  authentication += ":";
  authentication += password;
  authentication = EncodePassword( authentication.GetBuffer());

  char* parseString = strdup( serverAddress );

  char* tmpWebAddress = strtok( parseString, "/" );
  char* dllString = strtok( NULL, "" );
  if ( dllString == NULL ) dllString = "/tmtrack/tmtrack.dll?";

  webAddress = strtok( tmpWebAddress, ":" );
  char* portNumberStr = strtok( NULL, "/" );
  if ( portNumberStr == NULL ) portNumber = 80;
  else portNumber = atol( portNumberStr );

  postHeader = "POST ";
  postHeader += dllString;
  postHeader += "APIPage HTTP/1.0\r\nContent-Type: html/text\r\n";
  postHeader += "Authorization: Basic ";
  postHeader += authentication;
  postHeader += "\r\n";

  free( parseString );

  int result = ValidateVersion();
  if ( result != TS_OK )
  {
    // 0 is a version failure.
    if ( result == 0 )
    {
      TSSetLastError( TS_INVALID_VERSION );
      return TS_INVALID_VERSION;
    }
    else // < 0 is another kind of error;
    {
      TSSetLastError( result );
      return result;
    }

  }

  return result;
}
TSSocket* TSServer::OpenSocket()
{
  // Clear out the error message string before we get started
  errorMsg.GetBuffer( 0 )[0] = '\0';

  TSSocket* socket = new TSSocket;
  if ( socket == NULL )
  {
    errorMsg = "Error allocating memory for socket.";
    TSSetLastError( TS_MEMORY_ERROR );
    return NULL;
  }

  if ( !socket->Create() )
  {
    errorMsg = "Socket Create failed.";
    TSSetLastError( TS_SOCKET_CREATE_FAILED );
    delete socket;
    return NULL;
  }
  if ( !socket->Connect( webAddress.GetBuffer(), portNumber ))
  {
    errorMsg = "Socket Connect failed.";
    TSSetLastError( TS_SOCKET_CONNECT_FAILED );
    delete socket;
    return NULL;
  }
  return socket;
}
TSString TSServer::EncodePassword( const char* password )
{
  TSString out;

  unsigned char buf[3];
  int idx = 0;
	static char base64Table[] = 
		"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

  while ( *password )
  {
    buf[idx++] = *password++;

    if ( idx == 3 )
    {

      // Output the 4 encoded bytes
      out += base64Table[buf[0] >> 2];                                   // first 6-bits of byte 0
      out += base64Table[((( buf[0] & 0x03 ) << 4 )) | ( buf[1] >> 4 )]; // last 2-bits of byte 0 + first 4-bits of byte 1
      out += base64Table[((( buf[1] & 0x0f ) << 2 )) | ( buf[2] >> 6 )]; // last 4-bits of byte 1 + first 2-bits of byte 2
      out += base64Table[buf[2] & 0x3f];                                 // last 6-bits of byte 2

      idx = 0;
    }
  }

  // Special case handling of last 1 or 2 characters
  if ( idx == 1 )
  {
    out += base64Table[buf[0] >> 2];               // first 6-bits of byte 0
    out += base64Table[(( buf[0] & 0x03 ) << 4 )]; // last 2-bits of byte 0
    out += "==";                                   // == pad
  }
  else if ( idx == 2 )
  {
    out += base64Table[buf[0] >> 2];                                   // first 6-bits of byte 0
    out += base64Table[((( buf[0] & 0x03 ) << 4 )) | ( buf[1] >> 4 )]; // last 2-bits of byte 0 + first 4-bits of byte 1
    out += base64Table[(( buf[1] & 0x0f ) << 2 )];                     // last 4-bits of byte 1
    out += "=";                                                        // = pad
  }

  return out;
}
int TSServer::BuildFieldList( int tableId, TSFieldList &fieldList )
{
  TSSchema* schema = GetSchema( tableId );
  if ( schema == NULL ) return TS_ERROR;
  schema->fieldList.Duplicate( &fieldList );
  return TS_OK;
}
TSSchema* TSServer::GetSchema( int tableId )
{
  TSSchema* schema;
  TSPosition* pos = schemaCache.GetFirst();
  while( pos )
  {
    schema = ( TSSchema* ) schemaCache.GetAt( pos );
    if ( schema->tableId == tableId )
    {
      return schema;
    }
    pos = schemaCache.GetNext(pos);
  }

  // Must not have found the schema for this record type.
  // Send a message to the server to retrieve it.
  schema = new TSSchema;
  schema->tableId = tableId;

  int result;

  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return NULL;
  }

  s = "Func=ReadSchema&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  if ( !Send( socket, s ))
    return (0);
  socket->ReceiveInt( &result );

  if ( !result )
  {
    delete schema;
    delete socket;
    return NULL;
  }

  // Receive the id, name and count.
  int count;
  int id;
  TSString name;

  socket->ReceiveInt( &id );
  socket->ReceiveString( &schema->name );
  socket->ReceiveInt( &schema->userDefinedFields );
  socket->ReceiveInt( &count );

  TSField* field;
  for( int ii = 0; ii < count; ii++ )
  {
    field = new TSField();
    field->ReceiveSchema( socket );
    schema->fieldList.AddTail( field );
  }

  delete socket;

  schemaCache.AddHead( schema );

  return schema;
}
int TSServer::Send( TSSocket* socket, const char* str )
{
  TSString post;
  char lengthStr[64];
  char line[256];
  int code = -1;

  sprintf( lengthStr, "Content-length: %d\r\n\r\n", strlen( str ));
  post = postHeader + lengthStr + str;
  post += "\r\n";

  if( socket->Send( post.GetBuffer(), post.Length() ) == SOCKET_ERROR )
  {
    TSSetLastError( TS_SOCKET_WRITE_ERROR );
    return FALSE;
  }
  BOOL bFirst = TRUE;
  BOOL bError = FALSE;

  while( socket->ReadLine( line, 256 ) > 0 && strlen( line ) != 0 )
  {
    if ( bFirst )
    {
      sscanf( line, "%*s %d", &code );
      if( code != 200 )
      {
        bError = TRUE;
      }
    }
    bFirst = FALSE;
  }

  if ( bError || bFirst )
  {
    TSSetLastError( TS_SERVER_ERROR );
    sprintf( errorMsg.GetBuffer( 32 ), "Server Error: %d", code );
    return FALSE;
  }

  int result;

  socket->ReceiveInt( &result );
  socket->ReceiveString( &errorMsg );
  if ( !result )
  {
    TSSetLastError( TS_SERVER_ERROR );
  }
  return result;
}

/********************************************************************
  DATA ACCESS FUNCTIONS
 ********************************************************************/
int TSServer::AddField( TSRecord* field, int tableId, int fieldType )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=AddField&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeInt( fieldType, params );
  s += params;
  field->SocketString( params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  delete socket;
  return TS_OK;
}
int TSServer::AddRecord( TSRecord* rec, TSRecord* newRecord /*=NULL*/ )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=AddRecord&Params=";
  TSEncodeInt( rec->tableId, params );
  s += params;
  TSEncodeInt( rec->fieldType, params );
  s += params;
  rec->SocketString( params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int id;
  socket->ReceiveInt( &id );

  if( newRecord != NULL )
  {
    newRecord->Receive( socket );
  }
  else
  {
    TSRecord dummy( rec->tableId, this );
    dummy.fieldType = rec->fieldType;
    dummy.Receive( socket );
  }
  delete socket;
  return TS_OK;
}
int TSServer::DeleteRecord( int tableId, int id )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=DeleteRecord&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeInt( id, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  delete socket;
  if ( !result )
  {
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  return TS_OK;
}
int TSServer::GetConnectionInfo( char** dsn, char** databaseName, char** serverName )
{
  TSString s, params;

  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=GetConnectionInfo&Params=";

  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }

  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    TSSetLastError( TS_ERROR );
    delete socket;
    return TS_ERROR;
  }

  TSString tmpStr;

  socket->ReceiveString( &tmpStr );
  *dsn = new char[tmpStr.Length()+1];
  if ( *dsn == NULL )
  {
    TSSetLastError( TS_MEMORY_ERROR );
    return TS_MEMORY_ERROR;
  }
  strcpy( *dsn, tmpStr.GetBuffer() );

  tmpStr = "";
  socket->ReceiveString( &tmpStr );
  *databaseName = new char[tmpStr.Length()+1];
  if ( *databaseName == NULL )
  {
    TSSetLastError( TS_MEMORY_ERROR );
    return TS_MEMORY_ERROR;
  }
  strcpy( *databaseName, tmpStr.GetBuffer() );

  tmpStr = "";
  socket->ReceiveString( &tmpStr );
  *serverName = new char[tmpStr.Length()+1];
  if ( *serverName == NULL )
  {
    TSSetLastError( TS_MEMORY_ERROR );
    return TS_MEMORY_ERROR;
  }
  strcpy( *serverName, tmpStr.GetBuffer() );

  delete socket;
  return TS_OK;
}
int TSServer::GetConnectionInfo( char* dsn, char* databaseName, char* serverName)
{
  TSString s, params;

  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=GetConnectionInfo&Params=";

  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }

  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    TSSetLastError( TS_ERROR );
    delete socket;
    return TS_ERROR;
  }

  TSString tmpStr;

  socket->ReceiveString( &tmpStr );
  strcpy( dsn, tmpStr.GetBuffer() );

  tmpStr = "";
  socket->ReceiveString( &tmpStr );
  strcpy( databaseName, tmpStr.GetBuffer() );

  tmpStr = "";
  socket->ReceiveString( &tmpStr );
  strcpy( serverName, tmpStr.GetBuffer() );

  delete socket;
  return TS_OK;
}
int TSServer::GetDbInfo( int infoType, void* out )
{
  if ( out == NULL )
    return TS_ERROR;

  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=GetDbInfo&Params=";
  TSEncodeInt( infoType, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }

  int result;
  socket->ReceiveInt( &result );

  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }

  switch ( infoType )
  {
    case TS_DBINFO_VERSION:
    case TS_DBINFO_EXPIRATIONDATE:
    case TS_DBINFO_ROOTPROJECTID:
    case TS_DBINFO_ROOTFOLDERID:
    case TS_DBINFO_OBJECTVERSION:
    case TS_DBINFO_DBMSVER:
      socket->ReceiveInt(( int * ) out );
      break;
  
    case TS_DBINFO_EXITURL:
    case TS_DBINFO_ROOTPROJECTNAME:
    case TS_DBINFO_DBMSNAME:
      *(( TSString * ) out ) = "";
      socket->ReceiveString(( TSString * ) out );
      break;

    default:
      break;
  }

  delete socket;
  return TS_OK;
}
int TSServer::GetInt( int tableId, const char* columnName, int recId, int* result )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=GetInt&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeString( columnName, params );
  s += params;
  TSEncodeInt( recId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  socket->ReceiveInt( result );
  delete socket;
  if ( !result )
  {
    TSSetLastError( TS_ERROR );
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  return TS_OK;
}
int TSServer::GetString( int tableId, const char* columnName, int recId, char** result )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=GetString&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeString( columnName, params );
  s += params;
  TSEncodeInt( recId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }

  TSString tmpStr;
  socket->ReceiveString( &tmpStr );
  if ( tmpStr.Length() > 0 )
  {
    *result = new char[tmpStr.Length() + 1];
    if ( *result == NULL )
    {
      TSSetLastError( TS_MEMORY_ERROR );
      return TS_MEMORY_ERROR;
    }
    strcpy( *result, tmpStr.GetBuffer() );
  }
  else
  {
    *result = NULL;
  }

  delete socket;
  return TS_OK;
}

int TSServer::GetString( int tableId, const char* columnName, int recId, char* result, int size )
{
  char* tmp;
  int status = GetString( tableId, columnName, recId, &tmp );
  if ( status != TS_OK )
  {
    return status;
  }
  strncpy( result, tmp, size );
  delete tmp;
  return TS_OK;
}

int TSServer::GetSubmitTransition( int projectId, int* id )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=GetSubmitTransition&Params=";
  TSEncodeInt( projectId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  socket->ReceiveInt( id );
  delete socket;
  return TS_OK;
}

int TSServer::HasPrivilege( int userId, int projectId, int maskNumber, int mask )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=HasPrivilege&Params=";
  TSEncodeInt( userId, params );
  s += params;
  TSEncodeInt( projectId, params );
  s += params;
  TSEncodeInt( maskNumber, params );
  s += params;
  TSEncodeInt( mask, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return FALSE;
  }
  int val;
  socket->ReceiveInt( &val );
  delete socket;
  return val;
}

int TSServer::HasRecordPrivilege( enum recPriv_e recPriv, int userId, int tableId, int recId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=HasRecordPrivilege&Params=";
  TSEncodeInt( recPriv, params );
  s += params;
  TSEncodeInt( userId, params );
  s += params;
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeInt( recId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return FALSE;
  }
  int val;
  socket->ReceiveInt( &val );
  delete socket;
  return val;
}

int TSServer::MoveFolder( int folderId, int newParentId, int position )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=MoveFolder&Params=";
  TSEncodeInt( folderId, params );
  s += params;
  TSEncodeInt( newParentId, params );
  s += params;
  TSEncodeInt( position, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  delete socket;
  if ( !result )
  {
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  return TS_OK;
}
int TSServer::MoveProject( int projectId, int newParentId, int position )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=MoveProject&Params=";
  TSEncodeInt( projectId, params );
  s += params;
  TSEncodeInt( newParentId, params );
  s += params;
  TSEncodeInt( position, params );
  s += params;

  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  delete socket;
  if ( !result )
  {
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  return TS_OK;
}
int TSServer::ReadAllRecords( TSRecordList* list, int tableId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=ReadAllRecords&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );

  delete socket;
  return TS_OK;
}
int TSServer::ReadAttachmentList( TSRecordList* list, int tableId, int recId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=ReadAttachmentList&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeInt( recId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );

  delete socket;
  return TS_OK;
}


int TSServer::ReadAvailableTransitionList( TSRecordList* list, int tableId, int recId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadAvailableTransitionList&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeInt( recId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}

int TSServer::ReadChangeList( TSRecordList* list, int caseId, BOOL newFirst /*=FALSE*/ )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=ReadChangeList&Params=";
  TSEncodeInt( caseId, params );
  s += params;
  TSEncodeInt( newFirst, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}

int TSServer::ReadFolderItems( TSRecordList* list, int folderId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadFolderItems&Params=";
  TSEncodeInt( folderId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadFolderList( TSRecordList* list, int owner, int parentId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadFolderList&Params=";
  TSEncodeInt( owner, params );
  s += params;
  TSEncodeInt( parentId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadProjectSelectionList( TSRecordList* list, int selectid )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadProjectSelectionList&Params=";
  TSEncodeInt( selectid, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    return TSGetLastError();
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadProjectTransitionList( TSRecordList* list, int transId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadProjectTransitionList&Params=";
  TSEncodeInt( transId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadPropertyList( TSRecordList* list, int transId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadPropertyList&Params=";
  TSEncodeInt( transId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadRecord( TSRecord* rec, int id )
{
  TSString s, params;

  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadRecord&Params=";
  TSEncodeInt( rec->tableId, params );
  s += params;
  TSEncodeInt( rec->fieldType, params ); // This is the type.
  s += params;
  TSEncodeInt( id, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  rec->Receive( socket );
  delete socket;
  return result;
}

int TSServer::ReadRecordWithWhere( TSRecord* record, const char* whereClause )
{
  TSString s, params;

  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadRecordWithWhere&Params=";
  TSEncodeInt( record->tableId, params );
  s += params;
  TSEncodeInt( record->fieldType, params ); // This is the type.
  s += params;
  TSEncodeString( whereClause, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  record->Receive( socket );
  delete socket;
  return TS_OK;
}

///////////////////////////////////////////////////////////////////////
// Reads a record, filtering by the where clause and returning 
// only the desired fields
///////////////////////////////////////////////////////////////////////
int TSServer::ReadRecordWithWhere( TSRecord* record, 
                                   const char* whereClause,
                                   const std::vector<int>& fields )
{
  TSString s, params;

  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadSelectedFieldsWithWhere&Params=";
  TSEncodeInt( record->tableId, params );
  s += params;
  TSEncodeInt( record->fieldType, params ); // This is the type.
  s += params;
  TSEncodeString( whereClause, params );
  s += params;

  // Encode the vector of selected fields
  TSEncodeInt( fields.size(), params );
  s += params;

  std::vector<int>::const_iterator it = fields.begin();
  while ( it != fields.end() )
  {
    TSEncodeInt( *it, params );
    s += params;
    it++;
  }

  if( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  record->Receive( socket );
  delete socket;
  return TS_OK;
}

int TSServer::ReadRecordListWithWhere( TSRecordList* list, int tableId, const char* whereClause )
{
  TSString s, params;

  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadListWithWhere&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeString( whereClause, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}

///////////////////////////////////////////////////////////////////////
// Reads a record, filtering by the where clause and returning 
// only the desired fields
///////////////////////////////////////////////////////////////////////
int TSServer::ReadRecordListWithWhere( TSRecordList *list, 
                                       int tableId, 
                                       const char *whereClause,
                                       const std::vector<int>& fields )
{
  TSString s, params;

  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadListSelectedFieldsWithWhere&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeString( whereClause, params );
  s += params;

  // Encode the vector of selected fields
  TSEncodeInt( fields.size(), params );
  s += params;

  std::vector<int>::const_iterator it = fields.begin();
  while ( it != fields.end() )
  {
    TSEncodeInt( *it, params );
    s += params;
    it++;
  }

  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}


int TSServer::ReadRecordForId( TSRecord* record, const char* searchId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadRecordForItemId&Params=";
  TSEncodeInt( record->tableId, params );
  s += params;
  TSEncodeInt( record->fieldType, params );
  s += params;
  TSEncodeString( searchId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  record->Receive( socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadReport( TSRecord* report, const char* name )
{
  TSString s, params, modifiedName;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadReport&Params=";
  TSEncodeInt( TS_TBLID_REPORTS, params );
  s += params;
  TSEncodeInt( 0, params ); // reportType, currently needs to be 0.
  s += params;

  // The name needs to be in single quotes since it will be used
  // in a query.
  modifiedName = "'";
  modifiedName += name;
  modifiedName += "'";
  TSEncodeString( modifiedName, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  report->Receive( socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadReportList( TSRecordList* list, long userId, int perm )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadReportList&Params=";
  TSEncodeInt( userId, params );
  s += params;
  TSEncodeInt( perm, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadSelectionList( TSRecordList* list, int fieldId, int projectId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadSelectionList2&Params=";
  TSEncodeInt( fieldId, params );
  s += params;
  TSEncodeInt( projectId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}

int TSServer::ReadStateList( TSRecordList* list, int workflowId, BOOL incParent /*=FALSE*/ )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadStateList&Params=";
  TSEncodeInt( workflowId, params );
  s += params;
  TSEncodeInt( incParent, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadTransitionList( TSRecordList* list, int projectId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadTransitionListEx&Params=";
  TSEncodeInt( projectId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadUserDefinedFields( TSRecordList* list, int tableId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadUserDefinedFields&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadUserListForPrivilege( TSRecordList* list, int userid, TSRecordList* fieldList, int mask )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadUserListForPrivilege&Params=";
  TSEncodeInt( userid, params );
  s += params;
  fieldList->SocketString( params );
  s += params;
  TSEncodeInt( mask, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadVCActionsForModule( TSRecordList* list, const char* filename, int userid, int action2 )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadVCActionsForModule&Params=";
  TSEncodeString( filename, params );
  s += params;
  TSEncodeInt( userid, params );
  s += params;
  TSEncodeInt( action2, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadVCActions( TSRecordList* list, int caseId )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadVCActions&Params=";
  TSEncodeInt( caseId, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}
int TSServer::ReadUserSelectionList( TSRecordList* list, int fieldId, int projectId, 
                                     BOOL incDeleted /* = FALSE */ )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ReadUserSelectionList&Params=";
  TSEncodeInt( fieldId, params );
  s += params;
  TSEncodeInt( projectId, params );
  s += params;
  TSEncodeInt( incDeleted, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}

int TSServer::SetExitUrl( const char* exiturl )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=SetExitUrl&Params=";
  TSEncodeString( exiturl, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  delete socket;
  return TS_OK;
}
int TSServer::UpdateList( TSRecordList* list, int tableId, int recid1, int recid2 )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=UpdateList&Params=";
  TSEncodeInt( tableId, params );
  s += params;
  TSEncodeInt( recid1, params );
  s += params;
  TSEncodeInt( recid2, params );
  s += params;
  list->SocketString( params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  list->Receive( this, socket );
  delete socket;
  return TS_OK;
}

int TSServer::UpdateRecord( TSRecord* rec, TSRecord* newRecord /*=NULL*/ )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=UpdateRecord&Params=";
  TSEncodeInt( rec->tableId, params );
  s += params;
  TSEncodeInt( rec->fieldType, params );
  s += params;
  rec->SocketString( params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int id;
  socket->ReceiveInt( &id );
  if( newRecord != NULL )
  {
    newRecord->Receive( socket );
  }
  else
  {
    TSRecord dummy( rec->tableId, this );
    dummy.fieldType = rec->fieldType;
    dummy.Receive( socket );
  }
  delete socket;
  return TS_OK;
}

int TSServer::ValidateUser( const char* loginid, const char* pwd,
                            BOOL validatePwd/*=TRUE*/, int *userId /*=NULL*/ )
{
  int result;

  TSString s, params;

  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  s = "Func=ValidateUser&Params=";
  TSEncodeString( loginid, params );
  s += params;
  TSEncodeString( pwd, params );
  s += params;
  TSEncodeInt( validatePwd, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  socket->ReceiveInt( &result );
  delete socket;
  if ( !result )
  {
    if ( userId != NULL )
    {
      *userId = 0;
    }
    TSSetLastError(TS_INVALID_USER);
    return TS_INVALID_USER;
  }
  else
  {
    if( userId != NULL )
    {
      *userId = result;
    }
    return TS_OK;
  }
}

int TSServer::ValidateVersion()
{
  int result;

  TSString s, params;

  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }

  s = "Func=ValidateAPIVersion&params=";
  TSEncodeInt( TS_APIVERSION, params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }

  socket->ReceiveInt( &result );
  socket->ReceiveString( &errorMsg );

  delete socket;

  return result;
}

int TSServer::Submit( int* nIssueId, TSString& sLoginid, TSRecord* pRec,
                      int nTableId, int nProjectId, int nFolderId, int nType )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  if ( !pRec )
  {
    return TS_ERROR;
  }

  s = "Func=Submit&Params=";
  TSEncodeString( sLoginid, params );
  s += params;
  TSEncodeInt( nProjectId, params );
  s += params;
  TSEncodeInt( nTableId, params );
  s += params;
  TSEncodeInt( nFolderId, params );
  s += params;
  TSEncodeInt( nType, params );
  s += params;
  pRec->SocketString( params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  socket->ReceiveInt( &result );
  if ( nIssueId )
  {
    *nIssueId = result;
  }
  delete socket;
  return TS_OK;
}

int TSServer::Transition( TSString& sLoginid, TSRecord* pRec,
                          int nProjectId, int nTableId,
                          int nRecordId, int nTransition )
{
  TSString s, params;
  TSSocket* socket = OpenSocket();
  if ( socket == NULL )
  {
    return TSGetLastError();
  }
  if ( !pRec )
  {
    return TS_ERROR;
  }

  s = "Func=Transition&Params=";
  TSEncodeString( sLoginid, params );
  s += params;
  TSEncodeInt( nProjectId, params );
  s += params;
  TSEncodeInt( nTableId, params );
  s += params;
  TSEncodeInt( nRecordId, params );
  s += params;
  TSEncodeInt( nTransition, params );
  s += params;
  pRec->SocketString( params );
  s += params;
  if ( !Send( socket, s ))
  {
    delete socket;
    return TSGetLastError();
  }
  int result;
  socket->ReceiveInt( &result );
  if ( !result )
  {
    delete socket;
    TSSetLastError( TS_ERROR );
    return TS_ERROR;
  }
  delete socket;
  return TS_OK;
}