/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var sections = (ProcessSections)context.InputPropertyValues[ProcessEdit.SectionListProperty]; if (sections == null || sections.Count == 0) return; if ((bool)context.InputPropertyValues[ProcessEdit.IsSystemProperty]) return; var layoutList = (IProcessLayoutList)context.InputPropertyValues[PrimaryProperty]; var defaultLayout = layoutList.GetDefaultLayout(); if (defaultLayout == null) context.AddErrorResult(LanguageService.Translate("Rule_ProcessDefaultLayout")); foreach (var layout in layoutList) { if (string.IsNullOrEmpty(layout.Name)) context.AddErrorResult(PrimaryProperty, LanguageService.Translate("Rule_ProcessLayoutName")); if (string.IsNullOrEmpty(layout.LayoutInfo)) context.AddErrorResult(PrimaryProperty, LanguageService.Translate("Rule_ProcessSearchMustHaveAtLeastOneField")); } context.Complete(); }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var sections = (ProcessSections)context.InputPropertyValues[PrimaryProperty]; if (sections == null || sections.Count == 0) return; //ignore parent var localSections = sections.Where(s => !s.IsBase).ToList(); //duplicate section name check var duplicateSections = localSections.Where(x => localSections.Count(y => y.Name == x.Name) > 1); foreach (var section in duplicateSections) context.AddErrorResult(string.Format(LanguageService.Translate("Rule_UniqueSectionName"), section.Name)); //duplicate field's system name check var fields = new Dictionary<string, string>(); foreach (var section in sections.Where(s => s.FieldList != null)) foreach (var field in section.FieldList.Where(f => !string.IsNullOrEmpty(f.SystemName))) if (fields.Keys.Any(key => key.ToUpperInvariant().Equals(field.SystemName.ToUpperInvariant()))) { var duplicate = fields.First(f => f.Key.Equals(field.SystemName, StringComparison.OrdinalIgnoreCase)); context.AddErrorResult(string.Format(LanguageService.Translate("Rule_UniqueFieldSystemNames"), field.SystemName, section.Name, duplicate.Value)); } else fields.Add(field.SystemName, section.Name); }
protected override void Execute(RuleContext context) { var customerId = (int)ReadProperty(context.Target, RuleBaseClassesRoot.CustomerIdProperty); switch (customerId) { case 4: context.AddErrorResult(RuleBaseClassesRoot.NameProperty, "customer name required"); context.AddErrorResult(RuleBaseClassesRoot.CountryProperty, "country required"); context.AddErrorResult(RuleBaseClassesRoot.StateProperty, "state required"); break; case 5: context.AddWarningResult(RuleBaseClassesRoot.NameProperty, "customer name required"); context.AddWarningResult(RuleBaseClassesRoot.CountryProperty, "country required"); context.AddWarningResult(RuleBaseClassesRoot.StateProperty, "state required"); break; case 6: context.AddInformationResult(RuleBaseClassesRoot.NameProperty, "customer name required"); context.AddInformationResult(RuleBaseClassesRoot.CountryProperty, "country required"); context.AddInformationResult(RuleBaseClassesRoot.StateProperty, "state required"); break; } }
/// <summary> /// Rule implementation. /// </summary> /// <param name="context">Rule context.</param> protected override void Execute(RuleContext context) { var ctx = new System.ComponentModel.DataAnnotations.ValidationContext(context.Target, null, null); if (PrimaryProperty != null) { ctx.MemberName = PrimaryProperty.FriendlyName; } System.ComponentModel.DataAnnotations.ValidationResult result = null; try { if (PrimaryProperty != null) { object value = context.InputPropertyValues[PrimaryProperty]; result = this.Attribute.GetValidationResult(value, ctx); } else { result = this.Attribute.GetValidationResult(null, ctx); } } catch (Exception ex) { context.AddErrorResult(ex.Message); } if (result != null) { context.AddErrorResult(result.ErrorMessage); } }
protected override void Execute(RuleContext context) { if (context == null) { throw new ArgumentException("Context cannot be null"); } var imageArray = (byte[])context.InputPropertyValues[this.ImageProptery]; if (imageArray != null && imageArray.Length > 0) { try { using (var ms = new MemoryStream(imageArray)) { var image = System.Drawing.Image.FromStream(ms); if (image.Height != ImageConstants.AllowedHeight || image.Width != ImageConstants.AllowedWidth) { context.AddErrorResult(string.Format(CultureInfo.CurrentCulture, "The supplied image must have a height of {0} px and a width of {1} px.", ImageConstants.AllowedHeight, ImageConstants.AllowedWidth)); } } } catch (ArgumentException) { context.AddErrorResult("Image must be set with a valid image type."); } } }
/// <summary> /// Executes the rule. /// </summary> /// <param name="context">The rule context.</param> protected override void Execute(RuleContext context) { try { var process = (ProcessEdit)context.Target; var allFields = GetProcessFields(process); foreach (var field in process.GetAllFields()) { var crossRefStep = field.StepList.OfType<CrossRefOptionsStepEdit>().FirstOrDefault(); if (crossRefStep != null) { if (!IsFilterValid(crossRefStep.FilterDefinition, allFields)) context.AddErrorResult( string.Format(LanguageService.Translate("Rule_FilterReferencesInvalidFields"), field.Name ?? string.Empty)); continue; } var checklistStep = field.StepList.OfType<ChecklistSettingsStepEdit>().FirstOrDefault(); if (checklistStep != null) { if (!IsFilterValid(checklistStep.FilterDefinition, allFields)) context.AddErrorResult( string.Format(LanguageService.Translate("Rule_FilterReferencesInvalidFields"), field.Name ?? string.Empty)); } } } catch (Exception ex) { context.AddErrorResult(PrimaryProperty, ex.Message); } }
protected override void Execute(RuleContext context) { DateTime startTime = (DateTime) context.InputPropertyValues[startPropertyInfo]; DateTime endTime = (DateTime)context.InputPropertyValues[endPropertyInfo]; if (DateTime.Compare(startTime, endTime) >= 0) { context.AddErrorResult(ValidationMessages.InvalidTimeRange); } else if ((endTime - startTime).Hours <= 0) { context.AddErrorResult(ValidationMessages.MinHourInvalid); } else { var chainedContext1 = context.GetChainedContext(InnerTopOfHourStartRule); InnerTopOfHourStartRule.Execute(chainedContext1); var chainedContext2 = context.GetChainedContext(InnerTopOfHourEndRule); InnerTopOfHourEndRule.Execute(chainedContext2); } }
protected override void Execute(RuleContext context) { if (Csla.ApplicationContext.LogicalExecutionLocation == Csla.ApplicationContext.LogicalExecutionLocations.Client) { BackgroundWorker worker = new BackgroundWorker(); worker.DoWork += (s, e) => { System.Threading.Thread.Sleep(2000); var value = context.InputPropertyValues[PrimaryProperty]; if (value == null || value.ToString().ToUpper() == "ERROR") { context.AddErrorResult("error detected"); } }; worker.RunWorkerCompleted += (s, e) => context.Complete(); // simulating an asynchronous process. worker.RunWorkerAsync(); } else { var value = context.InputPropertyValues[PrimaryProperty]; if (value == null || value.ToString().ToUpper() == "ERROR") { context.AddErrorResult("error detected"); } context.Complete(); } }
protected override void Execute(RuleContext context) #endif { int role = (int)context.InputPropertyValues[PrimaryProperty]; #if __ANDROID__ var roles = await RoleList.GetListAsync(); if (!(await RoleList.GetListAsync()).ContainsKey(role)) { context.AddErrorResult("Role must be in RoleList"); } context.Complete(); #elif SILVERLIGHT RoleList.GetList((o, e) => { if (!e.Object.ContainsKey(role)) { context.AddErrorResult("Role must be in RoleList"); } context.Complete(); }); #else if (!RoleList.GetList().ContainsKey(role)) { context.AddErrorResult("Role must be in RoleList"); } #endif }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var process = context.Target as ProcessEdit; if (process == null) return; var commands = (ProcessCommandEditList)context.InputPropertyValues[PrimaryProperty]; var states = process.StateList; if (commands == null) return; if (states != null) foreach (var command in commands) { if (command.SecurityConfigurationList == null || command.SecurityConfigurationList.Count <= 0) continue; var configurationList = command.SecurityConfigurationList.Where(c => c.StateGuid != Constants.AllStatesGuid); var depricatedConfigurationList = configurationList.Where(c => states.Count(s => s.Guid == c.StateGuid) == 0); foreach (var depricatedItem in depricatedConfigurationList) context.AddErrorResult(PrimaryProperty, string.Format(LanguageService.Translate("Rule_CommandSecurityConfigurationsState"), command.CommandName, depricatedItem)); } else foreach (var command in commands) { if (command.SecurityConfigurationList == null || command.SecurityConfigurationList.Count <= 0) continue; foreach (var depricatedItem in command.SecurityConfigurationList) context.AddErrorResult(PrimaryProperty, string.Format(LanguageService.Translate("Rule_CommandSecurityConfigurationsState"), command.CommandName, depricatedItem)); } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { if (context == null) return; var selectedFrequency = (int?)context.InputPropertyValues[PrimaryProperty]; var frequencyTypeString = (string)context.InputPropertyValues[_frequencyTypeProperty]; var frequencyName = (string)context.InputPropertyValues[_frequencyName]; FrequencyEventEnum frequencyType; if (string.IsNullOrEmpty(frequencyTypeString)) frequencyTypeString = FrequencyEventEnum.Time.ToString(); if (!Enum.TryParse(frequencyTypeString, true, out frequencyType)) return; if (frequencyType == FrequencyEventEnum.Event) { if (!selectedFrequency.HasValue || selectedFrequency.Value == 0) { context.AddErrorResult(PrimaryProperty, string.Format(CultureInfo.InvariantCulture, "Frequency event for field \"{0}\" is required.", _frequencyFieldName)); } if (string.IsNullOrEmpty(frequencyName)) { context.AddErrorResult(PrimaryProperty, string.Format(CultureInfo.InvariantCulture, "Frequency event for field \"{0}\" is required.", _frequencyFieldName)); } } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var uri = context.InputPropertyValues[PrimaryProperty] as string; System.Diagnostics.Debug.WriteLine(uri); if (!string.IsNullOrWhiteSpace(uri) && !SystemPath.IsRelative(uri) && !Uri.IsWellFormedUriString(uri, UriKind.Absolute)) context.AddErrorResult(PrimaryProperty, "Invalid URI"); else if (SystemPath.IsRelative(uri) && !Uri.IsWellFormedUriString(uri, UriKind.Relative)) context.AddErrorResult(PrimaryProperty, "Invalid URI"); }
/// <summary> /// Does the check for primary propert less than compareTo property /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var value1 = (IComparable)context.InputPropertyValues[PrimaryProperty]; var value2 = (IComparable)context.InputPropertyValues[CompareTo]; if (value1.CompareTo(value2) >= 0) { context.AddErrorResult(string.Format("{0} must be less than {1}", PrimaryProperty.FriendlyName, CompareTo.FriendlyName)); context.AddErrorResult(CompareTo, string.Format("{0} must be larger than {1}", CompareTo.FriendlyName, PrimaryProperty.FriendlyName)); } }
protected override void Execute(RuleContext context) #endif { int role = (int)context.InputPropertyValues[PrimaryProperty]; #if __ANDROID__ var roles = await RoleList.GetListAsync(); if (!(await RoleList.GetListAsync()).ContainsKey(role)) context.AddErrorResult("Role must be in RoleList"); context.Complete(); #else if (!RoleList.GetList().ContainsKey(role)) context.AddErrorResult("Role must be in RoleList"); #endif }
protected override void Execute(RuleContext context) { var obj = context.Target.GetType().GetProperty(PrimaryProperty.Name).GetValue(context.Target); var msj = String.Format("Agregue al menos un elemento en {0}.", PrimaryProperty.FriendlyName); var list = obj as IList; if (list == null) { context.AddErrorResult(msj); return; } if (!(list.Count > 0)) { context.AddErrorResult(msj); } }
protected override void Execute(RuleContext context) { var activityIdValue = (int)context.InputPropertyValues[PrimaryProperty]; var activityStatusProperty = this.InputProperties.Single(p => p.Name == this.StatusName); var activtyStatusValue = (ActivitySubmissionStatus)context.InputPropertyValues[activityStatusProperty]; var approvedByIdProperty = this.InputProperties.Single(p => p.Name == this.ApprovedByIdName); var approvedByIdValue = (ActivitySubmissionStatus)context.InputPropertyValues[approvedByIdProperty]; if (approvedByIdValue == 0 && (activtyStatusValue == ActivitySubmissionStatus.Unset || activtyStatusValue == ActivitySubmissionStatus.AwaitingApproval || activtyStatusValue == ActivitySubmissionStatus.Approved)) { try { var activityTask = Task.Run(() => IoC.Container.Resolve <IObjectFactory <IActivityEdit> >().FetchAsync(activityIdValue)); var activity = activityTask.Result; context.AddOutValue(activityStatusProperty, activity.RequiresApproval ? ActivitySubmissionStatus.AwaitingApproval : ActivitySubmissionStatus.Approved); } catch (Exception) { context.AddErrorResult(PrimaryProperty, string.Format(CultureInfo.CurrentCulture, "Activity id {0} was not able to be retrieved.", activityIdValue)); } } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var commands = (ProcessCommandEditList)context.InputPropertyValues[PrimaryProperty]; if (commands == null) return; foreach (var command in commands) { var foundConfigurations = new HashSet<ProcessCommandSecurityConfigurationEdit>(); var command1 = command; foreach (var configuration in command.SecurityConfigurationList.Where(configuration => !foundConfigurations.Any(f => f.RoleId == configuration.RoleId && f.StateGuid == configuration.StateGuid && f.BusinessUnitId == configuration.BusinessUnitId && f.PersonFieldSystemName == configuration.PersonFieldSystemName) && command1.SecurityConfigurationList.Any(x => !x.Equals(configuration) && x.RoleId == configuration.RoleId && x.StateGuid == configuration.StateGuid && x.BusinessUnitId == configuration.BusinessUnitId && x.PersonFieldSystemName == configuration.PersonFieldSystemName)) ) { foundConfigurations.Add(configuration); context.AddErrorResult(PrimaryProperty, string.Format(LanguageService.Translate("Rule_UniqueSecurityConfiguration"), command.CommandName)); } } }
protected override void Execute(RuleContext context) { var activityIdValue = (int)context.InputPropertyValues[PrimaryProperty]; var activityStatusProperty = this.InputProperties.Single(p => p.Name == this.StatusName); var activtyStatusValue = (ActivitySubmissionStatus)context.InputPropertyValues[activityStatusProperty]; var approvedByIdProperty = this.InputProperties.Single(p => p.Name == this.ApprovedByIdName); var approvedByIdValue = (ActivitySubmissionStatus)context.InputPropertyValues[approvedByIdProperty]; if (approvedByIdValue == 0 && (activtyStatusValue == ActivitySubmissionStatus.Unset || activtyStatusValue == ActivitySubmissionStatus.AwaitingApproval || activtyStatusValue == ActivitySubmissionStatus.Approved)) { try { var activityTask = Task.Run(() => IoC.Container.Resolve<IObjectFactory<IActivityEdit>>().FetchAsync(activityIdValue)); var activity = activityTask.Result; context.AddOutValue(activityStatusProperty, activity.RequiresApproval ? ActivitySubmissionStatus.AwaitingApproval : ActivitySubmissionStatus.Approved); } catch (Exception) { context.AddErrorResult(PrimaryProperty, string.Format(CultureInfo.CurrentCulture, "Activity id {0} was not able to be retrieved.", activityIdValue)); } } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { if (context == null) return; var value = context.InputPropertyValues[InputProperties[0]]; if (value == null) { return; } var s = value as string; if (s != null && string.IsNullOrEmpty(s)) return; if (value is int) { return; } if (value is decimal) { if ((decimal)value < int.MaxValue && (decimal)value > int.MinValue) return; } context.AddErrorResult("Value must be between -2 147 483 648 and +2 147 483 647"); }
protected override void Execute(RuleContext context) { if (((IAppointmentRequest)context.Target).TimeEntries == null || ((IAppointmentRequest)context.Target).TimeEntries.Count < 1) { context.AddErrorResult(ValidationMessages.NoTimeEntries); } }
protected override void Execute(RuleContext context) { #if SILVERLIGHT int role = (int)context.InputPropertyValues[PrimaryProperty]; RoleList.GetList((o, e) => { if (!e.Object.ContainsKey(role)) context.AddErrorResult("Role must be in RoleList"); context.Complete(); }); #else int role = (int)context.InputPropertyValues[PrimaryProperty]; if (!RoleList.GetList().ContainsKey(role)) context.AddErrorResult("Role must be in RoleList"); #endif }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { if (string.IsNullOrWhiteSpace((string)context.InputPropertyValues[PrimaryProperty]) && (((SummaryTypes)context.InputPropertyValues[InputProperties[2]]) != SummaryTypes.Count)) { context.AddErrorResult(ProcessMetricEdit.MetricFieldSystemNameRuleHighlightProperty, LanguageService.Translate("Rule_MetricFieldIsRequired")); } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { if ((int)context.InputPropertyValues[ProcessScheduleEdit.ScheduleFrequencyPatternIdProperty] == 0) { context.AddErrorResult(PrimaryProperty, LanguageService.Translate("Rule_ScheduleFrequencyPattern")); } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var isSimpleProcess = (bool)context.InputPropertyValues[PrimaryProperty]; if (!isSimpleProcess) return; var sectionsProperty = InputProperties.First(x => x.Name.Equals(ProcessEdit.SectionListProperty.Name)); var sections = (ProcessSections)context.InputPropertyValues[sectionsProperty]; if (sections == null || sections.Count == 0) return; var invalidFieldTypes = string.Format("{0},{1},{2},{3},{4},{5},{6},{7}", ColumnTypes.Approval, ColumnTypes.Checklist, ColumnTypes.DisplayList, ColumnTypes.Result, ColumnTypes.Sample, ColumnTypes.SampleType, ColumnTypes.SamplingTechnique, ColumnTypes.SPCChart); foreach (var section in sections.Where(s => s.FieldList != null)) foreach (var field in section.FieldList.Where(f => !string.IsNullOrEmpty(f.SystemName)).Where(field => field.FieldType != null && invalidFieldTypes.Contains(field.FieldType.DataType))) context.AddErrorResult(string.Format(LanguageService.Translate("Rule_SympleProcessFields"), field.Name, section.Name)); }
/// <summary> /// Executes the rule in specified context. /// </summary> /// <param name="context">The context.</param> protected override void Execute(RuleContext context) { foreach (var field in context.InputPropertyValues) { // smartfields have their own implementation of IsEmpty var smartField = field.Value as ISmartField; if (smartField != null) { if (!smartField.IsEmpty) { return; } } else if (field.Value != null && !field.Value.Equals(field.Key.DefaultValue)) { return; } } var fields = context.InputPropertyValues.Select(p => p.Key.FriendlyName).ToArray(); var fieldNames = String.Join(", ", fields); context.AddErrorResult(string.Format(GetMessage(), fieldNames)); }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { if (string.IsNullOrEmpty((string)context.InputPropertyValues[ProcessScheduleEdit.ScheduleDisplayDateFieldProperty])) { context.AddErrorResult(PrimaryProperty, LanguageService.Translate("Rule_ScheduleDate")); } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { if ((Guid)context.InputPropertyValues[ProcessScheduleEdit.ScheduleStartStateGuidProperty] == Guid.Empty) { context.AddErrorResult(PrimaryProperty, LanguageService.Translate("Rule_ScheduleState")); } }
/// <summary> /// Business rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { object value = context.InputPropertyValues[PrimaryProperty]; if (Convert.ToDateTime(value) > DateTime.Now) { var message = string.Format(GetMessage(), PrimaryProperty.FriendlyName); context.Results.Add(new RuleResult(RuleName, PrimaryProperty, message) { Severity = Severity }); return; } try { if (Convert.ToDateTime(value) >= DateTime.MinValue) { return; } } catch (Exception ex) { context.AddErrorResult(string.Format("{0}{1} isn't valid.", ex.Message + Environment.NewLine, PrimaryProperty.FriendlyName)); } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { foreach (var item in context.InputPropertyValues.Where(x => (int)x.Value < 10)) { context.AddErrorResult(item.Key, LanguageService.Translate("Rule_PictureSize")); } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var allowRichText = (bool)context.InputPropertyValues[PrimaryProperty]; var mask = (string)context.InputPropertyValues[TextOptionsStepEdit.MaskProperty]; var maskType = (string)context.InputPropertyValues[TextOptionsStepEdit.MaskTypeProperty]; if (allowRichText && !string.IsNullOrEmpty(mask)) { context.AddErrorResult(InputProperties.First(x => x.Name == TextOptionsStepEdit.MaskRuleHighlightProperty.Name), LanguageService.Translate("Rule_OnlyMaskOrRichText1")); return; } if (allowRichText && maskType != "None") { context.AddErrorResult(InputProperties.First(x => x.Name == TextOptionsStepEdit.MaskTypeRuleHighlightProperty.Name), LanguageService.Translate("Rule_OnlyMaskOrRichText2")); } }
protected override void Execute(RuleContext context) { var target = (IAttachment)context.Target; if (target.SourceType == SourceType.None) { context.AddErrorResult("SourceType is required."); } }
protected override void Execute(RuleContext context) { var primero = (string)context.InputPropertyValues[PrimaryProperty]; var segundo = (string)context.InputPropertyValues[SecondaryProperty]; if (primero != segundo) context.AddErrorResult("Las contraseñas no son iguales! Verifique por favor"); }
protected override async void Execute(RuleContext context) { int role = (int)context.InputPropertyValues[PrimaryProperty]; var roles = await RoleList.CacheListAsync(); if (!roles.ContainsKey(role)) context.AddErrorResult("Role must be in RoleList"); context.Complete(); }
protected override void Execute(RuleContext context) { var target = (IUser)context.Target; if (target.Role == Role.None) { context.AddErrorResult("Role is required."); } }
protected override void Execute(RuleContext context) { var cust = (Customer)context.Target; if (cust.Zipcode == "12345") { context.AddErrorResult("private rule failed"); } }
protected override void Execute(RuleContext context) { Example target = (Example)context.Target; if (!string.IsNullOrEmpty(ReadProperty(target, Example.A).ToString()) && !String.IsNullOrEmpty(ReadProperty(target, Example.B).ToString())) { context.AddErrorResult("At least on property has to be null !"); } }
/// <summary> /// Business or validation rule implementation. /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { if (context == null) return; var value = context.InputPropertyValues[PrimaryProperty] as ICrossRefItemList; if (value == null || value.Count == 0) context.AddErrorResult(PrimaryProperty, string.Format(System.Globalization.CultureInfo.InvariantCulture, "'{0}' is required.", PrimaryProperty.FriendlyName)); }
protected override void Execute(RuleContext context) { var target = (EmployeeInformationEdit)context.Target; if (target.State == "NY" && target.Zip != "10108") { context.AddErrorResult(StringResources.ErrorsMessages.Errors.NYError); } }
protected override void Execute(RuleContext context) { var target = (ICategory)context.Target; var users = CategoryInfoList.FetchCategoryInfoList(new CategoryCriteria { Name = target.Name }); if (users.Count(row => row.CategoryId != target.CategoryId) != 0) { context.AddErrorResult("That category name is already in use."); } }
protected override void Execute(RuleContext context) { var args = new RuleContextArg(); if (!_delegateRule((T)context.Target, args)) { context.AddErrorResult(args.Description); } }
protected override void Execute(RuleContext context) { var target = (Foo)context.Target; if (target.Name == "2") { context.AddErrorResult("Name can not be 2"); } }
protected override void Execute(RuleContext context) { var target = (IUser)context.Target; var users = UserInfoList.FetchUserInfoList(new UserCriteria { Email = target.Email }); if (users.Count(row => row.UserId != target.UserId) != 0) { context.AddErrorResult("That email address is already in use."); } }
protected override void Execute(RuleContext context) { var target = (IStatus)context.Target; var users = StatusInfoList.FetchStatusInfoList(new StatusCriteria { Name = target.Name }); if (users.Count(row => row.StatusId != target.StatusId) != 0) { context.AddErrorResult("That status name is already in use."); } }
protected override void Execute(RuleContext context) { var target = (INote)context.Target; if (target.SourceType == SourceType.None) { context.AddErrorResult("SourceType is required."); } }
protected override void Execute(RuleContext context) { var primero = (string)context.InputPropertyValues[PrimaryProperty]; var segundo = (string)context.InputPropertyValues[SecondaryProperty]; if (primero != segundo) { context.AddErrorResult("Las contraseñas no son iguales! Verifique por favor"); } }
protected override void Execute(RuleContext context) { var pollOptionsProperty = this.InputProperties[0]; var pollOptions = context.InputPropertyValues[pollOptionsProperty] as BusinessList <IPollOption>; if (pollOptions == null || pollOptions.Count < 2) { context.AddErrorResult(pollOptionsProperty, "There must be at least two poll answers specified."); } }
protected override void Execute(RuleContext context) { var target = (Contact)context.Target; if (target.ContactType == BitzConstants.ContactTypes.Employee.Id && target.LastName.Length == 0) { context.AddErrorResult("Lastname required"); } }
/// <summary> /// Does the check for primary propert less than compareTo property /// </summary> /// <param name="context">Rule context object.</param> protected override void Execute(RuleContext context) { var value1 = (dynamic)context.InputPropertyValues[PrimaryProperty]; var value2 = (dynamic)context.InputPropertyValues[CompareTo]; if (value1 > value2) { context.AddErrorResult(string.Format("{0} must be less than or equal {1}", PrimaryProperty.FriendlyName, CompareTo.FriendlyName)); } }
protected override void Execute(RuleContext context) { var value1 = (IComparable)context.InputPropertyValues[this.PrimaryProperty]; var value2 = (IComparable)context.InputPropertyValues[this.CompareToProperty]; if (value1.CompareTo(value2) != 0) { context.AddErrorResult(string.Format("{0} must match {1}", this.PrimaryProperty.FriendlyName, this.CompareToProperty.FriendlyName)); } }
protected override void Execute(RuleContext context) { var primaryValue = context.InputPropertyValues[PrimaryProperty] + string.Empty; var dependentValue = context.InputPropertyValues[DependentProperty] + string.Empty; if (!string.IsNullOrWhiteSpace(dependentValue) && string.IsNullOrWhiteSpace(primaryValue)) { context.AddErrorResult(string.Format(MessageText, PrimaryProperty.FriendlyName, DependentProperty.FriendlyName)); } }
protected override void Execute(RuleContext context) { if (context.InputPropertyValues[PrimaryProperty] != null) { var val = (T)context.InputPropertyValues[PrimaryProperty]; if (!ListOfValues.Contains(val)) { context.AddErrorResult(string.Format("'{0}' is not in the list of expected values.", PrimaryProperty.FriendlyName)); } } }
protected override void Execute(RuleContext context) { #if SILVERLIGHT int role = (int)context.InputPropertyValues[PrimaryProperty]; RoleList.GetList((o, e) => { if (!e.Object.ContainsKey(role)) { context.AddErrorResult("Role must be in RoleList"); } context.Complete(); }); #else int role = (int)context.InputPropertyValues[PrimaryProperty]; if (!RoleList.GetList().ContainsKey(role)) { context.AddErrorResult("Role must be in RoleList"); } #endif }
protected override void Execute(RuleContext context) { var pollMaxAnswersProperty = this.InputProperties[0]; var pollOptionsProperty = this.InputProperties[1]; var pollMaxAnswers = context.InputPropertyValues[pollMaxAnswersProperty] as short?; var pollOptions = context.InputPropertyValues[pollOptionsProperty] as BusinessList <IPollOption>; if (pollMaxAnswers != null) { if (pollMaxAnswers <= 0) { context.AddErrorResult(pollMaxAnswersProperty, "The maximum answer count must be greater than zero."); } else if (pollOptions != null && pollMaxAnswers > pollOptions.Count) { context.AddErrorResult(pollMaxAnswersProperty, "The maximum answer count must be less than or equal to the poll option count."); } } }
protected override async void Execute(RuleContext context) { int role = (int)context.InputPropertyValues[PrimaryProperty]; var roles = await RoleList.CacheListAsync(); if (!roles.ContainsKey(role)) { context.AddErrorResult("Role must be in RoleList"); } context.Complete(); }
protected override void Execute(RuleContext context) { var primaryPropertyValue = (string)context.InputPropertyValues[PrimaryProperty]; var idProperty = this.InputProperties.Single(p => p.Name == this.IdPropertyName); var idValue = (int)context.InputPropertyValues[idProperty]; if (DuplicateCommand(idValue, primaryPropertyValue)) { context.AddErrorResult(string.Format(CultureInfo.CurrentCulture, "The value {0} already exists.", primaryPropertyValue)); } }
protected override void Execute(RuleContext context) { var value1 = (int)context.InputPropertyValues[PrimaryProperty]; var value2 = (string)context.InputPropertyValues[SecondaryProperty]; // uses the async methods in DataPortal to perform data access on a background thread. DuplicateCompanyCommand.BeginExecute(value1, value2, (o, e) => { if (e.Error != null) { context.AddErrorResult(string.Format("Error checking for duplicate company name. {0}", e.Error)); } else if (e.Object.IsDuplicate) { context.AddErrorResult("Duplicate company name."); } context.Complete(); }); }
protected override void Execute(RuleContext context) { var usuario = context.Target as Usuario; var valorNumerico = 0; bool result = int.TryParse(usuario.Alias, out valorNumerico); if (!result) { var nombresApellidos = string.Concat(usuario.ApellidoPaterno, usuario.ApellidoMaterno); if (String.IsNullOrEmpty(nombresApellidos)) { context.AddErrorResult(Usuario.ApellidoPaternoProperty, "Apellido Paterno deben ser obligatorio"); context.AddErrorResult(Usuario.ApellidoMaternoProperty, "Apellido Materno deben ser obligatorio"); } else { context.AddSuccessResult(true); } } }