Work on modpattern implementations

1 files changed, 83 insertions, 44 deletions

diff --git a/nameblocker.sp b/nameblocker.sp
index c4c945c..8e6ab33 100644
--- a/nameblocker.sp
+++ b/nameblocker.sp
@@ -53,7 +53,6 @@ public Plugin myinfo = {
 // any other methodmap or descendant of Handle (like Regex)
 
 #define PATTERN_MAX_LEN (512 + 1) /* 512 chars + null terminator */
-
 #define DATABASE_FAIL_MSG "Could not populate regex & pattern lists from database"
 
 enum OperatingMode {
@@ -126,22 +125,23 @@ void xRegisterIntConVar(ConVar& cv, int defaultVal, const char[] name, const cha
 
 int initPrepStatements() {
     char sqlerr[256 + 1];
+    
     SQL_LockDatabase(db);
     if((dbInsert = SQL_PrepareQuery(db, DBINSERTSTATEMENT, sqlerr, sizeof(sqlerr))) == null) {
-        logAndFail("Could not prepare insert statement: %s", sqlerr);
         SQL_UnlockDatabase(db);
+        logAndFail("Could not prepare insert statement: %s", sqlerr);
     }
     if((dbDelete = SQL_PrepareQuery(db, DBDELETESTATEMENT, sqlerr, sizeof(sqlerr))) == null) {
-        logAndFail("Could not prepare delete statement: %s", sqlerr);
         SQL_UnlockDatabase(db);
+        logAndFail("Could not prepare delete statement: %s", sqlerr);
     }
     if((dbReplace = SQL_PrepareQuery(db, DBREPLACESTATEMENT, sqlerr, sizeof(sqlerr))) == null) {
-        logAndFail("Could not prepare replace statement: %s", sqlerr);
         SQL_UnlockDatabase(db);
+        logAndFail("Could not prepare replace statement: %s", sqlerr);
     }
     if((dbPopulate = SQL_PrepareQuery(db, DBPOPULATESTATEMENT, sqlerr, sizeof(sqlerr))) == null) {
-        logAndFail("Could not prepare populate statement: %s", sqlerr);
         SQL_UnlockDatabase(db);
+        logAndFail("Could not prepare populate statement: %s", sqlerr);
     }
 
     // This might not work / I might have to use Format() instead of binding. We will see
@@ -215,7 +215,7 @@ int loadFromDatabase() {
             continue;
         }
 
-        if(aInsertPattern(pattern, cur, patternlist.Length)) {
+        if(aModPattern(MM_INSERT, regexlist.Length, pattern)) {
             LogError("Couldn't add regex \"%s\" to arraylists, continuing", pattern);
             CloseHandle(cur);
         }
@@ -269,7 +269,7 @@ public Action cmdRegisterPattern(int client, int args) {
         return Plugin_Handled;
     }
 
-    if(modPattern(DBM_INSERT, regexlist.Length, pattern)) {
+    if(modPattern(MM_INSERT, regexlist.Length, pattern)) {
         ReplyToCommand(client, "Error: could not register pattern");
         return Plugin_Handled;
     }
@@ -289,7 +289,7 @@ public Action cmdDeletePattern(int client, int args) {
         return Plugin_Handled;
     }
 
-    if(modPattern(DBM_DELETE, index)) {
+    if(modPattern(MM_DELETE, index)) {
         ReplyToCommand(client, "Error: could not remove pattern");
         return Plugin_Handled;
     }
@@ -315,7 +315,7 @@ public Action cmdReplacePattern(int client, int args) {
         return Plugin_Handled;
     }
 
-    if(modPattern(DBM_REPLACE, index, pattern)) {
+    if(modPattern(MM_REPLACE, index, pattern)) {
         ReplyToCommand(client, "Error: could not replace pattern in list");
         return Plugin_Handled;
     }
@@ -333,63 +333,102 @@ public Action cmdListPatterns(int client, int args) {
 
 
 
-enum DBMOD_MODE {
-    DBM_UNDEF,
-    DBM_INSERT,
-    DBM_DELETE,
-    DBM_REPLACE,
-    DBM_TOOBIG
+enum MOD_MODE {
+    MM_UNDEF,
+    MM_DELETE,
+    MM_INSERT,
+    MM_REPLACE,
+    MM_TOOBIG
 };
 
-int modPattern(DBMOD_MODE mode, int index, char[] pattern="") {
+int modPattern(MOD_MODE mode, int index, char[] pattern="", int patternlen=0) {
     if(index < 0 || index > regexlist.Length) return -1;
-    if(mode <= DBM_UNDEF || mode >= DBM_TOOBIG) return -1;
 
-    Transaction dbmod = SQL_CreateTransaction();
-    if(dbmod == null) return -1;
+    switch(mode) {
+        case MM_INSERT: {
+            if(IsNullString(pattern) || patternlen < 0 || patternlen > PATTERN_MAX_LEN) {return -1;}
 
-    // Update transaction
+            // Add pattern to database
+            SQL_LockDatabase(db);
+            SQL_UnlockDatabase(db);
 
-    // char errstr[512]; RegexError reerr;
-    // Regex res = CompileRegex(pattern, gcvarRegexCompFlags.IntValue, errstr, sizeof(errstr), reerr);
-    // if(res == null) {
-    //     LogError("Error: Could not compile regex pattern \"%s\": %s (%d)", pattern, errstr, reerr);
-    //     return -1;
-    // }
+            aModPattern(mode, index, pattern);
+        }
 
-    // Update lists
-        // Try to delete before inserting
+        case MM_DELETE: {
+            // Detele from database
+            SQL_LockDatabase(db);
+            SQL_UnlockDatabase(db);
 
-    return 0;
-}
+            aModPattern(mode, index);
+        }
 
-int aInsertPattern(char pattern[PATTERN_MAX_LEN], Regex res, int index) {
-    if(IsNullString(pattern) || res == null || index < 0 || index > regexlist.Length) return -1;
+        case MM_REPLACE: {
+            LogError("Replace mode not implemented yet");
+            return -1;
 
-    if(index == regexlist.Length) {
-        regexlist.Push(res);
-        patternlist.Push(pattern);
+            // Replace in database
+            // SQL_LockDatabase(db);
+            // SQL_UnlockDatabase(db);
 
-    } else {
-        regexlist.ShiftUp(index);
-        patternlist.ShiftUp(index);
-        regexlist.Set(index, res);
-        patternlist.Set(index, pattern);
+            // aModPattern(mode, index, pattern);
+        }
 
+        default: {
+            LogError("Given invalid DBMOD_MODE");
+            return -1;
+        }
     }
 
     return 0;
 }
 
-int aRemovePattern(int index) {
-    if(index < 0 || index >= regexlist.Length) return -1;
+int aModPattern(MOD_MODE mode, int index, char[] pattern="", int patternlen=0) {
+    if(mode <= MM_UNDEF || mode >= MM_TOOBIG || index < 0 || index > patternlist.Length) return -1;
+
+    if(mode > MM_DELETE) {
+        if(IsNullString(pattern) || patternlen < 0 || patternlen > PATTERN_MAX_LEN) return -1;
+
+        char errstr[512]; RegexError reerr;
+        Regex res = CompileRegex(pattern, gcvarRegexCompFlags.IntValue, errstr, sizeof(errstr), reerr);
+        if(res == null) {
+            LogError("Error: Could not compile regex pattern \"%s\": %s (%d)", pattern, errstr, reerr);
+            return -1;
+        }
+    }
+
 
-    regexlist.Erase(index);
-    patternlist.Erase(index);
 
     return 0;
 }
 
+// int aInsertPattern(char pattern[PATTERN_MAX_LEN], Regex res, int index) {
+//     if(IsNullString(pattern) || res == null || index < 0 || index > regexlist.Length) return -1;
+
+//     if(index == regexlist.Length) {
+//         regexlist.Push(res);
+//         patternlist.Push(pattern);
+
+//     } else {
+//         regexlist.ShiftUp(index);
+//         patternlist.ShiftUp(index);
+//         regexlist.Set(index, res);
+//         patternlist.Set(index, pattern);
+
+//     }
+
+//     return 0;
+// }
+
+// int aRemovePattern(int index) {
+//     if(index < 0 || index >= regexlist.Length) return -1;
+
+//     regexlist.Erase(index);
+//     patternlist.Erase(index);
+
+//     return 0;
+// }
+
 
 
 // Check's a user's name against the regex list. Returns -1 on error, 0 if skipped, 1 on hit