public static BadRequestException InvalidColumnsException(IReadOnlyList <ProfileColumn> invalidColumns) { if (invalidColumns.IsEmpty()) { throw new ArgumentException(nameof(invalidColumns)); } string message; if (invalidColumns.Count == 1) { message = I18NHelper.FormatInvariant( ErrorMessages.ArtifactList.ColumnsSettings.SingleInvalidColumn, invalidColumns.First().PropertyName); } else { const int maxPropertiesToShow = 3; message = I18NHelper.FormatInvariant( invalidColumns.Count > maxPropertiesToShow ? ErrorMessages.ArtifactList.ColumnsSettings.MultipleInvalidColumns : ErrorMessages.ArtifactList.ColumnsSettings.SomeInvalidColumns, string.Join(", ", invalidColumns.Take(maxPropertiesToShow).Select(column => column.PropertyName))); } return(new BadRequestException(message, ErrorCodes.InvalidColumns)); }
public void TestGetSupportedOperationsDisplayItemsWithBool(string cultureName, string search, string expected) { if (!string.IsNullOrEmpty(cultureName)) { var culture = CultureInfo.CreateSpecificCulture(cultureName); Thread.CurrentThread.CurrentCulture = culture; Thread.CurrentThread.CurrentUICulture = culture; I18NHelper.LoadLanguage(culture.TwoLetterISOLanguageName); } else { I18NHelper.LoadDefaultLanguage(); } var items = OperationHelper.GetSupportedOperationsDisplayItemsLocalized(typeof(string)); Assert.IsNotNull(items); Assert.IsTrue(items.Length > 0); // Act var result = items.FirstOrDefault(x => x.Id == search); // Assert Assert.IsNotNull(result); Assert.AreEqual(expected, result.Name); }
public static BadRequestException ColumnCapacityExceededException(string columnName, int maxCapacity) { var errorMessage = I18NHelper.FormatInvariant( ErrorMessages.ArtifactList.ColumnCapacityExceeded, columnName, maxCapacity); return(new BadRequestException(errorMessage, ErrorCodes.BadRequest)); }
private bool UserExistsInLdapDirectory(LdapSettings ldapSettings, LoginInfo loginInfo) { var userName = loginInfo.UserName != null?loginInfo.UserName.Trim() : loginInfo.Login; var filter = I18NHelper.FormatInvariant("(&(objectCategory={0})({1}={2}))", ldapSettings.GetEffectiveUserObjectCategoryAttribute(), ldapSettings.GetEffectiveAccountNameAttribute(), LdapHelper.EscapeLdapSearchFilter(userName)); try { var found = _authenticator.SearchLdap(ldapSettings, filter); if (found) { return(true); } _log.LogInformation(LogSourceLdap, I18NHelper.FormatInvariant("User '{0}' is not found in LDAP directory {1}", userName, ldapSettings.LdapAuthenticationUrl)); return(false); } catch (Exception ex) { _log.LogInformation(LogSourceLdap, I18NHelper.FormatInvariant("Error while searching a user in LDAP directory {0}", ldapSettings.LdapAuthenticationUrl)); _log.LogError(LogSourceLdap, ex); return(false); } }
public async Task Search_NotFoundArtifact_ResourceNotFoundException() { // arrange ArtifactBasicDetails artifactBasicDetails = null; _sqlArtifactRepositoryMock.Setup(q => q.GetArtifactBasicDetails(ScopeId, UserId, null)).ReturnsAsync(artifactBasicDetails); _searchEngineRepositoryMock.Setup(q => q.GetCollectionContentSearchArtifactResults(ScopeId, _pagination, true, UserId, null)).ReturnsAsync(_searchArtifactsResult); var errorMessage = I18NHelper.FormatInvariant(ErrorMessages.ArtifactNotFound, ScopeId); var excectedResult = new ResourceNotFoundException(errorMessage, ErrorCodes.ResourceNotFound); ResourceNotFoundException exception = null; // act try { await _searchEngineService.Search(ScopeId, _pagination, ScopeType.Contents, true, UserId); } catch (ResourceNotFoundException ex) { exception = ex; } // assert Assert.IsNotNull(exception); Assert.AreEqual(excectedResult.Message, exception.Message); }
public async Task <ReviewSettings> UpdateReviewSettingsAsync(int reviewId, ReviewSettings updatedReviewSettings, bool autoSave, int userId) { var reviewInfo = await GetReviewInfoAsync(reviewId, userId); if (!await _permissionsRepository.HasEditPermissions(reviewId, userId)) { throw ReviewsExceptionHelper.UserCannotModifyReviewException(reviewId); } var reviewData = await _reviewsRepository.GetReviewAsync(reviewId, userId); if (reviewData.ReviewStatus == ReviewPackageStatus.Closed) { throw new ConflictException(I18NHelper.FormatInvariant(ErrorMessages.ReviewIsClosed, reviewId), ErrorCodes.ReviewClosed); } await LockReviewAsync(reviewId, userId, reviewInfo); UpdateEndDate(updatedReviewSettings, autoSave, reviewData.ReviewPackageRawData); UpdateShowOnlyDescription(updatedReviewSettings, reviewData.ReviewPackageRawData); UpdateCanMarkAsComplete(reviewId, updatedReviewSettings, reviewData.ReviewPackageRawData); UpdateRequireESignature(reviewData.ReviewType, updatedReviewSettings, reviewData.ReviewPackageRawData); await UpdateRequireMeaningOfSignatureAsync(reviewInfo.ItemId, userId, reviewInfo.ProjectId, reviewData.ReviewType, updatedReviewSettings, reviewData.ReviewPackageRawData); await _reviewsRepository.UpdateReviewPackageRawDataAsync(reviewId, reviewData.ReviewPackageRawData, userId); return(await GetReviewSettingsFromReviewData(reviewData, reviewInfo)); }
private static bool Compare <T>(T obj1, T obj2, out string message) { message = null; if (obj1 == null && obj2 == null) { return(true); } if (obj1 == null || obj2 == null) { message = "One of the objects is null."; return(false); } var serializer = new XmlSerializer(obj1.GetType()); var serialized1 = new StringWriter(CultureInfo.InvariantCulture); var serialized2 = new StringWriter(CultureInfo.InvariantCulture); serializer.Serialize(serialized1, obj1); serializer.Serialize(serialized2, obj2); var str1 = serialized1.ToString(); var str2 = serialized2.ToString(); var areEqual = str1 == str2; if (!areEqual) { message = I18NHelper.FormatInvariant("object 1:\r\n{0}\r\nobject 2:\r\n{1}", str1, str2); } return(areEqual); }
public async Task DeleteProject(int userId, int projectId) { ProjectStatus?projectStatus; InstanceItem project = await _instanceRepository.GetInstanceProjectAsync(projectId, userId, fromAdminPortal : true); if (!TryGetProjectStatusIfProjectExist(project, out projectStatus)) { throw new ResourceNotFoundException( I18NHelper.FormatInvariant(ErrorMessages.ProjectWasDeletedByAnotherUser, project.Id, project.Name), ErrorCodes.ResourceNotFound); } if (projectStatus == ProjectStatus.Live) { Func <IDbTransaction, long, Task> action = async(transaction, transactionId) => { var revisionId = await _instanceRepository.RemoveProject(userId, projectId, transaction); await _instanceRepository.DeactivateWorkflowsWithLastAssignmentForDeletedProject(projectId, transaction); var artifactIds = await _instanceRepository.GetProjectArtifactIds(projectId, revisionId - 1, userId, transaction : transaction); await PostOperation(artifactIds, revisionId, userId, transactionId, transaction); }; await _instanceRepository.RunInTransactionAsync(action); } else { await _instanceRepository.PurgeProject(projectId, project); } }
public async Task <IEnumerable <Reply> > GetReplies(int artifactId, int discussionId, int?subArtifactId = null) { ValidateRequestParameters(artifactId, subArtifactId); if (discussionId < 1) { throw new BadRequestException(I18NHelper.FormatInvariant("Parameter: {0} is out of the range of valid values", nameof(discussionId))); } var userId = Session.UserId; var itemId = subArtifactId.HasValue ? subArtifactId.Value : artifactId; var revisionId = int.MaxValue; var isDeleted = await _artifactVersionsRepository.IsItemDeleted(itemId); var itemInfo = isDeleted ? await _artifactVersionsRepository.GetDeletedItemInfo(itemId) : await _artifactPermissionsRepository.GetItemInfo(itemId, userId, false); if (itemInfo == null || await _discussionsRepository.IsDiscussionDeleted(discussionId)) { throw new ResourceNotFoundException(); } if (subArtifactId.HasValue && itemInfo.ArtifactId != artifactId) { throw new BadRequestException("Please provide a proper subartifact Id"); } if (isDeleted) { revisionId = ((DeletedItemInfo)itemInfo).VersionId; } var permissions = await _artifactPermissionsRepository.GetArtifactPermissions(new[] { artifactId }, Session.UserId, false, revisionId); if (permissions.IsEmpty()) { permissions = await _artifactPermissionsRepository.GetArtifactPermissionDirectly(itemId, Session.UserId, itemInfo.ProjectId); } var projectPermissions = await _artifactPermissionsRepository.GetProjectPermissions(itemInfo.ProjectId); RolePermissions permission = RolePermissions.None; if (!permissions.TryGetValue(artifactId, out permission) || !permission.HasFlag(RolePermissions.Read)) { throw new AuthorizationException("You do not have permission to access the artifact"); } var result = await _discussionsRepository.GetReplies(discussionId, itemInfo.ProjectId); foreach (var reply in result) { reply.CanDelete = !projectPermissions.HasFlag(ProjectPermissions.CommentsDeletionDisabled) && permissions.TryGetValue(artifactId, out permission) && (permission.HasFlag(RolePermissions.DeleteAnyComment) || (permission.HasFlag(RolePermissions.Comment) && reply.UserId == userId)); reply.CanEdit = !projectPermissions.HasFlag(ProjectPermissions.CommentsModificationDisabled) && permissions.TryGetValue(artifactId, out permission) && (permission.HasFlag(RolePermissions.Comment) && reply.UserId == userId); } return(result); }
private async Task ValidateArtifact(VersionControlArtifactInfo artifactInfo) { // Confirm that the artifact is not deleted var isDeleted = await _stateChangeExecutorRepositories.ArtifactVersionsRepository.IsItemDeleted(_input.ArtifactId); if (isDeleted) { throw new ConflictException(I18NHelper.FormatInvariant("Artifact has been deleted and is no longer available for workflow state change. Please refresh your view.")); } if (artifactInfo.IsDeleted) { throw new ConflictException(I18NHelper.FormatInvariant("Artifact has been deleted and is no longer available for workflow state change. Please refresh your view.")); } if (artifactInfo.VersionCount != _input.CurrentVersionId) { throw new ConflictException(I18NHelper.FormatInvariant("Artifact has been updated. The current version of the artifact {0} does not match the specified version {1}. Please refresh your view.", artifactInfo.VersionCount, _input.CurrentVersionId)); } // Lock is obtained by current user inside the stored procedure itself // Check that it is not locked by some other user if (artifactInfo.LockedByUser != null && artifactInfo.LockedByUser.Id != _userId) { throw new ConflictException(I18NHelper.FormatInvariant("Artifact has been updated. Artifact is locked by another user. Please refresh your view.")); } }
private static XmlPropertyChangeAction ToXmlModel(IePropertyChangeAction ieAction, WorkflowDataMaps dataMaps) { if (ieAction == null) { return(null); } var xmlAction = new XmlPropertyChangeAction { Name = ieAction.Name, PropertyValue = ieAction.PropertyValue, UsersGroups = ToXmlModel(ieAction.UsersGroups, dataMaps) }; int propertyTypeId; if (!dataMaps.PropertyTypeMap.TryGetValue(ieAction.PropertyName, out propertyTypeId) && !WorkflowHelper.TryGetNameOrDescriptionPropertyTypeId(ieAction.PropertyName, out propertyTypeId)) { throw new ExceptionWithErrorCode(I18NHelper.FormatInvariant("Id of Standard Property Type '{0}' is not found.", ieAction.PropertyName), ErrorCodes.UnexpectedError); } xmlAction.PropertyTypeId = propertyTypeId; ToXmlModel(ieAction.ValidValues, propertyTypeId, ieAction.PropertyName, dataMaps, xmlAction); return(xmlAction); }
private async Task <int> SaveSettingsAsync(int itemId, int userId, ProfileSettingsParams profileSettings) { if (profileSettings == null) { throw new ArgumentException(I18NHelper.FormatInvariant( ErrorMessages.ArtifactList.SaveProfileSettingsProfileSettingsNull)); } var existingSettings = await _artifactListSettingsRepository.GetSettingsAsync(itemId, userId); var settings = new XmlProfileSettings { Columns = !profileSettings.ColumnsUndefined ? ArtifactListHelper.ConvertProfileColumnsToXmlProfileSettings(profileSettings.Columns) : existingSettings?.Columns, PaginationLimit = !profileSettings.PaginationLimitUndefined ? profileSettings.PaginationLimit : existingSettings?.PaginationLimit, }; if (existingSettings == null) { return(await _artifactListSettingsRepository.CreateSettingsAsync(itemId, userId, settings)); } else { return(await _artifactListSettingsRepository.UpdateSettingsAsync(itemId, userId, settings)); } }
private static XmlEmailNotificationAction ToXmlModel(IeEmailNotificationAction ieAction, IDictionary <string, int> propertyTypeMap) { if (ieAction == null) { return(null); } var xmlAction = new XmlEmailNotificationAction { Name = ieAction.Name, Emails = ieAction.Emails, Message = ieAction.Message }; if (ieAction.PropertyName != null) { int propertyTypeId; if (!propertyTypeMap.TryGetValue(ieAction.PropertyName, out propertyTypeId)) { throw new ExceptionWithErrorCode( I18NHelper.FormatInvariant("Id of Standard Property Type '{0}' is not found.", ieAction.PropertyName), ErrorCodes.UnexpectedError); } xmlAction.PropertyTypeId = propertyTypeId; } return(xmlAction); }
private static int?FindDefaultValidValueId(List <XmlCustomPropertyValidValue> validValues) { if (validValues == null) { return(null); } var orderedValidValues = validValues.OrderBy(v => I18NHelper.Int32ParseInvariant(v.OrderIndex)).ToList(); for (var i = 0; i < orderedValidValues.Count; i++) { var validValue = orderedValidValues.ElementAt(i); if (validValue?.Selected == "1") { int?vvId = null; if (!string.IsNullOrWhiteSpace(validValue.LookupListItemId)) { int intValue; if (int.TryParse(validValue.LookupListItemId, out intValue)) { vvId = intValue; } } return(vvId); } } return(null); }
/// <summary> /// Throws an exception if the argumentValue is less than lowerValue. /// </summary> /// <typeparam name="T">A type that implements <see cref="IComparable"/>.</typeparam> /// <param name="lowerValue">The lower value accepted as valid.</param> /// <param name="argumentValue">The argument value to test.</param> /// <param name="argumentName">Name of the argument.</param> /// <exception cref="System.ArgumentOutOfRangeException">Validation error.</exception> public static void ArgumentGreaterOrEqualThan <T>(T lowerValue, T argumentValue, string argumentName) where T : struct, IComparable { if (argumentValue.CompareTo((T)lowerValue) < 0) { throw new ArgumentOutOfRangeException(argumentName, argumentValue, I18NHelper.FormatInvariant("The size of '{0}' should be greater or equal to '{1}'.", argumentName, lowerValue)); } }
public static PropertyType ConvertToPropertyType(this SqlProjectMetaRepository.PropertyTypeVersion pv) { // Property XmlInfo is not supposed to be null, see bug 4819 var propertyFromXml = pv.PrimitiveType == PropertyPrimitiveType.Choice ? XmlModelSerializer.DeserializeCustomProperties(pv.XmlInfo).CustomProperties[0] : null; return(new PropertyType { Id = pv.PropertyTypeId, Name = pv.Name, VersionId = pv.VersionId, InstancePropertyTypeId = pv.InstancePropertyTypeId, PrimitiveType = pv.PrimitiveType, IsRichText = pv.PrimitiveType == PropertyPrimitiveType.Text ? pv.RichText : null, IsRequired = pv.Required, IsValidated = pv.PrimitiveType == PropertyPrimitiveType.Number || pv.PrimitiveType == PropertyPrimitiveType.Date || pv.PrimitiveType == PropertyPrimitiveType.Choice ? pv.Validate : null, IsMultipleAllowed = pv.PrimitiveType == PropertyPrimitiveType.Text || pv.PrimitiveType == PropertyPrimitiveType.Choice ? pv.AllowMultiple : null, StringDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.Text ? pv.StringDefaultValue : null, DateDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.Date ? pv.DateDefaultValue : null, DecimalDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.Number ? PropertyHelper.ToDecimal(pv.DecimalDefaultValue) : null, UserGroupDefaultValue = pv.PrimitiveType == PropertyPrimitiveType.User ? PropertyHelper.ParseUserGroups(pv.UserDefaultValue) : null, MinDate = pv.PrimitiveType == PropertyPrimitiveType.Date && pv.Validate.GetValueOrDefault() ? pv.MinDate : null, MaxDate = pv.PrimitiveType == PropertyPrimitiveType.Date && pv.Validate.GetValueOrDefault() ? pv.MaxDate : null, MinNumber = pv.PrimitiveType == PropertyPrimitiveType.Number && pv.Validate.GetValueOrDefault() ? PropertyHelper.ToDecimal(pv.MinNumber) : null, MaxNumber = pv.PrimitiveType == PropertyPrimitiveType.Number && pv.Validate.GetValueOrDefault() ? PropertyHelper.ToDecimal(pv.MaxNumber) : null, DecimalPlaces = pv.PrimitiveType == PropertyPrimitiveType.Number ? pv.DecimalPlaces : null, ValidValues = pv.PrimitiveType == PropertyPrimitiveType.Choice ? propertyFromXml?.ValidValues.OrderBy(v => I18NHelper.Int32ParseInvariant(v.OrderIndex)) .Select(v => { int?vvId = null; if (!string.IsNullOrWhiteSpace(v.LookupListItemId)) { int intValue; if (int.TryParse(v.LookupListItemId, out intValue)) { vvId = intValue; } } return new ValidValue { Id = vvId, Value = v.Value }; }).ToList() : null, DefaultValidValueId = pv.PrimitiveType == PropertyPrimitiveType.Choice ? FindDefaultValidValueId(propertyFromXml.ValidValues) // TODO : null, }); }
public async Task GetFile_FileAlreadyExpiredBeforeNow_NotFound() { // Arrange var moq = new Mock <IFilesRepository>(); var moqFileStreamRepo = new Mock <IFileStreamRepository>(); var moqConfigRepo = new Mock <IConfigRepository>(); var moqLog = new Mock <sl.IServiceLogRepository>(); var contentString = "Test2 content"; var fileChunk = new FileChunk() { ChunkNum = 1, ChunkContent = Encoding.UTF8.GetBytes(contentString), ChunkSize = Encoding.UTF8.GetBytes(contentString).Length }; var file = new File { FileId = new Guid("22222222-2222-2222-2222-222222222222"), FileName = "Test2.txt", StoredTime = I18NHelper.DateTimeParseExactInvariant("2015-09-05T22:57:31.7824054-04:00", "o"), FileType = "application/octet-stream", FileSize = fileChunk.ChunkSize, ChunkCount = 1, ExpiredTime = DateTime.UtcNow }; var moqDbConnection = new Mock <DbConnection>(); moq.Setup(t => t.CreateConnection()).Returns(moqDbConnection.Object); moq.Setup(t => t.GetFileHead(It.IsAny <Guid>())).ReturnsAsync(file); moq.Setup(t => t.GetFileInfo(It.IsAny <Guid>())).Returns(file); moq.Setup(t => t.ReadChunkContent(moqDbConnection.Object, file.FileId, 1)).Returns(fileChunk.ChunkContent); moqConfigRepo.Setup(t => t.FileChunkSize).Returns(1 * 1024 * 1024); var controller = new FilesController(moq.Object, moqFileStreamRepo.Object, moqConfigRepo.Object, moqLog.Object) { Request = new HttpRequestMessage { RequestUri = new Uri("http://localhost/files") }, Configuration = new HttpConfiguration() }; controller.Configuration.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "files/{id}", defaults: new { id = RouteParameter.Optional }); // Act var actionResult = await controller.GetFileContent("22222222222222222222222222222222"); System.Threading.CancellationToken cancellationToken = new System.Threading.CancellationToken(); HttpResponseMessage response = await actionResult.ExecuteAsync(cancellationToken); // Assert Assert.IsTrue(response.StatusCode == HttpStatusCode.NotFound, "Expired file should return status code as NotFound"); }
public static ResourceNotFoundException ReviewNotFoundException(int reviewId, int revisionId = int.MaxValue) { var errorMessage = revisionId != int.MaxValue ? I18NHelper.FormatInvariant("Review (Id:{0}) or its revision (#{1}) is not found.", reviewId, revisionId) : I18NHelper.FormatInvariant("Review (Id:{0}) is not found.", reviewId); return(new ResourceNotFoundException(errorMessage, ErrorCodes.ResourceNotFound)); }
public static I18NHelper GetInstance() { if (null == instance) { instance = new I18NHelper(); } return(instance); }
/// <summary> /// 阿拉伯数字转为汉字(支持0-9) /// </summary> /// <param name="number"></param> /// <returns></returns> public static string GetChineseNumber(int number) { if (number >= 0 && number <= 9) { return(I18NHelper.GetText(chineseNumIndex + number)); } Debug.LogWarning(string.Format("输入的数字{0}不在0~9范围内!", number)); return(""); }
public async Task <AuthenticationUser> AuthenticateSamlUserAsync(string samlResponse) { if (string.IsNullOrEmpty(samlResponse)) { throw new FormatException("Saml response cannot be empty"); } var instanceSettings = await _settingsRepository.GetInstanceSettingsAsync(); if (!instanceSettings.IsSamlEnabled.GetValueOrDefault()) { throw new AuthenticationException("Federated Authentication mechanism must be enabled"); } var fedAuthSettings = await _settingsRepository.GetFederatedAuthenticationSettingsAsync(); if (fedAuthSettings == null) { throw new AuthenticationException("Federated Authentication settings must be provided"); } var principal = _samlRepository.ProcessEncodedResponse(samlResponse, fedAuthSettings); AuthenticationUser user = null; if (fedAuthSettings.IsAllowingNoDomain) { foreach (var allowedDomain in fedAuthSettings.DomainList.OrderBy(l => l.OrderIndex)) { user = await _userRepository.GetUserByLoginAsync($"{allowedDomain.Name}\\{principal.Identity.Name}"); if (user != null) { break; } } } else { user = await _userRepository.GetUserByLoginAsync(principal.Identity.Name); } if (user == null) // cannot find user in the DB { await _log.LogInformation(WebApiConfig.LogSourceSessions, I18NHelper.FormatInvariant("Could not get user with login '{0}'. NameClaimType '{1}'", principal.Identity.Name, fedAuthSettings.NameClaimType)); throw new AuthenticationException("Invalid user name or password", ErrorCodes.InvalidCredentials); } if (!user.IsEnabled) { throw new AuthenticationException(I18NHelper.FormatInvariant("Your account '{0}' has been locked out, please contact your Blueprint Instance Administrator.", user.Login), ErrorCodes.AccountIsLocked); } user.LicenseType = await _userRepository.GetEffectiveUserLicenseAsync(user.Id); return(user); }
public async Task Read_File_Chunks_Success() { // This tests reading file chunks and pushing them to the output stream // Arrange var moqFilesRepo = new Mock <IFilesRepository>(); var moqConfigRepo = new Mock <IConfigRepository>(); int fileChunkSize = 125; var contentString = GetRandomString(125); // set the size of the content to force two loops to retrieve total of 250 bytes byte[] fileStreamContent = Encoding.UTF8.GetBytes(contentString + contentString); var file = new File { FileId = new Guid("22222222-2222-2222-2222-222222222222"), FileName = "Test2.txt", StoredTime = I18NHelper.DateTimeParseExactInvariant("2015-09-05T22:57:31.7824054-04:00", "o"), FileType = "application/octet-stream", FileSize = fileStreamContent.Length, ChunkCount = 2 }; var moqDbConnection = new Mock <DbConnection>(); moqFilesRepo.Setup(t => t.CreateConnection()).Returns(moqDbConnection.Object); moqFilesRepo.Setup(t => t.GetFileHead(It.IsAny <Guid>())).ReturnsAsync(file); moqFilesRepo.Setup(t => t.ReadChunkContent(moqDbConnection.Object, It.IsAny <Guid>(), It.IsAny <int>())).Returns(fileStreamContent.Take <byte>(125).ToArray <byte>()); moqConfigRepo.Setup(t => t.LegacyFileChunkSize).Returns(fileChunkSize); moqFilesRepo.Setup(t => t.GetFileInfo(It.IsAny <Guid>())).Returns(file); // Act SqlPushStream sqlPushStream = new SqlPushStream(); sqlPushStream.Initialize(moqFilesRepo.Object, file.FileId); HttpContent responseContent = new PushStreamContent(sqlPushStream.WriteToStream, new MediaTypeHeaderValue(file.ContentType)); Stream response = await responseContent.ReadAsStreamAsync(); string originalContent = Encoding.UTF8.GetString(fileStreamContent); string resultContent = string.Empty; using (var memoryStream = new MemoryStream()) { response.CopyTo(memoryStream); resultContent = Encoding.UTF8.GetString(memoryStream.ToArray()); } // Assert Assert.IsTrue(originalContent.Equals(resultContent)); }
public async Task HeadFile_GetHeadForExistentFileStreamFile_Success() { // Arrange var moq = new Mock <IFilesRepository>(); var moqFileStreamRepo = new Mock <IFileStreamRepository>(); var moqConfigRepo = new Mock <IConfigRepository>(); var moqLog = new Mock <sl.IServiceLogRepository>(); var file = new File { FileId = new Guid("33333333-3333-3333-3333-333333333333"), FileName = "Test3.txt", StoredTime = I18NHelper.DateTimeParseExactInvariant("2015-09-05T22:57:31.7824054-04:00", "o"), FileType = "text/html", ChunkCount = 1, IsLegacyFile = true }; moq.Setup(t => t.GetFileHead(It.IsAny <Guid>())).ReturnsAsync((File)null); moqFileStreamRepo.Setup(t => t.FileExists(file.FileId)).Returns(true); moqFileStreamRepo.Setup(t => t.GetFileHead(file.FileId)).Returns(file); var controller = new FilesController(moq.Object, moqFileStreamRepo.Object, moqConfigRepo.Object, moqLog.Object) { Request = new HttpRequestMessage { RequestUri = new Uri("http://localhost/files"), Method = HttpMethod.Head }, Configuration = new HttpConfiguration() }; controller.Configuration.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "files/{id}", defaults: new { id = RouteParameter.Optional }); // Act var actionResult = await controller.GetFileHead("33333333333333333333333333333333"); System.Threading.CancellationToken cancellationToken = new System.Threading.CancellationToken(); HttpResponseMessage response = await actionResult.ExecuteAsync(cancellationToken); var content = response.Content; var contentType = content.Headers.ContentType; var fileName = content.Headers.ContentDisposition.FileName; var storedTime = response.Headers.GetValues("Stored-Date"); // Assert Assert.IsTrue(response.IsSuccessStatusCode); Assert.AreEqual("Test3.txt", fileName); Assert.AreEqual("application/octet-stream", contentType.MediaType, string.Format("Returned content type {0} does not match expected {1}", contentType, "text/html")); Assert.AreEqual(DateTime.Parse("2015-09-05T22:57:31.7824054-04:00"), DateTime.Parse(storedTime.First())); }
// public static SamlSecurityToken CreateSamlSecurityToken(byte[] certificate, string password, params Claim[] claims) // { // const string acsUrl = "http://blueprintsys.com"; // var assertion = new SamlAssertion(new SamlNameIdentifier(DefaultIssuer)); // var conditions = new Saml2Conditions // { // NotBefore = DateTime.UtcNow, // NotOnOrAfter = DateTime.MaxValue // }; // conditions.AudienceRestrictions.Add(new Saml2AudienceRestriction(new Uri(acsUrl, UriKind.RelativeOrAbsolute))); // assertion.Conditions = conditions; // var subject = new Saml2Subject(); // subject.SubjectConfirmations.Add(new Saml2SubjectConfirmation(Bearer)); // assertion.Subject = subject; // var statement = new Saml2AttributeStatement(); // foreach (var claim in claims) // { // statement.Attributes.Add(new Saml2Attribute(claim.Type, claim.Value)); // assertion.Statements.Add(statement); // } // var clientSigningCredentials = new X509SigningCredentials( // new X509Certificate2(certificate, password, X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable)); // assertion.SigningCredentials = clientSigningCredentials; // return new Saml2SecurityToken(assertion); // } public static string Serialize(Saml2SecurityToken token) { var handler = new Saml2SecurityTokenHandler(); var sw = I18NHelper.CreateStringWriterInvariant(); using (var textWriter = new XmlTextWriter(sw)) { handler.WriteToken(textWriter, token); return(sw.ToString()); } }
public void InvalidColumnsException_AllParamsIsValid_OneProfileColumn_ReturnBadRequestException() { var expectedMessage = I18NHelper.FormatInvariant( ErrorMessages.ArtifactList.ColumnsSettings.SingleInvalidColumn, _profileColumns.First().PropertyName); var result = ArtifactListExceptionHelper.InvalidColumnsException(_profileColumns); Assert.IsNotNull(result); Assert.AreEqual(expectedMessage, result.Message); }
public async Task <WorkflowTriggersContainer> GetWorkflowEventTriggersForTransition(int userId, int artifactId, int workflowId, int fromStateId, int toStateId, int transitionId) { var desiredTransition = await GetTransitionForAssociatedStatesAsync(userId, artifactId, workflowId, fromStateId, toStateId, transitionId); if (desiredTransition == null) { throw new ConflictException(I18NHelper.FormatInvariant("No transitions available. Workflow could have been updated. Please refresh your view.")); } return(GetWorkflowTriggersContainer(desiredTransition.Triggers)); }
public async Task <AuthenticationUser> AuthenticateUserAsync(string login, string password, bool ignoreInvalidLoginAttempts) { if (string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password)) { throw new AuthenticationException("Username and password cannot be empty", ErrorCodes.EmptyCredentials); } var user = await _userRepository.GetUserByLoginAsync(login); if (user == null) { await _log.LogInformation(WebApiConfig.LogSourceSessions, I18NHelper.FormatInvariant("Could not get user with login '{0}'", login)); throw new AuthenticationException("Invalid username or password", ErrorCodes.InvalidCredentials); } var instanceSettings = await _settingsRepository.GetInstanceSettingsAsync(); if (instanceSettings.IsSamlEnabled.GetValueOrDefault()) { // Fallback is allowed by default (value is null) if (!user.IsFallbackAllowed.GetValueOrDefault(true)) { throw new AuthenticationException("User must be authenticated via Federated Authentication mechanism", ErrorCodes.FallbackIsDisabled); } } AuthenticationStatus authenticationStatus; switch (user.Source) { case UserGroupSource.Database: authenticationStatus = AuthenticateDatabaseUser(user, password, instanceSettings.PasswordExpirationInDays); break; case UserGroupSource.Windows: if (!instanceSettings.IsLdapIntegrationEnabled) { throw new AuthenticationException(string.Format("To authenticate user with login: {0}, ldap integration must be enabled", login), ErrorCodes.LdapIsDisabled); } authenticationStatus = await _ldapRepository.AuthenticateLdapUserAsync(login, password, instanceSettings.UseDefaultConnection); break; default: throw new AuthenticationException(string.Format("Authentication provider could not be found for login: {0}", login)); } await ProcessAuthenticationStatus(authenticationStatus, user, instanceSettings, ignoreInvalidLoginAttempts); user.LicenseType = await _userRepository.GetEffectiveUserLicenseAsync(user.Id); return(user); }
/// <summary> /// Throws an exception if the tested TimeSpam argument is not a valid timeout value. /// </summary> /// <exception cref="ArgumentOutOfRangeException">Thrown if the argument is not null and is not a valid timeout value.</exception> /// <param name="argumentValue">Argument value to check.</param> /// <param name="argumentName">Name of argument being checked.</param> public static void ArgumentIsValidTimeout(TimeSpan?argumentValue, string argumentName) { if (argumentValue.HasValue) { long totalMilliseconds = (long)argumentValue.Value.TotalMilliseconds; if (totalMilliseconds < (long)-1 || totalMilliseconds > (long)2147483647) { throw new ArgumentOutOfRangeException(I18NHelper.FormatInvariant("The valid range for '{0}' is from 0 to 24.20:31:23.647", argumentName)); } } }
public void ToInt32_NonNumericValue_ReturnsDefaultValue() { // Arrange const string s = "foo"; const int defaultValue = 5; // Act int x = I18NHelper.ToInt32(s, defaultValue); // Assert Assert.AreEqual(x, 5, I18NHelper.FormatInvariant("I18NHelper.ToInt32 converted '{0}' into {1} instead of {2}!", s, x, defaultValue)); }
public void TestLoadLanguage() { // Arrange var count = I18NHelper.Languages.Count; Assert.IsTrue(count > 0); // Act I18NHelper.LoadLanguage("DE"); // Assert Assert.IsTrue(I18NHelper.Count > 0); }