public void ProcessUpload(ResultArchiveUploadEditModel archiveUploadEditModel)
        {
            if (!ModelState.IsValid)
            {
                archiveUploadEditModel.FeedbackMessage = FeedbackMessageModel.CreateFailureMessage("server error.");
                SetResultArchiveStatus(archiveUploadEditModel.Id, ResultArchiveUploadStatus.UploadFailed);
                throw new Exception("EventId should not be empty!");
            }

            if (Request.Files.Count != 1)
            {
                SetResultArchiveStatus(archiveUploadEditModel.Id, ResultArchiveUploadStatus.UploadFailed);
                throw new Exception("File count should not be empty!");
            }

            if (archiveUploadEditModel.EventId < 1)
            {
                archiveUploadEditModel.FeedbackMessage = FeedbackMessageModel.CreateFailureMessage("server error.");
                SetResultArchiveStatus(archiveUploadEditModel.Id, ResultArchiveUploadStatus.UploadFailed);
                throw new Exception("EventId should not be empty!");
            }

            try
            {
                var theEvent = _eventRepository.GetById(archiveUploadEditModel.EventId);
                if (theEvent == null || theEvent.EventDate.Date > DateTime.Now.Date ||
                    theEvent.Status != EventStatus.Active)
                {
                    throw new Exception("Provide a valid EventId!");
                }
            }
            catch (Exception ex)
            {
                IoC.Resolve <ILogManager>().GetLogger <Global>().Error("Result Archive Upload Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                SetResultArchiveStatus(archiveUploadEditModel.Id, ResultArchiveUploadStatus.UploadFailed);
                throw new Exception(ex.Message);
            }

            try
            {
                HttpPostedFileBase postedFile = Request.Files[0];

                long returnLength = 0;
                var  statuses     = new List <FileUploadStatusModel>();
                if (string.IsNullOrEmpty(Request.Headers["X-File-Name"]))
                {
                    UploadWholeFile(postedFile, archiveUploadEditModel.File.Path, statuses,
                                    archiveUploadEditModel.EventId);
                }
                else
                {
                    returnLength = UploadPartialFile(postedFile, archiveUploadEditModel.File.Path, statuses,
                                                     archiveUploadEditModel.EventId);
                }

                var resultArchive = _resultArchiveUploadRepository.GetById(archiveUploadEditModel.Id);

                if (returnLength == archiveUploadEditModel.File.FileSize || returnLength == 0)
                {
                    resultArchive.UploadEndTime    = DateTime.Now;
                    resultArchive.Status           = ResultArchiveUploadStatus.Uploaded;
                    resultArchive.UploadPercentage = 100;
                }
                else
                {
                    resultArchive.UploadPercentage = (int)((returnLength * 100) / archiveUploadEditModel.File.FileSize);
                }

                _resultArchiveUploadRepository.Save(resultArchive);
                WriteJsonIframeSafe(statuses);
            }
            catch (Exception ex)
            {
                IoC.Resolve <ILogManager>().GetLogger <Global>().Error("Upload Failure! Message: " + ex.Message + "\n\t" + ex.StackTrace);
                SetResultArchiveStatus(archiveUploadEditModel.Id, ResultArchiveUploadStatus.UploadFailed);
            }
        }
        public JsonResult CreateResultArchive(long eventId, string fileName, long fileSize)
        {
            if (eventId < 1)
            {
                throw new Exception("EventId should not be empty!");
            }
            try
            {
                var theEvent = _eventRepository.GetById(eventId);
                if (theEvent == null || theEvent.EventDate.Date > DateTime.Now.Date || theEvent.Status != EventStatus.Active || theEvent.PodIds.IsNullOrEmpty())
                {
                    throw new Exception("Provide a valid EventId!");
                }
            }
            catch
            {
                var model = new ResultArchiveUploadEditModel
                {
                    EventId = -1,
                    File    = null,
                    Id      = 0
                };

                return(Json(model, JsonRequestBehavior.AllowGet));
            }

            var file = new File
            {
                Path       = fileName,
                Type       = FileType.Compressed,
                FileSize   = fileSize,
                UploadedBy = new OrganizationRoleUser(_session.UserSession.CurrentOrganizationRole.OrganizationRoleUserId),
                UploadedOn = DateTime.Now
            };

            file = _fileRepository.Save(file);

            var resultArchive = new ResultArchive
            {
                FileId                  = file.Id,
                EventId                 = eventId,
                UploadStartTime         = DateTime.Now,
                Status                  = ResultArchiveUploadStatus.Uploading,
                UploadedByOrgRoleUserId =
                    _session.UserSession.CurrentOrganizationRole.OrganizationRoleUserId
            };

            resultArchive = _resultArchiveUploadRepository.Save(resultArchive);

            //update the file name
            file.Path = _fileHelper.AddPostFixToFileName(file.Path, resultArchive.Id.ToString());
            _fileRepository.Save(file);


            //return ResultArchiveUploadEditModel;
            var editModel = new ResultArchiveUploadEditModel
            {
                EventId = eventId,
                File    = file,
                Id      = resultArchive.Id
            };

            return(Json(editModel, JsonRequestBehavior.AllowGet));
        }