24Hour.Service/24Hour/Controllers/Common/ReservationController.cs

using Elight.Entity;
using Elight.Logic;
using Elight.Utility;
using Elight.Utility.Code;
using Elight.Utility.Extensions;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;

namespace _24Hour.Controllers.Common
{
    /// <summary>
    /// 预约接待
    /// </summary>
    [Authorize]
    [ApiController]
    [Route("api/reception")]
    public class ReservationController : Controller
    {
        #region Identity
        private readonly SqlSugarClient _db;//数据库
        private readonly WriteSysLog _logs;//操作日志
        App_Sys_UserModel _userdata = new App_Sys_UserModel();//当前用户
        private readonly ILogger<LoginController> _logger;//日志
        Result result = new Result();
        public ReservationController(ILogger<LoginController> logger, SqlSugarClient db, WriteSysLog logs, User user)
        {
            _logger = logger;
            _db = db;
            _logs = logs;
            _userdata = user.Userdata();
        }

        #endregion


        #region 预约接待管理
        /// <summary>
        /// 预约接待分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryReception")]
        public async Task<Result> QueryReception(App_ReceptionInput Reception)
        {
            var Receptionlist = new List<App_ReceptionModel>();
            //获取工作台信息
            var app_staging = await _db.Queryable<StagingModel>().Where(w => w.IsDelete == 0).ToListAsync();
            //查询预约接待记录
            var list = await _db.Queryable<App_ReceptionModel>()
                .WhereIF(!string.IsNullOrEmpty(Reception.depart), q => q.depart.Contains(Reception.depart))
                .WhereIF(!string.IsNullOrEmpty(Reception.createusername), q => q.createusername.Contains(Reception.createusername))
                .WhereIF(!string.IsNullOrEmpty(Reception.receptionId), q => q.receptionId.Contains(Reception.receptionId))
                .WhereIF(Reception.state != null, q => q.state == Reception.state)
                .Where(q => q.IsDelete == 0).ToPageListAsync(Reception.PageIndex, Reception.PageSize);
            list.ForEach(q =>
            {
                var data = app_staging.Where(a => a.Id == q.receptionId).FirstOrDefault();
                if (data != null)
                {
                    q.receptionId = data.title;
                    Receptionlist.Add(q);
                }
            });
            var data = new QueryResult<App_ReceptionModel>(Reception, Receptionlist.OrderByDescending(q => q.creationtime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }
        /// <summary>
        /// 添加预约接待
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddReception")]
        public async Task<Result> AddReception(App_ReceptionModel Receptiondata)
        {
            try
            {
                _db.BeginTran();
                Receptiondata.Id = Guid.NewGuid().ToString();
                Receptiondata.createuserId = _userdata.Id.ToString();
                Receptiondata.createusername = _userdata.name;
                var num = await _db.Insertable(Receptiondata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("预约管理", "添加预约接待信息", result,_db);
            return result;
        }

        /// <summary>
        /// 修改预约接待
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateReception")]
        public async Task<Result> UpdateReception(App_ReceptionModel Receptiondata)
        {
            try
            {
                _db.BeginTran();
                var num = await _db.Updateable(Receptiondata).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("预约管理", "修改预约接待", result,_db);
            return result;
        }

        /// <summary>
        /// 删除预约接待
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteReception")]
        public async Task<Result> DeleteReception(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Receptionlist = await _db.Queryable<App_ReceptionModel>().In(q => q.Id, Currency.id).ToListAsync();
                Receptionlist.ForEach(q =>
                {
                    q.IsDelete = 1;
                });
                var num = await _db.Updateable(Receptionlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("预约管理", "删除预约接待", result,_db);
            return result;
        }


        /// <summary>
        /// 办理预约接待
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateReception_state")]
        public async Task<Result> UpdateReception_state(CurrencyDelete Currency)
        {
            try
            {
                var Receptionlist = await _db.Queryable<App_ReceptionModel>().Where(q => Currency.id.Contains(q.Id)).ToListAsync();
                Receptionlist.ForEach(q => { q.state = 1; });
                _db.BeginTran();
                var num = await _db.Updateable(Receptionlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "办理成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("预约管理", "办理预约接待", result,_db);
            return result;
        }
        #endregion

        #region 远程会见管理

        /// <summary>
        /// 根据当前登录人查询远程会见信息分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryRemoteuser")]
        public async Task<Result> QueryRemoteuser(App_RemoteInput Remotedata)
        {
            var Receptionlist = new List<App_RemoteModel>();
            //查询远程会见记录
            var list = await _db.Queryable<App_RemoteModel>()
                .WhereIF(Remotedata.Code != null, q => q.Code.Contains(Remotedata.Code))
                .WhereIF(Remotedata.name != null, q => q.name.Contains(Remotedata.name))
                .WhereIF(Remotedata.meetwitname != null, q => q.meetwitname.Contains(Remotedata.meetwitname))
                .WhereIF(Remotedata.state != null, q => q.state == Remotedata.state)
                .Where(q => q.IsDeleted == 0&&q.unitId==_userdata.unitCode).ToPageListAsync(Remotedata.PageIndex, Remotedata.PageSize);
            var data = new QueryResult<App_RemoteModel>(Remotedata, list.OrderByDescending(q => q.creationtime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }

        /// <summary>
        /// 远程会见分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryRemote")]
        public async Task<Result> QueryRemote(App_RemoteInput Remotedata)
        {
            var Receptionlist = new List<App_RemoteModel>();
            //查询远程会见记录
            var list = await _db.Queryable<App_RemoteModel>()
                .WhereIF(Remotedata.Code != null, q => q.Code.Contains(Remotedata.Code))
                .WhereIF(Remotedata.name != null, q => q.name.Contains(Remotedata.name))
                .WhereIF(Remotedata.meetwitname != null, q => q.meetwitname.Contains(Remotedata.meetwitname))
                .WhereIF(Remotedata.state != null, q => q.state == Remotedata.state)
                .Where(q => q.IsDeleted == 0).ToPageListAsync(Remotedata.PageIndex, Remotedata.PageSize);
            var data = new QueryResult<App_RemoteModel>(Remotedata, list.OrderByDescending(q => q.creationtime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }
        /// <summary>
        /// 添加远程会见
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddRemote")]
        public async Task<Result> AddRemote(App_RemoteModel Remotedata)
        {
            try
            {
                _db.BeginTran();
                Remotedata.Id = Guid.NewGuid().ToString();
                Remotedata.unitId = _userdata.unitCode.ToString();
                Remotedata.createuserId = _userdata.Id.ToString();
                Remotedata.createusername = _userdata.name;
                var num = await _db.Insertable(Remotedata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("远程会见管理", "添加远程会见", result, _db);
            return result;
        }

        /// <summary>
        /// 修改远程会见
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateRemote")]
        public async Task<Result> UpdateRemote(App_RemoteModel Remotedata)
        {
            try
            {
                _db.BeginTran();
                var num = await _db.Updateable(Remotedata).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("远程会见管理", "修改远程会见", result, _db);
            return result;
        }

        /// <summary>
        /// 删除远程会见
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteRemote")]
        public async Task<Result> DeleteRemote(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Receptionlist = await _db.Queryable<App_RemoteModel>().In(q => q.Id, Currency.id).ToListAsync();
                Receptionlist.ForEach(q =>
                {
                    q.IsDeleted = 1;
                });
                var num = await _db.Updateable(Receptionlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("远程会见管理", "删除远程会见", result, _db);
            return result;
        }


        /// <summary>
        /// 结束远程会见
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateRemote_state")]
        public async Task<Result> UpdateRemote_state(CurrencyDelete Currency)
        {
            try
            {
                var Receptionlist = await _db.Queryable<App_RemoteModel>().Where(q => Currency.id.Contains(q.Id)).ToListAsync();
                Receptionlist.ForEach(q => { q.state = 1; });
                _db.BeginTran();
                var num = await _db.Updateable(Receptionlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "结束成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("远程会见管理", "结束远程会见", result, _db);
            return result;
        }


        /// <summary>
        /// 取消远程会见
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("Updatecancellation_state")]
        public async Task<Result> Updatecancellation_state(CurrencyDelete Currency)
        {
            try
            {
                var Receptionlist = await _db.Queryable<App_RemoteModel>().Where(q => Currency.id.Contains(q.Id)).ToListAsync();
                Receptionlist.ForEach(q => { q.state = 2; });
                _db.BeginTran();
                var num = await _db.Updateable(Receptionlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "已取消";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("远程会见管理", "取消远程会见", result, _db);
            return result;
        }
        #endregion

        #region 设备管理
        /// <summary>
        /// 根据当前登录人查询设备信息分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryDeviceuser")]
        public async Task<Result> QueryDeviceuser(App_DeviceInput Devicedata)
        {
            var Receptionlist = new List<App_RemoteModel>();
            //查询远程会见记录
            var list = await _db.Queryable<App_RemoteModel>()
                .WhereIF(Devicedata.deviceno != null, q => q.Code.Contains(Devicedata.deviceno))
                .WhereIF(Devicedata.name != null, q => q.name.Contains(Devicedata.name))
                .WhereIF(Devicedata.state != null, q => q.state == Devicedata.state)
                .Where(q => q.IsDeleted == 0 && q.unitId == _userdata.unitCode).ToPageListAsync(Devicedata.PageIndex, Devicedata.PageSize);
            var data = new QueryResult<App_RemoteModel>(Devicedata, list.OrderByDescending(q => q.creationtime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }

        /// <summary>
        /// 设备分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryDevice")]
        public async Task<Result> QueryDevice(App_DeviceInput Devicedata)
        {
            var Receptionlist = new List<App_DeviceModel>();
            //查询远程会见记录
            var list = await _db.Queryable<App_DeviceModel>()
                .WhereIF(Devicedata.deviceno != null, q => q.deviceno.Contains(Devicedata.deviceno))
                .WhereIF(Devicedata.name != null, q => q.name.Contains(Devicedata.name))
                .WhereIF(Devicedata.state != null, q => q.state == Devicedata.state)
                .Where(q => q.IsDeleted == 0).ToPageListAsync(Devicedata.PageIndex, Devicedata.PageSize);
            var data = new QueryResult<App_DeviceModel>(Devicedata, list.OrderByDescending(q => q.creationtime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }
        /// <summary>
        /// 添加设备
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddDevice")]
        public async Task<Result> AddDevice(App_DeviceModel Devicedata)
        {
            try
            {
                _db.BeginTran();
                Devicedata.Id = Guid.NewGuid().ToString();
                Devicedata.unitId = _userdata.unitCode.ToString();
                Devicedata.createuserId = _userdata.Id.ToString();
                Devicedata.createusername = _userdata.name;
                var num = await _db.Insertable(Devicedata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("远程会见管理", "添加远程会见", result, _db);
            return result;
        }

        /// <summary>
        /// 修改设备
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateDevice")]
        public async Task<Result> UpdateDevice(App_DeviceModel Devicedata)
        {
            try
            {
                _db.BeginTran();
                var num = await _db.Updateable(Devicedata).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("远程会见管理", "修改远程会见", result, _db);
            return result;
        }

        /// <summary>
        /// 删除设备
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteDevice")]
        public async Task<Result> DeleteDevice(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Receptionlist = await _db.Queryable<App_DeviceModel>().In(q => q.Id, Currency.id).ToListAsync();
                Receptionlist.ForEach(q =>
                {
                    q.IsDeleted = 1;
                });
                var num = await _db.Updateable(Receptionlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("设备管理", "删除设备", result, _db);
            return result;
        }
        #endregion
    }
}