public void CanRegisterMateTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
Assert.Equal(testMate.FirstName, returned.FirstName);
Assert.Equal(testMate.LastName, returned.LastName);
Assert.Equal(testMate.UserName, returned.UserName);
Assert.Equal(testMate.Password, returned.Password);
Assert.Equal(testMate.Email, returned.Email);
Assert.Equal(testMate.Description, returned.Description);
Assert.Equal(testMate.Address, returned.Address);
Assert.Equal(testMate.Categories, returned.Categories);
Assert.Equal(testMate.Rank, returned.Rank);
Assert.Equal(testMate.Range, returned.Range);
_fixture.Dispose();
}
public ActionResult <List <JobPostReturnedModel> > GetAvailableWorks([FromQuery(Name = "categories")] Categories[] categories, [FromQuery(Name = "address")] string address, [FromQuery(Name = "distance")] int?distance, [FromQuery(Name = "rating")] int?rating)
{
try
{
int?mateID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (mateID == null)
{
return(NotFound(new ErrorMessageModel("Utilizador não existe!")));
}
MateDAO mateDao = new MateDAO(_connection);
Mate mate = mateDao.FindMateById((int)mateID);
if (address == null)
{
address = mate.Address;
}
IJobDAO jobDAO = new JobDAO(_connection);
List <JobPostReturnedModel> postsList = _mapper.Map <List <JobPostReturnedModel> >(jobDAO.GetJobs(categories, address, distance, rating, (int)mateID));
return(Ok(postsList));
}
catch (Exception ex)
{
return(UnprocessableEntity(new ErrorMessageModel(ex.Message)));
}
}
public void CanGetEncryptedTokenTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
string refreshToken = RefreshTokenHelper.generateRefreshToken();
RefreshTokenDAO refreshTokenDAO = new RefreshTokenDAO(_connection);
refreshTokenDAO.saveEncryptedRefreshToken(refreshToken, returned.Email);
EncryptedRefreshTokenModel returnedToken = refreshTokenDAO.GetEncryptedRefreshTokenModel(returned.Email);
Assert.Equal(returned.Email, returnedToken.Email);
Assert.True(PasswordOperations.VerifyHash(refreshToken, returnedToken.Hash, returnedToken.Salt));
_fixture.Dispose();
}
public void CanMateListWorkCategoriesTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
List <CategoryModel> category = MateDAO.CategoriesList(returned.Id).ToList();
Assert.Equal(Categories.PLUMBING, category.ElementAt(0).categories);
Assert.Equal(Categories.CLEANING, category.ElementAt(1).categories);
_fixture.Dispose();
}
public void CanUserUpdatePasswordTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Jessica";
testMate.LastName = "Coelho";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Ordem";
testMate.Categories = new[] { Categories.FURNITURE_ASSEMBLE, Categories.TRANSPORTATION };
testMate.Rank = Ranks.MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
UserDAO userDAO = new UserDAO(_connection);
PasswordUpdateModel newPass = new PasswordUpdateModel();
newPass.Password = "******";
newPass.OldPassword = "******";
Assert.True(userDAO.UpdatePassword(newPass, returned.Id));
_fixture.Dispose();
}
public void CanRegisterMateWithoutDescriptionTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
Assert.Equal(testMate.FirstName, returned.FirstName);
Assert.Equal(testMate.LastName, returned.LastName);
Assert.Equal(testMate.UserName, returned.UserName);
Assert.Equal(testMate.Password, returned.Password);
Assert.Equal(testMate.Email, returned.Email);
Assert.Equal(testMate.Address, returned.Address);
Assert.Equal(testMate.Categories, returned.Categories);
Assert.Equal(testMate.Rank, returned.Rank);
Assert.Equal(testMate.Range, returned.Range);
_fixture.Dispose();
}
public void ReturnExceptionWhenEmailDontExistSaveEncryptTokenTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
string refreshToken = RefreshTokenHelper.generateRefreshToken();
RefreshTokenDAO refreshTokenDAO = new RefreshTokenDAO(_connection);
Assert.Throws <Exception>(() => refreshTokenDAO.saveEncryptedRefreshToken(refreshToken, "*****@*****.**"));
_fixture.Dispose();
}
public ActionResult <MateProfileModel> GetMateById(int id)
{
MateDAO mateDAO = new MateDAO(_connection);
MateProfileModel returned = _mapper.Map <MateProfileModel>(mateDAO.FindMateById(id));
return(Ok(returned));
}
public void CanGetMateWithoutDescriptionByIdTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Jessica";
testMate.LastName = "Coelho";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Address = "Ordem";
testMate.Categories = new[] { Categories.FURNITURE_ASSEMBLE, Categories.TRANSPORTATION };
testMate.Rank = Ranks.MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
Mate m = MateDAO.FindMateById(returnedMate.Id);
Assert.Equal(returnedMate.Id, m.Id);
Assert.Equal(returnedMate.UserName, m.UserName);
Assert.Equal(returnedMate.FirstName, m.FirstName);
Assert.Equal(returnedMate.LastName, m.LastName);
Assert.Equal(returnedMate.Email, m.Email);
Assert.Equal(returnedMate.Address, m.Address);
_fixture.Dispose();
}
public void CanMateAddCategoriesTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Jessica";
testMate.LastName = "Coelho";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Ordem";
testMate.Categories = new[] { Categories.FURNITURE_ASSEMBLE, Categories.TRANSPORTATION };
testMate.Rank = Ranks.MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
CategoryModel category = new CategoryModel();
category.categories = Categories.CLEANING;
CategoryModel[] categories = { category };
MateDAO.AddCategory(returned.Id, categories);
Assert.True(MateDAO.CategoriesList(returned.Id).ToList().Exists(a => a.categories == Categories.CLEANING));
_fixture.Dispose();
}
public void CanMakeOfferOnJobWithoutPriceTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returned = EmployerDAO.Create(testEmployer);
IJobDAO jobPostDAO = new JobDAO(_connection);
JobPost testPost = new JobPost();
testPost.Title = "Canalização Estourada";
testPost.Category = Categories.PLUMBING;
testPost.Description = "Grande estouro nos canos da sanita";
testPost.Tradable = true;
testPost.InitialPrice = 60.6;
testPost.Address = "Rua sem fim";
testPost.PaymentMethod = new[] { Payment.PAYPAL, Payment.MONEY };
JobPost jobReturned = jobPostDAO.Create(returned.Id, testPost);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
Offer mateOffer = new Offer();
mateOffer.Price = 0;
mateOffer.JobPost = jobReturned;
Offer offer = jobPostDAO.makeOfferOnJob(mateOffer, returnedMate.Id);
//Verificar que o preço foi estabelicido com o default
Assert.Equal(testPost.InitialPrice, offer.Price);
Assert.Equal(mateOffer.JobPost.Id, offer.JobPost.Id);
Assert.False(offer.Approved);
_fixture.Dispose();
}
public void ReturnEmptyWhenSearchJobWithWrongLocationTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Rua Eng. Luís Carneiro Leão, Figueiró";
Employer returned = EmployerDAO.Create(testEmployer);
IJobDAO jobPostDAO = new JobDAO(_connection);
JobPost testPost = new JobPost();
testPost.Title = "Canalização Estourada";
testPost.Category = Categories.PLUMBING;
testPost.Description = "Grande estouro nos canos da sanita";
testPost.Tradable = true;
testPost.InitialPrice = 60.6;
testPost.Address = "Rua sem fim";
testPost.PaymentMethod = new[] { Payment.PAYPAL, Payment.MONEY };
JobPost jobReturned = jobPostDAO.Create(returned.Id, testPost);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Random City";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
Offer mateOffer = new Offer();
mateOffer.Price = 20;
mateOffer.Approved = false;
mateOffer.JobPost = jobReturned;
Offer offer = jobPostDAO.makeOfferOnJob(mateOffer, returnedMate.Id);
Categories[] categories = { Categories.PLUMBING };
Assert.Empty(jobPostDAO.GetJobs(categories, testMate.Address, 400, null, returnedMate.Id));
_fixture.Dispose();
}
public void CanSearchMateWithCategoriesAddressRankAndDistanceTest()
{
IMateDAO<Mate> MateDAO = new MateDAO(_connection);
Mate firstMate = new Mate();
firstMate.FirstName = "Marcelo";
firstMate.LastName = "Carvalho";
firstMate.UserName = "******";
firstMate.Password = "******";
firstMate.Email = "*****@*****.**";
firstMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
firstMate.Address = "Rua Eng. Luís Carneiro Leão, Figueiró";
firstMate.Categories = new[] { Categories.CLEANING, Categories.ELECTRICITY };
firstMate.Rank = Ranks.MATE;
firstMate.Range = 50;
Mate returnedFirst = MateDAO.Create(firstMate);
Mate secondMate = new Mate();
secondMate.FirstName = "Samuel";
secondMate.LastName = "Cunha";
secondMate.UserName = "******";
secondMate.Password = "******";
secondMate.Email = "*****@*****.**";
secondMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
secondMate.Address = "Vila Nova de Gaia";
secondMate.Categories = new[] { Categories.GARDENING, Categories.FURNITURE_ASSEMBLE };
secondMate.Rank = Ranks.SUPER_MATE;
secondMate.Range = 20;
Mate returnedSecond = MateDAO.Create(secondMate);
Categories[] categories = { Categories.CLEANING, Categories.GARDENING };
string myAddress = "Rua de Salgueiros, Penafiel";
List<Mate> mates = MateDAO.GetMates(categories, myAddress, Ranks.MATE, 40, null);
Mate[] matesArray = mates.ToArray();
Assert.Equal(returnedFirst.FirstName, matesArray[0].FirstName);
Assert.Equal(returnedFirst.LastName, matesArray[0].LastName);
Assert.Equal(returnedFirst.UserName, matesArray[0].UserName);
Assert.Equal(returnedFirst.Email, matesArray[0].Email);
Assert.Equal(returnedFirst.Description, matesArray[0].Description);
Assert.Equal(returnedFirst.Address, matesArray[0].Address);
Array.Reverse(matesArray[0].Categories);
Assert.Equal(returnedFirst.Categories, matesArray[0].Categories);
Assert.Equal(returnedFirst.Rank, matesArray[0].Rank);
Assert.Equal(returnedFirst.Range, matesArray[0].Range);
Assert.Single(matesArray);
_fixture.Dispose();
}
public void CanIgnoreValidJobTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Rua Eng. Luís Carneiro Leão, Nº 54 4590-244 Porto, Portugal";
Employer returned = EmployerDAO.Create(testEmployer);
IJobDAO jobPostDAO = new JobDAO(_connection);
JobPost testPost = new JobPost();
testPost.Title = "Canalização Estourada";
testPost.Category = Categories.PLUMBING;
testPost.Description = "Grande estouro nos canos da sanita";
testPost.Tradable = true;
testPost.InitialPrice = 60.6;
testPost.Address = "Rua de Salgueiros, Penafiel";
testPost.PaymentMethod = new[] { Payment.PAYPAL, Payment.MONEY };
JobPost jobReturned = jobPostDAO.Create(returned.Id, testPost);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Rua de Salgueiros, Penafiel";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
IgnoredJobModel job = new IgnoredJobModel();
job.Id = jobReturned.Id;
Assert.True(MateDAO.IgnoreJobPost(returnedMate.Id, job));
Categories[] categories = { Categories.PLUMBING };
Assert.Empty(jobPostDAO.GetJobs(categories, testMate.Address, 400, null, returnedMate.Id));
_fixture.Dispose();
}
public ActionResult <List <MateModelExtended> > GetMates(
[FromQuery(Name = "categories")] Categories[] categories,
[FromQuery(Name = "address")] string address,
[FromQuery(Name = "rank")] Ranks?rank,
[FromQuery(Name = "distance")] int?distance,
[FromQuery(Name = "rating")] int?rating)
{
IMateDAO <Mate> mateDAO = new MateDAO(_connection);
List <MateModelExtended> matesList = _mapper.Map <List <MateModelExtended> >(mateDAO.GetMates(categories, address, rank, distance, rating));
return(Ok(matesList));
}
public void CanVerifyIfUserIsNotFromChatTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returned = EmployerDAO.Create(testEmployer);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
ChatDAO chatDao = new ChatDAO(_connection);
int chatId = chatDao.CreateChatId();
Chat chat = new Chat();
chat.UserId = returned.Id;
chat.ChatId = chatId;
chatDao.CreateChat(chat);
chat.UserId = returnedMate.Id;
chatDao.CreateChat(chat);
bool user1IsFromChat = chatDao.IsUserFromChat(999999999, returned.Id);
bool user2IsFromChat = chatDao.IsUserFromChat(999999999, returnedMate.Id);
Assert.False(user1IsFromChat);
Assert.False(user2IsFromChat);
_fixture.Dispose();
}
public ActionResult <MateModel> Create(MateRegister regMate)
{
try
{
Mate mate = _mapper.Map <Mate>(regMate);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
MateModel mateModel = _mapper.Map <MateModel>(MateDAO.Create(mate));
return(Ok(mateModel));
}
catch (Exception ex)
{
return(BadRequest(new ErrorMessageModel(ex.Message)));
}
}
public ActionResult <List <CategoryModel> > CategoriesList()
{
int?mateID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (mateID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
MateDAO mateDAO = new MateDAO(_connection);
List <CategoryModel> categories = mateDAO.CategoriesList((int)mateID).ToList();
return(categories);
}
public void CanUserAddReportTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueir";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returnedEmployer = EmployerDAO.Create(testEmployer);
IReportDAO ReportDAO = new ReportDAO(_connection);
Report reportTest = new Report();
reportTest.Id = 1;
reportTest.Reason = Reasons.INADEQUATE_BEHAVIOUR;
reportTest.ReportedId = 35;
reportTest.ReporterId = 34;
reportTest.Comment = "O trabalho que fez nao presta";
Report repReturned = ReportDAO.ReportUser(returnedEmployer.Id, returnedMate.Id, reportTest);
Assert.Equal(reportTest.Id, repReturned.Id);
Assert.Equal(reportTest.Reason, repReturned.Reason);
Assert.Equal(reportTest.ReportedId, repReturned.ReportedId);
Assert.Equal(reportTest.ReporterId, repReturned.ReporterId);
Assert.Equal(reportTest.Comment, repReturned.Comment);
_fixture.Dispose();
}
public void CanUpdateChatHubConnectionTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returned = EmployerDAO.Create(testEmployer);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
ChatDAO chatDao = new ChatDAO(_connection);
chatDao.AddChatHubConnection(returned.Id, "connection1");
chatDao.AddChatHubConnection(returnedMate.Id, "connection2");
chatDao.UpdateChatHubConnection(returned.Id, "connection1Replaced");
chatDao.UpdateChatHubConnection(returnedMate.Id, "connection2Replaced");
ChatConnection connection1 = chatDao.GetChatConnectionFromUserId(returned.Id);
ChatConnection connection2 = chatDao.GetChatConnectionFromUserId(returnedMate.Id);
Assert.Equal("connection1Replaced", connection1.Connection);
Assert.Equal(returned.Id, connection1.UserId);
Assert.Equal("connection2Replaced", connection2.Connection);
Assert.Equal(returnedMate.Id, connection2.UserId);
_fixture.Dispose();
}
public ActionResult <Categories> AddCategory(CategoryModel[] category)
{
int?mateID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (mateID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
MateDAO mateDAO = new MateDAO(_connection);
mateDAO.AddCategory((int)mateID, category);
return(Ok(category));
}
public void CanUserRecoverPasswordTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Samuel";
testMate.LastName = "Cunha";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Quero recuperar a pass";
testMate.Address = "Aparecida";
testMate.Categories = new[] { Categories.GARDENING };
testMate.Rank = Ranks.MATE;
testMate.Range = 10;
Mate returned = MateDAO.Create(testMate);
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes("RQj!O9+Sq|D8XjYa|}kgnk|}ZaQUso)EMF48Fx1~0n~^~%]n|O{NqH(&5RqXbx7");
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Email, testMate.Email.ToString())
}),
Expires = DateTime.UtcNow.AddMinutes(10),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
var tokenString = tokenHandler.WriteToken(token);
String auxResetToken = tokenString;
PasswordOperations.NewPasswordRequest("*****@*****.**", auxResetToken);
LoginDAO loginDAO = new LoginDAO(_connection);
RecoverPasswordModel recoverPassword = new RecoverPasswordModel();
recoverPassword.Email = "*****@*****.**";
recoverPassword.Password = "******";
recoverPassword.ConfirmPassword = "******";
recoverPassword.Token = tokenString;
Assert.True(loginDAO.RecoverPassword(recoverPassword, returned.Email));
_fixture.Dispose();
}
public IActionResult Update(MateUpdate mateUpdate)
{
int?mateID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (mateID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
Mate mate = _mapper.Map <Mate>(mateUpdate);
MateDAO mateDAO = new MateDAO(_connection);
mateDAO.Update(mate, (int)mateID);
return(Ok(new SuccessMessageModel("Atualizado com sucesso!")));
}
public void CanEmployerAddReviewTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returnedEmp = EmployerDAO.Create(testEmployer);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueir";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returned = MateDAO.Create(testMate);
IReviewMateDAO ReviewMateDAO = new ReviewMateDAO(_connection);
MateReview reviewsTest = new MateReview();
reviewsTest.Id = 5;
reviewsTest.Rating = 4;
reviewsTest.Comment = "O trolha fez um trabalho excelente!";
MateReview revReturned = ReviewMateDAO.ReviewMate(returnedEmp.Id, returned.Id, reviewsTest);
Assert.Equal(reviewsTest.Id, revReturned.Id);
Assert.Equal(reviewsTest.Rating, revReturned.Rating);
Assert.Equal(reviewsTest.Comment, revReturned.Comment);
_fixture.Dispose();
}
public void ReturnExceptionCreatingChatWithUserId0Test()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returned = EmployerDAO.Create(testEmployer);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
ChatDAO chatDao = new ChatDAO(_connection);
int chatId = chatDao.CreateChatId();
Chat chat = new Chat();
chat.UserId = 0;
chat.ChatId = chatId;
Assert.Throws <Exception>(() => chatDao.CreateChat(chat));
_fixture.Dispose();
}
public ActionResult IgnoreJobPost([FromBody] IgnoredJobModel job)
{
int?mateID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (mateID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
MateDAO mateDAO = new MateDAO(_connection);
bool result = mateDAO.IgnoreJobPost((int)mateID, job);
if (!result)
{
return(UnprocessableEntity(new ErrorMessageModel("Publicação Inválida!")));
}
return(Ok(new SuccessMessageModel("Result : " + result)));
}
public ActionResult <List <MateReviewsModel> > MateReviewsList(int id)
{
int?EmployerID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
// caso o employerId seja nulo
if (EmployerID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
MateDAO mateDao = new MateDAO(_connection);
if (mateDao.FindMateById(id) == null)
{
return(NotFound(new ErrorMessageModel("Mate não Encontrado")));
}
ReviewMateDAO reviewDao = new ReviewMateDAO(_connection);
List <MateReviewsModel> reviewsList = reviewDao.MateReviewsList(id);
return(Ok(reviewsList));
}
public void CanEmployerRemoveFavoriteMateTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Jessica";
testMate.LastName = "Coelho";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Ordem";
testMate.Categories = new[] { Categories.FURNITURE_ASSEMBLE, Categories.TRANSPORTATION };
testMate.Rank = Ranks.MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
IEmployerDAO <Employer> employerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Ema";
testEmployer.LastName = "Coelho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lousada";
Employer returnedEmployer = employerDAO.Create(testEmployer);
int?returnedId = employerDAO.AddFavorite(returnedEmployer.Id, returnedMate.Id);
int?deletedID = employerDAO.RemoveFavorite(returnedEmployer.Id, returnedMate.Id);
Assert.Equal(returnedMate.Id, deletedID);
_fixture.Dispose();
}
public void CanEmployerListFavoriteMatesTest()
{
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Jessica";
testMate.LastName = "Coelho";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Ordem";
testMate.Categories = new[] { Categories.FURNITURE_ASSEMBLE, Categories.TRANSPORTATION };
testMate.Rank = Ranks.MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
IEmployerDAO <Employer> employerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Ema";
testEmployer.LastName = "Coelho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lousada";
Employer returnedEmployer = employerDAO.Create(testEmployer);
employerDAO.AddFavorite(returnedEmployer.Id, returnedMate.Id);
List <FavoriteModel> favoriteModels = employerDAO.FavoritesList(returnedEmployer.Id).ToList();
Assert.Equal(returnedMate.Email, favoriteModels.Find(a => a.Email == returnedMate.Email).Email);
_fixture.Dispose();
}
public void ReturnFalselWhenIgnoringAJobThatDoesntExistTest()
{
IEmployerDAO <Employer> EmployerDAO = new EmployerDAO(_connection);
Employer testEmployer = new Employer();
testEmployer.FirstName = "Marcelo";
testEmployer.LastName = "Carvalho";
testEmployer.UserName = "******";
testEmployer.Password = "******";
testEmployer.Email = "*****@*****.**";
testEmployer.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testEmployer.Address = "Lixa";
Employer returned = EmployerDAO.Create(testEmployer);
IMateDAO <Mate> MateDAO = new MateDAO(_connection);
Mate testMate = new Mate();
testMate.FirstName = "Miguel";
testMate.LastName = "Dev";
testMate.UserName = "******";
testMate.Password = "******";
testMate.Email = "*****@*****.**";
testMate.Description = "Lorem Ipsum is simply dummy text of the printing and typesetting industry.";
testMate.Address = "Figueiró";
testMate.Categories = new[] { Categories.CLEANING, Categories.PLUMBING };
testMate.Rank = Ranks.SUPER_MATE;
testMate.Range = 20;
Mate returnedMate = MateDAO.Create(testMate);
IgnoredJobModel job = new IgnoredJobModel();
job.Id = 1000;
Assert.False(MateDAO.IgnoreJobPost(returnedMate.Id, job));
_fixture.Dispose();
}
