IotCloudPlatform/IoTIntegrationPlatform/IoTIntegrationPlatform.Services/TaskSchedulingService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using SqlSugar;
using IoTIntegrationPlatform.Common;
using IoTIntegrationPlatform.Interface;
using IoTIntegrationPlatform.Model.common;
using IoTIntegrationPlatform.Model.Model;

namespace IoTIntegrationPlatform.Services
{
    public class TaskSchedulingService : ITaskSchedulingService
    {
        private ISqlSugarClient db { get; }
        public TaskSchedulingService(ISqlSugarClient _db)
        {
            db = _db;
        }

        #region 类句柄操作
        private IntPtr handle;
        private bool disposed = false;
        //关闭句柄
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1060:MovePInvokesToNativeMethodsClass"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Interoperability", "CA1401:PInvokesShouldNotBeVisible"), System.Runtime.InteropServices.DllImport("Kernel32")]
        public extern static Boolean CloseHandle(IntPtr handle);


        /// <summary>
        /// 释放对象资源
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// 释放对象资源
        /// </summary>
        /// <param name="disposing"></param>
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (handle != IntPtr.Zero)
                {
                    CloseHandle(handle);
                    handle = IntPtr.Zero;
                }
            }
            disposed = true;
        }
        ~TaskSchedulingService()
        {
            Dispose(false);
        }

        #endregion

        #region 任务调度信息

        /// <summary>
        /// 获取任务信息
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public ScheduledTaskInfo GetTaskInfo(BaseParm parm)
        {
            ScheduledTaskInfo model = new ScheduledTaskInfo();
            try
            {
                model = db.Queryable<ScheduledTaskInfo>()
                  .WhereIF(!string.IsNullOrEmpty(parm.Param), it => it.TaskName == parm.Param)
                  .WhereIF(!string.IsNullOrEmpty(parm.Param1), it => it.GroupName == parm.Param1)
                  .First();
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "GetTaskInfo");
            }
            return model;
        }

        /// <summary>
        /// 获取定时任务列表
        /// </summary>
        /// <param name="device_id"></param>
        /// <param name="user_id"></param>
        /// <param name="bassid"></param>
        /// <returns></returns>
        public List<ScheduledTaskInfo> GetTakList()
        {
            List<ScheduledTaskInfo> list = new List<ScheduledTaskInfo>();
            try
            {

                list = db.Queryable<ScheduledTaskInfo>().ToList();
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "GetTakList");
            }
            return list;
        }

        /// <summary>
        /// 获取定时任务列表[分页]
        /// </summary>
        /// <param name="parm"></param>
        /// <param name="page"></param>
        /// <returns></returns>
        public List<ScheduledTaskInfo> GetTakList(BaseParm parm, ref int page)
        {
            List<ScheduledTaskInfo> list = new List<ScheduledTaskInfo>();
            try
            {
                list = db.Queryable<ScheduledTaskInfo>()
                    .WhereIF(!string.IsNullOrEmpty(parm.Name), it => it.TaskName.Contains(parm.Name))
                    .ToPageList(parm.PageIndex, parm.PageSize, ref page);
            }
            catch (Exception ex)
            {
                Logging.Error(ex, ex.Message);
            }
            return list;
        }

        /// <summary>
        /// 添加任务
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ScheduledTaskInfo AddTask(ScheduledTaskInfo model)
        {
            try
            {
                model.Id = db.Insertable(model).ExecuteReturnIdentity();
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "AddTask");
            }
            return model;
        }

        /// <summary>
        /// 编辑任务
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdateTask(ScheduledTaskInfo model)
        {
            bool result = false;
            try
            {

                ScheduledTaskInfo oldModel=db.Queryable<ScheduledTaskInfo>().First(it=>it.Id==model.Id);
                model.LastRunTime = oldModel.LastRunTime;
                var row = db.Updateable(model).IgnoreColumns(it => new { it.Id }).Where(it=>it.Id==model.Id).ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "UpdateTask");
            }
            return result;
        }

        /// <summary>
        /// 编辑定时任务最后执行时间
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdateTaskLastRunTime(ScheduledTaskInfo model)
        {
            bool result = false;
            try
            {
                var row = db.Updateable(model).UpdateColumns(it => new { it.LastRunTime}).Where(it=>it.Id==model.Id).ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "UpdateTaskLastRunTime");
            }
            return result;
        }

        /// <summary>
        /// 编辑定时任务状态
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdateTaskStaus(ScheduledTaskInfo model)
        {
            bool result = false;
            try
            {
                var row = db.Updateable(model).UpdateColumns(it => new { it.Status }).Where(it => it.Id == model.Id).ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "UpdateTaskStaus");
            }
            return result;
        }

        /// <summary>
        /// 批量修改任务
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public bool BatchUpdateTask(List<ScheduledTaskInfo> list)
        {
            bool result = false;
            try
            {
                var row = db.Updateable(list).ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "BatchUpdateTask");
            }
            return result;
        }

        /// <summary>
        /// 删掉任务
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool DeleteTask(int id)
        {
            bool result = false;
            try
            {
                var row = db.Deleteable<ScheduledTaskInfo>().Where(it => it.Id == id).ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "UpdateTask");
            }
            return result;
        }

        #endregion

        #region 任务执行日志


        /// <summary>
        /// 获取任务日志列表
        /// </summary>
        /// <param name="device_id"></param>
        /// <param name="user_id"></param>
        /// <param name="bassid"></param>
        /// <returns></returns>
        public List<ScheduledTaskLog> GetTakLogList(BaseParm parm, ref int totalPage)
        {
            List<ScheduledTaskLog> list = new List<ScheduledTaskLog>();
            try
            {

                list = db.Queryable<ScheduledTaskLog>()
                        .WhereIF(!string.IsNullOrEmpty(parm.Id.ToString()), it => it.Task_Id == parm.Id)
                        .WhereIF(!string.IsNullOrEmpty(parm.Param),it=>it.Conent.Contains(parm.Param))
                        .WhereIF(parm.Status>0,it=>it.ExecutionState==parm.Status)
                        .OrderBy(it => it.Create_Time, OrderByType.Desc)
                        .ToPageList(parm.PageIndex, parm.PageSize, ref totalPage);
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "GetTakLogList");
            }
            return list;
        }

        /// <summary>
        /// 添加任务日志
        /// </summary>
        /// <param name="taskId"></param>
        /// <param name="state">执行状态 1:成功 2:失败 </param>
        /// <param name="content"></param>
        /// <returns></returns>
        public bool AddTaskLog(int taskId, int state, string content)
        {
            bool result = false;
            try
            {
                ScheduledTaskLog model = new ScheduledTaskLog();
                model.Uuid = Guid.NewGuid().ToString();
                model.Task_Id = taskId;
                model.ExecutionState = state;
                model.Conent = content;
                model.Create_Time = DateTime.Now;

                int row = db.Insertable(model).ExecuteCommand();
                if (row > 0)
                {
                    result = true;
                }
            }
            catch (Exception ex)
            {
                Logging.Error(ex, "AddTaskLog");
            }
            return result;
        }


        #endregion

    }
}