feixing/Permission.Service/Services/NewsTypeService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;
using Permission.Entity.DbContext;
using Permission.Entity.News;
using Permission.Entity.System;
using Permission.Infrastructure.Repositories;
using Permission.Infrastructure.WebControls;
using Permission.Service.IServices;
using Permission.Utils.Validate;

namespace Permission.Service.Services
{
    public class NewsTypeService : INewsTypeService
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly PermissionContext _dbContext;
        private readonly IBaseRepository<NewsType> _newsTypeRepository;

        public NewsTypeService(IUnitOfWork unitOfWork, PermissionContext dbContext, IBaseRepository<NewsType> newsTypeRepository)
        {
            this._unitOfWork = unitOfWork;
            this._dbContext = dbContext;
            this._newsTypeRepository = newsTypeRepository;
        }

        public bool AddModel(NewsType model)
        {
            try
            {
                model.GuidId = Guid.NewGuid().ToString();
                model.IsEnabled = model.IsEnabled != null;
                model.DeleteMark = false;
                model.CreateTime = DateTime.Now;
                var res = _newsTypeRepository.Save(model);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public bool ModifyModel(NewsType model)
        {
            try
            {
                var role = _newsTypeRepository.Get(model.Id);
                role.TypeName = model.TypeName;
                role.Img = model.Img;
                role.SortCode = model.SortCode;
                role.IsEnabled = model.IsEnabled;
                role.ModifyTime = DateTime.Now;
                role.ModifyUser = model.ModifyUser;
                role.Remark = model.Remark;
                var res = _newsTypeRepository.Update(role);
                return res;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        private static readonly Func<PermissionContext, int, NewsType> NewtypeById =
            EF.CompileQuery((PermissionContext db, int typeid) => db.NewsTypes
                .Include(u => u.NewsInfos)
                .FirstOrDefault(c => c.Id == typeid));

        public bool DeleteModel(int key)
        {
            try
            {
                var flag = false;
                if (!key.IsEmpty() || key > 0)
                {
                    var system = NewtypeById(_dbContext, key);
                    if (system.NewsInfos.Any())
                    {
                        system.NewsInfos.Clear();
                        var model = _newsTypeRepository.Get(key);
                        _newsTypeRepository.Delete(model);
                    }
                    else
                    {
                        var model = _newsTypeRepository.Get(key);
                        _newsTypeRepository.Delete(model);
                    }
                    flag = true;
                }
                else
                {
                    flag = false;
                }
                return flag;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public NewsType GetNewsTypeByKey(int key)
        {
            try
            {
                if (!key.IsEmpty() || key > 0)
                {
                    var data = _newsTypeRepository.Get(key);
                    return data;
                }
                return null;
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public Page<NewsType> PageList(string keyword, int pagesize, int pageindex)
        {
            try
            {
                int total = 0;
                if (keyword.IsEmpty())
                {
                    var data = _newsTypeRepository.PageList(pageindex, pagesize, us => us.OrderBy(ur => ur.SortCode),
                        u => u,
                        out total,
                        u => u.DeleteMark == false);

                    return data;
                }
                else
                {
                    var data = _newsTypeRepository.PageList(pageindex, pagesize, us => us.OrderBy(ur => ur.SortCode), u => u,
                        out total,
                        u => u.TypeName.Contains(keyword) && u.DeleteMark == false);
                    return data;
                }
            }
            catch (Exception e)
            {
                throw e;
            }
        }

        public List<NewsType> GetNewsTypeList()
        {
            try
            {
                var data = _newsTypeRepository.QueryEntity<NewsType, int, NewsType>(m => m.IsEnabled.Value == true && m.DeleteMark.Value == false, ms => ms.SortCode.Value, null, true).ToList();
                return data;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
    }
}