/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
// Set the replacements;
$objReplac = new A();
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objFaqTable';
$objTokens[2] = 'objFaqTableFId';
$objTokens[3] = 'objFaqTableFAnswer';
$objTokens[4] = 'objFaqTableFQuestion';
$objTokens[5] = 'objFaqTableFSEO';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objFaqTable;
$objReplac[2] = self::$objFaqTableFId;
$objReplac[3] = self::$objFaqTableFAnswer;
$objReplac[4] = self::$objFaqTableFQuestion;
$objReplac[5] = self::$objFaqTableFSEO;
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objArticleTable';
$objTokens[2] = 'objArticleTableFId';
$objTokens[3] = 'objArticleTableFTitle';
$objTokens[4] = 'objArticleTableFSEO';
$objTokens[5] = 'objArticleTableFContent';
$objTokens[6] = 'objArticleTableFDatePublished';
$objTokens[7] = 'objArticleTableFDateUpdated';
$objTokens[8] = 'objArticleTableFAuthorId';
$objTokens[9] = 'objArticleTableFCategoryId';
$objTokens[10] = 'objCategoryTable';
$objTokens[11] = 'objCategoryTableFId';
$objTokens[12] = 'objCategoryTableFName';
$objTokens[13] = 'objCategoryTableFSEO';
$objTokens[14] = 'objArticleTableFExcerpt';
$objTokens[15] = 'objCategoryTableFDescription';
$objTokens[16] = 'objArticleTableFState';
$objTokens[17] = 'objArticleTableFTags';
$objTokens[18] = 'objCommentsTable';
$objTokens[19] = 'objCommentsTableFId';
$objTokens[20] = 'objCommentsTableFName';
$objTokens[21] = 'objCommentsTableFEML';
$objTokens[22] = 'objCommentsTableFURL';
$objTokens[23] = 'objCommentsTableFRUId';
$objTokens[24] = 'objCommentsTableFComment';
$objTokens[25] = 'objCommentsTableFApproved';
$objTokens[26] = 'objCommentsTableFDate';
$objTokens[27] = 'objCommentsTableFArticleId';
$objTokens[28] = 'objArticleTableFViews';
$objTokens[29] = 'objArticleTableFCanComment';
$objTokens[30] = 'objCategoryTableFDate';
$objTokens[31] = 'objAuthenticationUserTable';
$objTokens[32] = 'objAuthenticationUserTableFId';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objArticleTable;
$objReplac[2] = self::$objArticleTableFId;
$objReplac[3] = self::$objArticleTableFTitle;
$objReplac[4] = self::$objArticleTableFSEO;
$objReplac[5] = self::$objArticleTableFContent;
$objReplac[6] = self::$objArticleTableFDatePublished;
$objReplac[7] = self::$objArticleTableFDateUpdated;
$objReplac[8] = self::$objArticleTableFAuthorId;
$objReplac[9] = self::$objArticleTableFCategoryId;
$objReplac[10] = self::$objCategoryTable;
$objReplac[11] = self::$objCategoryTableFId;
$objReplac[12] = self::$objCategoryTableFName;
$objReplac[13] = self::$objCategoryTableFSEO;
$objReplac[14] = self::$objArticleTableFExcerpt;
$objReplac[15] = self::$objCategoryTableFDescription;
$objReplac[16] = self::$objArticleTableFState;
$objReplac[17] = self::$objArticleTableFTags;
$objReplac[18] = self::$objCommentsTable;
$objReplac[19] = self::$objCommentsTableFId;
$objReplac[20] = self::$objCommentsTableFName;
$objReplac[21] = self::$objCommentsTableFEML;
$objReplac[22] = self::$objCommentsTableFURL;
$objReplac[23] = self::$objCommentsTableFRUId;
$objReplac[24] = self::$objCommentsTableFComment;
$objReplac[25] = self::$objCommentsTableFApproved;
$objReplac[26] = self::$objCommentsTableFDate;
$objReplac[27] = self::$objCommentsTableFArticleId;
$objReplac[28] = self::$objArticleTableFViews;
$objReplac[29] = self::$objArticleTableFCanComment;
$objReplac[30] = self::$objCategoryTableFDate;
$objReplac[31] = Authentication::$objAuthUsersTable;
$objReplac[32] = Authentication::$objAuthUsersTableFId;
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objSettingsCountryTable';
$objTokens[2] = 'objSettingsCountryTableFIso';
$objTokens[3] = 'objSettingsCountryTableFName';
$objTokens[4] = 'objSettingsCountryTableFPrnt';
$objTokens[5] = 'objSettingsCountryTableFIsoT';
$objTokens[6] = 'objSettingsCountryTableFCode';
$objTokens[7] = 'objSettingsErrTable';
$objTokens[8] = 'objSettingsErrTableFId';
$objTokens[9] = 'objSettingsErrTableFCode';
$objTokens[10] = 'objSettingsErrTableFTitle';
$objTokens[11] = 'objSettingsErrTableFContent';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objSettingsCountryTable;
$objReplac[2] = self::$objSettingsCountryTableFIso;
$objReplac[3] = self::$objSettingsCountryTableFName;
$objReplac[4] = self::$objSettingsCountryTableFPrnt;
$objReplac[5] = self::$objSettingsCountryTableFIsoT;
$objReplac[6] = self::$objSettingsCountryTableFCode;
$objReplac[7] = self::$objSettingsErrTable;
$objReplac[8] = self::$objSettingsErrTableFId;
$objReplac[9] = self::$objSettingsErrTableFCode;
$objReplac[10] = self::$objSettingsErrTableFTitle;
$objReplac[11] = self::$objSettingsErrTableFContent;
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objContactTable';
$objTokens[2] = 'objContactTableFId';
$objTokens[3] = 'objContactTableFMessage';
$objTokens[4] = 'objContactTableFSubjectId';
$objTokens[5] = 'objContactTableFEMAIL';
$objTokens[6] = 'objContactTableFResolved';
$objTokens[7] = 'objContactTableFComment';
$objTokens[8] = 'objContactTableFReceived';
$objTokens[9] = 'objContactTableFLastEdited';
$objTokens[10] = 'objContactSubjectTable';
$objTokens[11] = 'objContactSubjectFId';
$objTokens[12] = 'objContactSubjectFTitle';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objContactTable;
$objReplac[2] = self::$objContactTableFId;
$objReplac[3] = self::$objContactTableFMessage;
$objReplac[4] = self::$objContactTableFSubjectId;
$objReplac[5] = self::$objContactTableFEMAIL;
$objReplac[6] = self::$objContactTableFResolved;
$objReplac[7] = self::$objContactTableFComment;
$objReplac[8] = self::$objContactTableFReceived;
$objReplac[9] = self::$objContactTableFLastEdited;
$objReplac[10] = self::$objContactSubjectTable;
$objReplac[11] = self::$objContactSubjectFId;
$objReplac[12] = self::$objContactSubjectFTitle;
// Do a CALL to the parent;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current
* module which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objProductsTable';
$objTokens[2] = 'objProductsTableFId';
$objTokens[3] = 'objProductsTableFCode';
$objTokens[4] = 'objProductsTableFName';
$objTokens[5] = 'objProductsTableFSEO';
$objTokens[6] = 'objProductsTableFPDF';
$objTokens[7] = 'objProductsTableFURL';
$objTokens[8] = 'objProductsTableFDescription';
$objTokens[9] = 'objProductsTableFPrice';
$objTokens[10] = 'objProductsTableFStoc';
$objTokens[11] = 'objProductsTableFCategoryId';
$objTokens[12] = 'objCategoryTable';
$objTokens[13] = 'objCategoryTableFId';
$objTokens[14] = 'objCategoryTableFName';
$objTokens[15] = 'objCategoryTableFSEO';
$objTokens[16] = 'objCategoryTableFDescription';
$objTokens[17] = 'objProductsIMGTable';
$objTokens[18] = 'objProductsIMGTableFId';
$objTokens[19] = 'objProductsIMGTableFProdId';
$objTokens[20] = 'objProductsIMGTableFTitle';
$objTokens[21] = 'objProductsIMGTableFURL';
$objTokens[22] = 'objProductsIMGTableFCaption';
$objTokens[23] = 'objProductsPropertyTable';
$objTokens[24] = 'objProductsPropertyTableFId';
$objTokens[25] = 'objProductsPropertyTableFPId';
$objTokens[26] = 'objProductsPropertyTableFKey';
$objTokens[27] = 'objProductsPropertyTableFVar';
$objTokens[28] = 'objCategoryTableFDate';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objProductsTable;
$objReplac[2] = self::$objProductsTableFId;
$objReplac[3] = self::$objProductsTableFCode;
$objReplac[4] = self::$objProductsTableFName;
$objReplac[5] = self::$objProductsTableFSEO;
$objReplac[6] = self::$objProductsTableFPDF;
$objReplac[7] = self::$objProductsTableFURL;
$objReplac[8] = self::$objProductsTableFDescription;
$objReplac[9] = self::$objProductsTableFPrice;
$objReplac[10] = self::$objProductsTableFStoc;
$objReplac[11] = self::$objProductsTableFCategoryId;
$objReplac[12] = self::$objCategoryTable;
$objReplac[13] = self::$objCategoryTableFId;
$objReplac[14] = self::$objCategoryTableFName;
$objReplac[15] = self::$objCategoryTableFSEO;
$objReplac[16] = self::$objCategoryTableFDescription;
$objReplac[17] = self::$objProductsIMGTable;
$objReplac[18] = self::$objProductsIMGTableFId;
$objReplac[19] = self::$objProductsIMGTableFProdId;
$objReplac[20] = self::$objProductsIMGTableFTitle;
$objReplac[21] = self::$objProductsIMGTableFURL;
$objReplac[22] = self::$objProductsIMGTableFCaption;
$objReplac[23] = self::$objProductsPropertyTable;
$objReplac[24] = self::$objProductsPropertyTableFId;
$objReplac[25] = self::$objProductsPropertyTableFPId;
$objReplac[26] = self::$objProductsPropertyTableFKey;
$objReplac[27] = self::$objProductsPropertyTableFVar;
$objReplac[28] = self::$objCategoryTableFDate;
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objLetterTable';
$objTokens[2] = 'objLetterTableFId';
$objTokens[3] = 'objLetterTableFEML';
$objTokens[4] = 'objLetterTableFFirstName';
$objTokens[5] = 'objLetterTableFLastName';
$objTokens[6] = 'objLetterTableFType';
$objTokens[7] = 'objLetterTableFConfirmed';
$objTokens[8] = 'objLetterTableFKey';
$objTokens[9] = 'objLetterTableFSubscribed';
$objTokens[10] = 'objCategoryTable';
$objTokens[11] = 'objCategoryTableFId';
$objTokens[12] = 'objCategoryTableFName';
$objTokens[13] = 'objCategoryTableFSEO';
$objTokens[14] = 'objLetterTableFCategoryId';
$objTokens[15] = 'objCategoryTableFDate';
$objTokens[16] = 'objCategoryTableFDescription';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objLetterTable;
$objReplac[2] = self::$objLetterTableFId;
$objReplac[3] = self::$objLetterTableFEML;
$objReplac[4] = self::$objLetterTableFFirstName;
$objReplac[5] = self::$objLetterTableFLastName;
$objReplac[6] = self::$objLetterTableFType;
$objReplac[7] = self::$objLetterTableFConfirmed;
$objReplac[8] = self::$objLetterTableFKey;
$objReplac[9] = self::$objLetterTableFSubscribed;
$objReplac[10] = self::$objCategoryTable;
$objReplac[11] = self::$objCategoryTableFId;
$objReplac[12] = self::$objCategoryTableFName;
$objReplac[13] = self::$objCategoryTableFSEO;
$objReplac[14] = self::$objLetterTableFCategoryId;
$objReplac[15] = self::$objCategoryTableFDate;
$objReplac[16] = self::$objCategoryTableFDescription;
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objAudioTable';
$objTokens[2] = 'objAudioTableFId';
$objTokens[3] = 'objAudioTableFFile';
$objTokens[4] = 'objAudioTableFTitle';
$objTokens[5] = 'objAudioTableFSEO';
$objTokens[6] = 'objAudioTableFCategoryId';
$objTokens[7] = 'objCategoryTable';
$objTokens[8] = 'objCategoryTableFId';
$objTokens[9] = 'objCategoryTableFName';
$objTokens[10] = 'objCategoryTableFSEO';
$objTokens[11] = 'objCategoryTableFDescription';
$objTokens[12] = 'objAudioTableFArtist';
$objTokens[13] = 'objAudioTableFAlbum';
$objTokens[14] = 'objAudioTableFLyrics';
$objTokens[15] = 'objAudioTableFDescription';
$objTokens[16] = 'objAudioTableFUploaderId';
$objTokens[17] = 'objAudioTableFUploadedDate';
$objTokens[18] = 'objAudioTableFApproved';
$objTokens[19] = 'objAudioTableFArtwork';
$objTokens[20] = 'objCommentsTable';
$objTokens[21] = 'objCommentsTableFId';
$objTokens[22] = 'objCommentsTableFName';
$objTokens[23] = 'objCommentsTableFEML';
$objTokens[24] = 'objCommentsTableFURL';
$objTokens[25] = 'objCommentsTableFRUId';
$objTokens[26] = 'objCommentsTableFComment';
$objTokens[27] = 'objCommentsTableFApproved';
$objTokens[28] = 'objCommentsTableFDate';
$objTokens[29] = 'objCommentsTableFAudioFileId';
$objTokens[30] = 'objAudioTableFViews';
$objTokens[31] = 'objCategoyTableFDate';
$objTokens[32] = 'objAudioTableFCanComment';
$objTokens[33] = 'objAuthenticationUserTable';
$objTokens[34] = 'objAuthenticationUserTableFId';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objAudioTable;
$objReplac[2] = self::$objAudioTableFId;
$objReplac[3] = self::$objAudioTableFFile;
$objReplac[4] = self::$objAudioTableFTitle;
$objReplac[5] = self::$objAudioTableFSEO;
$objReplac[6] = self::$objAudioTableFCategoryId;
$objReplac[7] = self::$objCategoryTable;
$objReplac[8] = self::$objCategoryTableFId;
$objReplac[9] = self::$objCategoryTableFName;
$objReplac[10] = self::$objCategoryTableFSEO;
$objReplac[11] = self::$objCategoryTableFDescription;
$objReplac[12] = self::$objAudioTableFArtist;
$objReplac[13] = self::$objAudioTableFAlbum;
$objReplac[14] = self::$objAudioTableFLyrics;
$objReplac[15] = self::$objAudioTableFDescription;
$objReplac[16] = self::$objAudioTableFUploaderId;
$objReplac[17] = self::$objAudioTableFUploadedDate;
$objReplac[18] = self::$objAudioTableFApproved;
$objReplac[19] = self::$objAudioTableFArtwork;
$objReplac[20] = self::$objCommentsTable;
$objReplac[21] = self::$objCommentsTableFId;
$objReplac[22] = self::$objCommentsTableFName;
$objReplac[23] = self::$objCommentsTableFEML;
$objReplac[24] = self::$objCommentsTableFURL;
$objReplac[25] = self::$objCommentsTableFRUId;
$objReplac[26] = self::$objCommentsTableFComment;
$objReplac[27] = self::$objCommentsTableFApproved;
$objReplac[28] = self::$objCommentsTableFDate;
$objReplac[29] = self::$objCommentsTableFAudioFileId;
$objReplac[30] = self::$objAudioTableFViews;
$objReplac[31] = self::$objCategoryTableFDate;
$objReplac[32] = self::$objAudioTableFCanComment;
$objReplac[33] = Authentication::$objAuthUsersTable;
$objReplac[34] = Authentication::$objAuthUsersTableFId;
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A(array('objAuthDefaultGroup', 'objAuthDefaultUsername', 'objAuthDefaultPassword', 'objAuthUsersTable', 'objAuthUsersTableFId', 'objAuthUsersTableFUName', 'objAuthUsersTableFUPass', 'objAuthUsersTableFEML', 'objAuthUsersTableFPhone', 'objAuthUsersTableFFName', 'objAuthUsersTableFLName', 'objAuthUsersTableFUGId', 'objAuthUsersTableFRegOn', 'objAuthUsersTableFLastLog', 'objAuthUsersTableFHash', 'objAuthUsersTableFActivated', 'objAuthGroupTable', 'objAuthGroupTableFId', 'objAuthGroupTableFName', 'objAuthZonesTable', 'objAuthZonesTableFId', 'objAuthZonesTableFName', 'objAuthZonesTableFDesc', 'objAuthZonesTableFPrice', 'objAuthZoneMTable', 'objAuthZoneMTableFId', 'objAuthZoneMTableFZId', 'objAuthZoneMTableFUGId', 'objAuthZoneMTableFIUG', 'objAuthZoneMTableFAorD', 'objAuthZoneMTableFErase', 'objAuthUsersTableFCountry', 'objAuthUsersTableFSignature', 'objAuthUsersTableFDesc', 'objAuthUsersTableFYM', 'objAuthUsersTableFMSN', 'objAuthUsersTableFICQ', 'objAuthUsersTableFAOL', 'objAuthUsersTableFCity', 'objAuthUsersTableFAvatar', 'objAuthUsersTableFIp', 'objAuthGroupTableFSEO'));
// Set the replacements;
$objReplac = new A(array(self::$objAuthDefaultGroup, self::$objAuthDefaultUsername, self::$objAuthDefaultPassword, self::$objAuthUsersTable, self::$objAuthUsersTableFId, self::$objAuthUsersTableFUName, self::$objAuthUsersTableFUPass, self::$objAuthUsersTableFEML, self::$objAuthUsersTableFPhone, self::$objAuthUsersTableFFName, self::$objAuthUsersTableFLName, self::$objAuthUsersTableFUGId, self::$objAuthUsersTableFRegOn, self::$objAuthUsersTableFLastLog, self::$objAuthUsersTableFHash, self::$objAuthUsersTableFActivated, self::$objAuthGroupTable, self::$objAuthGroupTableFId, self::$objAuthGroupTableFName, self::$objAuthZonesTable, self::$objAuthZonesTableFId, self::$objAuthZonesTableFName, self::$objAuthZonesTableFDesc, self::$objAuthZonesTableFPrice, self::$objAuthZoneMTable, self::$objAuthZoneMTableFId, self::$objAuthZoneMTableFZId, self::$objAuthZoneMTableFUGId, self::$objAuthZoneMTableFIUG, self::$objAuthZoneMTableFAorD, self::$objAuthZoneMTableFErase, self::$objAuthUsersTableFCountry, self::$objAuthUsersTableFSignature, self::$objAuthUsersTableFDesc, self::$objAuthUsersTableFYM, self::$objAuthUsersTableFMSN, self::$objAuthUsersTableFICQ, self::$objAuthUsersTableFAOL, self::$objAuthUsersTableFCity, self::$objAuthUsersTableFAvatar, self::$objAuthUsersTableFIp, self::$objAuthGroupTableFSEO));
// Do a CALL to the parent;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
/**
* Will replace module tokens (also named table fields) that can be used independent of the table structure;
*
* This method, will replace a series of table field tokens, with their respective fields. This is to allow a better way to
* write SQL conditions from the front-end of the module, that will interact perfectly with the back-end of the current module,
* which should make the MVC pattern as pure as possible;
*
* @param S $objSQLParam The SQL string to be processed;
* @return S Will return the current SQL string with modified tokens;
*/
public function doModuleToken(S $objSQLParam)
{
// Set the tokens to be replaced;
$objTokens = new A();
$objTokens[1] = 'objLyricsTable';
$objTokens[2] = 'objLyricsTableFId';
$objTokens[3] = 'objLyricsTableFSEO';
$objTokens[4] = 'objLyricsTableFTitle';
$objTokens[5] = 'objLyricsTableFArtist';
$objTokens[6] = 'objLyricsTableFAlbum';
$objTokens[7] = 'objLyricsTableFLyrics';
$objTokens[8] = 'objLyricsTableFDateAdded';
// Set the replacements;
$objReplac = new A();
$objReplac[1] = self::$objLyricsTable;
$objReplac[2] = self::$objLyricsTableFId;
$objReplac[3] = self::$objLyricsTableFSEO;
$objReplac[4] = self::$objLyricsTableFTitle;
$objReplac[5] = self::$objLyricsTableFArtist;
$objReplac[6] = self::$objLyricsTableFAlbum;
$objReplac[7] = self::$objLyricsTableFLyrics;
$objReplac[8] = self::$objLyricsTableFDateAdded;
// Do a CALL to the parent, make it tokenize;
return parent::doModuleTokens($objTokens, $objReplac, $objSQLParam);
}
