Golang appengine-data.NewConn类(方法)实例源码

func updateTest(wr srv.WrapperRequest, t *Test) error {

	old, err := getTestById(wr, t.Id)
	if err != nil {
		return fmt.Errorf("updatetest: %v", err)
	}

	if wr.NU.ID() != old.AuthorId {
		return fmt.Errorf("updatetest: %s", users.ERR_NOTOPERATIONALLOWED)
	}

	// invariant fields
	t.TimeStamp = old.TimeStamp
	t.AuthorId = old.AuthorId

	q := data.NewConn(wr, "tests")
	err = q.Put(t)
	err = checkExercises(wr, t, err)
	err = deleteExercises(wr, t, err)
	err = addExercises(wr, t, err)
	err = deleteUsersAllowed(wr, t, err)
	err = addUsersAllowed(wr, t, err)
	err = deleteTestTags(wr, t, err)
	err = addTestTags(wr, t, err)

	if err != nil {
		return fmt.Errorf("updatetest: %v", err)
	}

	return nil
}

// Fill the exercises array in the test
func loadExercises(wr srv.WrapperRequest, t *Test, err error) error {
	if err != nil {
		return err
	}
	testEx := NewExerciseBuffer()

	qry := data.NewConn(wr, "tests-exercises")
	qry.AddFilter("TestId =", t.Id)
	err = qry.GetMany(&testEx)
	if err != nil {
		return err
	}

	t.Exercises = testEx

	// check if the test will be loaded for a student, in this case
	// do not read the solutions of the questions
	withSolution := true
	if wr.NU.GetRole() < users.ROLE_TEACHER {
		withSolution = false
	}
	// now, load the questions struct for each exercise
	for i := range t.Exercises {
		var q *questions.Question
		if withSolution {
			q, _ = questions.GetQuestById(wr, t.Exercises[i].QuestId)
		} else {
			q, _ = questions.GetQuestByIdWithoutSol(wr, t.Exercises[i].QuestId)
		}
		t.Exercises[i].Quest = q
	}

	return nil
}

func getCurrentUser(wr *srv.WrapperRequest) error {

	//var nu nusers.NUser
	var nu appusers.AppUser

	nus := users.NewNUserBuffer()
	u := wr.U
	if u == nil {
		return errors.New("No user session founded")
	}

	q := data.NewConn(*wr, "users")
	q.AddFilter("Mail =", u.Email)
	err := q.GetMany(&nus)

	if len(nus) <= 0 {
		// If the session users not in the datastore we use de admin
		// users of the app
		if wr.IsAdminRequest() {
			//nu = nusers.New(u.Email, "Administrador", nusers.ROLE_ADMIN)
			nu = GetDefaultUser(u.Email)
		} else {
			return errors.New("No user id found")
		}
	} else {
		nu = nus[0]
	}

	wr.NU = nu
	return err
}

func deleteUser(wr srv.WrapperRequest, nu *NUser) error {

	q := data.NewConn(wr, "users")
	err := q.Delete(nu)
	err = deleteUserTags(wr, nu, err)

	if err != nil {
		return fmt.Errorf("deleteuser: %v", err)
	}
	return nil
}

// Add the tags of the question to the database
func addQuestTags(wr srv.WrapperRequest, q *Question) error {
	for _, tag := range q.Tags {
		qry := data.NewConn(wr, "questions-tags")
		qt := &QuestionTag{QuestId: q.Id, Tag: tag}
		err := qry.Put(qt)
		if err != nil {
			return err
		}
	}
	return nil
}

func getExerciseById(wr srv.WrapperRequest, ExerciseId int64) (*Exercise, error) {
	ex := new(Exercise)
	qry := data.NewConn(wr, "tests-exercises")
	ex.Id = ExerciseId

	err := qry.Get(ex)
	if err != nil {
		return nil, fmt.Errorf("getexercisebyid: %v", err)
	}

	return ex, nil
}

func deleteTest(wr srv.WrapperRequest, t *Test) error {

	q := data.NewConn(wr, "tests")
	err := q.Delete(t)
	err = deleteExercises(wr, t, err)
	err = deleteUsersAllowed(wr, t, err)
	err = deleteTestTags(wr, t, err)

	if err != nil {
		return fmt.Errorf("deletetest: %v", err)
	}
	return nil
}

// Add the tags in the test to the database
func addTestTags(wr srv.WrapperRequest, t *Test, err error) error {
	if err != nil {
		return err
	}
	q := data.NewConn(wr, "tests-tags")
	for _, tag := range t.Tags {
		tt := &TestTag{TestId: t.Id, Tag: tag}
		err := q.Put(tt)
		if err != nil {
			return err
		}
	}
	return nil
}

// Add the exercises in the test to the database
func addExercises(wr srv.WrapperRequest, t *Test, err error) error {
	if err != nil {
		return err
	}
	q := data.NewConn(wr, "tests-exercises")
	for _, ex := range t.Exercises {
		ex.TestId = t.Id
		err := q.Put(ex)
		if err != nil {
			return err
		}
	}
	return nil
}

func addUserTags(wr srv.WrapperRequest, nu *NUser, err error) error {
	if err != nil {
		return err
	}
	q := data.NewConn(wr, "users-tags")
	for _, tag := range nu.Tags {
		ut := &UserTag{UserId: nu.Id, Tag: tag}
		err := q.Put(ut)
		if err != nil {
			return fmt.Errorf("addusertags: %v", err)
		}
	}
	return nil
}

// Add the users allowed in the test to the database
func addUsersAllowed(wr srv.WrapperRequest, t *Test, err error) error {
	if err != nil {
		return err
	}
	q := data.NewConn(wr, "tests-users")
	for _, uid := range t.UList {
		tu := &TestUser{Id: 0, TestId: t.Id, UserId: uid}
		err := q.Put(tu)
		if err != nil {
			return err
		}
	}
	return nil
}

func getUserById(wr srv.WrapperRequest, id int64) (*NUser, error) {
	nu := new(NUser)
	nu.Id = id
	q := data.NewConn(wr, "users")
	err := q.Get(nu)
	if err != nil {
		return nu, fmt.Errorf("getuserbyid: %v: %s", err, ERR_USERNOTFOUND)
	}
	nu.Tags, err = getUserTags(wr, nu)

	if err != nil {
		return nu, fmt.Errorf("getuserbyid: %v", err)
	}
	return nu, nil
}

// Return the users allowed for this tests
func getUsersAllowed(wr srv.WrapperRequest, t *Test) ([]*users.NUser, error) {
	nus := make([]*users.NUser, 0)
	qu := data.NewConn(wr, "users")
	for i := range t.UList {
		us := new(users.NUser)
		us.SetID(t.UList[i])
		err := qu.Get(us)
		if err != nil {
			continue
		}
		nus = append(nus, us)
	}

	return nus, nil
}

func GetAnswersById(wr srv.WrapperRequest, id int64) (*Answer, error) {
	a := NewAnswer(-1, -1)

	qry := data.NewConn(wr, "answers")
	a.Id = id

	err := qry.Get(a)
	if err != nil {
		return a, errors.New(ERR_ANSWERNOTFOUND)
	}

	getAnswerBody(wr, a)

	return a, nil
}

func getUserByMail(wr srv.WrapperRequest, email string) (*NUser, error) {
	nus := NewNUserBuffer()
	nu := new(NUser)

	q := data.NewConn(wr, "users")
	q.AddFilter("Mail =", email)
	q.GetMany(&nus)
	if len(nus) == 0 {
		return nu, fmt.Errorf("%s", ERR_USERNOTFOUND)
	}
	nu = nus[0]
	nu.Tags, _ = getUserTags(wr, nu)

	return nu, nil
}

func putAnswerBody(wr srv.WrapperRequest, a *Answer) error {

	bodyTable := bodiesTable[a.BodyType]
	q := data.NewConn(wr, bodyTable)
	var err error

	switch a.Body.GetType() {
	case TYPE_TESTSINGLE:
		tbody := a.Body.(*TestSingleBody)
		q.Put(tbody)
		a.BodyId = tbody.ID()
	default:
		err = errors.New(ERR_ANSWERWITHOUTBODY)
	}
	return err
}

func getAnswerBody(wr srv.WrapperRequest, a *Answer) error {

	bodyTable := bodiesTable[a.BodyType]

	q := data.NewConn(wr, bodyTable)
	var err error
	switch a.BodyType {
	case TYPE_TESTSINGLE:
		body := NewTestSingleAnswer(-1)
		body.Solution = 0 // must be set to zero to unmarshall propertly in cache
		body.Id = a.BodyId
		err = q.Get(body)
		a.Body = body
	}
	return err
}

// Delete the tags of the test
func deleteTestTags(wr srv.WrapperRequest, t *Test, err error) error {
	if err != nil {
		return err
	}
	testsTags := NewTestTagBuffer()
	q := data.NewConn(wr, "tests-tags")
	q.AddFilter("TestId =", t.Id)
	q.GetMany(&testsTags)

	for _, ttag := range testsTags {
		err := q.Delete(ttag)
		if err != nil {
			return err
		}
	}
	return nil
}

// Return the test with id
func getTestById(wr srv.WrapperRequest, id int64) (*Test, error) {
	t := NewTest()

	t.Id = id
	qry := data.NewConn(wr, "tests")
	err := qry.Get(t)

	err = loadTestTags(wr, t, err)
	err = loadExercises(wr, t, err)
	err = loadAllowed(wr, t, err)

	if err != nil {
		return nil, fmt.Errorf("gettestbyid: %v", err)
	}

	return t, nil
}

// Return all tests from authorId
func getTestsByAuthor(wr srv.WrapperRequest, authorId int64) (TestBuffer, error) {
	ts := NewTestBuffer()

	qry := data.NewConn(wr, "tests")
	qry.AddFilter("AuthorId =", authorId)
	err := qry.GetMany(&ts)

	for i := range ts {
		loadTestTags(wr, ts[i], err)
	}

	if err != nil {
		return ts, fmt.Errorf("gettestbyauthor: %v", err)
	}

	return ts, nil
}