public async Task <IHttpActionResult> DeleteRefractory([FromUri] int refId)  //optional
        {
            var authtor = await _uow.UserInfoService.GetUserById(User.Identity.GetUserId <int>());

            if (authtor == null)
            {
                return(this.Unauthorized());
            }

            if (authtor.IsBlocked)
            {
                return(BadRequest("Your account blocked."));
            }

            DTORefractory refractory = await _uow.RefractoryService.GetRefractoryByRefId(refId);

            if (refractory == null)
            {
                return(NotFound());
            }

            if (refractory.UserInfo.Id != authtor.Id)
            {
                return(BadRequest("It is not your refractory."));
            }

            if (!this.ModelState.IsValid)
            {
                return(BadRequest(this.ModelState));
            }

            await _uow.RefractoryService.DeleteRefractory(refId);

            return(Ok("Refractory removed"));
        }
        public async Task <IHttpActionResult> UnblockRefractory([FromUri] int refId)
        {
            DTORefractory refractory = await _uow.RefractoryService.GetRefractoryByRefId(refId);

            if (refractory == null)
            {
                return(NotFound());
            }

            if (!refractory.IsBlocked)
            {
                return(BadRequest("Refractory not blocked."));
            }

            var userId = this.User.Identity.GetUserId();

            if (userId == null || !User.IsInRole("admin"))
            {
                return(this.Unauthorized());
            }


            await _uow.ModeratorService.UnblockRefractory(refId);

            return(Ok("Refractory unblocked"));
        }
        public async Task <IHttpActionResult> EditRefractory([FromUri] int refId, [FromBody] RefractoryEditViewModel uRef)
        {
            var authtor = await _uow.UserInfoService.GetUserById(User.Identity.GetUserId <int>());

            if (authtor == null)
            {
                return(this.Unauthorized());
            }

            if (authtor.IsBlocked)
            {
                return(BadRequest("Your account blocked."));
            }

            DTORefractory refractory = await _uow.RefractoryService.GetRefractoryByRefId(refId);

            if (refractory == null)
            {
                return(NotFound());
            }

            if (refractory.UserInfo.Id != authtor.Id)
            {
                return(BadRequest("It is not your refractory."));
            }

            if (refractory.IsBlocked)
            {
                return(BadRequest("Refractory blocked."));
            }

            refractory.RefractoryDescription = uRef.RefractoryDescription;
            refractory.RefractoryType        = uRef.RefractoryType;
            refractory.RefractoryBrand       = uRef.RefractoryBrand;
            refractory.LastEdit = DateTime.Now;

            refractory.Density            = uRef.Density;
            refractory.MaxWorkTemperature = uRef.MaxWorkTemperature;
            refractory.Lime     = uRef.Lime;
            refractory.Alumina  = uRef.Alumina;
            refractory.Silica   = uRef.Silica;
            refractory.Magnesia = uRef.Magnesia;
            refractory.Carbon   = uRef.Carbon;
            refractory.Price    = uRef.Price;

            refractory.UserInfo = null;
            refractory.Comments = null;

            await _uow.RefractoryService.EditRefractory(refractory);

            return(Ok("Refractory edited"));
        }
        public async Task <IHttpActionResult> AddRefractory()
        {
            var authtor = await _uow.UserInfoService.GetUserById(User.Identity.GetUserId <int>());

            if (authtor == null)
            {
                return(this.Unauthorized());
            }

            if (authtor.IsBlocked)
            {
                return(BadRequest("Your account blocked."));
            }

            var            httpRequest = HttpContext.Current.Request;     //get request object
            HttpPostedFile refFile     = httpRequest.Files["RefPicture"]; //Gets the collection of files uploaded by the client, in multipart MIME format.

            if (refFile == null || refFile.ContentLength < 2)
            {
                return(BadRequest("No image"));
            }

            string filename = AddImage(refFile);  //add image for post


            DTORefractory newRefractory = new DTORefractory
            {
                RefractoryDescription = "", //descriptionRef Body (send next step EditRefractory by Id)
                RefractoryType        = httpRequest.Params["Type"],
                RefractoryBrand       = httpRequest.Params["Brand"],
                DateCreate            = DateTime.Now,
                UserInfoId            = authtor.Id,
                RefractoryPicture     = filename,
                Density            = float.Parse(httpRequest.Params["Density"]),
                MaxWorkTemperature = float.Parse(httpRequest.Params["MaxWorkTemperature"]),
                Lime     = float.Parse(httpRequest.Params["Lime"]),
                Alumina  = float.Parse(httpRequest.Params["Alumina"]),
                Silica   = float.Parse(httpRequest.Params["Silica"]),
                Magnesia = float.Parse(httpRequest.Params["Magnesia"]),
                Carbon   = float.Parse(httpRequest.Params["Carbon"]),
                Price    = float.Parse(httpRequest.Params["Price"])
            };

            if (!this.ModelState.IsValid)
            {
                return(BadRequest(this.ModelState));
            }

            await _uow.RefractoryService.AddRefractory(newRefractory);

            return(Content(HttpStatusCode.Created, "Refractory added"));
        }
Exemplo n.º 5
0
        public async Task EditRefractory(DTORefractory dtoRefractory)
        {
            var refractory = AutoMapper.Mapper.Map <DTORefractory, Refractory>(dtoRefractory);

            if (refractory.UserInfoId != 0)
            {
                await _uow.Refractory.Update(refractory);
            }
            else
            {
                throw new ArgumentException("Wrong data");
            }
        }
Exemplo n.º 6
0
        public async Task AddRefractory(DTORefractory dtoRefractory)
        {
            var refractory = AutoMapper.Mapper.Map <DTORefractory, Refractory>(dtoRefractory);

            if (refractory.RefractoryDescription != null)
            {
                await _uow.Refractory.Insert(refractory);
            }
            else
            {
                throw new ArgumentException("Wrong data");
            }
        }
Exemplo n.º 7
0
        public async Task <IHttpActionResult> AddComment([FromUri] int refId)
        {
            var    httpRequest = HttpContext.Current.Request;
            string comment     = httpRequest.Params["Coment"];

            DTORefractory refractory = await _uow.RefractoryService.GetRefractoryByRefId(refId);

            if (refractory == null)
            {
                return(NotFound());
            }

            var userId = this.User.Identity.GetUserId();

            if (userId == null)
            {
                return(this.Unauthorized());
            }

            if (comment.Length < 1)
            {
                ModelState.AddModelError("Body", "Please write comment.");
            }

            if (!this.ModelState.IsValid)
            {
                return(this.BadRequest(this.ModelState));
            }

            DTOUser user = await _uow.UserInfoService.GetUserById(User.Identity.GetUserId <int>());

            DTOComment dtoComment = new DTOComment {
                DateCreation = DateTime.Now, RefractoryId = refId, UserInfoId = user.Id, CommentBody = comment
            };

            await _uow.CommentService.AddComment(dtoComment);

            return(Content(HttpStatusCode.Created, "Comment added."));
        }
Exemplo n.º 8
0
        public async Task <IHttpActionResult> GetComments([FromUri] int refId)
        {
            if (!this.ModelState.IsValid)
            {
                return(this.BadRequest(this.ModelState));
            }

            DTORefractory refractory = await _uow.RefractoryService.GetRefractoryByRefId(refId);

            if (refractory == null)
            {
                return(NotFound());
            }

            if (refractory.IsBlocked)
            {
                return(BadRequest("This refractory blocked"));
            }

            var userId = User.Identity.GetUserId();

            if (userId == null)
            {
                return(this.Unauthorized());
            }

            List <CommentViewModel> comments = AutoMapper.Mapper.Map <IEnumerable <DTOComment>, List <CommentViewModel> >(
                await _uow.CommentService.GetCommentsForRefractory(refId));

            if (comments != null)
            {
                return(Ok(comments));
            }
            else
            {
                return(NotFound());
            }
        }
Exemplo n.º 9
0
        public async Task <IHttpActionResult> Delete([FromUri] int commentId)
        {
            if (!this.ModelState.IsValid)
            {
                return(this.BadRequest(this.ModelState));
            }

            if (User.Identity.GetUserName() == null)
            {
                return(this.Unauthorized());
            }

            var userId = User.Identity.GetUserId <int>();

            var comment = await _uow.CommentService.GetCommentById(commentId);

            if (comment == null)
            {
                return(NotFound());
            }

            DTORefractory post = await _uow.RefractoryService.GetRefractoryByRefId(comment.RefractoryId);

            if (post == null)
            {
                return(NotFound());
            }

            if (comment.UserInfoId != userId)
            {
                return(BadRequest("It is not your comment"));
            }

            await _uow.CommentService.DeleteComment(commentId);

            return(Ok("Comment deleted"));
        }