package gonganxitong

import (
	"path"
	"reflect"
	"strconv"
	"strings"

	"shylinux.com/x/ice"
	icebergs "shylinux.com/x/icebergs"
	"shylinux.com/x/icebergs/base/aaa"
	"shylinux.com/x/icebergs/base/ctx"
	"shylinux.com/x/icebergs/base/mdb"
	"shylinux.com/x/icebergs/base/nfs"
	"shylinux.com/x/icebergs/base/web"
	"shylinux.com/x/icebergs/base/web/html"
	kit "shylinux.com/x/toolkits"

	"shylinux.com/x/community/src/api"
	"shylinux.com/x/community/src/gonganxitong/model"
	"shylinux.com/x/mysql-story/src/db"
)

type UserPlacer interface {
	Placer
}
type Placer interface {
	Inputs(m *ice.Message, arg ...string)
	RewriteAppend(m *ice.Message, arg ...string) *ice.Message
	TransValue(m *ice.Message, key string, arg ...string) string
}
type Container interface {
	FindOrCreateByName(m *ice.Message, arg ...string)
}

type Table struct {
	db.Table
	UserPlace    UserPlacer
	Place        Placer
	Street       Container
	checkRole    string `name:"checkRole role"`
	inputs       string `name:"inputs" role:"void"`
	list         string `name:"list place_uid uid auto" role:"void"`
	marketInsert string `name:"marketInsert domain_uid* title* content" role:"leader"`
	memberList   string `name:"memberList" role:"void"`
	noticeList   string `name:"noticeList" role:"void"`
}

func (s Table) LoadTrans(m *ice.Message, arg ...string) {
	p := kit.FileLine(1, 100)
	if m.PrefixKey() != api.GONGANXITONG_PORTAL {
		ice.LoadTrans(m.Spawn(kit.Dict("_template", path.Join(path.Dir(p), "portal.json"))).Message, m.CommandKey(), m.GetCommand().Command)
	}
	h := ctx.GetCmdFile(m.Message, m.PrefixKey())
	kit.If(strings.HasPrefix(h, "/p/src/"), func() { h = strings.TrimPrefix(h, "/p/") })
	if path.Dir(h) != path.Dir(p) && m.CommandKey() != web.PORTAL {
		ice.LoadTrans(m.Spawn(kit.Dict("_template", path.Join(path.Dir(h), "portal.json"))).Message, m.CommandKey(), m.GetCommand().Command)
	}
}
func (s Table) Init(m *ice.Message, arg ...string) {
	s.LoadTrans(m, arg...)
	s.Table.Init(m, arg...)
}
func (s Table) AfterInit(m *ice.Message, arg ...string) {
	m.Cmd("applications", mdb.REMOVE, kit.Hashs(","+m.PrefixKey()+","))
}
func (s Table) AfterMigrate(m *ice.Message, arg ...string) {
	kit.If(m.GetCommand().Icon, func() { Portal{}.Show(m) })
}
func (s Table) BeforeAction(m *ice.Message, arg ...string) *ice.Message {
	return m
}
func (s Table) Inputs(m *ice.Message, arg ...string) {
	switch arg[0] {
	case model.USER_PLACE_ROLE:
		s.InputsListRole(m, UserPlaceRoleList, arg...)
	case model.PLACE_TYPE:
		s.InputsList(m, PlaceTypeList, arg...)
	case model.DOMAIN_UID:
		s.AutoCmdy(m, api.GONGANXITONG_DOMAIN).DisplayInputKeyNameIconTitle()
	default:
		s.Table.Inputs(m, arg...)
	}
}
func (s Table) InputsList(m *ice.Message, list ice.Any, arg ...string) {
	it := reflect.ValueOf(list).MapRange()
	for it.Next() {
		m.Push(arg[0], it.Key().Int()).Push(model.NAME, it.Value().String())
	}
	m.SortInt(arg[0]).DisplayInputKeyNameIconTitle()
}
func (s Table) InputsListRole(m *ice.Message, list ice.Any, arg ...string) {
	s.InputsListSkip(m, list, "1", arg...)
}
func (s Table) InputsListSkip(m *ice.Message, list ice.Any, skip string, arg ...string) {
	it := reflect.ValueOf(list).MapRange()
	for it.Next() {
		if it.Key().Int() > kit.Int64(skip) {
			m.Push(arg[0], it.Key().Int()).Push(model.NAME, it.Value().String())
		}
	}
	m.SortInt(arg[0]).DisplayInputKeyNameIconTitle()
}
func (s Table) InputsListValue(m *ice.Message, list ice.Any, key string) string {
	k, e := strconv.ParseInt(key, 10, 64)
	if e != nil {
		return key
	}
	it := reflect.ValueOf(list).MapRange()
	for it.Next() {
		if it.Key().Int() == k {
			return it.Value().String()
		}
	}
	return ""
}
func (s Table) ValueModel(m *ice.Message, action ice.Any, arg ...string) *ice.Message {
	defer m.Options(db.DB, m.Configv(db.DB)).Set(ice.MSG_OPTION, db.DB)
	defer m.Options(db.MODEL, m.Configv(db.MODEL)).Set(ice.MSG_OPTION, db.MODEL)
	defer m.Options(db.TARGET, kit.Select(m.CommandKey(), m.Config(db.MODELS))).Set(ice.MSG_OPTION, db.TARGET)
	kit.For(db.CommonField, func(k string) { arg = kit.TransArgKeys(arg, s.Keys(m.Option(db.TARGET), k), k) })
	return m.Options(arg).Cmdy(s.PrefixPortal(m), action, arg)
}
func (s Table) ValueCreate(m *ice.Message, arg ...string) {
	s.ValueModel(m, s.ValueCreate, arg...)
	s.RecordEventWithName(m, "")
	s.UserPlaceInit(m)
}
func (s Table) ValueRemove(m *ice.Message, arg ...string) {
	s.ValueModel(m, s.ValueRemove, arg...)
	s.RecordEventWithName(m, "")
}
func (s Table) ValueModify(m *ice.Message, arg ...string) {
	s.ValueModel(m, s.ValueModify, arg...)
	s.RecordEventWithName(m, "")
}
func (s Table) ValueList(m *ice.Message, arg []string, fields ...ice.Any) *ice.Message {
	if len(arg) > 0 {
		kit.If(len(fields) == 0, func() { fields = kit.TransArgs(kit.Split(m.Config(mdb.FIELDS), ",", ",")) })
		defer m.Options(db.FIELDS, fields).Set(ice.MSG_OPTION, db.FIELDS)
	}
	if s.ValueModel(m, s.ValueList, arg...); len(arg) == 1 {
		s.UserPlaceInit(m)
		if s.IsLeader(m) {
			s.Button(m, "")
		} else {
			if m.Length() == 0 {
				m.Echo("没有数据")
			}
			m.Action()
		}
	}
	return s.SelectJoinUser(m)
}
func (s Table) Create(m *ice.Message, arg ...string) { s.ValueCreate(m, arg...) }
func (s Table) Remove(m *ice.Message, arg ...string) { s.ValueRemove(m, arg...) }
func (s Table) Modify(m *ice.Message, arg ...string) { s.ValueModify(m, arg...) }
func (s Table) List(m *ice.Message, arg ...string) *ice.Message {
	return s.ValueList(m, arg)
}
func (s Table) FieldsDefault(m *ice.Message, arg ...string) Table {
	if m.Option(mdb.SELECT) == "" {
		if fields := m.Config(mdb.FIELDS); fields != "" {
			s.Table.FieldsWithCreatedAT(m, kit.Select(m.CommandKey(), m.Config(db.MODELS)), kit.TransArgs(kit.Split(fields, ",", ","))...)
		}
	}
	return s
}
func (s Table) LeftJoinValue(m *ice.Message, value, place ice.Any, arg ...string) string {
	model := s.ToLower(kit.TypeName(value))
	models := s.TableName(model)
	_model := s.ToLower(kit.TypeName(place))
	_models := s.TableName(_model)
	return kit.Format("LEFT JOIN %s ON %s.%s_uid = %s.uid AND %s.user_uid = '%s'", models, models, _model, _models, models, m.Option("user_uid"))
}
func (s Table) Select(m *ice.Message, arg ...string) *ice.Message {
	s.FieldsDefault(m).Table.Select(m, arg...)
	kit.If(m.Length() > 0, func() { s.UserPlaceInit(m) })
	return m
}
func (s Table) SelectDetail(m *ice.Message, arg ...string) *ice.Message {
	return s.FieldsDefault(m).Table.SelectDetail(m, arg...)
}
func (s Table) SelectJoinUser(m *ice.Message, arg ...string) *ice.Message {
	kit.If(len(arg) == 0, func() { arg = append(arg, model.NAME, model.AVATAR) })
	return s.SelectJoin(m, user{}, arg...)
}
func (s Table) SelectJoinCity(m *ice.Message, arg ...string) *ice.Message {
	kit.If(len(arg) == 0, func() { arg = append(arg, model.NAME) })
	return s.SelectJoin(m, city{}, arg...)
}
func (s Table) SelectJoinAuth(m *ice.Message, arg ...string) *ice.Message {
	if kit.IndexOf(m.Appendv(model.AUTH_TYPE), model.AUTH_TYPE) > -1 {
		return m
	}
	kit.If(len(arg) == 0, func() {
		arg = append(arg, model.NAME, model.INFO, model.AUTH_TYPE, model.AUTH_STATUS, model.AVATAR, model.BACKGROUND, model.DASHBOARD_UID)
	})
	defer s.SaveBack(m, ice.MSG_USERPOD, ice.MSG_USERROLE)()
	return s.SelectJoin(m, s.findSpaceCmd(m, api.RENZHENGSHOUQUAN_AUTH), arg...)
}
func (s Table) SelectJoinRecent(m *ice.Message, PLACE_UID string, arg ...string) *ice.Message {
	if m.Length() == 0 {
		return m
	}
	kit.If(len(arg) == 0, func() { arg = append(arg, model.CITY_NAME, model.STREET_NAME, model.PLACE_NAME) })
	list := []string{}
	m.Table(func(value ice.Maps) { kit.If(value[PLACE_UID], func(v string) { list = kit.AddUniq(list, v) }) })
	msg := m.Spawn()
	s.Fields(msg, kit.JoinFields("DISTINCT place_uid", kit.JoinFields(arg...)))
	recents := msg.CmdMap(recent{}, s.SelectList, model.PLACE_UID, list, model.PLACE_UID)
	m.Table(func(value ice.Maps) {
		recent := recents[value[PLACE_UID]]
		kit.For(arg, func(k string) { m.Push(k, recent[k]) })
	})
	return m
}
func (s Table) SelectJoinService(m *ice.Message, arg ...string) *ice.Message {
	kit.If(len(arg) == 0, func() { arg = append(arg, model.NODENAME, model.INDEX, model.NAME, model.ICON) })
	return s.SelectJoin(m, service{}, arg...)
}
func (s Table) RewriteAppend(m *ice.Message, arg ...string) *ice.Message {
	m.RewriteAppend(func(value, key string, index int) string {
		if value != "" && kit.IsIn(key, model.BACKGROUND, model.AVATAR) {
			value = m.Resource(value)
		}
		if _, e := strconv.ParseInt(value, 10, 64); e != nil {
			return value
		}
		switch key {
		case model.USER_PLACE_ROLE:
			value = UserPlaceRole(kit.Int(value)).String()
		case model.MEMBER_STATUS:
			value = MemberStatus(kit.Int(value)).String()
		case model.PLACE_TYPE:
			value = PlaceType(kit.Int(value)).String()
		case model.AUTH_STATUS:
			value = AuthStatus(kit.Int(value)).String()
		case model.APPLY_STATUS:
			value = ApplyStatus(kit.Int(value)).String()
		case model.ALLOW_STATUS:
			value = AllowStatus(kit.Int(value)).String()
		case model.MESSAGE_STATUS:
			value = MessageStatus(kit.Int(value)).String()
		}
		return value
	})
	return m
}
func (s Table) Update(m *ice.Message, data ice.Any, arg ...string) {
	if len(arg) == 0 {
		arg = append(arg, model.UID, kit.Select(m.Option(model.UID), m.Option(s.Keys(m.CommandKey(), model.UID))))
	}
	m.Info("what %v", data)
	s.Table.Update(m, data, arg...)
}
func (s Table) UpdateAuth(m *ice.Message, arg ...string) {
	s.Update(m, kit.Dict(model.AUTH_UID, arg[0]), arg[1:]...)
}
func (s Table) UpdateField(m *ice.Message, arg ...string) {
	s.Update(m, kit.Dict(arg[0], arg[1]), arg[2:]...)
}
func (s Table) UploadUpdate(m *ice.Message, field, uid string, arg ...string) {
	if m.IsErr() {
		return
	}
	p := m.UploadSave(path.Join(nfs.USR, kit.Select(field, m.Option(model.FIELD)), uid) + nfs.PS)
	s.Update(m, kit.Dict(kit.Select(m.Option(model.FIELD), field), p), model.UID, uid)
}
func (s Table) UploadCreate(m *ice.Message, field, uid string, arg ...string) {
	if m.IsErr() {
		return
	}
	p := m.UploadSave(path.Join(nfs.USR, kit.Select(field, m.Option(model.FIELD)), uid) + nfs.PS)
	s.Create(m, kit.Select(m.Option(model.FIELD), field), p, model.UID, uid)
}
func (s Table) ChangeStatus(m *ice.Message, place_uid, uid string, from, to int, arg ...string) *ice.Message {
	msg := s.ValueList(m.Spawn(), []string{place_uid, uid}, model.STATUS)
	if !m.WarnNotValid(msg.Length() == 0 || kit.Int(msg.Append(mdb.STATUS)) != int(from)) {
		s.Update(m, kit.Dict(mdb.STATUS, to, arg), model.UID, uid)
	}
	return m
}
func (s Table) CheckRole(m *ice.Message, arg ...string) {
	role := UserPlaceRole(s.UserPlaceRole(m))
	m.WarnNotRight(!kit.IsIn(role.String(), append(arg, UserPlaceCreator.String())...), role.String())
}
func (s Table) IsVisitor(m *ice.Message) bool {
	if role := kit.Int(m.Option(model.USER_ROLE)); role == 0 {
		return true
	}
	return false
}
func (s Table) IsLeader(m *ice.Message) bool {
	if role := kit.Int(m.Option(model.USER_ROLE)); role == 1 || role == 2 {
		return true
	}
	return false
}
func (s Table) IsWorker(m *ice.Message) bool {
	if role := kit.Int(m.Option(model.USER_ROLE)); role == 1 || role == 2 || role == 3 {
		return true
	}
	return false
}
func (s Table) UserPlaceRole(m *ice.Message) int {
	return kit.Int(m.Cmdy(s.PrefixPortal(m), s.UserPlaceRole).Option(model.USER_ROLE))
}
func (s Table) UserPlaceInit(m *ice.Message, arg ...string) {
	if m.Option(model.PLACE_INIT) == "" || m.PrefixKey() != m.Option(ice.MSG_INDEX) {
		return
	}
	m.Cmd(s.PrefixPortal(m), Portal{}.PlaceCmd, "addCount", model.INIT, 1, m.Option(model.PLACE_UID), m.Option(model.PLACE_INIT))
}
func (s Table) RecordEvent(m *ice.Message, info string, arg ...string) {
	m.Cmd(s.PrefixPortal(m), s.RecordEvent, info, arg)
}
func (s Table) RecordEventWithName(m *ice.Message, info string, arg ...string) {
	uid := kit.Select(m.Result(), m.Option(model.UID))
	kit.If(info == "", func() {
		switch info = m.ActionCmdTitle(); m.ActionKey() {
		case "placeCreate", mdb.CREATE:
			info = "✅ " + info
		case "placeRemove", mdb.REMOVE:
			info = "❌ " + info
		case "placeAuth":
			info = "🕑 " + info
		}
	})
	s.RecordEvent(m, kit.JoinWord(info, kit.Cut(uid, 6), kit.Select(m.Option(model.NAME), m.Option(model.TITLE))), uid)
}
func (s Table) MemberList(m *ice.Message, arg ...string) {
	m.Cmdy(s.Prefix(m, member{}), arg)
}
func (s Table) CityList(m *ice.Message, arg ...string) *ice.Message {
	m.Cmdy(s.Prefix(m, city{}), arg).RenameAppend(model.NAME, model.CITY_NAME)
	return m
}
func (s Table) CityCmd(m *ice.Message, arg ...ice.Any) *ice.Message {
	return m.Cmd(append([]ice.Any{city{}}, arg...)...)
}
func (s Table) CreditCmdy(m *ice.Message, arg ...ice.Any) *ice.Message {
	return m.Cmdy(append([]ice.Any{s.Prefix(m, credit{})}, arg...)...)
}
func (s Table) SettingCmdy(m *ice.Message, arg ...ice.Any) *ice.Message {
	return m.Cmdy(append([]ice.Any{s.Prefix(m, setting{})}, arg...)...)
}
func (s Table) AuthCreate(m *ice.Message, authType int, fromUID string, arg ...string) {
	s.AutoCmdy(m, api.RENZHENGSHOUQUAN_PORTAL, Portal{}.PlaceCreate,
		model.AUTH_NAME, m.Option(model.NAME), model.AUTH_INFO, m.Option(model.INFO),
		model.AUTH_TYPE, authType, model.FROM_UID, kit.Select(ice.AUTO, fromUID),
		model.SERVICE_UID, m.Option(model.SERVICE_UID),
	)
	s.Update(m, kit.Dict(m.OptionSimple(model.AUTH_UID)), arg...)
}
func (s Table) DashboardUpdate(m *ice.Message, arg ...string) {
	if m.IsErr() {
		return
	}
	m.Cmd(s.Prefix(m, Portal{}), s.DashboardUpdate)
}
func (s Table) MarketInsert(m *ice.Message, arg ...string) {
	m.Cmdy(s.Prefix(m, Portal{}), s.MarketInsert, arg)
}
func (s Table) ServiceList(m *ice.Message, arg ...string) *ice.Message {
	return m.Cmd(s.Prefix(m, service{}), arg)
}
func (s Table) GetCommandUID(m *ice.Message, arg ...string) {
	m.Option(model.COMMAND_UID, CommandUID(m, kit.Select(m.PrefixKey(), arg, 0)))
}
func (s Table) SendMessage(m *ice.Message, from, to string, arg ...string) {
	if m.IsErr() {
		return
	}
	m.Spawn(ice.Maps{db.DB: ""}).Cmd(s.Prefix(m, message{}), s.Create,
		model.FROM_USER_UID, kit.Select(m.Option(model.USER_UID), from), model.TO_USER_UID, kit.Select(m.Option(model.USER_UID), to),
		m.OptionSimple(model.COMMAND_UID), model.ARGS, kit.Join(arg),
	)
}
func (s Table) DoneMessage(m *ice.Message, arg ...string) {
	if m.Option(model.MESSAGE_UID) != "" {
		m.Spawn(ice.Maps{db.DB: ""}).Cmd(s.Prefix(m, message{}), message{}.Done, kit.Dict(model.UID, m.Option(model.MESSAGE_UID)))
	}
}
func (s Table) SendTemplate(m *ice.Message, from, to, title string, arg ...string) {
	if m.IsErr() {
		return
	}
	m.Cmd(s.PrefixPortal(m), s.SendTemplate, m.PrefixKey(), from, to, title, arg)
}
func (s Portal) SendTemplate(m *ice.Message, arg ...string) {
	name := kit.Select("", arg, 4)
	if name == "" {
		name = kit.JoinWord(m.Option(model.CITY_NAME), m.Option(model.STREET_NAME), kit.Select(m.Option(model.PLACE_NAME), m.Option(s.Keys(s.Place, model.NAME))))
	}
	uid, place_uid := kit.Select(m.Option(model.UID), arg, 5), kit.Select("", arg, 6)
	kit.If(place_uid == "", func() { place_uid = m.Option(s.Keys(s.Place, model.UID)) })
	link := m.Cmdx("", s.Link, place_uid, arg[0], uid)
	s.AutoCmd(m, user{}, s.SendTemplate, arg[1], arg[2], link, kit.JoinWord(m.Option(model.PORTAL_NAME), arg[3]), name, kit.Cut(uid, 6))
}
func (s Table) Button(m *ice.Message, info string, arg ...ice.Any) *ice.Message {
	kit.If(!m.IsErr() && m.Length() == 0, func() { m.Options(ctx.STYLE, html.FORM).EchoInfoButton(info, arg...) })
	return m
}
func (s Table) DisplayBase(m *ice.Message, file string) *ice.Message {
	if s.Place != nil {
		m.Option("_place_uid", s.ToLower(kit.TypeName(s.Place))+"_uid")
		m.Option("_place_name", s.ToLower(kit.TypeName(s.Place))+"_name")
		m.Option("_place_type", s.ToLower(kit.TypeName(s.Place))+"_type")
		m.Option("_user_place_role", s.ToLower(kit.TypeName(s.UserPlace))+"_role")
	}
	if s.Street != nil {
		m.Option("_street_name", s.ToLower(kit.TypeName(s.Street))+"_name")
	}
	m.Display(m.Resource(path.Join(path.Dir(kit.FileLine(1, 100)), kit.Select(m.CommandKey()+".js", file))))
	return m
}
func (s Table) Display(m *ice.Message, file string) *ice.Message {
	s.DisplayBase(m, file)
	base, sub := path.Dir(kit.FileLine(1, 100)), path.Dir(kit.FileLine(-1, 100))
	return m.Display(kit.Format(mdb.Cache(m.Message, kit.Keys(m.PrefixKey(), ctx.DISPLAY, file), func() ice.Any {
		if file == "" {
			file = m.Resource(path.Join(sub, m.CommandKey()+".js"))
		}
		if m.Template(file) == "" {
			if m.CommandKey() == web.PORTAL {
				file = m.Resource(path.Join(base, "portal.js"))
			} else {
				file = m.Resource(path.Join(base, "common.js"))
			}
		}
		return file
	})))
}
func (s Table) TransValue(m *ice.Message, key string, arg ...string) string {
	if value := kit.Select(m.Option(key), arg, 0); m.IsEnglish() {
		return value
	} else {
		return kit.Select(value, kit.Value(m.Target().Commands[m.CommandKey()].Meta, "_trans.value."+key+"."+value))
	}
}
func (s Table) TransRole(m *ice.Message, arg ...string) string {
	value := kit.Select(m.Option(s.Keys(s.UserPlace, model.ROLE)), arg, 0)
	role := s.Place.TransValue(m, s.Keys(s.UserPlace, model.ROLE), arg...)
	return kit.Format(`<span class="role %s %s">%s</span>`, value, kit.Select("", arg, 1), role)
}

func (s Table) Prefix(m *ice.Message, target ice.Any) string {
	return m.Prefix(kit.TypeName(target))
}
func (s Table) PrefixPortal(m *ice.Message) string {
	return m.Prefix(kit.TypeName(Portal{}))
}
func (s Table) findSpaceCmd(m *ice.Message, cmd ice.Any) ice.Any {
	cmds := ice.GetTypeKey(cmd)
	if space, ok := cmdSpace[cmds]; ok && space != ice.Info.NodeName {
		m.Options(ice.MSG_USERROLE, aaa.TECH, ice.MSG_USERPOD, space)
		return []string{web.SPACE, kit.Keys(ice.OPS, space), cmds}
	}
	return cmd
}
func (s Table) SaveBack(m *ice.Message, arg ...string) func() {
	list := []string{}
	kit.For(arg, func(k string) { list = append(list, m.Option(k)) })
	return func() {
		kit.For(arg, func(i int, k string) { m.Option(k, list[i]) })
	}
}
func (s Table) SpaceOpsCmdy(m *ice.Message, arg ...ice.Any) *ice.Message {
	return s.SpaceCmdy(m, ice.OPS, arg...)
}
func (s Table) SpaceOpsCmd(m *ice.Message, arg ...ice.Any) *ice.Message {
	return s.SpaceCmd(m, ice.OPS, arg...)
}
func (s Table) SpaceCmdy(m *ice.Message, space string, arg ...ice.Any) *ice.Message {
	return m.Cmdy(append([]ice.Any{web.SPACE, space, kit.Dict(ice.MSG_USERROLE, aaa.TECH)}, arg...)...)
}
func (s Table) SpaceCmd(m *ice.Message, space string, arg ...ice.Any) *ice.Message {
	return m.Cmd(append([]ice.Any{web.SPACE, space, kit.Dict(ice.MSG_USERROLE, aaa.TECH)}, arg...)...)
}
func (s Table) AutoCmdy(m *ice.Message, arg ...ice.Any) *ice.Message {
	defer s.SaveBack(m, ice.MSG_USERPOD, ice.MSG_USERROLE)()
	return m.Cmdy(append([]ice.Any{s.findSpaceCmd(m, arg[0])}, arg[1:]...)...)
}
func (s Table) AutoCmd(m *ice.Message, arg ...ice.Any) *ice.Message {
	return m.Cmd(append([]ice.Any{s.findSpaceCmd(m, arg[0])}, arg[1:]...)...)
}
func (s Table) ProcessPodCmd(m, msg *ice.Message, arg ...string) *ice.Message {
	m.ProcessPodCmd(msg.Append(web.SPACE), msg.Append(ctx.INDEX), kit.Split(msg.Append(ctx.ARGS)))
	m.Push(ice.FIELD_OPTION, kit.Format(kit.Dict(arg)))
	return m
}
func (s Table) Link(m *ice.Message, arg ...string) string {
	return m.Cmdx(s.PrefixPortal(m), s.Link, arg)
}

type Tables struct{ Table }

func (s Tables) BeforeMigrate(m *ice.Message, arg ...string) {}

func newTable() Table   { return Table{UserPlace: userPlace{}, Place: place{}, Street: street{}} }
func newTables() Tables { return Tables{Table: newTable()} }
func NewTable(userPlace UserPlacer, place Placer, street Container) Table {
	return Table{UserPlace: userPlace, Place: place, Street: street}
}
func NewTables(userPlace UserPlacer, place Placer, street Container) Tables {
	return Tables{Table: NewTable(userPlace, place, street)}
}
func NewPortal(userPlace UserPlacer, place Placer, street Container) Portal {
	return Portal{Table: Table{UserPlace: userPlace, Place: place, Street: street}}
}
func (s Portal) getTable() Table { return s.Table }

func PortalCmd(portal ice.Any) {
	h := kit.FileLine(-1, 100)
	p := kit.Keys("web.team", kit.ModPath(-1))
	table := portal.(interface{ getTable() Table }).getTable()
	tables := Tables{Table: table}
	cmd := func(name string, data ice.Any) {
		_, cmd := ice.Cmd(kit.Keys(p, name), data)
		cmd.RawHand = path.Join(path.Dir(h), name+".go")
		cmd.Actions[ice.CTX_INIT].Hand = icebergs.MergeHand(func(m *icebergs.Message, arg ...string) {
			m.Design(mdb.LIST, "", kit.JoinWord(table.Keys(table.Place, model.UID), model.UID, ice.AUTO))
			mdb.Config(m, db.DOMAIN, kit.PathName(1))
		}, cmd.Actions[ice.CTX_INIT].Hand)
	}
	cmd("portal", portal)
	cmd("search", search{Tables: tables})
	cmd("qrcode", qrcode{Tables: tables})
	cmd("event", event{Table: table})
	cmd("apply", apply{Table: table})
	cmd("allow", allow{Table: table})
	cmd("notice", notice{Table: table})
	cmd("setting", setting{Table: table})
	cmd("member", member{Tables: tables})
	cmd("credit", credit{Tables: tables})
	cmd("market", market{Table: table})
	cmd("message", message{Table: table})
	cmd("recent", recent{Table: table})
	cmd("service", service{Table: table})
	cmd("support", support{Table: table})
}