Пример #1
0
        public async Task <SaveExaminationAudioResult> SaveAsync(Stream stream, string boundary)
        {
            QuestionAudioFile audioFile = new QuestionAudioFile();

            var response = await transactionService.CommitAsync(new[] { TransactionContextScope.Main }, async() =>
            {
                using (var memoryStream = new MemoryStream())
                {
                    await stream.CopyToAsync(memoryStream);
                    audioFile = await GetSavedAudioFileInfo(memoryStream, boundary);
                    if (string.IsNullOrEmpty(audioFile.Name))
                    {
                        return(SaveExaminationAudioResult.Error);
                    }
                    await questionAudioFilesRepository.AddAsync(audioFile);
                    return(SaveExaminationAudioResult.Ok);
                }
            });

            if (response == SaveExaminationAudioResult.Ok)
            {
                BackgroundJob.Enqueue <IExaminationIntegrationResponseService>(service => service.NotifyLocalInstancesAboutNewAudioFile(CreateFilePath(audioFile.Name)));
            }

            return(response);
        }
Пример #2
0
        private async Task <bool> CheckAudioInfoForUpdate(QuestionAudioFile fileInfo, UpdateExaminationAudioFileInfoRequest request)
        {
            if (fileInfo == null)
            {
                return(false);
            }

            if (fileInfo.Name != request.FileName && await questionAudioFilesRepository.ExistsAsync(request.FileName))
            {
                return(false);
            }

            if (fileInfo.Id == request.Id && fileInfo.Name == request.FileName && fileInfo.Comment == request.Comment)
            {
                return(false);
            }

            return(true);
        }
Пример #3
0
        private async Task <QuestionAudioFile> GetSavedAudioFileInfo(MemoryStream memoryStream, string boundary)
        {
            MultipartSection section;
            var audioFile     = new QuestionAudioFile();
            var audioFileInfo = new AddExaminationAudioFileInfoRequest();

            memoryStream.Position = 0;
            var reader = new MultipartReader(boundary, memoryStream);

            while ((section = await reader.ReadNextSectionAsync()) != null)
            {
                if (section.HasHeaderInfo("audioFileInfo"))
                {
                    audioFileInfo = await GetAudioFileInfo(section);

                    audioFile = new QuestionAudioFile
                    {
                        Name    = audioFileInfo.FileName,
                        Comment = audioFileInfo.Comment
                    };

                    if (await questionAudioFilesRepository.ExistsAsync(audioFile.Name))
                    {
                        return(new QuestionAudioFile {
                            Name = string.Empty
                        });
                    }
                }
                if (section.HasHeaderFile() && !string.IsNullOrEmpty(audioFile.Name))
                {
                    var wavFileStream = CreateMemoryStream(section.Body);
                    await SaveAudioFileToLocalFolder(wavFileStream, audioFile.Name);
                }
            }
            audioFile.Path = CreateFilePath(audioFileInfo.FileName);
            return(audioFile);
        }
Пример #4
0
 public Task AddAsync(QuestionAudioFile audioFile)
 {
     audiosDataSet.Add(audioFile);
     return(dbContext.SaveChangesAsync());
 }
Пример #5
0
 public Task UpdateAsync(QuestionAudioFile audioFile)
 {
     audiosDataSet.Update(audioFile);
     return(dbContext.SaveChangesAsync());
 }