Docker/CloudBuilder/CloudBuilder.Master.Service/FamilyPersonService.auto.cs

using CloudBuilder.Core.DatabaseAccessor;
using CloudBuilder.Core.DatabaseAccessor.Entity;
using CloudBuilder.Core.Service;
using CloudBuilder.Master.Data;
using CloudBuilder.Master.Entity;
using CloudBuilder.Master.Policy;
using CloudBuilder.Master.SearchCriteria;
using CloudBuilder.Security.Data;
using CloudBuilder.Security.Entity;
using CloudBuilder.Security.Policy;
using CloudBuilder.Security.Service;
using CloudBuilder.Security.Utility;
using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.DependencyInjection;
namespace CloudBuilder.Master.Service
{
    public class FamilyPersonService : IFamilyPersonService
    {
        private readonly IApplicationService service;

        private IRepository<FamilyPersonEntity> repository;
        public FamilyPersonService(IApplicationService service)
        {
            this.service = service;
            repository = service.GetRepository<IRepository<FamilyPersonEntity>>();
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Find)]
        public FamilyPersonEntity[] FindAll()
        {
            return repository.DetachedEntities.ToArray();
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Find)]
        public FamilyPersonData FindByKey(string key)
        {
            FamilyPersonData data = new FamilyPersonData();
            if (string.IsNullOrEmpty(key)) return data;

            FamilyPersonEntity fp = repository.DetachedEntities.Where(x => x.PersonId == key).FirstOrDefault();

            if (fp == null) return data;

            data.FamilyPerson = new FamilyPersonDisplayData(fp);

            return data;
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Find)]
        public FamilyPersonResultData FindBySearchCriteria(FamilyPersonSearchCriteria criteria)
        {
            FamilyPersonResultData data = new FamilyPersonResultData();
            FamilyPersonEntity[] list = null;

            int count = 0;

            string sqlWhere = null;

            if (criteria.Filter != null && criteria.Filter.Length > 0)
            {
                sqlWhere = SearchFilter.ComposeWhereClause(criteria.Filter);
            }

            FamilyPersonEntity entity = FamilyPersonEntity.GetInstance(repository.GetDbContext().Database.ProviderName);
            string sql = entity.GetSelectTopFrom(criteria.limit, criteria.page, criteria.orderby.StringToDbField(), criteria.orderbytag, sqlWhere);

            string err = null;
            try
            {
                list = repository.FromSql(sql).ToArray();
            }
            catch (System.Exception ex)
            {
                err = ex.Message;
            }


            if (list != null && list.Length > 0)
            {
                sql = entity.GetSelectCountFrom(sqlWhere);
                count = Convert.ToInt32(repository.ExecuteScalar(sql));
            }

            data.Limit = criteria.limit;
            data.Page = criteria.page;
            data.Datas = list;
            data.Total = count;
            //data.Sql = sql;
            data.ErrorMessage = err;
            return data;
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Print)]
        public dynamic PrintBySearchCriteria(FamilyPersonSearchCriteria criteria)
        {
            throw new NotImplementedException();
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Insert)]
        [UnitOfWork]
        public FamilyPersonData Insert(FamilyPersonData data)
        {
            FamilyPersonEntity d = repository.DetachedEntities.Where(x => x.PersonId == data.FamilyPerson.PersonId).FirstOrDefault();
            if (d != null)
            {
                throw new ValidatedException("记录已存在.");
            }

            ValidateHelper.Validate(service, data.FamilyPerson, FamilyPersonEntity.DB_NAME_FAMILY_PERSON);

            d = new FamilyPersonEntity();
            ObjectCopyHelper.Copy(data.FamilyPerson, d);

            ISecurityGeneratorNumberService securityGeneratorNumberService = service.ServiceProvider.GetService<ISecurityGeneratorNumberService>()!;

            d.PersonId = securityGeneratorNumberService.GetNo(MasterPrefixPolicy.FAMILY_PERSON, MasterPrefixPolicy.FAMILY_PERSON_PERSON_ID, MasterPrefixPolicy.FAMILY_PERSON_PREFIX, YesNoPolicy.NO, MasterPrefixPolicy.FAMILY_PERSON_FORMAT);

            repository.InsertNow(d);


            return FindByKey(d.PersonId);
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Update)]
        [UnitOfWork]
        public FamilyPersonData Update(FamilyPersonData data)
        {
            FamilyPersonEntity d = repository.DetachedEntities.Where(x => x.PersonId == data.FamilyPerson.PersonId).FirstOrDefault();
            if (d == null)
            {
                throw new ValidatedException("记录不存在.");
            }

            ValidateHelper.Validate(service, data.FamilyPerson, FamilyPersonEntity.DB_NAME_FAMILY_PERSON);

            ObjectCopyHelper.Copy(data.FamilyPerson, d);

            repository.UpdateNow(d);

            return FindByKey(data.FamilyPerson.PersonId);
        }


        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Delete)]
        [UnitOfWork]
        public void Delete(string key)
        {
            var ent = repository.DetachedEntities.Where(x => x.PersonId == key).FirstOrDefault()!;
            if (ent != null) { repository.DeleteNow(ent); }
        }

        [PermissionOperate(name: MasterPermissionPolicy.FamilyPerson, operate: Operate.Delete)]
        [UnitOfWork]
        public void Deletes(string[] keys)
        {
            foreach (string key in keys)
            {
                Delete(key);
            }
        }
    }
}