コード例 #1
0
        /// <summary>
        /// Get InstallModel from installed config file
        /// </summary>
        /// <returns>InstallModel if the platform has been installed</returns>
        private InstallModel GetInstallationModel()
        {
            if (_installModel != null)
            {
                return(_installModel);
            }

            string installationFilePath = Path.Combine(_hostingEnvironment.ContentRootPath, Globals.InstallConfigFile);

            if (File.Exists(installationFilePath))
            {
                string strInstallation = File.ReadAllText(installationFilePath);
                _installModel = !string.IsNullOrEmpty(strInstallation) ? SDJsonConvert.DeserializeObject <InstallModel>(strInstallation) : null;
                return(_installModel);
            }
            return(null);
        }
コード例 #2
0
        public List <Language> GetAllLanguages(bool exceptEnabled = false)
        {
            var json     = EmbeddedProvider.GetFileContentAsString(typeof(LanguageManager).Assembly, "Cultures.json");
            var cultures = SDJsonConvert.DeserializeObject <List <Language> >(json);

            cultures.ForEach(c => c.FallbackCulture = Globals.FallbackLanguage);

            if (!exceptEnabled)
            {
                return(cultures);
            }

            var enabledLanguages = _languageRepository.GetLanguages();

            cultures = cultures.Where(language => enabledLanguages.All(el => el.CultureCode != language.CultureCode)).ToList();

            return(cultures);
        }
コード例 #3
0
        public List <Language> GetAllLanguages(bool exceptEnabled = false)
        {
            try
            {
                string          culuresJsonPath = Path.Combine(_hostingEnvironment.ContentRootPath, "cultures.json");
                List <Language> cultures        = SDJsonConvert.DeserializeObject <List <Language> >(System.IO.File.ReadAllText(culuresJsonPath));

                cultures.ForEach(c => c.FallbackCulture = Globals.FallbackLanguage);

                if (exceptEnabled)
                {
                    var enabledLanguages = _languageRepository.GetLanguages();
                    cultures = cultures.Where(language => !enabledLanguages.Any(el => el.CultureCode == language.CultureCode)).ToList();
                }

                return(cultures);
            }
            catch (Exception ex)
            {
                _logger.LogError("Error occured while getting all languages", ex);
                throw ex;
            }
        }
コード例 #4
0
 public static void SetObjectAsJson(this ISession session, string key, object value)
 {
     session.SetString(key, SDJsonConvert.SerializeObject(value));
 }
コード例 #5
0
        public static T GetObjectFromJson <T>(this ISession session, string key)
        {
            var value = session.GetString(key);

            return(value == null ? default(T) : SDJsonConvert.DeserializeObject <T>(value));
        }
コード例 #6
0
        public DeviserMapperProfile()
        {
            CreateMap <AdminPage, Core.Common.DomainTypes.AdminPage>()
            .ForMember(dest => dest.ModuleName, opt => opt.MapFrom(src => src.Module.Name))
            .ForMember(dest => dest.ModuleName, opt => opt.Condition(src => src.Module != null))
            .ReverseMap()
            .ForMember(dest => dest.Module, opt => opt.Ignore());

            CreateMap <ContentPermission, Core.Common.DomainTypes.ContentPermission>().ReverseMap();

            CreateMap <Property, Core.Common.DomainTypes.Property>().ReverseMap();

            CreateMap <ContentFieldType, Core.Common.DomainTypes.ContentFieldType>().ReverseMap();

            CreateMap <Core.Common.DomainTypes.ContentType, ContentType>()
            .ForMember(dest => dest.ContentTypeProperties, opt =>
                       opt.MapFrom(src => src.Properties.Select(ctp =>
                                                                new ContentTypeProperty
            {
                PropertyId    = ctp.Id,
                ContentTypeId = src.Id
            })))
            .ForMember(dest => dest.ContentTypeProperties, opt => opt.Condition(src => src.Properties != null))

            .ReverseMap()
            .ForMember(dest => dest.Properties, opt => opt.MapFrom(src => src.ContentTypeProperties.Select(ctp => ctp.Property)))
            .ForMember(dest => dest.Properties, opt => opt.Condition(src => src.ContentTypeProperties != null && src.ContentTypeProperties.All(cp => cp.Property != null)));

            CreateMap <ContentTypeField, Core.Common.DomainTypes.ContentTypeField>().ReverseMap();

            CreateMap <Core.Common.DomainTypes.LayoutType, LayoutType>()
            .ForMember(dest => dest.LayoutTypeProperties, opt => opt.MapFrom(src =>
                                                                             src.Properties != null ? src.Properties.Select(ctp => new LayoutTypeProperty {
                PropertyId = ctp.Id, LayoutTypeId = src.Id
            }) : null))
            .ReverseMap()
            .ForMember(dest => dest.Properties, opt => opt.MapFrom(src =>
                                                                   src.LayoutTypeProperties != null ? src.LayoutTypeProperties.Select(ctp => ctp.Property) : null));

            CreateMap <Core.Common.DomainTypes.Module, Module>().ReverseMap();

            CreateMap <ModuleView, Core.Common.DomainTypes.ModuleView>()
            .ForMember(dest => dest.Properties, opt => opt.MapFrom(src => src.ModuleViewProperties != null ? src.ModuleViewProperties.Select(ctp => ctp.Property) : null))
            .ReverseMap()
            .ForMember(dest => dest.ModuleViewProperties, opt => opt.MapFrom(src => src.Properties != null ? src.Properties.Select(macp => new ModuleViewProperty {
                PropertyId = macp.Id, ModuleViewId = src.Id
            }) : null));

            //CreateMap<Core.Common.DomainTypes.Module, Module>()
            // .ForMember(dest => dest.ModuleProperties, opt => opt.MapFrom(src =>
            //    src.Properties != null ? src.Properties.Select(ctp => new ModuleProperty { PropertyId = ctp.Id, ModuleId = src.Id }) : null))
            //.ReverseMap()
            //.ForMember(dest => dest.Properties, opt => opt.MapFrom(src =>
            //  src.ModuleProperties != null ? src.ModuleProperties.Select(ctp => ctp.Property) : null));

            CreateMap <ModuleViewType, Core.Common.DomainTypes.ModuleViewType>().ReverseMap();
            CreateMap <ModulePermission, Core.Common.DomainTypes.ModulePermission>().ReverseMap();

            CreateMap <PageContent, Core.Common.DomainTypes.PageContent>()
            .ForMember(dest => dest.Properties, opt =>
                       opt.MapFrom(src => !string.IsNullOrEmpty(src.Properties) ? SDJsonConvert.DeserializeObject <List <Core.Common.DomainTypes.Property> >(src.Properties) : null))
            .ReverseMap()
            .ForMember(dest => dest.Properties, opt =>
                       opt.MapFrom(src => (src.Properties != null) ? SDJsonConvert.SerializeObject(src.Properties) : null));

            CreateMap <Language, Core.Common.DomainTypes.Language>().ReverseMap();
            CreateMap <Layout, Core.Common.DomainTypes.Layout>().ReverseMap();
            CreateMap <Core.Common.DomainTypes.Layout, Core.Common.DomainTypes.PageLayout>().ReverseMap();
            CreateMap <Page, Core.Common.DomainTypes.Page>()
            .MaxDepth(10)
            .ReverseMap()
            .MaxDepth(10);

            CreateMap <Page, Page>()
            .ForMember(dest => dest.AdminPage, opt => opt.Ignore())
            .ForMember(dest => dest.ChildPage, opt => opt.Ignore())
            .ForMember(dest => dest.PageContent, opt => opt.Ignore())
            .ForMember(dest => dest.PageModule, opt => opt.Ignore())
            .ForMember(dest => dest.PageTranslation, opt => opt.Ignore())
            .ForMember(dest => dest.PagePermissions, opt => opt.Ignore())
            .ForMember(dest => dest.PageType, opt => opt.Ignore())
            .ForMember(dest => dest.Parent, opt => opt.Ignore())
            .ForMember(dest => dest.Layout, opt => opt.Ignore());

            CreateMap <PageType, Core.Common.DomainTypes.PageType>().ReverseMap();

            CreateMap <PageContentTranslation, Core.Common.DomainTypes.PageContentTranslation>().ReverseMap();

            CreateMap <PageModule, Core.Common.DomainTypes.PageModule>()
            .ForMember(dest => dest.Properties, opt =>
                       opt.MapFrom(src => !string.IsNullOrEmpty(src.Properties) ? SDJsonConvert.DeserializeObject <ICollection <Core.Common.DomainTypes.Property> >(src.Properties) : null))
            .ReverseMap()
            .ForMember(dest => dest.Properties, opt =>
                       opt.MapFrom(src => (src.Properties != null) ? SDJsonConvert.SerializeObject(src.Properties) : null));


            CreateMap <PagePermission, Core.Common.DomainTypes.PagePermission>()
            .ReverseMap();

            CreateMap <PageTranslation, Core.Common.DomainTypes.PageTranslation>()
            .ReverseMap();

            CreateMap <PageTranslation, PageTranslation>()
            .ForMember(dest => dest.Page, opt => opt.Ignore());


            CreateMap <Permission, Core.Common.DomainTypes.Permission>().ReverseMap();


            CreateMap <OptionList, Core.Common.DomainTypes.OptionList>()
            .ForMember(dest => dest.List, opt =>
                       opt.MapFrom(src => !string.IsNullOrEmpty(src.List) ? SDJsonConvert.DeserializeObject <List <Core.Common.DomainTypes.PropertyOption> >(src.List) : null))
            .ReverseMap()
            .ForMember(dest => dest.List, opt =>
                       opt.MapFrom(src => (src.List != null) ? SDJsonConvert.SerializeObject(src.List) : null));

            CreateMap <Role, Core.Common.DomainTypes.Role>().ReverseMap();

            //Roles from db needs to be ignored, because User.Roles is not Role type, it is UserRole - join entity.
            CreateMap <User, Core.Common.DomainTypes.User>()
            .ForMember(dest => dest.Roles, opt => opt
                       .MapFrom(src => src.UserRoles != null ? src.UserRoles.Select(ur => new Core.Common.DomainTypes.Role()
            {
                Id = ur.RoleId, Name = ur.Role.Name
            }).ToList() : null))
            .ReverseMap()
            .ForMember(dest => dest.UserRoles, opt => opt.MapFrom(src =>
                                                                  src.Roles != null ? src.Roles.Select(r => new UserRole()
            {
                RoleId = r.Id, UserId = src.Id
            }).ToList() : null));

            CreateMap <SiteSetting, Core.Common.DomainTypes.SiteSetting>().ReverseMap();
        }
コード例 #7
0
        private IHtmlContent RenderContentItem(PlaceHolder placeHolder)
        {
            IHtmlContent htmlContentItems = null;

            if (placeHolder == null)
            {
                return(htmlContentItems);
            }
            //string currentResult = "";
            var htmlCurrentResult = new HtmlContentBuilder();

            var currentResults = new List <ContentResult>();
            List <ContentResult> moduleResult = null;
            var layoutType = placeHolder.Type;

            ViewContext.ViewData["isEditMode"] = false;


            if (ModuleViewResults.ContainsKey(placeHolder.Id.ToString()))
            {
                //Modules
                if (ModuleViewResults.TryGetValue(placeHolder.Id.ToString(), out moduleResult))
                {
                    //sb.Append(moduleResult);
                    ModuleViewResults.Remove(placeHolder.Id.ToString());
                    currentResults.AddRange(moduleResult);
                }
            }

            if (PageContents.Any(pc => pc.ContainerId == placeHolder.Id))
            {
                //Page contents
                var pageContents = PageContents
                                   .Where(pc => pc.ContainerId == placeHolder.Id)
                                   .OrderBy(pc => pc.SortOrder).ToList();
                foreach (var pageContent in pageContents)
                {
                    var typeName           = pageContent.ContentType.Name;
                    var contentTranslation = pageContent.PageContentTranslation.FirstOrDefault(t => t.CultureCode.ToLower() == CurrentCulture.ToString().ToLower());
                    var content            = (contentTranslation != null) ? SDJsonConvert.DeserializeObject <dynamic>(contentTranslation.ContentData) : null;

                    if (content == null)
                    {
                        continue;
                    }
                    var dynamicContent = new DynamicContent
                    {
                        PageContent = pageContent,
                        Content     = content
                    };

                    var contentTypesViewPath = string.Format(Globals.ContentTypesViewPath, _scopeService.PageContext.SelectedTheme, typeName);

                    var htmlPageContent = _htmlHelper.Partial(contentTypesViewPath, dynamicContent);
                    //var contentResult = GetString(htmlContent);
                    currentResults.Add(new ContentResult
                    {
                        //Result = contentResult,
                        HtmlResult = htmlPageContent,
                        SortOrder  = pageContent.SortOrder
                    });
                }
            }

            //var placeHolderResult = RenderContentItems(placeHolder.PlaceHolders);
            //currentResults.Add(new ContentResult
            //{
            //    HtmlResult = placeHolderResult,
            //    SortOrder = placeHolder.SortOrder
            //});

            if (placeHolder.PlaceHolders != null && placeHolder.PlaceHolders.Count > 0)
            {
                foreach (var childPlaceHolder in placeHolder.PlaceHolders)
                {
                    var placeHolderResult = RenderContentItem(childPlaceHolder);
                    currentResults.Add(new ContentResult
                    {
                        HtmlResult = placeHolderResult,
                        SortOrder  = childPlaceHolder.SortOrder
                    });
                }
            }


            var sortedResult = currentResults.OrderBy(r => r.SortOrder).ToList();

            foreach (var contentResult in sortedResult)
            {
                //currentResult += contentResult.Result;
                htmlCurrentResult.AppendHtml(contentResult.HtmlResult);
            }

            var layoutContent = new LayoutContent
            {
                PlaceHolder   = placeHolder,
                ContentResult = htmlCurrentResult
            };

            htmlContentItems = _htmlHelper.Partial(string.Format(Globals.LayoutTypesPath, _scopeService.PageContext.SelectedTheme, layoutType), layoutContent);
            //var layoutResult = GetString(htmlContent);
            //sb.Append(layoutResult);

            return(htmlContentItems);
        }
コード例 #8
0
        public static void CreateMaps()
        {
            if (!IsConfigured())
            {
                Mapper.Initialize(config =>
                {
                    config.CreateMap <ContentPermission, Core.Common.DomainTypes.ContentPermission>().ReverseMap();

                    config.CreateMap <Core.Common.DomainTypes.ContentType, ContentType>()

                    .ForMember(dest => dest.ContentTypeProperties, opt => opt.MapFrom(src => src.Properties.Select(ctp => new ContentTypeProperty
                    {
                        PropertyId    = ctp.Id,
                        ContentTypeId = src.Id,
                        Property      = Mapper.Map <Property>(ctp)
                    }
                                                                                                                   )))
                    .ForMember(dest => dest.ContentTypeProperties, opt => opt.Condition(src => src.Properties != null))
                    .ReverseMap()
                    .ForMember(dest => dest.Properties, opt => opt.MapFrom(src => src.ContentTypeProperties.Select(ctp => ctp.Property)))
                    .ForMember(dest => dest.Properties, opt => opt.Condition(src => src.ContentTypeProperties != null && src.ContentTypeProperties.All(cp => cp.Property != null)));

                    config.CreateMap <Core.Common.DomainTypes.LayoutType, LayoutType>()
                    .ForMember(dest => dest.LayoutTypeProperties, opt => opt.MapFrom(src =>
                                                                                     src.Properties != null ? src.Properties.Select(ctp => new LayoutTypeProperty {
                        PropertyId = ctp.Id, LayoutTypeId = src.Id
                    }) : null))
                    .ReverseMap()
                    .ForMember(dest => dest.Properties, opt => opt.MapFrom(src =>
                                                                           src.LayoutTypeProperties != null ? src.LayoutTypeProperties.Select(ctp => ctp.Property) : null));

                    config.CreateMap <Core.Common.DomainTypes.Module, Module>().ReverseMap();

                    config.CreateMap <ModuleAction, Core.Common.DomainTypes.ModuleAction>()
                    .ForMember(dest => dest.Properties, opt => opt.MapFrom(src => src.ModuleActionProperties != null ? src.ModuleActionProperties.Select(ctp => ctp.Property) : null))
                    .ReverseMap()
                    .ForMember(dest => dest.ModuleActionProperties, opt => opt.MapFrom(src => src.Properties != null ? src.Properties.Select(macp => new ModuleActionProperty {
                        PropertyId = macp.Id, ModuleActionId = src.Id
                    }) : null));

                    //config.CreateMap<Core.Common.DomainTypes.Module, Module>()
                    // .ForMember(dest => dest.ModuleProperties, opt => opt.MapFrom(src =>
                    //    src.Properties != null ? src.Properties.Select(ctp => new ModuleProperty { PropertyId = ctp.Id, ModuleId = src.Id }) : null))
                    //.ReverseMap()
                    //.ForMember(dest => dest.Properties, opt => opt.MapFrom(src =>
                    //  src.ModuleProperties != null ? src.ModuleProperties.Select(ctp => ctp.Property) : null));

                    config.CreateMap <ModuleActionType, Core.Common.DomainTypes.ModuleActionType>().ReverseMap();
                    config.CreateMap <ModulePermission, Core.Common.DomainTypes.ModulePermission>().ReverseMap();

                    config.CreateMap <PageContent, Core.Common.DomainTypes.PageContent>()
                    .ForMember(dest => dest.Properties, opt =>
                               opt.MapFrom(src => !string.IsNullOrEmpty(src.Properties) ? SDJsonConvert.DeserializeObject <List <Core.Common.DomainTypes.Property> >(src.Properties) : null))
                    .ReverseMap()
                    .ForMember(dest => dest.Properties, opt =>
                               opt.MapFrom(src => (src.Properties != null) ? SDJsonConvert.SerializeObject(src.Properties) : null));

                    config.CreateMap <Language, Core.Common.DomainTypes.Language>().ReverseMap();
                    config.CreateMap <Layout, Core.Common.DomainTypes.Layout>().ReverseMap();
                    config.CreateMap <Core.Common.DomainTypes.Layout, Core.Common.DomainTypes.PageLayout>().ReverseMap();
                    config.CreateMap <Page, Core.Common.DomainTypes.Page>()
                    .MaxDepth(10)
                    .ReverseMap()
                    .MaxDepth(10);

                    config.CreateMap <PageType, Core.Common.DomainTypes.PageType>().ReverseMap();

                    config.CreateMap <PageContentTranslation, Core.Common.DomainTypes.PageContentTranslation>().ReverseMap();

                    config.CreateMap <PageModule, Core.Common.DomainTypes.PageModule>()
                    .ForMember(dest => dest.Properties, opt =>
                               opt.MapFrom(src => !string.IsNullOrEmpty(src.Properties) ? SDJsonConvert.DeserializeObject <ICollection <Core.Common.DomainTypes.Property> >(src.Properties) : null))
                    .ReverseMap()
                    .ForMember(dest => dest.Properties, opt =>
                               opt.MapFrom(src => (src.Properties != null) ? SDJsonConvert.SerializeObject(src.Properties) : null));


                    config.CreateMap <PagePermission, Core.Common.DomainTypes.PagePermission>()
                    .ReverseMap();

                    config.CreateMap <PageTranslation, Core.Common.DomainTypes.PageTranslation>()
                    .ReverseMap();


                    config.CreateMap <Permission, Core.Common.DomainTypes.Permission>().ReverseMap();
                    config.CreateMap <Property, Core.Common.DomainTypes.Property>().ReverseMap();

                    config.CreateMap <OptionList, Core.Common.DomainTypes.OptionList>()
                    .ForMember(dest => dest.List, opt =>
                               opt.MapFrom(src => !string.IsNullOrEmpty(src.List) ? SDJsonConvert.DeserializeObject <List <Core.Common.DomainTypes.PropertyOption> >(src.List) : null))
                    .ReverseMap()
                    .ForMember(dest => dest.List, opt =>
                               opt.MapFrom(src => (src.List != null) ? SDJsonConvert.SerializeObject(src.List) : null));

                    config.CreateMap <Role, Core.Common.DomainTypes.Role>().ReverseMap();

                    //Roles from db needs to be ignored, because User.Roles is not Role type, it is UserRole - join entity.
                    config.CreateMap <User, Core.Common.DomainTypes.User>()
                    .ForMember(dest => dest.Roles, opt => opt.Ignore())
                    .ReverseMap()
                    .ForMember(dest => dest.UserRoles, opt => opt.Ignore());

                    config.CreateMap <SiteSetting, Core.Common.DomainTypes.SiteSetting>().ReverseMap();
                });
            }
        }