String IMarkupFormatter.Comment(IComment comment)
 {
     return String.Concat(
         IntendBefore(comment.PreviousSibling),
         HtmlMarkupFormatter.Instance.Comment(comment),
         NewLineAfter(comment.NextSibling));
 }
Example #2
0
        public static void ParseComments(IComment message, List<string> comments, TokenReader tr)
        {
            message.Comments = "";
            foreach (string s in comments)
            {
                if (s.StartsWith(":"))
                {
                    try
                    {
                        string line = s.Substring(1);

                        //Remove comments after "//"
                        int cpos = line.IndexOf("//");
                        if (cpos >= 0)
                            line = line.Substring(0, cpos);

                        string[] parts = line.Split('=');
                        if (parts.Length > 2)
                            throw new ProtoFormatException("Bad option format, at most one '=', " + s, tr);
                        string key = parts[0].Trim().ToLowerInvariant();
                        if (parts.Length == 1)
                        {
                            //Parse flag
                            if (message is ProtoMessage)
                                ParseMessageFlags((ProtoMessage)message, key);
                            else if (message is Field)
                                ParseFieldFlags((Field)message, key);
                            else
                                throw new NotImplementedException();

                            continue;
                        }
                        else
                        {
                            string value = (parts.Length == 2) ? parts[1].Trim() : null;

                            if (message is ProtoMessage)
                                ParseMessageOption((ProtoMessage)message, key, value);
                            else if (message is Field)
                                ParseFieldOption((Field)message, key, value);
                            else
                                throw new NotImplementedException();

                            continue;
                        }
                    }
                    catch (Exception e)
                    {
                        throw new ProtoFormatException(e.Message, e, tr);
                    }
                }
                else
                {
                    message.Comments += s + "\n";
                }
            }
            message.Comments = message.Comments.Trim(new char[] { '\n' }).Replace("\n", "\r\n");
            comments.Clear();
        }
 public static string Render(IComment comment)
 {
     using (var writer = new StringWriter())
     {
         Render(comment, writer);
         return writer.ToString();
     }
 }
 public AdminController(std s, Postings p, Filings f, Contactus c, Commenting com)
 {
     studnt = s;
     post = p;
     comment = com;
     file = f;
     cont = c;
 }
Example #5
0
 public MockPost()
 {
     _postsTable = GetMockPosts();
     _commentRepository = new MockComment();
     _tagRepository = new MockTag();
     _categoryRepository = new MockCategory();
     _userRepository = new MockUser();
 }
Example #6
0
 public Post(IUser userRepository, ICategory categoryRepository, ITag tagRepository, IComment commentRepository)
 {
     _postsTable = context.GetTable<PostEntity>();
     _commentRepository = commentRepository;
     _tagRepository = tagRepository;
     _categoryRepository = categoryRepository;
     _userRepository = userRepository;
 }
        /// <summary>
        /// Gets the comment response.
        /// </summary>
        /// <param name="comment">The comment.</param>
        /// <param name="includeSensitiveInformation">if set to <c>true</c> [include sensitive information].</param>
        /// <returns></returns>
        public static CommentResponse GetCommentResponse(IComment comment, bool includeSensitiveInformation = false)
        {
            var commentResponseObject = CommentsUtilitiesReflector.Reflect("GetCommentResponse", comment, includeSensitiveInformation);

            var commentResponse = commentResponseObject as CommentResponse;

            return commentResponse;
        }
Example #8
0
 public CommentController(IPost postRepository, IComment commentsRepository, ISettings settingsRepository, ICacheService cacheService, IError errorLogger)
     : base(settingsRepository)
 {
     _postRepository = postRepository;
     _cacheService = cacheService;
     _commentsRepository = commentsRepository;
     _errorLogger = errorLogger;
 }
 //
 // GET: /Account/
 public AccountController(IUnitOfWork uow, IAccount accountService, ICountry countryService, IProvince provinceService, ICity cityService, IComment commentService)
 {
     _accountService = accountService;
     _countryService = countryService;
     _provinceService = provinceService;
     _cityService = cityService;
     _commentService = commentService;
     _uow = uow;
 }
Example #10
0
 public CommentProcessorPipeline(IComment commentRepository, ISettings settingsRepository, IAkismetService akismetService, IError error, CommentEntity commentEntity, RequestData requestData)
 {
     _commentRepository = commentRepository;
     _settingsRepository = settingsRepository;
     _akismetService = akismetService;
     _error = error;
     _commentEntity = commentEntity;
     _requestData = requestData;
 }
        private void CheckForSingleComments(string lineCheck, IComment comment)
        {
            var result = whiteSpaceHelper.CheckWhiteSpaceAroundCharacter(lineCheck, "'");
            // var result = this.whiteSpaceHelper.NeedWarningForSingleWhiteSpaceAfterKeyword(lineCheck, "//");

            if(result == true)
            {
                comment.AddCodeMarker(WarningId, this, AddSpaceAfterSingleComment, comment);
            }
        }
Example #12
0
 public static IHtmlString Comment(this ApiServices context, IComment comment)
 {
     if (comment != null)
     {
         var writer = new HtmlTextWriter(new StringWriter());
         CommentRenderer.Render(comment, new CommentRendererContext(writer, context));
         return MvcHtmlString.Create(writer.InnerWriter.ToString());
     }
     return MvcHtmlString.Create(string.Empty);
 }
Example #13
0
 public static Comment FromComment(IComment comment)
 {
     Comment t = new Comment
      {
     UserName = comment.UserName,
     Text = comment.Text,
     CreatedOn = comment.CreatedOn,
      };
      return t;
 }
Example #14
0
        public string Format(IComment comment)
        {
            foreach (var step in Formatters)
            {
                if (step.Criteria(comment) == true)
                    return step.Action(comment);
            }

            return null;
        }
Example #15
0
        public CommentAdminController(IPost postRepository, IComment commentRepository, ISettings settingsRepository)
            : base(settingsRepository)
        {
            _postRepository = postRepository;
            _commentRepository = commentRepository;
            ExpectedMasterName = string.Empty;

            _itemsPerPage = settingsRepository.ManageItemsPerPage;

            IsAdminController = true;
        }
Example #16
0
 public static CommentEntity CommentEntity(IComment comment)
 {
     return new CommentEntity()
     {
         Id = comment.Id,
         Description = comment.Description,
         CreatedOn = comment.CreatedOn,
         Reminder = comment.Reminder,
         Author = UserEntity(comment.Author),
         Task = TaskEntity(comment.Task)
     };
 }
Example #17
0
        public AdminController(IPost postRepository, IComment commentRepository, ICategory categoryRepository, ITag tagRepository, ISettings settingsRepository, IPathMapper pathMapper, IUser userRepository)
            : base(settingsRepository)
        {
            _postRepository = postRepository;
            _commentRepository = commentRepository;
            _categoryRepository = categoryRepository;
            _tagRepository = tagRepository;
            _pathMapper = pathMapper;
            _userRepository = userRepository;
            ExpectedMasterName = string.Empty;

            IsAdminController = true;
        }
Example #18
0
        public UserAdminController(IPost postRepository, IComment commentRepository, ICategory categoryRepository, ITag tagRepository, IUser userRepository, ISettings settingsRepository)
            : base(settingsRepository)
        {
            _postRepository = postRepository;
            _commentRepository = commentRepository;
            _categoryRepository = categoryRepository;
            _tagRepository = tagRepository;
            _userRepository = userRepository;
            ExpectedMasterName = string.Empty;

            _itemsPerPage = settingsRepository.ManageItemsPerPage;

            IsAdminController = true;
        }
        public static WorkLogItem ExtractWorkLogItem(IComment comment)
        {
            var hours = int.Parse(HoursRegEx.Match(comment.Body).Value);
            var minutes = int.Parse(MinutesRegEx.Match(comment.Body).Value);
            var day = int.Parse(DayRegEx.Match(comment.Body).Value);
            var month = int.Parse(MonthRegEx.Match(comment.Body).Value);
            var year = int.Parse(YearRegEx.Match(comment.Body).Value);

            return new WorkLogItem
            {
                Date = new DateTime(year, month, day),
                Time = new TimeSpan(0, hours, minutes, 0),
                Creator = comment.Author
            };
        }
 private static void Render(IComment node, TextWriter writer)
 {
     if (node is Summary)
     {
         RenderSummary((Summary)node, writer);
     }
     else if (node is InlineText)
     {
         RenderText((InlineText)node, writer);
     }
     else if (node is ParameterReference)
     {
         RenderParameterReference((ParameterReference)node, writer);
     }
     else
     {
         throw new NotSupportedException();
     }
 }
Example #21
0
        public long AddComment(IComment comment)
        {
            if (!string.IsNullOrEmpty(comment.CommentText))
            {
                var review = new comments
                {
                    text = comment.CommentText,
                    entity_id = comment.MaterialId,
                    parent_id = comment.ParentId,
                    proto_name = comment.ProtoName,
                    account_id = comment.AuthorId,
                    create_date = DateTime.Now
                };

                Insert(review);

                UpdateNestedSets(review.entity_id, review.proto_name, review.parent_id, review.level, review.left_key);

                return review.id;
            }

            return 0;
        }
 public void Add(IComment item)
 {
     _comment.Add(item);
     OnCommentAdded(new CommentEventArgs(item));
 }
Example #23
0
 private string FormatGeneralContainer(IComment comment)
 {
     return FormatChildren(comment.Children);
 }
Example #24
0
 /// <summary>
 /// Submits a comment to Akismet that should have been 
 ///   flagged as SPAM, but was not flagged by Akismet.
 /// </summary>
 /// <param name="comment">
 /// </param>
 public void SubmitSpam(IComment comment)
 {
   this.SubmitComment(comment, this.submitSpamUrl);
 }
Example #25
0
 public void AddComment(IComment comment)
 {
     this.Comments.Add(comment);
 }
Example #26
0
    /// <summary>
    /// Checks the comment and returns true if it is spam, otherwise false.
    /// </summary>
    /// <param name="comment">
    /// </param>
    /// <returns>
    /// The check comment for spam.
    /// </returns>
    /// <exception cref="InvalidResponseException">
    /// Akismet returned an empty response
    /// </exception>
    public bool CheckCommentForSpam(IComment comment)
    {
      CodeContracts.ArgumentNotNull(comment, "comment");

      string result = this.SubmitComment(comment, this.submitCheckUrl);

      if (result.IsNotSet())
      {
        throw new InvalidResponseException("Akismet returned an empty response");
      }

      if (result != "true" && result != "false")
      {
        throw new InvalidResponseException(
          string.Format(
            CultureInfo.InvariantCulture, "Received the response '{0}' from Akismet. Probably a bad API key.", result));
      }

      return bool.Parse(result);
    }
Example #27
0
        /// <summary>
        /// Cell comment Finder.
        /// Returns cell comment for the specified sheet, row and column.
        /// </summary>
        /// <param name="sheet">The sheet.</param>
        /// <param name="row">The row.</param>
        /// <param name="column">The column.</param>
        /// <returns>cell comment or 
        /// <c>null</c>
        ///  if not found</returns>
        public static HSSFComment FindCellComment(InternalSheet sheet, int row, int column)
        {
            HSSFComment comment = null;
            Dictionary<int, TextObjectRecord> noteTxo = new Dictionary<int, TextObjectRecord>(); //map shapeId and TextObjectRecord
            int i = 0;
            for (IEnumerator it = sheet.Records.GetEnumerator(); it.MoveNext(); )
            {
                RecordBase rec = (RecordBase)it.Current;
                if (rec is NoteRecord)
                {
                    NoteRecord note = (NoteRecord)rec;
                    if (note.Row == row && note.Column == column)
                    {
                        if (i < noteTxo.Count)
                        {
                            TextObjectRecord txo = (TextObjectRecord)noteTxo[note.ShapeId];
                            comment = new HSSFComment(note, txo);
                            comment.Row = note.Row;
                            comment.Column = note.Column;
                            comment.Author = note.Author;
                            comment.Visible = (note.Flags == NoteRecord.NOTE_VISIBLE);
                            comment.String = txo.Str;
                            break;
                        }
                    }
                }
                else if (rec is ObjRecord)
                {
                    ObjRecord obj = (ObjRecord)rec;
                    SubRecord sub = obj.SubRecords[0];
                    if (sub is CommonObjectDataSubRecord)
                    {
                        CommonObjectDataSubRecord cmo = (CommonObjectDataSubRecord)sub;
                        if (cmo.ObjectType == CommonObjectType.COMMENT)
                        {
                            //Find the nearest TextObjectRecord which holds comment's text and map it to its shapeId
                            while (it.MoveNext())
                            {
                                rec = (Record)it.Current;
                                if (rec is TextObjectRecord)
                                {
                                    noteTxo.Add(cmo.ObjectId, (TextObjectRecord)rec);
                                    break;
                                }
                            }

                        }
                    }
                }
            }
            return comment;
        }
Example #28
0
        /// <summary>
        /// Removes the comment for this cell, if
        /// there is one.
        /// </summary>
        /// <remarks>WARNING - some versions of excel will loose
        /// all comments after performing this action!</remarks>
        public void RemoveCellComment()
        {
            HSSFComment comment = FindCellComment(sheet.Sheet, record.Row, record.Column);
            this.comment = null;

            if (comment == null)
            {
                // Nothing to do
                return;
            }

            // Zap the underlying NoteRecord
            IList sheetRecords = sheet.Sheet.Records;
            sheetRecords.Remove(comment.NoteRecord);

            // If we have a TextObjectRecord, is should
            //  be proceeed by:
            // MSODRAWING with container
            // OBJ
            // MSODRAWING with EscherTextboxRecord
            if (comment.TextObjectRecord != null)
            {
                TextObjectRecord txo = comment.TextObjectRecord;
                int txoAt = sheetRecords.IndexOf(txo);

                if (sheetRecords[txoAt - 3] is DrawingRecord &&
                    sheetRecords[txoAt - 2] is ObjRecord &&
                    sheetRecords[txoAt - 1] is DrawingRecord)
                {
                    // Zap these, in reverse order
                    sheetRecords.RemoveAt(txoAt - 1);
                    sheetRecords.RemoveAt(txoAt - 2);
                    sheetRecords.RemoveAt(txoAt - 3);
                }
                else
                {
                    throw new InvalidOperationException("Found the wrong records before the TextObjectRecord, can't Remove comment");
                }

                // Now Remove the text record
                sheetRecords.Remove(txo);
            }
        }
Example #29
0
 /// <summary>
 /// Returns the comments in a format suitable for display
 /// </summary>
 /// <param name="comment"></param>
 /// <returns></returns>
 public string Format(IComment comment)
 {
     return Formatter.Format(comment);
 }
 public bool Remove(IComment item)
 {
     var suc = _comment.Remove(item);
     OnCommentRemoved(new CommentEventArgs(item));
     return suc;
 }