Beispiel #1
0
func CreateBank(rc *impl.RCM_Cmd) (interface{}, error) {
	log.D("rc CreateBank")
	var uid int64
	var uname string
	var bName string
	err := rc.ValidF(`
		uid,R|I,R:0;
		uname,R|S,L:0;
		bName,R|S,L:0;
		`, &uid, &uname, &bName)
	if err != nil {
		log.E("CreateBank arg err:%v", err)
		return 0, err
	}
	b := &bank.BANK{}
	b.UId = &uid
	b.Name = &bName
	b.UName = &uname
	b.Status = bank.GetString("N")
	b.Public = bank.GetInt(1)

	if n, err := b.C(nil); err != nil {
		log.E("CreateBank err:%v", err)
		return 0, err
	} else {
		return n, nil
	}
}
Beispiel #2
0
Datei: db.go Projekt: dgdn/goutil
func migrateAddColumn(db *sql.DB, table, column, typ, defaul, comment string) error {
	log.I("begin to add column[%s] to the table[%s]...", column, table)

	exists, err := tableColumnExist(db, table, column)
	if err != nil {
		log.E("get table column exists fail %v", err.Error())
		return err
	}
	if exists == false {
		_, err := db.Exec(fmt.Sprintf(`ALTER TABLE %s ADD %s %s default %s comment '%s';`, table, column, typ, defaul, comment))
		if err != nil {
			log.E("add column[%s] fail %v", column, err.Error())
			return err
		}
		log.I("have added column[%s] to the table[%s]", column, table)

		//set the old data of this field to default value
		_, err = db.Exec(fmt.Sprintf(`update %s set %s = ?`, table, column), "")
		return err

	} else {
		log.I("column[%s] already exists no need to add", column)
	}
	return nil
}
Beispiel #3
0
func LogErr(err error, reason string) error {
	_, file, line, _ := runtime.Caller(1)
	if err != nil {
		log.E("%v:%v %v:%v", file, line, reason, err.Error())

	} else {
		log.E(reason)
	}
	return errors.New(reason)
}
Beispiel #4
0
func UpdateBankPaper(rc *impl.RCM_Cmd) (interface{}, error) {
	var uid, bankId int64
	var paperIds, p2bIds, ext string
	err := rc.ValidF(`
		uid,R|I,R:0;
		bankId,R|I,R:0;
		paperIds,R|S,L:0;
		p2bIds,O|S,L:0;
		ext,O|S,L:0;
		`, &uid, &bankId, &paperIds, &p2bIds, &ext)
	if err != nil {
		log.E("UpdateBankPaper arg err:%v", err)
		return 0, err
	}
	extParse := []P2b_Paper{}
	json.Unmarshal([]byte(ext), &extParse)
	rs := []P2b_Paper{}
	paperIdsArr := []int64{}
	err = json.Unmarshal([]byte(paperIds), &paperIdsArr)
	if err != nil {
		return nil, err
	}

	if p2bIds == "" {
		p2bIds = "0"
	}
	sql_ := "delete from ebs_p2b where bank_id=? and tid not in (" + p2bIds + ")"
	var conn *sql.DB = dbMgr.DbConn()
	tx, err := conn.Begin()
	if err != nil {
		return nil, err
	}

	//同步练习
	for _, v := range extParse {
		fmt.Println(tx.Exec("insert into ebs_p2b (tid,bank_id,paper_id,status,add1) values (?,?,?,'N','P')", v.P2bId, bankId, v.PId))
	}
	//同步练习

	if ext != "" {
		sql_ += " and add1='P'"
	} else {
		sql_ += " and (add1!='P' or add1 is null)"
	}
	log.D("%s", sql_)
	if _, err := tx.Exec(sql_, bankId); err != nil {
		tx.Rollback()
		return nil, err
	}
	for _, v := range paperIdsArr {
		if res, err := tx.Exec("insert into ebs_p2b (bank_id,paper_id,status) values (?,?,'N')", bankId, v); err != nil {
			tx.Rollback()
			return nil, err
		} else {
			p2bId, _ := res.LastInsertId()
			rs = append(rs, P2b_Paper{p2bId, v})
		}
	}
	return rs, tx.Commit()
}
Beispiel #5
0
func LogNErr(err error) error {
	_, file, line, _ := runtime.Caller(1)
	if err != nil {
		log.E("%v:%v %v", file, line, err.Error())

	}
	return err
}
Beispiel #6
0
func SimpleHandle(fn func(*routing.HTTPSession) (interface{}, error)) routing.HandleFunc {
	return func(hs *routing.HTTPSession) routing.HResult {
		rst, err := fn(hs)
		if err != nil {
			log.E("err:%v", err.Error())
			return hs.MsgResE(1, err.Error())
		}
		return _common.MsgRes(hs, rst)
	}
}
Beispiel #7
0
func ChkIdx(C func(string) *tmgo.Collection, indexes map[string]map[string]tmgo.Index) error {
	for cname, index := range indexes {
		tc := C(cname)
		if _, err := tc.Count(); err != nil {
			return err
		}
		log.D("ChkIdx checking index on collection(%v)...", cname)
		idx_l, err := tc.Indexes()
		if err != nil {
			if qerr, ok := err.(*tmgo.QueryError); !ok || qerr.Code != 26 {
				err = util.Err("ChkIdx list indexes fail with error(%v) on collection(%v)", err, cname)
				log.E("%v", err)
				return err
			}
			log.D("ChkIdx the collection(%v) is not found, it will create empty one...", cname)
			err = tc.Create(&tmgo.CollectionInfo{})
			if err != nil {
				err = util.Err("ChkIdx create collection(%v) fail with error(%v)", cname, err)
				log.E("%v", err)
				return err
			}
		}
		exists := map[string]tmgo.Index{}
		for _, idx := range idx_l {
			exists[idx.Name] = idx
		}
		for iname, idx := range index {
			if _, ok := exists[iname]; ok {
				continue
			}
			idx.Name = iname
			err = C(cname).EnsureIndex(idx)
			if err != nil {
				err = util.Err("ChkIdx ensure index by keys(%v),name(%v) fail with error(%v) on collection(%v)", idx.Key, idx.Name, err, cname)
				log.E("%v", err)
				return err
			}
			log.D("ChkIdx ensure index(%v) on collection(%v) success", iname, cname)
		}
	}
	return nil
}
Beispiel #8
0
func GetBankItemCnt(rc *impl.RCM_Cmd) (interface{}, error) {
	var bankIds string
	err := rc.ValidF(`
		bankIds,R|S,L:0;
		`, &bankIds)
	if err != nil {
		log.E("GetBankItemCnt arg err:%v", err)
		return 0, err
	}
	return bank.GetBankQcAndPc(bankIds)
}
Beispiel #9
0
func AttendBankInfo(rc *impl.RCM_Cmd) (interface{}, error) {
	var bankIds string
	err := rc.ValidF(`
		bankIds,R|S,L:0;
		`, &bankIds)
	if err != nil {
		log.E("AttendBankInfo arg err:%v", err)
		return 0, err
	}
	return bank.AttendBankInfo(bankIds)
}
Beispiel #10
0
func ListBankPaper(rc *impl.RCM_Cmd) (interface{}, error) {
	var uid, bankId int64
	err := rc.ValidF(`
		uid,O|I,R:0;
		bankId,R|I,R:0;
		`, &uid, &bankId)
	if err != nil {
		log.E("ListBankPaper arg err:%v", err)
		return 0, err
	}
	return bank.FuncListBankPaper(uid, bankId)
}
Beispiel #11
0
func GetBankPaperScore(rc *impl.RCM_Cmd) (interface{}, error) {
	var bankId, paperId int64
	err := rc.ValidF(`
		bankId,R|I,R:0;
		paperId,R|I,R:0;
		`, &bankId, &paperId)
	if err != nil {
		log.E("GetBankPaperScore arg err:%v", err)
		return 0, err
	}
	return bank.GetBankPaperScore(bankId, paperId)
}
Beispiel #12
0
Datei: dbm.go Projekt: Centny/dbm
func (m *MDb) TPing() {
	var showlog = ShowLog && (util.Now()-m.log_time > ShowLogTime)
	if showlog {
		m.log_time = util.Now()
		log.D("MDb start ping to %v ", m.String())
	}
	err := m.H.Ping(m.DB)
	if err == nil || err.Error() != "Closed explicitly" {
		if err == nil {
			if showlog {
				log.D("MDb ping to %v success", m.String())
			}
		} else {
			log.E("MDb ping to %v error->%v, will mark to not active", m.String(), err)
		}
		m.lck.Lock()
		m.Active = err == nil
		m.ping = 0
		m.lck.Unlock()
		return
	}
	// m.H.Close(m.DB)
	//do reconnect
	log.E("MDb ping to %v error->%v, will try reconnect", m.String(), err)
	for {
		db, err := m.H.Create()
		if err == nil {
			log.D("MDb connect to %v success, will mark to active", m.String())
			m.lck.Lock()
			m.DB = db
			m.ping = 0
			m.Active = true
			m.lck.Unlock()
			break
		} else {
			log.E("MDb connect to %v error->%v, will retry after 5s", m.String(), err)
			time.Sleep(5 * time.Second)
		}
	}
}
Beispiel #13
0
func GetUsrPaperRecord(rc *impl.RCM_Cmd) (interface{}, error) {
	var p2bIds string
	var uid int64
	err := rc.ValidF(`
		p2bIds,R|S,L:0;
		userId,R|I,R:0;
		`, &p2bIds, &uid)
	if err != nil {
		log.E("GetUsrPaperRecord arg err:%v", err)
		return 0, err
	}
	return bank.GetUsrPaperRecord(uid, p2bIds)
}
Beispiel #14
0
func SimpleListHandle(fn func(*routing.HTTPSession) (interface{}, int64, error)) routing.HandleFunc {
	return func(hs *routing.HTTPSession) routing.HResult {
		list, total, err := fn(hs)
		if err != nil {
			log.E("err:%v", err.Error())
			return hs.MsgResE(1, err.Error())
		}
		return _common.MsgRes(hs, map[string]interface{}{
			"total": total,
			"list":  list,
		})
	}
}
Beispiel #15
0
func MakeDataAccessFilter(f func(*routing.HTTPSession) (bool, error)) routing.HandleFunc {
	return func(hs *routing.HTTPSession) routing.HResult {
		pass, err := f(hs)
		if err != nil {
			log.E("检验当前用户数据权限失败-%v", err.Error())
			return _common.MsgResE(hs, 1, "检验当前用户数据权限失败")
		}
		if !pass {
			return _common.MsgResE(hs, 1, "当前用户没权限访问该数据")
		}
		return routing.HRES_CONTINUE
	}
}
Beispiel #16
0
func wrapRedirectHandle(fn func(*routing.HTTPSession) []reflect.Value) routing.HandleFunc {
	return func(hs *routing.HTTPSession) routing.HResult {
		outs := fn(hs)
		if len(outs) != 2 {
			panic("redirect handle api return count should be 2")
		}
		if err, ok := outs[1].Interface().(error); ok && err != nil {
			log.E("err:%v", err.Error())
			return hs.MsgResE(1, err.Error())
		}
		hs.Redirect(outs[0].Interface().(string))
		return _common.MsgRes(hs, outs[0].Interface().(string))
	}
}
Beispiel #17
0
func JsonUnmarshalBody(hs *routing.HTTPSession, v interface{}) error {
	buf, _ := ioutil.ReadAll(hs.R.Body)
	rdr1 := myReader{bytes.NewBuffer(buf)}
	rdr2 := myReader{bytes.NewBuffer(buf)}

	decoder := json.NewDecoder(rdr1)
	err := decoder.Decode(v)
	if err != nil {
		log.E("parse request body fail:%v", err.Error())
		return fmt.Errorf("请求参数格式错误:%v", err)
	}
	hs.R.Body = rdr2
	return nil
}
Beispiel #18
0
func SaveAnswer(hs *routing.HTTPSession) routing.HResult {
	var aId int64
	var a string
	err := hs.ValidCheckVal(`
		aId,R|I,R:0;
		a,R|S,L:0;
		`, &aId, &a)
	if err != nil {
		log.E("SaveAnswer arg error:%v", err)
		return hs.MsgResE(1, fmt.Sprintf("%s:%s", common_.ARG_ERROR, err.Error()))
	}
	aParse := []ANSWER2{}
	if err := json.Unmarshal([]byte(a), &aParse); err != nil {
		log.E("%v", err)
		return hs.MsgResE(1, fmt.Sprintf("%s:作答内容格式错误,%s", common_.ARG_ERROR, err.Error()))
	}
	sql_ := `update ebs_answer set content=? where tid=?`
	conn := dbMgr.DbConn()
	if _, err := conn.Exec(sql_, a, aId); err != nil {
		log.E("SaveAnswer db error:%v,sql:%s,args:%v", err, sql_, a)
		return hs.MsgResE(2, fmt.Sprintf("%s:%s", common_.DB_ERROR, err.Error()))
	}
	return hs.MsgRes("success")
}
Beispiel #19
0
func EditBank(rc *impl.RCM_Cmd) (interface{}, error) {
	var bName string
	var id int64
	err := rc.ValidF(`
		bName,R|S,L:0;
		id,R|I,R:0;
		`, &bName, &id)
	if err != nil {
		log.E("EditBank arg err:%v", err)
		return 0, err
	}
	b := &bank.BANK{}
	b.Tid = &id
	b.Name = &bName
	return nil, b.U(nil)
}
Beispiel #20
0
func GetAnswerRecord(hs *routing.HTTPSession) routing.HResult {
	var aId int64
	err := hs.ValidCheckVal(`
		aId,R|I,R:0;
		`, &aId)
	if err != nil {
		log.E("GetAnswerRecord arg error:%v", err)
		return hs.MsgResE(1, fmt.Sprintf("%s:%s", common_.ARG_ERROR, err.Error()))
	}
	conn := dbMgr.DbConn()
	var content sql.NullString
	if err := conn.QueryRow("select content from ebs_answer where tid=?", aId).Scan(&content); err != nil {
		if err != sql.ErrNoRows {
			return hs.MsgResE(2, err.Error())
		}
	}
	return hs.MsgRes(content.String)
}
Beispiel #21
0
func FuncListBankQuestion(uid, bankId int64) ([]QUESTION, error) {
	rs := []QUESTION{}
	usrFilter := ""
	args := []interface{}{bankId, bankId}
	if uid != 0 {
		usrFilter = " and b.uid=?"
		args = append(args, uid)
	}
	conn := dbMgr.DbConn()
	sql_ := `select q.TID, q.NAME, q.BANK_ID, q.PID, q.TAG, q.DESCRIPTION, q.DURATION, q.SCORE, q.Q_ANALYZE, q.TYPE,q.Q_OPTION, q.ANSWER, q.UID, q.UNAME,q2b.score,q2b.ext,q2b.tid,q2b.seq
	from ebs_question q join ebs_q2b q2b on q2b.bank_id=? and q2b.q_id=q.tid join ebs_bank b on b.tid=?` + usrFilter + ` order by q2b.seq asc`
	log.D("sql:%s", sql_)
	if rows, err := conn.Query(sql_, args...); err != nil {
		return rs, err
	} else {
		columns := []string{"TID", "NAME", "BANK_ID", "PID", "TAG", "DESCRIPTION", "DURATION", "SCORE", "Q_ANALYZE", "TYPE",
			"Q_OPTION", "ANSWER", "UID", "UNAME", "SCORE"}
		for rows.Next() {
			vals := []interface{}{}
			b := QUESTION{}
			for _, v := range columns {
				(&b).GetFieldByColumn(v, &vals)
			}
			var ext sql.NullString
			var q2bId int64
			var q2bSeq sql.NullInt64
			vals = append(vals, &ext, &q2bId, &q2bSeq)
			if err := rows.Scan(vals...); err != nil {
				log.E("scan err:%v", err)
			}
			b.Q2bId = q2bId
			b.Q2bSeq = q2bSeq.Int64
			if ext.String != "" {
				extParse := EXT{}
				json.Unmarshal([]byte(ext.String), &extParse)
				b.SCORE = &extParse.Score
				b.DURATION = &extParse.Duration
				b.Ext = extParse
			}
			rs = append(rs, b)
		}
	}
	return rs, nil
}
Beispiel #22
0
func editQ2b(parse []EXT, tArr []int64, p2bIdArr []int64, tx *sql.Tx) error {
	for i, v := range parse {
		if v.Score < 0 {
			return fmt.Errorf("分数不能为负数")
		}
		//		if v.End<v.Begin{
		//			return fmt.Errorf("开始时间不能大于结束时间")
		//		}
		if v.Duration < 0 {
			return fmt.Errorf("作答时间不能小于0")
		}
		tableName := "ebs_p2b"
		if tArr[i] == 10 {
			tableName = "ebs_q2b"
		}

		if tArr[i] == 30 {
			tableName = "ebs_p2q"
		}
		b, _ := json.Marshal(v)
		ext := string(b)
		args := []interface{}{}
		args = append(args, ext)
		extraAttr := ""
		if tableName == "ebs_p2q" {
			args = append(args, v.Score, v.Seq)
			extraAttr = ",score=?,seq=?"
		}
		if tableName == "ebs_q2b" && v.Seq != "" {
			args = append(args, v.Seq)
			extraAttr = ",seq=?"
		}
		args = append(args, p2bIdArr[i])
		if _, err := tx.Exec("update "+tableName+" set ext=? "+extraAttr+" where tid=?", args...); err != nil {
			log.E("EditP2B db error:%v", err)
			return err
		}
	}
	return nil
}
Beispiel #23
0
//作答题库题目初始化所有题目answer
func InitQuestionsAnswer(uid, bankId int64, uname string, pid int64, tx *sql.Tx) error {
	now := time.Now().Unix()
	sql_ := `insert into ebs_answer (qid,paper_id,begin,uid,uname,status,type,bank_id,q2b_id,answer_key,add1 )
select q_id,0,?,?,?,'N',10,bank_id,tid,?,-1 from ebs_q2b where bank_id=? order by seq asc`
	if _, err := tx.Exec(sql_, now, uid, uname, pid, bankId); err != nil {
		return err
	}
	qs := []QUESTION{}
	sql_ = `update ebs_answer set paper_snapshot=?,answer_snapshot=? where q2b_id=? and answer_key=?`
	if rows, err := tx.Query("select q.tid,q.Q_ANALYZE,q.ANSWER,q2b.tid,q.description,q.duration,q2b.ext,q.name,q.q_option,q.pid,q2b.seq,q.score,q.type,q.uid,q.uname,q2b.bank_id,q.desc2 from ebs_question q join ebs_q2b q2b on q2b.q_id=q.tid and q2b.bank_id=?", bankId); err != nil {
		return err
	} else {

		for rows.Next() {
			q := QUESTION{}
			var q2bId, q2bSeq sql.NullInt64
			var q2bExt sql.NullString

			if err := rows.Scan(&q.Tid, &q.Q_ANALYZE, &q.ANSWER, &q2bId, &q.DESCRIPTION, &q.DURATION, &q2bExt, &q.Name, &q.Q_OPTION, &q.PID, &q2bSeq, &q.SCORE, &q.TYPE, &q.UID, &q.UNAME, &q.BANK_ID, &q.DESC2); err != nil {
				log.E("%v", err)
			}

			q.Q2bId = q2bId.Int64
			json.Unmarshal([]byte(q2bExt.String), &q.Ext)
			q.Q2bSeq = q2bSeq.Int64
			qs = append(qs, q)
		}
	}
	for _, v := range qs {
		as := fmt.Sprintf(`{"analyze":"%s","answer":"%s","id":%d},`, *v.Q_ANALYZE, *v.ANSWER, *v.Tid)

		// {"analyze":"略","answer":"[[{\"content\":\"B\",\"score\":2}]]","id":3782},
		if _, err := tx.Exec(sql_, v.ToString(), as, v.Q2bId, pid); err != nil {
			return err
		}
	}

	return nil
}
Beispiel #24
0
Datei: mgo.go Projekt: Centny/dbm
func AddDefault2(urls string) {
	for _, murl := range strings.Split(urls, ";") {
		url_m := strings.SplitAfterN(murl, "*", 2)
		var count = 1
		if len(url_m) > 1 {
			tc, err := util.ParseInt(url_m[1])
			if err != nil {
				panic(fmt.Sprintf("parsing uri(%v) fail with error %v", murl, err))
			}
			count = tc
		}
		var url = strings.TrimSuffix(url_m[0], "*")
		url_n := strings.SplitAfterN(url, "/", 2)
		if len(url_n) != 2 {
			panic(fmt.Sprintf("invalid db uri(%v)", url))
		}
		for i := 0; i < count; i++ { //connection multi time
			var tempDelay time.Duration
			for {
				mdb, err := dbm.NewMDb(NewMGO_H(url, url_n[1]))
				if err == nil {
					Default.Add(mdb)
					break
				}
				if tempDelay == 0 {
					tempDelay = 100 * time.Millisecond
				} else {
					tempDelay *= 2
				}
				if max := 8 * time.Second; tempDelay > max {
					tempDelay = max
				}
				log.E("AddDefault2 connection to server(%v) fail with error(%v), retrying after %v", url, err, tempDelay)
				time.Sleep(tempDelay)
			}
		}
	}
}
Beispiel #25
0
//获取一个题库中的试卷成绩,group by uid
func GetBankPaperScore(bankId, paperId int64) (interface{}, error) {
	rs := make(map[string]float64)
	sql_ := "select uid,score from ebs_answer where banK_id=? and p2b_id=? and status=?"
	conn := dbMgr.DbConn()
	if rows, err := conn.Query(sql_, bankId, paperId, "REMARKED"); err != nil {
		log.E("%v", err)
		return rs, err
	} else {
		for rows.Next() {
			var v1 sql.NullString
			var v2 sql.NullFloat64
			rows.Scan(&v1, &v2)
			rs[v1.String] = v2.Float64
		}
	}
	var totalScore sql.NullFloat64
	if err := conn.QueryRow(`select sum(score) from ebs_p2q where paper_id in (select p2b.paper_id from ebs_p2b p2b where p2b.tid=?)`, paperId).Scan(&totalScore); err != nil {
		return rs, err
	} else {
		rs["-1"] = totalScore.Float64
	}
	return rs, nil
}
Beispiel #26
0
func (a *AbsV) Build(dtcm *dtm.DTCM_S, id, info interface{}, args ...interface{}) (interface{}, interface{}, []interface{}, error) {
	var src = fmt.Sprintf("%v", args[0])
	video, err := ParseVideo(filepath.Join(a.WDir, src))
	if err != nil {
		err = util.Err("AbsV parse video by src(%v) error->%v", src, err)
		log.E("%v", err)
		return nil, nil, nil, err
	}
	video.Info = info
	video.Alias = a.Alias
	var mv, _ = util.Json2Map(util.S2Json(video))
	var tw, th, dur = video.Width, video.Height, int64(video.Duration * 1000000)
	var dst interface{}
	if len(args) > 1 {
		dst = args[1]
	} else {
		dst = strings.TrimSuffix(src, filepath.Ext(src))
	}
	log.D("AbsV adding task by src(%v),width(%v),height(%v),duration(%v)", src, tw, th, dur)
	return id, mv, []interface{}{
		src, dst, tw, th, dur,
	}, nil
}
Beispiel #27
0
func getPaper(id int64, f int64) (p PAPER, err_ error) {

	conn := dbMgr.DbConn()
	fmt.Println(conn.QueryRow("select tid,name,description,bank_id,tag,duration,score,q_grp,uid,uname from ebs_paper where tid=? and status='N'", id).Scan(
		&p.Tid, &p.Name, &p.DESCRIPTION, &p.BANK_ID, &p.TAG, &p.DURATION, &p.SCORE, &p.Q_GRP, &p.UID, &p.UNAME,
	))

	qgParse := []Q_GRP{}
	if p.Q_GRP != nil {
		fmt.Println(json.Unmarshal([]byte(*p.Q_GRP), &qgParse))
	}

	if len(qgParse) == 0 {
		return
	}
	questions := []map[string]interface{}{}
	child_questions := []map[string]interface{}{}
	sql_ := `select q.q_analyze,q.answer,q.tid,q.name,q.pid,q.tag,q.description,q.duration,q.score,q.type,q.q_option,p2q.seq,p2q.q_grp,p2q.tid,p2q.ext,q.desc2,q.uid from ebs_p2q p2q join ebs_question q on q.tid=p2q.qid where p2q.paper_id=? order by p2q.seq`
	//union select q.q_analyze,q.answer,q.tid,q.name,q.pid,q.tag,q.description,q.duration,q.score,q.type,q.q_option,0,0,0,0,q.desc2,q.uid from ebs_question q where q.pid<>0 and q.pid in (
	//select q.tid from ebs_p2q p2q join ebs_question q on q.tid=p2q.qid where p2q.paper_id=?)
	if rows, err := conn.Query(sql_, id); err != nil {
		log.E("GetPaperDetail Query err:%v,sql:%s", err, sql_)
		err_ = err
		return
	} else {
		for rows.Next() {
			var v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17 sql.NullString
			rows.Scan(&v12, &v13, &v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8, &v9, &v10, &v11, &v14, &v15, &v16, &v17)
			if v3.String != "0" {
				o := map[string]interface{}{
					"id":          v1.String,
					"name":        v2.String,
					"pid":         v3.String,
					"tag":         v4.String,
					"description": v5.String,
					"desc":        v5.String,
					"duration":    v6.String,
					"score":       v7.String,
					"type":        v8.String,
					"option":      v9.String,
					"seq":         v10.String,
					"uid":         v17.String,
				}
				if v8.String == "35" {
					o["description"], o["desc"] = v16.String, v16.String
				}
				if f == 1 {
					o["answer"] = v13.String
					o["analyze"] = v12.String
					o["desc"] = v5.String
				}
				child_questions = append(child_questions, o)

			} else {

				o := map[string]interface{}{
					"id":          v1.String,
					"name":        v2.String,
					"pid":         v3.String,
					"tag":         v4.String,
					"description": v5.String,
					"desc":        v5.String,
					"duration":    v6.String,
					"score": func() float64 {
						ext_ := EXT{}
						json.Unmarshal([]byte(v15.String), &ext_)
						return ext_.Score
					}(),
					"type":   v8.String,
					"option": v9.String,
					"seq":    v10.String,
					"qGrp":   v11.String,
					"p2qId":  v14.String,
					"ext": func() EXT {
						ext_ := EXT{}
						json.Unmarshal([]byte(v15.String), &ext_)
						return ext_
					}(),
					"uid": v17.String,
				}
				if v8.String == "35" {
					o["description"], o["desc"] = v16.String, v16.String
				}
				if f == 1 {
					o["answer"] = v13.String
					o["analyze"] = v12.String
					o["desc"] = v5.String
				}
				questions = append(questions, o)
			}
		}

		for i_, v_ := range questions {
			children := []map[string]interface{}{}
			for _, v := range child_questions {
				if v["pid"] == v_["id"] {
					children = append(children, v)
				}
			}
			questions[i_]["children"] = children
		}
	}
	var totalScore float64
	for _, v_ := range questions {
		totalScore += v_["score"].(float64)
	}
	for i, v := range qgParse {
		children := []map[string]interface{}{}
		for _, v_ := range questions {
			if v_["qGrp"] == fmt.Sprintf("%d", v.Id) {
				children = append(children, v_)
			}
		}
		qgParse[i].Questions = children
	}
	p.SCORE = &totalScore
	p.Q_PARSE = qgParse
	return
}
Beispiel #28
0
//查看题库题目,不显示题目答案
func FuncListBankQuestion2(bankId int64, parse common.ListParam, aid int64) ([]QUESTION, common.Pagiation, error) {
	rs := []QUESTION{}
	args := []interface{}{bankId}
	args = append(args, aid)

	//	answerFilter := ""
	//	if aid!=0{
	//		answerFilter = " and a.answer_key=?"
	//	}
	statusFilter := ""
	//1答对,0答错,-1未答
	if parse.Status != "" {
		statusFilter = " and a.add1=?"
		s := parse.Status
		if parse.Status == "-1" {
			statusFilter = " and a.status=?"
			s = "N"
		}
		args = append(args, s)
	}

	typeFilter := ""
	if parse.Type != 0 {
		typeFilter = " and q.type=?"
		args = append(args, parse.Type)
	}
	if parse.Pa.Pn < 1 || parse.Pa.Ps < 1 {
		parse.Pa.Pn = 1
		parse.Pa.Ps = 10
	}
	start := (parse.Pa.Pn - 1) * parse.Pa.Ps
	end := parse.Pa.Ps

	conn := dbMgr.DbConn()
	tx, err := conn.Begin()
	if err != nil {
		return rs, parse.Pa, err
	}
	sql_ := fmt.Sprintf(`select SQL_CALC_FOUND_ROWS q.TID, q.NAME, q.BANK_ID, q.PID, q.TAG, q.DESCRIPTION, q.DURATION, q.SCORE, q.Q_ANALYZE, q.TYPE,q.Q_OPTION, q.UID, q.UNAME,q2b.score,q2b.ext,q2b.tid,q2b.seq,q.desc2,a.tid,a.status,a.content,a.paper_snapshot,a.answer_snapshot from
	ebs_answer a left join ebs_question q on q.tid=a.qid left join ebs_q2b q2b on q2b.tid=a.q2b_id and q2b.bank_id=?
	where a.answer_key=? %s order by q2b.seq asc limit %d,%d`, statusFilter+typeFilter, start, end)
	if aid == 0 {
		sql_ = fmt.Sprintf(`select SQL_CALC_FOUND_ROWS q.TID, q.NAME, q.BANK_ID, q.PID, q.TAG, q.DESCRIPTION, q.DURATION, q.SCORE, q.Q_ANALYZE, q.TYPE,q.Q_OPTION, q.UID, q.UNAME,q2b.score,q2b.ext,q2b.tid,q2b.seq,q.desc2,a.tid,a.status,a.content,a.paper_snapshot,a.answer_snapshot
	from ebs_question q join ebs_q2b q2b on q2b.bank_id=? and q2b.q_id=q.tid left join ebs_answer a on a.answer_key=? and a.q2b_id=q2b.tid where 1=1 %s order by q2b.seq asc limit %d,%d`, statusFilter+typeFilter, start, end)
	}
	log.D("%v", sql_)
	if rows, err := tx.Query(sql_, args...); err != nil {
		tx.Commit()
		return rs, parse.Pa, err
	} else {
		columns := []string{"TID", "NAME", "BANK_ID", "PID", "TAG", "DESCRIPTION", "DURATION", "SCORE", "Q_ANALYZE", "TYPE",
			"Q_OPTION", "UID", "UNAME", "SCORE"}
		for rows.Next() {
			vals := []interface{}{}
			b := QUESTION{}
			for _, v := range columns {
				(&b).GetFieldByColumn(v, &vals)
			}
			var ext, desc2, aStatus, aContent, paperSnapshot, answerSnapshot sql.NullString
			var q2bId sql.NullInt64
			var q2bSeq, aIdRes sql.NullInt64
			vals = append(vals, &ext, &q2bId, &q2bSeq, &desc2, &aIdRes, &aStatus, &aContent, &paperSnapshot, &answerSnapshot)
			if err := rows.Scan(vals...); err != nil {
				log.E("scan err:%v", err)
			}
			qParse := QUESTION{}
			json.Unmarshal([]byte(paperSnapshot.String), &qParse)
			if qParse.Tid != nil {
				log.D("qParse:%v", qParse.ToString())
				b = qParse
				bb, _ := json.Marshal(qParse.Ext)
				ext.String = string(bb)
			}

			b.Q2bId = q2bId.Int64
			b.Q2bSeq = q2bSeq.Int64
			if b.TYPE != nil {
				if *b.TYPE == 35 {
					b.DESCRIPTION = &desc2.String
				}
			}
			if aid != 0 {
				b.Extra = map[string]interface{}{"aid": aIdRes.Int64, "aStatus": aStatus.String, "aContent": aContent.String}
			}
			if ext.String != "" {
				extParse := EXT{}
				json.Unmarshal([]byte(ext.String), &extParse)
				b.SCORE = &extParse.Score
				b.DURATION = &extParse.Duration
				b.Ext = extParse
			}
			rs = append(rs, b)
		}
	}

	if err := tx.QueryRow(`select FOUND_ROWS()`).Scan(&parse.Pa.Total); err != nil {
		tx.Commit()
		return rs, parse.Pa, err
	}
	tx.Commit()
	return rs, parse.Pa, nil
}