public async Task <ThreadDto> CreateThreadAsync(string boardId, ThreadCreationDto threadDto)
{
throwHelper.ThrowIfNullOrWhiteSpace(boardId, nameof(boardId));
throwHelper.ThrowIfNull(threadDto, nameof(threadDto));
if (await context.Boards.FindAsync(boardId) == null)
{
throw new KeyNotFoundException($"Board '{boardId}' does not exist.");
}
var thread = new ThreadDto {
Subject = threadDto.Subject, BoardId = boardId
};
var post = await posts.CreatePost(thread, threadDto.OpPost);
return(new ThreadDto
{
BoardId = boardId,
Subject = threadDto.Subject,
ThreadId = post.ThreadId,
OpPost = post,
Replies = Enumerable.Empty <PostDto>()
});
}
public ActionResult Put(int id, [FromBody] ThreadDto model)
{
var thread = _threadContext.Threads
.FirstOrDefault(t => t.Id == id);
if (thread == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
thread.Subject = model.Subject;
thread.AddDate = model.AddDate;
thread.UpdateDate = model.UpdateDate;
thread.Author = model.Author;
thread.Content = model.Content;
_threadContext.SaveChanges();
return(NoContent());
}
public static Thread Converter(ThreadDto threadDto)
{
string[] speakersId = threadDto.Speakers.Select(u => u.Id).ToArray();
string[] messagesId = threadDto.Messages.Select(m => m.Id).ToArray();
return(new Thread(threadDto.Id, speakersId, messagesId));
}
public async Task UpdateAsync(ThreadDto thread)
{
Thread match = await _unitOfWork.Threads.FindAsync(thread.ThreadId);
match.Title = thread.Title ?? match.Title;
await _unitOfWork.CompleteAsync();
}
public async Task <PostDto> CreatePost(ThreadDto threadDto, PostCreationDto postDto)
{
throwHelper.ThrowIfNull(threadDto, nameof(threadDto));
throwHelper.ThrowIfNull(postDto, nameof(postDto));
var thread = mapper.Map <Thread>(threadDto);
if (thread.Id != 0 || context.Threads.Local.Any(t => t.Id == thread.Id))
{
context.Attach(thread);
}
var post = new Post
{
CreationTime = DateTime.UtcNow,
Message = postDto.Message,
Name = postDto.AuthorName,
Thread = thread,
UserId = postDto.AuthorId
};
if (postDto.Attachment != null)
{
post.Image = await CreateImageAsync(postDto.Attachment);
}
context.Posts.Add(post);
await context.SaveChangesAsync();
return(mapper.Map <PostDto>(post));
}
private void DoConversion(object threadDto)
{
ThreadDto dto = (ThreadDto)threadDto;
DirectoryInfo workingDirectory = dto.cueFileInfo.Directory;
CueSheet cueSheet = new CueSheet(dto.cueFileInfo.FullName);
int currentSector = 0;
StringWriter gdiOutput = new StringWriter();
Invoke((MethodInvoker) delegate { progressBar1.Maximum = cueSheet.Tracks.Length; });
gdiOutput.WriteLine(cueSheet.Tracks.Length.ToString());
for (int i = 0; i < cueSheet.Tracks.Length; i++)
{
Track currentTrack = cueSheet.Tracks[i];
string inputTrackFilePath = Path.Combine(workingDirectory.FullName, currentTrack.DataFile.Filename);
bool canPerformFullCopy = currentTrack.Indices.Length == 1;
string outputTrackFileName = string.Format(
"track{0}.{1}",
currentTrack.TrackNumber,
currentTrack.TrackDataType == DataType.AUDIO ? "raw" : "bin");
string outputTrackFilePath = Path.Combine(workingDirectory.FullName, outputTrackFileName);
int sectorAmount;
if (canPerformFullCopy)
{
File.Copy(inputTrackFilePath, outputTrackFilePath);
sectorAmount = (int)(new FileInfo(inputTrackFilePath).Length / 2352);
}
else
{
int gapOffset = CountIndexFrames(currentTrack.Indices[1]);
sectorAmount = CopyFileWithGapOffset(inputTrackFilePath, outputTrackFilePath, gapOffset);
currentSector += gapOffset;
}
int gap = 0;
gdiOutput.WriteLine("{0} {1} {2} 2352 {3} {4}",
currentTrack.TrackNumber,
currentSector,
currentTrack.TrackDataType == DataType.AUDIO ? "0" : "4",
outputTrackFileName,
gap);
Invoke((MethodInvoker) delegate { progressBar1.Value++; });
currentSector += sectorAmount;
if (currentTrack.Comments.Contains("HIGH-DENSITY AREA"))
{
if (currentSector < 45000)
{
currentSector = 45000;
}
}
}
string gdiOutputPath = Path.Combine(workingDirectory.FullName, "disc.gdi");
File.WriteAllText(gdiOutputPath, gdiOutput.ToString());
inProgress = false;
}
public async Task EditAsync(ThreadDto dto)
{
var existingEntity = await _context.Threads.FirstOrDefaultAsync(e => e.Id == dto.Id);
MapDtoToExistingEntity(dto, existingEntity);
existingEntity.Category = _context.GetLocalOrAttach <Category>(dto.CategoryId);
await _context.SaveChangesAsync();
}
private bool AreEquivalent(ThreadDto threadDto, ConvThread thread)
{
return(threadDto.Id == thread.Id &&
threadDto.AvatarPath == thread.AvatarPath &&
threadDto.Description == thread.Description &&
threadDto.ModeratorId == thread.ModeratorId &&
threadDto.Name == thread.Name &&
threadDto.Topic == thread.Topic);
}
private void ValidateThread(ThreadDto thread)
{
if (thread == null)
{
throw new ArgumentNullException();
}
if (thread.Id == 0)
{
throw new IdNotSpecifiedException();
}
}
//TODO in DAL layer implement Data integrity constraints (using attributes)
//TODO probably, I'd better get some instances by name (login for User, name for Thread etc) rather than Id to provide good links
public async Task <ActionResult> Thread(int id)
{
ThreadDto threadDto = await Task.Run(() => _serviceFacade.ThreadService.Get.ById(id));
if (threadDto == null)
{
return(HttpNotFound("Такого треда не существует"));
}
return(View(threadDto.MapToVm()));
}
public async Task RemoveAsync(ThreadDto threadDto)
{
if (threadDto == null)
{
throw new ArgumentNullException("threadDto", "Argument is null");
}
var thread = Mapper.Map <ThreadDto, Thread>(threadDto);
UnitOfWork.Threads.Remove(thread);
await UnitOfWork.SaveChangesAsync();
}
public ActionResult Post([FromBody] ThreadDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var thread = _mapper.Map <Thread>(model);
_threadContext.Threads.Add(thread);
_threadContext.SaveChanges();
var key = thread.Id;
//var tmp = _threadContext.Threads.Last<Thread>().Id;
//var key = tmp + 1;
return(Created("api/thread/" + key, null));
}
public async Task <IActionResult> Edit([FromBody] ThreadDto payload)
{
if (payload == null)
{
return(BadRequest());
}
if (payload.Posts[0] == null)
{
return(BadRequest());
}
var thread = _threadService.FindWithTags(payload.Id);
if (thread == null)
{
return(BadRequest());
}
if (thread.CreatedById != CurrentUserId)
{
return(BadRequest());
}
thread.Title = payload.Title;
thread.DateModified = DateTime.Now;
thread.ThreadTags.Clear();
var payloadPost = payload.Posts[0];
var post = _postService.FindById(payloadPost.Id);
post.Content = payloadPost.Content;
await _unitOfWork.SaveChangesAsync();
payload.Tags.ForEach(t => thread.ThreadTags.Add(new ThreadTag {
TagId = t.Id
}));
await _unitOfWork.SaveChangesAsync();
return(Ok());
}
private void Form1_DragDrop(object sender, DragEventArgs e)
{
object insert = e.Data.GetData(DataFormats.FileDrop);
string[] filenames = (string[])insert;
string filename = filenames[0];
progressBar1.Maximum = 99;
progressBar1.Value = 0;
animationFrame = 0;
inProgress = true;
ThreadDto threadData = new ThreadDto();
threadData.cueFileInfo = new FileInfo(filename);
convertThread = new Thread(DoConversion);
convertThread.Priority = ThreadPriority.Lowest;
convertThread.Name = "Converter";
convertThread.Start(threadData);
}
public async Task <IActionResult> Create([FromBody] ThreadDto payload)
{
var thread = _mapper.Map <Thread>(payload);
if (thread == null)
{
return(BadRequest());
}
if (thread.TopicId == null)
{
return(BadRequest());
}
if (thread.Posts[0] == null)
{
return(BadRequest());
}
thread.Title = thread.Title.Trim();
thread.CreatedById = CurrentUserId;
thread.Posts[0].CreatedById = CurrentUserId;
thread.LastActivity = DateTime.Now;
thread.NumberOfPosts = 1;
thread.ThreadTags = new List <ThreadTag>();
payload.Tags.ForEach(t => thread.ThreadTags.Add(new ThreadTag {
TagId = t.Id
}));
var createdBy = _userService.FindById(CurrentUserId);
if (createdBy.Role == Role.Administrator || createdBy.Role == Role.Moderator)
{
SetApprovalStatus(thread, ApprovalStatus.Approved);
}
await _threadService.AddAsync(thread);
await _unitOfWork.SaveChangesAsync();
return(StatusCode(StatusCodes.Status201Created, thread));
}
public async Task ViewThreadAsync_CorrectId_ExpctingRedirectToAction()
{
// Arrange
var threadModel = new ThreadDto();
var threadId = Guid.NewGuid();
var userModel = new UserDto();
var threadViewModel = new ThreadViewModel();
var mockThredService = new Mock <IThreadService>();
mockThredService.Setup(service => service.FindThreadWithRelatedDataAsync(It.IsAny <Guid>(), It.IsAny <int>(), It.IsAny <int>())).ReturnsAsync(threadModel);
var mockUserService = new Mock <IUserService>();
mockUserService.Setup(service => service.FindUserAsync(It.IsAny <string>())).ReturnsAsync(userModel);
var mockAutoMapper = new Mock <IMapper>();
mockAutoMapper.Setup(mapper => mapper.Map <ThreadViewModel>(threadModel)).Returns(threadViewModel);
var threadController = new ThreadController(mockThredService.Object, mockUserService.Object, mockAutoMapper.Object)
{
ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "username")
}, "someAuthTypeName"))
}
}
};
// Act
var result = await threadController.ViewThreadAsync(threadId);
// Assert
var viewResult = Assert.IsAssignableFrom <ViewResult>(result);
Assert.IsAssignableFrom <ThreadViewModel>(viewResult.ViewData.Model);
}
public async Task <IActionResult> Post([FromBody] ThreadDto thread)
{
if (!ModelState.IsValid || thread.TagId == default)
{
return(BadRequest());
}
var toDb = new Thread()
{
Title = thread.Title,
Content = thread.Content,
UserId = thread.User.Id,
DateAdded = DateTime.Now,
TagId = thread.TagId
};
await _forumContext.Threads.AddAsync(toDb);
await _forumContext.SaveChangesAsync();
thread.Id = toDb.Id;
return(CreatedAtAction(nameof(Get), new { id = toDb.Id }, thread));
}
/// <summary>
/// Map using Automapper
/// </summary>
public static ThreadVm MapToVm(this ThreadDto ThreadDto)
{
return(Mapper.Map <ThreadDto, ThreadVm>(ThreadDto));
}
// GET: Thread
public async Task <ActionResult> Index(int id)
{
ThreadDto threadDto = await Task.Run(() => _serviceFacade.ThreadService.Get.ById(id));
return(View(threadDto.MapToVm()));
}
/// <summary>
/// Map using Automapper
/// </summary>
public static ConvThread MapToDbEntity(this ThreadDto Thread)
{
return(Mapper.Map <ThreadDto, ConvThread>(Thread));
}
public List <PostDto> ByThread(ThreadDto thread)
{
ValidateThread(thread);
return(ExecuteSelectQuery(uow => uow.PostRepository.GetByThread(thread.MapToDbEntity())));
}
public async Task <PagedList <ThreadDto> > GetThreadList(int requestorId, ThreadListParams listParams)
{
var threads = await _context.Threads
.Where(x => x.ThreadParticipants.Where(y => y.ParticipantId == requestorId).FirstOrDefault() != null)
.OrderByDescending(x => x.LastModified)
.Include(x => x.ThreadParticipants)
.Skip((listParams.PageNumber - 1) * listParams.PageSize)
.Take(listParams.PageSize)
.ToListAsync();
var threadDtos = new List <ThreadDto>();
var threadsNumber = await _context.Threads
.Where(x => x.ThreadParticipants.Where(y => y.ParticipantId == requestorId).FirstOrDefault() != null)
.OrderByDescending(x => x.LastModified)
.CountAsync();
if (threadsNumber == 0)
{
return(null);
}
foreach (Thread thread in threads)
{
var user = await _context.ThreadParticipants
.Where(x => x.ThreadId == thread.Id)
.Where(x => x.ParticipantId != requestorId)
.Include(x => x.Participant)
.FirstOrDefaultAsync();
var message = await _context.Messages
.Where(x => x.ThreadId == thread.Id)
.OrderByDescending(x => x.MessageSent)
.FirstOrDefaultAsync();
var lastMesageIsMine = true;
if (message.SenderId != requestorId)
{
lastMesageIsMine = false;
}
var isRead = true;
if (!message.IsRead)
{
isRead = false;
}
var threadDto = new ThreadDto()
{
UserOneId = requestorId,
UserTwoId = user.ParticipantId,
UserTwoName = user.Participant.Name,
UserTwoSurname = user.Participant.Surname,
UserTwoPhotoUrl = user.Participant.PhotoUrl,
LastModified = thread.LastModified,
Content = message.Content,
LastMessageIsMine = lastMesageIsMine,
IsRead = isRead
};
threadDtos.Add(threadDto);
}
return(new PagedList <ThreadDto>(threadDtos, threadsNumber, listParams.PageNumber, listParams.PageSize));
}
