Beispiel #1
0
        private static IEnumerable <Vertical> OrdinarySlideToVerticals(string courseId, Slide slide, string slideUrl, string solutionsUrl, Dictionary <string, string> videoGuids, string ltiId)
        {
            var componentIndex = 0;
            var components     = new List <Component>();

            while (componentIndex < slide.Blocks.Length)
            {
                var blocks = slide.Blocks.Skip(componentIndex).TakeWhile(x => !(x is YoutubeBlock) && !(x is ExerciseBlock)).ToList();
                if (blocks.Count != 0)
                {
                    var innerComponents = new List <Component>();
                    foreach (var block in blocks)
                    {
                        var component = block.ToEdxComponent("", slide, componentIndex);
                        innerComponents.Add(component);
                        componentIndex++;
                    }

                    var displayName    = componentIndex == blocks.Count ? slide.Title : "";
                    var header         = displayName == "" ? "" : "<h2>" + displayName + "</h2>";
                    var slideComponent = new HtmlComponent
                    {
                        DisplayName   = displayName,
                        UrlName       = slide.Guid + componentIndex,
                        Filename      = slide.Guid + componentIndex,
                        Source        = header + string.Join("", innerComponents.Select(x => x.AsHtmlString())),
                        Subcomponents = innerComponents.ToArray()
                    };
                    components.Add(slideComponent);
                }
                if (componentIndex >= slide.Blocks.Length)
                {
                    break;
                }

                var exerciseBlock  = slide.Blocks[componentIndex] as ExerciseBlock;
                var otherComponent = exerciseBlock != null
                                        ? exerciseBlock.GetExerciseComponent(componentIndex == 0?slide.Title : "”пражнение", slide, componentIndex, string.Format(slideUrl, courseId, slide.Index), ltiId)
                                     : ((YoutubeBlock)slide.Blocks[componentIndex]).GetVideoComponent(componentIndex == 0 ? slide.Title : "", slide, componentIndex, videoGuids);

                components.Add(otherComponent);
                componentIndex++;
            }

            var solutionComponents = new List <Component>();

            foreach (var result in slide.Blocks.OfType <ExerciseBlock>())
            {
                var comp = result.GetSolutionsComponent("–ешени¤", slide, componentIndex, string.Format(solutionsUrl, courseId, slide.Index), ltiId);
                solutionComponents.Add(comp);
                componentIndex++;
            }

            yield return(new Vertical(slide.Guid, slide.Title, components.ToArray()));

            if (solutionComponents.Count != 0)
            {
                yield return(new Vertical(slide.Guid + "0", "–ешени¤", solutionComponents.ToArray()));
            }
        }
Beispiel #2
0
        /// <summary>
        /// Creates a Bootstrap icon
        /// </summary>
        /// <param name="icon">Icon to be created</param>
        /// <param name="htmlAttributes">[Optional] Any extra HTML attributes</param>
        /// <returns>A Bootstrap icon</returns>
        public static IHtmlComponent CreateIcon(EBootstrapIcon icon, object htmlAttributes = null)
        {
            NameValueCollection htmlAttribs = WebExtrasUtil.AnonymousObjectToHtmlAttributes(htmlAttributes);

            List <string> cssClasses = new List <string>();

            if (htmlAttribs.ContainsKey("class"))
            {
                cssClasses.AddRange(htmlAttribs["class"].Split(' '));
                htmlAttribs.Remove("class");
            }

            switch (WebExtrasSettings.BootstrapVersion)
            {
            case EBootstrapVersion.V2:
                cssClasses.Add("icon-" + icon.ToString().ToLowerInvariant().Replace("_", "-"));
                break;

            case EBootstrapVersion.V3:
                cssClasses.Add("glyphicon glyphicon-" + icon.ToString().ToLowerInvariant().Replace("_", "-"));
                break;

            default:
                throw new BootstrapVersionException();
            }

            HtmlComponent i = new HtmlComponent(EHtmlTag.I);

            i.CssClasses.AddRange(cssClasses);
            return(i);
        }
Beispiel #3
0
        /// <summary>
        /// Create special buttons
        /// </summary>
        /// <typeparam name="T">Generic type to be used. This type must implement IExtendedHtmlString</typeparam>
        /// <param name="html">Current HTML element</param>
        /// <param name="type">Gumby button type</param>
        /// <param name="sizeOrstyle">Gumby button size/style</param>
        /// <returns>A Gumby button styled hyperlink</returns>
        /// <exception cref="GumbyThemeException">Thrown when a valid Gumby framework
        /// theme is not selected</exception>
        public static IExtendedHtmlString AsButton <T>(this T html, EGumbyButton type, params EGumbyButtonStyle[] sizeOrstyle) where T : IExtendedHtmlString
        {
            if (WebExtrasSettings.GumbyTheme == EGumbyTheme.None)
            {
                throw new GumbyThemeException();
            }

            if (!WebExtrasMvcUtil.CanDisplayAsButton(html))
            {
                throw new InvalidUsageException("The AsButton decorator can only be used with Button and Hyperlink extensions");
            }

            List <string> classes = new List <string>
            {
                "btn",
                type.ToString().ToLowerInvariant()
            };

            // if a style was specified then don't add the theme class
            EGumbyButtonStyle[] styles =
            {
                EGumbyButtonStyle.Oval,
                EGumbyButtonStyle.Rounded,
                EGumbyButtonStyle.Squared,
                EGumbyButtonStyle.Pill_Left,
                EGumbyButtonStyle.Pill_Right
            };

            int styleCnt = sizeOrstyle.Where(styles.Contains).Count();

            if (styleCnt == 0)
            {
                classes.Add(WebExtrasSettings.GumbyTheme.ToString().ToLowerInvariant());
            }

            // if no size was specified set as medium
            EGumbyButtonStyle[] sizes =
            {
                EGumbyButtonStyle.XLarge,
                EGumbyButtonStyle.Large,
                EGumbyButtonStyle.Medium,
                EGumbyButtonStyle.Small
            };

            int sizeCnt = sizeOrstyle.Where(sizes.Contains).Count();

            if (sizeCnt == 0)
            {
                classes.Add("medium");
            }

            HtmlComponent div = new HtmlComponent(EHtmlTag.Div);

            div.Attributes["class"] = string.Join(" ", classes
                                                  .Concat(sizeOrstyle.Select(s => s.ToString().ToLowerInvariant().Replace('_', '-'))));

            div.AppendTags.Add(html.Component);

            return(new ExtendedHtmlString(div));
        }
        public ActionResult AddOrEdit(HtmlComponentViewModel comp)
        {
            using (var db = new GenerateHtmlDbContext())
            {
                if (comp.Id == 0)
                {
                    var obj = new HtmlComponent
                    {
                        Name = comp.Name
                    };
                    db.HtmlComponents.Add(obj);
                    db.SaveChanges();
                    return(Json(new { success = true, message = "Saved successfully!!!" }, JsonRequestBehavior.AllowGet));
                }
                else
                {
                    var obj = new HtmlComponent
                    {
                        Name = comp.Name
                    };


                    db.Entry(obj).State = EntityState.Modified;
                    db.SaveChanges();
                    return(Json(new { success = true, message = "Updated successfully!!!" }, JsonRequestBehavior.AllowGet));
                }
            }
        }
Beispiel #5
0
        public HtmlComponent addElement()
        {
            var comp = new HtmlComponent();

            elements.Add(comp);
            return(comp);
        }
Beispiel #6
0
        /// <summary>
        ///   Create a label with the required field asterix
        /// </summary>
        /// <typeparam name="TModel">Type to be scanned</typeparam>
        /// <typeparam name="TValue">Property to be scanned</typeparam>
        /// <param name="html">Htmlhelper extension</param>
        /// <param name="expression">The property lamba expression</param>
        /// <param name="labelText">Label text to be shown</param>
        /// <param name="htmlAttributes">[Optional] Extra html attributes</param>
        /// <returns>A label with the required field asterix</returns>
        public static IExtendedHtmlString RequiredFieldLabelFor <TModel, TValue>(this HtmlHelpers <TModel> html,
                                                                                 Expression <Func <TModel, TValue> > expression, string labelText, object htmlAttributes = null)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            MemberExpression exp = expression.Body as MemberExpression;

            if (exp == null)
            {
                throw new ArgumentException("Unable to parse property lambda expression", "expression");
            }

            HtmlComponent label = new HtmlComponent(EHtmlTag.Label, htmlAttributes);

            label.Attributes["id"]   = WebExtrasUtil.GetFieldIdFromExpression(exp);
            label.Attributes["name"] = WebExtrasUtil.GetFieldNameFromExpression(exp);
            label.InnerHtml          = labelText;

            if (exp.Member.GetCustomAttributes(typeof(RequiredAttribute), true).Any())
            {
                HtmlComponent span = new HtmlComponent(EHtmlTag.Span);
                span.CssClasses.Add("required");
                span.InnerHtml = " *";

                label.AppendTags.Add(span);
            }

            return(new ExtendedHtmlString(label));
        }
        /// <summary>
        ///   Create bootstrap 3 tags
        /// </summary>
        /// <param name="htmlAttributes">Extra HTML attributes</param>
        private void CreateBootstrap3Tags(object htmlAttributes)
        {
            var defaultAttribs = new Dictionary <string, string>
            {
                { "type", "text" },
                { "id", WebExtrasUtil.GetFieldIdFromExpression(m_propertyExpression) },
                { "name", WebExtrasUtil.GetFieldNameFromExpression(m_propertyExpression) }
            };

            DataTypeAttribute[] customAttribs =
                (DataTypeAttribute[])m_propertyExpression.Member.GetCustomAttributes(typeof(DataTypeAttribute), false);
            if (customAttribs.Length > 0)
            {
                switch (customAttribs[0].DataType)
                {
                case DataType.EmailAddress:
                    defaultAttribs["type"] = "email";
                    break;

                case DataType.Password:
                    defaultAttribs["type"] = "password";
                    break;

                case DataType.MultilineText:
                    defaultAttribs["type"] = "textarea";
                    break;
                }
            }

            Dictionary <string, string> attribs = WebExtrasUtil
                                                  .AnonymousObjectToHtmlAttributes(htmlAttributes)
                                                  .ToDictionary()
                                                  .Merge(defaultAttribs)
                                                  .ToDictionary(k => k.Key, v => v.Value);

            HtmlComponent input;

            if (m_selectListItems != null)
            {
                input = new HtmlSelect(m_selectListItems, attribs);
            }
            else if (m_textAreaDimensions != null || attribs.ContainsValue("textarea"))
            {
                attribs.Remove("type");

                input = new HtmlComponent(EHtmlTag.TextArea, attribs);
            }
            else
            {
                input = new HtmlComponent(EHtmlTag.Input, attribs);
            }

            input.CssClasses.Add("form-control");

            Input      = input;
            InputGroup = new HtmlComponent(EHtmlTag.Div);
            InputGroup.CssClasses.Add("input-group");
            InputGroup.AppendTags.Add(input);
        }
Beispiel #8
0
        /// <summary>
        ///   Creates an alert
        /// </summary>
        /// <param name="type">Type of alert</param>
        /// <param name="message">Alert message</param>
        /// <param name="title">Title/Heading of the alert</param>
        /// <param name="icon">Icon to be rendered with title/heading</param>
        private void CreateAlert(EMessage type, string message, string title, IHtmlComponent icon)
        {
            CssClasses.Add(type.GetStringValue());

            HtmlComponent bc = new HtmlComponent(EHtmlTag.B)
            {
                InnerHtml = title ?? string.Empty
            };

            if (icon != null)
            {
                bc.PrependTags.Add(icon);
            }

            if (WebExtrasSettings.CssFramework != ECssFramework.JQueryUI)
            {
                CssClasses.Add("alert");

                Button closeBtn = new Button(EButton.Regular, "&times;", string.Empty);
                closeBtn.CssClasses.Add("close");
                closeBtn.Attributes["data-dismiss"] = "alert";

                PrependTags.Add(closeBtn);
                PrependTags.Add(bc);
                InnerHtml = (!string.IsNullOrWhiteSpace(title) || icon != null)
          ? WebExtrasSettings.HTMLSpace + message
          : message;
            }
            else
            {
                HtmlComponent div = new HtmlComponent(EHtmlTag.Div);

                switch (type)
                {
                case EMessage.Error:
                    div.CssClasses.Add("ui-state-error");
                    break;

                case EMessage.Information:
                case EMessage.Warning:
                    div.CssClasses.Add("ui-state-highlight");
                    break;

                case EMessage.Success:
                    div.CssClasses.Add("ui-state-success");
                    break;
                }

                div.CssClasses.Add("ui-corner-all");
                div.PrependTags.Add(bc);
                div.InnerHtml = (!string.IsNullOrWhiteSpace(title) || icon != null)
          ? WebExtrasSettings.HTMLSpace + message
          : message;

                PrependTags.Add(div);
            }

            Type = type;
        }
        IRegionDefinition IRegionDefinition.Html(string textAssetName, string defaultHtml)
        {
            var htmlComponent = new HtmlComponent(_componentDependenciesFactory);

            htmlComponent.Html(textAssetName, defaultHtml);
            _region.Content = htmlComponent;

            return(this);
        }
Beispiel #10
0
        ILayoutDefinition ILayoutDefinition.Html(string zoneName, string textAssetName, string defaultHtml)
        {
            var htmlComponent = new HtmlComponent(_componentDependenciesFactory);

            htmlComponent.Html(textAssetName, defaultHtml);
            _regionComponents[zoneName] = htmlComponent;

            return(this);
        }
        /// <summary>
        /// Renders a JQuery UI icon
        /// </summary>
        /// <param name="html">Current Html helper object</param>
        /// <param name="icon">JQuery UI icon</param>
        /// <param name="type">JQUery UI icon type</param>
        /// <param name="htmlAttributes">[Optional] Extra HTML attributes</param>
        /// <returns>A JQuery UI icon</returns>
        public static IExtendedHtmlString Icon(this HtmlHelper html, EJQueryUIIcon icon, EJQueryUIIconType type, object htmlAttributes = null)
        {
            HtmlComponent span = new HtmlComponent(EHtmlTag.Span, htmlAttributes);

            span.CssClasses.Add("ui-icon");
            span.CssClasses.Add(string.Format("ui-icon-{0}", icon.ToString().ToLowerInvariant().Replace("_", "-")));
            span.CssClasses.Add(type.GetStringValue());

            return(new ExtendedHtmlString(span));
        }
Beispiel #12
0
        /// <summary>
        /// Add an icon
        /// </summary>
        /// <typeparam name="T">Generic type to be used. This type must implement IExtendedHtmlString</typeparam>
        /// <param name="html">Current html element</param>
        /// <param name="icon">Icon to be rendered</param>
        /// <param name="htmlAttributes">[Optional] Extra html attributes</param>
        /// <returns>Html element with icon added</returns>
        public static T AddIcon <T>(this T html, EJQueryUIIcon icon, object htmlAttributes = null) where T : IExtendedHtmlString
        {
            HtmlComponent span = new HtmlComponent(EHtmlTag.Span, htmlAttributes);

            span.CssClasses.Add("ui-icon");
            span.CssClasses.Add(string.Format("ui-icon-{0}", icon.ToString().ToLowerInvariant().Replace("_", "-")));

            html.Component.PrependTags.Add(span);

            return(html);
        }
Beispiel #13
0
        /// <summary>
        ///   Creates a HTML hyperlink from given text and URL
        /// </summary>
        /// <param name="html">Current html helper object</param>
        /// <param name="linkText">Link text</param>
        /// <param name="url">Link URL</param>
        /// <param name="htmlAttributes">[Optional] Extra HTML attributes</param>
        /// <returns>HTML hyperlink</returns>
        public static IExtendedHtmlString Hyperlink(
            this HtmlHelpers html,
            string linkText,
            string url,
            object htmlAttributes = null)
        {
            HtmlComponent a = new HtmlComponent(EHtmlTag.A, htmlAttributes);

            a.Attributes["href"] = url;
            a.InnerHtml          = linkText;

            return(new ExtendedHtmlString(a));
        }
Beispiel #14
0
        /// <summary>
        ///   Creates a button
        /// </summary>
        /// <param name="html">Current HTML helpers</param>
        /// <param name="type">Button type</param>
        /// <param name="text">Button text</param>
        /// <param name="htmlAttributes">[Optional] Any extra html attributes</param>
        /// <returns>A HTML button element</returns>
        public static IExtendedHtmlString Button(this HtmlHelpers html, EButton type, string text, object htmlAttributes = null)
        {
            HtmlComponent component = new HtmlComponent(EHtmlTag.Button, htmlAttributes);

            component.Attributes["type"] = type.GetStringValue();
            component.InnerHtml          = text;

            if (type == EButton.Cancel)
            {
                component.Attributes["onclick"] = "javascript:window.history.back()";
            }

            return(new ExtendedHtmlString(component));
        }
        IPageDefinition IPageDefinition.RegionHtml(string regionName, string textAssetName, string defaultHtml)
        {
            if (string.IsNullOrEmpty(regionName))
            {
                throw new PageBuilderException("You must provide a region name when configuring page regions");
            }

            var component = new HtmlComponent(_componentDependenciesFactory);

            component.Html(textAssetName, defaultHtml);

            _page.PopulateRegion(regionName, component);

            return(this);
        }
Beispiel #16
0
        /// <summary>
        ///   Creates an HTML image
        /// </summary>
        /// <param name="html">Current HTML helper object</param>
        /// <param name="src">Image location</param>
        /// <param name="altText">Image alt text</param>
        /// <param name="title">Image title</param>
        /// <param name="htmlAttributes">[Optional] Extra HTML attributes</param>
        /// <returns>An HTML image</returns>
        public static IExtendedHtmlString Image(
            this HtmlHelpers html,
            string src,
            string altText,
            string title,
            object htmlAttributes = null)
        {
            HtmlComponent img = new HtmlComponent(EHtmlTag.Img, htmlAttributes);

            img.Attributes["src"]   = src;
            img.Attributes["title"] = title;
            img.Attributes["alt"]   = altText;

            return(new ExtendedHtmlString(img));
        }
Beispiel #17
0
        /// <summary>
        /// Creates an icon
        /// </summary>
        /// <param name="icon">Icon to be created</param>
        /// <param name="htmlAttributes">[Optional] Any extras HTML attributes</param>
        /// <returns>A Gumby icon</returns>
        public static IHtmlComponent CreateIcon(EGumbyIcon icon, object htmlAttributes = null)
        {
            NameValueCollection attrsDictionary = WebExtrasUtil.AnonymousObjectToHtmlAttributes(htmlAttributes);

            HtmlComponent i = new HtmlComponent(EHtmlTag.I);

            i.CssClasses.Add("icon-" + icon.ToString().ToLowerInvariant().Replace('_', '-'));

            foreach (string key in attrsDictionary.Keys)
            {
                i.Attributes[key] = attrsDictionary[key];
            }

            return(i);
        }
Beispiel #18
0
        /// <summary>
        /// Add an icon
        /// </summary>
        /// <typeparam name="T">Generic type to be used. This type must implement IExtendedHtmlString</typeparam>
        /// <param name="html">Current HTML element</param>
        /// <param name="icon">Gumby icon to be added</param>
        /// <param name="iconLeft">[Optional] Flag indicating whether to place icon on left. Defaults to true</param>
        /// <returns>HTML element with icon added</returns>
        public static T AddIcon <T>(this T html, EGumbyIcon icon, bool iconLeft = true) where T : IExtendedHtmlString
        {
            HtmlComponent ic = new HtmlComponent(EHtmlTag.I);

            ic.CssClasses.Add(icon.GetStringValue());

            if (iconLeft)
            {
                html.Component.PrependTags.Add(ic);
            }
            else
            {
                html.Component.AppendTags.Add(ic);
            }

            return(html);
        }
Beispiel #19
0
        /// <summary>
        /// Creates a Bootstrap Font-Awesome icon
        /// </summary>
        /// <param name="icon">Icon to be rendered</param>
        /// <param name="size">Icon size</param>
        /// <param name="htmlAttributes">Extra HTML attributes</param>
        /// <returns>A Bootstrap icon</returns>
        /// <exception cref="FontAwesomeVersionException">Thrown when a valid FontAwesome
        /// icon library version is not selected</exception>
        public static IHtmlComponent CreateIcon(EFontAwesomeIcon icon, EFontAwesomeIconSize size = EFontAwesomeIconSize.Normal, object htmlAttributes = null)
        {
            NameValueCollection attrsDictionary = WebExtrasUtil.AnonymousObjectToHtmlAttributes(htmlAttributes);

            List <string> cssClasses = new List <string>();

            if (attrsDictionary.ContainsKey("class"))
            {
                cssClasses.AddRange(attrsDictionary["class"].Split(' '));
                attrsDictionary.Remove("class");
            }

            string prefix;

            switch (WebExtrasSettings.FontAwesomeVersion)
            {
            case EFontAwesomeVersion.V3:
                prefix = "icon-";
                break;

            case EFontAwesomeVersion.V4:
                prefix = "fa fa-";
                break;

            default:
                throw new FontAwesomeVersionException();
            }

            cssClasses.Add(prefix + icon.ToString().ToLowerInvariant().Replace("_", "-"));

            if (size != EFontAwesomeIconSize.Normal)
            {
                cssClasses.Add(prefix + size.GetStringValue());
            }

            HtmlComponent i = new HtmlComponent(EHtmlTag.I);

            i.CssClasses.AddRange(cssClasses);

            foreach (string key in attrsDictionary.Keys)
            {
                i.Attributes[key] = attrsDictionary[key];
            }

            return(i);
        }
Beispiel #20
0
        /// <summary>
        ///   Create a HTML hyperlink with an image
        /// </summary>
        /// <param name="html">Current HTML helper object</param>
        /// <param name="src">Image location</param>
        /// <param name="altText">Image alt text</param>
        /// <param name="title">Image title</param>
        /// <param name="url">Link URL</param>
        /// <param name="htmlAttributes">
        ///   [Optional] Extra html attributes for the image link. By default
        ///   these attributes will be applied to the A tag only.
        /// </param>
        /// <returns>HTML image hyperlink</returns>
        public static IExtendedHtmlString Imagelink(
            this HtmlHelpers html,
            string src,
            string altText,
            string title,
            string url,
            object htmlAttributes = null)
        {
            object linkAttributes = null, imgAttributes = null;

            if (htmlAttributes != null)
            {
                // try to get the html attributes for the link and img
                IDictionary <string, object> attr = htmlAttributes
                                                    .GetType()
                                                    .GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                                    .Select(p => new KeyValuePair <string, object>(p.Name, p.GetValue(htmlAttributes, null)))
                                                    .ToDictionary(k => k.Key, v => v.Value);

                if (attr.ContainsKey("a"))
                {
                    linkAttributes = attr["a"];
                }
                if (attr.ContainsKey("img"))
                {
                    imgAttributes = attr["img"];
                }
            }

            // create <img> tag
            HtmlComponent img = new HtmlComponent(EHtmlTag.Img, imgAttributes);

            img.Attributes["src"]   = src;
            img.Attributes["alt"]   = altText;
            img.Attributes["title"] = title;

            // create <a> tag
            HtmlComponent link = new HtmlComponent(EHtmlTag.A, linkAttributes);

            link.Attributes["href"] = url;
            link.AppendTags.Add(img);

            return(new ExtendedHtmlString(link));
        }
Beispiel #21
0
        /// <summary>
        ///   Convert the current hyperlink to a label
        /// </summary>
        /// <returns>The converted label</returns>
        public IExtendedHtmlString ToLabel()
        {
            HtmlComponent label = new HtmlComponent(EHtmlTag.Label)
            {
                InnerHtml = InnerHtml
            };

            label.AppendTags.AddRange(AppendTags);
            label.PrependTags.AddRange(PrependTags);

            foreach (string key in Attributes.Keys)
            {
                label.Attributes.Add(key, Attributes[key]);
            }

            label.Attributes.Remove("href");
            label.CssClasses.AddRange(CssClasses);

            return(new ExtendedHtmlString(label));
        }
Beispiel #22
0
        /// <summary>
        /// Creates a jQuery UI icon
        /// </summary>
        /// <param name="icon">Icon to be created</param>
        /// <param name="htmlAttributes">[Optional] Any extra HTML attributes</param>
        /// <returns>A jQuery UI icon</returns>
        public static IHtmlComponent CreateIcon(EJQueryUIIcon icon, object htmlAttributes = null)
        {
            NameValueCollection rvd = WebExtrasUtil.AnonymousObjectToHtmlAttributes(htmlAttributes);

            List <string> cssClasses = new List <string>();

            if (rvd.ContainsKey("class"))
            {
                cssClasses.AddRange(rvd["class"].Split(' '));
                rvd.Remove("class");
            }

            cssClasses.Add("ui-icon");
            cssClasses.Add("ui-icon-" + icon.ToString().ToLowerInvariant().Replace("_", "-"));

            HtmlComponent i = new HtmlComponent(EHtmlTag.I);

            i.CssClasses.AddRange(cssClasses);

            return(i);
        }
Beispiel #23
0
        /// <summary>
        ///   Create the Gumby navigation bar
        /// </summary>
        /// <param name="list">Navigation bar items</param>
        private void CreateNavBar(HtmlList list)
        {
            this["class"] = "row navbar metro";

            Component.AppendTags.Add(list);

            // append the logo/brand is it was supplied
            if (Logo == null)
            {
                return;
            }

            HtmlComponent logoDiv = new HtmlComponent(EHtmlTag.Div);

            logoDiv.CssClasses.AddRange(Logo.CssClasses);
            Logo.CssClasses.Clear();

            logoDiv.AppendTags.Add(Logo.Component);

            Component.PrependTags.Add(logoDiv);
        }
Beispiel #24
0
        /// <summary>
        ///   Constructor
        /// </summary>
        /// <param name="type">Progress bar type</param>
        /// <param name="percent">Percentage of completion for the progress bar</param>
        /// <param name="srText">[Optional] Custom text to be displayed in progress bar. Defaults to percentage complete</param>
        /// <param name="htmlAttributes">[Optional] Extra HTML attributes</param>
        public BootstrapProgressBar(EBootstrapProgressBar type, int percent, string srText = null,
                                    object htmlAttributes = null)
            : base(EHtmlTag.Div, htmlAttributes)
        {
            Percent        = percent;
            this["class"] += "progress";

            HtmlComponent inner = new HtmlComponent(EHtmlTag.Div);

            switch (WebExtrasSettings.BootstrapVersion)
            {
            case EBootstrapVersion.None:
                throw new BootstrapVersionException();

            case EBootstrapVersion.V2:
                inner.Attributes["class"] = string.Format("bar bar-{0}", type.ToString().ToLowerInvariant());
                break;

            case EBootstrapVersion.V3:
                inner.Attributes["class"] =
                    string.Format("progress-bar progress-bar-{0}", type.ToString().ToLowerInvariant());
                inner.Attributes["role"]          = "progressbar";
                inner.Attributes["aria-valuenow"] = percent.ToString(CultureInfo.InvariantCulture);
                inner.Attributes["aria-valuemin"] = "0";
                inner.Attributes["aria-valuemax"] = "100";

                HtmlComponent spanInner = new HtmlComponent(EHtmlTag.Span);
                spanInner.InnerHtml           = string.IsNullOrWhiteSpace(srText) ? percent + "% Complete" : srText;
                spanInner.Attributes["class"] = "sr-only";

                inner.AppendTags.Add(spanInner);
                break;
            }

            Component.AppendTags.Add(inner);

            //this.m_tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }
        /// <summary>
        ///   Add an icon
        /// </summary>
        /// <typeparam name="T">Generic type to be used. This type must implement IExtendedHtmlString</typeparam>
        /// <param name="html">Current html element</param>
        /// <param name="cssClasses">Css classes to be added</param>
        /// <param name="htmlAttributes">[Optional] Extra html attributes</param>
        /// <returns>Html element with icon added</returns>
        private static T AddIcon <T>(T html, IEnumerable <string> cssClasses, object htmlAttributes = null)
            where T : IExtendedHtmlString
        {
            IDictionary <string, object> rvd = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);

            List <string> finalClasses = new List <string>(cssClasses)
            {
                "wb-ext-addicon"
            };

            if (rvd.ContainsKey("class"))
            {
                finalClasses.AddRange(rvd["class"].ToString().Split(' '));
                rvd.Remove("class");
            }

            HtmlComponent i = new HtmlComponent(EHtmlTag.I);

            i.CssClasses.AddRange(finalClasses);

            foreach (string key in rvd.Keys)
            {
                i.Attributes[key] = rvd[key].ToString();
            }

            html.Component.PrependTags.Add(i);

            if (html.Component.Attributes.ContainsKey("style"))
            {
                html.Component.Attributes["style"] += ";text-decoration:none";
            }
            else
            {
                html.Component.Attributes["style"] = "text-decoration:none";
            }

            return(html);
        }
        /// <summary>
        ///   Creates the add on
        /// </summary>
        /// <param name="data">The html to be added in the addon</param>
        /// <param name="append">Whether we are appending the addon or prepending the addon</param>
        /// <returns>The updated form control</returns>
        private IFormComponent <TModel, TValue> CreateAddOn(string data, bool append = true)
        {
            HtmlComponent e = new HtmlComponent(WebExtrasSettings.DefaultTagForTextEncapsulation);

            e.CssClasses.Add("input-group-addon");
            e.InnerHtml = data;

            if (append)
            {
                InputGroup.AppendTags.Add(e);
            }
            else
            {
                InputGroup.PrependTags.Add(e);
            }

            HtmlComponent lbl = new HtmlComponent(EHtmlTag.Label);

            lbl.Attributes["for"] = Input.Attributes["name"];

            string html = Label != null ? Label.InnerHtml : string.Empty;

            if (append)
            {
                html += data;
            }
            else
            {
                html = data + html;
            }

            lbl.InnerHtml = html;

            Label = lbl;

            return(this);
        }
        /// <summary>
        ///   Creates a Bootstrap navigation bar from the given
        ///   list of items
        /// </summary>
        /// <param name="list">Navigation bar items</param>
        private void CreateNavBar(HtmlList list)
        {
            list.Attributes["class"] = "nav navbar-nav";

            Attributes["class"] = Type.GetStringValue();

            switch (WebExtrasSettings.BootstrapVersion)
            {
            case EBootstrapVersion.V2:
                HtmlComponent innerNav = new HtmlComponent(EHtmlTag.Div);

                innerNav.Attributes["class"] = "navbar-inner";

                if (Brand != null)
                {
                    innerNav.PrependTags.Add(Brand.Component);
                }

                innerNav.AppendTags.Add(list);

                AppendTags.Add(innerNav);
                break;

            case EBootstrapVersion.V3:
                if (Brand != null)
                {
                    Brand.Attributes["class"] = "navbar-brand";
                    PrependTags.Add(Brand.Component);
                }

                AppendTags.Add(list);
                break;

            default:
                throw new BootstrapVersionException();
            }
        }
        /// <summary>
        ///   Add an icon
        /// </summary>
        /// <typeparam name="T">Generic type to be used. This type must implement IExtendedHtmlString</typeparam>
        /// <param name="html">Current html element</param>
        /// <param name="cssClasses">Css classes to be added</param>
        /// <param name="htmlAttributes">[Optional] Extra html attributes</param>
        /// <returns>HTML element with icon added</returns>
        private static T AddIcon <T>(T html, IEnumerable <string> cssClasses, object htmlAttributes = null)
            where T : IExtendedHtmlString
        {
            NameValueCollection rvd = WebExtrasUtil.AnonymousObjectToHtmlAttributes(htmlAttributes);

            List <string> finalClasses = new List <string>(cssClasses);

            if (rvd.ContainsKey("class"))
            {
                finalClasses.AddRange(rvd["class"].Split(' '));
                rvd.Remove("class");
            }

            HtmlComponent i = new HtmlComponent(EHtmlTag.I);

            i.CssClasses.AddRange(finalClasses);

            foreach (string key in rvd.Keys)
            {
                i.Attributes[key] = rvd[key];
            }

            // TODO: remove unnecessary conversion
            html.Component.PrependTags.Add(i);

            if (html.Component.Attributes.ContainsKey("style"))
            {
                html.Component.Attributes["style"] += ";text-decoration:none";
            }
            else
            {
                html.Component.Attributes["style"] = "text-decoration:none";
            }

            return(html);
        }
        /// <summary>
        ///   Creates a Bootstrap date time picker control
        /// </summary>
        /// <typeparam name="TModel">Type to be scanned</typeparam>
        /// <typeparam name="TValue">Property to be scanned</typeparam>
        /// <param name="html">HtmlHelper extension</param>
        /// <param name="expression">The property lamba expression</param>
        /// <param name="options">Date time picker options</param>
        /// <param name="htmlAttributes">Extra HTML attributes to be applied to the text box</param>
        /// <returns>A Bootstrap date time picker control</returns>
        public static IExtendedHtmlStringLegacy DateTimeTextBoxFor <TModel, TValue>(this HtmlHelper <TModel> html,
                                                                                    Expression <Func <TModel, TValue> > expression, PickerOptions options,
                                                                                    object htmlAttributes = (IDictionary <string, object>) null)
        {
            MemberExpression exp = expression.Body as MemberExpression;

            PickerOptions pickerOptions =
                options.GetHashCode() == BootstrapSettings.DateTimePickerOptions.GetHashCode()
          ? options.DeepClone()
          : options;

            pickerOptions = pickerOptions.TryFontAwesomeIcons();

            var model = ((DateTime?)ModelMetadata.FromLambdaExpression(expression, html.ViewData).Model);

            if (model.HasValue && model.Value > DateTime.MinValue)
            {
                pickerOptions.defaultDate = model;
            }

            string fieldId   = WebExtrasUtil.GetFieldIdFromExpression(exp);
            string fieldName = WebExtrasUtil.GetFieldNameFromExpression(exp);

            // create the text box
            HtmlComponent input   = new HtmlComponent(EHtmlTag.Input);
            var           attribs = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes)
                                    .ToDictionary(k => k.Key, v => v.Value.ToString());

            input.Attributes.Add(attribs);
            input.Attributes["type"] = "text";
            input.Attributes["name"] = fieldName;

            if (input.Attributes.ContainsKey("class"))
            {
                input.Attributes["class"] += " form-control";
            }
            else
            {
                input.Attributes["class"] = "form-control";
            }

            // create icon
            HtmlComponent icon = new HtmlComponent(EHtmlTag.I);

            if (WebExtrasSettings.FontAwesomeVersion == EFontAwesomeVersion.V4)
            {
                icon.CssClasses.Add("fa fa-calendar");
            }
            else if (WebExtrasSettings.FontAwesomeVersion == EFontAwesomeVersion.V3)
            {
                icon.CssClasses.Add("icon-calendar");
            }
            else
            {
                icon.CssClasses.Add("glyphicon glyphicon-calendar");
            }

            // create addon
            HtmlComponent addOn = new HtmlComponent(EHtmlTag.Span);

            addOn.CssClasses.Add("input-group-addon");
            addOn.AppendTags.Add(icon);

            // create JSON dictionary of the picker options
            string op = pickerOptions.ToJson(new JsonSerializerSettings {
                NullValueHandling = NullValueHandling.Ignore
            });

            HtmlComponent script = new HtmlComponent(EHtmlTag.Script);

            script.Attributes["type"] = "text/javascript";
            script.InnerHtml          = "$(function(){ $('#" + fieldId + "').datetimepicker(" + op + "); });";

            // create the final component
            IHtmlComponent control;

            if (pickerOptions.useAddonField.Equals(false))
            {
                NullWrapperComponent wrapper = new NullWrapperComponent();

                input.Attributes["id"] = fieldId;
                wrapper.Components.Add(input);

                wrapper.Components.Add(script);

                control = wrapper;
            }
            else
            {
                control = new HtmlComponent(EHtmlTag.Div);
                control.Attributes["id"]    = fieldId;
                control.Attributes["class"] = "input-group date";
                control.AppendTags.Add(input);
                control.AppendTags.Add(addOn);
                control.AppendTags.Add(script);
            }

            return(new HtmlElement(control));
        }
Beispiel #30
0
 public ActionResult AddOrEdit(HtmlComponentViewModel comp, HttpPostedFileBase styleSheetFile, HttpPostedFileBase scriptFile, HttpPostedFileBase imageFile, List <HttpPostedFileBase> mediaFiles)
 {
     try
     {
         using (var db = new GenerateHtmlDbContext())
         {
             ViewBag.Category = db.HtmlComponentCategories.Select(x => new SelectListItem {
                 Value = x.Id.ToString(), Text = x.Name
             }).ToList();
             if (!ModelState.IsValid)
             {
                 return(PartialView("~/Areas/Admin/Views/Home/_form.cshtml", comp));
             }
             if (comp.Id == 0)
             {
                 var obj = new HtmlComponent
                 {
                     Name       = comp.Name,
                     HtmlBody   = comp.HtmlBody,
                     ScriptPath = comp.ScriptPath,
                     CssPath    = comp.CssPath,
                     ImageName  = comp.ImageName,
                     CategoryId = comp.CategoryId
                 };
                 db.HtmlComponents.Add(obj);
                 db.SaveChanges();
                 if (imageFile != null)
                 {
                     var imageFilePath = HandleUploadFile(obj.Id, imageFile, Utils.ImagePath);
                     obj.ImageName = imageFilePath;
                 }
                 if (styleSheetFile != null && Path.GetExtension(styleSheetFile.FileName) == ".css")
                 {
                     var cssFilePath = HandleUploadFile(obj.Id, styleSheetFile, Utils.CssPath);
                     obj.CssPath = cssFilePath;
                 }
                 if (scriptFile != null && Path.GetExtension(scriptFile.FileName) == ".js")
                 {
                     var scriptFilePath = HandleUploadFile(obj.Id, scriptFile, Utils.ScriptsPath);
                     obj.ScriptPath = scriptFilePath;
                 }
                 if (mediaFiles.Any())
                 {
                     HandleMediaImages(obj.Id, mediaFiles);
                 }
                 db.Entry(obj).State = EntityState.Modified;
                 db.SaveChanges();
                 return(Json(new { success = true, message = "Lưu thành công." }, JsonRequestBehavior.AllowGet));
             }
             else
             {
                 var item = db.HtmlComponents.FirstOrDefault(x => x.Id == comp.Id);
                 if (item != null)
                 {
                     item.Name       = comp.Name;
                     item.HtmlBody   = comp.HtmlBody;
                     item.CategoryId = comp.CategoryId;
                     if (imageFile != null)
                     {
                         HandleDeleteFile(comp.ImageName, Utils.ImagePath);
                         var imageFilePath = HandleUploadFile(item.Id, imageFile, Utils.ImagePath);
                         item.ImageName = imageFilePath;
                     }
                     if (styleSheetFile != null && Path.GetExtension(styleSheetFile.FileName) == ".css")
                     {
                         HandleDeleteFile(comp.CssPath, Utils.CssPath);
                         var cssFilePath = HandleUploadFile(item.Id, styleSheetFile, Utils.CssPath);
                         item.CssPath = cssFilePath;
                     }
                     if (scriptFile != null && Path.GetExtension(scriptFile.FileName) == ".js")
                     {
                         HandleDeleteFile(comp.ScriptPath, Utils.ScriptsPath);
                         var scriptFilePath = HandleUploadFile(item.Id, scriptFile, Utils.ScriptsPath);
                         item.ScriptPath = scriptFilePath;
                     }
                     if (mediaFiles.Any())
                     {
                         HandleMediaImages(item.Id, mediaFiles);
                     }
                     db.Entry(item).State = EntityState.Modified;
                     db.SaveChanges();
                     return(Json(new { success = true, message = "Sửa thành công." }, JsonRequestBehavior.AllowGet));
                 }
                 return(Json(new { success = false, message = "Sửa thất bại" }, JsonRequestBehavior.AllowGet));
             }
         }
     }
     catch (Exception ex)
     {
         return(Json(new { success = false, message = "Sửa thất bại" }, JsonRequestBehavior.AllowGet));
     }
 }