/*Last Modified:  30-APR-1992 08:44:44.42, By: MARK */
/*
* The following routines display events in a really pretty fashion.
*
* They also allow one to easily enter an event
*/

#include "gopher.h"
#include "calendar.h"

#define EVENTFIELDS 10

static char * Eventtags[] = {
    "Time",
    "Month",
    "Day",
    "Year",
    "Length",
    "to",

    "Recurs (y/n)",
    "Recur length",

    "What",
    "Where"
    };

static int Eventxloc[] = {
    8, 7, 9, 8, 26, 38, 26, 26, 8, 7
    };

static int Eventyloc[] = {
    5, 6, 7, 8, 5, 5, 7, 8, 10, 11
    };

static Form EventForm = {
    EVENTFIELDS,
    "Make a New Event",
    Eventtags,
    NULL,
    NULL,
    Eventxloc,
    Eventyloc
    };


/** TODO there should be some way to pass in the date and time to be
   the default ***/

static char* Months[] = {
    "jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec"
    };
static char* Dates[] = {
    "01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12"
    };


BOOLEAN
createevent(When)
 time_t When;
{
    char *EventResponses[EVENTFIELDS];
    int i;
    FILE *TmpFile;
    char filename[40];
    char *ZeTime;
    char *cp;

    for (i=0 ; i<EVENTFIELDS; i++) {
         EventResponses[i] = (char *)malloc(MAXSTR);
         bzero(EventResponses[i], MAXSTR);
         EventResponses[i][0] = '\0';
    }

    /** Load up the given date into the date fields **/

    ZeTime = asctime(localtime(&When));

    strncpy(EventResponses[0], ZeTime + 11, 5); /** The time **/
    EventResponses[0][6] = '\0';
    strncpy(EventResponses[1], ZeTime + 4, 3);  /** The month **/
    EventResponses[1][4] = '\0';
    strncpy(EventResponses[2], ZeTime + 8, 2);  /** The Day
    EventResponses[2][3] = '\0';
    strncpy(EventResponses[3], ZeTime + 20, 4);  /** The Year **/
    EventResponses[3][5] = '\0';

    EventForm.values = EventResponses;

    if (NewForm(&EventForm) == FALSE)
         return(FALSE);

    /*** Put the stuff in a file in /tmp  In the proper format***/

    sprintf(filename, "/tmp/gopher.%d", getpid());

    if ( (TmpFile = fopen(filename, "w")) == NULL) {
         /*** Something's really screwed...... **/
         printf("Arrrrrrrrrrrrrrrrrrrghhhhh!!!!!!\n");
         return(FALSE);
    }


    /*** Output the year ***/

    fprintf(TmpFile, "Time: %s", EventResponses[3]);

    /*** Map the month names to numbers ***/
    /*** TODO, gotta check if the month is hosed! ***/

    for (i=0; i < 12; i++) {
         if (strncasecmp(EventResponses[1], Months[i], 3) == 0) {
              fprintf(TmpFile, "%s", Dates[i]);
              break;
         }
    }

    /*** Output the day of the month ***/

    switch (strlen(EventResponses[2])) {
    case 2:
         fprintf(TmpFile, "%s", EventResponses[2]);
         break;
    case 1:
         fprintf(TmpFile, "0%s", EventResponses[2]);
         break;
    case 3:
         /*** Error! ***/
         /*** TODO display a message ***/
         return(FALSE);
         break;
    }

    /** Yes, the elusive time! **/

    /** Make sure the hour is correct **/
    if (isdigit(EventResponses[0][0]) && (EventResponses[0][1] == ':')) {
         fputc('0', TmpFile);
         fputc(EventResponses[0][0], TmpFile);
    }
    else if (isdigit(EventResponses[0][0]) && isdigit(EventResponses[0][1])) {
         fputc(EventResponses[0][0], TmpFile);
         fputc(EventResponses[0][1], TmpFile);
    }

    else
         /*** Error!!! ***/
         return(FALSE);


    /** Now for the minutes **/
    cp = EventResponses[0];
    while (*cp != ':')
         cp++;

    cp++;

    fputc(*cp, TmpFile);
    fputc(*(cp+1), TmpFile);

    /** Put out the seconds 00 **/
    fputc('0', TmpFile);
    fputc('0', TmpFile);

    /*** Length min and length max ***/
    fprintf(TmpFile, " %s %s\n", EventResponses[4], EventResponses[5]);


    /*** TODO need to convert USERCAP to the real username ***/
    fprintf(TmpFile, "From: %s\n", USERCAP);
    fprintf(TmpFile, "Summary: %s\n", EventResponses[8]);
    fprintf(TmpFile, "Location: %s\n", EventResponses[9]);

    /*** Write out the recurs line ***/
    if (EventResponses[6][0] == 'y' ||EventResponses[6][0] == 'Y') {
         fprintf(TmpFile, "Recurs: %s\n", EventResponses[7]);
    }

    fclose(TmpFile);

    return(TRUE);
}




#define EVDSPFIELDS 9

static char * Evdsptags[] = {
    "When",
    "Length",
    "to",

    "Recurs",

    "What",
    "Where",

    "Created By",
    "Attendees",
    "Invited",
    };


static int Evdspxloc[] = {
    8, 38, 50, 6, 8, 7, 2, 3, 5, 3
    };

static int Evdspyloc[] = {
    5, 5, 5, 6, 7, 8, 9, 10, 11, 12
    };

static char Evdsptitle[80];

static Form EvdspForm = {
    EVDSPFIELDS,
    Evdsptitle,
    Evdsptags,
    NULL,
    NULL,
    Evdspxloc,
    Evdspyloc
    };


/**
** This guy loads up the EvdspForm with values from a file.
*/

EventFileToForm(tmpfile, Title)
 FILE *tmpfile;
{
    char inputline[MAXLINE];
    char *cp, *acp;
    static char *values[EVDSPFIELDS];
    int i;

    strcpy(EvdspForm.Title, Title);

    for (i=0 ; i<EVDSPFIELDS; i++) {
         values[i] = (char *)malloc(MAXSTR);
         bzero(values[i], MAXSTR);
    }

    while (fgets(inputline, 512, tmpfile) != NULL) {
         ZapCRLF(inputline);

         if (strncasecmp("Time: ", inputline, 6) == 0) {
              cp = inputline+5;
              while(*(cp++) == ' ');
              cp--;

              /** cp is now at the start of the time **/
              ISOasctime(cp, values[0]);

              cp = cp + 14;
              while(*(cp++) == ' ');

              /** cp is now at the length min **/

              acp = cp;
              while(*(acp++) == ' ');

              strncpy(values[1], cp-1, acp-cp+1);

              cp =acp;
              while(*(cp++) == ' ');

              strcpy(values[2], cp-1);
         }

         else if (strncasecmp("Recurs: ", inputline, 8)==0) {
              cp = inputline + 8;

              /** Should test that this value isn't m/y **/
              i = atoi(cp);

              if (i==7)
                   strcpy(values[3], "Weekly");
              else if (i==1)
                   strcpy(values[3], "Daily");
              else if (i==14)
                   strcpy(values[3], "Biweekly");
              else
                   sprintf(values[3], "Every %d Days", i);
         }

         else if (strncasecmp("Summary: ", inputline, 9) == 0)
              strcpy(values[4], inputline + 9);

         else if (strncasecmp("Location: ", inputline, 10) == 0)
              strcpy(values[5], inputline + 10);

         else if (strncasecmp("From: ", inputline, 6) == 0)
              strcpy(values[6], inputline + 6);

         else if (strncasecmp("Invited: ", inputline, 9) == 0)
              strcpy(values[8], inputline + 9);

         else if (strncasecmp("Attending: ", inputline, 11) == 0)
              strcpy(values[7], inputline +11);

    }

    EvdspForm.values = values;
}



BOOLEAN
GetEventFile(ZeGopher, tmpfile)
 GopherStruct *ZeGopher;
 FILE *tmpfile;
{
    char Attendingstr[MAXLINE], Invitedstr[MAXLINE];
    int sockfd, length;
    static char inputline[MAXLINE];
    char *cp;

    /*** Initialize variables ***/
    inputline[0] = '\0';

    /*** Get the event from the net ***/
    sockfd = OpenGopherConn(ZeGopher);

    Draw_Status("Receiving Event...");
    refresh();

    /** Send out the request **/
    writestring(sockfd, ZeGopher->sPath);
    writestring(sockfd, "\tfetch\r\n");

    /** Check the result of the command.  See if we screwed up... **/
    length = readline(sockfd, inputline, MAXLINE);
    if (inputline[0]=='-') {
         CursesErrorMsg(inputline + 2);
         return;
    }


    for(;;) {
         length = readline(sockfd, inputline, 512);

         if (length == 0)
              break;

         ZapCRLF(inputline);

         if ((inputline[0] == '.') && (inputline[1] == '\0'))
              break;
         else {
              fprintf(tmpfile, "%s\n", inputline);
         }
    }

    close(sockfd);

    /** Now let's find out how many people are going to this meeting **/
    sockfd = OpenGopherConn(ZeGopher);

    /** Send out the request **/
    writestring(sockfd, ZeGopher->sPath);
    writestring(sockfd, "\twhosat\r\n");

    /** Check the result of the command.  See if we screwed up... **/

    length = readline(sockfd, inputline, MAXLINE);
    if (inputline[0]=='-') {
         CursesErrorMsg(inputline + 2);
         fclose(tmpfile);
         close(sockfd);
         return(FALSE);
    }

    /** Okay, now we'll just put the list of users in the form
      Invited: <user1> <user2>  .... and
      Attending: <user1> <user2> ....
    ***/

    bzero(Attendingstr, MAXLINE);
    bzero(Invitedstr, MAXLINE);

    for(;;) {
         length = readline(sockfd, inputline, 512);

         if (length == 0)
              break;

         ZapCRLF(inputline);

         if ((inputline[0] == '.') && (inputline[1] == '\0'))
              break;
         else {
              cp = strchr(inputline, '\t');
              if (cp != NULL) {
                   cp++;
                   if (strncasecmp(cp, "invited", 7) == 0) {
                        strncat(Invitedstr, inputline, cp-inputline-1);
                        strcat(Invitedstr, ",");
                   }
                   else if (strncasecmp(cp, "attending", 9) == 0) {
                        strncat(Attendingstr, inputline, cp-inputline-1);
                        strcat(Invitedstr, ",");
                   }
              }
         }
    }
    /*** TODO Take off the last comma from the invited string. ***/


    fprintf(tmpfile, "Invited: %s\n", Invitedstr);
    fprintf(tmpfile, "Attending: %s\n", Attendingstr);

    return(TRUE); /*** Success ***/
}




EventInvite(ZeGopher, username)
 GopherStruct *ZeGopher;
 char *username;
{
    int sockfd, length;
    char inputline[MAXLINE];

    /** Open a connection to the server **/
    sockfd = OpenGopherConn(ZeGopher);

    /*** Send out the request ***/
    writestring(sockfd, ZeGopher->sPath);
    writestring(sockfd, "\tinvite\t");
    writestring(sockfd, username);
    writestring(sockfd, "\r\n");

    /*** get the response from the net.. ***/
    length = readline(sockfd, inputline, MAXLINE);

    if (inputline[0] == '-') {
         CursesErrorMsg(inputline + 2);
         return;
    }
}


HandleEvent(ZeGopher)
 GopherStruct *ZeGopher;
{
    BOOLEAN Done = FALSE;

    int i=0, length, sockfd;
    char tmpfilename[HALFLINE];
    FILE *tmpfile;
    char inputline[512];
    char sTmp[5];
    char ch, *cp;
    GopherStruct TmpGopher, *Gopherp, SaveGoph;


    SaveGoph.sFileType = ZeGopher->sFileType;
    strcpy(SaveGoph.sTitle, ZeGopher->sTitle);
    strcpy(SaveGoph.sHost, ZeGopher->sHost);
    strcpy(SaveGoph.sPath, ZeGopher->sPath);
    SaveGoph.iPort = ZeGopher->iPort;


    /** Open a temporary file **/

    sprintf(tmpfilename, "/tmp/gopher.%d",getpid());

    if ((tmpfile = fopen(tmpfilename, "w")) == NULL) {
         CursesErrorMsg("Couldn't make a tmp file!");
         return;
    }

    GetEventFile(ZeGopher, tmpfile);

    /*** Reopen the file as read-only ***/
    fclose(tmpfile);

    if ((tmpfile = fopen(tmpfilename, "r")) == NULL) {
         CursesErrorMsg("Whoa!!!!!");
         return;
    }

    /*** Load the event into the form ***/
    EventFileToForm(tmpfile, ZeGopher->sTitle);
    fclose(tmpfile);


    while (!Done) {


         /** Display the form **/
         DisplayForm(EvdspForm);
/*        Centerline("I - Invite, D - Details, M - Modify, ESC - exit", LINES - 4);
         Centerline("A - Accept Invitation, C - Decline Invitation", LINES - 3);
*/
         refresh();

         ch = getch();
         switch (ch) {

         case '\033':
              Done = TRUE;
              break;
         case 'i':
         case 'I':
              /*** Call the inviter here ***/
              /**** Hack alert !!***/

              CursesErrorMsg("Please show me the calendar of the person you want to invite,");
              /** Save IT!!! ***/

              CreateLink(ZeGopher);

              /*** Find out who we this user is ***/

              inputline[0] = '\0';
              GetOneOption("What is this person's name? ", inputline);

              /*** Now invite them to the event ***/
              EventInvite(&SaveGoph, inputline);

              /*** Now we must get the form again ***/

              sprintf(tmpfilename, "/tmp/gopher.%d",getpid());
              if ((tmpfile = fopen(tmpfilename, "w")) == NULL) {
                   CursesErrorMsg("Couldn't make a tmp file!");
                   return;
              }

              GetEventFile(&SaveGoph, tmpfile);

              /*** Reopen the file as read-only ***/
              fclose(tmpfile);

              if ((tmpfile = fopen(tmpfilename, "r")) == NULL) {
                   CursesErrorMsg("Whoa!!!!!");
                   return;
              }

              /*** Load the event into the form ***/
              EventFileToForm(tmpfile, SaveGoph.sTitle);
              fclose(tmpfile);

              break;

         case 'D':
         case 'd':
              /*** Decline the invitation ***/

              sockfd = OpenGopherConn(ZeGopher);

              /** Send out the request **/
              writestring(sockfd, ZeGopher->sPath);
              writestring(sockfd, "\tmodpers\t");
              writestring(sockfd, USERCAP);
              writestring(sockfd, "\r\n");

              /** Modify our status field ***/
              writestring(sockfd, "Status: Absent\r\n");
              writestring(sockfd, ".\r\n");

              /*** Get the result of the modpers command ***/
              inputline[0] = '-';
              length = readline(sockfd, inputline, MAXLINE);
              if (inputline[0] == '-') {
                   CursesErrorMsg(inputline + 2);
              }

              close(sockfd);

              /*** Now we must get the form again ***/

              sprintf(tmpfilename, "/tmp/gopher.%d",getpid());
              if ((tmpfile = fopen(tmpfilename, "w")) == NULL) {
                   CursesErrorMsg("Couldn't make a tmp file!");
                   return;
              }

              GetEventFile(&SaveGoph, tmpfile);

              /*** Reopen the file as read-only ***/
              fclose(tmpfile);

              if ((tmpfile = fopen(tmpfilename, "r")) == NULL) {
                   CursesErrorMsg("Whoa!!!!!");
                   return;
              }

              /*** Load the event into the form ***/
              EventFileToForm(tmpfile, SaveGoph.sTitle);
              fclose(tmpfile);



              break;

         case 'a':
         case 'A':
              /*** Accept the invitation ***/
              sockfd = OpenGopherConn(&SaveGoph);

              /** Send out the request **/
              writestring(sockfd, SaveGoph.sPath);
              writestring(sockfd, "\tmodpers\t");
              writestring(sockfd, USERCAP);
              writestring(sockfd, "\r\n");

              /** Modify our status field ***/
              writestring(sockfd, "Status: attending\r\n");
              writestring(sockfd, ".\r\n");

              /*** Get the result of the modpers command ***/
              inputline[0] = '-';
              length = readline(sockfd, inputline, MAXLINE);
              if (inputline[0] == '-') {
                   CursesErrorMsg(inputline + 2);
              }

              close(sockfd);

              /*** Now we must get the form again ***/

              sprintf(tmpfilename, "/tmp/gopher.%d",getpid());
              if ((tmpfile = fopen(tmpfilename, "w")) == NULL) {
                   CursesErrorMsg("Couldn't make a tmp file!");
                   return;
              }

              GetEventFile(&SaveGoph, tmpfile);

              /*** Reopen the file as read-only ***/
              fclose(tmpfile);

              if ((tmpfile = fopen(tmpfilename, "r")) == NULL) {
                   CursesErrorMsg("Whoa!!!!!");
                   return;
              }

              /*** Load the event into the form ***/
              EventFileToForm(tmpfile, SaveGoph.sTitle);
              fclose(tmpfile);



              break;


         case 'm':
         case 'M':
              break;
         }
    }

    /** Good little clients clean up after themselves..**/

    if (remove(tmpfilename)!=0)
         fprintf(stderr, "Couldn't remove %s!!!\n");
}



/*
* This takes the iso standard format time and puts it into a more
* palatable format
*/

ISOasctime(isotime, chartime)
 char *isotime;
 char *chartime;
{
    /** Snarf the time off **/

    /**     1991 01 01 23 00 00**/

    /** the time **/

    int month;

    chartime[0] = isotime[8];
    chartime[1] = isotime[9];
    chartime[2] = ':';
    chartime[3] = isotime[10];
    chartime[4] = isotime[11];
    chartime[5] = ' ';

    month = (isotime[4]-'0') * 10 + (isotime[5] - '0');

    strncpy(chartime +6, Months[month-1], 3);

    chartime[9] = ' ';

    /** The day **/

    chartime[10] = isotime[6];
    chartime[11] = isotime[7];

    chartime[12] = ' ';

    strncpy(chartime+13, isotime, 4);

    chartime[17] = '\0';
}

You are viewing proxied material from gopher.meulie.net. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.