func (transition *Transition) ConfigureQorResource(res *admin.Resource) { if res.GetMeta("State") == nil { res.Meta(&admin.Meta{Name: "State", Permission: roles.Allow(roles.Update, "nobody")}) } }
func (publish *Publish) InjectQorAdmin(res *admin.Resource) { if !injected { injected = true for _, gopath := range strings.Split(os.Getenv("GOPATH"), ":") { admin.RegisterViewPath(path.Join(gopath, "src/github.com/qor/qor/publish/views")) } } res.UseTheme("publish") controller := publishController{publish} router := res.GetAdmin().GetRouter() router.Get(fmt.Sprintf("^/%v/diff/", res.ToParam()), controller.Diff) router.Get(fmt.Sprintf("^/%v", res.ToParam()), controller.Preview) router.Post(fmt.Sprintf("^/%v", res.ToParam()), controller.PublishOrDiscard) res.GetAdmin().RegisterFuncMap("render_publish_meta", func(value interface{}, meta *admin.Meta, context *admin.Context) template.HTML { var err error var result = bytes.NewBufferString("") var tmpl = template.New(meta.Type + ".tmpl").Funcs(context.FuncMap()) if tmpl, err = context.FindTemplate(tmpl, fmt.Sprintf("metas/publish/%v.tmpl", meta.Type)); err != nil { if tmpl, err = context.FindTemplate(tmpl, fmt.Sprintf("metas/index/%v.tmpl", meta.Type)); err != nil { tmpl, _ = tmpl.Parse("{{.Value}}") } } data := map[string]interface{}{"Value": context.ValueOf(value, meta), "Meta": meta} if err := tmpl.Execute(result, data); err != nil { utils.ExitWithMsg(err.Error()) } return template.HTML(result.String()) }) res.GetAdmin().RegisterFuncMap("publish_unique_key", func(res *admin.Resource, record interface{}, context *admin.Context) string { return fmt.Sprintf("%s__%v", res.ToParam(), context.GetDB().NewScope(record).PrimaryKeyValue()) }) }
func (s Status) InjectQorAdmin(res *admin.Resource) { if res.GetMeta("PublishStatus") == nil { res.IndexAttrs(append(res.IndexAttrs(), "-PublishStatus")...) res.ShowAttrs(append(res.ShowAttrs(), "-PublishStatus")...) res.EditAttrs(append(res.EditAttrs(), "-PublishStatus")...) res.NewAttrs(append(res.NewAttrs(), "-PublishStatus")...) } }
func (i18n *I18n) ConfigureQorResource(res *admin.Resource) { res.UseTheme("i18n") res.GetAdmin().I18n = i18n res.SearchAttrs("value") // generate search handler for i18n res.GetAdmin().RegisterFuncMap("lt", func(locale, key string, withDefault bool) string { if translations := i18n.Translations[locale]; translations != nil { if t := translations[key]; t != nil && t.Value != "" { return t.Value } } if withDefault { if translations := i18n.Translations[Default]; translations != nil { if t := translations[key]; t != nil { return t.Value } } } return "" }) res.GetAdmin().RegisterFuncMap("i18n_available_keys", func(context *admin.Context) (keys []string) { translations := i18n.Translations[Default] if translations == nil { for _, values := range i18n.Translations { translations = values break } } keyword := context.Request.URL.Query().Get("keyword") for key, translation := range translations { if (keyword == "") || (strings.Index(strings.ToLower(translation.Key), strings.ToLower(keyword)) != -1 || strings.Index(strings.ToLower(translation.Value), keyword) != -1) { keys = append(keys, key) } } sort.Strings(keys) pagination := context.Searcher.Pagination pagination.Total = len(keys) pagination.PrePage = 25 pagination.CurrentPage, _ = strconv.Atoi(context.Request.URL.Query().Get("page")) if pagination.CurrentPage == 0 { pagination.CurrentPage = 1 } if pagination.CurrentPage > 0 { pagination.Pages = pagination.Total / pagination.PrePage } context.Searcher.Pagination = pagination if pagination.CurrentPage == -1 { return keys } lastIndex := pagination.CurrentPage * pagination.PrePage if pagination.Total < lastIndex { lastIndex = pagination.Total } return keys[(pagination.CurrentPage-1)*pagination.PrePage : lastIndex] }) res.GetAdmin().RegisterFuncMap("i18n_primary_locale", func(context admin.Context) string { if locale := context.Request.Form.Get("primary_locale"); locale != "" { return locale } return getAvailableLocales(context.Request, context.CurrentUser)[0] }) res.GetAdmin().RegisterFuncMap("i18n_editing_locale", func(context admin.Context) string { if locale := context.Request.Form.Get("to_locale"); locale != "" { return locale } return getLocaleFromContext(context.Context) }) res.GetAdmin().RegisterFuncMap("i18n_viewable_locales", func(context admin.Context) []string { return getAvailableLocales(context.Request, context.CurrentUser) }) res.GetAdmin().RegisterFuncMap("i18n_editable_locales", func(context admin.Context) []string { return getEditableLocales(context.Request, context.CurrentUser) }) controller := i18nController{i18n} router := res.GetAdmin().GetRouter() router.Get(fmt.Sprintf("^/%v", res.ToParam()), controller.Index) router.Post(fmt.Sprintf("^/%v", res.ToParam()), controller.Update) router.Put(fmt.Sprintf("^/%v", res.ToParam()), controller.Update) for _, gopath := range strings.Split(os.Getenv("GOPATH"), ":") { admin.RegisterViewPath(path.Join(gopath, "src/github.com/qor/qor/i18n/views")) } }
func (s *Sorting) InjectQorAdmin(res *admin.Resource) { Admin := res.GetAdmin() res.UseTheme("sorting") if res.Config.Permission == nil { res.Config.Permission = roles.NewPermission() } if !injected { injected = true for _, gopath := range strings.Split(os.Getenv("GOPATH"), ":") { admin.RegisterViewPath(path.Join(gopath, "src/github.com/qor/qor/sorting/views")) } } role := res.Config.Permission.Role if _, ok := role.Get("sorting_mode"); !ok { role.Register("sorting_mode", func(req *http.Request, currentUser qor.CurrentUser) bool { return req.URL.Query().Get("sorting") != "" }) } if res.GetMeta("Position") == nil { res.Meta(&admin.Meta{ Name: "Position", Valuer: func(value interface{}, ctx *qor.Context) interface{} { db := ctx.GetDB() var count int var pos = value.(sortingInterface).GetPosition() if _, ok := modelValue(value).(sortingDescInterface); ok { if total, ok := db.Get("sorting_total_count"); ok { count = total.(int) } else { db.New().Model(modelValue(value)).Count(&count) } pos = count - pos + 1 } primaryKey := ctx.GetDB().NewScope(value).PrimaryKeyValue() url := path.Join(ctx.Request.URL.Path, fmt.Sprintf("%v", primaryKey), "sorting/update_position") return template.HTML(fmt.Sprintf("<input type=\"number\" class=\"qor-sorting-position\" value=\"%v\" data-sorting-url=\"%v\" data-position=\"%v\">", pos, url, pos)) }, Permission: roles.Allow(roles.Read, "sorting_mode"), }) } var attrs []string for _, attr := range res.IndexAttrs() { if attr != "Position" { attrs = append(attrs, attr) } } res.IndexAttrs(append(attrs, "Position")...) router := Admin.GetRouter() router.Post(fmt.Sprintf("^/%v/\\d+/sorting/update_position$", res.ToParam()), updatePosition) }
func (l *Locale) ConfigureQorResource(res *admin.Resource) { Admin := res.GetAdmin() res.UseTheme("l10n") if res.Config.Permission == nil { res.Config.Permission = roles.NewPermission() } res.Config.Permission.Allow(roles.CRUD, "locale_admin").Allow(roles.Read, "locale_reader") if res.GetMeta("Localization") == nil { res.Meta(&admin.Meta{Name: "Localization", Valuer: func(value interface{}, ctx *qor.Context) interface{} { db := ctx.GetDB() context := Admin.NewContext(ctx.Writer, ctx.Request) var languageCodes []string scope := db.NewScope(value) db.New().Set("l10n:mode", "unscoped").Model(res.Value).Where(fmt.Sprintf("%v = ?", scope.PrimaryKey()), scope.PrimaryKeyValue()).Pluck("language_code", &languageCodes) var results string availableLocales := getAvailableLocales(ctx.Request, ctx.CurrentUser) OUT: for _, locale := range availableLocales { for _, localized := range languageCodes { if locale == localized { results += fmt.Sprintf("<span class=\"qor-label is-active\">%s</span> ", context.T(locale)) continue OUT } } results += fmt.Sprintf("<span class=\"qor-label\">%s</span> ", context.T(locale)) } return template.HTML(results) }}) attrs := res.IndexAttrs() var hasLocalization bool for _, attr := range attrs { if attr == "Localization" { hasLocalization = true break } } if hasLocalization { res.IndexAttrs(append(res.IndexAttrs(), "-LanguageCode")...) } else { res.IndexAttrs(append(res.IndexAttrs(), "-LanguageCode", "Localization")...) } res.ShowAttrs(append(res.ShowAttrs(), "-LanguageCode", "-Localization")...) res.EditAttrs(append(res.EditAttrs(), "-LanguageCode", "-Localization")...) res.NewAttrs(append(res.NewAttrs(), "-LanguageCode", "-Localization")...) } // Set meta permissions for _, field := range Admin.Config.DB.NewScope(res.Value).Fields() { if isSyncField(field.StructField) { if meta := res.GetMeta(field.Name); meta != nil { permission := meta.Permission if permission == nil { permission = roles.Allow(roles.CRUD, "global_admin").Allow(roles.Read, "locale_reader") } else { permission = permission.Allow(roles.CRUD, "global_admin").Allow(roles.Read, "locale_reader") } meta.Permission = permission } else { res.Meta(&admin.Meta{Name: field.Name, Permission: roles.Allow(roles.CRUD, "global_admin").Allow(roles.Read, "locale_reader")}) } } } // Roles role := res.Config.Permission.Role if _, ok := role.Get("locale_admin"); !ok { role.Register("locale_admin", func(req *http.Request, currentUser qor.CurrentUser) bool { currentLocale := getLocaleFromContext(&qor.Context{Request: req}) for _, locale := range getEditableLocales(req, currentUser) { if locale == currentLocale { return true } } return false }) } if _, ok := role.Get("global_admin"); !ok { role.Register("global_admin", func(req *http.Request, currentUser qor.CurrentUser) bool { return getLocaleFromContext(&qor.Context{Request: req}) == Global }) } if _, ok := role.Get("locale_reader"); !ok { role.Register("locale_reader", func(req *http.Request, currentUser qor.CurrentUser) bool { currentLocale := getLocaleFromContext(&qor.Context{Request: req}) for _, locale := range getAvailableLocales(req, currentUser) { if locale == currentLocale { return true } } return false }) } // Inject for l10n if !injected { injected = true for _, gopath := range strings.Split(os.Getenv("GOPATH"), ":") { admin.RegisterViewPath(path.Join(gopath, "src/github.com/qor/qor/l10n/views")) } // Middleware Admin.GetRouter().Use(func(context *admin.Context, middleware *admin.Middleware) { db := context.GetDB().Set("l10n:locale", getLocaleFromContext(context.Context)) if mode := context.Request.URL.Query().Get("locale_mode"); mode != "" { db = db.Set("l10n:mode", mode) } if context.Request.URL.Query().Get("sorting") != "" { db = db.Set("l10n:mode", "locale") } context.SetDB(db) middleware.Next(context) }) // FunMap Admin.RegisterFuncMap("current_locale", func(context admin.Context) string { return getLocaleFromContext(context.Context) }) Admin.RegisterFuncMap("global_locale", func() string { return Global }) Admin.RegisterFuncMap("viewable_locales", func(context admin.Context) []string { return getAvailableLocales(context.Request, context.CurrentUser) }) Admin.RegisterFuncMap("editable_locales", func(context admin.Context) []string { return getEditableLocales(context.Request, context.CurrentUser) }) Admin.RegisterFuncMap("createable_locales", func(context admin.Context) []string { editableLocales := getEditableLocales(context.Request, context.CurrentUser) if _, ok := context.Resource.Value.(localeCreatableInterface); ok { return editableLocales } else { for _, locale := range editableLocales { if locale == Global { return []string{Global} } } } return []string{} }) } }
func (publish *Publish) ConfigureQorResource(res *admin.Resource) { for _, gopath := range strings.Split(os.Getenv("GOPATH"), ":") { admin.RegisterViewPath(path.Join(gopath, "src/github.com/qor/qor/publish/views")) } res.UseTheme("publish") if event := res.GetAdmin().GetResource("PublishEvent"); event == nil { eventResource := res.GetAdmin().AddResource(&PublishEvent{}, &admin.Config{Invisible: true}) eventResource.IndexAttrs("Name", "Description", "CreatedAt") } controller := publishController{publish} router := res.GetAdmin().GetRouter() router.Get(fmt.Sprintf("^/%v/diff/", res.ToParam()), controller.Diff) router.Get(fmt.Sprintf("^/%v", res.ToParam()), controller.Preview) router.Post(fmt.Sprintf("^/%v", res.ToParam()), controller.PublishOrDiscard) res.GetAdmin().RegisterFuncMap("render_publish_meta", func(value interface{}, meta *admin.Meta, context *admin.Context) template.HTML { var err error var result = bytes.NewBufferString("") var tmpl = template.New(meta.Type + ".tmpl").Funcs(context.FuncMap()) if tmpl, err = context.FindTemplate(tmpl, fmt.Sprintf("metas/publish/%v.tmpl", meta.Type)); err != nil { if tmpl, err = context.FindTemplate(tmpl, fmt.Sprintf("metas/index/%v.tmpl", meta.Type)); err != nil { tmpl, _ = tmpl.Parse("{{.Value}}") } } data := map[string]interface{}{"Value": context.ValueOf(value, meta), "Meta": meta} if err := tmpl.Execute(result, data); err != nil { utils.ExitWithMsg(err.Error()) } return template.HTML(result.String()) }) res.GetAdmin().RegisterFuncMap("publish_unique_key", func(res *admin.Resource, record interface{}, context *admin.Context) string { return fmt.Sprintf("%s__%v", res.ToParam(), context.GetDB().NewScope(record).PrimaryKeyValue()) }) res.GetAdmin().RegisterFuncMap("is_publish_event_resource", func(res *admin.Resource) bool { return IsPublishEvent(res.Value) }) }