public void UploadAttachmentAsync(InMemoryMultipartFormDataStreamProvider dataStreamProvider, ResponseBase responseBase, int userID, string defaultPath)
        {
            ResponseBase submitIdeaAttachmentResponse          = new ResponseBase();
            RestAPIIdeaSupportingRequest ideaSupportingRequest = dataStreamProvider.restAPIIdeaSupportingRequest;

            ideaSupportingRequest.ideaAttachments.ToList().ForEach((ideaAttachment) =>
            {
                ideaAttachment.IdeaId = ideaSupportingRequest.IdeaId;
            });
            foreach (IdeaAttachmentRequest ideaAttachmentRequest in ideaSupportingRequest.ideaAttachments)
            {
                string inputFileName = ideaAttachmentRequest.AttachedFileName;
                string folderpath    = UploadPath(ideaAttachmentRequest, ideaSupportingRequest.IdeaId);
                logger.Info($"Folder path={folderpath}");
                string filepath = Path.Combine(folderpath, inputFileName);
                if (IsS3Enable)
                {
                    UploadRequestToS3(folderpath, filepath, ideaAttachmentRequest.stream);
                }
                else
                {
                    SaveAttachments(ideaAttachmentRequest.stream, inputFileName, folderpath);
                }
            }
        }
        public SubmitIdeaAttachmentResponse SubmitIdeaAttachment(InMemoryMultipartFormDataStreamProvider provider, int UserID)
        {
            SubmitIdeaAttachmentResponse restAPISubmitIdeaResponse = new SubmitIdeaAttachmentResponse()
            {
                Status = Success
            };
            RestAPIIdeaSupportingRequest IdeaSupportingRequest = provider.restAPIIdeaSupportingRequest;

            IdeaSupportingRequest.UserID = UserID;

            try
            {
                attachmentUtils.SubmitIdeaAttachment(restAPISubmitIdeaResponse, IdeaSupportingRequest, UserID);
                if (restAPISubmitIdeaResponse.ErrorList.Count != 0)
                {
                    restAPISubmitIdeaResponse.Status = Failure;
                    return(restAPISubmitIdeaResponse);
                }

                fileUtil.UploadAttachmentAsync(provider, restAPISubmitIdeaResponse, UserID, provider.DefaultPath);

                if (restAPISubmitIdeaResponse.ErrorList.Count != 0)
                {
                    restAPISubmitIdeaResponse.Status = Failure;
                }
            }
            catch (Exception ex)
            {
                restAPISubmitIdeaResponse.Status = Failure;
                throw new Exception(ex.Message, ex);
            }
            return(restAPISubmitIdeaResponse);
        }
        public void SubmitIdeaAttachment(ResponseBase response, RestAPIIdeaSupportingRequest restAPIIdeaSupportingRequest, int UserID)
        {
            DatabaseWrapper.databaseOperation(response, (context, query) =>
            {
                Idea idea = query.GetIdeaById(context, restAPIIdeaSupportingRequest.IdeaId);
                if (idea == null)
                {
                    response.ErrorList.Add(Faults.IdeaNotFound);
                    return;
                }

                if (!string.IsNullOrWhiteSpace(restAPIIdeaSupportingRequest.Ideatags))
                {
                    tagUtil.InsertTags(response, idea, restAPIIdeaSupportingRequest.Ideatags, UserID);
                }

                if (!string.IsNullOrEmpty(restAPIIdeaSupportingRequest.GitRepo))
                {
                    idea.GitRepo = restAPIIdeaSupportingRequest.GitRepo;
                }

                List <IdeaAttachment> ideaAttachments = new List <IdeaAttachment>();
                if (restAPIIdeaSupportingRequest.ideaAttachments.Count > 0)
                {
                    restAPIIdeaSupportingRequest.ideaAttachments.ForEach((Id) =>
                    {
                        IdeaAttachment newIdea   = new IdeaAttachment();
                        newIdea.AttachedFileName = Id.AttachedFileName;
                        newIdea.FileExtention    = Id.FileExtention;
                        newIdea.FileSizeInByte   = Id.FileSizeInByte;
                        newIdea.IdeaId           = Id.IdeaId;
                        newIdea.CreatedDate      = DateTime.UtcNow;
                        newIdea.FolderName       = Id.DocumentTypeFolderName;
                        ideaAttachments.Add(newIdea);

                        if (Id.DocumentTypeFolderName == Enum.GetName(typeof(folderNames), folderNames.DefaultImage))
                        {
                            query.DeleteDefaultImageAttachment(context, idea.IdeaId);
                        }
                    });
                    idea.IdeaAttachments = ideaAttachments;
                    query.AddIdeaAttachments(context, ideaAttachments);
                }

                idea.ModifiedDate = DateTime.UtcNow;
                context.SubmitChanges();

                idea.AttachmentCount = idea.IdeaAttachments.Count;
                idea.IsAttachment    = idea.IdeaAttachments.Count == 0 ? false : true;

                context.SubmitChanges();
            }, readOnly: false
                                              );
            if (response == null && response.ErrorList.Count != 0)
            {
                response.ErrorList.Add(Faults.ServerIsBusy);
                return;
            }
        }