コード例 #1
0
 public void InvokeFlowRuleCode(ManagementAgent ma, FlowRule rule, CSEntry csentry, MVEntry mventry)
 {
     Tracer.TraceInformation("enter-invokeflowrulecode {0}", rule.Name);
     try
     {
         FlowRuleCode r = (FlowRuleCode)rule;
         if (r.Direction.Equals(Direction.Import))
         {
             ma.InvokeMapAttributesForImport(r.Name, csentry, mventry);
         }
         else
         {
             ma.InvokeMapAttributesForExport(r.Name, csentry, mventry);
         }
         r = null;
     }
     catch (Exception ex)
     {
         Tracer.TraceError("invokeflowrulecode {0}", ex.GetBaseException());
         throw ex;
     }
     finally
     {
         Tracer.TraceInformation("exit-invokeflowrulecode {0}", rule.Name);
     }
 }
コード例 #2
0
ファイル: FIM.MARE.cs プロジェクト: guoyu07/mare-4
 public void InvokeFlowRule(FlowRule rule, CSEntry csentry, MVEntry mventry)
 {
     Tracer.TraceInformation("enter-invokeflowrule {0}", rule.Name);
     Tracer.Indent();
     try
     {
         FlowRule r           = (FlowRule)rule;
         object   targetValue = null;
         foreach (Value value in r.SourceExpression.Source)
         {
             if (value.GetType().Equals(typeof(MultiValueAttribute)))
             {
                 MultiValueAttribute attr = (MultiValueAttribute)value;
                 object mv = attr.GetValueOrDefault(r.Direction, csentry, mventry);
                 targetValue = attr.Transform(mv, TransformDirection.Source);
             }
             if (value.GetType().Equals(typeof(Attribute)))
             {
                 Attribute attr         = (Attribute)value;
                 object    concateValue = attr.GetValueOrDefault(r.Direction, csentry, mventry);
                 concateValue = attr.Transform(concateValue, TransformDirection.Source);
                 targetValue  = targetValue as string + concateValue;
                 attr         = null;
                 continue;
             }
             if (value.GetType().Equals(typeof(Constant)))
             {
                 targetValue = targetValue + ((Constant)value).Value;
                 continue;
             }
         }
         targetValue = r.Target.Transform(targetValue, TransformDirection.Target);
         r.Target.SetTargetValue(r.Direction, csentry, mventry, targetValue);
         r = null;
     }
     catch (Exception ex)
     {
         Tracer.TraceError("invokeflowrule {0}", ex.GetBaseException());
         throw ex;
     }
     finally
     {
         Tracer.Unindent();
         Tracer.TraceInformation("exit-invokeflowrule {0}", rule.Name);
     }
 }
コード例 #3
0
        public void MapAttributesForImportExportDetached(string FlowRuleName, CSEntry csentry, MVEntry mventry, Direction direction)
        {
            Tracer.TraceInformation("enter-mapattributesforimportexportdetached [{0}]", direction);

            List <FlowRule> rules = null;

            try
            {
                string maName = csentry.MA.Name;
                Tracer.TraceInformation("mvobjectid: {0}, ma: {1}, rule: {2}", mventry.ObjectID, maName, FlowRuleName);

                ManagementAgent ma = config.ManagementAgent.Where(m => m.Name.Equals(maName)).FirstOrDefault();
                if (ma == null)
                {
                    throw new NotImplementedException("management-agent-" + maName + "-not-found");
                }
                rules = ma.FlowRule.Where(r => r.Name.Equals(FlowRuleName) && r.Direction.Equals(direction)).ToList <FlowRule>();
                if (rules == null)
                {
                    throw new NotImplementedException(direction.ToString() + "-rule-'" + FlowRuleName + "'-not-found-on-ma-" + maName);
                }
                foreach (FlowRule r in rules)
                {
                    Tracer.TraceInformation("found-rule name: {0}, description: {1}", r.Name, r.Description);
                }
                FlowRule rule = rules.Where(ru => ru.Conditions.AreMet(csentry, mventry)).FirstOrDefault();
                if (rule == null)
                {
                    throw new DeclineMappingException("no-" + direction.ToString() + "-rule-'" + FlowRuleName + "'-found-on-ma-'" + maName + "'-where-conditions-were-met");
                }

                #region FlowRuleDefault
                if (rule.GetType().Equals(typeof(FlowRule)))
                {
                    InvokeFlowRule(rule, csentry, mventry);
                    return;
                }
                #endregion
                #region FlowRuleCode
                if (rule.GetType().Equals(typeof(FlowRuleCode)))
                {
                    InvokeFlowRuleCode(ma, rule, csentry, mventry);
                    return;
                }
                #endregion

                rule = null;
            }
            catch (Exception ex)
            {
                Tracer.TraceError("mapattributesforimportexportdetached {0}", ex.GetBaseException());
                throw ex;
            }
            finally
            {
                if (rules != null)
                {
                    rules.Clear();
                    rules = null;
                }
                Tracer.TraceInformation("exit-mapattributesforimportexportdetached [{0}]", direction);
            }
        }