Пример #1
0
        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)));
            }
        }
Пример #2
0
        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)));
            }
        }
Пример #3
0
        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));
        }
Пример #4
0
        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));
            }
        }
Пример #5
0
        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));
            }
        }
Пример #6
0
        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)));
            }
        }
Пример #7
0
        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!"));
        }
Пример #8
0
        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)));
            }
        }
Пример #9
0
        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)));
            }
        }
Пример #10
0
        /// <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);
            }
        }
Пример #11
0
        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)));
            }
        }
Пример #12
0
        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)));
            }
        }
Пример #13
0
        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)));
            }
        }
Пример #14
0
        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)));
            }
        }
Пример #15
0
        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);
        }
Пример #16
0
        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));
        }
Пример #17
0
        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));
        }
Пример #18
0
        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));
        }
Пример #20
0
        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));
        }
Пример #21
0
        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));
        }
Пример #23
0
        /// <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);
            }
        }
Пример #24
0
        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));
        }
Пример #25
0
        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)));
        }
Пример #26
0
        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)));
            }
        }
Пример #27
0
        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));
        }
Пример #28
0
        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)));
            }
        }
Пример #29
0
        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));
            }
        }
Пример #30
0
        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)));
            }
        }