merge depuis master
continuous-integration/drone/push Build is passing
Details
continuous-integration/drone/push Build is passing
Details
commit
f86c66250a
@ -1,14 +0,0 @@
|
||||
using Dto;
|
||||
using Model.OrderCriteria;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public interface IInquiryDataService : IInquiryService<InquiryDTO>
|
||||
{
|
||||
public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria);
|
||||
public InquiryDTO GetInquiryById(int id);
|
||||
public InquiryDTO GetInquiryByTitle(string title);
|
||||
public bool DeleteInquiry(int id);
|
||||
public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry);
|
||||
public InquiryDTO CreateInquiry(string title, string description, bool isUser);
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
using Dto;
|
||||
using Model.OrderCriteria;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public interface ILessonDataService : ILessonService<LessonDTO>
|
||||
{
|
||||
public IEnumerable<LessonDTO> GetLessons(int page, int number, LessonOrderCriteria orderCriteria);
|
||||
public LessonDTO GetLessonById(int id);
|
||||
public LessonDTO GetLessonByTitle(string title);
|
||||
public bool DeleteLesson(int id);
|
||||
public LessonDTO UpdateLesson(int id, LessonDTO lesson);
|
||||
public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit);
|
||||
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
using Dto;
|
||||
using Model.OrderCriteria;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public interface IParagraphDataService : IParagraphService<ParagraphDTO>
|
||||
{
|
||||
public IEnumerable<ParagraphDTO> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria);
|
||||
public ParagraphDTO GetParagraphById(int id);
|
||||
public ParagraphDTO GetParagraphByTitle(string title);
|
||||
public bool DeleteParagraph(int id);
|
||||
public ParagraphDTO UpdateParagraph(int id, ParagraphDTO paragraph);
|
||||
public ParagraphDTO CreateParagraph(string title, string content, string info, string query, string comment, int lessonId);
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
using Dto;
|
||||
using Model.OrderCriteria;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public interface ISuccessDataService : ISuccessService<SuccessDTO>
|
||||
{
|
||||
public IEnumerable<SuccessDTO> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria);
|
||||
public SuccessDTO GetSuccessByUserId(int id);
|
||||
public SuccessDTO GetSuccessByInquiryId(int id);
|
||||
public bool DeleteSuccess(int id);
|
||||
public SuccessDTO UpdateSuccess(int id, SuccessDTO success);
|
||||
public SuccessDTO CreateSuccess(int userId, int inquiryId, bool isFinished);
|
||||
}
|
||||
@ -1,14 +0,0 @@
|
||||
using Dto;
|
||||
using Model.OrderCriteria;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public interface IUserDataService : IUserService<UserDTO>
|
||||
{
|
||||
public IEnumerable<UserDTO> GetUsers(int page, int number, UserOrderCriteria orderCriteria);
|
||||
public UserDTO GetUserById(int id);
|
||||
public UserDTO GetUserByUsername(string username);
|
||||
public bool DeleteUser(int id);
|
||||
public UserDTO UpdateUser(int id, UserDTO user);
|
||||
public UserDTO CreateUser(string username, string password, string email, bool isAdmin);
|
||||
}
|
||||
@ -1,121 +0,0 @@
|
||||
using Entities;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Dto;
|
||||
using Model.OrderCriteria;
|
||||
using DbContextLib;
|
||||
using Shared.Mapper;
|
||||
using Shared.ModelToEntities;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public class InquiryDataService : IInquiryDataService
|
||||
{
|
||||
private UserDbContext DbContext { get; set; }
|
||||
|
||||
public InquiryDataService(UserDbContext context)
|
||||
{
|
||||
DbContext = context;
|
||||
context.Database.EnsureCreated();
|
||||
}
|
||||
|
||||
public IEnumerable<InquiryDTO> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria)
|
||||
{
|
||||
IQueryable<InquiryEntity> query = DbContext.Inquiries.Skip((page - 1) * number).Take(number);
|
||||
switch (orderCriteria)
|
||||
{
|
||||
case InquiryOrderCriteria.None:
|
||||
break;
|
||||
case InquiryOrderCriteria.ByTitle:
|
||||
query = query.OrderBy(s => s.Title);
|
||||
break;
|
||||
case InquiryOrderCriteria.ByDescription:
|
||||
query = query.OrderBy(s => s.Description);
|
||||
break;
|
||||
case InquiryOrderCriteria.ByIsUser:
|
||||
query = query.OrderBy(s => s.IsUser);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
var inquiries = query.ToList();
|
||||
return inquiries.Select(s => s.FromEntityToDTO());
|
||||
}
|
||||
|
||||
public InquiryDTO GetInquiryById(int id)
|
||||
{
|
||||
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Id == id);
|
||||
if (inquiryEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
|
||||
}
|
||||
return inquiryEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public InquiryDTO GetInquiryByTitle(string title)
|
||||
{
|
||||
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Title == title);
|
||||
if (inquiryEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver l'enquête", nameof(title));
|
||||
}
|
||||
return inquiryEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public InquiryDTO CreateInquiry(string title, string description, bool isUser)
|
||||
{
|
||||
var newInquiryEntity = new InquiryDTO(title, description, isUser);
|
||||
DbContext.Inquiries.Add(newInquiryEntity.FromDTOToEntity());
|
||||
DbContext.SaveChangesAsync();
|
||||
return newInquiryEntity;
|
||||
}
|
||||
|
||||
public bool DeleteInquiry(int id)
|
||||
{
|
||||
var inquiryEntity = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
|
||||
if (inquiryEntity == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
DbContext.Inquiries.Remove(inquiryEntity);
|
||||
DbContext.SaveChangesAsync();
|
||||
return true;
|
||||
}
|
||||
public InquiryDTO UpdateInquiry(int id, InquiryDTO inquiry)
|
||||
{
|
||||
var updatingInquiry = DbContext.Inquiries.FirstOrDefault(u => u.Id == id);
|
||||
if (updatingInquiry == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver l'enquête", nameof(id));
|
||||
}
|
||||
|
||||
updatingInquiry.Title = inquiry.Title;
|
||||
updatingInquiry.Description = inquiry.Description;
|
||||
updatingInquiry.IsUser = inquiry.IsUser;
|
||||
DbContext.SaveChangesAsync();
|
||||
return updatingInquiry.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public async Task<InquiryDTO?> AddItem(InquiryDTO? item)
|
||||
{
|
||||
var inquiry = await DbContext.CreateItemAsync<InquiryEntity>(item.FromDTOToEntity());
|
||||
return inquiry.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteItem(int id)
|
||||
{
|
||||
var sucess = await DbContext.DeleteItemAsync<InquiryEntity>(id);
|
||||
return sucess;
|
||||
}
|
||||
|
||||
public async Task<InquiryDTO> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
|
||||
{
|
||||
var inquiry = await DbContext.UpdateItemAsync<InquiryEntity, TDto>(id, newItem);
|
||||
return inquiry.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<InquiryDTO>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
|
||||
{
|
||||
var inquiries = await DbContext.GetItemsWithFilter<InquiryEntity>(page, count, orderCriteria, filter, valueFilter);
|
||||
return inquiries.Select(i => i.FromEntityToDTO());
|
||||
}
|
||||
}
|
||||
@ -1,123 +0,0 @@
|
||||
using DbContextLib;
|
||||
using Entities;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Dto;
|
||||
using Model.OrderCriteria;
|
||||
using Shared.Mapper;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public class LessonDataService : ILessonDataService
|
||||
{
|
||||
private UserDbContext DbContext { get; set; }
|
||||
public LessonDataService(UserDbContext context)
|
||||
{
|
||||
DbContext = context;
|
||||
context.Database.EnsureCreated();
|
||||
}
|
||||
public IEnumerable<LessonDTO> GetLessons(int page, int number, LessonOrderCriteria orderCriteria)
|
||||
{
|
||||
IQueryable<LessonEntity> query = DbContext.Lessons.Skip((page - 1) * number).Take(number);
|
||||
switch (orderCriteria)
|
||||
{
|
||||
case LessonOrderCriteria.None:
|
||||
break;
|
||||
case LessonOrderCriteria.ByTitle:
|
||||
query = query.OrderBy(s => s.Title);
|
||||
break;
|
||||
case LessonOrderCriteria.ByLastPublisher:
|
||||
query = query.OrderBy(s => s.LastPublisher);
|
||||
break;
|
||||
case LessonOrderCriteria.ByLastEdit:
|
||||
query = query.OrderBy(s => s.LastEdit);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
var lessons = query.ToList();
|
||||
return lessons.Select(s => s.FromEntityToDTO());
|
||||
}
|
||||
|
||||
public LessonDTO GetLessonById(int id)
|
||||
{
|
||||
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Id == id);
|
||||
if (lessonEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
|
||||
}
|
||||
|
||||
return lessonEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public LessonDTO GetLessonByTitle(string title)
|
||||
{
|
||||
var lessonEntity = DbContext.Lessons.FirstOrDefault(u => u.Title == title);
|
||||
if (lessonEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver la leçon", nameof(title));
|
||||
}
|
||||
|
||||
return lessonEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public bool DeleteLesson(int id)
|
||||
{
|
||||
var lessonEntity = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
|
||||
if (lessonEntity == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
DbContext.Lessons.Remove(lessonEntity);
|
||||
DbContext.SaveChangesAsync();
|
||||
return true;
|
||||
}
|
||||
|
||||
public LessonDTO UpdateLesson(int id, LessonDTO lesson)
|
||||
{
|
||||
var updatingLesson = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
|
||||
if (updatingLesson == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
|
||||
}
|
||||
|
||||
updatingLesson.Title = lesson.Title;
|
||||
updatingLesson.LastPublisher = lesson.LastPublisher;
|
||||
updatingLesson.LastEdit = lesson.LastEdit;
|
||||
DbContext.SaveChangesAsync();
|
||||
return updatingLesson.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public LessonDTO CreateLesson(string title, string lastPublisher, DateOnly? lastEdit)
|
||||
{
|
||||
var newLessonEntity = new LessonDTO()
|
||||
{
|
||||
Title = title,
|
||||
LastPublisher = lastPublisher,
|
||||
LastEdit = lastEdit,
|
||||
};
|
||||
DbContext.Lessons.Add(newLessonEntity.FromDTOToEntity());
|
||||
DbContext.SaveChangesAsync();
|
||||
return newLessonEntity;
|
||||
}
|
||||
|
||||
public Task<LessonDTO?> AddItem(LessonDTO? item)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public Task<bool> DeleteItem(int id)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public Task<LessonDTO> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
|
||||
public Task<IEnumerable<LessonDTO>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
|
||||
{
|
||||
throw new NotImplementedException();
|
||||
}
|
||||
}
|
||||
@ -1,116 +0,0 @@
|
||||
using Entities;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Dto;
|
||||
using DbContextLib;
|
||||
using Model.OrderCriteria;
|
||||
using Shared;
|
||||
using Shared.Mapper;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public class ParagraphDataService : IParagraphDataService
|
||||
{
|
||||
private UserDbContext DbContext { get; set; }
|
||||
public ParagraphDataService(UserDbContext context)
|
||||
{
|
||||
DbContext = context;
|
||||
context.Database.EnsureCreated();
|
||||
}
|
||||
|
||||
public IEnumerable<ParagraphDTO> GetParagraphs(int page, int number, ParagraphOrderCriteria orderCriteria)
|
||||
{
|
||||
IQueryable<ParagraphEntity> query = DbContext.Paragraphs.Skip((page - 1) * number).Take(number);
|
||||
switch (orderCriteria)
|
||||
{
|
||||
case ParagraphOrderCriteria.None:
|
||||
break;
|
||||
case ParagraphOrderCriteria.ByTitle:
|
||||
query = query.OrderBy(s => s.Title);
|
||||
break;
|
||||
case ParagraphOrderCriteria.ByContent:
|
||||
query = query.OrderBy(s => s.Content);
|
||||
break;
|
||||
case ParagraphOrderCriteria.ByInfo:
|
||||
query = query.OrderBy(s => s.Info);
|
||||
break;
|
||||
case ParagraphOrderCriteria.ByQuery:
|
||||
query = query.OrderBy(s => s.Query);
|
||||
break;
|
||||
case ParagraphOrderCriteria.ByComment:
|
||||
query = query.OrderBy(s => s.Comment);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
var paragraphs = query.ToList();
|
||||
return paragraphs.Select(s => s.FromEntityToDTO());
|
||||
}
|
||||
|
||||
public ParagraphDTO GetParagraphById(int id)
|
||||
{
|
||||
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Id == id);
|
||||
if (paragraphEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
|
||||
}
|
||||
|
||||
return paragraphEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public ParagraphDTO GetParagraphByTitle(string title)
|
||||
{
|
||||
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(u => u.Title == title);
|
||||
if (paragraphEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(title));
|
||||
}
|
||||
|
||||
return paragraphEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public bool DeleteParagraph(int id)
|
||||
{
|
||||
var paragraphEntity = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
|
||||
if (paragraphEntity == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
DbContext.Paragraphs.Remove(paragraphEntity);
|
||||
DbContext.SaveChangesAsync();
|
||||
return true;
|
||||
}
|
||||
|
||||
public ParagraphDTO UpdateParagraph(int id, ParagraphDTO paragraphDTO)
|
||||
{
|
||||
var updatingParagraph = DbContext.Paragraphs.FirstOrDefault(p => p.Id == id);
|
||||
if (updatingParagraph == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver le paragraphe", nameof(id));
|
||||
}
|
||||
|
||||
updatingParagraph.Title = paragraphDTO.Title;
|
||||
updatingParagraph.Content = paragraphDTO.Content;
|
||||
updatingParagraph.Info = paragraphDTO.Info;
|
||||
updatingParagraph.Query = paragraphDTO.Query;
|
||||
updatingParagraph.Comment = paragraphDTO.Comment;
|
||||
DbContext.SaveChangesAsync();
|
||||
return updatingParagraph.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public ParagraphDTO CreateParagraph(string title, string content, string info, string query, string comment, int lessonId)
|
||||
{
|
||||
var newParagraphEntity = new ParagraphDTO()
|
||||
{
|
||||
Title = title,
|
||||
Content = content,
|
||||
Info = info,
|
||||
Query = query,
|
||||
Comment = comment,
|
||||
LessonId = lessonId
|
||||
};
|
||||
DbContext.Paragraphs.Add(newParagraphEntity.FromDTOToEntity());
|
||||
DbContext.SaveChangesAsync();
|
||||
return newParagraphEntity;
|
||||
}
|
||||
}
|
||||
@ -1,103 +0,0 @@
|
||||
using Entities;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Dto;
|
||||
using DbContextLib;
|
||||
using Model.OrderCriteria;
|
||||
using Shared.Mapper;
|
||||
|
||||
namespace Shared;
|
||||
|
||||
public class SuccessDataService : ISuccessDataService
|
||||
{
|
||||
private UserDbContext DbContext { get; set; }
|
||||
public SuccessDataService(UserDbContext context)
|
||||
{
|
||||
DbContext = context;
|
||||
context.Database.EnsureCreated();
|
||||
}
|
||||
public IEnumerable<SuccessDTO> GetSuccesses(int page, int number, SuccessOrderCriteria orderCriteria)
|
||||
{
|
||||
IQueryable<SuccessEntity> query = DbContext.Successes.Skip((page - 1) * number).Take(number);
|
||||
switch (orderCriteria)
|
||||
{
|
||||
case SuccessOrderCriteria.None:
|
||||
break;
|
||||
case SuccessOrderCriteria.ByUserId:
|
||||
query = query.OrderBy(s => s.UserId);
|
||||
break;
|
||||
case SuccessOrderCriteria.ByInquiryId:
|
||||
query = query.OrderBy(s => s.InquiryId);
|
||||
break;
|
||||
case SuccessOrderCriteria.ByIsFinished:
|
||||
query = query.OrderBy(s => s.IsFinished);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
var successes = query.ToList();
|
||||
return successes.Select(s => s.FromEntityToDTO());
|
||||
}
|
||||
|
||||
public SuccessDTO GetSuccessByUserId(int id)
|
||||
{
|
||||
var userEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
|
||||
if (userEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
|
||||
}
|
||||
|
||||
return userEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public SuccessDTO GetSuccessByInquiryId(int id)
|
||||
{
|
||||
var userEntity = DbContext.Successes.FirstOrDefault(u => u.InquiryId == id);
|
||||
if (userEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
|
||||
}
|
||||
|
||||
return userEntity.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public bool DeleteSuccess(int id)
|
||||
{
|
||||
var successEntity = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
|
||||
if (successEntity == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
DbContext.Successes.Remove(successEntity);
|
||||
DbContext.SaveChangesAsync();
|
||||
return true;
|
||||
}
|
||||
|
||||
public SuccessDTO UpdateSuccess(int id, SuccessDTO success)
|
||||
{
|
||||
var updatingSuccess = DbContext.Successes.FirstOrDefault(u => u.UserId == id);
|
||||
if (updatingSuccess == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver le succès", nameof(id));
|
||||
}
|
||||
|
||||
updatingSuccess.UserId = success.UserId;
|
||||
updatingSuccess.InquiryId = success.InquiryId;
|
||||
updatingSuccess.IsFinished = success.IsFinished;
|
||||
DbContext.SaveChangesAsync();
|
||||
return updatingSuccess.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public SuccessDTO CreateSuccess(int userId, int inquiryId, bool isFinished)
|
||||
{
|
||||
var newSuccessEntity = new SuccessDTO()
|
||||
{
|
||||
UserId = userId,
|
||||
InquiryId = inquiryId,
|
||||
IsFinished = isFinished,
|
||||
};
|
||||
DbContext.Successes.Add(newSuccessEntity.FromDTOToEntity());
|
||||
DbContext.SaveChangesAsync();
|
||||
return newSuccessEntity;
|
||||
}
|
||||
}
|
||||
@ -1,152 +0,0 @@
|
||||
using Dto;
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.EntityFrameworkCore;
|
||||
using Entities;
|
||||
using Shared.Mapper;
|
||||
using DbContextLib;
|
||||
using Model.OrderCriteria;
|
||||
using Shared.ModelToEntities;
|
||||
|
||||
namespace Shared
|
||||
{
|
||||
public class UserDataService : IUserDataService
|
||||
{
|
||||
private UserDbContext DbContext { get; set; }
|
||||
|
||||
public UserDataService(UserDbContext context)
|
||||
{
|
||||
DbContext = context;
|
||||
context.Database.EnsureCreated();
|
||||
}
|
||||
|
||||
public UserDTO GetUserById(int id)
|
||||
{
|
||||
var userEntity = DbContext.Users.FirstOrDefault(u => u.Id == id);
|
||||
if (userEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
|
||||
}
|
||||
|
||||
return userEntity.FromEntityToDTO();
|
||||
|
||||
}
|
||||
|
||||
public UserDTO GetUserByUsername(string username)
|
||||
{
|
||||
var userEntity = DbContext.Users.FirstOrDefault(u => u.Username == username);
|
||||
if (userEntity == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(username));
|
||||
}
|
||||
|
||||
return userEntity.FromEntityToDTO();
|
||||
|
||||
}
|
||||
|
||||
public IEnumerable<UserDTO> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
|
||||
{
|
||||
IQueryable<UserEntity> query = DbContext.Users.Skip((page - 1) * number).Take(number);
|
||||
switch (orderCriteria)
|
||||
{
|
||||
case UserOrderCriteria.None:
|
||||
break;
|
||||
case UserOrderCriteria.ById:
|
||||
query = query.OrderBy(s => s.Id);
|
||||
break;
|
||||
case UserOrderCriteria.ByUsername:
|
||||
query = query.OrderBy(s => s.Username);
|
||||
break;
|
||||
case UserOrderCriteria.ByEmail:
|
||||
query = query.OrderBy(s => s.Email);
|
||||
break;
|
||||
case UserOrderCriteria.ByIsAdmin:
|
||||
query = query.OrderBy(s => s.IsAdmin);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
var users = query.ToList();
|
||||
return users.Select(s => s.FromEntityToDTO());
|
||||
}
|
||||
|
||||
public bool DeleteUser(int id)
|
||||
{
|
||||
var userEntity = DbContext.Users.FirstOrDefault(u => u.Id == id);
|
||||
if (userEntity == null)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
DbContext.Users.Remove(userEntity);
|
||||
DbContext.SaveChangesAsync();
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
public UserDTO UpdateUser(int id, UserDTO user)
|
||||
{
|
||||
var updatingUser = DbContext.Users.FirstOrDefault(u => u.Id == id);
|
||||
if (updatingUser == null)
|
||||
{
|
||||
throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(id));
|
||||
}
|
||||
|
||||
updatingUser.Username = user.Username;
|
||||
updatingUser.Password = user.Password;
|
||||
updatingUser.Email = user.Email;
|
||||
updatingUser.IsAdmin = user.IsAdmin;
|
||||
DbContext.SaveChangesAsync();
|
||||
return updatingUser.FromEntityToDTO();
|
||||
|
||||
}
|
||||
|
||||
public UserDTO CreateUser(string username, string password, string email, bool isAdmin)
|
||||
{
|
||||
var newUserEntity = new UserDTO
|
||||
{
|
||||
Username = username,
|
||||
Password = password,
|
||||
Email = email,
|
||||
IsAdmin = isAdmin
|
||||
};
|
||||
DbContext.Users.Add(newUserEntity.FromDTOToEntity());
|
||||
DbContext.SaveChangesAsync();
|
||||
return newUserEntity;
|
||||
|
||||
}
|
||||
|
||||
public async Task<UserDTO?> AddItem(UserDTO? item)
|
||||
{
|
||||
using(var context = new UserDbContext())
|
||||
{
|
||||
var user = await DbContext.CreateItemAsync<UserEntity>(item.FromDTOToEntity());
|
||||
return user.FromEntityToDTO();
|
||||
}
|
||||
}
|
||||
|
||||
public Task<bool> DeleteItem(int id)
|
||||
{
|
||||
using (var context = new UserDbContext())
|
||||
{
|
||||
var user = context.DeleteItemAsync<UserEntity>(id);
|
||||
return user;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<UserDTO> UpdateItem<TDto>(int? id, TDto? newItem) where TDto : class
|
||||
{
|
||||
var user = await DbContext.UpdateItemAsync<UserEntity, TDto>(id, newItem);
|
||||
return user.FromEntityToDTO();
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<UserDTO>> GetItems(int page, int count, object? orderCriteria = null, string? filter = null, object? valueFilter = null)
|
||||
{
|
||||
var usersEntities = await DbContext.GetItemsWithFilter<UserEntity>(page, count, orderCriteria, filter, valueFilter);
|
||||
return usersEntities.Select(e => e).ToList().Select(e => e.FromEntityToDTO());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,51 @@
|
||||
using Entities;
|
||||
|
||||
namespace TestEF.EntitiesTests;
|
||||
|
||||
public class TestInquiryEntity
|
||||
{
|
||||
private const int _id = 42;
|
||||
private const string _title = "Title";
|
||||
private const string _description = "_description";
|
||||
private const bool _isUser = true;
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
InquiryEntity inquiry = new InquiryEntity();
|
||||
Assert.Equal(0, inquiry.Id);
|
||||
Assert.Null(inquiry.Title);
|
||||
Assert.Null(inquiry.Description);
|
||||
Assert.False(inquiry.IsUser);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithOnlyId()
|
||||
{
|
||||
InquiryEntity inquiry = new InquiryEntity(_id);
|
||||
Assert.Equal(_id, inquiry.Id);
|
||||
Assert.Null(inquiry.Title);
|
||||
Assert.Null(inquiry.Description);
|
||||
Assert.False(inquiry.IsUser);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutId()
|
||||
{
|
||||
InquiryEntity inquiry = new InquiryEntity(_title, _description, _isUser);
|
||||
Assert.Equal(0, inquiry.Id);
|
||||
Assert.Equal(_title, inquiry.Title);
|
||||
Assert.Equal(_description, inquiry.Description);
|
||||
Assert.True(inquiry.IsUser);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithAllAttributes()
|
||||
{
|
||||
InquiryEntity inquiry = new InquiryEntity(_id, _title, _description, _isUser);
|
||||
Assert.Equal(_id, inquiry.Id);
|
||||
Assert.Equal(_title, inquiry.Title);
|
||||
Assert.Equal(_description, inquiry.Description);
|
||||
Assert.True(inquiry.IsUser);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,52 @@
|
||||
using Entities;
|
||||
|
||||
namespace TestEF;
|
||||
|
||||
public class TestInquiryTableEntity
|
||||
{
|
||||
private const int _inquiryId = 42;
|
||||
private static InquiryEntity _inquiry = new InquiryEntity();
|
||||
private const string _databaseName = "Database";
|
||||
private const string _connectionInfo = "Connection";
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
InquiryTableEntity tableEntity = new InquiryTableEntity();
|
||||
Assert.Equal(0, tableEntity.OwnerId);
|
||||
Assert.Null(tableEntity.Owner);
|
||||
Assert.Null(tableEntity.DatabaseName);
|
||||
Assert.Null(tableEntity.ConnectionInfo);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithOnlyId()
|
||||
{
|
||||
InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId);
|
||||
Assert.Equal(_inquiryId, tableEntity.OwnerId);
|
||||
Assert.Null(tableEntity.Owner);
|
||||
Assert.Null(tableEntity.DatabaseName);
|
||||
Assert.Null(tableEntity.ConnectionInfo);
|
||||
}
|
||||
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutId()
|
||||
{
|
||||
InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiry, _databaseName, _connectionInfo);
|
||||
Assert.Equal(0, tableEntity.OwnerId);
|
||||
Assert.Equal(_inquiry, tableEntity.Owner);
|
||||
Assert.Equal(_databaseName, tableEntity.DatabaseName);
|
||||
Assert.Equal(_connectionInfo, tableEntity.ConnectionInfo);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutNavigationProperty()
|
||||
{
|
||||
InquiryTableEntity tableEntity = new InquiryTableEntity(_inquiryId, _databaseName, _connectionInfo);
|
||||
Assert.Equal(_inquiryId, tableEntity.OwnerId);
|
||||
Assert.Null(tableEntity.Owner);
|
||||
Assert.Equal(_databaseName, tableEntity.DatabaseName);
|
||||
Assert.Equal(_connectionInfo, tableEntity.ConnectionInfo);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,42 @@
|
||||
using Entities;
|
||||
using Microsoft.VisualBasic;
|
||||
|
||||
namespace TestEF;
|
||||
|
||||
public class TestLessonEntity
|
||||
{
|
||||
private const int _id = 42;
|
||||
private const string _title = "Title";
|
||||
private const string _lastPublisher = "Last Publisher";
|
||||
private static DateOnly _lastEdit = new DateOnly();
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
LessonEntity lesson = new LessonEntity();
|
||||
Assert.Equal(0, lesson.Id);
|
||||
Assert.Null(lesson.Title);
|
||||
Assert.Null(lesson.LastPublisher);
|
||||
Assert.Null(lesson.LastEdit);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutId()
|
||||
{
|
||||
LessonEntity lesson = new LessonEntity(_title, _lastPublisher, _lastEdit);
|
||||
Assert.Equal(0, lesson.Id);
|
||||
Assert.Equal(_title, lesson.Title);
|
||||
Assert.Equal(_lastPublisher, lesson.LastPublisher);
|
||||
Assert.Equal(_lastEdit, lesson.LastEdit);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithAllAttributes()
|
||||
{
|
||||
LessonEntity lesson = new LessonEntity(_id, _title, _lastPublisher, _lastEdit);
|
||||
Assert.Equal(_id, lesson.Id);
|
||||
Assert.Equal(_title, lesson.Title);
|
||||
Assert.Equal(_lastPublisher, lesson.LastPublisher);
|
||||
Assert.Equal(_lastEdit, lesson.LastEdit);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,49 @@
|
||||
using Entities;
|
||||
|
||||
namespace TestEF;
|
||||
|
||||
public class TestNotepadEntity
|
||||
{
|
||||
private const int _id = 42;
|
||||
private const int _userId = 42;
|
||||
private static UserEntity _userEntity = new UserEntity();
|
||||
private const int _inquiryId = 42;
|
||||
private static InquiryEntity _inquiryEntity = new InquiryEntity();
|
||||
private const string _notes = "This is some notes example";
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
NotepadEntity notepad = new NotepadEntity();
|
||||
Assert.Equal(0, notepad.Id);
|
||||
Assert.Equal(0, notepad.UserId);
|
||||
Assert.Null(notepad.User);
|
||||
Assert.Equal(0, notepad.InquiryId);
|
||||
Assert.Null(notepad.Inquiry);
|
||||
Assert.Null(notepad.Notes);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutId()
|
||||
{
|
||||
NotepadEntity notepad = new NotepadEntity(_userId, _userEntity, _inquiryId, _inquiryEntity, _notes);
|
||||
Assert.Equal(0, notepad.Id);
|
||||
Assert.Equal(_userId, notepad.UserId);
|
||||
Assert.Equal(_userEntity, notepad.User);
|
||||
Assert.Equal(_inquiryId, notepad.InquiryId);
|
||||
Assert.Equal(_inquiryEntity, notepad.Inquiry);
|
||||
Assert.Equal(_notes, notepad.Notes);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithAllAttributes()
|
||||
{
|
||||
NotepadEntity notepad = new NotepadEntity(_id, _userId, _userEntity, _inquiryId, _inquiryEntity, _notes);
|
||||
Assert.Equal(_id, notepad.Id);
|
||||
Assert.Equal(_userId, notepad.UserId);
|
||||
Assert.Equal(_userEntity, notepad.User);
|
||||
Assert.Equal(_inquiryId, notepad.InquiryId);
|
||||
Assert.Equal(_inquiryEntity, notepad.Inquiry);
|
||||
Assert.Equal(_notes, notepad.Notes);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,50 @@
|
||||
using Entities;
|
||||
|
||||
namespace TestEF;
|
||||
|
||||
public class TestParagraphEntity
|
||||
{
|
||||
private const int _id = 42;
|
||||
private const string _title = "Title";
|
||||
private const string _info = "Info";
|
||||
private const string _content = "Content";
|
||||
private const string _query = "Query";
|
||||
private const string _comment = "Comment";
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
ParagraphEntity paragraph = new ParagraphEntity();
|
||||
Assert.Equal(0, paragraph.Id);
|
||||
Assert.Null(paragraph.Title);
|
||||
Assert.Null(paragraph.Info);
|
||||
Assert.Null(paragraph.Content);
|
||||
Assert.Null(paragraph.Query);
|
||||
Assert.Null(paragraph.Comment);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutId()
|
||||
{
|
||||
ParagraphEntity paragraph = new ParagraphEntity(_title, _content, _info, _query, _comment);
|
||||
Assert.Equal(0, paragraph.Id);
|
||||
Assert.Equal(_title, paragraph.Title);
|
||||
Assert.Equal(_info, paragraph.Info);
|
||||
Assert.Equal(_content, paragraph.Content);
|
||||
Assert.Equal(_query, paragraph.Query);
|
||||
Assert.Equal(_comment, paragraph.Comment);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithAllAttributes()
|
||||
{
|
||||
ParagraphEntity paragraph = new ParagraphEntity(_id, _title, _content, _info, _query, _comment, 10);
|
||||
Assert.Equal(_id, paragraph.Id);
|
||||
Assert.Equal(_title, paragraph.Title);
|
||||
Assert.Equal(_info, paragraph.Info);
|
||||
Assert.Equal(_content, paragraph.Content);
|
||||
Assert.Equal(_query, paragraph.Query);
|
||||
Assert.Equal(_comment, paragraph.Comment);
|
||||
Assert.Equal(10, paragraph.LessonId);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,92 @@
|
||||
using Entities;
|
||||
|
||||
namespace TestEF;
|
||||
|
||||
public class TestSolutionEntity
|
||||
{
|
||||
private const string _murdererFirstName = "John";
|
||||
private const string _murdererLastName = "Doe";
|
||||
private const string _murderPlace = "WhiteHouse";
|
||||
private const string _murderWeapon = "Nuclear Bomb";
|
||||
private const string _explaination = "This is an explaination";
|
||||
private const int _inquiryId = 42;
|
||||
private static InquiryEntity _inquiry = new InquiryEntity();
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
SolutionEntity solution = new SolutionEntity();
|
||||
Assert.Equal(0, solution.OwnerId);
|
||||
Assert.Null(solution.Owner);
|
||||
Assert.Null(solution.MurdererFirstName);
|
||||
Assert.Null(solution.MurdererLastName);
|
||||
Assert.Null(solution.MurderPlace);
|
||||
Assert.Null(solution.MurderWeapon);
|
||||
Assert.Null(solution.Explaination);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithOnlyId()
|
||||
{
|
||||
SolutionEntity solution = new SolutionEntity(_inquiryId);
|
||||
Assert.Equal(_inquiryId, solution.OwnerId);
|
||||
Assert.Null(solution.Owner);
|
||||
Assert.Null(solution.MurdererFirstName);
|
||||
Assert.Null(solution.MurdererLastName);
|
||||
Assert.Null(solution.MurderPlace);
|
||||
Assert.Null(solution.MurderWeapon);
|
||||
Assert.Null(solution.Explaination);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutOwnerId()
|
||||
{
|
||||
SolutionEntity solution = new SolutionEntity(_inquiry, _murdererFirstName, _murdererLastName, _murderPlace,
|
||||
_murderWeapon, _explaination);
|
||||
Assert.Equal(0, solution.OwnerId);
|
||||
Assert.Equal(_inquiry, solution.Owner);
|
||||
Assert.Equal(_murdererFirstName, solution.MurdererFirstName);
|
||||
Assert.Equal(_murdererLastName, solution.MurdererLastName);
|
||||
Assert.Equal(_murderPlace, solution.MurderPlace);
|
||||
Assert.Equal(_murderWeapon, solution.MurderWeapon);
|
||||
Assert.Equal(_explaination, solution.Explaination);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithAllAttributes()
|
||||
{
|
||||
SolutionEntity solution = new SolutionEntity(_inquiryId, _inquiry, _murdererFirstName, _murdererLastName,
|
||||
_murderPlace, _murderWeapon, _explaination);
|
||||
Assert.Equal(_inquiryId, solution.OwnerId);
|
||||
Assert.Equal(_inquiry, solution.Owner);
|
||||
Assert.Equal(_murdererFirstName, solution.MurdererFirstName);
|
||||
Assert.Equal(_murdererLastName, solution.MurdererLastName);
|
||||
Assert.Equal(_murderPlace, solution.MurderPlace);
|
||||
Assert.Equal(_murderWeapon, solution.MurderWeapon);
|
||||
Assert.Equal(_explaination, solution.Explaination);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Constructor_ShouldSetProperties_WhenCalledWithSixParameters()
|
||||
{
|
||||
// Arrange
|
||||
const int ownerId = 1;
|
||||
const string murdererFirstName = "John";
|
||||
const string murdererLastName = "Doe";
|
||||
const string murderPlace = "WhiteHouse";
|
||||
const string murderWeapon = "Nuclear Bomb";
|
||||
const string explanation = "This is an explanation";
|
||||
|
||||
// Act
|
||||
var solutionEntity = new SolutionEntity(ownerId, murdererFirstName, murdererLastName, murderPlace, murderWeapon,
|
||||
explanation);
|
||||
|
||||
// Assert
|
||||
Assert.Equal(ownerId, solutionEntity.OwnerId);
|
||||
Assert.Equal(murdererFirstName, solutionEntity.MurdererFirstName);
|
||||
Assert.Equal(murdererLastName, solutionEntity.MurdererLastName);
|
||||
Assert.Equal(murderPlace, solutionEntity.MurderPlace);
|
||||
Assert.Equal(murderWeapon, solutionEntity.MurderWeapon);
|
||||
Assert.Equal(explanation, solutionEntity.Explaination);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,58 @@
|
||||
using Entities;
|
||||
|
||||
namespace TestEF;
|
||||
|
||||
public class TestSuccessEntity
|
||||
{
|
||||
private const int _userId = 42;
|
||||
private const int _inquiryId = 7;
|
||||
private const bool _isFinished = true;
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
SuccessEntity success = new SuccessEntity();
|
||||
Assert.Equal(0, success.UserId);
|
||||
Assert.Null(success.User);
|
||||
Assert.Equal(0, success.InquiryId);
|
||||
Assert.Null(success.Inquiry);
|
||||
Assert.False(success.IsFinished);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithIds()
|
||||
{
|
||||
SuccessEntity success = new SuccessEntity(_userId, _inquiryId, _isFinished);
|
||||
Assert.Equal(_userId, success.UserId);
|
||||
Assert.Null(success.User);
|
||||
Assert.Equal(_inquiryId, success.InquiryId);
|
||||
Assert.Null(success.Inquiry);
|
||||
Assert.True(success.IsFinished);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithNavigationProperties()
|
||||
{
|
||||
UserEntity user = new UserEntity();
|
||||
InquiryEntity inquiry = new InquiryEntity();
|
||||
SuccessEntity success = new SuccessEntity(user, inquiry, _isFinished);
|
||||
Assert.Equal(0, success.UserId);
|
||||
Assert.NotNull(success.User);
|
||||
Assert.Equal(0, success.InquiryId);
|
||||
Assert.NotNull(success.Inquiry);
|
||||
Assert.True(success.IsFinished);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithAllAttributes()
|
||||
{
|
||||
UserEntity user = new UserEntity();
|
||||
InquiryEntity inquiry = new InquiryEntity();
|
||||
SuccessEntity success = new SuccessEntity(_userId, user, _inquiryId, inquiry, _isFinished);
|
||||
Assert.Equal(_userId, success.UserId);
|
||||
Assert.NotNull(success.User);
|
||||
Assert.Equal(_inquiryId, success.InquiryId);
|
||||
Assert.NotNull(success.Inquiry);
|
||||
Assert.True(success.IsFinished);
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,57 @@
|
||||
using Entities;
|
||||
|
||||
namespace TestEF
|
||||
{
|
||||
public class TestUserEntity
|
||||
{
|
||||
private const string _username = "username";
|
||||
private const string _email = "example@email.com";
|
||||
private const string _password = "password";
|
||||
private const bool _isAdmin = true;
|
||||
private const int _id = 42;
|
||||
|
||||
[Fact]
|
||||
public void TestDefaultConstructor()
|
||||
{
|
||||
UserEntity user = new UserEntity();
|
||||
Assert.Equal(0, user.Id);
|
||||
Assert.Null(user.Username);
|
||||
Assert.Null(user.Email);
|
||||
Assert.Null(user.Password);
|
||||
Assert.False(user.IsAdmin);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithOnlyId()
|
||||
{
|
||||
UserEntity user = new UserEntity(_id);
|
||||
Assert.Equal(_id, user.Id);
|
||||
Assert.Null(user.Username);
|
||||
Assert.Null(user.Email);
|
||||
Assert.Null(user.Password);
|
||||
Assert.False(user.IsAdmin);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutId()
|
||||
{
|
||||
UserEntity user = new UserEntity(_username, _password, _email, _isAdmin);
|
||||
Assert.Equal(0, user.Id);
|
||||
Assert.Equal(_username, user.Username);
|
||||
Assert.Equal(_email, user.Email);
|
||||
Assert.Equal(_password, user.Password);
|
||||
Assert.True(user.IsAdmin);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TestConstructorWithoutAllAttributes()
|
||||
{
|
||||
UserEntity user = new UserEntity(_id, _username, _password, _email, _isAdmin);
|
||||
Assert.Equal(_id, user.Id);
|
||||
Assert.Equal(_username, user.Username);
|
||||
Assert.Equal(_email, user.Email);
|
||||
Assert.Equal(_password, user.Password);
|
||||
Assert.True(user.IsAdmin);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
namespace TestEF
|
||||
{
|
||||
public class UnitTest1
|
||||
{
|
||||
[Fact]
|
||||
public void Test1()
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Reference in new issue