// Create creates a new FormSubmission based on the payload of replies and the
// formID that is being submitted.
// 200 Success, 400 Bad Request, 404 Not Found, 500 Internal
func (formSubmissionHandle) Create(c *web.Context) error {
var payload struct {
Recaptcha string `json:"recaptcha"`
Answers []submission.AnswerInput `json:"replies"`
}
if err := json.NewDecoder(c.Request.Body).Decode(&payload); err != nil {
return err
}
formID := c.Params["form_id"]
// We should check to see if the form has a recaptcha property.
f, err := form.Retrieve(c.SessionID, c.Ctx["DB"].(*db.DB), formID)
if err != nil {
return err
}
// If the recaptcha is enabled on the form, then we should check that the
// response contains the data we need and if it's valid.
if enabled, ok := f.Settings["recaptcha"].(bool); ok && enabled {
if len(payload.Recaptcha) <= 0 {
log.Error(c.SessionID, "FormSubmission : Create", ErrInvalidCaptcha, "Payload empty")
return ErrInvalidCaptcha
}
// Check to see if Recaptcha has been enabled on the server.
if recaptchaSecret, ok := c.Web.Ctx["recaptcha"].(string); ok {
// Communicate with the Google Recaptcha Web Service to validate the
// request.
if err := ValidateReacaptchaResponse(c, recaptchaSecret, payload.Recaptcha); err != nil {
log.Error(c.SessionID, "FormSubmission : Create", err, "Recaptcha validation failed")
return ErrInvalidCaptcha
}
} else {
log.Dev(c.SessionID, "FormSubmission : Create", "Recaptcha disabled, will not check")
}
}
s, err := ask.CreateSubmission(c.SessionID, c.Ctx["DB"].(*db.DB), formID, payload.Answers)
if err != nil {
return err
}
c.Respond(s, http.StatusOK)
return nil
}
func Test_CreateDeleteSubmission(t *testing.T) {
db := setup(t)
defer teardown(t, db)
// CreateSubmission(context interface{}, db *db.DB, formID string, answers []submission.AnswerInput) (*submission.Submission, error)
t.Log("Given the need to add a submission.")
{
//----------------------------------------------------------------------
// Get the form fixture.
fms, err := formfix.Get("ask_form")
if err != nil {
t.Fatalf("%s\tShould be able to get the form fixture : %v", tests.Failed, err)
}
t.Logf("%s\tShould be able to get the form fixture", tests.Success)
if err := formfix.Add(tests.Context, db, fms); err != nil {
t.Fatalf("%s\tShould be able to add the form fixture : %v", tests.Failed, err)
}
t.Logf("%s\tShould be able to add the form fixture", tests.Success)
fm := fms[0]
t.Log("\tWhen starting from an empty submission collection")
{
var answers []submission.AnswerInput
// Create the answers based on the form layout.
answer := time.Now().Unix()
for _, step := range fm.Steps {
for _, widget := range step.Widgets {
answers = append(answers, submission.AnswerInput{
WidgetID: widget.ID,
Answer: answer,
})
}
}
// Create the submission.
sub, err := ask.CreateSubmission(tests.Context, db, fm.ID.Hex(), answers)
if err != nil {
t.Fatalf("\t%s\tShould be able to create a submission : %v", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to create a submission.", tests.Success)
// Ensure that the answers match.
matchSubmissionsAndAnswers(t, sub, fm, answers)
// Get the submission from the database.
rsub, err := submission.Retrieve(tests.Context, db, sub.ID.Hex())
if err != nil {
t.Fatalf("\t%s\tShould be able to retrieve a created submission : %v", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to retrieve a created submission.", tests.Success)
// Ensure that their answers match.
matchSubmissionsAndAnswers(t, rsub, fm, answers)
// Ensure that the form's stats were updated.
rfm, err := form.Retrieve(tests.Context, db, fm.ID.Hex())
if err != nil {
t.Fatalf("\t%s\tShould be able to retrieve a form : %v", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to retrieve a form.", tests.Success)
if rfm.Stats.Responses != 1 {
t.Fatalf("\t%s\tShould be able to update the stats on a form : Expected %d, got %d", tests.Failed, 1, rfm.Stats.Responses)
}
t.Logf("\t%s\tShould be able to update the stats on a form", tests.Success)
// Delete the submission.
if err := ask.DeleteSubmission(tests.Context, db, sub.ID.Hex(), fm.ID.Hex()); err != nil {
t.Fatalf("\t%s\tShould be able to delete a submission : %v", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to delete a submission.", tests.Success)
// Ensure that it is deleted.
if _, err := submission.Retrieve(tests.Context, db, sub.ID.Hex()); err == nil {
t.Fatalf("\t%s\tShould return not found when trying to retrieve a deleted submission : No error", tests.Failed)
} else if err != mgo.ErrNotFound {
t.Fatalf("\t%s\tShould return not found when trying to retrieve a deleted submission : %v", tests.Failed, err)
}
t.Logf("\t%s\tShould return not found when trying to retrieve a deleted submission.", tests.Success)
// Ensure that the form's stats were updated.
rfm, err = form.Retrieve(tests.Context, db, fm.ID.Hex())
if err != nil {
t.Fatalf("\t%s\tShould be able to retrieve a form : %v", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to retrieve a form.", tests.Success)
if rfm.Stats.Responses != 0 {
t.Fatalf("\t%s\tShould be able to update the stats on a form : Expected %d, got %d", tests.Failed, 0, rfm.Stats.Responses)
}
t.Logf("\t%s\tShould be able to update the stats on a form", tests.Success)
}
}
}
