doesn't build lol

Common_Errors_how_avoid.md

@@ -0,0 +1,3 @@
+### No such table in DB
+
+Close all rows objects

handler.go

@@ -39,10 +39,11 @@ var DB *sqlx.DB
 
 func loadDumbData() error {
 	// No recur patterns since we aren't using them yet
-	for i:= 1000; i < 1500; i++ {
+	for i:= 0; i < 50; i++ {
 		task := Task{TaskID: i, UserID: "1111", Category: "asdf", TaskName: "some name" + strconv.Itoa(i), Description: "sumdesc" + strconv.Itoa(i), StartTime: time.Now(), EndTime: time.Now(), IsCompleted: false, IsRecurring: false, IsAllDay: false}
 		lol, err := CreateTask(task)
-		if lol || (err != nil){
+		if !lol || (err != nil){
+			fmt.Println("loading EXPLODE", err)
 			return err
 		}
 	}
@@ -88,21 +89,23 @@ func connectToDB() error {
 func CreateTask(task Task) (bool, error) {
 	tx, err := DB.Beginx() //start transaction
 	if err != nil {
+		fmt.Println("breaky 1 ")
 		return false, err
 	}
 	defer tx.Rollback() //abort transaction if error
 
 	//preparing statement to prevent SQL injection issues
-	stmt, err := tx.Preparex("INSERT INTO TaskTable (UserID, Category, TaskName, Description, StartTime, EndTime, IsCompleted, IsRecurring, IsAllDay) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)")
+	stmt, err := tx.Preparex("INSERT INTO TaskTable (TaskID, UserID, Category, TaskName, Description, StartTime, EndTime, IsCompleted, IsRecurring, IsAllDay) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
 	if err != nil {
+		fmt.Println("breaky 2")
 		return false, err
 	}
 
-	defer stmt.Close() //defer the closing of SQL statement to ensure it closes once the function completes
-
-	_, err = stmt.Exec(task.UserID, task.Category, task.TaskName, task.Description, task.StartTime, task.EndTime, task.IsCompleted, task.IsRecurring, task.IsAllDay)
+	defer stmt.Close() //defer the closing of SQL statement to ensure it Closes once the function completes
+	_, err = stmt.Exec(task.TaskID, task.UserID, task.Category, task.TaskName, task.Description, task.StartTime, task.EndTime, task.IsCompleted, task.IsRecurring, task.IsAllDay)
 
 	if err != nil {
+		fmt.Println("breaky 3 ", err)
 		return false, err
 	}
 
@@ -143,22 +146,41 @@ func EditTask(task Task, id int) (bool, error) {
 
 
 // Need hardcode Uid for testing until we have auth0
-func GetUserTask(Uid int) ([]*TaskPreview, error) {
-	rows, err := DB.Query("SELECT TaskID, UserID, Category, TaskName, StartTime, EndTime, IsCompleted, IsRecurring, IsAllDay FROM TaskTable WHERE UserID=?;", Uid)
-	var utaskArr []*TaskPreview
+func GetUserTask(Uid int) ([]TaskPreview, error) {
+	rows, err := DB.Query("SELECT TaskID, UserID, Category, TaskName, StartTime, EndTime, IsCompleted, IsRecurring, IsAllDay FROM TaskTable;")
+	utaskArr := []TaskPreview{}
+	if (err != nil){
+		fmt.Println(err)
+		rows.Close()
+		return utaskArr, err
+	}
+	fmt.Println(Uid)
 	for rows.Next(){
-		taskprev := new(TaskPreview)
-		rows.Scan(&taskprev.TaskID, &taskprev.UserID,&taskprev.Category,&taskprev.TaskName,&taskprev.StartTime,&taskprev.EndTime,&taskprev.IsCompleted,&taskprev.IsRecurring,&taskprev.IsAllDay)
+		var taskprev TaskPreview
+		erro := rows.Scan(&taskprev.TaskID, &taskprev.UserID,&taskprev.Category,&taskprev.TaskName,&taskprev.StartTime,&taskprev.EndTime,&taskprev.IsCompleted,&taskprev.IsRecurring,&taskprev.IsAllDay)
+		if (erro != nil){
+			fmt.Println(erro)
+			rows.Close()
+		}
 		utaskArr = append(utaskArr, taskprev)
 	}
+	rows.Close()
 	return utaskArr, err
 }
 
-func GetTaskId(Tid int) (Task, error){
+func GetTaskId(Tid int) (Task, error, bool){
 	rows, err := DB.Query("SELECT * FROM TaskTable WHERE TaskID=?;", Tid)
 	var taskit Task
+	if err != nil{
+		fmt.Println(err)
+		return taskit, err, false
+	}
 	for rows.Next(){
+
 		rows.Scan(&taskit.TaskID, &taskit.UserID,&taskit.Category,&taskit.TaskName, &taskit.Description, &taskit.StartTime,&taskit.EndTime,&taskit.IsCompleted,&taskit.IsRecurring,&taskit.IsAllDay)
+		rows.Close()
+		return taskit, err, true
 	}
-	return taskit, err
+	rows.Close()
+	return taskit, err, false
 }

main.go

@@ -26,7 +26,15 @@ func main() {
 		fmt.Println("Error connecting to database:", err)
 		return
 	}
-
+	erro := loadDumbData()
+	if erro != nil{
+		fmt.Println("error loaduing dumb data", err)
+	}
+	utest := testmain()
+	if !utest{
+		fmt.Println("unit test failure")
+		return
+	}
 	//Router: takes incoming requests and routes them to functions to handle them
 	//Building a group of routes starting with this path
 	v1 := r.Group("/main/blah") //TODO: FIX the route and the uri's below
@@ -38,7 +46,6 @@ func main() {
 		v1.DELETE("tasks/:id", deleteTask)
 
 	}
-	loadDumbData()
 
 	fmt.Println("Running at http://localhost:8080")
 	r.Run() // listen and serve on 0.0.0.0:8080
@@ -57,8 +64,10 @@ func createTask(c *gin.Context) {
 
 	if success {
 		c.JSON(http.StatusOK, gin.H{"message": "Success"})
+		return
 	} else {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create task", "details": err.Error()})
+		return
 	}
 }
 
@@ -68,6 +77,7 @@ func editTask(c *gin.Context) {
 	id, err := strconv.Atoi(c.Param("id"))
 	if err != nil {
 		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid TaskId"})
+		return
 	}
 
 	if err := c.ShouldBindJSON(&json); err != nil {
@@ -79,13 +89,16 @@ func editTask(c *gin.Context) {
 
 	if success {
 		c.JSON(http.StatusOK, gin.H{"message": "Success"})
+		return
 	} else {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to edit task", "details": err.Error()})
+		return
 	}
 }
 
 func deleteTask(c *gin.Context) {
 	c.JSON(http.StatusOK, gin.H{"message": "Called deleteTask"})
+	return
 }
 
 func getAllUserTasks(c *gin.Context) {
@@ -95,6 +108,7 @@ func getAllUserTasks(c *gin.Context) {
 	if err != nil {
 		fmt.Println("ERROR LOG:  Problem in getAllUserTasks, probably DB related")
 		c.JSON(http.StatusBadRequest, gin.H{"error": "This is really bad"})
+		return
 	}
 	c.JSON(http.StatusOK, gin.H{"list": arr})
 }
@@ -104,11 +118,19 @@ func getTaskById(c *gin.Context) {
 	if(err1 != nil){
 		fmt.Println("ERROR LOG:  str2int error")
 		c.JSON(http.StatusBadRequest, gin.H{"error": "This is really bad"})
+		return
+	}
+	task, err, value := GetTaskId(tid)
+	if !value{
+		fmt.Println("ERROR LOG:  getting a non idd task")
+		c.JSON(http.StatusBadRequest, gin.H{"not found": "no task"})
+		return
 	}
-	task, err := GetTaskId(tid)
 	if err != nil {
 		fmt.Println("ERROR LOG:  Problem in getAllUserTasks, probably DB related")
 		c.JSON(http.StatusBadRequest, gin.H{"error": "This is really bad"})
+		return
 	}
 	c.JSON(http.StatusOK, gin.H{"task": task})
+	return
 }

schema.sql

@@ -1,23 +1,23 @@
 CREATE TABLE UserTable (
-    UserID VARCHAR(255) PRIMARY KEY -- Assuming Auth0 provides a string-based user ID
+    UserID VARCHAR(255) PRIMARY KEY NOT NULL-- Assuming Auth0 provides a string-based user ID
 );
 
 CREATE TABLE TaskTable (
-    TaskID INT PRIMARY KEY,
-    UserID VARCHAR(255),
-    Category VARCHAR(255),
+    TaskID INT PRIMARY KEY NOT NULL,
+    UserID VARCHAR(255) NOT NULL,
+    Category VARCHAR(255) NOT NULL,
     TaskName VARCHAR(255) NOT NULL,
-    Description TEXT,
+    Description TEXT NOT NULL,
     StartTime DATETIME,
     EndTime DATETIME,
-    IsCompleted BOOLEAN,
-    IsRecurring BOOLEAN,
-    IsAllDay BOOLEAN,
+    IsCompleted BOOLEAN NOT NULL,
+    IsRecurring BOOLEAN NOT NULL,
+    IsAllDay BOOLEAN NOT NULL,
     FOREIGN KEY (UserID) REFERENCES UserTable(UserID)
 );
 
 CREATE TABLE RecurrencePatterns (
-    TaskID INT,
+    TaskID INT NOT NULL,
     RecurringType VARCHAR(15) CHECK(RecurringType IN ('daily','weekly','monthly')),
     DayOfWeek INT check(DayOfWeek >= 0 and DayOfWeek <= 7),
     DayOfMonth INT check(DayOfMonth >= 0 and DayOfMonth <= 31),

unittests.go

@@ -0,0 +1,56 @@
+package main
+
+// When a new backend function is made, add a test function for it that returns a bool, and then put that func in testmain
+import (
+	"fmt"
+)
+
+func testmain() bool {
+	return TestCreateTask() && TestEditTask() && TestGetUserTask() && TestGetTaskId()
+}
+
+
+func TestCreateTask() bool {
+	return true
+}
+func TestEditTask() bool {
+	return true
+}
+func TestGetUserTask() bool {
+	taskl, err := GetUserTask(1111)
+	if err != nil{
+		fmt.Println(err)
+		return false
+	}
+	if len(taskl) != 50 {
+		print("error test get user task wrong count")
+		return false
+	}
+	return true
+}
+func TestGetTaskId() bool {
+	task, erro, found := GetTaskId(5)
+	if erro != nil{
+		fmt.Println(err)
+		return false
+	}
+
+	if !found {
+		fmt.Println("didn't find task")
+		return false
+	}
+	if task == nil {
+		fmt.Println("nil task")
+		return false
+	}
+	task, erro, found = GetTaskId(-5)
+	if found == false {
+		fmt.Println("didn't find task")
+		return false
+	}
+	if found{
+		fmt.Println("found bad task")
+		return false
+	}
+	return true
+}