private async Task <T> Update <T>(OrganizationContractorInput input)
            where T : OrganizationContractorOutput
        {
            _logger.LogTrace(
                GetLogMessage(
                    $@"OrganizationId: {input.OrganizationId}, ContractorId: {input.ContractorId}"));

            var entity = await Repository.Queryable()
                         .FindById(input.ContractorId, input.OrganizationId)
                         .FirstAsync();

            entity.InjectFrom(input);
            entity.Updated = DateTimeOffset.UtcNow;


            await Repository.UpdateAsync(entity, true);

            var result = await GetById <T>(input.ContractorId, input.OrganizationId);

            await Task.Run(() =>
            {
                RaiseEvent(new OrganizationContractorUpdatedEvent {
                    OrganizationContractor = result
                });
            });

            return(result);
        }
        public async Task <IActionResult> AddContractor([FromRoute] Guid organizationId, [FromRoute] Guid personId,
                                                        [FromBody] OrganizationContractorInput input)
        {
            var result = await _contractorService
                         .Create <AgencyOwnerOrganizationContractorOutput>(_agencyOwner, input);

            return(Ok(result));
        }
        public async Task <T> Create <T>(OrganizationContractorInput model)
            where T : OrganizationContractorOutput
        {
            _logger.LogTrace(
                GetLogMessage($@"OrganizationId: {model.OrganizationId}, ContractorId: {model.ContractorId}"));

            var e = await Repository.Queryable()
                    .IgnoreQueryFilters()
                    .FirstOrDefaultAsync(x => x.OrganizationId == model.OrganizationId && x.ContractorId == model.ContractorId);

            if (e != null)
            {
                if (e.IsDeleted)
                {
                    e.UpdatedById = _userInfo.UserId;
                    e.Updated     = DateTimeOffset.UtcNow;
                    e.IsDeleted   = false;
                    e.CreatedById = _userInfo.UserId;
                    e.Created     = DateTimeOffset.UtcNow;
                    e.InjectFrom(model);

                    await Repository.UpdateAsync(e, true);
                }
            }
            else
            {
                e = new OrganizationContractor()
                {
                    Created          = DateTimeOffset.UtcNow,
                    Updated          = DateTimeOffset.UtcNow,
                    UpdatedById      = _userInfo.UserId,
                    CreatedById      = _userInfo.UserId,
                    ContractorStream = model.ContractorStream
                }.InjectFrom(model) as OrganizationContractor;

                await Repository.InsertAsync(e, true);
            }

            var output = await GetById <T>(model.ContractorId, model.OrganizationId);

            await Task.Run(() =>
            {
                RaiseEvent(new OrganizationContractorCreatedEvent
                {
                    OrganizationContractor = output
                });
            });

            return(output);
        }
 public Task <T> Update <T>(IOrganizationAccountManager am, OrganizationContractorInput input) where T : OrganizationContractorOutput
 {
     input.OrganizationId = am.OrganizationId;
     return(Update <T>(input));
 }
 public Task <T> Update <T>(IAgencyOwner ao, OrganizationContractorInput input)
     where T : OrganizationContractorOutput
 {
     input.OrganizationId = ao.OrganizationId;
     return(Update <T>(input));
 }
Beispiel #6
0
 public Task <T> GetById <T>(OrganizationContractorInput input)
     where T : OrganizationContractorOutput
 {
     return(GetById <T>(input.ContractorId, input.OrganizationId));
 }