merge from master

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IForumService.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Interfaces
+{
+    public interface IForumService
+    {
+        Task<ServiceResult<List<ForumPreviewDto>>> GetForums(int courseId);
+
+        Task<ServiceResult<Forum>> Create(ForumCreateDto newForum);
+
+        Task<ServiceResult<Forum>> Delete(int forumId);
+
+        Task<ServiceResult<List<string>>> GetSubscribedUsers(int forumId);
+
+        Task<ServiceResult<List<bool>>> Subscribe(int forumId, int userId);
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IMessageService.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+
+namespace Tsi1.BusinessLayer.Interfaces
+{
+    public interface IMessageService
+    {
+        Task<ServiceResult<List<MessagePreviewDto>>> GetMessages(int userId, int otherUserId);
+
+        Task<ServiceResult<MessagePreviewDto>> Send(MessageCreateDto newMessage);
+
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IPostMessageService.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Interfaces
+{
+    public interface IPostMessageService
+    {
+        Task<ServiceResult<List<PostMessagePreviewDto>>> GetPostMessages(int postId);
+
+        Task<ServiceResult<PostMessage>> Create(PostMessageCreateDto newPostMessage);
+
+        Task<ServiceResult<PostMessage>> Delete(int postMessageId);
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IPostService.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Interfaces
+{
+    public interface IPostService
+    {
+        Task<ServiceResult<List<PostPreviewDto>>> GetPosts(int forumId);
+
+        Task<ServiceResult<Post>> Create(PostCreateDto newPost);
+
+        Task<ServiceResult<Post>> Delete(int postId);
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Interfaces/IUserService.cs

@@ -11,6 +11,9 @@ namespace Tsi1.BusinessLayer.Interfaces
     public interface IUserService
     {
         Task<ServiceResult<User>> Authenticate(string username, string password);
+
         Task<ServiceResult<User>> Create(UserRegisterDto dto, string type);
+
+        Task<ServiceResult<List<UserPreviewDto>>> GetAll();
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Services/EmailService.cs

+using MailKit;
+using MailKit.Net.Smtp;
+using MailKit.Security;
+using Microsoft.Extensions.Options;
+using MimeKit;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.BusinessLayer.Interfaces;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Services
+{
+    public class EmailService : IEmailService
+    {
+        private readonly MailSettings _mailSettings;
+
+        public EmailService(IOptions<MailSettings> mailSettings)
+        {
+            _mailSettings = mailSettings.Value;
+        }
+
+        public async Task<ServiceResult<bool>> SendEmailAsync(MimeMessage message)
+        {
+            ServiceResult<bool> result = new ServiceResult<bool>();
+
+            message.Sender = MailboxAddress.Parse(_mailSettings.Mail);
+
+            var client = new SmtpClient();
+            client.CheckCertificateRevocation = false;
+
+            try
+            {
+                await client.ConnectAsync(_mailSettings.Host, _mailSettings.Port, SecureSocketOptions.StartTls);
+            }
+            catch (Exception e)
+            {
+                result.HasError = true;
+                result.Message = ErrorMessages.CannotConnectToSmtpServer;
+                return result;
+            }
+
+            try
+            {
+                await client.AuthenticateAsync(_mailSettings.Mail, _mailSettings.Password);
+            }
+            catch (Exception)
+            {
+                result.HasError = true;
+                result.Message = ErrorMessages.CannotAuthenticateToSmtpServer;
+                return result;
+            }
+
+            try
+            {
+                await client.SendAsync(message);
+            }
+            catch (Exception)
+            {
+                result.HasError = true;
+                result.Message = string.Format(ErrorMessages.CannotSendEmail, message.Subject);
+                return result;
+            }
+
+            await client.DisconnectAsync(true);
+
+            return result;
+        }
+
+        public async Task<ServiceResult<bool>> NotifyNewPostOrMessage(PostCreateDto postCreateDto,  List<string> users)
+        {
+            var message = new MimeMessage();
+
+            foreach (var user in users)
+            {
+                message.To.Add(MailboxAddress.Parse(user));
+            }
+
+            message.Subject = $"Nuevo Post: {postCreateDto.Title}";
+            message.Body = new TextPart("html")
+            {
+                Text = $"<p> Hay un nuevo post perteneciente al foro suscripto."
+            };
+
+            var result = await SendEmailAsync(message);
+
+            return result;
+        }
+
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Services/ForumService.cs

+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using Org.BouncyCastle.Math.EC.Rfc7748;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.BusinessLayer.Interfaces;
+using Tsi1.DataLayer;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Services
+{
+    public class ForumService : IForumService
+    {
+        private readonly Tsi1Context _context;
+
+        private readonly IMapper _mapper;
+
+        public ForumService(Tsi1Context context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public async Task<ServiceResult<Forum>> Create(ForumCreateDto newForum)
+        {
+            var result = new ServiceResult<Forum>();
+
+            var forum = _mapper.Map<Forum>(newForum);
+
+            _context.Forums.Add(forum);
+            await _context.SaveChangesAsync();
+
+            result.Data = forum;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<Forum>> Delete(int forumId)
+        {
+            var result = new ServiceResult<Forum>();
+
+            var forum = await _context.Forums.FirstOrDefaultAsync(x => x.Id == forumId);
+
+            if (forum == null)
+            {
+                result.HasError = true;
+                result.Message = string.Format(ErrorMessages.ForumDoesNotExist, forumId);
+                return result;
+            }
+
+            _context.Forums.Remove(forum);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        public async Task<ServiceResult<List<ForumPreviewDto>>> GetForums(int courseId)
+        {
+            var result = new ServiceResult<List<ForumPreviewDto>>();
+
+            var forums = await _context.Forums
+                .Where(x => x.CourseId == courseId)
+                .ToListAsync();
+
+            var forumDtos = _mapper.Map<List<ForumPreviewDto>>(forums);
+
+            result.Data = forumDtos;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<List<string>>> GetSubscribedUsers(int forumId)
+        {
+            var result = new ServiceResult<List<string>>();
+
+            var userEmails = await _context.ForumUsers
+                .Where(x => x.ForumId == forumId)
+                .Select(x => x.User.Email)
+                .ToListAsync();
+
+            result.Data = userEmails;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<List<bool>>> Subscribe(int forumId, int userId)
+        {
+            var result = new ServiceResult<List<bool>>();
+
+            var forum = await _context.Forums.FirstOrDefaultAsync(x => x.Id == forumId);
+
+            if (forum == null)
+            {
+                result.HasError = true;
+                result.Message = string.Format(ErrorMessages.ForumDoesNotExist, forumId);
+                return result;
+            }
+
+            var forumUser = new ForumUser
+            {
+                ForumId = forumId,
+                UserId = userId,
+            };
+
+            _context.ForumUsers.Add(forumUser);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Services/MessageService.cs

+using AutoMapper;
+using MongoDB.Bson;
+using MongoDB.Driver;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.BusinessLayer.Interfaces;
+using Tsi1.DataLayer.Entities;
+using Tsi1.DataLayer.MongoDbConfiguration;
+
+namespace Tsi1.BusinessLayer.Services
+{
+    public class MessageService : IMessageService
+    {
+        private readonly IMapper _mapper;
+
+        private readonly IMongoCollection<Message> _messages;
+
+        public MessageService(ITsi1DatabaseSettings settings, IMapper mapper)
+        {
+            var client = new MongoClient(settings.ConnectionString);
+            var database = client.GetDatabase(settings.DatabaseName);
+
+            _messages = database.GetCollection<Message>(settings.Tsi1CollectionName);
+            _mapper = mapper;
+        }
+
+        public async Task<ServiceResult<List<MessagePreviewDto>>> GetMessages(int userId, int otherUserId)
+        {
+            var result = new ServiceResult<List<MessagePreviewDto>>();
+
+            var sort = Builders<Message>.Sort.Ascending("Date");
+
+            var messages = await _messages.Find(m => (m.SenderId == userId && m.ReceiverId == otherUserId)
+                                        || (m.SenderId == otherUserId && m.ReceiverId == userId))
+                                        .Sort(sort)
+                                        .ToListAsync();
+
+            var messagesDto = _mapper.Map<List<MessagePreviewDto>>(messages);
+
+            result.Data = messagesDto;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<MessagePreviewDto>> Send(MessageCreateDto newMessage)
+        {
+            var result = new ServiceResult<MessagePreviewDto>();
+
+            var message = _mapper.Map<Message>(newMessage);
+            message.Date = DateTime.Now;
+
+            
+            await _messages.InsertOneAsync(message);
+
+            var messageDto = _mapper.Map<MessagePreviewDto>(message);
+
+            result.Data = messageDto;
+
+            return result;
+        }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Services/PostMessageService.cs

+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.BusinessLayer.Interfaces;
+using Tsi1.DataLayer;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Services
+{
+    public class PostMessageService : IPostMessageService
+    {
+        private readonly Tsi1Context _context;
+
+        private readonly IMapper _mapper;
+
+        public PostMessageService(Tsi1Context context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public async Task<ServiceResult<PostMessage>> Create(PostMessageCreateDto newPostMessage)
+        {
+            var result = new ServiceResult<PostMessage>();
+
+            var postMessage = _mapper.Map<PostMessage>(newPostMessage);
+
+            postMessage.Date = DateTime.Now;
+
+            _context.PostMessages.Add(postMessage);
+            await _context.SaveChangesAsync();
+
+            result.Data = postMessage;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<PostMessage>> Delete(int postMessageId)
+        {
+            var result = new ServiceResult<PostMessage>();
+
+            var postMessage = await _context.PostMessages.FirstOrDefaultAsync(x => x.Id == postMessageId);
+
+            if (postMessage == null)
+            {
+                result.HasError = true;
+                result.Message = string.Format(ErrorMessages.PostMessageDoesNotExist, postMessageId);
+                return result;
+            }
+
+            _context.PostMessages.Remove(postMessage);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        public async Task<ServiceResult<List<PostMessagePreviewDto>>> GetPostMessages(int postId)
+        {
+            var result = new ServiceResult<List<PostMessagePreviewDto>>();
+
+            var postMessages = await _context.PostMessages
+                .Where(x => x.PostId == postId)
+                .ToListAsync();
+
+            var postMessageDtos = _mapper.Map<List<PostMessagePreviewDto>>(postMessages);
+
+            result.Data = postMessageDtos;
+
+            return result;
+        }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Services/PostService.cs

+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Tsi1.BusinessLayer.Dtos;
+using Tsi1.BusinessLayer.Helpers;
+using Tsi1.BusinessLayer.Interfaces;
+using Tsi1.DataLayer;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.BusinessLayer.Services
+{
+    public class PostService : IPostService
+    {
+        private readonly Tsi1Context _context;
+
+        private readonly IMapper _mapper;
+
+        public PostService(Tsi1Context context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        public async Task<ServiceResult<Post>> Create(PostCreateDto newPost)
+        {
+            var result = new ServiceResult<Post>();
+
+            var post = _mapper.Map<Post>(newPost);
+
+            post.Date = DateTime.Now;
+
+            _context.Posts.Add(post);
+            await _context.SaveChangesAsync();
+
+            result.Data = post;
+
+            return result;
+        }
+
+        public async Task<ServiceResult<Post>> Delete(int postId)
+        {
+            var result = new ServiceResult<Post>();
+
+            var post = await _context.Posts.FirstOrDefaultAsync(x => x.Id == postId);
+
+            if (post == null)
+            {
+                result.HasError = true;
+                result.Message = string.Format(ErrorMessages.PostDoesNotExist, postId);
+                return result;
+            }
+
+            _context.Posts.Remove(post);
+
+            await _context.SaveChangesAsync();
+
+            return result;
+        }
+
+        public async Task<ServiceResult<List<PostPreviewDto>>> GetPosts(int forumId)
+        {
+            var result = new ServiceResult<List<PostPreviewDto>>();
+
+            var posts = await _context.Posts
+                .Where(x => x.ForumId == forumId)
+                .ToListAsync();
+
+            var postDtos = _mapper.Map<List<PostPreviewDto>>(posts);
+
+            result.Data = postDtos;
+
+            return result;
+        }
+    }
+}

Tsi1.Api/Tsi1.BusinessLayer/Services/UserService.cs

-using Microsoft.EntityFrameworkCore;
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Tsi1.BusinessLayer.Dtos;
@@ -15,9 +17,12 @@ namespace Tsi1.BusinessLayer.Services
     {
         private readonly Tsi1Context _context;
 
-        public UserService(Tsi1Context context)
+        private readonly IMapper _mapper;
+
+        public UserService(Tsi1Context context, IMapper mapper)
         {
             _context = context;
+            _mapper = mapper;
         }
 
         public async Task<ServiceResult<User>> Authenticate(string username, string password)
@@ -84,5 +89,20 @@ namespace Tsi1.BusinessLayer.Services
 
             return result;
         }
+
+        public async Task<ServiceResult<List<UserPreviewDto>>> GetAll()
+        {
+            var result = new ServiceResult<List<UserPreviewDto>>();
+
+            var users = await _context.Users
+                .Where(x => x.UserType.Name != UserTypes.FacultyAdmin)
+                .ToListAsync();
+
+            var usersDto = _mapper.Map<List<UserPreviewDto>>(users);
+
+            result.Data = usersDto;
+
+            return result;
+        }
     }
 }

Tsi1.Api/Tsi1.BusinessLayer/Tsi1.BusinessLayer.csproj

@@ -4,6 +4,13 @@
     <TargetFramework>netcoreapp3.1</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="10.1.1" />
+    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="8.1.0" />
+    <PackageReference Include="MailKit" Version="2.9.0" />
+    <PackageReference Include="MimeKit" Version="2.9.2" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Tsi1.DataLayer\Tsi1.DataLayer.csproj" />
   </ItemGroup>

Tsi1.Api/Tsi1.DataLayer/Entities/Course.cs

@@ -10,6 +10,7 @@ namespace Tsi1.DataLayer.Entities
         {
             StudentCourses = new HashSet<StudentCourse>();
             ProfessorCourses = new HashSet<ProfessorCourse>();
+            Forums = new HashSet<Forum>();
         }
 
         public int Id { get; set; }
@@ -17,5 +18,6 @@ namespace Tsi1.DataLayer.Entities
 
         public ICollection<StudentCourse> StudentCourses { get; set; }
         public ICollection<ProfessorCourse> ProfessorCourses { get; set; }
+        public ICollection<Forum> Forums { get; set; }
     }
 }

Tsi1.Api/Tsi1.DataLayer/Entities/Forum.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.DataLayer.Entities
+{
+    public class Forum
+    {
+        public Forum()
+        {
+            Posts = new HashSet<Post>();
+            ForumUsers = new HashSet<ForumUser>();
+        }
+
+        public int Id { get; set; }
+
+        public string Name { get; set; }
+
+        public int CourseId { get; set; }
+
+        public Course Course { get; set; }
+
+        public ICollection<Post> Posts { get; set; }
+        public ICollection<ForumUser> ForumUsers { get; set; }
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Entities/ForumUser.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.DataLayer.Entities
+{
+    public class ForumUser
+    {
+        public int ForumId { get; set; }
+        public int UserId { get; set; }
+
+        public Forum Forum { get; set; }
+        public User User { get; set; }
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Entities/Message.cs

+using MongoDB.Bson;
+using MongoDB.Bson.Serialization.Attributes;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.DataLayer.Entities
+{
+    public class Message
+    {
+        [BsonId]
+        [BsonRepresentation(BsonType.ObjectId)]
+        public string Id { get; set; }
+
+        public int SenderId { get; set; }
+
+        public int ReceiverId { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime Date { get; set; } 
+
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Entities/Post.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.DataLayer.Entities
+{
+    public class Post
+    {
+        public Post()
+        {
+            PostMessages = new HashSet<PostMessage>();
+        }
+
+        public int Id { get; set; }
+
+        public string Title { get; set; }
+
+        public DateTime Date { get; set; }
+
+        public int ForumId { get; set; }
+
+        public Forum Forum { get; set; }
+
+        public int UserId { get; set; }
+
+        public User User { get; set; }
+
+        public ICollection<PostMessage> PostMessages { get; set; }
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Entities/PostMessage.cs

+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Tsi1.DataLayer.Entities
+{
+    public class PostMessage
+    {
+        public int Id { get; set; }
+
+        public string Content { get; set; }
+
+        public DateTime Date { get; set; }
+
+        public int UserId { get; set; }
+
+        public User User { get; set; }
+
+        public int PostId { get; set; }
+
+        public Post Post { get; set; }
+    }
+}

Tsi1.Api/Tsi1.DataLayer/Entities/User.cs

@@ -6,6 +6,13 @@ namespace Tsi1.DataLayer.Entities
 {
     public class User
     {
+        public User()
+        {
+            Posts = new HashSet<Post>();
+            PostMessages = new HashSet<PostMessage>();
+            ForumUsers = new HashSet<ForumUser>();
+        }
+
         public int Id { get; set; }
         public int UserTypeId { get; set; }
         public int? StudentId { get; set; }
@@ -19,5 +26,9 @@ namespace Tsi1.DataLayer.Entities
         public UserType UserType { get; set; }
         public Student Student { get; set; }
         public Professor Professor { get; set; }
+
+        public ICollection<Post> Posts { get; set; }
+        public ICollection<PostMessage> PostMessages { get; set; }
+        public ICollection<ForumUser> ForumUsers { get; set; }
     }
 }

Tsi1.Api/Tsi1.DataLayer/EntityConfiguration/ForumConfiguration.cs

+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using System;
+using System.Collections.Generic;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using Tsi1.DataLayer.Entities;
+
+namespace Tsi1.DataLayer.EntityConfiguration
+{
+    class ForumConfiguration : IEntityTypeConfiguration<Forum>
+    {
+        public void Configure(EntityTypeBuilder<Forum> builder)
+        {
+            builder.HasKey(x => x.Id);
+
+            builder.HasIndex(x => new { x.CourseId, x.Name })
+                .IsUnique();
+
+            builder.Property(x => x.Name)
+                .IsRequired()
+                .HasColumnType("character varying(50)");
+
+            builder.HasOne(x => x.Course)
+                .WithMany(x => x.Forums)
+                .HasForeignKey(x => x.CourseId);
+
+        }
+    }
+}