public RegisteredAnimal MarkAs(string userId, Guid rAnimalId, Status status, string title, string description, Coordinate coordinates)
        {
            if (status.Equals(Status.Found))
            {
                var foundRAnimal = _registeredAnimalProvider.Get(rAnimalId);
                if (foundRAnimal == null)
                {
                    throw new ApiException(HttpStatusCode.Forbidden, ApiError.NotFound);
                }
                if (!foundRAnimal.UserId.Equals(userId))
                {
                    throw new ApiException(HttpStatusCode.Forbidden, ApiError.AccessForbidden);
                }

                //remove from animal list
                _animalDataProvider.Remove(foundRAnimal.Animal);

                //remove link
                foundRAnimal.Animal = null;
                _registeredAnimalProvider.Update(foundRAnimal);

                _unitOfWork.Commit();

                return(RegisteredAnimalMapper.DtoS(foundRAnimal));
            }

            var lostRAnimal = _registeredAnimalProvider.Get(rAnimalId);

            if (lostRAnimal == null)
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.NotFound);
            }
            if (!lostRAnimal.UserId.Equals(userId))
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.AccessForbidden);
            }

            var animal = new DAL.Entity.Animal()
            {
                Image       = lostRAnimal.Image,
                Title       = string.IsNullOrEmpty(title) ? lostRAnimal.Name : title,
                Description = string.IsNullOrEmpty(description) ? "" : description,
                UploadDate  = DateTimeOffset.Now,
                Status      = Status.Lost,
                Coordinates = new List <DAL.Entity.Coordinate>()
                {
                    CoordinateMapper.StoD(coordinates)
                }
            };

            lostRAnimal.Animal = animal;

            var updatedAnimal = _registeredAnimalProvider.Update(lostRAnimal);

            _unitOfWork.Commit();

            return(RegisteredAnimalMapper.DtoS(updatedAnimal));
        }
        public RegisteredAnimal GetById(Guid id)
        {
            var animal = _registeredAnimalProvider.Get(id);

            if (animal == null)
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.NotFound);
            }

            return(RegisteredAnimalMapper.DtoS(animal));
        }
        public IEnumerable <RegisteredAnimal> GetWithPagination(string userId, ushort skip, ushort count)
        {
            var rAnimals = _registeredAnimalProvider.GetAll(userId, skip, count);

            if (rAnimals == null)
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.NotFound);
            }

            return(RegisteredAnimalMapper.DtoS(rAnimals));
        }
        public IActionResult Post([FromBody] RegisteredAnimal rAnimal)
        {
            try
            {
                string userId      = User.FindFirst(ClaimTypes.PrimarySid).Value;
                var    addedAnimal = RegisteredAnimalMapper.StoA(_privateProfileService.Add(userId, RegisteredAnimalMapper.AtoS(rAnimal)));

                return(Ok(addedAnimal));
            }
            catch (System.Exception s)
            {
                return(BadRequest());
            }
        }
        public RegisteredAnimal GetById(string userId, Guid id)
        {
            var animal = _registeredAnimalProvider.Get(id);

            if (animal == null)
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.NotFound);
            }
            if (!animal.UserId.Equals(userId))
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.AccessForbidden);
            }

            return(RegisteredAnimalMapper.DtoS(animal));
        }
        public RegisteredAnimal Add(string userId, RegisteredAnimal animal)
        {
            animal.UploadDate = DateTimeOffset.Now;
            var databaseLayerAnimal = RegisteredAnimalMapper.StoD(animal);
            var addedAnimal         = _registeredAnimalProvider.Add(databaseLayerAnimal);

            QRCodeData qrCodeData  = _qrGenerator.CreateQrCode(addedAnimal.Id.ToString(), QRCodeGenerator.ECCLevel.Q);
            QRCode     qrCode      = new QRCode(qrCodeData);
            Bitmap     qrCodeImage = qrCode.GetGraphic(20);

            var qrId = _fileService.Upload(userId, _fileService.AsJpeg(qrCodeImage), "image/jpeg");

            addedAnimal.QR     = qrId.ToString();
            addedAnimal.UserId = userId;
            _registeredAnimalProvider.Update(addedAnimal);

            _unitOfWork.Commit();

            return(RegisteredAnimalMapper.DtoS(addedAnimal));
        }
 public IActionResult Get(string id)
 {
     try
     {
         string userId           = User.FindFirst(ClaimTypes.PrimarySid).Value;
         var    registeredAnimal = RegisteredAnimalMapper.StoA(_privateProfileService.GetById(userId, new Guid(id)));
         return(Ok(registeredAnimal));
     }
     catch (ApiException exp)
     {
         return(StatusCode(
                    exp.GetStatusCode(),
                    Error.CreateBuilder().SetErrorMessage(exp.GetErrorMessage()).Build()
                    ));
     }
     catch
     {
         return(BadRequest());
     }
 }
        public RegisteredAnimal Edit(string userId, Guid animalId, RegisteredAnimal animal)
        {
            var rAnimal = _registeredAnimalProvider.Get(animalId);

            if (rAnimal == null)
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.NotFound);
            }
            if (!rAnimal.UserId.Equals(userId))
            {
                throw new ApiException(HttpStatusCode.Forbidden, ApiError.AccessForbidden);
            }

            rAnimal.Image = animal.Image;
            rAnimal.Name  = animal.Name;

            var updatedAnimal = _registeredAnimalProvider.Update(rAnimal);

            _unitOfWork.Commit();

            return(RegisteredAnimalMapper.DtoS(updatedAnimal));
        }
        public IActionResult MarkAs(
            string id,
            [FromQuery(Name = "type")] int type,
            [FromQuery(Name = "title")] string title,
            [FromQuery(Name = "description")] string description,
            [FromQuery(Name = "lat")] float lat,
            [FromQuery(Name = "lng")] float lng
            )
        {
            try
            {
                string userId       = User.FindFirst(ClaimTypes.PrimarySid).Value;
                var    markedAnimal = _privateProfileService.MarkAs(
                    userId,
                    new Guid(id),
                    (DAL.Enum.Status)type,
                    title,
                    description,
                    CoordinateMapper.AtoS(new Coordinate()
                {
                    Latitude = lat, Longitude = lng
                })
                    );

                return(Ok(RegisteredAnimalMapper.StoA(markedAnimal)));
            }
            catch (ApiException exp)
            {
                return(StatusCode(
                           exp.GetStatusCode(),
                           Error.CreateBuilder().SetErrorMessage(exp.GetErrorMessage()).Build()
                           ));
            }
            catch
            {
                return(BadRequest());
            }
        }
 public IActionResult GetWithPagination(
     [FromQuery(Name = "skip")] ushort skip,
     [FromQuery(Name = "count")] ushort count
     )
 {
     try
     {
         string userId            = User.FindFirst(ClaimTypes.PrimarySid).Value;
         var    registeredAnimals = RegisteredAnimalMapper.StoA(_privateProfileService
                                                                .GetWithPagination(userId, skip, count));
         return(Ok(registeredAnimals));
     }
     catch (ApiException exp)
     {
         return(StatusCode(
                    exp.GetStatusCode(),
                    Error.CreateBuilder().SetErrorMessage(exp.GetErrorMessage()).Build()
                    ));
     }
     catch
     {
         return(BadRequest());
     }
 }