private async void OnRegisterCommand() { RegisterErrorMsg = null; if (RegisterUserName == null || RegisterPassword == null || RegisterConfirmPassword == null || RegisterFirstName == null || RegisterLastName == null || RegisterEmail == null) { RegisterErrorMsg = MessageNames.RegisterBlank; } else { RegisterErrorMsg = ValidationUtilities.ValidateInput(RegisterFirstName); if (RegisterErrorMsg == null) { RegisterErrorMsg = ValidationUtilities.ValidateInput(RegisterLastName); if (RegisterErrorMsg == null) { RegisterErrorMsg = ValidationUtilities.ValidateInput(RegisterUserName); if (RegisterErrorMsg == null) { if (RegexUtilities.IsValidEmail(RegisterEmail)) { RegisterErrorMsg = ValidationUtilities.ValidatePassword(RegisterPassword); if (RegisterErrorMsg == null) { if (RegisterPassword != RegisterConfirmPassword) { RegisterErrorMsg = MessageNames.RegisterWrongPasswords; } else { try { _userName.FirstName = RegisterFirstName; _userName.LastName = RegisterLastName; _userName.UserName = RegisterUserName; _userName.Password = RegisterPassword; _userName.Email = RegisterEmail; await _userDataService.RegisterUser(_userName); } catch (Exception) { RegisterErrorMsg = MessageNames.RegisterUniqueException; } } } } else { RegisterErrorMsg = MessageNames.RegisterWrongEmail; } } } } } if (RegisterErrorMsg == null) { MessagingCenter.Send(this, MessageNames.RegisterdUser); _navigationService.GoBack(); } }
public IHttpActionResult ResetPassword(SendActivationReq req) { try { string currentUsrEmail = HttpUtilities.GetUserNameFromToken(this.Request); byte[] salt = AuthorizationUtilities.generateSalt(); User user = _context.Users.FirstOrDefault(i => i.Id == req.UserId); // if (user.IsActiveUser == false) ValidationUtilities.ValidateUserforNewPassword(req.UserId, user); string generatedPassword = AuthorizationUtilities.GeneratePassword(); AuthorizationUtilities.SendPasswordtoUser(user.Email, generatedPassword); byte[] pwdhash = AuthorizationUtilities.hash(generatedPassword, user.Salt); // user.Salt = salt; user.Password = pwdhash;//AuthorizationUtilities.hash(generatedPassword, salt); user.ModifiedBy = currentUsrEmail; // user.UpdatedAt = DateTimeOffset.UtcNow; _context.Entry(user).State = System.Data.Entity.EntityState.Modified; _context.SaveChanges(); return(Ok()); } catch (HttpResponseException ex) { throw ex; } catch (Exception ex) { LGSELogger.Error(ex); return(InternalServerError(ex)); } }
public async Task <IHttpActionResult> PostRole(RoleRequest item) { try { string currentUserEmail = HttpUtilities.GetUserNameFromToken(this.Request); string message = ValidationUtilities.ValidateRole(item); if (string.IsNullOrEmpty(message)) { Mapper.Initialize(cfg => cfg.CreateMap <RoleRequest, Role>() .ForMember(i => i.CreatedBy, j => j.UseValue(currentUserEmail)) ); var RoleMap = Mapper.Map <RoleRequest, Role>(item); RoleMap.Id = Guid.NewGuid().ToString(); Role current = await InsertAsync(RoleMap); return(CreatedAtRoute("Tables", new { id = current.Id }, current)); } else { return(BadRequest(message)); } } catch (Exception ex) { HttpUtilities.ServerError(ex, Request); return(null); } }
public IHttpActionResult SendActivationLink(SendActivationReq req) { try { string currentUsrEmail = HttpUtilities.GetUserNameFromToken(this.Request); var user = _context.Users.FirstOrDefault(i => i.Id == req.UserId); if (user.IsActiveUser == false) { return(BadRequest(ErrorCodes.USER_DEACTIVATED_BY_ADMIN.ToString())); } else if (user.Domain.IsActive == false) { return(BadRequest(ErrorCodes.DOMAIN_IS_INACTIVE.ToString())); } ValidationUtilities.ValidateUserforActivationLink(req.UserId, user); string otpCode = AuthorizationUtilities.GenerateOTPCode(); AuthorizationUtilities.SendOTPtoUser(user.Email, otpCode); user.OTPCode = otpCode; user.OTPGeneratedAt = DateTimeOffset.UtcNow; user.ModifiedBy = currentUsrEmail; // user.UpdatedAt = DateTimeOffset.UtcNow; _context.Entry(user).State = System.Data.Entity.EntityState.Modified; _context.SaveChanges(); return(Ok()); } catch (HttpResponseException ex) { throw ex; } catch (Exception ex) { LGSELogger.Error(ex); return(InternalServerError(ex)); } }
public override IEnumerable <ValidationMessage> GetValidationMessages(Dictionary <string, Dictionary <string, Operation> > entity, RuleContext context) { // get all operation objects that are either of get or post type var serviceDefinition = (ServiceDefinition)context.Root; var listOperations = entity.Values.SelectMany(opDict => opDict.Where(pair => pair.Key.ToLower().Equals("get") || pair.Key.ToLower().Equals("post"))); foreach (var opPair in listOperations) { // if the operation id is already of the type _list we can skip this check if (ListRegex.IsMatch(opPair.Value.OperationId)) { continue; } var violatingPath = ValidationUtilities.GetOperationIdPath(opPair.Value.OperationId, entity).Key; if (ValidationUtilities.IsXmsPageableResponseOperation(opPair.Value)) { yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty(violatingPath).AppendProperty(opPair.Key).AppendProperty("operationId")), this, opPair.Value.OperationId, XmsPageableViolation)); } else if (ValidationUtilities.IsArrayTypeResponseOperation(opPair.Value, serviceDefinition)) { yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty(violatingPath).AppendProperty(opPair.Key).AppendProperty("operationId")), this, opPair.Value.OperationId, ArrayTypeViolation)); } } }
/// <summary> /// Reads exactly the specified number of bytes from a stream. /// </summary> /// /// <param name="stream">The stream to read from.</param> /// <param name="buffer">The array in which to store bytes.</param> /// <param name="offset">The index in <paramref name="buffer"/> of the first byte to /// store.</param> /// <param name="count">The number of bytes to store.</param> /// <param name="throwIfNoData"><c>true</c> to throw an exception if the end of the stream /// is reached before reading any data. If <c>false</c>, this method returns /// <c>false</c> instead of throwing an exception. An exception is always thrown if /// one or more bytes were read before reaching the end of the stream.</param> /// /// <returns><c>true</c> if the requested number of bytes were read from the underlying /// stream, or <c>false</c> if the end of the stream was reached without reading any /// bytes and <paramref name="throwIfNoData"/> is <c>true</c>.</returns> /// /// <exception cref="ArgumentNullException"><paramref name="stream"/> or /// <paramref name="buffer"/> are <c>null</c>.</exception> /// <exception cref="ArgumentOutOfRangeException">The specified /// <paramref name="offset"/> and <paramref name="count"/> fall outside the bounds of /// the <paramref name="buffer"/> array.</exception> /// <exception cref="EndOfStreamException">The end of the stream was reached before the /// requested number of bytes were read, and <paramref name="throwIfNoData"/> is /// <c>true</c>.</exception> /// <exception cref="IOException">An I/O error occurred.</exception> /// <exception cref="NotSupportedException">The stream does not support /// reading.</exception> /// <exception cref="ObjectDisposedException">The stream object has been /// disposed.</exception> public static bool ReadExactly(this Stream stream, byte[] buffer, int offset, int count, bool throwIfNoData) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } ValidationUtilities.ValidateArraySlice(buffer, offset, count, nameof(buffer), nameof(offset), nameof(count)); int totalBytesRead = 0; while (count > 0) { int bytesRead = stream.Read(buffer, offset, count); Debug.Assert(bytesRead >= 0 && bytesRead <= count); if (bytesRead == 0) { if (!throwIfNoData && totalBytesRead == 0) { return(false); } throw new EndOfStreamException(); } count -= bytesRead; offset += bytesRead; totalBytesRead += bytesRead; } return(true); }
public void TestValidateRuleThrowsException() { var vm = new TestViewModel(); vm.AllRules.Add(new KeyValuePair <string, IValidationRule>( nameof(vm.Property), new DelegateValidationRule <int>(x => throw new Exception("test exception")) )); vm.AllRules.Add(new KeyValuePair <string, IValidationRule>( nameof(vm.Property), new DelegateValidationRule <int>(x => new ValidationRuleResult(true, "error")) )); ValidationRuleResult[] results = ValidationUtilities.Validate(vm, nameof(vm.Property)) .ToArray(); Assert.AreEqual(2, results.Length); // first rule throws an exception Assert.AreEqual(true, results[0].IsError); Assert.AreEqual("test exception", results[0].ErrorMessage); // second rule yields a failed result Assert.AreEqual(true, results[1].IsError); Assert.AreEqual("error", results[1].ErrorMessage); }
// POST tables/User public IHttpActionResult PostUser(RegisterRequest request) { try { string errorMessage = ValidationUtilities.ValidateUserDetails(request); var domainObj = DbUtilities.GetDomainDetails(request.Email); if (errorMessage.Equals(string.Empty)) { string otpCode = AuthorizationUtilities.GenerateOTPCode(); string userEmail = HttpUtilities.GetUserNameFromToken(this.Request); DbUtilities.SaveTheUser(request, otpCode, domainObj, userEmail, request.IsActiveUser); AuthorizationUtilities.SendOTPtoUser(request.Email, otpCode); return(Ok(HttpUtilities.CustomResp(ErrorCodes.USER_CREATED.ToString()))); } else { return(BadRequest(errorMessage)); } } catch (Exception ex) { LGSELogger.Error(ex); return(InternalServerError(ex)); } //return CreatedAtRoute("Tables", new { id = current.Id }, current); }
// PATCH tables/User/48D68C86-6EA6-4C25-AA33-223FC9A27959 public Task PatchUser(string id, Delta <UserEditRequest> patch) { try { //Admins can also modify user. ValidationUtilities.ValidateEditUserRequest(id, patch.GetEntity(), patch.GetChangedPropertyNames().ToList()); string requesterEmail = HttpUtilities.GetUserNameFromToken(this.Request); var user = context.Users.FirstOrDefault(i => i.Email == requesterEmail); if (string.IsNullOrEmpty(requesterEmail) || user == null) { var response = HttpUtilities.FrameHTTPResp(System.Net.HttpStatusCode.BadRequest, Common.Utilities.ErrorCodes.INVALID_TOKEN, string.Empty); throw new HttpResponseException(response); } Delta <User> deltaDest = new Delta <User>(); foreach (var item in patch.GetChangedPropertyNames()) { object result; patch.TryGetPropertyValue(item, out result); deltaDest.TrySetPropertyValue(item, result); } deltaDest.TrySetPropertyValue("ModifiedBy", requesterEmail); deltaDest.TrySetPropertyValue("UpdatedAt", DateTimeOffset.UtcNow); return(UpdateAsync(id, deltaDest)); } catch (HttpResponseException ex) { throw ex; } catch (Exception ex) { HttpUtilities.ServerError(ex, Request); return(null); } }
/// <summary> /// Verifies whether an LRO PUT operation returns response models for /// 200/201 status codes /// </summary> /// <param name="definitions"></param> /// <param name="context"></param> /// <returns></returns> public override IEnumerable <ValidationMessage> GetValidationMessages(Dictionary <string, Dictionary <string, Operation> > paths, RuleContext context) { var serviceDefinition = (ServiceDefinition)context.Root; foreach (var path in paths) { var lroPutOps = path.Value.Where(val => val.Key.ToLower().Equals("put")).Select(val => val.Value); foreach (var op in lroPutOps) { if (op.Responses == null) { // if put operation has no response model, let some other validation rule handle the violation continue; } foreach (var resp in op.Responses) { if (resp.Key == "200" || resp.Key == "201") { var modelRef = resp.Value?.Schema?.Reference ?? string.Empty; if (!serviceDefinition.Definitions.ContainsKey(modelRef.StripDefinitionPath())) { var violatingVerb = ValidationUtilities.GetOperationIdVerb(op.OperationId, path); yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty(path.Key).AppendProperty(violatingVerb).AppendProperty("responses").AppendProperty(resp.Key)), this, op.OperationId, resp.Key)); } } } } } }
/// <summary> /// Verifies whether the location property for a tracked resource has the x-ms-mutability extension set correctly /// </summary> /// <param name="definitions"></param> /// <param name="context"></param> /// <returns></returns> public override IEnumerable <ValidationMessage> GetValidationMessages(Dictionary <string, Schema> definitions, RuleContext context) { var trackedResources = context.TrackedResourceModels; foreach (var resource in trackedResources) { var modelHierarchy = ValidationUtilities.EnumerateModelHierarchy(resource, definitions); var modelsWithLocationProp = modelHierarchy.Where(model => (definitions[model].Required?.Contains("location") == true) && (definitions[model].Properties?.ContainsKey("location") == true)); if (modelsWithLocationProp.Any()) { var modelWithLocationProp = modelsWithLocationProp.First(); if (definitions[modelWithLocationProp].Properties["location"].Extensions?.ContainsKey("x-ms-mutability") != true) { yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty("properties").AppendProperty("location")), this, modelWithLocationProp)); } else { var jObject = JsonConvert.DeserializeObject <object[]>(definitions[modelWithLocationProp].Properties["location"].Extensions["x-ms-mutability"].ToString()); // make sure jObject and the expected mutability properties have exact same elements if (jObject.Except(LocationPropertyMutability).Any() || LocationPropertyMutability.Except(jObject).Any()) { yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty("properties").AppendProperty("location").AppendProperty("x-ms-mutability")), this, resource)); } } } } }
public async Task <string> Validate(RoleGetOptions options) { try { _logger.LogInformation("Start role validating."); string result = ValidationUtilities.ValidateRoleName(options.Name); if (!string.IsNullOrEmpty(result)) { return(result); } if (!options.Id.HasValue) { var models = await _dao.Get(options); if (models.Count() > 0) { string message = "Role with same user name have been already created. Please try another."; _logger.LogInformation(message); return(message); } } _logger.LogInformation("Role successfuly validated."); return(null); } catch (Exception exception) { _logger.LogError(exception.Message); throw exception; } }
/// <summary> /// This rule passes if the paths contain reference to exactly one of the namespace resources /// </summary> /// <param name="paths"></param> /// <returns></returns> public override bool IsValid(Dictionary <string, Dictionary <string, Operation> > paths, RuleContext context, out object[] formatParameters) { IEnumerable <string> resourceProviders = ValidationUtilities.GetResourceProviders(paths); formatParameters = new [] { string.Join(", ", resourceProviders) }; return(resourceProviders.ToList().Count <= 1); }
// Verifies if a tracked resource has a corresponding PATCH operation public override IEnumerable <ValidationMessage> GetValidationMessages(Dictionary <string, Schema> definitions, RuleContext context) { ServiceDefinition serviceDefinition = (ServiceDefinition)context.Root; // enumerate all the PATCH operations IEnumerable <Operation> patchOperations = ValidationUtilities.GetOperationsByRequestMethod("patch", serviceDefinition); foreach (var op in patchOperations) { var reqModels = op.Parameters.Where(p => p.In == ParameterLocation.Body).Select(p => p.Schema?.Reference?.StripDefinitionPath()).Where(p => !string.IsNullOrEmpty(p)); foreach (var reqModel in reqModels) { // select all models that have properties set to required var reqProps = ValidationUtilities.EnumerateRequiredProperties(reqModel, definitions); // select all models that have properties with default values var defValProps = ValidationUtilities.EnumerateDefaultValuedProperties(reqModel, definitions); var modelHierarchy = ValidationUtilities.EnumerateModelHierarchy(reqModel, definitions); foreach (var reqProp in reqProps) { var modelContainingReqProp = modelHierarchy.First(model => definitions[model].Required?.Contains(reqProp) == true); yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty(modelContainingReqProp).AppendProperty("required")), this, "required", op.OperationId, modelContainingReqProp, reqProp)); } foreach (var defValProp in defValProps) { var modelContainingDefValProp = modelHierarchy.First(model => definitions[model].Properties?.Contains(defValProp) == true); yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty(modelContainingDefValProp).AppendProperty("properties").AppendProperty(defValProp.Key)), this, "default-valued", op.OperationId, modelContainingDefValProp, defValProp.Key)); } } } }
// Token: 0x06000CA3 RID: 3235 RVA: 0x0005572C File Offset: 0x0005392C private void DrawCheckAvailabilityButton(Rect position) { GUI.enabled = (!string.IsNullOrEmpty(this._characterName) && !this._checkButtonClicked && !this._waitingForWsReturn); if (GUITools.Button(new Rect(225f, 60f, 110f, 24f), new GUIContent("Check Availability"), BlueStonez.buttondark_small)) { this.HideKeyboard(); this._availableNames.Clear(); this._checkButtonClicked = true; this._targetHeight = 260f; if (!ValidationUtilities.IsValidMemberName(this._characterName, ApplicationDataManager.CurrentLocale.ToString())) { this._feedbackMessageColor = Color.red; this._errorMessage = "'" + this._characterName + "' is not a valid name!"; } else { this._waitingForWsReturn = true; UserWebServiceClient.IsDuplicateMemberName(this._characterName, new Action <bool>(this.IsDuplicatedNameCallback), delegate(Exception ex) { this._waitingForWsReturn = false; this._feedbackMessageColor = Color.red; this._errorMessage = "Our server had an error, please try again."; }); } } GUI.enabled = true; }
private static bool ValidateValue(object value, ValidationContext validationContext, List <ValidationResult> validationResults, IEnumerable <ValidationAttribute> validationAttributes, string memberPath) { if (validationResults == null) { Validator.ValidateValue(value, validationContext, validationAttributes); } else { // todo, needs to be array aware List <ValidationResult> currentResults = new List <ValidationResult>(); if (!Validator.TryValidateValue(value, validationContext, currentResults, validationAttributes)) { // transform the validation results by applying the member path to the results if (!string.IsNullOrEmpty(memberPath)) { currentResults = ValidationUtilities.ApplyMemberPath(currentResults, memberPath).ToList(); } validationResults.AddRange(currentResults); return(false); } } return(true); }
/// <summary> /// This method recursively applies the specified validation errors to this instance /// and any nested instances (based on member paths specified in the validation results). /// Since this method correctly handles complex types, this method should be used rather /// than directly applying results to the collection. /// </summary> /// <param name="instance">The target entity or complex type to apply the errors to.</param> /// <param name="validationResults">The validation results to apply.</param> internal static void ApplyValidationErrors(object instance, IEnumerable <ValidationResult> validationResults) { // first apply the errors to this instance Entity entityInstance = instance as Entity; if (entityInstance != null) { entityInstance.ValidationResultCollection.ReplaceErrors(validationResults); } else { ((ComplexObject)instance).ValidationResultCollection.ReplaceErrors(validationResults); } // next enumerate all complex members and apply nested validation results MetaType metaType = MetaType.GetMetaType(instance.GetType()); foreach (MetaMember complexMember in metaType.DataMembers.Where(p => p.IsComplex && !p.IsCollection)) { // filter the results to only those with a member name that begins with a dotted path // starting at the current complex member IEnumerable <ValidationResult> results = validationResults.Where(p => p.MemberNames.Any(q => !string.IsNullOrEmpty(q) && q.StartsWith(complexMember.Member.Name + ".", StringComparison.Ordinal))); ComplexObject complexObject = (ComplexObject)complexMember.GetValue(instance); if (complexObject != null) { results = ValidationUtilities.RemoveMemberPrefix(results, complexMember.Member.Name); ApplyValidationErrors(complexObject, results); } } }
public override IEnumerable <ValidationMessage> GetValidationMessages(Dictionary <string, Dictionary <string, Operation> > entity, RuleContext context) { // get all operation objects that are either of get or post type ServiceDefinition serviceDefinition = context.Root; var listOperations = entity.Values.SelectMany(opDict => opDict.Where(pair => pair.Key.ToLower().Equals("get") || pair.Key.ToLower().Equals("post"))); foreach (var opPair in listOperations) { // if the operation id is not of type _list* or does not return an array type, skip if (!ListRegex.IsMatch(opPair.Value.OperationId) || !ValidationUtilities.IsXmsPageableResponseOperation(opPair.Value)) { continue; } string collType = opPair.Value.Responses.GetValueOrNull("200")?.Schema?.Reference?.StripDefinitionPath(); // if no response type defined skip if (collType == null) { continue; } var collTypeDef = serviceDefinition.Definitions[collType]; // if collection object has 2 properties or less (x-ms-pageable objects can have the nextlink prop) // and the object does not have a property named "value", show the warning if ((collTypeDef.Properties?.Count <= 2) && collTypeDef.Properties.All(prop => !(prop.Key.ToLower().Equals("value") && prop.Value.Type == DataType.Array))) { var violatingPath = ValidationUtilities.GetOperationIdPath(opPair.Value.OperationId, entity); yield return(new ValidationMessage(new FileObjectPath(context.File, context.Path.AppendProperty(violatingPath.Key).AppendProperty(opPair.Key).AppendProperty("responses").AppendProperty("200").AppendProperty("schema")), this, collType, opPair.Value.OperationId)); } } }
/// <summary> /// Reads concatenated data from the underlying sequence of source readers. /// </summary> /// /// <param name="buffer">The array in which to store data.</param> /// <param name="index">The index in <paramref name="buffer"/> of the first byte to /// store.</param> /// <param name="count">The maximum number of bytes to store.</param> /// /// <returns>The actual number of bytes read, which may be less than the amount requested /// or zero if the end of the concatenated sources is reached.</returns> /// /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is /// <c>null</c>.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="index"/> or /// <paramref name="count"/> are negative or fall outside the array /// bounds.</exception> /// <exception cref="IOException">An I/O error occurred.</exception> /// <exception cref="ObjectDisposedException">This reader or one or more source readers /// have been disposed.</exception> public override int Read(char[] buffer, int index, int count) { if (_sources == null) { throw new ObjectDisposedException(GetType().Name); } ValidationUtilities.ValidateArraySlice(buffer, index, count, nameof(buffer), nameof(index), nameof(count)); int total = 0; while (count > 0) { if (_sources.Count == 0) { return(total); } int bytesRead = _sources.Peek().Read(buffer, index, count); if (bytesRead == 0) { _sources.Dequeue().Dispose(); } total += bytesRead; count -= bytesRead; index += bytesRead; } return(total); }
public string Validate(Cart model) { try { _logger.LogInformation("Start cart validating."); StringBuilder builder = new StringBuilder(); if (!ValidationUtilities.MoreThanValueRule(model.Count)) { builder.AppendLine("You can't add zero products to cart."); } string message = builder.ToString(); if (!string.IsNullOrEmpty(message)) { return(message); } _logger.LogInformation("Cart successfuly validated."); return(null); } catch (Exception exception) { _logger.LogError(exception.Message); throw exception; } }
public void Init() { TestId = Guid.NewGuid().ToString("N").Substring(0, 8); Console.WriteLine("Running test " + TestId + ". If failed AND log uploaded is enabled, log can be find in " + Path.Combine(DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture), TestId)); if (_enableRealtimeLogUpload) { TimerTask = new Task(() => { TestTimer = new Timer() { Interval = 1000, Enabled = true, AutoReset = true }; TestTimer.Elapsed += PeriodicUploadLog; TestTimer.Start(); }); TimerTask.Start(); } ValidationUtilities.ValidateEnvVariable("JAVA_HOME"); if (!Directory.Exists(BinFolder)) { throw new InvalidOperationException(BinFolder + " not found in current directory, cannot init test"); } }
/// <inheritdoc /> public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { var results = new List <ValidationResult>(); if (ForeignKey.ForeignColumns.Count > 0) { var ctxt = new ValidationContext(ForeignKey, validationContext.Items); ctxt.InitializeServiceProvider(validationContext.GetService); ValidationUtilities.TryCollectResults(ctxt, ForeignKey, results); } else { if (string.IsNullOrEmpty(ForeignKey.Name)) { results.Add(new ValidationResult(ErrorMessages.ForeignKeyNameCannotBeNullOrEmpty)); } if (string.IsNullOrEmpty(ForeignKey.ForeignTable)) { results.Add(new ValidationResult(ErrorMessages.ForeignTableNameCannotBeNullOrEmpty)); } } return(results); }
public async Task <string> Validate(DepartmentGetOptions options) { try { _logger.LogInformation("Start department validating."); string result = ValidationUtilities.ValidateDepartmentFullName(options.FullName); if (!string.IsNullOrEmpty(result)) { return(result); } var models = await _dao.Get(options); if (models.Count() > 0) { string message = "Department with same name have been already created. Please try another."; _logger.LogInformation(message); return(message); } _logger.LogInformation("Department successfuly validated."); return(null); } catch (Exception exception) { _logger.LogError(exception.Message); throw exception; } }
public async Task<string> ValidateUser(UserGetOptions options) { try { _logger.LogInformation("Start user name and email validating."); string result = ValidationUtilities.ValidateUserName(options.Username); if (!string.IsNullOrEmpty(result)) return result; result = ValidationUtilities.ValidateEmail(options.Email); if (!string.IsNullOrEmpty(result)) return result; var users = await _dao.Get(options); if (users.Where(o => o.Username != options.Username).Count() > 0) { string message = "User with same user name or email have been already created. Please try another or try to sign in."; _logger.LogInformation(message); return message; } _logger.LogInformation("User name and email successfuly validated."); return null; } catch (Exception exception) { _logger.LogError(exception.Message); throw exception; } }
// Token: 0x06000D02 RID: 3330 RVA: 0x00059AF8 File Offset: 0x00057CF8 private void Login(string emailAddress, string password) { CmunePrefs.WriteKey <bool>(CmunePrefs.Key.Player_AutoLogin, this._rememberPassword); if (this._rememberPassword) { CmunePrefs.WriteKey <string>(CmunePrefs.Key.Player_Password, password); CmunePrefs.WriteKey <string>(CmunePrefs.Key.Player_Email, emailAddress); } this._errorAlpha = 1f; if (string.IsNullOrEmpty(emailAddress)) { LoginPanelGUI.ErrorMessage = LocalizedStrings.EnterYourEmailAddress; } else if (string.IsNullOrEmpty(password)) { LoginPanelGUI.ErrorMessage = LocalizedStrings.EnterYourPassword; } else if (!ValidationUtilities.IsValidEmailAddress(emailAddress)) { LoginPanelGUI.ErrorMessage = LocalizedStrings.EmailAddressIsInvalid; } else if (!ValidationUtilities.IsValidPassword(password)) { LoginPanelGUI.ErrorMessage = LocalizedStrings.PasswordIsInvalid; } else { this.Hide(); UnityRuntime.StartRoutine(Singleton <AuthenticationManager> .Instance.StartLoginMemberEmail(emailAddress, password)); } }
/// <summary> /// Populates list of resources, tracked resources and proxy resources /// </summary> private void PopulateResourceTypes(ServiceDefinition serviceDefinition) { this.ResourceModels = ValidationUtilities.GetResourceModels(serviceDefinition).ToList(); this.TrackedResourceModels = ValidationUtilities.GetTrackedResources(this.ResourceModels, serviceDefinition.Definitions).ToList(); this.ChildTrackedResourceModels = ValidationUtilities.GetChildTrackedResourcesWithImmediateParent(serviceDefinition).ToList(); this.ParentTrackedResourceModels = ValidationUtilities.GetParentTrackedResources(this.TrackedResourceModels, this.ChildTrackedResourceModels).ToList(); this.ProxyResourceModels = this.ResourceModels.Except(this.TrackedResourceModels).ToList(); }
// Token: 0x06001226 RID: 4646 RVA: 0x0006AF48 File Offset: 0x00069148 public static bool ValidateMemberName(string name, LocaleType locale = LocaleType.en_US) { if (locale != LocaleType.ko_KR) { return(ValidationUtilities.IsValidMemberName(name)); } return(ValidationUtilities.IsValidMemberName(name, "ko-KR")); }
public string this[string columnName] { get { switch (columnName) { case nameof(Name): if (string.IsNullOrWhiteSpace(Name)) { return("Required"); } if (ValidationUtilities.ValidateName(Name) != null) { return("Must be a valid identifier"); } if (Name.StartsWith(" ")) { return("Can't start with a space"); } if (Name.EndsWith(" ")) { return("Can't end with a space"); } if (_existingNames != null && _existingNames.Any(s => string.Equals(s, Name, StringComparison.OrdinalIgnoreCase))) { return("Duplicated name"); } return(null); case nameof(SelectedFieldType): if (SelectedFieldType == null) { return("Required"); } return(null); case nameof(Prompt): if (string.IsNullOrWhiteSpace(Prompt)) { return("Required"); } if (ValidationUtilities.ValidateFieldPrompt(Prompt) != null) { return("Cannot end in a colon or space"); } return(null); } return(null); } }
/// <summary> /// Initializes a new data stream using the specified data. /// </summary> /// /// <param name="data">The array to wrap.</param> /// <param name="offset">The index of the first byte to wrap.</param> /// <param name="count">The number of bytes to wrap.</param> /// /// <exception cref="ArgumentNullException"><paramref name="data"/> is /// <c>null</c>.</exception> /// <exception cref="ArgumentOutOfRangeException"><paramref name="offset"/> and/or /// <paramref name="count"/> fall outside the bounds of the array.</exception> public ProtocolReader(byte[] data, int offset, int count) { ValidationUtilities.ValidateArraySlice(data, offset, count, nameof(data), nameof(offset), nameof(count)); _buffer = data; _position = _originalPosition = offset; _endPosition = offset + count; }
/// <summary> /// Validation fails iof tracked resource fails to meet one of the four required criteria. /// </summary> /// <param name="definitions">Operation Definition to validate</param> /// <param name="formatParameters">The noun to be put in the failure message</param> /// <returns></returns> public override bool IsValid(Dictionary <string, Schema> definitions, RuleContext context, out object[] formatParameters) { IEnumerable <Operation> getOperations = ValidationUtilities.GetOperationsByRequestMethod("get", (ServiceDefinition)context.Root); foreach (KeyValuePair <string, Schema> definition in definitions) { if (!exemptedNames.IsMatch(definition.Key) && ValidationUtilities.IsTrackedResource(definition.Value, definitions)) { bool getCheck = getOperations.Any(operation => operation.Responses.Any(response => response.Key.Equals("200") && response.Value.Schema != null && response.Value.Schema.Reference != null && response.Value.Schema.Reference.EndsWith("/" + definition.Key) ) ); if (!getCheck) { formatParameters = new object[2]; formatParameters[0] = definition.Key; formatParameters[1] = 1; return(false); } bool listByResourceGroupCheck = this.ListByXCheck(getOperations, listByRgRegEx, definition.Key, definitions); if (!listByResourceGroupCheck) { formatParameters = new object[2]; formatParameters[0] = definition.Key; formatParameters[1] = 2; return(false); } bool listBySubscriptionIdCheck = this.ListByXCheck(getOperations, listBySidRegEx, definition.Key, definitions); if (!listBySubscriptionIdCheck) { formatParameters = new object[2]; formatParameters[0] = definition.Key; formatParameters[1] = 3; return(false); } bool schemaResult = this.HandleSchema(definition.Value, definitions); if (!schemaResult) { formatParameters = new object[2]; formatParameters[0] = definition.Key; formatParameters[1] = 4; return(false); } } } formatParameters = new object[0]; return(true); }