public async Task <ActionResult <MusicResource> > CreateMusic([FromBody] SaveMusicResource saveMusicResource)
        {
            var validatorMusic   = new SaveMusicResourceValidator();
            var validationResult = await validatorMusic.ValidateAsync(saveMusicResource);

            if (!validationResult.IsValid)
            {
                return(BadRequest(validationResult.Errors.FirstOrDefault().ErrorMessage));
            }

            var artist = await _artistService.GetById(saveMusicResource.ArtistId);

            if (artist == null)
            {
                return(BadRequest("No such an artist"));
            }

            var music = _mapper.Map <SaveMusicResource, Music>(saveMusicResource);

            var newMusic = await _musicService.Create(music);

            var newMusicResource = _mapper.Map <Music, MusicResource>(newMusic);

            return(Ok(newMusicResource));
        }
        public async Task <IActionResult> CreateMusicAsync([FromBody] CreateMusicCommand command)
        {
            try
            {
                if (string.IsNullOrEmpty(command.Name))
                {
                    command.Name = string.Empty;
                }

                if (command.Title == null)
                {
                    command.Title = string.Empty;
                }
                if (command.Album == null)
                {
                    command.Album = string.Empty;
                }
                if (command.PublishingYear == null)
                {
                    command.PublishingYear = string.Empty;
                }

                Enum.TryParse <CreatureTypes>(command.CreatureType, true, out CreatureTypes creatureType);
                Enum.TryParse <OwnerTypes>(command.OwnerType, true, out OwnerTypes ownerTypes);

                var result = await musicService.Create(
                    command.Name,
                    command.Album,
                    command.PublishingYear,
                    command.OwnerId,
                    command.LicenceLink,
                    command.MusicLink,
                    command.DemoLink,
                    command.Key1,
                    command.Key2,
                    command.FullKey,
                    creatureType,
                    ownerTypes);

                return(Ok(new { MusicId = result }));
            }
            catch (Exception ex)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, ex));
            }
        }
        private void OverlayButtonClick(object sender, EventArgs e)
        {
            // Диалоговое окно
            var outputFile = new SaveFileDialog();

            outputFile.FileName   = "OtputFile";
            outputFile.DefaultExt = "*.mp3";
            outputFile.Filter     = "MP3 File (.mp3)|*.mp3";
            if (outputFile.ShowDialog() != DialogResult.OK)
            {
                return;
            }

            // Создание основного трека
            var    musicList = MusicList.Items?.Cast <string>()?.ToList();
            double musicBreak;

            if (!double.TryParse(PauseBetweenTrack.Text, out musicBreak))
            {
                return;
            }

            // TODO: Здесь надо дальше везде обрабатывать исключения на созданиях, наложениях и сохранениях
            var musicTrack       = musicService.Create(musicList, musicBreak);
            var musicTrackLenght = musicService.GetLenght(musicList, musicBreak); // TODO: Передавать трек

            // Создание водяного знака
            var watermarkTrack = watermarkService.Create(
                musicTrackLenght,
                WatermarkPathLabel.Text,
                Convert.ToDouble(WatermarkRepeat.Text),
                Convert.ToDouble(WatermarkOffset.Text));

            // Наложение водяного знака и сохранение в файл
            var mixingFile = watermarkService.Overlay(musicTrack, watermarkTrack, Convert.ToDouble(WatermarkOffset.Text));

            watermarkService.SaveToFile(mixingFile, outputFile.FileName);
        }