LASAPlatform/OpenAuth.App/ServiceApp/ManageApp.cs

using DocumentFormat.OpenXml.Wordprocessing;
using Infrastructure;
using OpenAuth.App.BaseApp.Base;
using OpenAuth.App.Interface;
using OpenAuth.App.ServiceApp.Request;
using OpenAuth.App.ServiceApp.Response;
using OpenAuth.Repository;
using OpenAuth.Repository.Domain;
using SqlSugar;

namespace OpenAuth.App.ServiceApp
{
    public class ManageApp : SqlSugarBaseApp<LasaDronePort, SugarDbContext>
    {
        public ManageApp(ISugarUnitOfWork<SugarDbContext> unitWork, ISimpleClient<LasaDronePort> repository, IAuth auth) : base(unitWork, repository, auth)
        {
        }

        /// <summary>
        /// 分页获取所有数据 
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<Response<PageInfo<List<LasaDronePort>>>> GetPageList(int pageIndex, int pageSize, string key)
        {
            int totalCount = 0;
            PageModel pageModel = new PageModel()
            {
                PageIndex = pageIndex,
                PageSize = pageSize,
                TotalCount = totalCount
            };
            var list = await Repository.GetPageListAsync(it => it.Name.Contains(key), pageModel, it => it.UpdateTime, OrderByType.Desc);
            return new Response<PageInfo<List<LasaDronePort>>>
            {
                Result = new PageInfo<List<LasaDronePort>> { Items = list, Total = totalCount }
            };
        }
        /// <summary>
        /// 获取无人机列表
        /// </summary>
        /// <param name="page"></param>
        /// <param name="limit"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<Response<PageInfo<List<LasaUav>>>> GetUavPageList(int page, int limit, string key)
        {
            RefAsync<int> totalCount = 0;
            using (var db = UnitWork.CreateContext())
            {
                var list = await db.LasaUav.AsQueryable()
                    .WhereIF(!string.IsNullOrEmpty(key), a => a.Name.Contains(key))
                    .ToPageListAsync(page, limit, totalCount);
                return new Response<PageInfo<List<LasaUav>>>
                {
                    Result = new PageInfo<List<LasaUav>> { Items = list, Total = totalCount }
                };
            }
        }
        /// <summary>
        /// 获取任务列表
        /// </summary>
        /// <param name="page"></param>
        /// <param name="limit"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<Response<PageInfo<List<LasaTask>>>> GetTaskPageList(int page, int limit, string key)
        {
            RefAsync<int> totalCount = 0;
            using (var db = UnitWork.CreateContext())
            {
                var list = await db.LasaTask.AsQueryable()
                    .WhereIF(!string.IsNullOrEmpty(key), a => a.TaskName.Contains(key))
                    .ToPageListAsync(page, limit, totalCount);
                return new Response<PageInfo<List<LasaTask>>>
                {
                    Result = new PageInfo<List<LasaTask>> { Items = list, Total = totalCount }
                };
            }
        }
        //添加任务
        public async Task<Response<bool>> AddTask(LasaTask task)
        {
            using (var db = UnitWork.CreateContext())
            {
                task.Id = Guid.NewGuid().ToString();
                task.CreateId = _auth.GetCurrentUser().User.Id;
                task.CreateTime = DateTime.Now;
                var flag = await db.LasaTask.InsertAsync(task);
                if(db.Commit())
                    return new Response<bool> { Result = true, Message = "添加成功" };
                else
                    return new Response<bool> { Result = false, Message = "添加失败" }; 
            }
        }
        //编辑任务
        public async Task<Response<bool>> EditTask(LasaTask task)
        {
            using (var db = UnitWork.CreateContext())
            { 
                var flag = await db.LasaTask.UpdateAsync(task);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "编辑成功" };
                else
                    return new Response<bool> { Result = false, Message = "编辑失败" };
            }
        }
        //删除任务
        public async Task<Response<bool>> DeleteTask(string id)
        {
            using (var db = UnitWork.CreateContext())
            {
                var flag = await db.LasaTask.DeleteAsync(it => it.Id == id);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "删除成功" };
                else
                    return new Response<bool> { Result = false, Message = "删除失败" };
            }
        }
        #region 航线管理
        /// <summary>
        /// 获取航线列表
        /// </summary>
        /// <param name="page"></param>
        /// <param name="limit"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<Response<PageInfo<List<LasaAirLine>>>> GetAirLinePageList(int page, int limit, string key)
        {
            RefAsync<int> totalCount = 0;
            using (var db = UnitWork.CreateContext())
            {
                var list = await db.LasaAirLine.AsQueryable()
                    .WhereIF(!string.IsNullOrEmpty(key), a => a.AirLineName.Contains(key))
                    .ToPageListAsync(page, limit, totalCount);
                return new Response<PageInfo<List<LasaAirLine>>>
                {
                    Result = new PageInfo<List<LasaAirLine>> { Items = list, Total = totalCount }
                };
            }
        }
        //添加航线
        public async Task<Response<bool>> AddAirLine(LasaAirLine lasaAirLine)
        {
            using (var db = UnitWork.CreateContext())
            {
                lasaAirLine.Id = Guid.NewGuid().ToString();
                lasaAirLine.CreateId = _auth.GetCurrentUser().User.Id;
                lasaAirLine.CreateTime = DateTime.Now;
                var flag = await db.LasaAirLine.InsertAsync(lasaAirLine);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "添加成功" };
                else
                    return new Response<bool> { Result = false, Message = "添加失败" };
            }
        }
        //编辑航线
        public async Task<Response<bool>> EditAirLine(LasaAirLine lasaAirLine)
        {
            using (var db = UnitWork.CreateContext())
            {
                var flag = await db.LasaAirLine.UpdateAsync(lasaAirLine);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "编辑成功" };
                else
                    return new Response<bool> { Result = false, Message = "编辑失败" };
            }
        }
        //删除航线
        public async Task<Response<bool>> DeleteAirLine(string id)
        {
            using (var db = UnitWork.CreateContext())
            {
                var flag = await db.LasaAirLine.DeleteAsync(it => it.Id == id);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "删除成功" };
                else
                    return new Response<bool> { Result = false, Message = "删除失败" };
            }
        }
        //生成航线文件

        #endregion
        #region 项目管理 
        /// <summary>
        /// 获取项目列表
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<Response<List<dynamic>>> GetWorkspaceList(string key)
        {
            RefAsync<int> totalCount = 0;
            using (var db = UnitWork.CreateContext())
            {
                var list = await db.LasaWorkspace.AsQueryable()
                    .WhereIF(!string.IsNullOrEmpty(key), a => a.WorkspaceName.Contains(key))
                    .LeftJoin<SysUser>((a,u)=>a.CreateId==u.Id)
                    .Select<dynamic>((a, u) => new
                    {
                        a.Id,
                        a.WorkspaceName,
                        a.WorkspaceDesc,
                        a.Sate,
                        a.CreateTime,
                        a.CreateId,
                        u.Account,
                        u.Name
                    })
                    .ToListAsync();
                return new Response<List<dynamic>>
                {
                    Result =  list
                };
            }
        }
        //添加项目 
        public async Task<Response<bool>> AddWorkspace(WorkSpace info)
        {
            using (var db = UnitWork.CreateContext())
            {
                LasaWorkspace lasaWorkspace= info.LasaWorkspace;
                lasaWorkspace.Id = Guid.NewGuid().ToString();
                lasaWorkspace.CreateId = _auth.GetCurrentUser().User.Id;
                lasaWorkspace.CreateTime = DateTime.Now;

                List<LasaSpaceDevice> devices= new List<LasaSpaceDevice>();
                foreach(var item in info.DeviceIds)
                {
                    LasaSpaceDevice sd = new LasaSpaceDevice();
                    sd.WorkSpaceId=lasaWorkspace.Id;
                    sd.DeviceId = item;
                    devices.Add(sd);
                }

                List<LasaSpaceUser> users = new List<LasaSpaceUser>();
                foreach (var item in info.UserIds)
                {
                    LasaSpaceUser sd = new LasaSpaceUser();
                    sd.WorkSpaceId = lasaWorkspace.Id;
                    sd.UserId = item;
                    users.Add(sd);
                }

                foreach (var item in info.Lockfly)
                {
                    item.Id = Guid.NewGuid().ToString();
                    item.WorkSpaceId= lasaWorkspace.Id;
                    await db.LasaSpaceLockFly.InsertAsync(item);
                }
                await db.LasaWorkspace.InsertAsync(lasaWorkspace);
                await db.LasaSpaceDevice.InsertRangeAsync(devices);
                await db.LasaSpaceUser.InsertRangeAsync(users);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "添加成功" };
                else
                    return new Response<bool> { Result = false, Message = "添加失败" };
            }
        }
        //编辑项目 
        public async Task<Response<bool>> EditWorkspace(WorkSpace info)
        {
            using (var db = UnitWork.CreateContext())
            {
                LasaWorkspace lasaWorkspace = info.LasaWorkspace;
                var flag = await db.LasaWorkspace.UpdateAsync(lasaWorkspace);
                List<LasaSpaceDevice> devices = new List<LasaSpaceDevice>();
                foreach (var item in info.DeviceIds)
                {
                    LasaSpaceDevice sd = new LasaSpaceDevice();
                    sd.WorkSpaceId = lasaWorkspace.Id;
                    sd.DeviceId = item;
                    devices.Add(sd);
                }

                List<LasaSpaceUser> users = new List<LasaSpaceUser>();
                foreach (var item in info.UserIds)
                {
                    LasaSpaceUser sd = new LasaSpaceUser();
                    sd.WorkSpaceId = lasaWorkspace.Id;
                    sd.UserId = item;
                    users.Add(sd);
                }
                foreach (var item in info.Lockfly)
                {
                    if (!string.IsNullOrEmpty(item.Id))
                    {
                        await db.LasaSpaceLockFly.UpdateAsync(item);
                    }
                    else
                    {
                        item.Id = Guid.NewGuid().ToString();
                        item.WorkSpaceId = lasaWorkspace.Id;
                        await db.LasaSpaceLockFly.InsertAsync(item);
                    }
                }

                await db.LasaSpaceDevice.DeleteAsync(r=>r.WorkSpaceId == lasaWorkspace.Id);
                await db.LasaSpaceDevice.InsertRangeAsync(devices);
                await db.LasaSpaceUser.DeleteAsync(r=>r.WorkSpaceId==lasaWorkspace.Id);
                await db.LasaSpaceUser.InsertRangeAsync(users);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "编辑成功" };
                else
                    return new Response<bool> { Result = false, Message = "编辑失败" };
            }
        }
        //获取无人机信息
        public async Task<Response<List<LasaUav>>> GetUavList()
        {
            
            using (var db = UnitWork.CreateContext())
            {
                var list=db.LasaSpaceDevice.AsQueryable()?.Select(r=>r.DeviceId).ToList();
                
                var uavlist = await db.LasaUav.AsQueryable()
                    .Where(r=>!list.Contains(r.Id))
                    .ToListAsync();
                return new Response<List<LasaUav>>
                {
                    Result=uavlist
                };
            }
        }

        /// <summary>
        /// 根据项目id获取项目信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<Response<WorkSpaceRes>> GetWorkSpaceById(string id)
        {
            using (var db = UnitWork.CreateContext())
            {
                WorkSpaceRes res=new WorkSpaceRes();
                var workspace= await db.LasaWorkspace.AsQueryable().Where(r=>r.Id==id).FirstAsync();
                var sysuser = db.User.AsQueryable()
                    .LeftJoin<LasaSpaceUser>((r, a) => r.Id == a.UserId)
                    .Where((r, a) => a.WorkSpaceId == id)
                    .Select((r, a) => r).ToList();
                var uav=db.LasaUav.AsQueryable()
                    .LeftJoin<LasaSpaceDevice>((r,a)=>r.Id==a.DeviceId)
                    .Where((r,a)=>a.WorkSpaceId==id)
                    .Select((r,a)=>r).ToList();
                var lockfly=db.LasaSpaceLockFly.AsQueryable().Where(r=>r.WorkSpaceId==id).ToList();
                res.users = sysuser;
                res.lasaUavs = uav;
                res.lasaSpaceLockFlies = lockfly;
                res.workspace = workspace;

                return new Response<WorkSpaceRes>
                {
                    Result = res
                };
            }
        }

        //删除项目 
        public async Task<Response<bool>> DeleteWorkspace(string id)
        {
            using (var db = UnitWork.CreateContext())
            {
                await db.LasaWorkspace.UpdateAsync(u => new LasaWorkspace
                {
                    IsDelete = true
                }, u => u.Id == id);
                if (db.Commit())
                    return new Response<bool> { Result = true, Message = "删除成功" };
                else
                    return new Response<bool> { Result = false, Message = "删除失败" };
            }
        }
        #endregion
    }
}