LegalServiceV1/SourceCode/V2/ContractService/ContractService.Web/Controllers/BaseSystemController.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web;
using System.Web.Mvc;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.MultiTenancy;
using Abp.Runtime.Caching;
using Abp.Timing;
using Abp.Web.Models;
using Abp.Web.Mvc.Authorization;
using Abp.Web.Security.AntiForgery;
using ContractService.Authorization;
using ContractService.Authorization.Roles;
using ContractService.BaseInfo;
using ContractService.BaseSystem.AuditLog;
using ContractService.BaseSystem.Sessions.Dto;
using ContractService.Configuration;
using IwbZero.Auditing;
using IwbZero.Authorization.Base.Users;
using IwbZero.ToolCommon.LogHelpers;
using IwbZero.ToolCommon.StringModel;

namespace ContractService.Controllers
{
    [DisableAuditing]
    [AbpMvcAuthorize(PermissionNames.PagesSystemMg)]
    public class BaseSystemController : IwbControllerBase
    {

        public BaseSystemController(ICacheManager cacheManager, IRepository<Role> roleRepository, IRepository<SysFunction> functionRepository, IAuditLogsAppService logsAppService)
        {
            RoleRepository = roleRepository;
            FunctionRepository = functionRepository;
            LogsAppService = logsAppService;
            CacheManager = cacheManager;
        }
        private IRepository<Role> RoleRepository { get; }
        private IRepository<SysFunction> FunctionRepository { get; }
        private IAuditLogsAppService LogsAppService { get; }


        [AbpMvcAuthorize(PermissionNames.PagesSystemMgTenantMg)]
        public async Task<ActionResult> SysTenants()
        {
            if (AbpSession.MultiTenancySide != MultiTenancySides.Host)
            {
                ThrowError(IwbLanguageMessage.NoPermissionOperation);
            }
            ViewBag.IsActive = await StatesManager.GetSelectListAsync("Active", "Status");
            return View();
        }

        [AbpMvcAuthorize(PermissionNames.PagesSystemMgRoleMg)]
        public async Task<ActionResult> SysRoles()
        {
            var user = AbpSession.GetCurrentUser();
            ViewBag.IsActive = await StatesManager.GetSelectListAsync("Active", "Status");
            ViewBag.RoleType = await StatesManager.GetSelectListAsync("UserRole", "UserRoleType");
            var accountType = await StatesManager.GetSelectListAsync("Account", "AccountType");
            ViewBag.AccountType = accountType;
            ViewBag.AccountTypeName = accountType.FirstOrDefault(a => a.Value == (user.AccountType + ""))?.Text ?? "";
            ViewBag.CurrentUser = user;
            return View();
        }

        [AbpMvcAuthorize(PermissionNames.PagesSystemMgUserMg)]
        public async Task<ActionResult> SysUsers()
        {
            var user = AbpSession.GetCurrentUser();
            ViewBag.IsActive = await StatesManager.GetSelectListAsync("Active", "Status");
            ViewBag.UserType = await StatesManager.GetSelectListAsync("UserRole", "UserRoleType");
            var accountType = await StatesManager.GetSelectListAsync("Account", "AccountType");
            ViewBag.AccountType = accountType;
            ViewBag.AccountTypeName = accountType.FirstOrDefault(a => a.Value == (user.AccountType + ""))?.Text ?? "";
            ViewBag.CurrentUser = user;
            if (AbpSession.UserType == UsersAndRolesTypeDefinition.Supper ||
                AbpSession.UserType == UsersAndRolesTypeDefinition.System)
            {
                var sList = new List<SelectListItem>();
                var list = RoleRepository.GetAllList(a =>
                    (AbpSession.UserName == UserBase.AdminUserName || a.RoleType > AbpSession.UserType) &&
                    (AbpSession.AccountType == AccountTypeDefinition.System || a.AccountType == AbpSession.AccountType));
                foreach (var l in list)
                {
                    sList.Add(new SelectListItem { Text = l.DisplayName, Value = l.Name });
                }

                ViewBag.Roles = sList;
            }
            return View();
        }

        [AbpMvcAuthorize(PermissionNames.PagesSystemMgStateMg)]
        public ActionResult SysStates()
        {
            return View();
        }

        [AbpMvcAuthorize(PermissionNames.PagesSystemMgSettingMg)]
        public ActionResult SysSettings()
        {
            return View();
        }

        [AbpMvcAuthorize(PermissionNames.PagesSystemMgFunctionMg)]
        public async Task<ActionResult> SysFunctions()
        {
            ViewBag.FunctionType = await StatesManager.GetSelectListAsync("Function", "FunctionType");
            return View();
        }

        [AbpMvcAuthorize(PermissionNames.PagesSystemMgLogMg)]
        public ActionResult SysLogs()
        {
            ViewBag.ServiceNames = LogsAppService.GetLogServiceSelectListStrs();
            return View();
        }
        [AbpAllowAnonymous]
        public ActionResult Notification()
        {
            return View();
        }
        [AbpMvcAuthorize(PermissionNames.PagesSystemMgHelpMg)]
        public async Task<ActionResult> SysHelps()
        {
            ViewBag.Classification = await StatesManager.GetSelectListAsync("SysHelp", "Classification");
            var funs = await FunctionRepository.GetAllListAsync(a =>
                a.FunctionType == FunctionTypeDefinition.Catalog || a.FunctionType == FunctionTypeDefinition.Menu);
            ViewBag.FunctionMenu = "";
            foreach (var fun in funs)
            {
                ViewBag.FunctionMenu += fun.ParentNo == "0"
                    ? $"<option value=\"{fun.FunctionNo}\"  disabled selected>{fun.FunctionName}</option>"
                    : $"<option value=\"{fun.FunctionNo}\" parent=\"{fun.ParentNo}\">{fun.FunctionName}</option>";
            }
            return View();
        }


        [DisableAbpAntiForgeryTokenValidation]
        [DontWrapResult]
        public ActionResult KindEditorUploadFile()
        {
            try
            {
                if (!int.TryParse(SettingManager.GetValue(IwbSettingNames.UploadFileMaxSize), out int maxSize))
                {
                    maxSize = 10;
                }
                maxSize = maxSize < 1 ? 1 : maxSize > 100 ? 100 : maxSize;
                HttpPostedFileBase file = Request.Files["imgFile"];
                if (file == null)
                {
                    return Json(new { error = 1, message = L("FileUploadNoFile") });
                }
                if (file.ContentLength >= 1024 * 1024 * maxSize)
                {
                    return Json(new { error = 1, message = string.Format(L("FileUploadMaxSize"), $"{maxSize}M") });
                }
                var fileName = $"{Clock.Now:yyyyMMddHHmmss}_{file.FileName}";
                string lcPath = SettingManager.GetValue(IwbSettingNames.DownloadPath) + "/KindEditorUploadFile";
                string dir = Request["dir"];
                if (!string.IsNullOrEmpty(dir))
                {
                    lcPath = Path.Combine(lcPath, dir);
                }
                var filePath = Server.MapPath($"~/{lcPath}");
                if (!Directory.Exists(filePath))
                {
                    Directory.CreateDirectory(filePath);
                }
                file.SaveAs(Path.Combine(filePath, fileName));
                return Json(new { error = 0, url = Path.Combine(lcPath, fileName), fileName = file.FileName }, "text/html;charset=UTF-8");
            }
            catch (Exception e)
            {
                this.LogError(e);
                return Json(new { error = 1, message = L("FileUploadException") }, "text/html;charset=UTF-8");

            }
        }
    }

    [DisableAuditing]
    [AbpMvcAuthorize(PermissionNames.PagesUserHelpInfo)]
    public class HelpController : IwbControllerBase
    {
        public HelpController(IRepository<SysHelp> helpRepository)
        {
            HelpRepository = helpRepository;
        }

        private IRepository<SysHelp> HelpRepository { get; }
        [AbpMvcAuthorize(PermissionNames.PagesUserHelpInfo)]
        public async Task<ActionResult> Index()
        {
            var helps = (await HelpRepository.GetAllListAsync()).OrderBy(a => a.Sequence).ToList();
            return View(helps);
        }
    }
}