Example #1
0
        public async Task GenerateReportFile(DashboardItemExportRequestModel requestModel)
        {
            OperationDataResult <FileStreamModel> result = await _interviewsService.GenerateFile(requestModel);

            const int bufferSize = 4086;

            byte[] buffer = new byte[bufferSize];
            Response.OnStarting(async() =>
            {
                try
                {
                    if (!result.Success)
                    {
                        Response.ContentLength = result.Message.Length;
                        Response.ContentType   = "text/plain";
                        Response.StatusCode    = 400;
                        byte[] bytes           = Encoding.UTF8.GetBytes(result.Message);
                        await Response.Body.WriteAsync(bytes, 0, result.Message.Length);
                        await Response.Body.FlushAsync();
                    }
                    else
                    {
                        using (FileStream excelStream = result.Model.FileStream)
                        {
                            int bytesRead;
                            Response.ContentLength = excelStream.Length;
                            Response.ContentType   = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
                            while ((bytesRead = excelStream.Read(buffer, 0, buffer.Length)) > 0 &&
                                   !HttpContext.RequestAborted.IsCancellationRequested)
                            {
                                await Response.Body.WriteAsync(buffer, 0, bytesRead);
                                await Response.Body.FlushAsync();
                            }
                        }
                    }
                }
                finally
                {
                    if (!string.IsNullOrEmpty(result?.Model?.FilePath) &&
                        System.IO.File.Exists(result.Model.FilePath))
                    {
                        System.IO.File.Delete(result.Model.FilePath);
                    }
                }
            });
        }
Example #2
0
        public async Task <OperationDataResult <FileStreamModel> > GenerateFile(
            DashboardItemExportRequestModel requestModel)
        {
            string excelFile = null;

            try
            {
                var reportDataResult = await _dashboardService
                                       .GetSingleForView(
                    requestModel.DashboardId,
                    true,
                    requestModel.ItemId);

                if (!reportDataResult.Success)
                {
                    return(new OperationDataResult <FileStreamModel>(false, reportDataResult.Message));
                }

                var dashboardItemView = reportDataResult.Model.Items.FirstOrDefault();

                if (dashboardItemView == null)
                {
                    return(new OperationDataResult <FileStreamModel>(
                               false,
                               _localizationService.GetString("DashboardItemNotFound")));
                }

                var interviews = new List <InterviewsExportModel>();
                foreach (var textQuestionData in dashboardItemView.TextQuestionData)
                {
                    var interviewsExportModel = new InterviewsExportModel
                    {
                        Id             = textQuestionData.Id,
                        Comments       = textQuestionData.Commentary,
                        Tag            = textQuestionData.LocationName,
                        Date           = textQuestionData.Date,
                        Question       = dashboardItemView.FirstQuestionName,
                        FilterQuestion = dashboardItemView.FilterQuestionName,
                        FilterAnswer   = dashboardItemView.FilterAnswerName,
                    };
                    interviews.Add(interviewsExportModel);
                }

                excelFile = _interviewsExcelService.CopyTemplateForNewAccount("interviews-template");
                bool writeResult = _interviewsExcelService.WriteInterviewsExportToExcelFile(
                    interviews,
                    excelFile);

                if (!writeResult)
                {
                    throw new Exception($"Error while writing excel file {excelFile}");
                }

                var result = new FileStreamModel()
                {
                    FilePath   = excelFile,
                    FileStream = new FileStream(excelFile, FileMode.Open),
                };

                return(new OperationDataResult <FileStreamModel>(true, result));
            }
            catch (Exception e)
            {
                if (!string.IsNullOrEmpty(excelFile) && File.Exists(excelFile))
                {
                    File.Delete(excelFile);
                }

                Trace.TraceError(e.Message);
                _logger.LogError(e.Message);
                return(new OperationDataResult <FileStreamModel>(
                           false,
                           _localizationService.GetString("ErrorWhileExportingInterviews")));
            }
        }