webform

main.go (7685B)

---

 package main
 
 import (
 	"bytes"
 	"encoding/json"
 	"fmt"
 	"log"
 	"net/http"
 	"os"
 	"os/signal"
 	"strconv"
 )
 
 // An Entry is either a Part or a Question.
 type Entry interface {
 	isPart() bool
 	makeAns(map[string][]string) ([]Ans, error)
 	HTML() string
 }
 
 type Part struct {
 	Q   string
 	Ent []Entry
 }
 
 func (*Part) isPart() bool { return true }
 func (p *Part) HTML() string {
 	html := fmt.Sprintf("<fieldset>\n<legend>%s</legend>\n", p.Q)
 	for _, e := range p.Ent {
 		html += e.HTML()
 	}
 	return html + "</fieldset>\n"
 }
 
 func (p *Part) makeAns(ans map[string][]string) ([]Ans, error) {
 	var a []Ans
 	for _, e := range p.Ent {
 		aa, err := e.makeAns(ans)
 		if err != nil {
 			return nil, err
 		}
 		a = append(a, aa...)
 	}
 	return a, nil
 }
 
 type Question struct {
 	Q         string
 	Qid       string
 	T         string // answer type: "text", "radio", "check"
 	RadioList []string
 	CheckList []string
 }
 
 func (*Question) isPart() bool { return false }
 func (q *Question) HTML() string {
 	switch q.T {
 	case "check":
 		html := fmt.Sprintf("<fieldset>\n<legend>%s</legend>\n", q.Q)
 		for n, a := range q.CheckList {
 			id := q.Qid + strconv.Itoa(n)
 			html += fmt.Sprintf("<input type=\"checkbox\" name=\"%s\" id=\"%s\" value=\"%d\">\n"+
 				"<label for=\"%s\">%s</label>\n", q.Qid, id, n, id, a)
 			if a == "その他" {
 				html += fmt.Sprintf("<input type=\"text\" name=\"%s_other\" id=\"%s_other\">\n", q.Qid, q.Qid)
 			}
 		}
 		html += "</fieldset>\n"
 		return html
 	case "radio":
 		html := fmt.Sprintf("<fieldset>\n<legend>%s</legend>\n", q.Q)
 		for n, a := range q.RadioList {
 			id := q.Qid + strconv.Itoa(n)
 			html += fmt.Sprintf("<input type=\"radio\" name=\"%s\" id=\"%s\" value=\"%d\">\n"+
 				"<label for=\"%s\">%s</label>\n", q.Qid, id, n, id, a)
 			if a == "その他" {
 				html += fmt.Sprintf("<input type=\"text\" name=\"%s_other\" id=\"%s_other\">\n", q.Qid, q.Qid)
 			}
 		}
 		html += "</fieldset>\n"
 		return html
 	case "text":
 		return fmt.Sprintf("<fieldset>\n<legend>%s</legend>\n"+
 			"<textarea name=\"%s\" id=\"%s\"></textarea></fieldset>",
 			q.Q, q.Qid, q.Qid)
 	default:
 		panic(fmt.Sprintf("unknown question type: %s\n", q.T))
 	}
 }
 
 func (q *Question) makeAns(ans map[string][]string) ([]Ans, error) {
 	a, ok := ans[q.Qid]
 	if !ok {
 		a = []string{""}
 	}
 	switch q.T {
 	case "check":
 		l := make([]string, 0)
 		for _, i := range a {
 			if i == "" { // empty answer for "その他"
 				continue
 			}
 			n, err := strconv.Atoi(i)
 			if err != nil {
 				return nil, fmt.Errorf("invalid answer %q for %s.", i, q.Qid)
 			}
 			if n < 0 || len(q.CheckList) <= n {
 				return nil, fmt.Errorf("invalid answer %q for %s.", n, q.Qid)
 			}
 			if q.CheckList[n] == "その他" {
 				var other string
 				if l, ok := ans[q.Qid+"_other"]; ok {
 					if len(l) > 0 {
 						other = l[0]
 					}
 				}
 				l = append(l, "その他:"+other)
 			} else {
 				l = append(l, q.CheckList[n])
 			}
 		}
 		return []Ans{CheckAns{Qid: q.Qid, Type: q.T, Ans: l}}, nil
 	case "radio":
 		if len(a) != 1 {
 			return nil, fmt.Errorf("invalid length %d for %s.\n", len(a), q.Qid)
 		}
 		if a[0] == "" { // empty answer
 			return []Ans{RadioAns{Qid: q.Qid, Type: q.T, Ans: ""}}, nil
 		}
 		i, err := strconv.Atoi(a[0])
 		if err != nil {
 			return nil, fmt.Errorf("invalid answer %s for %s.", a[0], q.Qid)
 		}
 		if i < 0 || len(q.RadioList) <= i {
 			return nil, fmt.Errorf("invalid answer %s for %s.", a[0], q.Qid)
 		}
 		if q.RadioList[i] == "その他" {
 			var other string
 			if l, ok := ans[q.Qid+"_other"]; ok {
 				if len(l) > 0 {
 					other = l[0]
 				}
 			}
 			return []Ans{RadioAns{Qid: q.Qid, Type: q.T, Ans: "その他:" + other}}, nil
 		}
 		return []Ans{RadioAns{Qid: q.Qid, Type: q.T, Ans: q.RadioList[i]}}, nil
 	case "text":
 		if len(a) != 1 {
 			return nil, fmt.Errorf("invalid length %d for %s.\n", len(a), q.Qid)
 		}
 		return []Ans{TextAns{Qid: q.Qid, Type: q.T, Ans: a[0]}}, nil
 	default:
 		panic(fmt.Errorf("unknown question type: %v", q.T))
 	}
 }
 
 type Ans interface {
 	qid() string
 }
 
 type TextAns struct {
 	Qid  string
 	Type string
 	Ans  string
 }
 func (a TextAns) qid() string { return a.Qid }
 
 type RadioAns struct {
 	Qid  string
 	Type string
 	Ans  string
 }
 func (a RadioAns) qid() string { return a.Qid }
 
 type CheckAns struct {
 	Qid  string
 	Type string
 	Ans  []string
 }
 func (a CheckAns) qid() string { return a.Qid }
 
 var Q Part = Part{
 	Q: "きのかわ弦楽合奏団第7回定期演奏会 アンケート",
 	Ent: []Entry{
 		&Question{
 			Q:   "この演奏会をどのようにしてお知りになりましたか。",
 			Qid: "information",
 			T:   "check",
 			CheckList: []string{
 				"ポスター", "友人・知人", "その他",
 			},
 		},
 		&Part{
 			Q: "あなたについて教えてください",
 			Ent: []Entry{
 				&Question{
 					Q:   "年齢",
 					Qid: "age",
 					T:   "radio",
 					RadioList: []string{
 						"10歳未満", "10代", "20代",
 					},
 				},
 				&Question{
 					Q:   "性別",
 					Qid: "sex",
 					T:   "radio",
 					RadioList: []string{
 						"男性", "女性",
 					},
 				},
 				&Question{
 					Q:   "住所",
 					Qid: "address",
 					T:   "radio",
 					RadioList: []string{
 						"和歌山市", "海南市", "その他",
 					},
 				},
 			},
 		},
 		&Part{
 			Q: "演奏の感想",
 			Ent: []Entry{
 				&Question{
 					Q:   "1曲目",
 					Qid: "feelings1",
 					T:   "text",
 				},
 				&Question{
 					Q:   "2曲目",
 					Qid: "feelings2",
 					T:   "text",
 				},
 			},
 		},
 	},
 }
 
 var bufc = make(chan []byte)
 
 func main() {
 	f, err := os.Create("a.json")
 	if err != nil {
 		log.Fatalf("create file: %v\n", err)
 	}
 	intc := make(chan os.Signal, 3)
 	done := make(chan struct{})
 	listenErrChan := make(chan struct{})
 	signal.Notify(intc, os.Interrupt)
 	go writer(intc, listenErrChan, done, bufc, f)
 	go func() {
 		http.HandleFunc("/", handler)
 		err := http.ListenAndServe("localhost:8000", nil)
 		log.Printf("listenAndServe: %v\n", err)
 		close(listenErrChan)
 	}()
 	<-done
 	os.Exit(0)
 }
 
 func handler(w http.ResponseWriter, r *http.Request) {
 	if r.Method == "POST" {
 		if err := r.ParseForm(); err != nil {
 			fmt.Fprintf(w, "server error...\n")
 			log.Printf("error: parse form: %v\n", err)
 			return
 		}
 		fmt.Fprint(w, exitPage)
 		log.Printf("ans: %q\n", r.PostForm)
 		a, err := Q.makeAns(r.PostForm)
 		if err != nil {
 			log.Printf("makeAns: %v\n", err)
 			return
 		}
 		A, err := json.MarshalIndent(a, "", "  ")
 		if err != nil {
 			log.Printf("marchalIndent: %v\n", err)
 			return
 		}
 		bufc <- A
 	} else {
 		fmt.Fprint(w, header+Q.HTML()+footer)
 	}
 }
 
 // Writer reads json data from c and writes them to f.
 // This function closes f after c is closed.
 func writer(intc <-chan os.Signal, listenErrChan <-chan struct{},
 	done chan<- struct{}, c <-chan []byte, f *os.File) {
 	defer close(done)
 	const bufSize = 4096
 	var buf bytes.Buffer
 L:
 	for {
 		select {
 		case q := <-c:
 			if err := json.Compact(&buf, q); err != nil {
 				log.Printf("error: compact: %v\n", err)
 				continue
 			}
 			if buf.Len() >= bufSize {
 				if _, err := f.Write(buf.Next(bufSize)); err != nil {
 					log.Printf("error: write to file: %v\n", err)
 					continue
 				}
 			}
 		case <-intc:
 			break L
 		case <-listenErrChan:
 			break L
 		}
 	}
 	if _, err := f.Write(buf.Bytes()); err != nil {
 		log.Printf("error: write to file: %v\n", err)
 	}
 	if err := f.Close(); err != nil {
 		log.Printf("close file: %v\n", err)
 	}
 }
 
 const header = `<html>
 <head>
 </head>
 <body>
 <form method="POST" onSubmit="return window.confirm('送信してもよろしいですか？')">
 `
 
 const footer = `<input type="submit" value="送信">
 </form>
 </body>
 </html>
 `
 
 const exitPage = `
 <html>
 送信完了しました。ご回答ありがとうございます。
 </html>
 `