コード例 #1
0
ファイル: Common.cs プロジェクト: hazdik/CodeOnTimeTutorial
        public BusinessObjectParameters(params Object[] values)
        {
            string parameterMarker = null;

            for (int i = 0; (i < values.Length); i++)
            {
                object v = values[i];
                if (v is FieldValue)
                {
                    FieldValue fv = ((FieldValue)(v));
                    Add(fv.Name, fv.Value);
                }
                else
                {
                    if (String.IsNullOrEmpty(parameterMarker))
                    {
                        parameterMarker = SqlStatement.GetParameterMarker(String.Empty);
                    }
                    Add((parameterMarker
                         + ("p" + i.ToString())), v);
                }
            }
        }
コード例 #2
0
        public int ExecuteAction(ActionArgs args, ActionResult result, ViewPage page)
        {
            DataTable t = GetTable(args.Controller, null);

            if (args.CommandName == "Insert")
            {
                DataRow r = t.NewRow();
                foreach (FieldValue v in args.Values)
                {
                    DataField f = page.FindField(v.Name);
                    if (f.IsPrimaryKey && f.ReadOnly)
                    {
                        object key = null;
                        if (f.Type == "Guid")
                        {
                            key = Guid.NewGuid();
                        }
                        else
                        if (!(PrimaryKeys.TryGetValue(args.Controller, out key)))
                        {
                            key = -1;
                            PrimaryKeys.Add(args.Controller, key);
                        }
                        else
                        {
                            key = (Convert.ToInt32(key) - 1);
                            PrimaryKeys[args.Controller] = key;
                        }
                        r[v.Name] = key;
                        result.Values.Add(new FieldValue(v.Name, key));
                        FieldValue fv = args.SelectFieldValueObject(v.Name);
                        fv.NewValue = key;
                        fv.Modified = true;
                    }
                    else
                    if (v.Modified)
                    {
                        if (v.NewValue == null)
                        {
                            r[v.Name] = DBNull.Value;
                        }
                        else
                        {
                            r[v.Name] = v.NewValue;
                        }
                    }
                }
                t.Rows.Add(r);
                return(1);
            }
            else
            {
                DataRow targetRow = null;
                foreach (DataRow r in t.Rows)
                {
                    bool matched = true;
                    foreach (DataField f in page.Fields)
                    {
                        if (f.IsPrimaryKey)
                        {
                            object kv  = r[f.Name];
                            object kv2 = args.SelectFieldValueObject(f.Name).OldValue;
                            if (((kv == null) || (kv2 == null)) || !((kv.ToString() == kv2.ToString())))
                            {
                                matched = false;
                                break;
                            }
                        }
                    }
                    if (matched)
                    {
                        targetRow = r;
                        break;
                    }
                }
                if (targetRow == null)
                {
                    return(0);
                }
                if (args.CommandName == "Delete")
                {
                    t.Rows.Remove(targetRow);
                }
                else
                {
                    foreach (FieldValue v in args.Values)
                    {
                        if (v.Modified)
                        {
                            if (v.NewValue == null)
                            {
                                targetRow[v.Name] = DBNull.Value;
                            }
                            else
                            {
                                targetRow[v.Name] = v.NewValue;
                            }
                        }
                    }
                }
                return(1);
            }
        }
コード例 #3
0
 protected virtual void ExecuteRule(string ruleId)
 {
     MethodInfo[] methods = GetType().GetMethods((BindingFlags.Public | (BindingFlags.NonPublic | BindingFlags.Instance)));
     foreach (MethodInfo method in methods)
     {
         object[] ruleBindings = method.GetCustomAttributes(typeof(RuleAttribute), true);
         foreach (RuleAttribute ra in ruleBindings)
         {
             if (ra.Id == ruleId)
             {
                 BlockRule(ruleId);
                 ParameterInfo[] parameters = method.GetParameters();
                 object[]        arguments  = new object[parameters.Length];
                 for (int i = 0; (i < parameters.Length); i++)
                 {
                     ParameterInfo p = parameters[i];
                     if ((parameters.Length == 1) && p.ParameterType.IsSubclassOf(typeof(BusinessRulesObjectModel)))
                     {
                         object self = p.ParameterType.Assembly.CreateInstance(p.ParameterType.FullName, true, BindingFlags.CreateInstance, null, new object[] {
                             this
                         }, System.Globalization.CultureInfo.CurrentCulture, null);
                         System.Reflection.FieldInfo[] fields = self.GetType().GetFields((BindingFlags.Instance | BindingFlags.NonPublic));
                         foreach (System.Reflection.FieldInfo fi in fields)
                         {
                             string fieldName = fi.Name.Substring("_".Length);
                             if (fieldName.Length == 1)
                             {
                                 fieldName = fieldName.ToUpper();
                             }
                             else
                             {
                                 fieldName = (char.ToUpper(fieldName[0]) + fieldName.Substring(1));
                             }
                             FieldValue v = SelectFieldValueObject(fieldName);
                             if (v != null)
                             {
                                 try
                                 {
                                     self.GetType().InvokeMember(fi.Name, (BindingFlags.SetField | (BindingFlags.Instance | BindingFlags.NonPublic)), null, self, new object[] {
                                         DataControllerBase.ConvertToType(fi.FieldType, v.Value)
                                     });
                                 }
                                 finally
                                 {
                                     // release resources here
                                 }
                             }
                         }
                         arguments[i] = self;
                     }
                     else
                     {
                         FieldValue v = SelectFieldValueObject(p.Name);
                         if (v != null)
                         {
                             if (p.ParameterType.Equals(typeof(FieldValue)))
                             {
                                 arguments[i] = v;
                             }
                             else
                             {
                                 try
                                 {
                                     arguments[i] = DataControllerBase.ConvertToType(p.ParameterType, v.Value);
                                 }
                                 catch (Exception)
                                 {
                                 }
                             }
                         }
                     }
                 }
                 method.Invoke(this, arguments);
             }
         }
     }
 }
コード例 #4
0
        private bool InternalExecuteMethod(ActionArgs args, ActionResult result, ActionPhase phase, bool viewMatch, bool argumentMatch)
        {
            _arguments = args;
            _result    = result;
            bool success = false;

            MethodInfo[] methods = GetType().GetMethods((BindingFlags.Public | (BindingFlags.NonPublic | BindingFlags.Instance)));
            foreach (MethodInfo method in methods)
            {
                object[] filters = method.GetCustomAttributes(typeof(ControllerActionAttribute), true);
                foreach (ControllerActionAttribute action in filters)
                {
                    if (((action.Controller == args.Controller) || (!(String.IsNullOrEmpty(args.Controller)) && Regex.IsMatch(args.Controller, action.Controller))) && ((!(viewMatch) && String.IsNullOrEmpty(action.View)) || (action.View == args.View)))
                    {
                        if ((action.CommandName == args.CommandName) && ((!(argumentMatch) && String.IsNullOrEmpty(action.CommandArgument)) || (action.CommandArgument == args.CommandArgument)))
                        {
                            if (action.Phase == phase)
                            {
                                ParameterInfo[] parameters = method.GetParameters();
                                if ((parameters.Length == 2) && ((parameters[0].ParameterType == typeof(ActionArgs)) && (parameters[1].ParameterType == typeof(ActionResult))))
                                {
                                    method.Invoke(this, new object[] {
                                        args,
                                        result
                                    });
                                }
                                else
                                {
                                    object[] arguments = new object[parameters.Length];
                                    for (int i = 0; (i < parameters.Length); i++)
                                    {
                                        ParameterInfo p = parameters[i];
                                        FieldValue    v = SelectFieldValueObject(p.Name);
                                        if (v != null)
                                        {
                                            if (p.ParameterType.Equals(typeof(FieldValue)))
                                            {
                                                arguments[i] = v;
                                            }
                                            else
                                            {
                                                try
                                                {
                                                    arguments[i] = DataControllerBase.ConvertToType(p.ParameterType, v.Value);
                                                }
                                                catch (Exception)
                                                {
                                                }
                                            }
                                        }
                                    }
                                    method.Invoke(this, arguments);
                                    success = true;
                                }
                            }
                        }
                    }
                }
            }
            return(success);
        }