public ActionResult Edit(TopicDto model)
{
var subscribers = this.GetValidSubscribers();
if (subscribers == null || !subscribers.Any())
{
return(Json(false, "Modify the topic failure. there are not any subscriber."));
}
model.Subscribers = (from subscriber in subscribers
select new SubscriberDto
{
Email = subscriber
}).ToList();
model.UpdatedBy = this.LoginUser.Identity.Name;
this.EncodeInput(model);
try
{
using (var service = ServiceLocator.Instance.Resolve <ITopicService>())
{
service.ModifyTopic(model);
}
}
catch (Exception)
{
return(Json(false, "Modify the topic failure."));
}
return(Json(true));
}
public void ConvertsToBoardCorrectly()
{
string prompt = "prompt";
string correctResponse = "correctResponse";
AnswerDto answerDto = new AnswerDto()
{
Prompt = prompt,
CorrectResponse = correctResponse
};
List <AnswerDto> answerDtos = new List <AnswerDto>()
{
answerDto
};
string topicName = "topicName";
TopicDto topicDto = new TopicDto()
{
Answers = answerDtos,
Name = topicName
};
List <TopicDto> topicDtos = new List <TopicDto>()
{
topicDto
};
string boardName = "boardName";
BoardDto boardDto = new BoardDto
{
Name = boardName,
Topics = topicDtos
};
var board = boardDto.ToBoard();
Assert.True(board.Name == boardName, "Board.Name was not copied correctly.");
Assert.True(board.Topics.Count() == topicDtos.Count(), "Board.Topics was not copied correctly");
}
public async Task UpdateTopicAsync(TopicDto topicDto)
{
var topicEntity = TopicMapper.Map(topicDto);
_unitOfWork.TopicRepository.Update(topicEntity);
await _unitOfWork.CommitAsync();
}
public async Task <(string Message, bool?IsSuccess)> DeleteTopic(int topicId, OperationLogDto logDto)
{
try
{
var conn = _context.GetDbConnection();
var posts = (await conn.QueryAsync <PhpbbPosts>("SELECT * FROM phpbb_posts WHERE topic_id = @topicId", new { topicId })).AsList();
if (!posts.Any())
{
return(string.Format(LanguageProvider.Moderator[GetLanguage(), "TOPIC_DOESNT_EXIST_FORMAT"], topicId), false);
}
var topic = await conn.QueryFirstOrDefaultAsync <PhpbbTopics>("SELECT * FROM phpbb_topics WHERE topic_id = @topicId", new { topicId });
if (topic != null)
{
var dto = new TopicDto
{
ForumId = topic.ForumId,
TopicId = topic.TopicId,
TopicTitle = topic.TopicTitle,
TopicStatus = topic.TopicStatus,
TopicType = topic.TopicType,
TopicLastPosterColour = topic.TopicLastPosterColour,
TopicLastPosterId = topic.TopicLastPosterId,
TopicLastPosterName = topic.TopicLastPosterName,
TopicLastPostId = topic.TopicLastPostId,
TopicLastPostTime = topic.TopicLastPostTime,
Poll = await _postService.GetPoll(topic)
};
await conn.ExecuteAsync(
"INSERT INTO phpbb_recycle_bin(type, id, content, delete_time, delete_user) VALUES (@type, @id, @content, @now, @userId)",
new
{
type = RecycleBinItemType.Topic,
id = topic.TopicId,
content = await Utils.CompressObject(dto),
now = DateTime.UtcNow.ToUnixTimestamp(),
logDto.UserId
}
);
await conn.ExecuteAsync(
"DELETE FROM phpbb_topics WHERE topic_id = @topicId; " +
"DELETE FROM phpbb_poll_options WHERE topic_id = @topicId",
new { topicId }
);
}
await DeletePostsCore(posts, logDto, false);
await _operationLogService.LogModeratorTopicAction(ModeratorTopicActions.DeleteTopic, logDto.UserId, topicId);
return(LanguageProvider.Moderator[GetLanguage(), "TOPIC_DELETED_SUCCESSFULLY"], true);
}
catch (Exception ex)
{
var id = Utils.HandleError(ex);
return(string.Format(LanguageProvider.Errors[GetLanguage(), "AN_ERROR_OCCURRED_TRY_AGAIN_ID_FORMAT"], id), false);
}
}
public async Task <ApiRequestResult> AddAsync(TopicDto dto)
{
var command = dto.EntityMap <TopicDto, Topic>();
await _topicRepository.AddAsync(command);
return(ApiRequestResult.Success("添加成功"));
}
public void ConvertsToTopicProperly()
{
string prompt = "prompt";
string correctResponse = "correctResponse";
AnswerDto answerDto = new AnswerDto()
{
Prompt = prompt,
CorrectResponse = correctResponse
};
List <AnswerDto> answerDtos = new List <AnswerDto>()
{
answerDto
};
string topicName = "topicName";
TopicDto topicDto = new TopicDto()
{
Answers = answerDtos,
Name = topicName
};
var topic = topicDto.ToTopic();
Assert.True(topic.Answers.Count() == answerDtos.Count(), "Topic.Answers were not copied correctly.");
Assert.True(topic.Name == topicName, "Topic.Name was not copied correctly.");
}
protected virtual async Task Create(TopicDto input)
{
Topic topicDto = MappingProfile.MappingConfigurationSetups().Map <Topic>(input);
_context.Topic.Add(topicDto);
await _context.SaveChangesAsync();
}
public void ModifyTopic(TopicDto topicDto, bool includeSubscriber = true)
{
var topic = this._topicRepository.GetByKey(topicDto.ID);
if (topic == null)
{
return;
}
topic.Update(topicDto.TopicName, topicDto.Description, topicDto.Subject, topicDto.Body, topicDto.UpdatedBy);
if (includeSubscriber)
{
this._topicRepository.RemoveSubscribers(topic.Subscribers);
var subscribers = topicDto.Subscribers;
if (subscribers != null)
{
var taskSubcribers = (from subscriber in subscribers
select new Subscriber(topic.ID, subscriber.Email));
topic.AddSubscribers(taskSubcribers.ToArray());
}
}
this._topicRepository.Update(topic);
}
public async Task <TopicDto> GetByIdAsync(string userId, int topicId)
{
using (IDbConnection connection = _connectionProvider.GetConnection())
{
TopicDto topic = await connection.QueryFirstOrDefaultAsync <TopicDto>(GET_TOPICS, new { topicId });
NotFoundException.ThrowIfNull(topic, nameof(topic));
IEnumerable <EventDto> events = await connection.QueryAsync <EventDto>(GET_EVENTS_FOR_TOPIC, new { topicId });
IEnumerable <QuestionDto> questions = await connection.QueryAsync <QuestionDto>(GET_QUESTIONS_FOR_TOPIC, new { topicId });
IEnumerable <AnswerDto> answers = await connection.QueryAsync <AnswerDto>(GET_ANSWERS_FOR_TOPIC, new { topicId });
IEnumerable <AttemptDto> attempts = await connection.QueryAsync <AttemptDto>(GET_ATTEMPTS_FOR_USER, new { userId, topicId });
ILookup <int, AnswerDto> answerLokup = answers.ToLookup(x => x.QuestionId);
foreach (QuestionDto question in questions)
{
question.Answers = answerLokup[question.Id];
}
topic.Events = events;
topic.Questions = questions;
topic.Attempts = attempts;
return(topic);
}
}
public async Task <TopicDto> GetTopic(Guid topicId, int page, int pageSize)
{
var topic =
await
Topics.Include(t => t.Author)
.Include(t => t.Author.Identity)
.Include(t => t.Posts.Select(p => p.Author.Identity))
.Get(topicId);
var topicAuthor = Mapper.Map <UserProfile, AuthorModel>(topic.Author);
topicAuthor.Avatar = FileManager.GetAvatar(topic.Author.Email);
var dto = new TopicDto
{
Id = topic.Id,
Title = topic.Title,
Posts = topic.Posts.Skip((page - 1) * pageSize).Take(pageSize).Select(post => new PostDto
{
Id = post.Id,
Author = new AuthorModel(post.Author.Email,
post.Author.Identity.Role,
FileManager.GetAvatar(post.Author.Email),
string.Concat(post.Author.Surname, " ", post.Author.Name, " ", post.Author.Patronymic)),
Content = post.Content,
CreationDate = post.CreationDate,
AttachedFiles = FileManager.GetPostFiles(post.Id)
}),
Author = topicAuthor
};
return(dto);
}
public bool Add(TopicDto topicDto)
{
try
{
var result = _topicRepository.GetByName(topicDto.TopicName);
if (result == null)
{
Topic topic = new Topic()
{
TopicName = topicDto.TopicName,
TopicDetail = topicDto.TopicDetail
};
_topicRepository.Add(topic);
_topicRepository.SaveChange();
}
else
{
return(false);
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
//[ProducesResponseType(typeof(TopicDto), StatusCodes.Status200OK)]
public IActionResult AddTopic(TopicDto topicDto)
{
try
{
var topicDtos = _topicService.Add(topicDto);
if (topicDtos)
{
SuccessModel.SuccessCode = "200";
SuccessModel.SuccessMessage = "Success";
return(Ok(SuccessModel));
}
else
{
ErrorModel.ErrorCode = "400";
ErrorModel.ErrorMessage = "Add Fail";
return(BadRequest(ErrorModel));
}
}
catch (Exception ex)
{
ErrorModel.ErrorMessage = ex.Message;
ErrorModel.ErrorCode = "500";
return(StatusCode(500, ErrorModel));
}
}
public void Execute(TopicDto request)
{
var topic = Context.Topics.Find(request.Id);
if (topic == null)
{
throw new EntityNotFoundException();
}
if (topic.Subject != request.Subject)
{
throw new EntityAlreadyExistsException();
}
var user = Context.Users.Find(topic.UserId);
var category = Context.Categories.Find(topic.CategoryId);
topic.ModifiedAt = DateTime.Now;
topic.Subject = request.Subject;
topic.Content = request.Content;
topic.CategoryId = category.Id;
topic.UserId = user.Id;
Context.SaveChanges();
}
public async Task <IActionResult> SaveTopic(TopicDto topicDto)
{
if (User.FindFirst(ClaimTypes.Role).Value != "1")
{
return(Unauthorized());
}
try
{
var topic = _mapper.Map <Topic>(topicDto);
var number = await _repo.SaveTopic(topic);
if (number != 0)
{
return(StatusCode(200));
}
}
catch (System.Exception ex)
{
Extensions.ReportError(ex);
}
return(StatusCode(400));
}
public async Task <object> SubmitTopic([Service] Context context, [GraphQLNonNullType] Guid authorId, [GraphQLNonNullType] SubmitTopic topic)
{
TopicDto topicDto = topic.ToTopicDto();
return(await context.AddTopicAsync(authorId, topicDto).ContinueWith(task => task.MapAsync(topicId =>
context.GetTopicAsync(authorId, topicId)), TaskContinuationOptions.OnlyOnRanToCompletion)
.Unwrap().ContinueWith(t => t.Result.Flatten().Unwrap()));
}
public void Execute(TopicDto request)
{
_validator.ValidateAndThrow(request);
var topic = _context.Topics.Find(request.Id);
topic.Name = request.Name;
_context.SaveChanges();
}
public async Task <Result <SuccessModel, ErrorModel> > AddTopic(TopicDto topicDto)
{
Uri url = new Uri(BaseUriUser, $"/Topic/AddTopic");
Result <SuccessModel, ErrorModel> result = await PostMethodAsync <SuccessModel, ErrorModel>(url, topicDto);
return(result);
}
public async Task <ApiRequestResult> UpdateAsync(TopicDto dto)
{
var entity = await _topicRepository.GetAsync(dto.Id.Value);
var newEntity = dto.EntityMap(entity);
await _topicRepository.UpdateAsync(newEntity);
return(ApiRequestResult.Success("修改成功"));
}
public void SetUp()
{
_topicService = new Mock <ICrudInterface <TopicDto> >();
_topicController = new TopicController(_topicService.Object);
_topic = new TopicDto {
Id = "topic1", Name = "Unit Tests", MaxAttemptCount = 3, QuestionsPerAttempt = 5, TimeToPass = 5, TopicNumber = 5, SubjectId = "subject1"
};
}
public static TopicDto ToDto(this Topic topic)
{
TopicDto topicDto = new TopicDto()
{
Answers = topic.Answers.Select(x => x.ToDto()),
Name = topic.Name
};
return(topicDto);
}
protected virtual async Task Update(TopicDto input)
{
var users = await _context.Topic.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (users != null)
{
Topic topicDto = MappingProfile.MappingConfigurationSetups().Map <Topic>(input);
_context.Topic.Update(topicDto);
await _context.SaveChangesAsync();
}
}
public async Task CreateOrEditTopic(TopicDto input)
{
if (input.Id == null || input.Id == 0)
{
await Create(input);
}
else
{
await Update(input);
}
}
private void RetrieveData()
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
TopicFacade facade = new TopicFacade(uow);
CurrentInstance = facade.RetrieveOrNewTopic(InstanceId, new TopicConverter());
PostFacade postFacade = new PostFacade(uow);
CurrentInstance.Posts = postFacade.RetrievePostsByTopic(InstanceId, new PostConverter());
}
}
private void CalibrateTopics(TopicDto topic)
{
var tasks = topic.TopicTasks.Where(this.CalibrateCore);
if (!tasks.Any())
{
return;
}
this._filterTopics.Add(topic, tasks);
}
public bool PostTopic(TopicDto topicDto)
{
using (var context = new ChatContext())
{
TopicModel topicModel = new TopicModel();
topicModel.name = topicDto.name;
topicModel.author = context.UserModel.First(user => user.id == topicDto.authorid);
context.TopicModel.Add(topicModel);
context.SaveChanges();
return(true);
}
}
public async Task RemoveAsync(TopicDto topicDto)
{
if (topicDto == null)
{
throw new ArgumentNullException("topicDto", "Argument is null");
}
var topic = Mapper.Map <TopicDto, Topic>(topicDto);
UnitOfWork.Topics.Remove(topic);
await UnitOfWork.SaveChangesAsync();
}
public void Execute(TopicDto request)
{
_validator.ValidateAndThrow(request);
var topic = new Topic
{
Name = request.Name
};
_context.Topics.Add(topic);
_context.SaveChanges();
}
public IActionResult Topic(int topicId)
{
var user = service.GetUserById(User.Identity.GetUserId());
var posts = service.ReadAllPostsInTopic(topicId);
var topic = service.GetTopicById(topicId); //TODO use Include
var model = new TopicDto {
Posts = posts, Topic = topic, User = user
};
service.NewTopicView(topicId);
return(View(model));
}
public async Task <Either <Error, Guid> > AddTopicAsync(Guid authorId, TopicDto topic)
{
Either <Error, AuthorDto> author = await GetAuthorAsync(authorId);
return((await author.MapAsync(async a =>
{
Guid topicId = Guid.NewGuid();
topic.Id = topicId;
a.Topics.Add(topic);
Either <Error, AuthorDto> updated = await UpdateAuthorAsync(a);
return updated.Map(p => topicId);
})).Flatten());
}
private void RetrieveData()
{
using (IUnitOfWork uow = UnitOfWorkFactory.Instance.Start(DataStoreResolver.CRMDataStoreKey))
{
TopicFacade facade = new TopicFacade(uow);
TopicDto instance = facade.RetrieveOrNewTopic(InstanceId, new TopicConverter());
if (instance.IsNew)
{
instance.IssuedById = CurrentUserContext.User.UserId;
}
CurrentInstance = instance;
}
}
