public ManageCategoriesController(IPostsService posts, IAnswersService answers, ICommentsService comments, ICategoriesService categories)
{
this.posts = posts;
this.answers = answers;
this.comments = comments;
this.categories = categories;
}
public AdvertisementsAdministrationController(IAdvertisementsService advertisements, ICategoriesService categories, ITownsService towns, ICommentsService comments)
{
this.advertisements = advertisements;
this.categories = categories;
this.towns = towns;
this.comments = comments;
}
public CommentsController(ICommentsService comments, IRecipesService recipes, IIdentifierProvider identifierProvider, ISanitizer sanitizer)
{
this.comments = comments;
this.recipes = recipes;
this.sanitizer = sanitizer;
this.identifierProvider = identifierProvider;
}
public PostsController(IPostsService posts, ICategoriesService postCategory, ICommentsService postComments, IPointsService postPoints)
{
this.posts = posts;
this.postCategory = postCategory;
this.postComments = postComments;
this.postPoints = postPoints;
}
public UserController(IUsersService usersService, IQuestionsService questionsService, ILikesService likesService, ICommentsService commentsService)
{
this.usersService = usersService;
this.questionsService = questionsService;
this.commentsService = commentsService;
this.likesService = likesService;
}
public BeerController(IBeersService beers, IIdentifierProvider identifier, ICountriesService countries, IBeerTypesService beerTypes, ICommentsService comments)
{
this.beers = beers;
this.countries = countries;
this.beerTypes = beerTypes;
this.identifier = identifier;
this.comments = comments;
}
public MainViewModel(ITwitterFeedService twitterFeedService, INavigationService navigationService, ICommentsService commentsService)
{
_twitterFeedService = twitterFeedService;
_navigationService = navigationService;
_commentsService = commentsService;
Tweets = new ObservableCollection<TweetDto>();
}
public CommentsServiceTests()
{
this.service = new CommentsService();
service.Add(new Comments { Text = "Nice" }
);
service.Add(new Comments { Text = "Delicious" }
);
}
public PostsController(IPostsService posts, IAnswersService answers, ICategoriesService categories, ITagsService tags, ICommentsService comments)
{
this.posts = posts;
this.answers = answers;
this.categories = categories;
this.tags = tags;
this.comments = comments;
}
public AdminLessonController(
ILessonsService lessonsService,
ICommentsService commentsService,
ISubjectsService subjectsService)
{
this.lessonsService = lessonsService;
this.commentsService = commentsService;
this.subjectsService = subjectsService;
}
public CommentsController(ICommentsService comments, IVideoCatalogService videoCatalog, IUserManagementService userManagement)
{
if (comments == null) throw new ArgumentNullException("comments");
if (videoCatalog == null) throw new ArgumentNullException("videoCatalog");
if (userManagement == null) throw new ArgumentNullException("userManagement");
_comments = comments;
_videoCatalog = videoCatalog;
_userManagement = userManagement;
}
public CommentsController(
ICommentsService commentsService,
//IMappingService mappingService,
IUsersService usersService)
{
this.commentsService = commentsService;
//this.mappingService = mappingService;
this.usersService = usersService;
}
public NodeService(
IUnitOfWork db,
ISuggestionService suggestionService,
ICommentsService commentsService)
{
this._db = db;
_suggestionService = suggestionService;
_commentsService = commentsService;
}
public SellersController(
IUsersService usersService,
IRolesService rolesService,
IUserRolesService<ApplicationUserRole> userRolesService,
ICommentsService commentsService,
IVotesService votesService,
IProductsService productsService)
: base(usersService, rolesService, userRolesService, commentsService, votesService, productsService)
{
}
public TownsAdministrationController(
ITownsService towns,
ICommentsService comments,
IAdvertisementsService advertisements,
UserManager<ApplicationUser> manager)
{
this.towns = towns;
this.comments = comments;
this.advertisements = advertisements;
this.manager = manager;
}
public PostsController(
IPostsService postsService,
ICommentsService commentsService,
IRegionsService regionsService,
IPostCategoriesService postCategoriesService,
IPetsService petsService)
: base()
{
this.postsService = postsService;
this.commentsService = commentsService;
this.regionsService = regionsService;
this.postCategoriesService = postCategoriesService;
this.petsService = petsService;
}
public KnowledgeSessionApiController(
IKnowledgeSessionService knowledgeSessionService,
IKnowledgeSessionMemberService knowledgeSessionMemberService,
INodeService nodeService,
ISuggestionService suggestionService,
INodeModificationService nodeModificationService,
ICommentsService commentsService,
INodeResourceService nodeResourceService,
ITextMergeSuggestionService textMergeSuggestionService)
{
_knowledgeSessionService = knowledgeSessionService;
_knowledgeSessionMemberService = knowledgeSessionMemberService;
_nodeService = nodeService;
_suggestionService = suggestionService;
_nodeModificationService = nodeModificationService;
_commentsService = commentsService;
_nodeResourceService = nodeResourceService;
_textMergeSuggestionService = textMergeSuggestionService;
}
public CommentsController(ICommentsService commentsService, UserManager <ApplicationUser> userManager)
{
this.commentsService = commentsService;
this.userManager = userManager;
}
/// <summary>
/// Comments controller
/// </summary>
/// <param name="service">Service for operations</param>
public CommentsController(ICommentsService service)
{
this._commentsService = service;
}
public ItemViewModel(ICommentsService commentsService, INavigationService navigationService)
{
_commentsService = commentsService;
_navigationService = navigationService;
}
public WallService(IMoviesService moviesService, ICommentsService commentsService)
{
_commentsService = commentsService;
_moviesService = moviesService;
}
//private IUserService _userService;
public CommentsAPIController(ICommentsService CommentsService/*, IUserService UserService*/)
{
_commentsService = CommentsService;
//_userService = UserService;
}
public CommentController(ICommentsService commentsService)
{
_commentsService = commentsService;
}
public AnswersController(IAnswersService answers, ICommentsService comments)
{
m_Comments = comments;
m_Answers = answers;
}
//public CommentsController()
//{
// var db = new MovieDbContext();
// this.service = new CommentsService(new EfRepository<Comment>(db));
// this.movieService = new MoviesService(new EfRepository<Movie>(db));
// this.usersService = new UsersService(new EfRepository<User>(db));
//}
public CommentsController(ICommentsService commentsService, IMoviesService movies, IUsersService users)
{
this.service = commentsService;
this.movieService = movies;
this.usersService = users;
}
public CommentController(ICommentsService commentsService, UserManager <ApplicationUser> userManager, IProductsService productsService)
{
this.commentsService = commentsService;
this.userManager = userManager;
this.productsService = productsService;
}
public EditCommentPageModel(ICommentsService commentsService)
{
_commentsService = commentsService;
}
public UsersController(ILogger <UsersController> logger, IUsersService userService, IIdeasService ideasService, ICommentsService commentsService)
{
_logger = logger;
_logger.LogInformation("Users Controller was created!");
_usersService = userService;
_ideasService = ideasService;
_commentsService = commentsService;
}
public CommentsGrpcService(ICommentsService commentsService) => this.commentsService = commentsService;
public HomeController(IQuestionsService questionsService, ICommentsService commentsService)
{
this.questionsService = questionsService;
this.commentService = commentService;
}
public CommentsController(ICommentsService comments, IIdentityProvider identityProvider)
{
this.comments = comments;
this.identityProvider = identityProvider;
}
public CommentsController(ICommentsService comments, UserManager <User> userManager)
{
this.comments = comments;
this.userManager = userManager;
}
public CommentsController(ICommentsService commentsService, IFacilitiesService facilitiesService, IUsersService usersService)
{
this.comments = commentsService;
this.facilities = facilitiesService;
this.users = usersService;
}
public HttpResponseMessage GetComments(string blogId, string postId, HttpRequestMessage request, int pageIndex = 1, int pageSize = 10)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
try
{
ICommentsService commentsService = ObjectFactory.GetInstance <ICommentsService>();
var comments = commentsService.GetAllFromPost(String.Format("posts/{0}", postId), pageIndex, pageSize);
if (comments != null)
{
if (this.ClientAcceptsMediaType("text/html", request))
{
var commentsHtml = comments.GenerateCommentsHtml();
response.Content = new ObjectContent <string>(commentsHtml, "text/html");
}
else
{
SyndicationFeed postCommentsFeed = new SyndicationFeed
{
Title =
new TextSyndicationContent(
String.Format("Post {0} comments", postId)),
LastUpdatedTime = new DateTimeOffset(DateTime.Now)
};
postCommentsFeed.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
List <SyndicationItem> itemList = new List <SyndicationItem>();
postCommentsFeed.Items = itemList;
foreach (var comment in comments)
{
SyndicationItem item = new SyndicationItem
{
Id = comment.Id,
LastUpdatedTime = comment.updated,
PublishDate = comment.published
};
item.Links.Add(SyndicationLink.CreateSelfLink(new Uri(String.Format("{0}/blogs/{1}/posts/{2}/{3}", this.serviceURI, blogId, postId, comment.Id))));
item.Links.Add(SyndicationLink.CreateAlternateLink(request.RequestUri, "text/html"));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/blogs/{1}/posts/{2}", this.serviceURI, blogId, postId)), "service.post", "Parent post", "application/atom+xml;type=feed", 0));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/blogs/{1}/posts/{2}/{3}", this.serviceURI, blogId, postId, comment.Id)), "service.edit", "Edit comment", "application/atom+xml;type=feed", 0));
var pagingLinks = this.BuildPagingLinks(commentsService.Count(), pageIndex, pageSize, request.RequestUri);
foreach (var link in pagingLinks)
{
item.Links.Add(link);
}
item.Authors.Add(new SyndicationPerson(string.Empty, comment.author, string.Empty));
item.Content = SyndicationContent.CreatePlaintextContent(comment.content);
itemList.Add(item);
}
SyndicationFeedFormatter formatter = null;
if (this.ClientAcceptsMediaType("application/atom+xml", request))
{
formatter = postCommentsFeed.GetAtom10Formatter();
}
else
{
if (this.ClientAcceptsMediaType("application/rss+xml", request))
{
formatter = postCommentsFeed.GetRss20Formatter();
}
}
response.Content = new ObjectContent(typeof(SyndicationFeedFormatter), formatter);
}
}
else
{
response.StatusCode = HttpStatusCode.NoContent;
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public CommentsController(ICommentsService commentsSevice)
{
this.comments = commentsSevice;
}
public HttpResponseMessage GetComment(string blogId, string postId, string id, HttpRequestMessage request)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
try
{
ICommentsService commentsService = ObjectFactory.GetInstance <ICommentsService>();
var comment = commentsService.Get(String.Format("comments/{0}", id));
var etag = request.Headers.IfNoneMatch.FirstOrDefault();
if (etag != null && etag.Tag == comment.etag)
{
response.StatusCode = HttpStatusCode.NotModified;
}
else
{
if (comment != null)
{
if (this.ClientAcceptsMediaType("text/html", request))
{
response.Content = new ObjectContent <string>(comment.ToHtml(), "text/html");
}
else
{
SyndicationFeed commentFeed = new SyndicationFeed
{
Title = new TextSyndicationContent("Single Comment"),
LastUpdatedTime = new DateTimeOffset(DateTime.Now)
};
commentFeed.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
SyndicationItem item = new SyndicationItem();
List <SyndicationItem> itemList = new List <SyndicationItem> {
item
};
commentFeed.Items = itemList;
item.Id = comment.Id;
item.LastUpdatedTime = comment.updated;
item.PublishDate = comment.published;
item.Content = new TextSyndicationContent(comment.content);
item.Links.Add(SyndicationLink.CreateSelfLink(request.RequestUri));
item.Links.Add(SyndicationLink.CreateAlternateLink(request.RequestUri, "text/html"));
item.Links.Add(new SyndicationLink(request.RequestUri, "service.edit", "Edit Comment", "application/atom+xml;type=feed", 0));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/blogs/{1}/posts/{2}/{3}", this.serviceURI, blogId, postId, comment.Id)), "service.comments", "Post comments", "application/atom+xml;type=feed", 0));
item.Links.Add(new SyndicationLink(new Uri(String.Format("{0}/blogs/{1}/posts/{2}", this.serviceURI, blogId, postId)), "service.post", "Parent post", "application/atom+xml;type=feed", 0));
item.Authors.Add(new SyndicationPerson(string.Empty, comment.author, string.Empty));
SyndicationFeedFormatter formatter = null;
if (this.ClientAcceptsMediaType("application/atom+xml", request))
{
formatter = commentFeed.GetAtom10Formatter();
}
else
{
if (this.ClientAcceptsMediaType("application/rss+xml", request))
{
formatter = commentFeed.GetRss20Formatter();
}
}
response.Content = new ObjectContent(typeof(SyndicationFeedFormatter), formatter);
}
}
else
{
response.StatusCode = HttpStatusCode.NotFound;
}
}
}
catch (Exception)
{
response.StatusCode = HttpStatusCode.InternalServerError;
}
return(response);
}
public CommentsService(ILogger <CommentsService> logger, ICommentsService commentsService, IAuthorizationService authorizationService)
{
_logger = logger;
this.commentsService = commentsService;
this.authorizationService = authorizationService;
}
public AdminService(IUnitOfWork repo, IAccountService serv, IRatingService ratingServ, ICommentsService commentServ)
{
db = repo;
service = serv;
ratingService = ratingServ;
commentService = commentServ;
}
// private readonly IComments_PraiseService IComments_PraiseService;
public CommentsController(ICommentsService newsService)
{
this.service = newsService;
// this.IComments_PraiseService = newIComments_PraiseService;
}
public MessageHandleController(IApplicationContextAccessor applicationContextAccessor, IMessageService messageService, ICommentsService commentsService, ICookie cookie)
{
_applicationContextAccessor = applicationContextAccessor;
_messageService = messageService;
_commentService = commentsService;
_cookie = cookie;
}
public CommentsController(ICommentsService commentsService)
{
this.commentsService = commentsService;
}
public PostsController(IPostsService postsService, ICommentsService commentsService, CommentsController commentsController)
{
_postsService = postsService;
_commentsService = commentsService;
_commentsController = commentsController;
}
public CommentsController(ICommentsService service, IPostsService postsService)
{
this.service = service;
this.postsService = postsService;
}
// GET: api/Posts
public CommentsController(ICommentsService service, ILogger <CommentsController> logger)
{
this.service = service;
this.logger = logger;
}
public CommentsAdminController(ICommentsService comments)
: base()
{
this.comments = comments;
}
public CommentsController(ICommentsService commentsService,
IMovieService movieService)
{
this._commentsService = commentsService;
this._movieService = movieService;
}
public CommentsController()
{
this.comments = new CommentsService(new GenericRepository<Comment>(new RealEstateSystemDbContext()));
this.identityProvider = new AspNetIdentityProvider();
}
public ManageCategoriesController(IPostsService posts, IAnswersService answers, ICommentsService comments, ICategoriesService categories)
{
m_Posts = posts;
m_Answers = answers;
m_Comments = comments;
m_Categories = categories;
}
public IdeasService(IDbRepository<Idea> ideas, IIdentifierProvider identifierProvider, ICommentsService comments)
{
this.ideas = ideas;
this.identifierProvider = identifierProvider;
this.comments = comments;
}
public LatestCommentsViewComponent(ICommentsService commentsService)
{
this.commentsService = commentsService;
}
public CommentsController(ILogger <CommentsController> logger, IAnswersService answersService, ICommentsService commentsService)
{
_logger = logger;
_answersService = answersService;
_commentsService = commentsService;
}
public CommentsLogic(ICommentsService service)
{
this.service = service;
}
public CommentsController(IAdvertisementsService advertisements, ICommentsService comments, UserManager<ApplicationUser> manager)
{
this.advertisements = advertisements;
this.comments = comments;
this.manager = manager;
}
public CommentsController(ICommentsService comments)
{
this.comments = comments;
}
public CommentsAdministrationController(ICommentsService comments)
{
this.comments = comments;
}
public CommentsWidgetService(IWidgetBasePartService widgetBasePartService, IApplicationContext applicationContext, CMSDbContext dbContext, ICommentsService commentsService) : base(widgetBasePartService, applicationContext, dbContext)
{
_commentsService = commentsService;
}
public CategoriesAdministrationController(ICategoriesService categories, ICommentsService comments, IAdvertisementsService advertisements)
{
this.categories = categories;
this.comments = comments;
this.advertisements = advertisements;
}
public CommentsController(ICommentsService commentsService, IUsersService usersService)
{
this.commentsService = commentsService;
this.usersService = usersService;
}
public HomeController(IIdeasService ideas, ICommentsService comments)
{
this.ideas = ideas;
this.comments = comments;
}
public BlogController(IBlogsService blogsService, ICommentsService commentsService)
{
this.blogsService = blogsService;
this.commentsService = commentsService;
}
