Пример #1
0
        public DummyPageManagerService()
        {
            dummypages = new List <Page>();
            Page page = new Page();

            page.Id   = 1;
            page.Name = "Kyler";


            ParagraphItem p = new ParagraphItem();

            p.PageId = page.Id;

            p.Id = 1;

            p.time = DateTime.Now;

            p.Title = " A Whole New World";

            p.Content = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut" +
                        " labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ";


            page.ParagraphItems.Add(p);

            dummypages.Add(page);
        }
Пример #2
0
        public async Task <IActionResult> DeleteParagraph([Bind("PageId,Id")] ParagraphItem paragraph)
        {
            _pageManagerService.DeleteParagraph(paragraph);


            var items = _pageManagerService.GetPageList();

            return(View("PagesManager", items));
        }
Пример #3
0
        public async Task <IActionResult> AddParagraph([Bind("Title,Content,PageId")] ParagraphItem paragraph)
        {
            paragraph.time = DateTime.Now;

            _pageManagerService.AddParagraph(paragraph);


            var items = _pageManagerService.GetPageList();

            return(View("PagesManager", items));
        }
Пример #4
0
        /// <summary>
        /// A method that transform a paragraph string to a list of paragraph items with appropriate text format information
        /// </summary>
        /// <param name="paragraph">The text</param>
        /// <param name="italicStrings">A list of strings that should be written with italics</param>
        /// <returns></returns>
        private List <ParagraphItem> GetParagraphItems(String paragraph, List <String> italicStrings)
        {
            List <ParagraphItem> items = new List <ParagraphItem>();

            if (paragraph == "")
            {
                return(items);
            }

            if (italicStrings.IsEmpty())
            {
                ParagraphItem item = new ParagraphItem(paragraph, false);
                items.Add(item);
                return(items);
            }

            Int32 startPos = 0;

            while (startPos < paragraph.Length)
            {
                Int32  minPos         = paragraph.Length;
                Int32  maxPos         = -1;
                String italicItemText = "";
                String normalItemText = "";
                foreach (String italicString in italicStrings)
                {
                    if (italicString.IsNotEmpty())
                    {
                        Int32 pos = paragraph.IndexOf(italicString, startPos);
                        if (pos > maxPos)
                        {
                            maxPos = pos;
                        }
                        if (pos < minPos && pos > -1)
                        {
                            minPos         = pos;
                            italicItemText = italicString;
                        }
                    }
                }
                normalItemText = paragraph.Substring(startPos, minPos - startPos);
                ParagraphItem normalItem = new ParagraphItem(normalItemText, false);
                items.Add(normalItem);
                if (italicItemText != "")
                {
                    ParagraphItem italicItem = new ParagraphItem(italicItemText, true);
                    items.Add(italicItem);
                }
                startPos = startPos + normalItemText.Length + italicItemText.Length;
            }

            return(items);
        }
Пример #5
0
        public bool DeleteParagraph(ParagraphItem item)
        {
            ParagraphItem item1 = _context.ParagraphItems
                                  .Where(pi => pi.Id == item.Id)
                                  .FirstOrDefault();

            _context.Remove(item1);

            _context.SaveChanges();

            return(true);
        }
Пример #6
0
        public bool AddParagraph(ParagraphItem content)
        {
            foreach (var thing in dummypages)
            {
                if (content.PageId == thing.Id)
                {
                    thing.ParagraphItems.Add(content);
                }
            }

            return(true);
        }
        /// <summary>
        /// Converts FB2 poem  author element
        /// </summary>
        /// <param name="paragraphItem">item to convert</param>
        /// <param name="poemAuthorConverterParams"></param>
        /// <returns>XHTML representation</returns>
        public IHTMLItem Convert(ParagraphItem paragraphItem, PoemAuthorConverterParamsV2 poemAuthorConverterParams)
        {
            if (paragraphItem == null)
            {
                throw new ArgumentNullException("paragraphItem");
            }

            var paragraphConverter = new ParagraphConverterV2();
            var item = paragraphConverter.Convert(paragraphItem, new ParagraphConverterParamsV2 {
                ResultType = ParagraphConvTargetEnumV2.Paragraph, StartSection = false, Settings = poemAuthorConverterParams.Settings
            });

            SetClassType(item, ElementStylesV2.PoemAuthor);
            return(item);
        }
Пример #8
0
        /// <summary>
        /// Converts FB2 citation author element
        /// </summary>
        /// <param name="paragraphItem">item to convert</param>
        /// <param name="citationAuthorConverterParams"></param>
        /// <returns>XHTML representation</returns>
        public IHTMLItem Convert(ParagraphItem paragraphItem, CitationAuthorConverterParamsV2 citationAuthorConverterParams)
        {
            if (paragraphItem == null)
            {
                throw new ArgumentNullException("paragraphItem");
            }
            var cite = new Div(HTMLElementType.XHTML11);

            var paragraphConverter = new ParagraphConverterV2();

            cite.Add(paragraphConverter.Convert(paragraphItem,
                                                new ParagraphConverterParamsV2 {
                Settings = citationAuthorConverterParams.Settings, ResultType = ParagraphConvTargetEnumV2.Paragraph, StartSection = false
            }));

            SetClassType(cite, ElementStylesV2.CitationAuthor);
            return(cite);
        }
        /// <summary>
        /// Removes empty paragraphs from the end of Word document.
        /// </summary>
        /// <param name="document">The Word document</param>
        private static void RemoveEmptyPage(WordDocument document)
        {
            WTextBody textBody = document.LastSection.Body;

            //A flag to determine any renderable item found in the Word document.
            bool IsRenderableItem = false;

            //Iterates text body items.
            for (int itemIndex = textBody.ChildEntities.Count - 1; itemIndex >= 0 && !IsRenderableItem; itemIndex--)
            {
                //Check item is empty paragraph and removes it.
                if (textBody.ChildEntities[itemIndex] is WParagraph)
                {
                    WParagraph paragraph = textBody.ChildEntities[itemIndex] as WParagraph;
                    //Iterates into paragraph
                    for (int pIndex = paragraph.Items.Count - 1; pIndex >= 0; pIndex--)
                    {
                        ParagraphItem paragraphItem = paragraph.Items[pIndex];

                        //If page break found in end of document, then remove it to preserve contents in same page
                        if ((paragraphItem is Break && (paragraphItem as Break).BreakType == BreakType.PageBreak))
                        {
                            paragraph.Items.RemoveAt(pIndex);
                        }

                        //Check paragraph contains any renderable items.
                        else if (!(paragraphItem is BookmarkStart || paragraphItem is BookmarkEnd))
                        {
                            IsRenderableItem = true;
                            //Found renderable item and break the iteration.
                            break;
                        }
                    }
                    //Remove empty paragraph and the paragraph with bookmarks only
                    if (paragraph.Items.Count == 0 || !IsRenderableItem)
                    {
                        textBody.ChildEntities.RemoveAt(itemIndex);
                    }
                }
            }
        }
Пример #10
0
 public bool AddParagraph(ParagraphItem content)
 {
     _context.Add(content);
     _context.SaveChangesAsync();
     return(true);
 }
Пример #11
0
        public override object BuildDetail(EntityDTO dto)
        {
            BpmnDetailDTO detail = new BpmnDetailDTO();
            EntityData    data   = new EntityData();

            detail.Title = dto.Name;
            EntityDTO parent = data.GetActivityOverviewParent(dto.ID);

            //TODO:
            detail.RelatedSubprocess = parent.Name;
            detail.User                    = dto.RenderHTML(GlobalStringResource.User, RenderOption.Break);
            detail.ActivityNature          = dto.RenderHTML(GlobalStringResource.ActivityNature, RenderOption.Break);
            detail.TriggerInput            = dto.RenderHTML(GlobalStringResource.TriggerInput, RenderOption.Break);
            detail.Output                  = dto.RenderHTML(GlobalStringResource.Output, RenderOption.Break);
            detail.ActivityStepDescription = dto.RenderHTML(GlobalStringResource.ActivityStepDescription, RenderOption.Break);
            detail.ActivityNarrative       = dto.RenderHTML(GlobalStringResource.ActivityNarrative,
                                                            RenderOption.Break);

            List <EntityDTO> variations = data.GetActivityVariations(dto.ID);

            if (variations.Count > 0)
            {
                foreach (EntityDTO variation in variations)
                {
                    ActivityVariationItem av = new ActivityVariationItem();
                    variation.ExtractProperties();
                    av.ActivityVariation = variation.Name;
                    av.Description       = variation.RenderHTML(GlobalStringResource.Description, RenderOption.Break);
                    detail.ActivityVariations.Add(av);
                }
            }

            List <EntityDTO> mappings = data.GetSubProcessParagraphs(dto.ID);

            if (mappings.Count > 0)
            {
                foreach (EntityDTO map in mappings)
                {
                    ParagraphItem p = new ParagraphItem();
                    map.ExtractProperties();
                    p.ParagraphName = MappingToolUrlHelper.GenerateValidParagraphLinkMarkup(map.Name);
                    p.ParagraphRef  = map.RenderHTMLAsAnchor(GlobalStringResource.ParagraphReference, RenderOption.Span, true);
                    detail.Paragraphs.Add(p);
                }
            }

            List <EntityDTO> useCases = data.GetUseCases(dto.ID);

            if (useCases.Count > 0)
            {
                foreach (EntityDTO useCase in useCases)
                {
                    UseCaseItem uc = new UseCaseItem();
                    useCase.ExtractProperties();
                    uc.UseCaseID   = useCase.Name;
                    uc.Description = useCase.RenderHTML(GlobalStringResource.Description, RenderOption.Break);
                    detail.UseCases.Add(uc);
                }
            }

            List <EntityDTO> requiredData = data.GetRequiredData(dto.ID);

            if (requiredData.Count > 0)
            {
                requiredData.Sort((b1, b2) => string.Compare(b1.Name, b2.Name, true));
                foreach (EntityDTO document in requiredData)
                {
                    RequiredDataItem rq = new RequiredDataItem();
                    document.ExtractProperties();
                    rq.RequiredData = document.Name;
                    rq.Description  = document.RenderHTML(GlobalStringResource.Description, RenderOption.Break);
                    detail.RequiredData.Add(rq);
                }
            }

            List <EntityDTO> sampleReferences = data.GetSampleReference(dto.ID);

            if (sampleReferences.Count > 0)
            {
                foreach (EntityDTO reference in sampleReferences)
                {
                    SampleReferenceItem sr = new SampleReferenceItem();
                    reference.ExtractProperties();
                    sr.SampleReference = reference.Name;
                    sr.Description     = reference.RenderHTML(GlobalStringResource.Description, RenderOption.Break);
                    sr.ReferenceLink   = reference.RenderHTMLAsAnchor(GlobalStringResource.ReferenceLink, RenderOption.Span, true);
                    detail.SampleReferences.Add(sr);
                }
            }
            return(detail);
        }
Пример #12
0
        /// <summary>
        /// Converts FB2 Paragraph to EPUB paragraph
        /// </summary>
        /// <param name="paragraphItem">item to convert</param>
        /// <param name="paragraphConverterParams"></param>
        /// <returns></returns>
        public HTMLItem Convert(ParagraphItem paragraphItem, ParagraphConverterParamsV2 paragraphConverterParams)
        {
            if (paragraphItem == null)
            {
                throw new ArgumentNullException("paragraphItem");
            }
            var  paragraph        = CreateBlock(paragraphConverterParams.ResultType);
            bool needToInsertDrop = paragraphConverterParams.Settings.CapitalDrop && paragraphConverterParams.StartSection;

            foreach (var item in paragraphItem.ParagraphData)
            {
                if (item is SimpleText)
                {
                    var textConverter = new SimpleTextElementConverterV2();
                    foreach (var s in textConverter.Convert(item,
                                                            new SimpleTextElementConverterParamsV2 {
                        Settings = paragraphConverterParams.Settings, NeedToInsertDrop = needToInsertDrop
                    }))
                    {
                        if (needToInsertDrop)
                        {
                            needToInsertDrop = false;
                            SetClassType(paragraph, ElementStylesV2.CapitalDrop);
                        }
                        paragraph.Add(s);
                    }
                }
                else if (item is InlineImageItem)
                {
                    // if no image data - do not insert link
                    if (paragraphConverterParams.Settings.Images.HasRealImages())
                    {
                        var inlineItem = item as InlineImageItem;
                        if (paragraphConverterParams.Settings.Images.IsImageIdReal(inlineItem.HRef))
                        {
                            var inlineImageConverter = new InlineImageConverterV2();
                            paragraph.Add(inlineImageConverter.Convert(inlineItem, new InlineImageConverterParamsV2 {
                                Settings = paragraphConverterParams.Settings
                            }));
                            paragraphConverterParams.Settings.Images.ImageIdUsed(inlineItem.HRef);
                        }
                        if (needToInsertDrop) // in case this is "drop" image - no need to create a drop
                        {
                            needToInsertDrop = false;
                        }
                    }
                }
                else if (item is InternalLinkItem)
                {
                    var internalLinkConverter = new InternalLinkConverterV2();
                    foreach (var s in internalLinkConverter.Convert(item as InternalLinkItem,
                                                                    new InternalLinkConverterParamsV2 {
                        Settings = paragraphConverterParams.Settings, NeedToInsertDrop = needToInsertDrop
                    }))
                    {
                        if (needToInsertDrop)
                        {
                            needToInsertDrop = false;
                            SetClassType(paragraph, ElementStylesV2.CapitalDrop);
                        }
                        paragraph.Add(s);
                    }
                }
            }

            //SetClassType(paragraph);
            paragraph.GlobalAttributes.ID.Value =
                paragraphConverterParams.Settings.ReferencesManager.AddIdUsed(paragraphItem.ID, paragraph);

            return(paragraph);
        }
Пример #13
0
 public bool DeleteParagraph(ParagraphItem item)
 {
     throw new NotImplementedException();
 }