// BaseCurrencyCode retrieves application base currency code
func BaseCurrencyCode(cr config.Reader) (language.Currency, error) {
base, err := cr.GetString(config.Path(PathCurrencyBase))
if config.NotKeyNotFoundError(err) {
return language.Currency{}, err
}
return language.ParseCurrency(base)
}
// WithPasswordFromConfig retrieves the password from the configuration with path
// as defined in constant PathJWTPassword
func WithPasswordFromConfig(cr config.Getter) Option {
pw, err := cr.String(config.Path(PathJWTPassword))
if config.NotKeyNotFoundError(err) {
pw = string(uuid.NewRandom())
}
return WithPassword([]byte(pw))
}
// AllowedCurrencies returns all installed currencies from global scope.
func AllowedCurrencies(cr config.Reader) ([]string, error) {
installedCur, err := cr.GetString(config.Path(PathSystemCurrencyInstalled))
if config.NotKeyNotFoundError(err) {
return nil, err
}
// TODO use internal model of PathSystemCurrencyInstalled defined in package directory
return strings.Split(installedCur, ","), nil
}
// IsSingleStoreMode check if Single-Store mode is enabled in configuration and from Store count < 3.
// This flag only shows that admin does not want to show certain UI components at backend (like store switchers etc)
// if Magento has only one store view but it does not check the store view collection.
func (sm *Service) IsSingleStoreMode() bool {
isEnabled, err := sm.cr.GetBool(config.Path(PathSingleStoreModeEnabled)) // default scope
if config.NotKeyNotFoundError(err) {
// TODO maybe log error here
return false
}
return sm.HasSingleStore() && isEnabled
}
// WithValidateBaseURL is a middleware which checks if the request base URL
// is equal to the one store in the configuration, if not
// i.e. redirect from http://example.com/store/ to http://www.example.com/store/
// @see app/code/Magento/Store/App/FrontController/Plugin/RequestPreprocessor.php
func WithValidateBaseURL(cr config.ReaderPubSuber) ctxhttp.Middleware {
// Having the GetBool command here, means you must restart the app to take
// changes in effect. @todo refactor and use pub/sub to automatically change
// the isRedirectToBase value.
checkBaseURL, err := cr.GetBool(config.Path(PathRedirectToBase)) // scope default
if config.NotKeyNotFoundError(err) && PkgLog.IsDebug() {
PkgLog.Debug("ctxhttp.WithValidateBaseUrl.GetBool", "err", err, "path", PathRedirectToBase)
}
redirectCode := http.StatusMovedPermanently
if rc, err := cr.GetInt(config.Path(PathRedirectToBase)); rc != redirectCode && false == config.NotKeyNotFoundError(err) {
redirectCode = http.StatusFound
}
return func(h ctxhttp.Handler) ctxhttp.Handler {
return ctxhttp.HandlerFunc(func(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
if checkBaseURL && r.Method != "POST" {
_, requestedStore, err := FromContextReader(ctx)
if err != nil {
if PkgLog.IsDebug() {
PkgLog.Debug("ctxhttp.WithValidateBaseUrl.FromContextServiceReader", "err", err, "ctx", ctx)
}
return errgo.Mask(err)
}
baseURL, err := requestedStore.BaseURL(config.URLTypeWeb, requestedStore.IsCurrentlySecure(r))
if err != nil {
if PkgLog.IsDebug() {
PkgLog.Debug("ctxhttp.WithValidateBaseUrl.requestedStore.BaseURL", "err", err, "ctx", ctx)
}
return errgo.Mask(err)
}
if err := httputils.IsBaseURLCorrect(r, &baseURL); err != nil {
if PkgLog.IsDebug() {
PkgLog.Debug("store.WithValidateBaseUrl.IsBaseUrlCorrect.error", "err", err, "baseURL", baseURL, "request", r)
}
baseURL.Path = r.URL.Path
baseURL.RawPath = r.URL.RawPath
baseURL.RawQuery = r.URL.RawQuery
baseURL.Fragment = r.URL.Fragment
http.Redirect(w, r, (&baseURL).String(), redirectCode)
return nil
}
}
return h.ServeHTTPContext(ctx, w, r)
})
}
}
// BaseURL returns a parsed and maybe cached URL from config.ScopedReader.
// It returns a copy of url.URL or an error. Possible URLTypes are:
// - config.URLTypeWeb
// - config.URLTypeStatic
// - config.URLTypeMedia
func (s *Store) BaseURL(ut config.URLType, isSecure bool) (url.URL, error) {
switch isSecure {
case true:
if pu := s.urlcache.secure.Get(ut); pu != nil {
return *pu, nil
}
case false:
if pu := s.urlcache.unsecure.Get(ut); pu != nil {
return *pu, nil
}
}
var p model.BaseURL
switch ut {
case config.URLTypeWeb:
p = backend.Backend.WebUnsecureBaseURL
if isSecure {
p = backend.Backend.WebSecureBaseURL
}
break
case config.URLTypeStatic:
p = backend.Backend.WebUnsecureBaseStaticURL
if isSecure {
p = backend.Backend.WebSecureBaseStaticURL
}
break
case config.URLTypeMedia:
p = backend.Backend.WebUnsecureBaseMediaURL
if isSecure {
p = backend.Backend.WebSecureBaseMediaURL
}
break
case config.URLTypeAbsent: // hack to clear the cache :-( refactor that
_ = s.urlcache.unsecure.Clear()
return url.URL{}, s.urlcache.secure.Clear()
// TODO(cs) rethink that here and maybe add the other paths if needed.
default:
return url.URL{}, fmt.Errorf("Unsupported UrlType: %d", ut)
}
rawURL := p.Get(s.Config)
if strings.Contains(rawURL, model.PlaceholderBaseURL) {
// TODO(cs) replace placeholder with \Magento\Framework\App\Request\Http::getDistroBaseUrl()
// getDistroBaseUrl will be generated from the $_SERVER variable,
base, err := s.cr.String(config.Path(config.PathCSBaseURL))
if config.NotKeyNotFoundError(err) {
PkgLog.Debug("store.Store.BaseURL.String", "err", err, "path", config.PathCSBaseURL)
base = config.CSBaseURL
}
rawURL = strings.Replace(rawURL, model.PlaceholderBaseURL, base, 1)
}
rawURL = strings.TrimRight(rawURL, "/") + "/"
if isSecure {
retURL, retErr := s.urlcache.secure.Set(ut, rawURL)
return *retURL, retErr
}
retURL, retErr := s.urlcache.unsecure.Set(ut, rawURL)
return *retURL, retErr
}
