special.cs

动易SiteFactory&#8482 网上商店系统1.0源代码

namespace PowerEasy.Contents
{
    using PowerEasy.AccessManage;
    using PowerEasy.Common;
    using PowerEasy.Components;
    using PowerEasy.Enumerations;
    using PowerEasy.IDal.Contents;
    using PowerEasy.Model.Contents;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Web;

    public sealed class Special
    {
        private static readonly ISpecial dal = DataAccess.CreateSpecial();

        private Special()
        {
        }

        public static bool AddContentToSpecialInfos(int specialId, string generalIds)
        {
            if (!DataValidator.IsValidId(generalIds))
            {
                return false;
            }
            foreach (string str in generalIds.Split(new char[] { ',' }))
            {
                int generalId = DataConverter.CLng(str);
                if (!ExistInSpecialInfos(specialId, generalId) && !dal.AddToSpecialInfos(specialId, generalId))
                {
                    return false;
                }
            }
            return true;
        }

        public static bool AddContentToSpecialInfos(string specialIds, string generalIds)
        {
            bool flag2 = true;
            if (!DataValidator.IsValidId(specialIds))
            {
                return false;
            }
            if (!DataValidator.IsValidId(generalIds))
            {
                return false;
            }
            string[] strArray = specialIds.Split(new char[] { ',' });
            string[] strArray2 = generalIds.Split(new char[] { ',' });
            foreach (string str in strArray)
            {
                foreach (string str2 in strArray2)
                {
                    int specialId = DataConverter.CLng(str);
                    int generalId = DataConverter.CLng(str2);
                    if (!ExistInSpecialInfos(specialId, generalId) && !dal.AddToSpecialInfos(specialId, generalId))
                    {
                        flag2 = false;
                        break;
                    }
                }
            }
            return flag2;
        }

        public static bool AddSpecial(SpecialInfo specialInfo)
        {
            RolePermissions.AccessCheck(OperateCode.SpecialManage);
            EncodeSpecialInfo(specialInfo);
            return dal.AddSpecial(specialInfo);
        }

        public static bool AddSpecialCategory(SpecialCategoryInfo specialCategoryInfo)
        {
            EncodeSpecialCategoryInfo(specialCategoryInfo);
            return dal.AddSpecialCategory(specialCategoryInfo);
        }

        public static bool AddToSpecialInfos(string specialIds, int generalId)
        {
            if (!DataValidator.IsValidId(specialIds))
            {
                return false;
            }
            string[] strArray = specialIds.Split(new char[] { ',' });
            for (int i = 0; i < strArray.Length; i++)
            {
                if (!AddContentToSpecialInfos(DataConverter.CLng(strArray[i]), generalId.ToString()))
                {
                    return false;
                }
            }
            return true;
        }

        private static void DecodeSpecialCategoryInfo(SpecialCategoryInfo specialCategoryInfo)
        {
            if (!specialCategoryInfo.IsNull)
            {
                specialCategoryInfo.SpecialCategoryName = DataSecurity.HtmlDecode(specialCategoryInfo.SpecialCategoryName);
                specialCategoryInfo.SpecialCategoryDir = DataSecurity.HtmlDecode(specialCategoryInfo.SpecialCategoryDir);
                specialCategoryInfo.SpecialTemplatePath = DataSecurity.HtmlDecode(specialCategoryInfo.SpecialTemplatePath);
                specialCategoryInfo.SearchTemplatePath = DataSecurity.HtmlDecode(specialCategoryInfo.SearchTemplatePath);
                specialCategoryInfo.Description = DataSecurity.HtmlDecode(specialCategoryInfo.Description);
            }
        }

        private static void DecodeSpecialInfo(SpecialInfo specialInfo)
        {
            if (specialInfo != null)
            {
                specialInfo.SpecialName = DataSecurity.HtmlDecode(specialInfo.SpecialName);
                specialInfo.SpecialDir = DataSecurity.HtmlDecode(specialInfo.SpecialDir);
                specialInfo.SpecialIdentifier = DataSecurity.HtmlDecode(specialInfo.SpecialIdentifier);
                specialInfo.SpecialPic = DataSecurity.HtmlDecode(specialInfo.SpecialPic);
                specialInfo.SpecialTips = DataSecurity.HtmlDecode(specialInfo.SpecialTips);
                specialInfo.SpecialTemplatePath = DataSecurity.HtmlDecode(specialInfo.SpecialTemplatePath);
                specialInfo.SearchTemplatePath = DataSecurity.HtmlDecode(specialInfo.SearchTemplatePath);
                specialInfo.Description = DataSecurity.HtmlDecode(specialInfo.Description);
                specialInfo.CustomContent = DataSecurity.HtmlDecode(specialInfo.CustomContent);
            }
        }

        private static void DeleteFolder(int specialId)
        {
            SpecialInfo specialInfoById = GetSpecialInfoById(specialId);
            SpecialCategoryInfo specialCategoryInfoById = GetSpecialCategoryInfoById(specialInfoById.SpecialCategoryId);
            string str = VirtualPathUtility.AppendTrailingSlash(SiteConfig.SiteOption.CreateHtmlPath) + VirtualPathUtility.AppendTrailingSlash(specialCategoryInfoById.SpecialCategoryDir) + specialInfoById.SpecialDir;
            string file = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, str);
            if (FileSystemObject.IsExist(file, FsoMethod.Folder))
            {
                FileSystemObject.Delete(file, FsoMethod.Folder);
            }
        }

        public static bool DeleteSpecialById(int specialId)
        {
            RolePermissions.AccessCheck(OperateCode.SpecialManage);
            DeleteFolder(specialId);
            DeleteSpecialInfoBySpecialId(specialId);
            return dal.DeleteSpecial(specialId);
        }

        public static bool DeleteSpecialCategoryById(int specialCategoryId)
        {
            RolePermissions.AccessCheck(OperateCode.SpecialManage);
            DeleteSpecialCategoryFolder(specialCategoryId);
            foreach (SpecialInfo info in GetSpecialList(specialCategoryId))
            {
                DeleteSpecialById(info.SpecialId);
            }
            return dal.DeleteSpecialCategoryById(specialCategoryId);
        }

        private static void DeleteSpecialCategoryFolder(int specialCategoryId)
        {
            SpecialCategoryInfo specialCategoryInfoById = GetSpecialCategoryInfoById(specialCategoryId);
            string str = VirtualPathUtility.AppendTrailingSlash(SiteConfig.SiteOption.CreateHtmlPath) + specialCategoryInfoById.SpecialCategoryDir;
            string file = Path.Combine(HttpContext.Current.Request.PhysicalApplicationPath, str);
            if (FileSystemObject.IsExist(file, FsoMethod.Folder))
            {
                FileSystemObject.Delete(file, FsoMethod.Folder);
            }
        }

        public static bool DeleteSpecialIdInSpecialInfos(string specialIds)
        {
            if (!DataValidator.IsValidId(specialIds))
            {
                return false;
            }
            return dal.DeleteSpecialIdInSpecialInfos(specialIds);
        }

        public static bool DeleteSpecialInfoById(string specialInfoIds)
        {
            if (!DataValidator.IsValidId(specialInfoIds))
            {
                return false;
            }
            return dal.DeleteSpecialInfoById(specialInfoIds);
        }

        public static bool DeleteSpecialInfoById(string specialInfoIds, int specialId)
        {
            if (!DataValidator.IsValidId(specialInfoIds))
            {
                return false;
            }
            return dal.DeleteSpecialInfoById(specialInfoIds, specialId);
        }

        public static bool DeleteSpecialInfoBySpecialId(int specialId)
        {
            return dal.DeleteSpecialInfoBySpecialId(specialId);
        }

        public static bool DeleteSpecialInfos(int generalId)
        {
            return dal.DeleteSpecialInfos(generalId);
        }

        private static void EncodeSpecialCategoryInfo(SpecialCategoryInfo specialCategoryInfo)
        {
            if (specialCategoryInfo != null)
            {
                specialCategoryInfo.SpecialCategoryName = DataSecurity.HtmlEncode(specialCategoryInfo.SpecialCategoryName);
                specialCategoryInfo.SpecialCategoryDir = DataSecurity.HtmlEncode(specialCategoryInfo.SpecialCategoryDir);
                specialCategoryInfo.SpecialTemplatePath = DataSecurity.HtmlEncode(specialCategoryInfo.SpecialTemplatePath);
                specialCategoryInfo.SearchTemplatePath = DataSecurity.HtmlEncode(specialCategoryInfo.SearchTemplatePath);
                specialCategoryInfo.Description = DataSecurity.HtmlEncode(specialCategoryInfo.Description);
            }
        }

        private static void EncodeSpecialInfo(SpecialInfo specialInfo)
        {
            if (specialInfo != null)
            {
                specialInfo.SpecialName = DataSecurity.HtmlEncode(specialInfo.SpecialName);
                specialInfo.SpecialDir = DataSecurity.HtmlEncode(specialInfo.SpecialDir);
                specialInfo.SpecialIdentifier = DataSecurity.HtmlEncode(specialInfo.SpecialIdentifier);
                specialInfo.SpecialPic = DataSecurity.HtmlEncode(specialInfo.SpecialPic);
                specialInfo.SpecialTips = DataSecurity.HtmlEncode(specialInfo.SpecialTips);
                specialInfo.SpecialTemplatePath = DataSecurity.HtmlEncode(specialInfo.SpecialTemplatePath);
                specialInfo.SearchTemplatePath = DataSecurity.HtmlEncode(specialInfo.SearchTemplatePath);
                specialInfo.Description = DataSecurity.HtmlEncode(specialInfo.Description);
                specialInfo.CustomContent = DataSecurity.HtmlEncode(specialInfo.CustomContent);
            }
        }

        public static bool ExistInSpecialInfos(int generalId)
        {
            return dal.ExistInSpecialInfos(generalId);
        }

        public static bool ExistInSpecialInfos(int specialId, int generalId)
        {
            return dal.ExistInSpecialInfos(specialId, generalId);
        }

        public static bool ExistsSpecialCategoryIdInSpecials(int specialCategoryId)
        {
            return dal.ExistsSpecialCategoryIdInSpecials(specialCategoryId);
        }

        public static bool ExistsSpecialCategoryName(string specialCategoryName)
        {
            return dal.ExistsSpecialCategoryName(specialCategoryName);
        }

        public static bool ExistsSpecialDir(string specialDir)
        {
            return dal.ExistsSpecialDir(specialDir);
        }

        public static bool ExistsSpecialName(string specialName)
        {
            return dal.ExistsSpecialName(specialName);
        }

        public static int GetCountSpecial(int specialCategoryId)
        {
            return dal.GetCountSpecial(specialCategoryId);
        }

        public static string GetGeneralIdBySpecialId(string specialId)
        {
            return dal.GetGeneralIdBySpecialId(specialId);
        }

        public static string GetGeneralIdBySpecialInfoId(string specialInfoId)
        {
            string generalIdBySpecialInfoId = "";
            if (DataValidator.IsValidId(specialInfoId))
            {
                generalIdBySpecialInfoId = dal.GetGeneralIdBySpecialInfoId(specialInfoId);
            }
            return generalIdBySpecialInfoId;