odbtest/test/reauth.go

/*
	Before you execute the program, Launch `cqlsh` and execute:

create keyspace example with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };
create table example.tweet(timeline text, id UUID, text text, PRIMARY KEY(id));
create index on example.tweet(timeline);
*/
package main

import (
	"os"
	//"fmt"
	"flag"
	// "strconv"
	"strings"

	"git.wecise.com/wecise/odbserver/odb/test"
	"gitee.com/wecisecode/util/logger"
)

var domain map[string][]string
var stat *PrepareStatement
var qstat *PrepareStatement

var ccache map[string]string //key is class+tag==>path

func main() {

	logger.SetConsole(true)
	logger.SetLevel(logger.INFO)

	keyspace := flag.String("keyspace", "matrix", "keyspace")
	flag.Parse()

	var err error

	option := &Option{Cache: CacheAll, Keyspace: *keyspace, DisableInitialHostLookup: true}
	g, err := test.NewG(option)

	if err != nil {
		logger.Error(err.Error())
	} else {
		defer g.Close()
	}

	rst, _, err := g.Query(`select name, id, tadd, tdelete, tedit, tlist from /matrix/group limit -1`, &QueryMeta{Return: ReturnAll, MinAsteriskField: false, KeepClassID: false})

	if err != nil {
		logger.Error(err.Error())
		os.Exit(2)
	}

	stat, err = g.Prepare(`update /matrix/group set tadd = ?, tdelete = ?, tedit = ?, tlist = ? where id = ?`)
	if err != nil {
		logger.Error(err.Error())
		os.Exit(2)
	}

	qstat, err = g.Prepare(`select path from /matrix/tagdir where domain in ? and name=?`)

	if err != nil {
		logger.Error(err.Error())
		os.Exit(2)
	}

	ccache = map[string]string{}
	domain = map[string][]string{}
	if rows, _, err := g.Query("SELECT mclass, name FROM /matrix/system/domain"); err != nil {
		logger.Error(err.Error())
		os.Exit(2)
	} else {
		for _, row := range rows {
			name := row["name"].(string)
			class := row["mclass"].(string)
			if cc, ok := domain[class]; ok {
				cc = append(cc, name)
				domain[class] = cc
			} else {
				domain[class] = []string{name}
			}
		}
	}

	for _, row := range rst {

		name := row["name"].(string)
		logger.Infof("######### %s #########", name)

		id := row["id"].(string)
		var tadd, tdelete, tedit, tlist map[string]string

		if val := row["tadd"]; val != nil {
			tadd = val.(map[string]string)
		}

		if val := row["tdelete"]; val != nil {
			tdelete = val.(map[string]string)
		}

		if val := row["tedit"]; val != nil {
			tedit = val.(map[string]string)
		}

		if val := row["tlist"]; val != nil {
			tlist = val.(map[string]string)
		}

		convert(g, stat, id, tadd, tdelete, tedit, tlist)
	}
}

func convert(g *Gutil, stat *PrepareStatement, id string, tadd, tdelete, tedit, tlist map[string]string) {

	add := convertmap(g, tadd)
	delete := convertmap(g, tdelete)
	edit := convertmap(g, tedit)
	list := convertmap(g, tlist)

	if true {
		if _, _, err := stat.Exec(add, delete, edit, list, id); err != nil {
			logger.Error(err.Error())
		}
	}

}

func convertmap(g *Gutil, v map[string]string) map[string]string {

	n := map[string]string{}

	for cls, s := range v {

		exps := []string{}

		ss := strings.Split(s, ",")
		for _, sss := range ss {

			if sss != "" {

				tags := strings.Split(sss, "+")
				if len(tags) == 1 { // no+
					if full, ok := ccache[cls+"/"+sss]; ok {
						exps = append(exps, full)
					} else {
						full = fullclass(g, cls, sss)
						exps = append(exps, full)
						ccache[cls+"/"+sss] = full
					}

				} else {
					comp := []string{}

					for _, tag := range tags {
						if full, ok := ccache[cls+"/"+tag]; ok {
							comp = append(comp, full)
						} else {
							full := fullclass(g, cls, tag)
							comp = append(comp, full)
							ccache[cls+"/"+tag] = full
						}
					}

					switch len(comp) {
					case 0:
					case 1:
						exps = append(exps, comp[0])
					default:
						exps = append(exps, strings.Join(comp, "+"))
					}
				}
			}
		}

		switch len(exps) {
		case 0:
		case 1:
			n[cls] = exps[0]
		default:
			n[cls] = strings.Join(exps, ",")
		}
	}

	return n
}

func fullclass(g *Gutil, cls, v string) string {
	if idx := strings.Index(v, "/"); idx != -1 {
		return v
	} else {
		if ds, ok := domain[cls]; !ok {
			logger.Warnf("not find domain for %s", cls)
		} else {
			if rst, _, err := qstat.Exec(ds, v); err != nil {
				logger.Warnf("can't find domain: %v, tag: %s, err: %v", ds, v, err)
			} else {
				if len(rst) > 0 {
					logger.Infof("find tag: %s => %s in domian %v", v, rst[0]["path"].(string), ds)
					return rst[0]["path"].(string)
				} else {
					logger.Warnf("can't find tag: %s in domian: %v", v, ds)
				}
			}
		}
	}

	return v
}