Example #1
0
        /// <summary>
        /// Rolls back the specified <see cref="UploadSession" />. This cleans up the session storage for this session and
        /// requests. This also removes any files that were uploaded during the session.
        /// </summary>
        /// <param name="session">The <see cref="UploadSession" /> to roll back.</param>
        public static void RollbackSession(UploadSession session)
        {
            foreach (UploadRequest request in session.UploadRequests)
                CleanupRequest(request);

            EndSession(session);
        }
        public ActionResult UploadResult(CustomSqlServerModel model, UploadSession session)
        {
            

            model.UploadSession = session;

            return View(model);
        }
Example #3
0
        /// <summary>
        /// Commits the specified <see cref="UploadSession" />. This completes the session so it won't be automatically
        /// rolled back when the session timeout expires.
        /// </summary>
        /// <param name="session">The <see cref="UploadSession" /> to commit.</param>
        public static void CommitSession(UploadSession session)
        {
            //session.State = UploadState.Complete;

            //SessionStorageProvider.SaveSession(session, false);
            
            EndSession(session);
        }
Example #4
0
        /// <summary>
        /// Commits the specified <see cref="UploadSession" />. This completes the session so it won't be automatically
        /// rolled back when the session timeout expires.
        /// </summary>
        /// <param name="session">The <see cref="UploadSession" /> to commit.</param>
        public static void CommitSession(UploadSession session)
        {
            //session.State = UploadState.Complete;

            //SessionStorageProvider.SaveSession(session, false);

            EndSession(session);
        }
        public ActionResult UploadResult(ValidationModel model, UploadSession session)
        {
            

            model.UploadSession = session;

            return View(model);
        }
Example #6
0
        internal static void EndSession(UploadSession session)
        {
            SessionStorageProvider.RemoveSession(session.UploadSessionId);

            if (CurrentUploadSessionInternal != null && CurrentUploadSessionInternal.UploadSessionId == session.UploadSessionId)
            {
                CurrentUploadSessionInternal = null;
            }
        }
Example #7
0
        /// <summary>
        /// Rolls back the specified <see cref="UploadSession" />. This cleans up the session storage for this session and
        /// requests. This also removes any files that were uploaded during the session.
        /// </summary>
        /// <param name="session">The <see cref="UploadSession" /> to roll back.</param>
        public static void RollbackSession(UploadSession session)
        {
            foreach (UploadRequest request in session.UploadRequests)
            {
                CleanupRequest(request);
            }

            EndSession(session);
        }
Example #8
0
        protected void uploadButton_Click(object sender, EventArgs e)
        {
            uploadResultPanel.Visible = true;
            uploadPanel.Visible = false;

            _uploadSession = SlickUploadContext.CurrentUploadSession;

            if (UploadSession != null && UploadSession.State == UploadState.Complete)
            {
                if (UploadSession.UploadedFiles.Count > 0)
                {
                    resultsRepeater.DataSource = UploadSession.UploadedFiles;
                    resultsRepeater.DataBind();
                }
            }
        }
        public ActionResult UploadResult(UploadSession session)
        {
            
                    if (session != null && session.State == UploadState.Complete && session.UploadedFiles.Count > 0)
                    {
                        // Simulate post processing
                        for (int i = 0; i <= 100; i++)
                        {
                            session.ProcessingStatus["percentComplete"] = i.ToString();
                            session.ProcessingStatus["percentCompleteText"] = i.ToString() + "%";

                            SlickUploadContext.UpdateSession(session);

                            System.Threading.Thread.Sleep(100);
                        }
                    }


            return View(session);
        }
Example #10
0
        internal static void CompleteSession(UploadSession session, UploadErrorType errorType)
        {
            bool hasErrored = (errorType != UploadErrorType.None);

            int successfulFiles = 0;

            if (!hasErrored)
            {
                foreach (UploadRequest request in session.UploadRequests)
                {
                    if (session.CancelledRequests != null && Array.IndexOf<string>(session.CancelledRequests, request.UploadRequestId) != -1)
                        CancelRequest(request);

                    // TODO: we assume if it is uploading that it is almost done and do nothing. Instead, we should block until it becomes not uploading,
                    // or nuke it if it doesn't finish shortly
                    /*if (request.State == UploadState.Uploading)
                        throw new Exception("Request " + request.UploadRequestId + " is still processing.");
                    if (request.State == UploadState.Uploading)
                        CancelRequest(request);*/
                    // TODO: should we consider cancels as not errored? I guess not, because we still consider it an error if everything was cancelled. Maybe revisit when we do AllowPartialError
                    if (request.ErrorType != UploadErrorType.None)
                        hasErrored = true;
                    else
                        successfulFiles += request._uploadedFilesInternal.Count;
                }
            }

            if (hasErrored && errorType == UploadErrorType.None && session.UploadProfile.AllowPartialError && successfulFiles > 0)
                hasErrored = false;

            if (hasErrored && errorType == UploadErrorType.None)
            {
                // Try to find an error
                foreach (UploadRequest request in session.UploadRequests)
                {
                    if (request.ErrorType != UploadErrorType.None)
                    {
                        errorType = request.ErrorType;

                        break;
                    }
                }

                if (errorType == UploadErrorType.None)
                    errorType = UploadErrorType.Other;
            }

            session.State = !hasErrored ? UploadState.Complete : UploadState.Error;
            session.ErrorType = errorType;

            UpdateSession(session);

            // TODO: what happens here if a request is still in progress for some reason. Can we guarantee that never happens?
            foreach (UploadRequest request in session.UploadRequests)
            {
                bool isFailedRequest = (session.FailedRequests != null && Array.IndexOf<string>(session.FailedRequests, request.UploadRequestId) != -1);

                if (hasErrored || request.ErrorType != UploadErrorType.None || isFailedRequest)
                {
                    if (isFailedRequest)
                    {
                        request.State = UploadState.Error;

                        if (request.ErrorType == UploadErrorType.None)
                            request.ErrorType = UploadErrorType.FailedByClient;
                    }

                    CleanupRequest(request);
                }
            }
        }
Example #11
0
 /// <summary>
 /// Updates the specified <see cref="UploadSession" /> in the current session storage provider.
 /// </summary>
 /// <param name="session">The <see cref="UploadSession" /> to update.</param>
 public static void UpdateSession(UploadSession session)
 {
     SessionStorageProvider.SaveSession(session, false);
 }
Example #12
0
        internal static void EndSession(UploadSession session)
        {
            SessionStorageProvider.RemoveSession(session.UploadSessionId);

            if (CurrentUploadSessionInternal != null && CurrentUploadSessionInternal.UploadSessionId == session.UploadSessionId)
                CurrentUploadSessionInternal = null;
        }
Example #13
0
        public ActionResult IndexUploadResult(OverviewModel model, UploadSession session)
        {
            model.UploadSession = session;

            return View(model);
        }
Example #14
0
        //
        // GET: /Upload/
        /// <summary>
        /// path数据结构
        /// 001_西山区|4567_虹桥立交|8889_日常巡检 解析为三个文件夹
        /// 西山区(001)
        ///   |
        ///   |---虹桥立交(4567)
        ///         |
        ///         |----日常巡检(8889)
        /// </summary>
        public JsonResult Add(UploadSession uploadSession, string userId, string spaceId, string userName, string depId, string visible, string path)
        {
            //var userId = _requestProvider["UserId"];
            //var spaceId = _requestProvider["SpaceId"];
            //var userName = _requestProvider["UserName"];
            //var depId = _requestProvider["DepId"];
            //var visible = _requestProvider["Visible"];
            //var path = _requestProvider["Path"];
            _logger.Info("DocumentController 添加文档.");

            if (string.IsNullOrWhiteSpace(userId))
            {
                _logger.Error("文档参数错误, 缺少 UserId 参数.");
                throw new HttpResponseException(HttpStatusCode.BadRequest);
            }
            _logger.InfoFormat("文档参数userId:{0}", userId);

            if (string.IsNullOrWhiteSpace(userName))
            {
                _logger.Error("文档参数错误, 缺少 userName 参数.");
                throw new HttpResponseException(HttpStatusCode.BadRequest);
            }
            _logger.InfoFormat("文档参数userName:{0}", userName);

            if (string.IsNullOrWhiteSpace(depId))
            {
                _logger.Error("文档参数缺少 depId 参数,默认设置为空");
                depId = string.Empty;
            }
            _logger.InfoFormat("文档参数depId:{0}", depId);

            var visiblity = Visible.Public;
            if (!string.IsNullOrWhiteSpace(visible))
            {

                visiblity = (Visible)Enum.Parse(typeof(Visible), visible);
                _logger.InfoFormat("文档参数为:{0}", visiblity);
            }
            else
            {
                _logger.Info("文档参数缺少 visible 参数,默认设置为Public");
            }

            SpaceObject space;
            if (string.IsNullOrWhiteSpace(path))
            {
                _logger.Info("文档参数缺少 path 参数,采用spaceId参数");
                space = string.IsNullOrWhiteSpace(spaceId) ?
                    _spaceService.GetDefaultSpace() : _spaceService.GetSpace(spaceId);
            }
            else
            {
                _logger.InfoFormat("文档参数path:{0}", path);
                space = _spaceService.MakeSpace(string.Empty, path, userId, userName, depId, visiblity);
            }

            if (uploadSession.UploadedFiles.Count == 0)
            {
                _logger.Error("文档参数错误, 上传文件失败.");
                throw new HttpResponseException(HttpStatusCode.BadRequest);
            }

            _logger.Info(string.Format("Add Document, spaceId:[{0}];userId:[{1}];userName:[{2}]。", spaceId, userId, userName));

            try
            {
                var file = uploadSession.UploadedFiles.First();
                var document = DocumentBuilder.Build(file,
                                                    space.Id.ToString(),
                                                    space.SpaceSeqNo,
                                                    space.SpaceName,
                                                    userId,
                                                    userName,
                                                    depId,
                                                    visiblity);
                var documentObj = _documentService.Add(document);
                if (documentObj.DocumentCategory != DocumentCategory.Image)
                {
                    documentObj.DisplayPath = documentObj.PreviewUrl;
                }

                return Json(documentObj.ToObject<DocumentContract>());
            }
            catch (Exception ex)
            {
                _logger.Error(ex.Message);
                _logger.Error(ex.StackTrace);
                throw new HttpResponseException(HttpStatusCode.InternalServerError);
            }
        }
Example #15
0
        internal static void CompleteSession(UploadSession session, UploadErrorType errorType)
        {
            bool hasErrored = (errorType != UploadErrorType.None);

            int successfulFiles = 0;

            if (!hasErrored)
            {
                foreach (UploadRequest request in session.UploadRequests)
                {
                    if (session.CancelledRequests != null && Array.IndexOf <string>(session.CancelledRequests, request.UploadRequestId) != -1)
                    {
                        CancelRequest(request);
                    }

                    // TODO: we assume if it is uploading that it is almost done and do nothing. Instead, we should block until it becomes not uploading,
                    // or nuke it if it doesn't finish shortly

                    /*if (request.State == UploadState.Uploading)
                     *  throw new Exception("Request " + request.UploadRequestId + " is still processing.");
                     * if (request.State == UploadState.Uploading)
                     *  CancelRequest(request);*/
                    // TODO: should we consider cancels as not errored? I guess not, because we still consider it an error if everything was cancelled. Maybe revisit when we do AllowPartialError
                    if (request.ErrorType != UploadErrorType.None)
                    {
                        hasErrored = true;
                    }
                    else
                    {
                        successfulFiles += request._uploadedFilesInternal.Count;
                    }
                }
            }

            if (hasErrored && errorType == UploadErrorType.None && session.UploadProfile.AllowPartialError && successfulFiles > 0)
            {
                hasErrored = false;
            }

            if (hasErrored && errorType == UploadErrorType.None)
            {
                // Try to find an error
                foreach (UploadRequest request in session.UploadRequests)
                {
                    if (request.ErrorType != UploadErrorType.None)
                    {
                        errorType = request.ErrorType;

                        break;
                    }
                }

                if (errorType == UploadErrorType.None)
                {
                    errorType = UploadErrorType.Other;
                }
            }

            session.State     = !hasErrored ? UploadState.Complete : UploadState.Error;
            session.ErrorType = errorType;

            UpdateSession(session);

            // TODO: what happens here if a request is still in progress for some reason. Can we guarantee that never happens?
            foreach (UploadRequest request in session.UploadRequests)
            {
                bool isFailedRequest = (session.FailedRequests != null && Array.IndexOf <string>(session.FailedRequests, request.UploadRequestId) != -1);

                if (hasErrored || request.ErrorType != UploadErrorType.None || isFailedRequest)
                {
                    if (isFailedRequest)
                    {
                        request.State = UploadState.Error;

                        if (request.ErrorType == UploadErrorType.None)
                        {
                            request.ErrorType = UploadErrorType.FailedByClient;
                        }
                    }

                    CleanupRequest(request);
                }
            }
        }
Example #16
0
 /// <summary>
 /// Updates the specified <see cref="UploadSession" /> in the current session storage provider.
 /// </summary>
 /// <param name="session">The <see cref="UploadSession" /> to update.</param>
 public static void UpdateSession(UploadSession session)
 {
     SessionStorageProvider.SaveSession(session, false);
 }
Example #17
0
 public ActionResult Index(UploadSession session)
 {
     return View(session);
 }
Example #18
0
 public ActionResult ClientApiUploadResult(UploadSession session)
 {
     return View(session);
 }
 public ActionResult UploadResult(UploadSession session)
 {
     
     return View(session);
 }
Example #20
0
        public ActionResult Upload(UploadSession session, string spaceId)
        {
            _logger.Info("DocumentController 添加文档");

            try
            {
                var files = session.UploadedFiles;

                var userId = _contextService.UserId;
                var userName = _contextService.NickName;
                var depId = _contextService.DepId;
                var space = _spaceService.GetSpace(spaceId);

                _logger.Info(string.Format("Add Document, spaceId:[{0}];spaceSeqNo:[{1}], spaceName:[{2}], userId:[{3}];userName:[{4}]。",
                    space.Id, space.SpaceSeqNo, space.SpaceName, userId, userName));

                var documents = new List<DocumentObject>();
                foreach (var file in files)
                {
                    var document = DocumentBuilder.Build(file, space.Id.ToString(), space.SpaceSeqNo, space.SpaceName, userId, userName, depId, Visible.Public);
                    documents.Add(document);
                }

                var contracts = _documentService.Add(documents);

                return Json(new UploadViewModel(ErrorMessages.Success,
                                                ErrorMessages.GetErrorMessages(ErrorMessages.Success), contracts));

            }
            catch (Exception ex)
            {
                _logger.Error(ex.StackTrace);
                _logger.Error(ex.Message);
                return Json(new UploadViewModel(ErrorMessages.UploadFailed, ex.Message));
            }
        }