public IActionResult GetUserById(int userId)
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorMessageModel("Sem Autorização ou sem sessão inciada")));
}
try
{
UserDAO userDAO = new UserDAO(_connection, this._environment.ContentRootPath);
User user = userDAO.FindById(userId);
if (user == null)
{
return(BadRequest(new ErrorMessageModel("Utilizador não encontrado!")));
}
return(Ok(user));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public ActionResult <SuccessMessageModel> Reschedule(int id, DateModel date)
{
try{
int?employerId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (employerId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
WorkDAO workDao = new WorkDAO(_connection);
WorkDetailsModel work = workDao.FindById(id, (int)employerId);
if (work == null)
{
return(BadRequest(new ErrorMessageModel("O trabalho não existe ou não está associado ao Employer!")));
}
bool updated = workDao.updateDate(id, date);
if (updated)
{
return(Ok(new SuccessMessageModel("Data atualizada com sucesso!")));
}
else
{
return(BadRequest(new ErrorMessageModel("Erro! A data não foi atualizada!")));
}
} catch (Exception e) {
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public async Task <IActionResult> Create(PuplicationCreate model)
{
int?uId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (uId == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
if (model.ImagePath == null)
{
model.ImagePath = 0;
}
model.UtilizadorId = (int)uId;
PublicationDAO publicationDao = new PublicationDAO(_connection);
Publication resultPublication = publicationDao.Create(model);
resultPublication.UtilizadorId = (int)uId;
resultPublication.Tittle = model.Tittle;
resultPublication.Tradable = model.Tradable;
resultPublication.UserAddress = model.UserAddress;
resultPublication.InstrumentCondition = model.InstrumentCondition;
resultPublication.InitialPrice = model.InitialPrice;
resultPublication.Category = model.Category;
return(Ok(resultPublication));
}
public IActionResult deleteMainPicture(int publicationId, ImageName image)
{
try
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
PublicationDAO pDAO = new PublicationDAO(_connection);
bool deleted = pDAO.deleteMainImage(publicationId, image);
if (deleted == true)
{
return(Ok("Imagem apagada!"));
}
else
{
return(BadRequest("Imagem não apagada ou inexistente!"));
}
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult UploadImagesToPost(int id, [FromForm] IFormFileCollection images, IFormFile mainImage)
{
try
{
int?uId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (uId == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
PublicationDAO pDAO = new PublicationDAO(_connection);
Publication p = pDAO.FindById(id);
if (p.UtilizadorId != uId)
{
return(NotFound("Publicação não encontrada!"));
}
bool result = pDAO.UploadImagesToPost(id, images, mainImage);
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult UploadImagesToPost(int id,
[FromForm] IFormFileCollection images,
[FromForm] IFormFile mainImage)
{
try
{
int?employerID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (employerID == null)
{
return(Unauthorized(new ErrorMessageModel("Não Autorizado!")));
}
IJobDAO jobDAO = new JobDAO(_connection, this._environment.ContentRootPath);
if (jobDAO.FindById(id, (int)employerID) == null)
{
return(NotFound(new ErrorMessageModel("Post não encontrado!")));
}
SuccessMessageModel message = jobDAO.UploadImagesToPost(id, images, mainImage);
return(Ok(message));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public ActionResult <bool> CreateChat(int matchId, int publicationId, string publicationName)
{
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (userId == null)
{
return(Unauthorized(new ErrorExceptionModel("Utilizador não tem autorização!")));
}
UserDAO userDAO = new UserDAO(_connection);
User user = userDAO.FindById(matchId);
if (userId < 0)
{
return(UnprocessableEntity(new ErrorExceptionModel("Utilizador não existe!")));
}
Chat chat = new Chat();
chat.UserId = (int)userId;
chat.PublicationId = publicationId;
chat.PublicationName = publicationName;
ChatDAO chatDAO = new ChatDAO(_connection);
chat.ChatId = chatDAO.CreateChatId();
chatDAO.CreateChat(chat);
chat.UserId = matchId;
chatDAO.CreateChat(chat);
return(Ok("Concluído!"));
}
public IActionResult deleteImage(int post, ImageName image)
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorMessageModel("Sem Autorização ou sem sessão inciada")));
}
if (image == null)
{
return(BadRequest(new ErrorMessageModel("Nome de imagem não enviado!")));
}
try
{
JobDAO jobDAO = new JobDAO(_connection, this._environment.ContentRootPath);
bool deleted = jobDAO.deleteImage((int)id, post, image);
if (deleted == true)
{
return(Ok(new SuccessMessageModel("Imagem apagada!")));
}
else
{
return(BadRequest(new ErrorMessageModel("Imagem não apagada ou inexistente!")));
}
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
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)));
}
}
/// <summary>
/// Override de OnConnectedAsync
/// Este metodo e chamado quando e estabelecida uma conexão ao hub e
/// adiciona a conexão à BD
/// </summary>
/// <returns>Retorna um callback UserConnected com o id de conexão</returns>
public override async Task OnConnectedAsync()
{
try
{
await Clients.All.SendAsync("UserConnected", Context.ConnectionId);
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)Context.User.Identity);
if (userId == null)
{
throw new Exception("O utilizador não existe!");
}
ChatDAO chatDao = new ChatDAO(_connection);
if (chatDao.GetChatConnectionFromUserId((int)userId) == null)
{
chatDao.AddChatHubConnection((int)userId, Context.ConnectionId);
}
else
{
chatDao.UpdateChatHubConnection((int)userId, Context.ConnectionId);
}
await base.OnConnectedAsync();
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ActionResult CreateChat(int matchId)
{
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (userId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não tem autorização ou não existe!")));
}
try
{
ChatDAO chatDAO = new ChatDAO(_connection);
if (chatDAO.getChatIdWithTargetUser((int)userId, matchId) == null)
{
Chat chat = new Chat();
chat.UserId = (int)userId;
chat.ChatId = chatDAO.CreateChatId();
chatDAO.CreateChat(chat);
chat.UserId = matchId;
chatDAO.CreateChat(chat);
return(Ok(new SuccessMessageModel("Chat criado!")));
}
return(Ok(new SuccessMessageModel("O Chat já existe!")));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public ActionResult <Message> getLastMessageFromChat(int id)
{
int?userId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (userId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não tem autorização ou não existe!")));
}
try
{
ChatDAO chatDao = new ChatDAO(_connection);
Message message = chatDao.GetLastMessageFromChat(id, (int)userId);
if (message != null)
{
return(Ok(message));
}
return(BadRequest(new ErrorMessageModel("Não existe connection ID!")));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public IActionResult deleteProfilePicture()
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
try
{
UserDAO userDAO = new UserDAO(_connection);
bool deleted = userDAO.deleteImage((int)id);
if (deleted == true)
{
return(Ok(new SuccessExceptionModel("Imagem apagada!")));
}
else
{
return(BadRequest(new ErrorExceptionModel("Imagem não apagada ou inexistente!")));
}
}
catch (Exception e)
{
return(BadRequest(new ErrorExceptionModel(e.Message)));
}
}
public ActionResult <List <FavoriteModel> > FavoritesList()
{
try
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorMessageModel("Sem Autorização ou sem sessão inciada")));
}
EmployerDAO employerDAO = new EmployerDAO(_connection);
List <FavoriteModel> favorites = employerDAO.FavoritesList((int)id).ToList();
if (favorites == null)
{
return(NotFound(new ErrorMessageModel("Lista de favoritos Inexistente!")));
}
return(favorites);
}
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 ActionResult <List <PendingJobModel> > PendingJobsList()
{
int?employerID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (employerID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
EmployerDAO employerDAO = new EmployerDAO(_connection);
List <PendingJobModel> pendingJobs = employerDAO.PendingJobsList((int)employerID).ToList();
return(Ok(pendingJobs));
}
public ActionResult <List <JobPostReturnedModel> > GetAllEmployerPosts()
{
int?employerID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (employerID == null)
{
return(Unauthorized());
}
IJobDAO jobDAO = new JobDAO(_connection);
List <JobPostReturnedModel> listPosts = _mapper.Map <List <JobPostReturnedModel> >(jobDAO.GetEmployerPosts((int)employerID));
return(Ok(listPosts));
}
public ActionResult <Chat[]> GetChatsArray()
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorExceptionModel("Utilizador não tem autorização!")));
}
ChatDAO chatDAO = new ChatDAO(_connection);
Chat[] chatArray = chatDAO.GetChats((int)id);
return(chatArray);
}
public ActionResult <List <MateReviewsModel> > MateReviewsList()
{
int?mateID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
// caso o mate id seja nulo
if (mateID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
ReviewMateDAO reviewDao = new ReviewMateDAO(_connection);
List <MateReviewsModel> reviewsList = reviewDao.MateReviewsList((int)mateID);
return(Ok(reviewsList));
}
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 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 ActionResult <MateReviewsModel> ReviewMate(int mate, MateReviewsModel revModel)
{
int?employerID = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
// caso o mate id seja nulo
if (employerID == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
MateReview review = _mapper.Map <MateReview>(revModel);
IReviewMateDAO ReviewMateDAO = new ReviewMateDAO(_connection);
MateReviewsModel reviewModel = _mapper.Map <MateReviewsModel>(ReviewMateDAO.ReviewMate((int)employerID, mate, review));
return(Ok(reviewModel));
}
/// <summary>
/// Override de OnDisconnectedAsync
/// Este metodo e chamado quando deixa de esistir uma conexão ao hub e
/// remove a conexão da BD
/// </summary>
/// <returns>Retorna uma task assincrona UserDisconnected com o id de conexão</returns>
public override async Task OnDisconnectedAsync(Exception ex)
{
try
{
await Clients.All.SendAsync("UserDisconnected", Context.ConnectionId);
int userId = (int)ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)Context.User.Identity);
ChatDAO chatDao = new ChatDAO(_connection);
chatDao.DeleteChatHubConnection(Context.ConnectionId);
await base.OnDisconnectedAsync(ex);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public ActionResult <Publication> DeletePublication(int publicationId)
{
int?uId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (uId == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
UserDAO userDAO = new UserDAO(_connection);
Publication publication = userDAO.FindPublicationById(publicationId);
if (publication.UtilizadorId != uId)
{
return(NotFound("Publicação não encontrada!"));
}
bool deleted = userDAO.DeletePublication(publicationId);
return(Ok(deleted));
}
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 <Message> > GetMessages(int chatId)
{
int?loggedUser = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (loggedUser == null)
{
return(Unauthorized("Utilizador não autorizado ou inexistente!"));
}
try
{
ChatDAO chatDAO = new ChatDAO(_connection);
List <Message> messageList = chatDAO.GetMessageList(chatId, (int)loggedUser);
return(Ok(messageList));
}
catch (Exception e)
{
return(BadRequest(new ErrorMessageModel(e.Message)));
}
}
public ActionResult <WorkModel> Create(WorkModel work)
{
int?employerId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (employerId == null)
{
return(Unauthorized(new ErrorMessageModel("Utilizador não existe!")));
}
IWorkDAO WorkDao = new WorkDAO(_connection);
Job JobModel = _mapper.Map <Job>(work);
WorkModel result = _mapper.Map <WorkModel>(WorkDao.Create((int)employerId, JobModel));
if (result == null)
{
return(BadRequest(new ErrorMessageModel("Mate ou Post não encontrados!")));
}
return(Ok(result));
}
public IActionResult UpdatePassword(UserUpdatePassword passwordUpdateModel)
{
try
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
UserDAO userDAO = new UserDAO(_connection);
bool newPass = userDAO.UpdatePassword(passwordUpdateModel, id);
return(Ok(new SuccessExceptionModel("Password alterada com sucesso!")));
}
catch (Exception ex)
{
return(BadRequest(new ErrorExceptionModel(ex.Message)));
}
}
public IActionResult DeletePublicationfromFavorites(int pId)
{
try
{
int?uId = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (uId == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
UserDAO userDAO = new UserDAO(_connection);
bool reult = userDAO.DeletePublicationFromFavorites((int)uId, pId);
return(Ok(reult));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public IActionResult UploadProfilePic(IFormFile profilePic)
{
try
{
int?id = ClaimHelper.GetIdFromClaimIdentity((ClaimsIdentity)this.ControllerContext.HttpContext.User.Identity);
if (id == null)
{
return(Unauthorized(new ErrorExceptionModel("Sem Autorização ou sem sessão inciada")));
}
UserDAO userDAO = new UserDAO(_connection);
bool message = userDAO.UploadImagesToUser((int)id, profilePic);
return(Ok(message));
}
catch (Exception ex)
{
return(BadRequest(new ErrorExceptionModel(ex.Message)));
}
}
