public HttpResponseMessage SignOut([FromUri] string callback) { diagnostics.WriteInformationTrace(TraceEventId.InboundParameters, "Client callback uri:{0}", callback); if (string.IsNullOrEmpty(callback)) { diagnostics.WriteErrorTrace(TraceEventId.Exception, "callback parameter is null or empty"); return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format(MessageStrings.Argument_Error_Message_Template, callback))); } FederatedAuthentication.WSFederationAuthenticationModule.SignOut(true); var acsConfig = FederatedAuthentication.FederationConfiguration.WsFederationConfiguration; string wtrealm = acsConfig.Realm; // construct the call back Url UriBuilder wreply = new UriBuilder(this.Request.RequestUri.Scheme, this.Request.RequestUri.Host); wreply.Path = "SignOutCallback"; string queryparam = string.Concat("callback=", callback); wreply.Query = queryparam; string url = string.Format("{0}?wa=wsignout1.0&wreply={1}&wtrealm={2}", acsConfig.Issuer, HttpUtility.UrlEncode(wreply.ToString()), wtrealm); // Construct the Response var response = Request.CreateResponse(HttpStatusCode.Moved); response.Headers.Location = new Uri(url); diagnostics.WriteVerboseTrace(TraceEventId.OutboundParameters, "Redirect Uri to Acs logout {0}", response.Headers.Location); return(response); }
public HttpResponseMessage GetRepositories() { // Check if the model binding was successful and is in a valid state if (!ModelState.IsValid) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Empty)); } try { // Check if the file service is valid Check.IsNotNull(this.repositoryService, "repositoryService"); bool isAdmin = this.user.UserRoles.Any(ur => ur.Role.Name.Equals(Roles.Administrator.ToString(), StringComparison.OrdinalIgnoreCase)); IEnumerable <RepositoryDataModel> repositoryList = this.repositoryService.RetrieveRepositories(isAdmin); return(Request.CreateResponse <IEnumerable <RepositoryDataModel> >(HttpStatusCode.OK, repositoryList)); } catch (ArgumentNullException ane) { return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ane.Message)); } catch (Exception ex) { string error = ex.Message + ex.StackTrace + ex.GetType().ToString(); if (null != ex.InnerException) { error += ex.InnerException.Message + ex.InnerException.StackTrace + ex.InnerException.GetType().ToString(); } diagnostics.WriteErrorTrace(TraceEventId.Exception, "Exception:{0}", error); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error)); } }
public async Task <HttpResponseMessage> GetQualityCheckRulesAndFileSheets(int fileId) { var fileService = fileServiceFactory.GetFileService(BaseRepositoryEnum.Default.ToString()); Func <DM.File, bool> fileByFileIdAndUserIdFilter = f => f.FileId == fileId && f.CreatedBy == this.user.UserId && (f.isDeleted == null || f.isDeleted == false); var file = fileService.GetFiles(fileByFileIdAndUserIdFilter).FirstOrDefault(); if (file == null) { return(Request.CreateErrorResponse(HttpStatusCode.NotFound, MessageStrings.FileNotFound)); } string fileExtension = Path.GetExtension(file.Name); if (!(fileExtension.Equals(Constants.XLSX, StringComparison.InvariantCultureIgnoreCase) || fileExtension.Equals(Constants.CSV, StringComparison.InvariantCultureIgnoreCase))) { return(Request.CreateErrorResponse(HttpStatusCode.NotImplemented, MessageStrings.QualityCheckNotSupportedErrorMessage)); } bool isAdmin = this.user.UserRoles.Any(ur => ur.Role.Name.Equals(Roles.Administrator.ToString(), StringComparison.OrdinalIgnoreCase)); QualityChecksViewModel qualityChecksViewModel = new QualityChecksViewModel(); qualityChecksViewModel.ColumnRules = this.qcService.GetQualityCheckRules(isAdmin); try { qualityChecksViewModel.FileSheets = await fileService.GetDocumentSheetDetails(file); } catch (FileFormatException ex) { diagnostics.WriteErrorTrace(TraceEventId.Exception, ex); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex.Message)); } return(Request.CreateResponse(HttpStatusCode.OK, qualityChecksViewModel)); }
/// <summary> /// Executes when Unhandled Exception is thrown. /// </summary> /// <param name="context">ActionExecuted Context</param> public override void OnException(HttpActionExecutedContext context) { DiagnosticsProvider diagnostics = new DiagnosticsProvider(this.GetType()); Exception exception = context.Exception; diagnostics.WriteErrorTrace(TraceEventId.Exception, exception); context.Response = context.Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception.Message); }
public HttpResponseMessage GetUsersByNameIdentifier() { string message = string.Empty; string nameIdentifier = string.Empty; HttpStatusCode status = HttpStatusCode.OK; try { // Check if the user service is valid Check.IsNotNull(this.userService, "userService"); nameIdentifier = Helpers.IdentityHelper.GetNameClaimTypeValue(this.User as ClaimsPrincipal); diagnostics.WriteVerboseTrace(TraceEventId.InboundParameters, "Retrieving user with name identifier:{0}", nameIdentifier); User retrievedUser = this.userService.GetUserWithRolesByNameIdentifier(nameIdentifier); return(Request.CreateResponse <UserInformation>(status, new UserInformation(retrievedUser))); } catch (ArgumentNullException ane) { if (ane.ParamName.Equals("userService")) { message = MessageStrings.User_Service_Is_Null; status = HttpStatusCode.InternalServerError; } } catch (ArgumentException ae) { message = string.Format(CultureInfo.CurrentCulture, MessageStrings.Argument_Error_Message_Template, ae.ParamName); status = HttpStatusCode.BadRequest; } catch (UserNotFoundException) { message = MessageStrings.User_Not_Found; status = HttpStatusCode.NotFound; diagnostics.WriteErrorTrace(TraceEventId.Exception, "User with nameidentifier {0} not found", nameIdentifier); } return(Request.CreateErrorResponse(status, message)); }
public HttpResponseMessage AuthorizeUser() { try { // Check if OAuthCode exists if not then redict to Windows Live if (!this.HasOAuthCode()) { diagnostics.WriteInformationTrace(TraceEventId.Flow, "Redirecting to live"); // Retreive the call back param string callBackUrl = this.Request.GetQueryNameValuePairs().Where(p => p.Key == "callBackUrl").FirstOrDefault().Value; string windowsLiveLoginUrl = this.GetWindowsLiveLoginUrl(callBackUrl); // Construct the Response var response = Request.CreateResponse(HttpStatusCode.Moved); response.Headers.Location = new Uri(windowsLiveLoginUrl); return(response); } else { diagnostics.WriteInformationTrace(TraceEventId.Flow, "Call back from live"); string code = this.Request.GetQueryNameValuePairs().Where(p => p.Key == SkyDriveConstants.OAuth_Code).FirstOrDefault().Value; string callBackUrl = this.Request.GetQueryNameValuePairs().Where(p => p.Key == "callBackUrl").FirstOrDefault().Value; // Get the AccessToken and Refresh Token by calling WindowsLive rest API OAuthToken token = GetWindowsLiveTokens(code, callBackUrl); diagnostics.WriteInformationTrace(TraceEventId.Flow, "Redirecting to client"); var response = Request.CreateResponse(HttpStatusCode.Moved); string clientCallBackUrl = AppendAuthTokensToCallBackUrl(token, callBackUrl); response.Headers.Location = new Uri(clientCallBackUrl); return(response); } } catch (Exception ex) { diagnostics.WriteErrorTrace(TraceEventId.Exception, ex); string error = ex.Message + ex.StackTrace + ex.GetType().ToString(); if (null != ex.InnerException) { error += ex.InnerException.Message + ex.InnerException.StackTrace + ex.InnerException.GetType().ToString(); } return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error)); } }
protected void Application_Error(object sender, EventArgs e) { // Get the error details Exception ex = Server.GetLastError(); // Check exception type and default Http 500 (internal server error) Response.StatusCode = (ex is HttpException) ? (ex as HttpException).GetHttpCode() : (int)HttpStatusCode.InternalServerError; // Log exception DiagnosticsProvider diagnostics = new DiagnosticsProvider(this.GetType()); string error = string.Join("\n", "Unhandled Exception: ", ex.ToString()); diagnostics.WriteErrorTrace(TraceEventId.Exception, error); // Clear buffers Server.ClearError(); Response.End(); }
public HttpResponseMessage AddUpdateAuthToken(AuthToken token) { try { // Create file service instance Repository repository = this.repositoryService.GetRepositoryById(token.RespositoryId); if (null == repository) { diagnostics.WriteErrorTrace(TraceEventId.Exception, "Repository is null"); return(Request.CreateErrorResponse(HttpStatusCode.NotFound, MessageStrings.Invalid_Repository_id)); } token.UserId = this.user.UserId; this.userService.AddUpdateAuthToken(token); return(Request.CreateResponse(HttpStatusCode.OK)); } catch (ArgumentException ex) { message = string.Format(CultureInfo.CurrentCulture, MessageStrings.Argument_Error_Message_Template, ex.ParamName); status = HttpStatusCode.BadRequest; } return(Request.CreateErrorResponse(status, message)); }
public HttpResponseMessage SaveFileLevelMetadata(int fileId, int repositoryId, IEnumerable <SaveFileLevelMetadata> saveFileLevelMetadataList) { HttpResponseMessage httpResponseMessage; try { Check.IsNotNull(saveFileLevelMetadataList, "saveFileLevelMetadataList"); fileService.SaveFileLevelMetadata(fileId, repositoryId, saveFileLevelMetadataList); httpResponseMessage = Request.CreateResponse(HttpStatusCode.OK, true); } catch (ArgumentException ex) { diagnostics.WriteErrorTrace(TraceEventId.Exception, ex); message = string.Format(CultureInfo.CurrentCulture, MessageStrings.Argument_Error_Message_Template, ex.ParamName); httpResponseMessage = Request.CreateErrorResponse(HttpStatusCode.BadRequest, message); } return(httpResponseMessage); }
public HttpResponseMessage Publish(PublishMessage publishMessage) { string message = string.Empty; HttpError error = null; try { if (null == publishMessage) { diagnostics.WriteErrorTrace(TraceEventId.Exception, "publishMessage null"); return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, string.Format(MessageStrings.Argument_Error_Message_Template, "publishMessage"))); } publishMessage.UserId = this.user.UserId; Repository repository = this.repositoryService.GetRepositoryById(publishMessage.RepositoryId); if (null == repository) { diagnostics.WriteErrorTrace(TraceEventId.Exception, "Repository is null"); return(Request.CreateErrorResponse(HttpStatusCode.NotFound, MessageStrings.Invalid_Repository_id)); } // Create file service instance this.fileService = this.fileServiceFactory.GetFileService(repository.BaseRepository.Name); File file = this.fileService.GetFileByFileId(publishMessage.FileId); if (null == file) { diagnostics.WriteErrorTrace(TraceEventId.Exception, "File is null"); return(Request.CreateErrorResponse(HttpStatusCode.NotFound, MessageStrings.Invalid_File_Id)); } // Perform validations this.fileService.ValidateForPublish(publishMessage); // Publish the message to queue this.publishQueueService.PostFileToQueue(publishMessage); file.Status = FileStatus.Inqueue.ToString(); file.RepositoryId = repository.RepositoryId; file.ModifiedOn = DateTime.UtcNow; // update the file status and associate repository this.fileService.UpdateFile(file); return(Request.CreateResponse(HttpStatusCode.OK)); } catch (ArgumentException argumentException) { error = new HttpError(string.Format(MessageStrings.Argument_Error_Message_Template, argumentException.ParamName)); return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, error)); } catch (MetadataValidationException metadataValidationException) { if (metadataValidationException.NotFound) { error = metadataValidationException.GetHttpError(string.Format(MessageStrings.Required_Field_Metadata_Not_Found_Template, metadataValidationException.FieldName)); } else if (metadataValidationException.MetadataTypeNotFound) { error = metadataValidationException.GetHttpError(string.Format(MessageStrings.Metadata_Type_Not_Found_Template, metadataValidationException.FieldName)); } else { error = metadataValidationException.GetHttpError(string.Format(MessageStrings.Metadata_Field_Value_Type_Mismatch_Template, metadataValidationException.FieldName)); } return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error)); } catch (DataFileNotFoundException fileNotFoundException) { error = fileNotFoundException.GetHttpError(MessageStrings.FileNotFound); return(Request.CreateErrorResponse(HttpStatusCode.NotFound, error)); } catch (RepositoryNotFoundException repositoryNotFoundException) { error = repositoryNotFoundException.GetHttpError(MessageStrings.Invalid_Repository_id); return(Request.CreateErrorResponse(HttpStatusCode.NotFound, error)); } catch (AccessTokenNotFoundException accessTokenNotFoundException) { error = accessTokenNotFoundException.GetHttpError(MessageStrings.Access_Token_Is_Null); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error)); } catch (FileAlreadyPublishedException fileAlreadyPublishedException) { error = fileAlreadyPublishedException.GetHttpError(MessageStrings.File_Already_Published); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error)); } }
public async Task <HttpResponseMessage> Post(string fileName, string fileExtension, string contentType) { try { Check.IsNotEmptyOrWhiteSpace(fileName, "fileName"); Check.IsNotEmptyOrWhiteSpace(fileExtension, "fileExtension"); Check.IsNotEmptyOrWhiteSpace(contentType, "contentType"); byte[] fileContent = default(byte[]); if (Request.Content.IsMimeMultipartContent("form-data")) { string root = Path.GetTempPath(); MultipartFormDataStreamProvider streamProvider = new MultipartFormDataStreamProvider(root); await Request.Content.ReadAsMultipartAsync(streamProvider); MultipartFileData multipartFileData = streamProvider.FileData.First(); /********************************************************* * This API under stress can cause IO exception, for File read * or Delete operation. More details @https://aspnetwebstack.codeplex.com/workitem/176 * Following logic retries file operations at most 3 times * inducing the recommended delay in case of failure. */ int executionDelay = 50, readRetryCount = 3, deleteRetryCount = 3; // Retry mechanics for file read operation while (readRetryCount-- > 0) { try { using (FileStream fileSource = new FileStream(multipartFileData.LocalFileName, FileMode.Open, FileAccess.Read)) { fileContent = await fileSource.GetBytesAsync(); } break; } catch (IOException ioe) { diagnostics.WriteErrorTrace(TraceEventId.Exception, ioe.ToString()); } await Task.Delay(executionDelay); } // Retry mechanics for file delete operation while (deleteRetryCount-- > 0) { try { await Task.Factory.StartNew(() => System.IO.File.Delete(multipartFileData.LocalFileName)); break; } catch (IOException ioe) { diagnostics.WriteErrorTrace(TraceEventId.Exception, ioe.ToString()); } await Task.Delay(executionDelay); } } else { var bufferlessInputStream = HttpContext.Current.Request.GetBufferlessInputStream(); Check.IsNotNull(bufferlessInputStream, "HttpContext.Current.Request.GetBufferlessInputStream()"); fileContent = await bufferlessInputStream.GetBytesAsync(); } this.fileService.ValidateForUpload(fileName, this.user.UserId); DataFile dataFile = new DataFile { FileContent = fileContent, ContentType = contentType, FileName = fileName, CreatedBy = this.user.UserId, FileExtentsion = fileExtension }; IFileHandler fileHandler = this.fileHandlerFactory.GetFileHandler(contentType, this.user.UserId); diagnostics.WriteInformationTrace(Utilities.Enums.TraceEventId.Flow, "blob-before file upload"); var uploadedDataDetails = fileHandler.Upload(dataFile); diagnostics.WriteInformationTrace(Utilities.Enums.TraceEventId.Flow, "blob-after file upload"); if (!uploadedDataDetails.Any() || uploadedDataDetails.Any(dd => dd.FileDetail.FileId == 0)) { return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, MessageStrings.UploadFailed)); } return(Request.CreateResponse <IEnumerable <DataDetail> >(HttpStatusCode.OK, uploadedDataDetails)); } catch (ValidationException validationException) { HttpError error = validationException.GetHttpError(string.Format(MessageStrings.Upload_Validation_Error_Template, validationException.FileName)); return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, error)); } catch (ArgumentException ex) { message = string.Format(CultureInfo.CurrentCulture, MessageStrings.Argument_Error_Message_Template, ex.ParamName); status = HttpStatusCode.BadRequest; } return(Request.CreateErrorResponse(status, message)); }