protected override Command CreateDeleteLinksCommand(Person entity, IAuthenticatedUser user, string selector)
        {
            switch (selector)
            {
            case "UnlinkDisciplesFromPerson": return(Command
                                                     .NonQuery()
                                                     .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                                                     .StoredProcedure("[PersonBoundedContext].[pPerson_UnlinkDisciples]")
                                                     .ThrowWhenNoRecordIsUpdated(false)
                                                     .Parameters(
                                                         p => p.Name("personId").Value(entity.Id)
                                                         ));

            case "UnlinkServantsFromPerson": return(Command
                                                    .NonQuery()
                                                    .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                                                    .StoredProcedure("[PersonBoundedContext].[pPerson_UnlinkServants]")
                                                    .ThrowWhenNoRecordIsUpdated(false)
                                                    .Parameters(
                                                        p => p.Name("personId").Value(entity.Id)
                                                        ));

            default: throw new InvalidOperationException();
            }
        }
Пример #2
0
        public async override Task <IEnumerable <Person> > GetAllAsync()
        {
            var result = await Query <Person>
                         .Collection()
                         .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                         .StoredProcedure("[PersonBoundedContext].[pPerson_GetAll]")
                         .ExecuteAsync();

            return(result.Records);
        }
 protected override Command CreateDeleteCommand(Person entity, IAuthenticatedUser user, string selector)
 {
     return(Command
            .NonQuery()
            .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
            .StoredProcedure("[PersonBoundedContext].[pPerson_Delete]")
            .Parameters(
                p => p.Name("personId").Value(entity.Id)
                ));
 }
Пример #4
0
        public async override Task <(int, IEnumerable <Person>)> GetAsync(CollectionQueryParameters queryParameters)
        {
            var result = await Query <Person>
                         .Collection()
                         .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                         .StoredProcedure("[PersonBoundedContext].[pPerson_Get]")
                         .QueryParameters(queryParameters)
                         .Parameters(p => p.Name("count").Count())
                         .ExecuteAsync();

            return(result.Count, result.Records);
        }
Пример #5
0
        public IEnumerable <Person> GetAllDisciplesForPerson(int personId)
        {
            var result = Query <Person>
                         .Collection()
                         .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                         .StoredProcedure("[PersonBoundedContext].[pPerson_GetAllDisciples]")
                         .Parameters(
                p => p.Name("personId").Value(personId)
                )
                         .Execute();

            return(result.Records);
        }
Пример #6
0
        public async override Task <Person> GetByIdAsync(int personId)
        {
            var result = await Query <Person>
                         .Single()
                         .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                         .StoredProcedure("[PersonBoundedContext].[pPerson_GetById]")
                         .Parameters(
                p => p.Name("personId").Value(personId)
                )
                         .ExecuteAsync();

            return(result.Record);
        }
        protected override Command CreateInsertCommand(Person entity, IAuthenticatedUser user, string selector)
        {
            if (user != null)
            {
                entity.CreatedBy = (int)user.Id;
            }

            var command = Query <Person>
                          .Single()
                          .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                          .StoredProcedure("[PersonBoundedContext].[pPerson_Insert]")
                          .Parameters(
                p => p.Name("name").Value(entity.Name),
                p => p.Name("gender").Value(entity.Gender),
                p => p.Name("createdBy").Value(entity.CreatedBy)
                )
                          .OnBeforeCommandExecuted(cmd =>
            {
                var dependencies = Dependencies();

                var disciplesDependency = (Person)dependencies?.SingleOrDefault(d => d.Selector == "Disciples")?.Entity;

                if (disciplesDependency != null)
                {
                    entity.LeaderId = disciplesDependency.Id;
                }

                cmd.Parameters(
                    p => p.Name("leaderId").Value(entity.LeaderId)
                    );

                var servantsDependency = (Person)dependencies?.SingleOrDefault(d => d.Selector == "Servants")?.Entity;

                if (servantsDependency != null)
                {
                    entity.MasterId = servantsDependency.Id;
                }

                cmd.Parameters(
                    p => p.Name("masterId").Value(entity.MasterId)
                    );
            })
                          .RecordInstance(entity)
                          .MapProperties(
                p => p.Name("Id").Index(0)
                );

            return(command);
        }
        protected override Command CreateUpdateCommand(Person entity, IAuthenticatedUser user, string selector)
        {
            if (user != null)
            {
                entity.UpdatedBy = (int)user.Id;
            }

            return(Command
                   .NonQuery()
                   .Connection(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName())
                   .StoredProcedure("[PersonBoundedContext].[pPerson_Update]")
                   .Parameters(
                       p => p.Name("personId").Value(entity.Id),
                       p => p.Name("name").Value(entity.Name),
                       p => p.Name("gender").Value(entity.Gender),
                       p => p.Name("updatedBy").Value(entity.UpdatedBy),
                       p => p.Name("leaderId").Value(entity.LeaderId),
                       p => p.Name("masterId").Value(entity.MasterId)
                       ));
        }
 public SavePersonCommandAggregate() : base(new DomainFramework.DataAccess.RepositoryContext(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName()))
 {
 }
 public SavePersonCommandAggregate(PersonInputDto person, EntityDependency[] dependencies = null) : base(new DomainFramework.DataAccess.RepositoryContext(PersonWithDisciplesAndServantsConnectionClass.GetConnectionName()))
 {
     Initialize(person, dependencies);
 }