Exemple #1
0
        public async Task <List <CategorySummaryModel> > MapCategorySummaryModelAsync(IEnumerable <Category> categories, int thumbSize)
        {
            Guard.NotNull(categories, nameof(categories));

            var fileIds = categories
                          .Select(x => x.MediaFileId ?? 0)
                          .Where(x => x != 0)
                          .Distinct()
                          .ToArray();

            var files = (await _mediaService.GetFilesByIdsAsync(fileIds)).ToDictionarySafe(x => x.Id);

            return(await categories
                   .SelectAsync(async c =>
            {
                var name = c.GetLocalized(y => y.Name);
                var model = new CategorySummaryModel
                {
                    Id = c.Id,
                    Name = name
                };

                _services.DisplayControl.Announce(c);

                // Generate URL.
                if (c.ExternalLink.HasValue())
                {
                    var link = await _linkResolver.ResolveAsync(c.ExternalLink);
                    if (link.Status == LinkStatus.Ok)
                    {
                        model.Url = link.Link;
                    }
                }

                if (model.Url.IsEmpty())
                {
                    model.Url = _urlHelper.RouteUrl(nameof(Category), new { SeName = c.GetActiveSlug() });
                }

                files.TryGetValue(c.MediaFileId ?? 0, out var file);

                model.Image = new ImageModel
                {
                    File = file,
                    ThumbSize = thumbSize,
                    Title = file?.File?.GetLocalized(x => x.Title)?.Value.NullEmpty() ?? string.Format(T("Media.Category.ImageLinkTitleFormat"), name),
                    Alt = file?.File?.GetLocalized(x => x.Alt)?.Value.NullEmpty() ?? string.Format(T("Media.Category.ImageAlternateTextFormat"), name),
                    NoFallback = _catalogSettings.HideCategoryDefaultPictures
                };

                _services.DisplayControl.Announce(file?.File);

                return model;
            })
                   .AsyncToList());
        }
Exemple #2
0
        protected override async Task ApplyLinkAsync(MenuItemProviderRequest request, TreeNode <MenuItem> node)
        {
            // Always resolve against current store, current customer and working language.
            var result = await _linkResolver.ResolveAsync(request.Entity.Model);

            var item = node.Value;

            item.Url     = result.Link;
            item.ImageId = result.PictureId;

            if (item.Text.IsEmpty())
            {
                item.Text = result.Label;
            }

            switch (result.Type)
            {
            case LinkType.Product:
            case LinkType.Category:
            case LinkType.Manufacturer:
            case LinkType.Topic:
                if (request.IsEditMode)
                {
                    // Info: node.Value.EntityId is MenuItemRecord.Id for editing MenuItemRecord.
                }
                else
                {
                    item.EntityId   = result.Id;
                    item.EntityName = result.Type.ToString();
                }
                break;
            }

            if (request.IsEditMode)
            {
                var info = result.Type.GetLinkTypeInfo();
                item.Summary = T(info.ResKey);
                item.Icon    = info.Icon;

                if (item.Url.IsEmpty())
                {
                    item.Text   = null;
                    item.ResKey = "Admin.ContentManagement.Menus.SpecifyLinkTarget";
                }
            }
            else
            {
                // For edit mode, only apply MenuItemRecord.Published.
                item.Visible = result.Status == LinkStatus.Ok;
            }
        }
Exemple #3
0
        public async Task <IActionResult> Edit(int id)
        {
            var topic = await _db.Topics.FindByIdAsync(id, false);

            if (topic == null)
            {
                return(RedirectToAction("List"));
            }

            var model = await MapperFactory.MapAsync <Topic, TopicModel>(topic);

            await PrepareTopicModelAsync(topic, model);

            model.WidgetZone = topic.WidgetZone.SplitSafe(",").ToArray();
            model.CookieType = (int?)topic.CookieType;

            AddLocales(model.Locales, async(locale, languageId) =>
            {
                locale.ShortTitle      = topic.GetLocalized(x => x.ShortTitle, languageId, false, false);
                locale.Title           = topic.GetLocalized(x => x.Title, languageId, false, false);
                locale.Intro           = topic.GetLocalized(x => x.Intro, languageId, false, false);
                locale.Body            = topic.GetLocalized(x => x.Body, languageId, false, false);
                locale.MetaKeywords    = topic.GetLocalized(x => x.MetaKeywords, languageId, false, false);
                locale.MetaDescription = topic.GetLocalized(x => x.MetaDescription, languageId, false, false);
                locale.MetaTitle       = topic.GetLocalized(x => x.MetaTitle, languageId, false, false);
                locale.SeName          = await topic.GetActiveSlugAsync(languageId, false, false);
            });

            // Get menu links.
            IPagedList <MenuEntity> menus = null;
            var pageIndex = 0;

            do
            {
                menus = await _db.Menus
                        .ApplyStandardFilter(true)
                        .ToPagedList(pageIndex++, 500)
                        .LoadAsync();

                foreach (var menu in menus)
                {
                    foreach (var item in menu.Items.Where(x => x.ProviderName != null && x.ProviderName == "entity"))
                    {
                        var link = await _linkResolver.ResolveAsync(item.Model);

                        if (link.Type == LinkType.Topic && link.Id == topic.Id)
                        {
                            var url = Url.Action("EditItem", "Menu", new { id = item.Id, area = "Admin" });

                            var label = string.Concat(
                                menu.Title.NullEmpty() ?? menu.SystemName.NullEmpty() ?? "".NaIfEmpty(),
                                " » ",
                                item.Title.NullEmpty() ?? link.Label.NullEmpty() ?? "".NaIfEmpty());

                            model.MenuLinks[url] = label;
                        }
                    }
                }
            }while (menus.HasNextPage);

            return(View(model));
        }
Exemple #4
0
        private async Task <Tuple <TreeNode <MenuItem>, int> > ConvertNodeAsync(
            MenuItemProviderRequest request,
            TreeNode <ICategoryNode> categoryNode,
            int randomId)
        {
            var node = categoryNode.Value;
            var name = node.Id > 0 ? node.GetLocalized(x => x.Name) : null;

            var menuItem = new MenuItem
            {
                Id         = randomId++.ToString(),
                EntityId   = node.Id,
                EntityName = nameof(Category),
                MenuItemId = request.Entity.Id,
                Text       = name?.Value ?? node.Name,
                Rtl        = name?.CurrentLanguage?.Rtl ?? false,
                BadgeText  = node.Id > 0 ? node.GetLocalized(x => x.BadgeText) : null,
                BadgeStyle = node.BadgeStyle,
                RouteName  = node.Id > 0 ? "Category" : "HomePage",
                ImageId    = node.MediaFileId
            };

            // Handle external link
            if (node.ExternalLink.HasValue())
            {
                var link = await _linkResolver.ResolveAsync(node.ExternalLink);

                if (link.Status == LinkStatus.Ok)
                {
                    menuItem.Url = link.Link;
                }
            }

            if (menuItem.Url.IsEmpty())
            {
                if (node.Id > 0)
                {
                    menuItem.RouteName = "Category";
                    menuItem.RouteValues.Add("SeName", await node.GetActiveSlugAsync());
                }
                else
                {
                    menuItem.RouteName = "Homepage";
                }
            }

            // Picture
            if (node.Id > 0 && node.ParentCategoryId == 0 && node.Published && node.MediaFileId != null)
            {
                menuItem.ImageId = node.MediaFileId;
            }

            // Apply inheritable properties.
            menuItem.Visible         = request.Entity.Published;
            menuItem.PermissionNames = request.Entity.PermissionNames;

            if (request.Entity.NoFollow)
            {
                menuItem.LinkHtmlAttributes.Add("rel", "nofollow");
            }

            if (request.Entity.NewWindow)
            {
                menuItem.LinkHtmlAttributes.Add("target", "_blank");
            }

            var convertedNode = new TreeNode <MenuItem>(menuItem)
            {
                Id = categoryNode.Id
            };

            if (categoryNode.HasChildren)
            {
                foreach (var childNode in categoryNode.Children)
                {
                    var tuple = await ConvertNodeAsync(request, childNode, randomId);

                    convertedNode.Append(tuple.Item1);
                    randomId = tuple.Item2;
                }
            }

            return(new Tuple <TreeNode <MenuItem>, int>(convertedNode, randomId));
        }