public RepliesController(IRepliesRepository repliesRepository, ITopicsRepository topicsRepository, IUsersRepository usersRepository, IMapper mapper)
{
_repliesRepository = repliesRepository;
_topicsRepository = topicsRepository;
_usersRepository = usersRepository;
_mapper = mapper;
}
public DataManager(IUsersRepository usesrs, ITopicsRepository topics, IDiscussionsRepository discussions, IMessagesRepository messages)
{
usersRepository = usesrs;
topicsRepository = topics;
discussionsRepository = discussions;
messagessRepository = messages;
}
public TopicsController(ITopicsRepository topicsRepository,
IChaptersRepository chaptersRepository, IUserRepository userRepository)
{
ChaptersRepository = chaptersRepository;
UserRepository = userRepository;
TopicsRepository = topicsRepository;
}
public ListOfTopics(ISectionsRepository sectionsRepo, ITopicsRepository topicsRepo, IMessagesRepository messagesRepo, int currentPage)
{
Sections = new List<Topics>();
TotalTopics = topicsRepo.Topics.Count();
int skip = (currentPage - 1) * TopicsPerPage;
int current = 0;
foreach (var section in sectionsRepo.Sections)
{
List<Theme> Themes = new List<Theme>();
foreach (var topic in topicsRepo.Topics.Where(t => t.SectionID == section.Id).ToList())
{
if ((current >= skip) && (current < TopicsPerPage + skip))
Themes.Add(new Theme()
{
Posts = topic,
TotalPosts = messagesRepo.Messages.Where(m => m.TopicId == topic.Id).Count(),
UserId = messagesRepo.Messages.Where(m =>
(m.TopicId == topic.Id) && (m.IsFirstMessage == true)).FirstOrDefault().UserId
});
current++;
}
if (Themes.Count() == 0)
continue;
Sections.Add(new Topics() { SectionId = section.Id, SectionTheme = section.Theme, Items = Themes });
if (current >= TopicsPerPage + skip)
break;
}
CurrentPage = currentPage;
}
public async Task InvokeAsync(HttpContext context, ITopicsRepository topicsRepository, IMapper mapper)
{
var topics = topicsRepository.GetAll();
var model = mapper.Map <IEnumerable <TopicModel> >(topics);
await Ok(context, model);
}
public ForumController(IMessagesRepository messages, IUsersRepository users,
ISectionsRepository sections, ITopicsRepository topics)
{
this.messages = messages;
this.users = users;
this.sections = sections;
this.topics = topics;
}
public TopicsService(ITopicsRepository itopicsRepository,
ITeacherRepository iteacherRepository,
IStudentRepository studentRepository)
{
_topicsRepository = itopicsRepository;
_teacherRepository = iteacherRepository;
_studentRepository = studentRepository;
}
public GetAllTopicsHandler(ITopicsRepository topicsRepository,
IVotesRepository votesRepository,
UserManager <User> userManager)
{
_topicsRepository = topicsRepository;
_votesRepository = votesRepository;
_userManager = userManager;
}
public TopicsController(ITopicsRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
_repository = repository;
}
public GetQuizByIdHandler(
IQuizzesRepository quizRepository,
ITopicsRepository topicsRepository)
{
_quizRepository = quizRepository
?? throw new ArgumentNullException(nameof(quizRepository));
_topicsRepository = topicsRepository
?? throw new ArgumentNullException(nameof(topicsRepository));
}
public CreateTopicHandler(IMapper mapper,
ITopicsRepository topicsRepository,
IOptionsRepository optionsRepository,
ITransaction databaseTransaction, ILogger <CreateTopicHandler> logger)
{
_mapper = mapper;
_topicsRepository = topicsRepository;
_optionsRepository = optionsRepository;
_databaseTransaction = databaseTransaction;
_logger = logger;
}
public GetTopicDetailsHandler(ITopicsRepository topicsRepository,
IOptionsRepository optionsRepository,
IVotesRepository votesRepository,
UserManager <User> userManager, IMapper mapper)
{
_topicsRepository = topicsRepository;
_optionsRepository = optionsRepository;
_votesRepository = votesRepository;
_userManager = userManager;
_mapper = mapper;
}
public AddVoteCommandHandler(IVotesRepository votesRepository,
IMapper mapper,
IOptionsRepository optionsRepository,
ITopicsRepository topicsRepository,
ILogger <AddVoteCommandHandler> logger)
{
_votesRepository = votesRepository;
_mapper = mapper;
_optionsRepository = optionsRepository;
_topicsRepository = topicsRepository;
_logger = logger;
}
public TopicsController(ITopicsRepository topicsRepository,
IMapper mapper,
IUsersRepository usersRepository,
ICategoriesRepository categoriesRepository,
IRepliesRepository repliesRepository)
{
_topicsRepository = topicsRepository;
_usersRepository = usersRepository;
_categoriesRepository = categoriesRepository;
_repliesRepository = repliesRepository;
_mapper = mapper;
}
public TopicsController(
ITopicsRepository topicsRepository,
IStudentRepository studentRepository,
SignInManager <ApplicationUser> signManager,
UserManager <ApplicationUser> userManager
)
{
_topicsRepository = topicsRepository;
//_studentRepository = studentRepository;
_signManager = signManager;
_userManager = userManager;
}
public ForumController(ITopicGroupsRepository topicGroupsRepository,
ITopicsRepository topicsRepository,
IDiscussionsRepository discussionsRepository,
IContributionsRepository contributionsRepository,
UserManager <User> userManager,
ITagsService tagsService)
{
this.topicGroupsRepository = topicGroupsRepository;
this.topicsRepository = topicsRepository;
this.discussionsRepository = discussionsRepository;
this.contributionsRepository = contributionsRepository;
this.userManager = userManager;
this.tagsService = tagsService;
}
public async Task InvokeAsync(HttpContext context, ITopicsRepository topicsRepository, IMapper mapper, DefaultEventGridEventHandler eventHandler, IOptions <AwesomeEventGridOptions> options)
{
try
{
ModelState.Reset();
using (var reader = new StreamReader(context.Request.Body, Encoding.UTF8))
{
var topicToCreate = JsonConvert.DeserializeObject <TopicModel>(await reader.ReadToEndAsync(), options.Value.SerializerSettings);
if (topicToCreate == null)
{
ModelState.AddError("", "Request body is required");
}
Validate(topicToCreate);
if (!ModelState.IsValid)
{
await BadRequest(context);
return;
}
if (topicsRepository.FindByName(topicToCreate.Name) != null)
{
ModelState.AddError("name", "Topic does already exists");
await BadRequest(context);
return;
}
var topic = mapper.Map <Topic>(topicToCreate);
topic = topicsRepository.Add(topic);
var topicModel = mapper.Map <TopicModel>(topic);
//todo fix url:
await CreatedAt(context, "http://foo", topicModel);
}
}
catch (JsonException ex)
{
ModelState.AddError("", ex.Message);
await BadRequest(context);
}
}
public async Task InvokeAsync(HttpContext context, ITopicsRepository topicsRepository, IMapper mapper)
{
ModelState.Reset();
var name = (string)context.GetRouteData().Values["name"];
var topic = topicsRepository.FindByName(name);
if (topic == null)
{
ModelState.AddError("name", "Topic with this name not found");
await NotFound(context);
}
else
{
var model = mapper.Map <TopicModel>(topic);
await Ok(context, model);
}
}
public async Task InvokeAsync(HttpContext context, ITopicsRepository topicsRepository, IMapper mapper, IEventGridEventHandler eventGridEventHandler)
{
var options = context.RequestServices.GetService <IOptions <AwesomeEventGridOptions> >();
ModelState.Reset();
var topic = (string)context.GetRouteData().Values["name"];
if (topicsRepository.FindByName(topic) == null)
{
ModelState.AddError("name", "Topic does not exists");
await BadRequest(context);
}
else
{
using (var reader = new StreamReader(context.Request.Body, Encoding.UTF8))
{
var eventsToPublish = JsonConvert.DeserializeObject <EventModel[]>(await reader.ReadToEndAsync(), options.Value.SerializerSettings);
await eventGridEventHandler.HandleAsync(topic, eventsToPublish);
await Accepted(context);
}
}
}
public TopicsControllerTests()
{
_topicsRepositoryMock = Substitute.For <ITopicsRepository>();
_server = TestServer.Create(app => OwinStartup.CoreConfiguration(app, PrepareContainer));
}
public TopicsController(ITopicsRepository repository)
{
_repository = repository;
}
public GetAllTopicsHandler(ITopicsRepository topicRepository)
{
_topicRepository = topicRepository ?? throw new ArgumentNullException(nameof(topicRepository));
}
public TopicsService(ITopicsRepository topicsRepository, IUnitOfWork unitOfWork)
{
this.topicsRepository = topicsRepository;
this.unitOfWork = unitOfWork;
}
public async Task InvokeAsync(HttpContext context, IHttpClientFactory httpClientFactory, ISubscriptionsRepository subscriptionsRepository, ITopicsRepository topicsRepository, IMapper mapper, IEventGridEventHandler eventGridEventHandler, IOptions <AwesomeEventGridOptions> options)
{
try
{
ModelState.Reset();
using (var reader = new StreamReader(context.Request.Body, Encoding.UTF8))
{
var routeData = context.GetRouteData();
var topic = (string)routeData.Values["topic"];
if (topicsRepository.FindByName(topic) == null)
{
ModelState.AddError("name", "Topic with this name not found");
await NotFound(context);
return;
}
var subscriptionModel = JsonConvert.DeserializeObject <SubscriptionModel>(await reader.ReadToEndAsync(), options.Value.SerializerSettings);
var subscription = mapper.Map <Subscription>(subscriptionModel);
subscription.Topic = topic;
var client = httpClientFactory.CreateClient();
var validation = new SubscriptionValidationEventDataModel()
{
ValidationCode = Guid.NewGuid().ToString()
};
var source = $"{options.Value.TopicsPath}/{topic}#validation";
var validationEvent = new EventModel
{
EventType = "subscriptions.validate",
Source = new Uri(source, UriKind.Relative),
Data = validation,
};
var response = await client.PostAsJsonAsync(subscription.EndpointUrl, validationEvent);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsAsync <SubscriptionValidationResponse>();
if (content.ValidationResponse != validation.ValidationCode)
{
ModelState.AddError("", "Endpoint responded with invalid validation code.");
await BadRequest(context);
return;
}
var newSubscription = subscriptionsRepository.AddOrUpdate(subscription);
var model = mapper.Map <SubscriptionModel>(newSubscription);
var link = "http://link"; // todo
await CreatedAt(context, link, model);
// }
// catch (HttpRequestException ex)
// {
// return BadRequest(ex.Message);
// }
}
}
catch (JsonException ex)
{
ModelState.AddError("", ex.Message);
await BadRequest(context);
}
catch (HttpRequestException ex)
{
ModelState.AddError("", ex.Message);
await BadRequest(context);
}
}
/// <summary>
/// Construct TopicsController
/// </summary>
/// <param name="topicRepository"></param>
public TopicsController(ITopicsRepository topicRepository)
{
TopicRepository = topicRepository;
}
private void InitServices()
{
_modulesService = new ModulesRepository(AppConfig.ServiceUrl, _accountService);
_chaptersService = new ChaptersRepository(AppConfig.ServiceUrl, _accountService);
_topicsService = new TopicsRepository(AppConfig.ServiceUrl, _accountService);
}
public TopicsService(ITopicsRepository topicsRepository)
{
_topicsRepository = topicsRepository;
}