/// <summary>
        /// Register all modules
        /// </summary>
        public static void RegisterModules(RouteCollection routes, ITypeContainer container)
        {
            var typeSearcher = TypeSearcher.Instance();
            var moduleTypes  = typeSearcher.SearchTypesByBaseType(typeof(IModule));

            Modules = new Dictionary <string, ModuleDescriptor>();

            foreach (var moduleType in moduleTypes)
            {
                if (moduleType.IsAbstract)
                {
                    continue;
                }

                var module = (IModule)Activator.CreateInstance(moduleType);

                if (module != null && string.IsNullOrEmpty(module.Name))
                {
                    continue;
                }

                if (Modules.ContainsKey(module.Name))
                {
                    continue;
                }

                var _asmName         = moduleType.Assembly.GetName();
                var moduleDescriptor = new ModuleDescriptor()
                {
                    Name = module.Name,
                    AssemblyQualifiedName = moduleType.AssemblyQualifiedName,
                    AssemblyFullName      = _asmName.FullName,
                    AssemblyName          = _asmName.Name
                };
                moduleDescriptor.LoadAssemblyInfo();

                ServiceModule serviceModule = module as ServiceModule;

                if (serviceModule != null)
                {
                    serviceModule.RegisterTypes(container);
                    serviceModule.RegisterRoutes(RouteTable.Routes);
                }

                SolutionModule solutionModule = module as SolutionModule;

                if (solutionModule != null && !solutionModule.DisableAutoRoutesRegistration)
                {
                    #region Auto route generation

                    var routeName     = string.Format("solution_{0}", module.Name);
                    var additional_ns = solutionModule.GetNamespaces();
                    var ns            = new List <string>();
                    ns.Add(moduleType.Namespace);
                    if (additional_ns != null && additional_ns.Length > 0)
                    {
                        ns.AddRange(additional_ns);
                    }

                    if (routes[routeName] == null)
                    {
                        moduleDescriptor.RouteName = routeName;
                        var ctrls = moduleType.Assembly.GetTypes().Where(t => t.BaseType != null && t.BaseType.Equals(typeof(Controller))).ToList();

                        if (ctrls.Count > 0)
                        {
                            var hostDashboardType = Type.GetType("DNA.Web.HostDashboardAttribute,DNA.Web.ServiceModel");
                            var myDashboardType   = Type.GetType("DNA.Web.MyDashboardAttribute,DNA.Web.ServiceModel");

                            foreach (var ctrl in ctrls)
                            {
                                var dashboardMethods = ctrl.GetMethods().Where(m => m.IsDefined(hostDashboardType, false));
                                var myDashboards     = ctrl.GetMethods().Where(m => m.IsDefined(myDashboardType, false));

                                foreach (var m in dashboardMethods)
                                {
                                    var ctrlName           = ctrl.Name.Replace("Controller", "");
                                    var dashboardRouteName = "host_module_" + module.Name + "_" + ctrlName + "_" + m.Name;
                                    if (RouteTable.Routes[dashboardRouteName] == null)
                                    {
                                        routes.MapRoute(dashboardRouteName, "{host}/{solution}/{controller}/{action}/{id}",
                                                        new { id = UrlParameter.Optional },
                                                        new { host = "host", solution = module.Name, controller = ctrlName, action = m.Name });
                                    }
                                }

                                foreach (var m in myDashboards)
                                {
                                    var ctrlName    = ctrl.Name.Replace("Controller", "");
                                    var myRouteName = "mysite_" + module.Name + "_" + ctrlName + "_" + m.Name;
                                    if (RouteTable.Routes[myRouteName] == null)
                                    {
                                        routes.MapRoute(myRouteName, "{mysite}/{solution}/{controller}/{action}/{id}",
                                                        new { id = UrlParameter.Optional },
                                                        new { mysite = "mysite", solution = module.Name, controller = ctrlName, action = m.Name });
                                    }
                                }
                            }

                            if (RouteTable.Routes[routeName] == null)
                            {
                                routes.MapRoute(routeName, "{website}/{locale}/{solution}/{controller}/{action}/{id}",
                                                new { action = "index", id = UrlParameter.Optional },
                                                new { solution = module.Name, locale = @"([a-z]{2})-([a-z]{2}|[A-Z]{2})" });
                            }
                        }
                    }

                    #endregion
                }

                Modules.Add(module.Name, moduleDescriptor);
            }

            container.Apply();
        }
Beispiel #2
0
        private static IEnumerable <DashboardGroup> GetItemGroups <T>(WebContext context)
            where T : DashboardBaseAttribute
        {
            var groups = new List <DashboardGroup>();
            var items  = new List <DashboardItem>();
            var url    = UrlUtility.CreateUrlHelper();

            var typeSearcher = TypeSearcher.Instance();
            var controllers  = typeSearcher.SearchTypesByBaseType(typeof(Controller));

            foreach (Type controller in controllers)
            {
                var methods = controller.GetMethods(BindingFlags.Public | BindingFlags.Instance);
                var actions = from MethodInfo method in methods
                              where (method.GetCustomAttributes(typeof(T), true).Length > 0)
                              select method;
                var sol = ModuleRegistration.Modules.Select(s => s.Value).FirstOrDefault(s => !string.IsNullOrEmpty(s.RouteName) && s.AssemblyFullName.Equals(controller.Assembly.FullName));

                foreach (MethodInfo action in actions)
                {
                    T      attr         = (T)Attribute.GetCustomAttribute(action, typeof(T));
                    string text         = attr.Text;
                    var    securityAttr = Attribute.GetCustomAttribute(action, typeof(SecurityActionAttribute));

                    if (securityAttr != null)
                    {
                        if (!context.HasPermisson(controller, action.Name))
                        {
                            continue;
                        }
                    }

                    var httpPostAttr = Attribute.GetCustomAttribute(action, typeof(HttpPostAttribute));
                    if (httpPostAttr != null)
                    {
                        continue;
                    }

                    if (string.IsNullOrEmpty(attr.Text) && string.IsNullOrEmpty(attr.ResKey))
                    {
                        continue;
                    }

                    if (!string.IsNullOrEmpty(attr.ResKey))
                    {
                        if (!string.IsNullOrEmpty(attr.ResBaseName))
                        {
                            text = App.GetResourceString(attr.ResBaseName, attr.ResKey);
                        }
                        else
                        {
                            text = App.GetResourceString(attr.ResKey);
                        }
                    }

                    string _controller = controller.Name.Replace("Controller", "");
                    var    curGroup    = groups.FirstOrDefault(g => g.Name.Equals(attr.Group, StringComparison.OrdinalIgnoreCase));

                    if (curGroup == null)
                    {
                        curGroup = new DashboardGroup()
                        {
                            Name = attr.Group
                        };
                        groups.Add(curGroup);
                    }

                    if (!string.IsNullOrEmpty(attr.GroupResKey) && !string.IsNullOrEmpty(attr.ResBaseName) && string.IsNullOrEmpty(curGroup.Title))
                    {
                        curGroup.Title = App.GetResourceString(attr.ResBaseName, attr.GroupResKey);
                    }

                    var area = GetArea(controller);

                    var _item = new DashboardItem()
                    {
                        Order         = attr.Sequence,
                        Title         = text,
                        Icon          = attr.Icon,
                        Action        = action.Name,
                        Controller    = _controller,
                        Area          = area,
                        ImageUrl      = string.IsNullOrEmpty(attr.Icon) ? url.Content("~/content/images/icon_process_16.png") : url.Content("~/content/images/" + attr.Icon),
                        NavigationUrl = url.Action(action.Name, _controller, new { Area = area, website = context.Website, locale = context.Locale })
                    };

                    var _routeName = attr.RouteName;

                    if (sol != null && string.IsNullOrEmpty(_routeName))
                    {
                        if (typeof(T) == typeof(HostDashboardAttribute))
                        {
                            _routeName = "host_module_" + sol.Name + "_" + _controller + "_" + action.Name;
                        }
                        else
                        {
                            if (typeof(T) == typeof(MyDashboardAttribute))
                            {
                                _routeName = "mysite_" + sol.Name + "_" + _controller + "_" + action.Name;
                            }
                            else
                            {
                                _routeName = sol.RouteName;
                            }
                        }
                    }

                    if (!string.IsNullOrEmpty(_routeName))
                    {
                        var route       = RouteTable.Routes[_routeName] as Route;
                        var routeValues = new RouteValueDictionary(new
                        {
                            Area       = area,
                            website    = context.Website,
                            action     = action.Name,
                            controller = _controller,
                            locale     = context.Locale
                        });

                        var path = url.RouteUrl(_routeName, routeValues);

                        if (string.IsNullOrEmpty(path))
                        {
                            path = route.Url;
                            foreach (string key in route.Defaults.Keys)
                            {
                                path = path.Replace("{" + key + "}", routeValues.Keys.Contains(key) ? routeValues[key].ToString() : route.Defaults[key].ToString());
                            }

                            foreach (string key in route.Constraints.Keys)
                            {
                                var constr = route.Constraints[key].ToString();
                                if (!constr.StartsWith("("))
                                {
                                    path = path.Replace("{" + key + "}", constr);
                                }
                            }

                            foreach (string key in routeValues.Keys)
                            {
                                path = path.Replace("{" + key + "}", routeValues[key].ToString());
                            }
                        }
                        _item.NavigationUrl = url.Content("~/" + path);
                    }

                    if (curGroup.Items.Count(i => i.NavigationUrl.Equals(_item.NavigationUrl, StringComparison.OrdinalIgnoreCase)) == 0)
                    {
                        curGroup.Items.Add(_item);
                    }
                }
            }
            return(groups.OrderBy(g => g.Name).ToList());
        }
Beispiel #3
0
        private static void RegisterSpecifiedTypes()
        {
            var typeSearcher = TypeSearcher.Instance();

            var unityConfigFile = HttpRuntime.AppDomainAppPath + "unity.config";
            var unity           = XDocument.Load(unityConfigFile);
            var ns        = unity.Root.GetDefaultNamespace();
            var isChanged = false;

            var types = typeSearcher.SearchTypesOfAttribute(typeof(InjectAttribute), false);

            foreach (var type in types)
            {
                var typeName     = type.Name;
                var typeFullName = type.FullName + "," + type.Assembly.GetName().Name;
                var asmName      = type.Assembly.GetName().Name;
                var typeNS       = type.Namespace;
                var mapTo        = "";

                var iocAttr = typeSearcher.ExtractCustomAttribute <InjectAttribute>(type);

                if (!string.IsNullOrEmpty(iocAttr.Alias))
                {
                    typeName = iocAttr.Alias;
                }


                if (!string.IsNullOrEmpty(iocAttr.MapTo))
                {
                    mapTo = iocAttr.MapTo;
                }

                //Register alias name

                var aliasNode = unity.Root.Elements(ns + "alias").FirstOrDefault(e => e.StrAttr("alias").Equals(typeName));

                if (aliasNode == null)
                {
                    unity.Root.Add(new XElement(ns + "alias",
                                                new XAttribute("alias", typeName),
                                                new XAttribute("type", typeFullName)));
                    isChanged = true;
                }

                //Register namespace

                if (unity.Root.Elements(ns + "namespace").FirstOrDefault(e => e.StrAttr("name").Equals(typeNS)) == null)
                {
                    unity.Root.Add(new XElement(ns + "namespace", new XAttribute("name", typeNS)));
                    isChanged = true;
                }

                //Register assembly

                if (unity.Root.Elements(ns + "assembly").FirstOrDefault(e => e.StrAttr("name").Equals(asmName)) == null)
                {
                    unity.Root.Add(new XElement(ns + "assembly", new XAttribute("name", asmName)));
                    isChanged = true;
                }


                //Register types

                if (!string.IsNullOrEmpty(mapTo))
                {
                    var aliasName = typeName[0].ToString().ToLower() + typeName.Substring(1);

                    if (unity.Root.Descendants(ns + "register").FirstOrDefault(e => e.StrAttr("type").Equals(mapTo) &&
                                                                               e.StrAttr("mapTo").Equals(typeName)) == null)
                    {
                        unity.Root
                        .Element(ns + "container")
                        .Add(new XElement(ns + "register",
                                          new XAttribute("type", mapTo),
                                          new XAttribute("mapTo", typeName),
                                          new XAttribute("name", aliasName)));
                        isChanged = true;
                    }
                }
            }

            if (isChanged)
            {
                unity.Save(unityConfigFile);
            }
        }