//GetLeaderBoardsOfTest handler func to get the leaderboards of a particilar test func (m *Mongo) GetLeaderBoardsOfTest(c *gin.Context) { testId := c.Param("testId") if testId == "" { utils.ErrorResponse(c, http.StatusBadRequest, "No id provided") return } var result models.Result //convert testid string to bson.ObjectId if bson.IsObjectIdHex(testId) { result.TestId = bson.ObjectIdHex(testId) } else { utils.ErrorResponse(c, http.StatusExpectationFailed, "Cannot retreive test id") return } results, err := result.GetResultByID(m.Database) log.Println("The res", results) if err != nil { utils.ErrorResponse(c, http.StatusInternalServerError, "Cannot retreive from db") return } c.JSON(http.StatusOK, gin.H{ "results": results, }) }
func (m *Mongo) GetAllTest(c *gin.Context) { tokenReceived := c.Query("token") subject, err := utils.AuthenticateTokenGetSubject(tokenReceived) if err != nil { utils.ErrorResponse(c, http.StatusForbidden, "Log In Again") return } var test models.Test test.Subject = subject tests, err := test.GetAllTest(m.Database) if err != nil { utils.ErrorResponse(c, http.StatusInternalServerError, "Could not retreive test") return } c.JSON(http.StatusOK, gin.H{ "err": nil, "tests": tests, }) }
func (m *Mongo) StudentLogin(c *gin.Context) { var loginForm struct { Username string `json:"username"` Password string `json:"password"` } err := c.BindJSON(&loginForm) if err != nil { log.Println("Github retards", err) utils.ErrorResponse(c, http.StatusInternalServerError, "Incorrect params") return } var studMahan models.Student studMahan.Username = loginForm.Username studMahan.Password = loginForm.Password stud, err := studMahan.CheckUserPassword(m.Database) if err != nil { log.Println("Absent", err) utils.ErrorResponse(c, http.StatusNotFound, "No such user") return } if stud.Username != "" { //make the f****n token /** Create the token */ token := jwt.New(jwt.SigningMethodHS256) token.Claims["username"] = stud.Username token.Claims["group"] = stud.Group token.Claims["exp"] = time.Now().Add(time.Hour * 72).Unix() tokenString, err := token.SignedString([]byte(utils.MySigningKey)) if err != nil { utils.ErrorResponse(c, http.StatusInternalServerError, "Error creating token") return } c.JSON(http.StatusOK, gin.H{ "token": tokenString, }) } else { utils.ErrorResponse(c, http.StatusNotFound, "No such user") return } }
func (m *Mongo) GetTest(c *gin.Context) { tokenReceived := c.Query("token") id := c.Param("id") _, err := utils.JwtAuthenticator(tokenReceived) if err != nil { utils.ErrorResponse(c, http.StatusForbidden, "Log in again") return } log.Println("thr dod", id) var test models.Test if bson.IsObjectIdHex(id) { test.Id = bson.ObjectIdHex(id) } else { utils.ErrorResponse(c, http.StatusInternalServerError, "Oh boy not again") return } test, err = test.GetTest(m.Database) if err != nil { utils.ErrorResponse(c, http.StatusInternalServerError, "Could not get the test") return } /** todo get all questions for this test should be probably done with go routines for improved performance */ var questions []models.Question for _, id := range test.QuestionIds { temp_question, err := getQuestion(m.Database, id) if err != nil { log.Println("Somethin's up ", err) } else { questions = append(questions, temp_question) } } c.JSON(http.StatusOK, gin.H{ "err": nil, "test": test, "questions": questions, }) }
func (m *Mongo) GetExams(c *gin.Context) { tokenReceived := c.Query("token") token, err := utils.JwtAuthenticator(tokenReceived) println("ofijwejio") if err != nil { log.Println("kauwa", err) utils.ErrorResponse(c, http.StatusForbidden, "Log IN again") return } username, ok := token.Claims["username"].(string) if !ok { log.Println("kauwa", ok) utils.ErrorResponse(c, http.StatusForbidden, "log in afain") return } var s models.Student s.Username = username groups, err := s.GetGroup(m.Database) if err != nil { log.Println("kauwa", err) utils.ErrorResponse(c, http.StatusInternalServerError, "Its the fuckif se") return } var tests []models.Test for _, group := range groups { t, err := models.GetEnabledByGroup(m.Database, group) if err == nil { for _, value := range t { tests = append(tests, value) } } } c.JSON(http.StatusOK, gin.H{ "tests": tests, }) }
/** Handler for new teacher */ func (mongo *Mongo) AddTeacher(c *gin.Context) { /** Room for imporv use auto bindind */ var teacher models.Teacher var req struct { AdminPass string `json:"adminPass"` Username string `json:"username"` Password string `json:"password"` Subject string `json:"subject"` } err := c.BindJSON(&req) if err != nil { utils.ErrorResponse(c, http.StatusBadRequest, "Could not parse") return } adminPass := req.AdminPass if adminPass == "admin" { teacher.Password = req.Password teacher.Subject = req.Subject teacher.Username = req.Username if teacher.Password == "" || teacher.Subject == "" || teacher.Username == "" { var res utils.Response res.Err = true res.Msg = "Missing params" c.JSON(http.StatusForbidden, res) } else { /** Insert the teacher in the db */ response := teacher.AddDoc(mongo.Database) if response.Err == true { c.JSON(http.StatusInternalServerError, response) } else { c.JSON(http.StatusOK, response) } } } else { var res utils.Response res.Err = true res.Msg = "Unauth " c.JSON(http.StatusForbidden, res) } }
func (m *Mongo) GetUserNames(c *gin.Context) { usernames, err := models.GetUserNames(m.Database) if err != nil { println("E", err) utils.ErrorResponse(c, http.StatusInternalServerError, "F**k's gone wrong") return } c.JSON(http.StatusOK, usernames) }
func (m *Mongo) StudentSignUp(c *gin.Context) { var signUpForm struct { Username string `json:"username"` Password string `json:"password"` Group []string `json:"groups"` } err := c.BindJSON(&signUpForm) if err != nil { log.Println("rui", err) utils.ErrorResponse(c, http.StatusBadRequest, "Params wring") return } if signUpForm.Username == "" || signUpForm.Password == "" || len(signUpForm.Group) == 0 { log.Println(signUpForm) utils.ErrorResponse(c, http.StatusBadRequest, "Give Proper Formats") return } student := models.Student{ Username: signUpForm.Username, Password: signUpForm.Password, Group: signUpForm.Group, } err = student.NewUser(m.Database) if err != nil { log.Println("kauwa", err) utils.ErrorResponse(c, http.StatusInternalServerError, "Cannot sign u up") return } c.JSON(http.StatusOK, gin.H{ "msg": "All done", }) }
func (m *Mongo) EnableTest(c *gin.Context) { tokenReceived := c.Query("token") id := c.Param("id") enabler := c.Query("enable") subject, err := utils.AuthenticateTokenGetSubject(tokenReceived) if err != nil { utils.ErrorResponse(c, http.StatusForbidden, "Log in again") return } log.Println("thr dod", id) var test models.Test test.Subject = subject if bson.IsObjectIdHex(id) { test.Id = bson.ObjectIdHex(id) } else { utils.ErrorResponse(c, http.StatusInternalServerError, "Oh boy not again") return } if enabler == "true" { test.Enable = false } else { test.Enable = true } err = test.SetTestProps(m.Database) if err != nil { utils.ErrorResponse(c, http.StatusInternalServerError, "Could not get the test") return } c.JSON(http.StatusOK, gin.H{ "err": nil, }) }
func (m *Mongo) AddTest(c *gin.Context) { var addTestInput struct { Token string `json:"token"` Ids []string `json:"ids"` Name string `json:"name"` Group string `json:"group"` } //Parse the req body err := c.BindJSON(&addTestInput) if err != nil { //send the incorrect response utils.ErrorResponse(c, http.StatusBadRequest, "Parse error") return } //check the token token, err := utils.JwtAuthenticator(addTestInput.Token) if err != nil { utils.ErrorResponse(c, http.StatusForbidden, "Log In again") return } var test models.Test subject, ok := token.Claims["subject"].(string) if !ok { utils.ErrorResponse(c, http.StatusForbidden, "Log In again") return } var questionIds []bson.ObjectId //convert string ids to object ids for _, e := range addTestInput.Ids { if bson.IsObjectIdHex(e) { log.Println("The objectid for") questionIds = append(questionIds, bson.ObjectIdHex(e)) } else { utils.ErrorResponse(c, http.StatusInternalServerError, "ITS NOT U ITS ME ") return } } test.Subject = subject test.QuestionIds = questionIds test.Name = addTestInput.Name test.Group = addTestInput.Group test.Enable = false //add test to database err = test.AddTest(m.Database) if err != nil { log.Println("The funckin eeror", err) utils.ErrorResponse(c, http.StatusInternalServerError, "Cannot Insert") return } c.JSON(http.StatusOK, gin.H{ "err": nil, }) }
//GetRanks ..get the overall rankings implementing the ranking algo func (m *Mongo) GetRanks(c *gin.Context) { results, err := models.GetResults(m.Database) if err != nil { utils.ErrorResponse(c, http.StatusInternalServerError, "Error querying") return } users := make(map[string]float64) tests := make(map[string]struct{}) var tempTestId string //get unique usernames and testids for _, user := range results { _, ok := users[user.Username] if !ok { users[user.Username] = 0 } tempTestId = user.TestId.Hex() _, okAgain := tests[tempTestId] if !okAgain && tempTestId != "" { tests[tempTestId] = struct{}{} } } log.Println("Users", users, tests) for user := range users { theScore := 0.0 for _ = range tests { var restScore, myScore []float64 totRestScore := 0.0 for _, result := range results { thisScore, err := strconv.ParseFloat(result.Score, 64) if err != nil { log.Println("Errorwa", err) utils.ErrorResponse(c, http.StatusInternalServerError, "Cannot convert to str") return } if result.Username == user { myScore = append(myScore, thisScore) } else { restScore = append(restScore, thisScore) totRestScore += thisScore } } expectedScore := totRestScore / float64(len(restScore)) for _, sc := range myScore { theScore += (sc - expectedScore) } } users[user] = theScore } panic("Not implemented") c.JSON(http.StatusOK, gin.H{ "users": users, "tests": tests, }) }
func (m *Mongo) StoreResult(c *gin.Context) { type ResponseForm struct { Id string `json:"id"` Answer string `json:"answer"` } var resultForm struct { Token string `json:"token"` Score string `json:"score"` Response []ResponseForm `json:"response"` TestId string `json:"test_id"` } err := c.BindJSON(&resultForm) if err != nil { log.Println("rui", err) utils.ErrorResponse(c, http.StatusBadRequest, "Params wring") return } token, err := utils.JwtAuthenticator(resultForm.Token) println("ofijwejio") if err != nil { log.Println("kauwa", err) utils.ErrorResponse(c, http.StatusForbidden, "Log IN again") return } username, ok := token.Claims["username"].(string) if !ok { log.Println("kauwa", ok) utils.ErrorResponse(c, http.StatusForbidden, "log in afain") return } var res []models.Answer for _, r := range resultForm.Response { var temp models.Answer temp.Answer = r.Answer if bson.IsObjectIdHex(r.Id) { temp.QuestionId = bson.ObjectIdHex(r.Id) } res = append(res, temp) } var r models.Result r.Username = username r.Response = res r.Score = resultForm.Score if bson.IsObjectIdHex(resultForm.TestId) { r.TestId = bson.ObjectIdHex(resultForm.TestId) } err = r.InsertResult(m.Database) if err != nil { log.Println("kauwa", err) utils.ErrorResponse(c, http.StatusInternalServerError, "Cannot save result") return } c.JSON(http.StatusOK, gin.H{ "msg": "Done", }) }