/// <summary>
        /// mocks updating media
        /// </summary>
        /// <param name="updateDto">instance of <see cref="MediaUpdateDto"/></param>
        /// <returns>instance of <see cref="MediaDto"/></returns>
        public async Task <MediaDto> UpdateAsync(MediaUpdateDto updateDto)
        {
            Media media = await Task.Run(() => { return(_medias.Where(m => m.Id == updateDto.Id).First()); });

            media.Source = updateDto.Source;

            return(new MediaDto
            {
                Id = media.Id,
                GroupId = media.GroupId,
                Source = media.Source,
                Type = media.Type.ToString(),
                Url = media.Url
            });
        }
        public ActionResult <Media> UpdateMedia([FromBody] MediaUpdateDto mediaUpdateDto, Guid mediaId, [FromHeader] Guid accountId, [FromHeader] string key)
        {
            try
            {
                //pristup metodi imaju samo autorizovani korisnici
                if (!auth.AuthorizeUser(key))
                {
                    return(StatusCode(StatusCodes.Status401Unauthorized, "Authorization failed!"));
                }

                var oldMedia = mediaRepository.GetMediaById(mediaId);
                if (oldMedia == null)
                {
                    return(StatusCode(StatusCodes.Status404NotFound, "There is no media!"));
                }
                Media newMedia = mapper.Map <Media>(mediaUpdateDto);
                newMedia.ItemForSaleId = oldMedia.ItemForSaleId;

                if (oldMedia.AccountId != accountId)
                {
                    return(StatusCode(StatusCodes.Status403Forbidden, "User doesn't have permission to update media because he didn't create it"));
                }

                var itemForSale = itemForSaleService.GetItemForSaleById <ItemForSaleDto>(HttpMethod.Get, oldMedia.ItemForSaleId).Result;
                if (itemForSale == null)
                {
                    throw new DbException("Item for sale with that ID doesn't exist!");
                }

                mediaRepository.UpdateMedia(oldMedia, newMedia);
                mediaRepository.SaveChanges();
                logger.Log(LogLevel.Information, contextAccessor.HttpContext.TraceIdentifier, "", "Updated media.", null);

                return(Ok(oldMedia));
            }
            catch (Exception ex)
            {
                logger.Log(LogLevel.Error, contextAccessor.HttpContext.TraceIdentifier, "", "Error while updating media!", null);

                return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
            }
        }
        /// <summary>
        /// updates media
        /// </summary>
        /// <param name="updateDto">instance of <see cref="MediaUpdateDto"/></param>
        /// <returns>instance of <see cref="MediaDto"/></returns>
        public async Task <MediaDto> UpdateAsync(MediaUpdateDto updateDto)
        {
            Media media = await _context.Medias.FindAsync(updateDto.Id);

            if (media == null)
            {
                throw new KeyNotFoundException($"Media with id: {updateDto.Id} could not be found!");
            }

            media.Source   = updateDto.Source;
            media.PublicId = updateDto.PublicId;
            _context.Medias.Update(media);

            await _context.SaveChangesAsync();

            return(new MediaDto {
                Id = media.Id,
                GroupId = media.GroupId,
                Source = media.Source,
                Type = media.Type.ToString(),
                Url = media.Url,
                PublicId = media.PublicId
            });
        }