public static RuleConfiguration FromRuleStorage(RuleStorage ruleStorage) { RuleConfiguration ruleConfiguration = new RuleConfiguration(ruleStorage.OrganizationalUnitRoot.ObjectGuid, ruleStorage.Id.ObjectGuid); UnifiedPolicyStorageFactory.CopyPropertiesFromStorage <RuleConfiguration>(ruleConfiguration, new TenantSettingFacade <RuleStorage>(ruleStorage)); return(ruleConfiguration); }
private IList <Guid> ValidateUpdateObjectSyncParameters() { IList <Guid> list = new List <Guid>(); foreach (string text in this.UpdateObjectId) { switch (this.ObjectType.First <ConfigurationObjectType>()) { case ConfigurationObjectType.Policy: { PolicyStorage storageObject = (PolicyStorage)base.GetDataObject <PolicyStorage>(new PolicyIdParameter(text), base.DataSession, null, new LocalizedString?(Strings.ErrorPolicyNotFound(text)), new LocalizedString?(Strings.ErrorPolicyNotUnique(text))); list.Add(Utils.GetUniversalIdentity(storageObject)); break; } case ConfigurationObjectType.Rule: { RuleStorage storageObject2 = (RuleStorage)base.GetDataObject <RuleStorage>(new ComplianceRuleIdParameter(text), base.DataSession, null, new LocalizedString?(Strings.ErrorRuleNotFound(text)), new LocalizedString?(Strings.ErrorRuleNotUnique(text))); list.Add(Utils.GetUniversalIdentity(storageObject2)); break; } default: throw new NotImplementedException(); } } return(list); }
protected override IConfigurable PrepareDataObject() { RuleStorage ruleStorage = (RuleStorage)base.PrepareDataObject(); ruleStorage.Name = base.Name; ruleStorage.SetId(((ADObjectId)this.policyStorage.Identity).GetChildId(base.Name)); ruleStorage.MasterIdentity = Guid.NewGuid(); PsDlpComplianceRule psDlpComplianceRule = new PsDlpComplianceRule(ruleStorage) { Comment = base.Comment, Disabled = base.Disabled, Mode = Mode.Enforce, Policy = Utils.GetUniversalIdentity(this.policyStorage), Workload = this.policyStorage.Workload, ContentPropertyContainsWords = this.ContentPropertyContainsWords, ContentContainsSensitiveInformation = this.ContentContainsSensitiveInformation, AccessScopeIs = this.AccessScopeIs, BlockAccess = this.BlockAccess }; if (!psDlpComplianceRule.GetTaskActions().Any <PsComplianceRuleActionBase>()) { throw new RuleContainsNoActionsException(psDlpComplianceRule.Name); } ADObjectId adobjectId; base.TryGetExecutingUserId(out adobjectId); psDlpComplianceRule.UpdateStorageProperties(this, base.DataSession as IConfigurationSession, true); return(ruleStorage); }
protected override IConfigurable PrepareDataObject() { RuleStorage ruleStorage = (RuleStorage)base.PrepareDataObject(); ruleStorage.Name = base.Name; ruleStorage.SetId(((ADObjectId)this.policyStorage.Identity).GetChildId(base.Name)); PsHoldRule psHoldRule = new PsHoldRule(ruleStorage) { Comment = base.Comment, Disabled = base.Disabled, Mode = Mode.Enforce, Policy = Utils.GetUniversalIdentity(this.policyStorage), Workload = this.policyStorage.Workload, ContentMatchQuery = this.ContentMatchQuery, ContentDateFrom = this.ContentDateFrom, ContentDateTo = this.ContentDateTo, HoldContent = this.HoldContent, HoldDurationDisplayHint = this.HoldDurationDisplayHint }; if (!psHoldRule.GetTaskActions().Any <PsComplianceRuleActionBase>()) { throw new RuleContainsNoActionsException(psHoldRule.Name); } ADObjectId adobjectId; base.TryGetExecutingUserId(out adobjectId); psHoldRule.UpdateStorageProperties(this, base.DataSession as IConfigurationSession, true); return(ruleStorage); }
protected override void StampChangesOn(IConfigurable dataObject) { RuleStorage ruleStorage = (RuleStorage)dataObject; ruleStorage.ResetChangeTracking(true); base.PsRulePresentationObject = new PsHoldRule(ruleStorage); PsHoldRule psHoldRule = (PsHoldRule)base.PsRulePresentationObject; base.PsRulePresentationObject.PopulateTaskProperties(this, base.DataSession as IConfigurationSession); if (base.PsRulePresentationObject.ReadOnly) { throw new TaskRuleIsTooAdvancedToModifyException(base.PsRulePresentationObject.Name); } if (ruleStorage.Mode == Mode.PendingDeletion) { base.WriteError(new ErrorCommonComplianceRuleIsDeletedException(ruleStorage.Name), ErrorCategory.InvalidOperation, null); } base.StampChangesOn(dataObject); this.CopyExplicitParameters(); if (!Utils.ValidateContentDateParameter(psHoldRule.ContentDateFrom, psHoldRule.ContentDateTo)) { throw new InvalidContentDateFromAndContentDateToPredicateException(); } if (!psHoldRule.GetTaskActions().Any <PsComplianceRuleActionBase>()) { base.WriteError(new RuleContainsNoActionsException(psHoldRule.Name), ErrorCategory.InvalidData, psHoldRule); } psHoldRule.UpdateStorageProperties(this, base.DataSession as IConfigurationSession, false); }
internal virtual void PopulateTaskProperties(Task task, IConfigurationSession configurationSession) { RuleStorage ruleStorage = base.DataObject as RuleStorage; ADUser userObjectByExternalDirectoryObjectId = Utils.GetUserObjectByExternalDirectoryObjectId(ruleStorage.CreatedBy, configurationSession); ADUser userObjectByExternalDirectoryObjectId2 = Utils.GetUserObjectByExternalDirectoryObjectId(ruleStorage.LastModifiedBy, configurationSession); this.CreatedBy = ((!Utils.ExecutingUserIsForestWideAdmin(task) && userObjectByExternalDirectoryObjectId != null) ? userObjectByExternalDirectoryObjectId.DisplayName : ruleStorage.CreatedBy); this.LastModifiedBy = ((!Utils.ExecutingUserIsForestWideAdmin(task) && userObjectByExternalDirectoryObjectId2 != null) ? userObjectByExternalDirectoryObjectId2.DisplayName : ruleStorage.LastModifiedBy); }
public static RuleStorage ToRuleStorage(RuleConfiguration rule) { RuleStorage ruleStorage = new RuleStorage(); ruleStorage[ADObjectSchema.OrganizationalUnitRoot] = new ADObjectId(rule.TenantId); ruleStorage.Name = rule.Name; ruleStorage.SetId((ADObjectId)DalHelper.ConvertFromStoreObject(rule.ObjectId, typeof(ADObjectId))); UnifiedPolicyStorageFactory.CopyPropertiesToStorage <RuleConfiguration>(new TenantSettingFacade <RuleStorage>(ruleStorage), rule); return(ruleStorage); }
public void PropertySet_AliasTest() { RuleStorage rules = RuleStorage.Instance; Type type1 = typeof(TestAlias1::AliasTestPack.Class1); var type1Rules = rules.GetValidationRules(type1); Assert.That(type1Rules.ValidationStrategyBuilders.Any(x => x.Key.Name == "TestPack1NotNull"), Is.True, "type1 rule notNull"); Type type2 = typeof(TestAlias2::AliasTestPack.Class1); var type2Rules = rules.GetValidationRules(type2); Assert.That(type2Rules.ValidationStrategyBuilders.Any(x => x.Key.Name == "TestPack1NotNull"), Is.False, "type1 rule notNull present"); Assert.That(type2Rules.ValidationStrategyBuilders.Any(x => x.Key.Name == "TestPack2NotNull"), Is.True, "type1 rule notNull present"); }
protected override IConfigurable PrepareDataObject() { RuleStorage ruleStorage = (RuleStorage)base.PrepareDataObject(); ruleStorage.Name = this.ruleName; ruleStorage.SetId(((ADObjectId)this.policyStorage.Identity).GetChildId(this.ruleName)); DeviceRuleBase deviceRuleBase = this.CreateDeviceRule(ruleStorage); deviceRuleBase.Policy = Utils.GetUniversalIdentity(this.policyStorage); deviceRuleBase.Workload = this.policyStorage.Workload; deviceRuleBase.TargetGroups = this.TargetGroups; this.SetPropsOnDeviceRule(deviceRuleBase); deviceRuleBase.UpdateStorageProperties(this, base.DataSession as IConfigurationSession, true); return(ruleStorage); }
protected override IConfigurable PrepareDataObject() { RuleStorage ruleStorage = (RuleStorage)base.PrepareDataObject(); ruleStorage.Name = this.Name; ruleStorage.SetId(((ADObjectId)this.policyStorage.Identity).GetChildId(this.Name)); AuditConfigurationRule auditConfigurationRule = new AuditConfigurationRule(ruleStorage) { Policy = Utils.GetUniversalIdentity(this.policyStorage), Workload = this.policyStorage.Workload, AuditOperation = this.AuditOperation }; auditConfigurationRule.UpdateStorageProperties(); return(ruleStorage); }
protected override void StampChangesOn(IConfigurable dataObject) { RuleStorage ruleStorage = (RuleStorage)dataObject; ruleStorage.ResetChangeTracking(true); AuditConfigurationRule auditConfigurationRule = new AuditConfigurationRule(dataObject as RuleStorage); auditConfigurationRule.PopulateTaskProperties(); if (ruleStorage.Mode == Mode.PendingDeletion) { base.WriteError(new ErrorCommonComplianceRuleIsDeletedException(ruleStorage.Name), ErrorCategory.InvalidOperation, null); } base.StampChangesOn(dataObject); auditConfigurationRule.CopyChangesFrom(base.DynamicParametersInstance); auditConfigurationRule.AuditOperation = this.AuditOperation; auditConfigurationRule.UpdateStorageProperties(); }
internal virtual void UpdateStorageProperties(Task task, IConfigurationSession configurationSession, bool isNewRule) { if (!Utils.ExecutingUserIsForestWideAdmin(task)) { ADObjectId objectId; task.TryGetExecutingUserId(out objectId); ADUser userObjectByObjectId = Utils.GetUserObjectByObjectId(objectId, configurationSession); if (userObjectByObjectId != null) { RuleStorage ruleStorage = base.DataObject as RuleStorage; ruleStorage.LastModifiedBy = userObjectByObjectId.ExternalDirectoryObjectId; if (isNewRule) { ruleStorage.CreatedBy = userObjectByObjectId.ExternalDirectoryObjectId; } } } }
public void ReloadRulesForAnalyzer(string analyzerProgramName) { Task.Run(() => { var analyzer = Analyzers.FirstOrDefault(a => a.Key == analyzerProgramName).Value; AddMessage($"Reloading rules for {analyzerProgramName}. Stopping Analyzer."); analyzer.StopAnalyzer(); while (analyzer.State != State.Stopped) { //wait for stop } analyzer.UnloadAllRules(); AddMessage($"{analyzerProgramName} analyzer stopped and rules unloaded."); var rules = RuleStorage.GetRulesForApplication(analyzerProgramName); AddRulesToAnalyzer(rules); AddMessage($"{analyzer.ProgramName} analyzer starting."); analyzer.StartAnalyzer(); }); }
protected DeviceRuleBase(RuleStorage ruleStorage) : base(ruleStorage) { }
public PsHoldRule(RuleStorage ruleStorage) : base(ruleStorage) { }
protected abstract DeviceRuleBase CreateDeviceRule(RuleStorage dataObject);
protected override DeviceRuleBase CreateDeviceRule(RuleStorage dataObject) { return(new DeviceConfigurationRule(dataObject)); }
protected override DeviceRuleBase CreateDeviceRule(RuleStorage dataObject) { return(new DeviceTenantRule(dataObject)); }
protected override DeviceRuleBase CreateDeviceRuleObject(RuleStorage ruleStorage) { return(new DeviceTenantRule(ruleStorage)); }
protected abstract DeviceRuleBase CreateDeviceRuleObject(RuleStorage ruleStorage);
protected override DeviceRuleBase CreateDeviceRule(RuleStorage ruleStorage) { return(new DeviceConfigurationRule(ruleStorage)); }
public PsComplianceRuleBase(RuleStorage ruleStorage) : base(ruleStorage) { }
protected override DeviceRuleBase CreateDeviceRule(RuleStorage ruleStorage) { return(new DeviceConditionalAccessRule(ruleStorage)); }
protected override DeviceRuleBase CreateDeviceRule(RuleStorage dataObject) { return(new DeviceConditionalAccessRule(dataObject)); }
public PsDlpComplianceRule(RuleStorage ruleStorage) : base(ruleStorage) { }
public DeviceTenantRule(RuleStorage ruleStorage) : base(ruleStorage) { }