public EmployeeGroupAggregateRoot Create(IWorkContext context, CreateEmployeeGroupCommand commmand)
        {
            this.ApplyEvent(new CreateEmployeeGroupEvent()
            {
                Creator     = context.GetWorkerName(),
                AggregateId = this.AggregateId,
                Version     = this.Version,
                CreateDate  = context.WorkTime,
                EmployeeId  = commmand.EmployeeId,
                GroupId     = commmand.GroupId,
            });

            return(this);
        }
 public static EmployeeGroupAggregateRoot Register(IWorkContext context, CreateEmployeeGroupCommand command)
 {
     return(new EmployeeGroupAggregateRoot(command.AggregateId).Create(context, command));
 }
        public ICommandHandlerResult Execute(ICommandContext context, DistributeEmployeeGroupCommand command)
        {
            var employee = this.employeeRepository.Rebuild(command.EmployeeId);

            if (employee == null)
            {
                return(context.CreateResult(CommandHandlerStatus.NotExists));
            }

            var employeeGroups = this.employeeGroupRepository.RebuildRootUsingEmployeeId(command.EmployeeId);

            if (employeeGroups.IsNullOrEmpty())
            {
                var list = new List <EmployeeGroupAggregateRoot>(100);
                foreach (var r in command.GroupId)
                {
                    var cmd = new CreateEmployeeGroupCommand(NewId.GenerateNumber(NewId.StringLength.L24))
                    {
                        EmployeeId = command.EmployeeId,
                        GroupId    = r,
                    };

                    var root = context.GetAggregateRoot(cmd.AggregateId, () => EmployeeGroupAggregateRoot.Register(context, cmd));
                    if (root.CanCommit())
                    {
                        list.Add(root);
                    }
                }

                this.employeeGroupRepository.Save(list);
                return(context.CreateResult(CommandHandlerStatus.Success));
            }

            //表明这些是新增的,在新加的记录中删除已经存在的
            var news = new List <EmployeeGroupAggregateRoot>(100);

            foreach (var r in command.GroupId)
            {
                if (employeeGroups.Any(t => t.GroupId == r))
                {
                    continue;
                }

                var cmd = new CreateEmployeeGroupCommand(NewId.GenerateNumber(NewId.StringLength.L24))
                {
                    EmployeeId = command.EmployeeId,
                    GroupId    = r,
                };

                var root = context.GetAggregateRoot(cmd.AggregateId, () => EmployeeGroupAggregateRoot.Register(context, cmd));
                if (root.CanCommit())
                {
                    news.Add(root);
                }
            }

            if (news.Any())
            {
                this.employeeGroupRepository.Save(news);
            }

            //表明这些是已经存在,在已经存在的记录中删除不是新的记录中
            var deletes = new List <EmployeeGroupAggregateRoot>(100);

            foreach (var r in employeeGroups)
            {
                if (command.GroupId.Any(t => t == r.GroupId))
                {
                    continue;
                }

                r.Remove(context);
                if (r.CanCommit())
                {
                    deletes.Add(r);
                }
            }
            if (deletes.Any())
            {
                this.employeeGroupRepository.Remove(deletes);
            }

            return(context.CreateResult(CommandHandlerStatus.Success));
        }