Library: FOSSL Vending System v1

//---------------------------------------------------------------------------------//
//Copyright Info Below... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//(c)2007 Ilobmirt Tenk

//This file is part of the FOSSL Vendor Project

//    FOSSL Vendor is free software; you can redistribute it and/or modify
//    it under the terms of the Lesser GNU General Public License as published by
//    the Free Software Foundation; either version 3 of the License, or
//    (at your option) any later version.

//    FOSSL Vendor is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    Lesser GNU General Public License for more details.

//    You should have received a copy of the Lesser GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.

//---------------------------------------------------------------------------------//
//Copyright Info Above... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

default
{

    touch_start(integer total_number)
    {
        
        //If an avatar touches this object, tell the main script that (insert avatar's name here) touched it.
        if (llDetectedType(0) & AGENT){
            llMessageLinked(LINK_ROOT,0,"infoRequested#" + llDetectedName(0),NULL_KEY);
        }
    
    }
}

//---------------------------------------------------------------------------------//
//Copyright Info Below... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//(c)2007 Ilobmirt Tenk

//This file is part of the FOSSL Vendor Project

//    FOSSL Vendor is free software; you can redistribute it and/or modify
//    it under the terms of the Lesser GNU General Public License as published by
//    the Free Software Foundation; either version 3 of the License, or
//    (at your option) any later version.

//    FOSSL Vendor is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    Lesser GNU General Public License for more details.

//    You should have received a copy of the Lesser GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.

//---------------------------------------------------------------------------------//
//Copyright Info Above... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//=================================================================//
//List all the global variables here...
//=================================================================//

//count of the current Notecard line to read
integer intSettingLines = 0;

//key of the notecard line to be read
key keySettingsId;

//determines if the vendor requested for this script to register if it was meant to display images
integer blnRequested = FALSE;

//determines if it is ready to make that response
integer blnReadyToPost = FALSE;

//determines if this object displays debugging output
integer blnDebug = FALSE;

//=================================================================//
//Customize the following variables
//=================================================================//

//relative category index of the vendor
integer intCategory = 0;

//relative subcategory index of the vendor
integer intSubCategory = 0;

//Is the Category of the vendor absolute (true) or relative (False)
integer blnAbsoluteCategory = FALSE;

//Is the SubCategory of the vendor absolute (true) or relative (False)
integer blnAbsoluteSubCategory = FALSE;

//does this prim display images?
integer blnImages = FALSE;

//=================================================================//
//Customize the above variables
//=================================================================//

//This displays messages to the owner if debug mode has been set to true
debugMessage(string strMessage){

    if(blnDebug == TRUE){

        llOwnerSay("FOSSLVendorLink:    " + strMessage);
        
    }
    
}

default
{

        //start reading the settings notecard upon script start
        state_entry(){
                
            //Obtain the first line of the vendor link settings
            keySettingsId = llGetNotecardLine("FOSSL_LINK_SETTINGS", intSettingLines); 

        
        }

        //Reset the script when the container object gets rezzed
        on_rez(integer intParam){
     
            llResetScript();
              
        }

        //If somehing within the vendor changed, update the setting by resetting the script
        changed(integer change){
     
        // If I change the contents of the vendor
        if(change & CHANGED_INVENTORY){ 
            
            //reset the script to make use of the changes
            llResetScript();
            
        }
              
    }

    //Read the link settings notecard. Configure the link based on each line.
    dataserver(key query_id, string data) {
        
        if (query_id == keySettingsId) {
            if (data != EOF) {    // not at the end of the notecard

                debugMessage("Notecard Line = \"" + data + "\"");
                //split the record into variable names and values
                list lstSplit = llParseString2List(data,["="],[]);
                string strVariable = llToUpper(llStringTrim(llList2String(lstSplit,0),STRING_TRIM));
                string strValue = llStringTrim(llList2String(lstSplit,1),STRING_TRIM);

                if(strVariable == "CATEGORY"){

                    intCategory = (integer) strValue;
                    debugMessage("intCategory = " + (string) intCategory);
            
            
                }
                if(strVariable == "SUBCATEGORY"){

                    intSubCategory = (integer) strValue;
                    debugMessage("intSubCategory = " + (string) intSubCategory);
            
                }
                if(strVariable == "IMAGES"){

                    blnImages = (integer) strValue;
                    debugMessage("blnImages = " + (string) blnImages);
            
                }
                if(strVariable == "ABSOLUTE CATEGORY"){

                    blnAbsoluteCategory = (integer) strValue;
                    debugMessage("blnAbsoluteCategory = " + (string) blnAbsoluteCategory);
            
                }
                if(strVariable == "ABSOLUTE SUBCATEGORY"){

                    blnAbsoluteSubCategory = (integer) strValue;
                    debugMessage("blnAbsoluteSubCategory = " + (string) blnAbsoluteSubCategory);
            
                }

                keySettingsId = llGetNotecardLine("FOSSL_LINK_SETTINGS", ++intSettingLines); // request next line
            }
            else{
             
                //If this link is a display, add self to vendor's list of displays
                if(blnImages == TRUE){

                    blnReadyToPost = TRUE;

                    if(blnRequested == TRUE){

                        debugMessage("addScreen#" + (string) blnAbsoluteCategory + "#" + (string) intCategory + "#"+ (string) blnAbsoluteSubCategory + "#" + (string) intSubCategory);
                        llMessageLinked(LINK_ROOT,0,"addScreen#" + (string) blnAbsoluteCategory + "#" + (string) intCategory + "#"+ (string) blnAbsoluteSubCategory + "#" + (string) intSubCategory,NULL_KEY);
                        
                    }
                    
                }
                                      
            }
        }
        
    }

    //Tell the vendor to change index whenever it gets touched by an avatar
    touch_start(integer total_number)
    {
        
        //If an avatar touches this object, tell the main script to change its selected index
        //If the index is relative to 0#0, ignore the click
        if ((llDetectedType(0) & AGENT) && ((blnAbsoluteCategory == TRUE || blnAbsoluteSubCategory == TRUE) || (intCategory != 0 || intSubCategory != 0)) ){
        
            debugMessage("linkClicked#"+ (string) blnAbsoluteCategory + "#" + (string) intCategory + "#"+ (string) blnAbsoluteSubCategory + "#" + (string) intSubCategory);
            llMessageLinked(LINK_ROOT,0,"linkClicked#"+ (string) blnAbsoluteCategory + "#" + (string) intCategory + "#"+ (string) blnAbsoluteSubCategory + "#" + (string) intSubCategory,NULL_KEY);
        
        }
    
    }

    link_message(integer sender_number, integer number, string message, key id)
	{

		//Separate the linked message into the function and variables
		list lstMessage = llParseString2List(message,["#"],[]);
		string strFunction = llList2String(lstMessage,0);

		//getDisplays
		if(strFunction == "getDisplays" ){

            blnRequested = TRUE;
            debugMessage("Link has been requested to register itself as a diplay if possible.");
            debugMessage("blnRequested = " + (string) blnRequested);
            debugMessage("blnReadyToPost = " + (string) blnReadyToPost);
            debugMessage("blnImages = " + (string) blnImages);
            
            if(blnImages == TRUE){

                debugMessage("Link is ready to post, registering...");
                debugMessage("addScreen#" + (string) blnAbsoluteCategory + "#" + (string) intCategory + "#"+ (string) blnAbsoluteSubCategory + "#" + (string) intSubCategory);
                        llMessageLinked(LINK_ROOT,0,"addScreen#" + (string) blnAbsoluteCategory + "#" + (string) intCategory + "#"+ (string) blnAbsoluteSubCategory + "#" + (string) intSubCategory,NULL_KEY);

            }

        }
        //debugMode#blnEnabled
		else if(strFunction == "debugMode"){

			blnDebug = (integer) llList2String(lstMessage,1);
			
		}
        
    }

}

//FOSSLVendorBuyModule
//---------------------------------------------------------------------------------//
//Copyright Info Below... Please Do not Remove //
//---------------------------------------------------------------------------------//

//(c)2007 Ilobmirt Tenk

//This file is part of the FOSSL Vendor Project

// FOSSL Vendor 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; either version 3 of the License, or
// (at your option) any later version.

// FOSSL Vendor is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.

//---------------------------------------------------------------------------------//
//Copyright Info Above... Please Do not Remove //
//---------------------------------------------------------------------------------//
// modified by Fleur Dollinger 6 April 2008 - enable income splitting
// modified by Fleur Dollinger 28 April 2008 - option to disable deed to group

//=================================================================//
//List all the global variables here...
//=================================================================//

//This is the current L$ to US$ rate
float gfltLindenToUSDollarRate = 0.004;
//This is the key used to retrieve the L$ to US$ data via http
key gkeyHTTPLindenToUSDollarRate = NULL_KEY;

//This is the current price of the object displayed in the vendor
integer gintCurrentPrice = 0;

//count of the current Notecard line to read
integer gintSettingLines = 0;

//key of the notecard line to be read
key gkeySettingsId;

//determines if this object displays debugging output
integer gblnDebug = FALSE;

//income can be split between any number of avatars (as well as owner)
//Set gintNumSplit to a value greater than zero and set set up appropriate details for each split.
integer gintNumSplit = 0;

//Each Split is based upon 3 indexes of a list
//Split Array = [(Avatar Key), (Split amount), (Split Type)]
//Avatar Key - The key of the avatar that one plans to split a profit with
//Split Amount - How much that avatar will get per sale
//Split Type - What kind of measurement are we talking about? Percent? L$? US$?
list glstDefaultSplits = []; //Splitting scheme for all items sold by the vendor

//DEFAULT IS TO DISABLE DEED TO GROUP
// note that that the vendor will not be able to refund overpayments or split and distribute money if the vendor is deeded to group so its recommended to always leave this disabled
integer gintDeedToGroup = FALSE;
//get the object's owner - NULL_KEY
list groupD;

//This displays messages to the owner if debug mode has been set to true
debugMessage(string strMessage){

    if(gblnDebug == TRUE){

        llOwnerSay("FOSSLVendorBuy: " + strMessage);

    }
}


//Calculate the amount of cash given as it goes with profit splitting
splitMoney(integer amount)
{

    integer intIndex = 0;
    integer intLength = llGetListLength(glstDefaultSplits);
    key keyAvatar = NULL_KEY;
    integer intSplitCurrency = 0;
    string strType = "";

    for(intIndex = 0; intIndex < intLength; intIndex += 3 ){

        keyAvatar = llList2Key(glstDefaultSplits,intIndex);
        strType = llToUpper(llList2Key(glstDefaultSplits,intIndex + 2));
        if(keyAvatar != NULL_KEY && keyAvatar != llGetOwner()){

            //Is the type in US Dollars?
            if(strType == "US$" || strType == "$"){

                intSplitCurrency = (integer) (llList2Float(glstDefaultSplits,intIndex + 1) / gfltLindenToUSDollarRate);

            }
            //Is the type shown as a percentage?
            else if(strType == "%"){

                intSplitCurrency = (integer) ((llList2Float(glstDefaultSplits,intIndex + 1) * (float) amount) / 100.0);

            }
            //It must be a flat out L$ rate
            else{

                intSplitCurrency = llList2Integer(glstDefaultSplits,intIndex + 1);

            }

            llGiveMoney(keyAvatar, intSplitCurrency);
            debugMessage("Splitting with "+ (string) keyAvatar +" L$" + (string) intSplitCurrency +".");
            
        }
            
    }

}

//In this state, vendor must accept debit permissions before using the vendor
default
{

state_entry()
{

    groupD = llGetObjectDetails(llGetOwner(), [OBJECT_GROUP]);
    debugMessage("GroupD:" + (string) llList2String(groupD,0));

    //request permission on startup if not deeded to a group
    if((gintDeedToGroup == 0 && (key) llList2String(groupD,0) == NULL_KEY) || gintDeedToGroup == 1){

        //Asks vendor owner for the ability to withdraw cash from vendor owner's account.
        llRequestPermissions(llGetOwner(),PERMISSION_DEBIT );

    }
    else{

        llWhisper(0,"Deeding this vendor to a group is not permitted. Debit permission has been denied.");
    }

}


on_rez(integer start_param)
{

    //reset script upon rezz
    llResetScript();

}

link_message(integer sender_number, integer number, string message, key id)
{

    //Separate the linked message into the function and variables
    list lstMessage = llParseString2List(message,["#"],[]);
    string strFunction = llList2String(lstMessage,0);

    if(strFunction == "goingOnline"){

        //prevent vendor from staying online untill permissions are granted
        llMessageLinked(LINK_SET,0,"goOffline",NULL_KEY); //Tell Vendor to go offline if not already


    }
    //debugMode#blnEnabled
    else if(strFunction == "debugMode"){

        gblnDebug = (integer) llList2String(lstMessage,1);

    }


}

//Depending on if avatar accepts or declines request, either stay in this state, or move on...
run_time_permissions(integer permissions){

    //if user accepted debit permissions
    if(permissions & PERMISSION_DEBIT){

        state transactionsSetup; //Change state to setup for transactions

    }
    else if(!(permissions & PERMISSION_DEBIT)){

        llOwnerSay("Sorry, but this vendor requires its owner to allow for debit permissions.");
        llOwnerSay("To enable vendor service, touch the containing prim of the payment script, and accept the debit request.");

    }

}

touch(integer total_number){

    if ((gintDeedToGroup == 0 && (key) llList2String(groupD,0) == NULL_KEY) || gintDeedToGroup == 1){

        //Asks vendor owner for the ability to withdraw cash from vendor owner's account.
        llRequestPermissions(llGetOwner(),PERMISSION_DEBIT );

    }
    else{

        llWhisper(0,"Deeding this vendor to a group is not permitted. Debit permission has been denied.");
    }

}

}

//This state sets up all the data before transactions are to occur
state transactionsSetup{

state_entry(){

    llOwnerSay("Vendor is now able to make transactions with this script.\nReading Configuration data...");
    //Obtain the first line of the vendor buy settings;
    gkeySettingsId = llGetNotecardLine("FOSSL_BUY_SETTINGS", gintSettingLines);


}

changed( integer vBitChanges ){

    //Detect change of ownership, as this may indicate that the owner has deeded this object to a group, in which case we may want to disable Debit permission.
    //If any kind of split is activated you will have to disallow deeding this vendor to the group as groups cannot 'pay' other people out of the split.
    //This is really only relevant if you are giving this vendor to other people to sell your products for you.
    if (vBitChanges & CHANGED_OWNER){

        llResetScript();

    }

}

//Reset the vendor upon rezzing
on_rez(integer start_param){

    llResetScript();

}

//Read the link settings notecard. Configure the link based on each line.
dataserver(key query_id, string data) {

    if (query_id == gkeySettingsId) {

        if (data != EOF) { // not at the end of the notecard

            debugMessage("Notecard Line = \"" + data + "\"");
            //split the record into variable names and values
            list lstSplit = llParseString2List(data,["="],[]);
            string strVariable = llToUpper(llStringTrim(llList2String(lstSplit,0),STRING_TRIM));
            string strValue = llStringTrim(llList2String(lstSplit,1),STRING_TRIM );

            // get setting for intDeedToGroup (default is 0 = disable)
            if(strVariable == "DEED TO GROUP"){

                gintDeedToGroup = (integer) strValue;
                debugMessage("intDeedToGroup = " + strValue);

            }

            //Get settings for splits
            //Start By looking for "split"
            //Since there's some dynamicism to this, some more proccessing is neccesary
            if(llGetSubString(strVariable, 0, 4) == "SPLIT"){

                list lstSplitVariableDetails = llParseString2List(strVariable,[" "],[]);

                //If it was just "Split" after all, user just wants to set the number of profit splitting in the vendor
                if(llGetListLength(lstSplitVariableDetails) == 1){

                    gintNumSplit = (integer) strValue;
                    //if income splitting is enabled, must disable Deed To Group
                    if (gintNumSplit > 0){

                        gintDeedToGroup = 0;
                        debugMessage("DEED TO GROUP DISABLED AS INCOME SPLITTING HAS BEEN ACTIVATED");

                    }

                    debugMessage("SPLIT = " + (string) gintNumSplit);
                    
                    //Create an array of splits with just default values
                    integer intIndex;

                    //Reset values of default split
                    glstDefaultSplits = [];

                    for(intIndex = 0; intIndex < gintNumSplit; intIndex++){

                        //Add an entity to split with using default values
                        glstDefaultSplits += [NULL_KEY,0,"L$"];

                    }

                }
                //There's more to it than that, Find out what part of the split needs to be set
                else{

                    //Get the index that will be enacted upon
                    integer intSplitIndexDetails = llList2Integer(lstSplitVariableDetails, 1) - 1;
                    //Get more info on what the user wants set for the split
                    string strSubVariable = llList2String(lstSplitVariableDetails, 2);

                    //The user wants to set the recipient key for the split
                    if(strSubVariable == "KEY"){

                        //Replace the index with the new key of the recipient
                        glstDefaultSplits = llListReplaceList(glstDefaultSplits, [strValue], (intSplitIndexDetails * 3), (intSplitIndexDetails * 3));
                        debugMessage("glstDefaultSplits["+ (string) (intSplitIndexDetails * 3) +"] = " + strValue);

                    }
                    //The user wants to set the amount the recipient gets
                    else if(strSubVariable == "AMOUNT"){

                        //Replace the index with the new currency value to be shared
                        glstDefaultSplits = llListReplaceList(glstDefaultSplits, [strValue], ((intSplitIndexDetails * 3) + 1), ((intSplitIndexDetails * 3) + 1));
                        debugMessage("glstDefaultSplits["+ (string) ((intSplitIndexDetails * 3) + 1) +"] = " + strValue);

                    }
                    //The user wants to set the type of split the recipient gets
                    else if(strSubVariable == "TYPE"){

                        //Replace the index with the new type of split to be shared
                        glstDefaultSplits = llListReplaceList(glstDefaultSplits, [strValue], ((intSplitIndexDetails * 3) + 2), ((intSplitIndexDetails * 3) + 2));
                        debugMessage("glstDefaultSplits["+ (string) ((intSplitIndexDetails * 3) + 2) +"] = " + strValue);

                    }

                }
            
            }

            gkeySettingsId = llGetNotecardLine("FOSSL_BUY_SETTINGS", ++gintSettingLines); // request next line
        }
        //No more lines to read in the configuration notecard
        else{

            llOwnerSay("Vendor is now able to sell products. Enabling transactions.");
            llMessageLinked(LINK_SET,0,"goOnline",NULL_KEY); //Tell Vendor to go online if not already
            state transactionsAcceptable; //Change state to allow for transactions

        }

    }

}
}

//In this state, vendor is ready to sell products
//Allow transactions to commence
state transactionsAcceptable{
    
state_entry(){
 
    //Time to start getting lindex data
    gkeyHTTPLindenToUSDollarRate = llHTTPRequest("http://secondlife.com/httprequest/homepage.php", [HTTP_METHOD, "GET"], "");
    //Poll For Lindex Data every five minutes (300 seconds)
    llSetTimerEvent(300.0);
          
}

changed( integer vBitChanges ){

    //Detect change of ownership, as this may indicate that the owner has deeded this object to a group, in which case we may want to disable Debit permission.
    //If any kind of split is activated you will have to disallow deeding this vendor to the group as groups cannot 'pay' other people out of the split.
    //This is really only relevant if you are giving this vendor to other people to sell your products for you.
    if (vBitChanges & CHANGED_OWNER){

        llResetScript();

    }

}

//Reset the vendor upon rezzing
on_rez(integer start_param){

    llResetScript();

}

//set the current price to the value of num. This is incase that the user over/under pays for the item
link_message(integer sender_num, integer num, string str, key id){

    if(str == "updatePrice"){

        gintCurrentPrice = num;
        
        //If the price of the item is free
        if(gintCurrentPrice == 0){
            
            state giveAwayFreeProducts;
            
        }

    }

}

//Whenever an avatar pays an object that this script is in, check for correct amount.
//Then if correct amount is payed, notify the system of a sale
money(key giver, integer amount) {

    // has the user paid the correct amount?
    if (amount == gintCurrentPrice){

        // if so, thank the payer by name.
        llSay(0,"Thank you, " + llKey2Name(giver) + ".");
        //give them the lovely object displayed on the vendor

        //send message back to root object to give out product
        llMessageLinked(LINK_ROOT,0,"itemBought#" + (string)giver,NULL_KEY);

        // if settings card includes split details
        if (gintNumSplit > 0){
            
            debugMessage("Splitting Income...");
            splitMoney (amount);

        }

    }

    // is the amount paid less than it needs to be?
    else if (amount < gintCurrentPrice){

        // if so, tell them they're getting a refund, then refund their money.
        llSay(0,"You didn't pay enough, " + llKey2Name(giver) + ". Refunding your payment of L$" + (string)amount + ".");
        llGiveMoney(giver, amount); // refund amount paid.

    }

    // if it's not exactly the amount required, and it's not less than the amount required,
    // the payer has paid too much.
    else{

        // tell them they've overpaid.
        integer intRefund = amount - gintCurrentPrice; // determine how much extra they've paid.
        llSay(0,"You paid too much, " + llKey2Name(giver) + ". Your change is L$" + (string)intRefund + ".");
        llGiveMoney(giver, intRefund); // refund their change.
        //give them the lovely object displayed on the vendor

        //send message back to root object to give out product.
        llMessageLinked(LINK_ROOT,0,"itemBought#" + (string)giver,NULL_KEY);

        // if settings card includes split details
        if (gintNumSplit > 0){
            
            debugMessage("Splitting Income...");
            splitMoney (amount);

        }

    }

}

//Five minutes have elapsed, lets refresh our lindex data
timer(){
    
    //Time to start getting lindex data
    gkeyHTTPLindenToUSDollarRate = llHTTPRequest("http://secondlife.com/httprequest/homepage.php", [HTTP_METHOD, "GET"], "");

}

//Use http in this script pureley to collect lindex data
http_response(key request_id, integer status, list metadata, string body){
    
    //If the requested lindex page reponded correctly
    if(request_id == gkeyHTTPLindenToUSDollarRate && status == 200){
        
        //Split that garbled mess into data we can actually use
        list lstMetaData = llParseString2List(body,["\t","\n"],[]);
        //Set the rate using the 17th element of that data
        gfltLindenToUSDollarRate = 1.0 / llList2Float(lstMetaData,17);
        
        
    }
    
}

}

//In This state, the item is purchased whenever a prim is clicked upon
//This state is exited whenever the price changes to something that isn't free
state giveAwayFreeProducts{
    
changed( integer vBitChanges ){

    //Detect change of ownership, as this may indicate that the owner has deeded this object to a group, in which case we may want to disable Debit permission.
    //If any kind of split is activated you will have to disallow deeding this vendor to the group as groups cannot 'pay' other people out of the split.
    //This is really only relevant if you are giving this vendor to other people to sell your products for you.
    if (vBitChanges & CHANGED_OWNER){

        llResetScript();

    }

}

//Reset the vendor upon rezzing
on_rez(integer start_param){

    llResetScript();

}

//set the current price to the value of num. This is incase that the user over/under pays for the item
link_message(integer sender_num, integer num, string str, key id){

    if(str == "updatePrice"){

        gintCurrentPrice = num;
        
        //If the price isn't free anymore
        if(gintCurrentPrice > 0){
            
            state transactionsAcceptable;
            
        }

    }

}

//The User simply needs to touch the prim in order to get the item
touch_end(integer num_detected){
    
    //send message back to root object to give out product.
    llMessageLinked(LINK_ROOT,0,"itemBought#" + (string) llDetectedKey(0),NULL_KEY);
    
}
    
}

//---------------------------------------------------------------------------------//
//Copyright Info Below... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//(c)2007 Ilobmirt Tenk

//This file is part of the FOSSL Vendor Project

//    FOSSL Vendor is free software; you can redistribute it and/or modify
//    it under the terms of the Lesser GNU General Public License as published by
//    the Free Software Foundation; either version 3 of the License, or
//    (at your option) any later version.

//    FOSSL Vendor is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    Lesser GNU General Public License for more details.

//    You should have received a copy of the Lesser GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.

//---------------------------------------------------------------------------------//
//Copyright Info Above... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

default
{

    //Upon hearing "EmailRequest" send an e-mail to a designated target
    link_message(integer sender_number, integer number, string message, key id)
    {

        //split the message into manageable bits
        //intent of the message can be defined in index 0
        list lstMessageParsed = llParseString2List(message,["#"],[]);

        //Is it a request for an e-mail to be sent?
        if(llList2String(lstMessageParsed,0) == "EmailRequest"){

            //Send an e-mail using the rest of the list
            llEmail(llList2String(lstMessageParsed,1),llList2String(lstMessageParsed,2),llList2String(lstMessageParsed,3));
            
        }
        
    }
    
}

//---------------------------------------------------------------------------------//
//Copyright Info Below... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//(c)2007 Ilobmirt Tenk

//This file is part of the FOSSL Vendor Project

//    FOSSL Vendor is free software; you can redistribute it and/or modify
//    it under the terms of the Lesser GNU General Public License as published by
//    the Free Software Foundation; either version 3 of the License, or
//    (at your option) any later version.

//    FOSSL Vendor is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    Lesser GNU General Public License for more details.

//    You should have received a copy of the Lesser GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.

//---------------------------------------------------------------------------------//
//Copyright Info Above... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//=================================================================//
//List all the global variables here...
//=================================================================//

list lstProducts;                   //List of products loaded into memory. Product records are as follows...
                                    //current#Category#Subcategory#Price#Name#TextureUUID

list lstItemRequestList;            //List of items to be requested from the server
//each record is in the form of "Category#SubCategory#DatabaseKey#LineRead"

integer intItemRequestList = 0;        //Number of item database requests to send to the server

integer intMaxProducts = 0;            //Maximum Number of products that can be loaded

integer intProductListCounter = -2147483646;    //Keeps track of a counter used for indicating the most and needed products in category

key keyProductsUUID = NULL_KEY;                 //The uuid of the notecard to be read for products

integer blnDebug = FALSE;                        //Determines if script will output debugging messages

//=================================================================//
//Define the following functions
//=================================================================//

//This displays messages to the owner if debug mode has been set to true
debugMessage(string strMessage){

    if(blnDebug == TRUE){

        llOwnerSay("FOSSLProductDatabase:   " + strMessage);
        
    }
    
}

//Find the product array index based upon the Category and Sub category Index
//If Not found, returns -1
integer findIndexByCategory(integer intCategory, integer intSubCategory){

    integer intProductListIndex = -1;
    integer intTotalLength = llGetListLength(lstProducts);
    integer blnFound = FALSE;
    string strSearchCondition = ((string)intCategory + "#" +(string)intSubCategory);
    
    list lstProduct = [];

    do{

        intProductListIndex++;
        lstProduct = llParseString2List(llList2String(lstProducts,intProductListIndex),["#"],[]);

        //current#Category#Subcategory#Price#Name#TextureUUID
        if(strSearchCondition == (llList2String(lstProduct,1) + "#" + llList2String(lstProduct,2))){

            blnFound = TRUE;

        }


    } while(blnFound == FALSE && intProductListIndex < intTotalLength);

    if(blnFound == TRUE){

        return intProductListIndex;

    }
    else{

        return -1;

    }

}

//when product list counter has reached maximum, use this to start back from square 1
resetCounter(){

    debugMessage("Query counter Maxed out. Resetting query.");
    
    integer intItemsIndex = -1;
    integer intItemsLength = llGetListLength(lstProducts);
    integer intMinimum = 0;
    integer intMaximum = 0;
    integer intDifference = 0;
    list lstOpenedIndex = [];

    lstProducts = llListSort(lstProducts,1,TRUE);

    intMinimum = (integer) llList2String(llParseString2List(llList2String(lstProducts,0),["#"],[]),0);
        
    do{

        ++intItemsIndex;
        lstOpenedIndex = llParseString2List(llList2String(lstProducts,intItemsIndex),["#"],[]);
        intMaximum = (integer) llList2String(lstOpenedIndex,0);
        intDifference = intMaximum - intMinimum;
        lstOpenedIndex = llListReplaceList( lstOpenedIndex,[(string) (-2147483646 + intDifference)], 0,0);
        lstProducts = llListReplaceList(lstProducts,[llDumpList2String(lstOpenedIndex,"#")], intItemsIndex,intItemsIndex);
        
    }while(intItemsIndex < intItemsLength);
    
    
    intProductListCounter = -2147483645 + intDifference; // set the counter to one greater than recent
    
}

//This function adds an item to the buffer
//If the buffer is full, replace the first item not being used by a display
//If the item is to be used by a display, update the displays.
addItem(string strItem){

    debugMessage("Appending Item to Database");
    
    //If the counter is more equal to the maximum integer,
    //reset the database index for most and least used database queries
    if(intProductListCounter == 2147483646){

        resetCounter();

    }

    //If the number of products are less than that of the maximum, add it to the buffer
    if((llGetListLength(lstProducts) - 1) < intMaxProducts){

        debugMessage("Buffer not Full. Appending.");
    
        //Use a space hack trick for conserving memory
        //Expand lstProducts with an extra element
        lstProducts += [ ((string) (++intProductListCounter)) + "#" + strItem];

    }
    //Otherwise, replace the first index that is least recent
    else{

        debugMessage("Buffer Full. Replacing least accessed index.");
    
        //Sort lstProducts starting from least recent data to most recent data
        lstProducts = llListSort(lstProducts,1,TRUE);
        //Overwrite first, least used index with current product
        lstProducts = llListReplaceList(lstProducts,[((string) (++intProductListCounter)) + "#" + strItem],0,0);

    }

}

//This function adds item requests to the buffer before it starts obtaining them from the notecard
itemRequest(integer intCategory, integer intSubCategory, string strReturnRequest){

    //Use memory conservative techniques to reduce memory footprint
    //take that record and add it to the waitlist
    //categoryRequest#subcategoryRequest#ReturnQuery#notecardKey#notecardLine
    debugMessage("Reqesting data from notecard...");
    lstItemRequestList = llListReplaceList((lstItemRequestList = []) + lstItemRequestList,[(string)intCategory + "#" + (string)intSubCategory + "#" + strReturnRequest + "#" + (string) llGetNotecardLine(keyProductsUUID,0) + "#0" ],intItemRequestList,intItemRequestList);

    //increment # of items on the waitlist
    intItemRequestList++;

}

//This function removes item requests by their index
removeItemRequest(integer intIndex){

    //Use memory conservative techniques to reduce memory footprint
    //remove the item by index
    lstItemRequestList = llDeleteSubList((lstItemRequestList = []) + lstItemRequestList,intIndex,intIndex);
    
    //decrement # of items on the waitlist
    intItemRequestList--;
    
    
}

//Use this function to make database requests off temporary memory first
//If an index can't be found, make a request off of notecard memory
dbQuery(integer intCategory, integer intSubCategory, string strReturnRequest){

    integer intFoundIndex = findIndexByCategory(intCategory,intSubCategory);
    list lstFoundProduct = [];

    //Index found... return the result and update the access couter on that item
    if(intFoundIndex != -1){

        //If the counter is more equal to the maximum integer,
        //reset the database index for most and least used database queries
        if(intProductListCounter == 2147483646){

            resetCounter();

        }

        //Split the found product into its elements for individual element manipulation
        lstFoundProduct = llParseString2List(llList2String(lstProducts,intFoundIndex),["#"],[]);

        //Advance the database access counter indicating this is the latest item in the database
        lstFoundProduct = llListReplaceList(lstFoundProduct,[(string)(++intProductListCounter)],0,0);

        debugMessage("Found Request in Buffer... returning values");
        
        //return query to owner
        //dbResults#ReturnQuery#(productRecord)
        llMessageLinked(LINK_SET,0,"dbResults#" + strReturnRequest + "#" + llDumpList2String(llList2List(lstFoundProduct,1,-1),"#"),NULL_KEY);
        
    }
    //Index not found... time to make a notecard request
    else{

        debugMessage("Requested Query not found in Buffer. Retrieving data from source...");
        itemRequest(intCategory,intSubCategory,strReturnRequest);
        
    }
    
}

//=================================================================//
//Customize the above functions
//=================================================================//


default
{

    //Activate this event when container script is rezzed
    //Its best to just reset the database and start with fresh data
    on_rez(integer start_param)
    {

        //Reset this script upon rezzing the containing prim
        llResetScript();
        
    }

    //Activate this event when a companion script sends out a linked message
    //Use this event to determine if that script is making a request of this script
    //This script accepts database query requests, database resizing requests,
    //database source requests, and database clearing
    link_message(integer sender_number, integer number, string message, key id)
    {

        //Separate the linked message into the function and variables
        list lstMessage = llParseString2List(message,["#"],[]);
        string strFunction = llList2String(lstMessage,0);

        //A scripted object wants to obtain information about a product
        //dbRequest#requestKey#Category#SubCategory
        if(strFunction == "dbRequest"){

            debugMessage("dbRequest = " + llList2String(lstMessage,1) );
            dbQuery((integer) llList2String(lstMessage,2), (integer) llList2String(lstMessage,3), llList2String(lstMessage,1));
            
        }
        //clearDatabase
        else if(strFunction == "clearDatabase"){

            lstProducts = [];
            
        }
        //setBuffer#bufferLength
        else if(strFunction == "setBuffer"){

            //Clear database
            lstProducts = [];

            //Reset database counter
            intProductListCounter = -2147483646;

            //Set the maximum # of products in inventory
            intMaxProducts = (integer) llList2String(lstMessage,1);
            
        }
        //addBuffer#bufferLength
        else if(strFunction == "addBuffer"){

            //Set the maximum # of products in inventory
            intMaxProducts += 1;
            
        }
        //setDB#productNotecardUUID
        else if(strFunction == "setDB"){

            //Clear out any requests and database inventory
            lstProducts = [];
            intItemRequestList = 0;
            lstItemRequestList = [];

            //reset inventory counter
            intProductListCounter = -2147483646;

            //Assign Key of products notecard to this uuid
            keyProductsUUID = (key) llList2String(lstMessage,1);
            
        }
        //debugMode#blnEnabled
        else if(strFunction == "debugMode"){

            blnDebug = (integer) llList2String(lstMessage,1);
            
        }
        //getMemory
        else if(strFunction == "getMemory"){
         
            llOwnerSay("FOSSLVendorProductDatabase:   Memory = " + (string) llGetFreeMemory() +"/16000 Bytes");
                  
        }
                
    }

    //Activate this event when a query couldn't find the solution in a list (fast)
    //each request has a notecard line# and key to keep track of where they are
    //If request can't find the index in the card, return that the inventory wasn't found
    dataserver(key requested, string data)
    {

       list lstCurrentRequestedItem;
       integer intWaitListIndex = 0;
       integer blnKeyFound = FALSE;

       //loop through the product request list to determine if this data server event matches the product request
       for(;(intWaitListIndex < intItemRequestList) && (blnKeyFound == FALSE); intWaitListIndex++){

            //Extract the query into its elements
           lstCurrentRequestedItem = llParseString2List(llList2String(lstItemRequestList,intWaitListIndex),["#"],[]);

           //Attempt to match the current notecard request key with that of the events
           if(requested == (key)llList2String(lstCurrentRequestedItem,3)){

               //If this is not the end of the product list...
               if(data != EOF){

                   //Extract the product line into its elements
                   list lstProductParsedLine = llParseString2List(data,["#"],[]);

                   //Does this product line match with the request?
                   if( ((integer)llList2String(lstProductParsedLine,0) == (integer)llList2String(lstCurrentRequestedItem,0)) && ((integer)llList2String(lstProductParsedLine,1) == (integer)llList2String(lstCurrentRequestedItem,1)) ){

                        //return query to owner
                        //dbResults#ReturnQuery#(productRecord)
                        llMessageLinked(LINK_SET,0,"dbResults#" + llList2String(lstCurrentRequestedItem,2) + "#" + data,NULL_KEY);
                
                       //Add the product line to product buffer
                       addItem(data);
                            
                       //Remove the request from the list
                       removeItemRequest(intWaitListIndex);
                            
                   }
                   else{

                        //start requesting for the next line of the notecard
                        //categoryRequest#subcategoryRequest#ReturnQuery#notecardKey#notecardLine
                       lstItemRequestList = llListReplaceList(lstItemRequestList,[llList2String(lstCurrentRequestedItem,0) + "#" + llList2String(lstCurrentRequestedItem,1) + "#" + llList2String(lstCurrentRequestedItem,2) + "#" + (string) llGetNotecardLine(keyProductsUUID,(((integer) llList2String(lstCurrentRequestedItem,4)) + 1)) + "#" + (string)(((integer) llList2String(lstCurrentRequestedItem,4)) + 1) ],intWaitListIndex,intWaitListIndex);
                            
                   }
                        
               }
               //If this is the end of the product list and still the item category and subcategory isn't found,
               //chances are, there's no product
               else{

                   //return query to owner
                   //dbResults#ReturnQuery#(productRecord)
                   llMessageLinked(LINK_SET,0,"dbResults#" + llList2String(lstCurrentRequestedItem,2) + "#" + llList2String(lstCurrentRequestedItem,0) + "#" + llList2String(lstCurrentRequestedItem,1) + "#-1#NO_ITEM_AVAILABLE#NO_IMAGE_AVAILABLE",NULL_KEY);
            
                   //Add a NULL product to product buffer
                   addItem(llList2String(lstCurrentRequestedItem,0) + "#" + llList2String(lstCurrentRequestedItem,1) + "#-1#NO_ITEM_AVAILABLE#NO_IMAGE_AVAILABLE");

                   //Remove the request from the list
                   removeItemRequest(intWaitListIndex);
                   
               }

               blnKeyFound = TRUE;
                    
           }
                
       }
                    
    }
    
}

//---------------------------------------------------------------------------------//
//Copyright Info Below... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//(c)2007 Ilobmirt Tenk

//This file is part of the FOSSL Vendor Project

//    FOSSL Vendor 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; either version 3 of the License, or
//    (at your option) any later version.

//    FOSSL Vendor is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.

//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.

//---------------------------------------------------------------------------------//
//Copyright Info Above... Please Do not Remove                                     //
//---------------------------------------------------------------------------------//

//=================================================================//
//List all the global variables here...
//=================================================================//

//count of the current Notecard line to read
integer intSettingLines = 0;

//key of the notecard line to be read
key keySettingsId;

//This is the slurl to the server location
string strServerLocation = "";

//This counts the number of times the server has been made to deliver an item
integer intServerDeliveries = 0;

//determines if this object displays debugging output
integer blnDebug = FALSE;

//=================================================================//
//Customize the following variables
//=================================================================//

//determines if this script will outsource its e-mail functionality to save itself from that horrid 20 second delay
integer blnEmailAgents = FALSE;

//The name of the products notecard vendor clients will be reading off of
string strProductsCardName = "FOSSL_PRODUCTS_LIST";

//The channel in which server will listen to its owner
integer intListenChannel = 54;

//The key in which communication wil be encrypted with
string strEncryptionKey = "";

//determines if this server will allow others inworld to access the server
integer blnAnonAccess = TRUE;

//determines if this server will allow others outside of Secondlife to access the server
integer blnOutsideAccess = FALSE;

//Email this address upon a deliverey to say that an item has been given to the customer
string strEmailOnDeliverey = ""; 

//=================================================================//
//Customize the above variables
//=================================================================//

//This displays messages to the owner if debug mode has been set to true
debugMessage(string strMessage){

    if(blnDebug == TRUE){

        llOwnerSay(strMessage);
        
    }
    
}

//Used for encrypting communications between itself and the inworld server
string encrypt(string strPayload){

    //If there is an encryption key...
    if(strEncryptionKey != ""){

        //Use this simple Algrorythm to encrypt/decrypt input string
        return llXorBase64StringsCorrect(llStringToBase64(strPayload), llStringToBase64(strEncryptionKey));

    }
    //otherwise...
    else{

        //Just return the string as is.
        return strPayload;

    }

}

//Used for decrypting communications between itself and the inworld server
string decrypt(string strPayload){

    //If there is an encryption key...
    if(strEncryptionKey != ""){

        //Use this simple Algrorythm to encrypt/decrypt input string
        return llBase64ToString(llXorBase64StringsCorrect(strPayload, llStringToBase64(strEncryptionKey)));

    }
    //otherwise...
    else{

        //Just return the string as is.
        return strPayload;
            
    }

}

default
{
    state_entry(){

        //Obtain the first line of the vendor link settings
        keySettingsId = llGetNotecardLine("FOSSL_SERVER_SETTINGS", intSettingLines);
        
        vector vectSimLocation = llGetPos();
        string strPosX = (string) llRound(vectSimLocation.x);
        string strPosY = (string) llRound(vectSimLocation.y);
        string strPosZ = (string) llRound(vectSimLocation.z);
        
        strServerLocation = "http://slurl.com/secondlife/" + llEscapeURL(llGetRegionName()) + "/" + strPosX + "/" + strPosY + "/" + strPosZ;
        debugMessage("Server Location = " + strServerLocation );
        
    }

    //Reset the script when the container object gets rezzed
    on_rez(integer intParam){
     
        llResetScript();
              
    }

    //If somehing within the server changed, update the setting by resetting the script
    changed(integer change){
     
        // If I change the contents of the server
        if(change & CHANGED_INVENTORY){ 

            llOwnerSay("Server contents changed!");
            llOwnerSay("Resetting script to make use of those changes.");
            //reset the script to make use of the changes
            llResetScript();
            
        }
              
    }

    //Read the server settings notecard. Configure the server based on each line.
    dataserver(key query_id, string data) {
        
        if (query_id == keySettingsId) {
            if (data != EOF) {    // not at the end of the notecard

                debugMessage("Notecard Line = \"" + data + "\"");
                //split the record into variable names and values
                list lstSplit = llParseString2List(data,["="],[]);
                string strVariable = llToUpper(llStringTrim(llList2String(lstSplit,0),STRING_TRIM));
                string strValue = llStringTrim(llList2String(lstSplit,1),STRING_TRIM);

                if(strVariable == "PRODUCT CARD"){

                    strProductsCardName = strValue;
                    debugMessage("strProductsCardName = " + strProductsCardName);
            
            
                }
                if(strVariable == "EMAIL AGENTS"){

                    blnEmailAgents = (integer) strValue;
                    debugMessage("blnEmailAgents = " + (string) blnEmailAgents);
            
                }
                
                if(strVariable == "CHANNEL"){

                    intListenChannel = (integer) strValue;
                    debugMessage("intListenChannel = " + (string) intListenChannel);
                    
                }

                if(strVariable == "KEY"){

                    strEncryptionKey = strValue;
                    debugMessage("strEncryptionKey = " + strEncryptionKey);
                    
                }

                if(strVariable == "ANON ACCESS"){

                    blnAnonAccess = (integer) strValue;
                    debugMessage("blnAnonAccess = " + (string) blnAnonAccess);
                    
                }

                if(strVariable == "OUTSIDE ACCESS"){

                    blnOutsideAccess = (integer) strValue;
                    debugMessage("blnOutsideAccess = " + (string) blnOutsideAccess);
                    
                }        
                if(strVariable == "EMAIL"){
                
                    strEmailOnDeliverey = strValue;
                
                }

                keySettingsId = llGetNotecardLine("FOSSL_SERVER_SETTINGS", ++intSettingLines); // request next line
            }
            //Server is done reading its settings. Start listening to the owner and start ilstening in for those e-mails
            else{

                //Capture toggle of Debug Setings
                llListen(intListenChannel,"",llGetOwner(),"debug");
                llListen(intListenChannel,"",llGetOwner(),"id");
                llListen(intListenChannel,"",llGetOwner(),"reset");
                llListen(intListenChannel,"",llGetOwner(),"count");

                llOwnerSay("Server has completed setup.");
                llOwnerSay("Please use \"" + (string) llGetKey() + "\" as the value of \"SERVER\" in the client vendors if you want them to point to this server.");

                llSetTimerEvent(1.0); //set e-mail poll time to 1 second
                                      
            }
        }
        
    }

    //Follow the commands spoken by its owner
    listen(integer channel, string name, key id, string message)
    {

        //If owner wants to listen to the vendor's debug messages
        if(message == "debug"){

            blnDebug = !blnDebug;
            llOwnerSay("Debug Mode set to: " + (string) blnDebug);
            
        }
        //If Owner wants to listen to the server's Id
        else if(message == "id"){

            llOwnerSay("Please use \"" + (string) llGetKey() + "\" as the value of \"SERVER\" in the client vendors if you want them to point to this server.");
            
        }
        //If Owner wants the server to reset its script
        else if(message == "reset"){

            llOwnerSay("Resetting the Server upon command...");
            llResetScript();
            
        }
        else if(message == "count"){
         
            llOwnerSay( "This server has delivered " + (string) intServerDeliveries + " objects since script initialization.");
               
        }
        //Owner didn't give it an adequate command
        else{

            llOwnerSay("I don't know what you want me to do.");
            
        }
        
    }

    //Use this event to poll for incomming e-mails
    timer()
    {

        //poll for any incomming e-mail
        //filtering happens at the e-mail event
        llGetNextEmail("","");
        
    }

    //Triggered when e-mail poll yeids an incomming e-mail
    email(string time, string address, string subject, string body, integer remaining)
    {

        key keyRequester = (key) llGetSubString(address,0,35); //obtain requester uuid from address
        key keyRequesterOwner = llGetOwnerKey(keyRequester); //obtain the owner of the requesting object
        string strMessage = decrypt(llDeleteSubString(body, 0, llSubStringIndex(body, "\n\n") + 1)); //the message without e-mail headers
        string strSubject = decrypt(subject);
        debugMessage("E-mail From: " + address);
        debugMessage("E-mail Subject: " + subject);
        debugMessage("E-mail Message: " + strMessage);
        
        debugMessage("Object Key: " + (string) keyRequester);
        debugMessage("E-mail Owner: " + (string) keyRequesterOwner);
        debugMessage("Server Owner: " + (string) llGetOwner());

        //First condition:
        //Did the e-mail originate with an object made by the same person who owns this server?
        //Its considered safe to accept your own requests, not from others
        integer blnFirstCondition = (keyRequesterOwner == llGetOwner());

        //Second condition:
        //Does the server allow e-mail originate with an object made by someone else within Secondlife?
        //Its considered less safe than condition 1, but its safer than an a sophisticated attack by a web server
        integer blnSecondCondition = ((keyRequester != NULL_KEY) && (blnAnonAccess == TRUE));

        //Third condition:
        //Does the Server allow for ananymous outside access to thie server?
        //Careful, this is the least safest permission of all!!!
        //Source will not be checked for authenticity!!!
        integer blnThirdCondition = ((blnAnonAccess == TRUE) && (blnOutsideAccess == TRUE));
        

        //Does the source of the message meet any of the specified conditions?
        if( (blnFirstCondition == TRUE) || (blnSecondCondition == TRUE) || (blnThirdCondition == TRUE) ){

            debugMessage("Requester Passed Verification, processing request...");
            llSetTimerEvent(0.0); //Stop the polling timer in case there are more e-mails
            
            //If a client vendor requests for a new product card uuid
            if(strSubject == "Requesting Product List"){

                debugMessage("Giving " + (string) keyRequester + " the UUID of the product card.");
                
                //If there are available scripts dedicated to offloading the delay in llEmail, do so.
                //If not, make the e-mail request within this script taking into account the 20 second
                //script delay set in by LL to prevent e-mail spam. <:P
                if(blnEmailAgents == TRUE){

                    llMessageLinked(LINK_SET,0,"EmailRequest#" + address + "#" + encrypt("Update Product List") + "#" + encrypt((string) llGetInventoryKey(strProductsCardName)) ,NULL_KEY);

                }
                else{

                    llEmail(address,encrypt("Update Product List"),encrypt((string) llGetInventoryKey(strProductsCardName)));

                }
                
            }
            //If a client vendor requests for a product to be delivered
            else if(strSubject == "Give Item"){

                intServerDeliveries++;

                //Start by getting the person uuid and the object name
                list lstRequestSplit = llParseString2List(strMessage,["^"],[]);
                debugMessage("Giving " + llKey2Name((key) llList2String(lstRequestSplit,0)) + " a \"" + decrypt(llList2String(lstRequestSplit,1)) + "\"");
                //using the split list, give a person a product as described in the e-mail
                llGiveInventory((key) llList2String(lstRequestSplit,0), llList2String(lstRequestSplit,1));
                
                //Notify the certain e-mail address of a sale
                if(strEmailOnDeliverey != ""){
                    
                    //Send another E-mail Request hopefully, its just a missed e-mail request
                    //Make Request for product card UUID
                    //If there are available scripts dedicated to offloading the delay in llEmail, do so.
                    //If not, make the e-mail request within this script taking into account the 20 second
                    //script delay set in by LL to prevent e-mail spam. <:P
                    if(blnEmailAgents == TRUE){
                        
                        llMessageLinked(LINK_SET,0,"EmailRequest#" + strEmailOnDeliverey + "#Item Delivered - "+ llList2String(lstRequestSplit,1) +"#Purchaser - " + llList2String(lstRequestSplit,0) + "\nItem Purchased - " + llList2String(lstRequestSplit,1) +"\nLocation - " + strServerLocation,NULL_KEY);
                         debugMessage("Sent email notification to " + strEmailOnDeliverey);
                        
                    }
                    else{
                        
                        llEmail(strEmailOnDeliverey ,"Item Delivered - "+ llList2String(lstRequestSplit,1), "Purchaser - " + llList2String(lstRequestSplit,0) + "\nItem Purchased - " + llList2String(lstRequestSplit,1) +"\nLocation - " + strServerLocation);
                        
                    }
            
                }
                    
            }
        }

        //If there are no more e-mail requests, start polling using the timer
        if(remaining <= 0){

            llSetTimerEvent(1.0);
            
        }
        //Otherwise, just get the next message right here
        else{

            llGetNextEmail("","");
            
        }
            
    }

}

//FOSSLVendorMainClient
//---------------------------------------------------------------------------------//
//Copyright Info Below... Please Do not Remove //
//---------------------------------------------------------------------------------//

//(c)2007 Ilobmirt Tenk

//This file is part of the FOSSL Vendor Project

// FOSSL Vendor 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; either version 3 of the License, or
// (at your option) any later version.

// FOSSL Vendor is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.

//---------------------------------------------------------------------------------//
//Copyright Info Above... Please Do not Remove //
//---------------------------------------------------------------------------------//

//=================================================================//
//List all the global variables here...
//=================================================================//

string strCurrentItem = ""; //This is the current item that the product index is on
// the server, store the notecards in the server
string strINFO = " Info"; //This is the suffix for the info notecard - create one for each product - if using
integer intSeparateInfo = TRUE; //SET TRUE OR FALSE - if true the vendor will deliver a separate card for each item

list lstItemRequestList; //List of items to be requested from the server
//each record is in the form of "Category#SubCategory#DatabaseKey"

list lstDisplays; //List of displays to render products on
//Each display has a record of "Link#absoluteCategory#Category#absoluteSubCategory #SubCategory"

integer intHashCounter = -2147483646; //Used in the creation of a unique request

integer intSettingLines = 0; //Total # of lines in the settings notecard

integer intProductLines = 0; //Total # of lines in the products notecard

integer intItemRequestList = 0; //Number of item database requests to send to the server

integer intProductIndexCategory = 0; //Current index of visible product shown by Category

integer intProductIndexSubCategory = 0; //Current index of visible product shown by sub Category

integer intProductIndexMaxCategory = 0; //Maximum index of categorys

integer intProductIndexMaxSubCategory = 0; //Maximumindex of SubCategorys

integer intInfoCount = 0; //Number of times people clicked on the info button

integer intEmailRequestStarted = 0; //Last time an e-mail was sent out to the server

integer intLastProductUpdate = 0; //Last time product list was updated

key keySettingsId; //Used to load system Settings

key keyProductsUUID; //The uuid of the notecard to be read for products

key keyProductCategories; //The key of the line being read from the products card to determine length of categories

integer blnWaitingForServer = FALSE; //Used to determine if vendor is currently requesting a uuid for the product notecard

integer blnServerDown = TRUE; //Used to determine if the in-world server is down

integer blnDebug = FALSE; //Used to determine if vendor will output debugging information

string strVendorLocation = ""; //This is the slurl to the vendor location

//=================================================================//
//Customize the following variables
//=================================================================//

key keyTexLoading = "56617727-a972-f7d2-a730-484644a1fcb7"; //Texture UUID to represent that an item is loading

key keyTexOffline = "b8426d53-221d-9fc2-5b29-3ef16e2bd7a3"; //Texture UUID to represent the vendor has no connection to the server

key keyTexNothing = "93481f65-67ff-f166-cc64-e6fe1069c1c1"; //Texture UUID to represent that there is no item for this index

key keyServer = NULL_KEY; //This is a pointer to an object server. If this is not NULL_KEY, the vending system will consider selling items from that server.

string strInfoCardName = ""; //Name of the information notecard that talks about your company

string strProductsCardName = "FOSSL_PRODUCTS_LIST"; //Name of the products card to read off of

string strEncryptionKey = ""; //Key to encrypt its communications with

integer intBuffer = 0; //How big do you want you product inventory to be? This goes beyond the # of displays

float fltInventoryRefresh = 3600.0; //Time delay before vendor clears its product inventory and makes another request for more items

integer intServerTimeout = 60; //Time in seconds before vendor is considered down

integer intCommChannel = 45; //Channel in which you can communicate to your vending machine

string strEmailOnSale = ""; //Email this address upon a sale to say that an item has been bought

integer blnEmailAgents = FALSE; //Can this script export the task of sending e-mails to other in-world objects?

//=================================================================//
//Customize the above variables
//=================================================================//



//=================================================================//
//Define global Functions here...
//=================================================================//

//This displays messages to the owner if debug mode has been set to true
debugMessage(string strMessage){

    if(blnDebug == TRUE){

        llOwnerSay("FOSSLVendorMainClient: " + strMessage);

    }

}

//Used for encrypting communications between itself and the inworld server
string encrypt(string strPayload){

    //If there is an encryption key...
    if(strEncryptionKey != ""){

        //Use this simple Algrorythm to encrypt/decrypt input string
        return llXorBase64StringsCorrect(llStringToBase64(strPayload), llStringToBase64(strEncryptionKey));

    }
    //otherwise...
    else{

        //Just return the string as is.
        return strPayload;

    }

}

//Used for decrypting communications between itself and the inworld server
string decrypt(string strPayload){

    //If there is an encryption key...
    if(strEncryptionKey != ""){

    //Use this simple Algrorythm to encrypt/decrypt input string
    return llBase64ToString(llXorBase64StringsCorrect(strPayload, llStringToBase64(strEncryptionKey)));

    }
    //otherwise...
    else{

        //Just return the string as is.
        return strPayload;

    }

}

//Enters the vending system into an offline mode if not offline already
goOffline(){

    blnServerDown = TRUE; //Set state of vendor to be offline
    clearRequests(); //Clear any pending requests for products
    llMessageLinked(LINK_SET,0,"goingOffline",NULL_KEY); //Notify system its going offline
    displaysOffline(); //Reflect the changes on display

}

//Restores functionality to the vending machine from an offline mode
goOnline(){

    blnServerDown = FALSE; //Set state of vendor to be online
    llMessageLinked(LINK_SET,0,"goingOnline",NULL_KEY);
    displaysLoading(); //reflect changes on display

}

//This will set each display to a loading texture
//This will also send out database requests for each link
displaysLoading(){

    list lstDisplay = [];
    integer intIndex = 0;
    integer intDisplayIndex = 0;
    integer intDisplays = llGetListLength(lstDisplays);
    integer blnDisplayAbsoluteCategory = 0;
    integer blnDisplayAbsoluteSubCategory = 0;
    integer intDisplayCategory = 0;
    integer intDisplaySubCategory = 0;
    integer intDisplayRelativeCategory = 0;
    integer intDisplayRelativeSubCategory = 0;

    strCurrentItem = "";
    updatePrices();

    //Loop through each index of the available displays
    for(; intIndex < intDisplays; intIndex++){

        //collect prim location, then texturethem with the offline texture
        //Link#absoluteCategory#Category#absoluteSubCategory #SubCategory
        lstDisplay = llParseString2List(llList2String(lstDisplays,intIndex),["#"],[]);
        intDisplayIndex = (integer) llList2String(lstDisplay,0);

        intDisplayRelativeCategory = (integer) llList2String(lstDisplay,2);
        blnDisplayAbsoluteCategory = (integer) llList2String(lstDisplay,1);
        blnDisplayAbsoluteSubCategory = (integer) llList2String(lstDisplay,3);
        intDisplayRelativeSubCategory = (integer) llList2String(lstDisplay,4);

        //Obtain displayed category
        if(blnDisplayAbsoluteCategory == TRUE){

            intDisplayCategory = intDisplayRelativeCategory;
            debugMessage("Display category is Absolute");

        }
        else{

            intDisplayCategory = intDisplayRelativeCategory + intProductIndexCategory;
            debugMessage("Display category is Relative");
            
            debugMessage("Normalising Category index");
            //Make sure displayed Category is between 0 and the maximum category
            while(intDisplayCategory > intProductIndexMaxCategory){

                intDisplayCategory -= (intProductIndexMaxCategory + 1);

            }

            while(intDisplayCategory < 0){

                intDisplayCategory += (intProductIndexMaxCategory + 1);

            }

        }

        //Obtain displayed SubCategory
        if(blnDisplayAbsoluteSubCategory == TRUE){

            intDisplaySubCategory = intDisplayRelativeSubCategory;
            debugMessage("Display subcategory is Absolute");

        }
        else{

            intDisplaySubCategory = intDisplayRelativeSubCategory + intProductIndexSubCategory;
            debugMessage("Display subcategory is relative");
        
            debugMessage("Normalising Category index");
            //Make sure displayed SubCategory is between 0 and the maximum category
            while(intDisplaySubCategory > intProductIndexMaxSubCategory){

                intDisplaySubCategory -= (intProductIndexMaxSubCategory + 1);

            }

            while(intDisplaySubCategory < 0){

                intDisplaySubCategory += (intProductIndexMaxSubCategory + 1) ;

            }

        }

        debugMessage("Display Categories found @ " + (string) intDisplayCategory + "#" + (string) intDisplaySubCategory);

        llSetLinkTexture(intDisplayIndex, keyTexLoading ,ALL_SIDES);

        debugMessage("Item Request for link # "+ (string) intDisplayIndex +" = " + (string) intDisplayCategory + "#" + (string) intDisplaySubCategory);
        itemRequest(intDisplayCategory,intDisplaySubCategory,intDisplayIndex);

    }

}

//This will Update all visible displays with the offline texture
//Also, it will prevent payments to be made to the machine
displaysOffline(){

    list lstDisplay = [];
    integer intIndex = 0;
    integer intDisplayIndex = 0;
    integer intDisplays = llGetListLength(lstDisplays);

    strCurrentItem = "";
    updatePrices();

    //Loop through each index of the available displays
    for(; intIndex < intDisplays; intIndex++){

        //collect prim location, then texturethem with the offline texture
        lstDisplay = llParseString2List(llList2String(lstDisplays,intIndex),["#"],[]);
        intDisplayIndex = (integer) llList2String(lstDisplay,0);
        llSetLinkTexture(intDisplayIndex, keyTexOffline ,ALL_SIDES);

    }

}

//This will update a single screen with an associated texture
updateDisplay(string strReturnQuery){

    debugMessage("strReturnQuery for texturing = " + strReturnQuery);
    //Extract the query into its elements
    //return query = "dbResults#ReturnQuery#(productRecord)"
    //ProductRecord = "Category#Subcategory#Price#Name#TextureUUID"
    list lstReturnQuery = llParseString2List(strReturnQuery,["#"],[]);

    //extract the query ID into its elements
    //queryID = "linkNumber^queryHash"
    list lstQuery = llParseString2List(llList2String(lstReturnQuery,1) ,["#"],[]);
    string strTextureElement = llList2String(lstReturnQuery,6);

    integer intLinkNumber = (integer) llList2String(lstQuery,0);
    debugMessage("Texture for Prim #"+ (string) intLinkNumber +" = " + strTextureElement );

    //Granted, the image for the item index is available, texure it.
    if( (strTextureElement != "") && (strTextureElement != "NO_IMAGE_AVAILABLE") ){

        llSetLinkTexture(intLinkNumber,(key) strTextureElement,ALL_SIDES);

    }
    //If there doesn't appear to be an image for the product, give it the nothing texture
    else{

        llSetLinkTexture(intLinkNumber,keyTexNothing,ALL_SIDES);

    }

    //If query returned something that is equal to product index, capture it as a current index
    if((llList2String(lstReturnQuery,2) + "#" + llList2String(lstReturnQuery,3)) == ((string)intProductIndexCategory + "#" + (string)intProductIndexSubCategory )){

        strCurrentItem = llDumpList2String(llList2List(lstReturnQuery,2,-1),"#");
        //change the info card name
        if (intSeparateInfo == TRUE){

            // use the product name plus the strINFO suffix to identify the notecard to deliver;
            strInfoCardName = llList2String(llList2List(lstReturnQuery,2,-1), 3) + strINFO;
            
        }
        //NB if FALSE the originally set info card wil be used instead;

        debugMessage("Current Info name:" + strInfoCardName);
        //Update prices
        updatePrices();

    }

}


//This makes the vendor update the price based upon current Index as well as the displayed objects.
updatePrices(){

    list lstParsedItem = [];
    integer intPrice = 0;

    if(strCurrentItem != ""){

        lstParsedItem = llParseString2List(strCurrentItem,["#"],[]);
        intPrice = (integer) llList2String(lstParsedItem,2);
    
        if((intPrice > 0) && (blnServerDown == FALSE) ){

            llSetPayPrice(PAY_HIDE, [intPrice, PAY_HIDE, PAY_HIDE, PAY_HIDE]);

        }
        else{

            llSetPayPrice(PAY_HIDE, [PAY_HIDE, PAY_HIDE, PAY_HIDE, PAY_HIDE]);

        }

        llMessageLinked(LINK_SET,intPrice,"updatePrice",NULL_KEY); //set the prices for the buy/gift buttons

    }
    else{

        llSetPayPrice(PAY_HIDE, [PAY_HIDE, PAY_HIDE, PAY_HIDE, PAY_HIDE]);

    }


}


//This function adds item requests to the buffer before it starts obtaining them from the database
itemRequest(integer intCategory, integer intSubCategory, integer intLink){

    //keep hash counter going. Never let it reach its end
    if(intHashCounter == 2147483646 ){

        intHashCounter = -2147483646;

    }

    string strQueryID = (string)intLink + "^" + llMD5String("H@5h",++intHashCounter);

    //take that record and add it to the waitlist
    lstItemRequestList = llListReplaceList((lstItemRequestList = []) + lstItemRequestList,[(string)intCategory + "#" + (string)intSubCategory + "#" + strQueryID ],intItemRequestList,intItemRequestList);

    //increment # of items on the waitlist
    intItemRequestList++;

    llMessageLinked(LINK_SET,0,"dbRequest#" + strQueryID + "#" + (string) intCategory + "#" + (string) intSubCategory ,NULL_KEY);

}

//This function removes item requests by their index
removeItemRequest(integer intIndex){

    //remove the item by index
    lstItemRequestList = llDeleteSubList((lstItemRequestList = []) + lstItemRequestList,intIndex,intIndex);
    
    //decrement # of items on the waitlist
    intItemRequestList--;


}

//clears the request buffer
clearRequests(){

    lstItemRequestList= [];
    intItemRequestList = 0;

}

//Proccesses the dbQuery to see if it matches a request
processQuery(string strDBQuery){

    integer intIndex = -1;
    integer blnFound = FALSE;
    string strQueryID = llList2String(llParseString2List(strDBQuery,["#"],[]),1);
    list lstParsedRequest = [];

    debugMessage("Proccessing Query = " + strQueryID );

    //loop while there are requests to proccess and if the query doesn't match
    do{

        ++intIndex; //advance an index

        lstParsedRequest = llParseString2List(llList2String(lstItemRequestList,intIndex),["#"],[]);

        if(strQueryID == llList2String(lstParsedRequest,2) ){

            blnFound = TRUE;

            updateDisplay(strDBQuery);

            removeItemRequest(intIndex);

        }

    }while( (intIndex < intItemRequestList) && (blnFound == FALSE) );

}

default
{
    //Activated upon the beginning of script execution
    //Start setting up vendor settings
    state_entry(){

        //Keep debug mode in all scripts the same on startup or reset
        llMessageLinked(LINK_SET,0,"debugMode#"+ (string) blnDebug ,NULL_KEY);
        llOwnerSay("FOSSLVendorClient: Loading Settings...");
        keySettingsId = llGetNotecardLine("FOSSL_CLIENT_SETTINGS", intSettingLines); //Obtain the first line of the vendor settings
        
        vector vectSimLocation = llGetPos();
        string strPosX = (string) llRound(vectSimLocation.x);
        string strPosY = (string) llRound(vectSimLocation.y);
        string strPosZ = (string) llRound(vectSimLocation.z);
        

        strVendorLocation = "http://slurl.com/secondlife/" + llEscapeURL(llGetRegionName()) + "/" + strPosX + "/" + strPosY + "/" + strPosZ;
        debugMessage("Vendor Location = " + strVendorLocation );
     
    }

    //Activated upon rezzing of its container prim
    //Use this event to update the settings of the vending system
    on_rez(integer start_param){

        //reset the script when I rez it
        llResetScript();

    }

    //Activated upon modification of vendor's inventory
    //Reset script to make use of possible changes
    changed(integer change){

        // If I change the contents of the vendor
        if(change & CHANGED_INVENTORY){

        //reset the script to make use of the changes
            llResetScript();

        }

    }

//Activate this event when a companion script sends out a linked message
    //Use this event to determine if that script is making a request or response of this script
    //This script accepts requests to go online of offline, link clicked requests,
    //screen addition requests, buying requests, and info requests
    link_message(integer sender_num, integer num, string str, key id){

        debugMessage("Link message recieved = " + str);

        list lstMessage = llParseString2List(str,["#"],[]);
        string strFunction = llList2String(lstMessage,0);

        //Vendor module wants vendor to go online
        if(strFunction == "goOnline"){

            goOnline();

        }
        //Vendor module wants vendor to go offline
        if(strFunction == "goOffline"){

            goOffline();

        }
        //"linkClicked#absoluteCategory#CategoryShift#absolut eSubcategory#SubCategoryShift"
        if(strFunction == "linkClicked"){

            integer intDiffCategory = (integer) llList2String(lstMessage,2);
            integer intDiffSubCategory = (integer) llList2String(lstMessage,4);
            integer blnAbsoluteCategory = (integer) llList2String(lstMessage,1);
            integer blnAbsoluteSubCategory = (integer) llList2String(lstMessage,3);

            //Determine Category
            if(blnAbsoluteCategory == TRUE){

                intProductIndexCategory = intDiffCategory;

            }
            else{

                intProductIndexCategory += intDiffCategory;
                
                //Keep Category larger than 0
                while(intProductIndexCategory < 0){

                    intProductIndexCategory += (intProductIndexMaxCategory + 1);

                }
                //Keep Category less than or equal to max
                while(intProductIndexCategory > intProductIndexMaxCategory){

                    intProductIndexCategory -= (intProductIndexMaxCategory+1);

                }

            }

            //Determine Subcategory
            if(blnAbsoluteSubCategory == TRUE){

                intProductIndexSubCategory = intDiffSubCategory;

            }
            else{

                intProductIndexSubCategory += intDiffSubCategory;
                
                //Keep SubCategory larger than 0
                while(intProductIndexSubCategory < 0){

                    intProductIndexSubCategory += (intProductIndexMaxSubCategory + 1);

                }

                //Keep SubCategory less than or equal to max
                while(intProductIndexSubCategory > intProductIndexMaxSubCategory){

                    intProductIndexSubCategory -= (intProductIndexMaxSubCategory + 1);

                }

            }

            clearRequests();
            displaysLoading();

        }
        //"addScreen#absoluteCategory#CategoryShift#absoluteS ubcategory#SubCategoryShift"
        else if(strFunction == "addScreen"){

            debugMessage("Screen added ... Updating the screens");

            lstDisplays += [(string) sender_num + "#" + llList2String(lstMessage,1) + "#" + llList2String(lstMessage,2) + "#" + llList2String(lstMessage,3) + "#" + llList2String(lstMessage,4) ];

            clearRequests();
            llMessageLinked(LINK_SET,0,"addBuffer" ,NULL_KEY); //set new Buffer Length
            displaysLoading();


        }
        //"itemBought#BuyerUUID"
        else if(strFunction == "itemBought"){

            key keyBuyerUUID = (key)llList2String(lstMessage,1);
            list lstItemBought = llParseString2List(strCurrentItem,["#"],[]);
            string strItemBought = llList2String(lstItemBought,3);

            debugMessage( llKey2Name(keyBuyerUUID) + " has bought your item.");
            llWhisper(0,"Thank you " + llKey2Name(keyBuyerUUID) + " for purchasing the " + strItemBought +".");

            //If this is networked, request server to distribute object
            if(keyServer != NULL_KEY){

                //Send another E-mail Request hopefully, its just a missed e-mail request
                //Make Request for product card UUID
                //If there are available scripts dedicated to offloading the delay in llEmail, do so.
                //If not, make the e-mail request within this script taking into account the 20 second
                //script delay set in by LL to prevent e-mail spam. <:P
                if(blnEmailAgents == TRUE){

                    llMessageLinked(LINK_SET,0,"EmailRequest#" + (string) keyServer + "@lsl.secondlife.com#"+ encrypt("Give Item") +"#" + encrypt((string) keyBuyerUUID + "^" + strItemBought) ,NULL_KEY);

                    //Notify the certain e-mail address of a sale
                    if(strEmailOnSale != ""){
                        
                        llMessageLinked(LINK_SET,0,"EmailRequest#" + strEmailOnSale + "#Item Purchsed - "+ strItemBought +"#Purchaser - " + llKey2Name(keyBuyerUUID) + "\nItem Purchased - " + strItemBought +"\nLocation - " + strVendorLocation,NULL_KEY);
                         debugMessage("Sent email notification to " + strEmailOnSale);
                        
                    }

                }
                else{

                    llEmail((string) keyServer + "@lsl.secondlife.com",encrypt("Give Item"),encrypt((string) keyBuyerUUID + "^" + strItemBought));
                    //Notify the certain e-mail address of a sale
                    if(strEmailOnSale != ""){
                        
                        llEmail( strEmailOnSale, "Item Purchsed - "+ strItemBought,"Purchaser - " + llKey2Name(keyBuyerUUID) + "\nItem Purchased - " + strItemBought +"\nLocation - " + strVendorLocation);
                        debugMessage("Sent email notification to " + strEmailOnSale);
                        
                    }

                }

            }
            //Otherwise, give the person the object in its own inventory
            else{

                llGiveInventory(keyBuyerUUID, strItemBought);

            }

        }
        //"infoRequested#requesterUUID"
        else if(strFunction == "infoRequested"){

            intInfoCount++;
            key keyRequesterUUID = (key)llList2String(lstMessage,1);
            debugMessage( llKey2Name(keyRequesterUUID) + " wants to know more about your business.");


            //If this is networked, request server to distribute notecard
            if(keyServer != NULL_KEY){

                //Send another E-mail Request hopefully, its just a missed e-mail request
                //Make Request for product card UUID
                //If there are available scripts dedicated to offloading the delay in llEmail, do so.
                //If not, make the e-mail request within this script taking into account the 20 second
                //script delay set in by LL to prevent e-mail spam. <:P
                if(blnEmailAgents == TRUE){

                    llMessageLinked(LINK_SET,0,"EmailRequest#" + (string) keyServer + "@lsl.secondlife.com#"+ encrypt("Give Note") +"#" + encrypt((string) keyRequesterUUID + "^" + strInfoCardName) ,NULL_KEY);

                }
                else{

                    llEmail((string) keyServer + "@lsl.secondlife.com",encrypt("Give Note"),encrypt((string) keyRequesterUUID + "^" + strInfoCardName));

                }

            }
            //Otherwise, give the person the object in its own inventory
            else{

                llGiveInventory(keyRequesterUUID, strInfoCardName);

            }

        }
        //dbResults#QueryID#(product data)
        else if(strFunction == "dbResults"){

            processQuery(str);//check if response was needed

        }
        else{

            //Ignore the message

        }

    }

    //used to read vendor settings, calculate index lengths, and retrieve product data
    dataserver(key query_id, string data) {

        //Whenever vendor is reading the settings notecard.
        //This usually happens once during script initialization
        //Data should be an assignment per line
        //Record format should be "variable=value"
        if (query_id == keySettingsId) {
    
            if (data != EOF) { // not at the end of the notecard
    
                //split the record into variable names and values
                list lstSplit = llParseString2List(data,["="],[]);
                string strVariable = llToUpper(llStringTrim(llList2String(lstSplit,0),STRING_TRIM));
                string strValue = llStringTrim(llList2String(lstSplit,1),STRING_TRIM );

                if(strVariable == "LOADING TEXTURE"){

                    keyTexLoading = (key) strValue;

                }
                if(strVariable == "EMAIL"){

                    strEmailOnSale = strValue;

                }
                if(strVariable == "SEPARATE INFO"){

                    intSeparateInfo = (integer) strValue;
                    
                }
                if(strVariable == "INFO SUFFIX"){

                    strINFO = strValue;
                    debugMessage("INFO CARD SUFFIX:" + strINFO);

                }
                if(strVariable == "OFFLINE TEXTURE"){

                    keyTexOffline = (key) strValue;

                }
                if(strVariable == "NOTHING TEXTURE"){

                    keyTexNothing = (key) strValue;

                }
                if(strVariable == "SERVER"){

                    keyServer = (key) strValue;

                }
                if(strVariable == "PRODUCT CARD"){

                    strProductsCardName = strValue;

                }
                if(strVariable == "INFO CARD"){

                    strInfoCardName = strValue;

                }
                if(strVariable == "COMM CHANNEL"){

                    intCommChannel = (integer) strValue;

                }
                if(strVariable == "REFRESH"){

                    fltInventoryRefresh = (float) strValue;

                }
                if(strVariable == "TIMEOUT"){

                    intServerTimeout = (integer) strValue;

                }
                if(strVariable == "BUFFER"){

                    intBuffer = (integer) strValue;

                }
                if(strVariable == "EMAIL AGENTS"){

                    blnEmailAgents = (integer) strValue;

                }
                if(strVariable == "KEY"){

                    strEncryptionKey = strValue;

                }

                keySettingsId = llGetNotecardLine("FOSSL_CLIENT_SETTINGS", ++intSettingLines); // request next line
        
            }
            //Settings notecard has been read, proceed with obtaining products card.
            else{

                llOwnerSay("FOSSLVendorClient: Vendor Settings loaded.");
                llListen(intCommChannel,"",llGetOwner(),"count"); //activate listen event whenever I say count on the listening channel
                llListen(intCommChannel,"",llGetOwner(),"debug"); //activate listen event whenever I say debug on the listening channel
                llListen(intCommChannel,"",llGetOwner(),"reset"); //activate listen event whenever I say reset on the listening channel
                llListen(intCommChannel,"",llGetOwner(),"online"); //activate listen event whenever I say online on the listening channel
                llListen(intCommChannel,"",llGetOwner(),"offline"); //activate listen event whenever I say offline on the listening channel
                llListen(intCommChannel,"",llGetOwner(),"memory"); //activate listen event whenever I say memory on the listening channel

                //Is this vendor networked?
                if(keyServer != NULL_KEY){

                    llOwnerSay("FOSSLVendorClient: Vendor is networked. Contacting Server for Product List.");

                    //If there are available scripts dedicated to offloading the delay in llEmail, do so.
                    //If not, make the e-mail request within this script taking into account the 20 second
                    //script delay set in by LL to prevent e-mail spam. <:P
                    if(blnEmailAgents == TRUE){

                        llMessageLinked(LINK_SET,0,"EmailRequest#" + (string) keyServer + "@lsl.secondlife.com#"+ encrypt("Requesting Product List") + "#" + encrypt("NULL"),NULL_KEY);

                    }
                    else{

                        llEmail((string) keyServer + "@lsl.secondlife.com",encrypt("Requesting Product List"),encrypt("NULL"));

                    }
                    blnWaitingForServer = TRUE;
                    intEmailRequestStarted = llGetUnixTime();
                    llSetTimerEvent(1.0);

                }
                //Otherwise, if it is not networked, load the product list uuid locally
                else{

                    llOwnerSay("FOSSLVendorClient: Vendor is not networked. Obtaining Product List locally.");
                    keyProductsUUID = llGetInventoryKey(strProductsCardName);
                    llOwnerSay("FOSSLVendorClient: Determining Maximums for Categories and Subcategories. This may take a while...");
                    //start obtaining the # of categories and subcategories
                    keyProductCategories = llGetNotecardLine(keyProductsUUID,intProductLines) ;

                }

                //Update database buffer to the length specified by notecard
                llMessageLinked(LINK_SET, 0, "setBuffer#" + (string) intBuffer, NULL_KEY);

            }
        }
        //Whenever vendor is reading the products notecard to determine size of its categories and subcategories.
        else if(query_id == keyProductCategories){

            //If the products notecard needs to be read further...
            if(data != EOF){

                list lstProductParsedLine = llParseString2List(data,["#"],[]); //Parse the line into a list
    
                //Determine if current Category # is the current Maximum
                if(intProductIndexMaxCategory < (integer) llList2String(lstProductParsedLine,0)){

                    intProductIndexMaxCategory = (integer) llList2String(lstProductParsedLine,0);

                }

                //Determine if current SubCategory # is the current Maximum
                if(intProductIndexMaxSubCategory < (integer) llList2String(lstProductParsedLine,1)){

                    intProductIndexMaxSubCategory = (integer) llList2String(lstProductParsedLine,1);

                }

                //Read the next line of the products notecard
                keyProductCategories = llGetNotecardLine(keyProductsUUID,++intProductLines);

            }
            //After reading the notecard, vendor is ready to operate
            else{

                llOwnerSay("FOSSLVendorClient: Categories and SubCategories determined. Vendor is now able to load products.");

                intProductLines = 0; //clear this for later updates
                clearRequests(); //clear any requests for products if any
                llMessageLinked(LINK_SET,0,"setBuffer#" + (string) intBuffer ,NULL_KEY);//clear the current list of products in buffer, if any
                llMessageLinked(LINK_SET, 0, "setDB#" + (string) keyProductsUUID, NULL_KEY); //Tell Database where it gets its data
                goOnline();

                //Request displays to register if there are none already
                if(lstDisplays == []){

                    llMessageLinked(LINK_SET,0,"getDisplays",NULL_KEY); //request all screens to register

                }

                //Only refresh the inventory if it is networked
                if(keyServer != NULL_KEY){

                    llSetTimerEvent(fltInventoryRefresh); //Set timer to request product notecard uuid at a set interval

                }

            }

        }

    }

    timer(){

        //Depending on if the vendor is waiting from a response from the server,
        //either wait for an e-mail from the server, or make a request for an updated product list
        if(blnWaitingForServer == TRUE){
    
            if(llGetUnixTime() - intEmailRequestStarted < intServerTimeout){
    
                //llGetNextEmail((string) keyServer + "@lsl.secondlife.com",encrypt("Update Product List"));
                llGetNextEmail("","");        
        
            }
            else{

                //take vendor offline if not done already
                goOffline();

                //Send another E-mail Request hopefully, its just a missed e-mail request
                //Make Request for product card UUID
                //If there are available scripts dedicated to offloading the delay in llEmail, do so.
                //If not, make the e-mail request within this script taking into account the 20 second
                //script delay set in by LL to prevent e-mail spam. <:P
                if(blnEmailAgents == TRUE){

                    llMessageLinked(LINK_SET,0,"EmailRequest#" + (string) keyServer + "@lsl.secondlife.com#"+ encrypt("Requesting Product List") + "#" + encrypt("NULL"),NULL_KEY);

                }
                else{

                    llEmail((string) keyServer + "@lsl.secondlife.com",encrypt("Requesting Product List"),encrypt("NULL"));

                }

                intEmailRequestStarted = llGetUnixTime(); //After this, timer loop will look for a server response

            }

        }
        else{

            //Make Request for product card UUID
            //If there are available scripts dedicated to offloading the delay in llEmail, do so.
            //If not, make the e-mail request within this script taking into account the 20 second
            //script delay set in by LL to prevent e-mail spam. <:P
            if(blnEmailAgents == TRUE){

                llMessageLinked(LINK_SET,0,"EmailRequest#" + (string) keyServer + "@lsl.secondlife.com#"+ encrypt("Requesting Product List") + "#" + encrypt("NULL"),NULL_KEY);

            }
            else{

                llEmail((string) keyServer + "@lsl.secondlife.com",encrypt("Requesting Product List"),encrypt("NULL"));

            }

            blnWaitingForServer = TRUE;
            intEmailRequestStarted = llGetUnixTime(); //After this, timer loop will look for a server response
            llSetTimerEvent(1.0);

        }

    }

    email(string time, string address, string subject, string body, integer remaining){

        debugMessage("Recieved E-mail from : " + address);

        if (address == (string) keyServer + "@lsl.secondlife.com" && subject == encrypt("Update Product List")){

            //don't wait for more e-mail
            blnWaitingForServer = FALSE;

            //make this the last time products were updated
            intLastProductUpdate = llGetUnixTime();

            //Remove e-mail header to generate the new uuid
            key keyNewUUID = (key) decrypt(llDeleteSubString(body, 0, llSubStringIndex(body, "\n\n") + 1));

            //New product notecard uuid is in the message
            keyProductsUUID = keyNewUUID;

            //start obtaining the # of categories and subcategories
            keyProductCategories = llGetNotecardLine(keyProductsUUID,intProductLines) ;

            //polling for further e-mails using the timer event is no longer neccesary
            llSetTimerEvent(0.0);

        }

        if(remaining > 0 ){

            //load the next e-mail in que to try and clear the e-mail buffer
            //llGetNextEmail((string) keyServer + "@lsl.secondlife.com",encrypt("Update Product List"));
            llGetNextEmail("","");

        }

    }

    listen( integer channel, string name, key id, string message ){

        if(id == llGetOwner()){

            //Count the number of times users requested information
            if(message == "count"){
                
                llOwnerSay("FOSSLVendorClient: Notecard info request at " + (string)intInfoCount + ".");
                
            }

            //Enable or disable verbose output
            else if(message == "debug"){

                blnDebug = !blnDebug;
                llOwnerSay("FOSSLVendorClient: Debug Mode set to: " + (string) blnDebug);
                llMessageLinked(LINK_SET,0,"debugMode#" + (string) blnDebug,NULL_KEY);

            }

            //Make the vendor go online
            else if(message == "online"){

                goOnline();
                debugMessage("Vendor attempting to go online");

            }

            //Make the vendor go offline
            else if(message == "offline"){

                goOffline();
                debugMessage("Vendor attempting to go offline");

            }

            //Reset the scripts
            else if(message == "reset"){

                llResetScript();

            }
            //Get the current free memory in script
            else if(message == "memory"){

                llOwnerSay("FOSSLVendorClient: Memory = " + (string) llGetFreeMemory() +"/16000 Bytes");
                llMessageLinked(LINK_SET,0,"getMemory",NULL_KEY); //If other scripts understand this, have them output free memory also

            }
            else{
                
                llOwnerSay("FOSSLVendorClient: I dunno what youre talking about.");
            
            }

        }

    }

}