private async Task NotifyContact(Domain.Entities.Contact contactToNotify, ApplyData applyData, int sequenceNo, CancellationToken cancellationToken)
        {
            var email       = contactToNotify.Email;
            var contactname = contactToNotify.DisplayName;
            var reference   = applyData.Apply.ReferenceNumber;
            var standard    = applyData.Apply.StandardName;

            if (sequenceNo == ApplyConst.ORGANISATION_SEQUENCE_NO)
            {
                var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(EmailTemplateNames.ApplyEPAOInitialSubmission);

                await _mediator.Send(new SendEmailRequest(email, emailTemplate, new { contactname, reference }), cancellationToken);

                var emailTemplateAlert = await _eMailTemplateQueryRepository.GetEmailTemplate(EmailTemplateNames.ApplyEPAOAlertSubmission);

                await _mediator.Send(new SendEmailRequest(string.Empty, emailTemplateAlert, new { contactname, reference }), cancellationToken);
            }
            else if (sequenceNo == ApplyConst.STANDARD_SEQUENCE_NO)
            {
                var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(EmailTemplateNames.ApplyEPAOStandardSubmission);

                await _mediator.Send(new SendEmailRequest(email, emailTemplate, new { contactname, reference, standard }), cancellationToken);
            }
            else if (sequenceNo == ApplyConst.ORGANISATION_WITHDRAWAL_SEQUENCE_NO || sequenceNo == ApplyConst.STANDARD_WITHDRAWAL_SEQUENCE_NO)
            {
                var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(EmailTemplateNames.WithdrawalEPAOSubmission);

                await _mediator.Send(new SendEmailRequest(email, emailTemplate, new { contactname, reference }), cancellationToken);
            }
        }
Пример #2
0
        public async Task <Domain.Entities.Contact> EditContactAsync(Domain.Entities.Contact contact)
        {
            _context.Contacts.Update(contact);
            await _context.SaveChangesAsync();

            return(contact);
        }
Пример #3
0
        public async Task <Domain.Entities.Contact> CreateContactAsync(Domain.Entities.Contact contact)
        {
            await _context.AddAsync(contact);

            await _context.SaveChangesAsync();

            return(contact);
        }
        protected override void Handle(NotMatchCommand request)
        {
            var contact = new Domain.Entities.Contact(Guid.NewGuid(), request.UserId, request.MatchedUserId, false);

            _dbContext.Contacts.Add(contact);

            if (_dbContext.SaveChanges() == 0)
            {
                throw new Exception("Could not add new contact");
            }
        }
        private async Task NotifyContact(Domain.Entities.Contact contactToNotify, ApplyData applyData, CancellationToken cancellationToken)
        {
            var email             = contactToNotify.Email;
            var contactname       = contactToNotify.DisplayName;
            var standard          = applyData.Apply.StandardName;
            var standardreference = applyData.Apply.StandardReference;
            var version           = applyData.Apply.Versions.First();

            var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(EmailTemplateNames.ApplyEPAOStandardOptin);

            await _mediator.Send(new SendEmailRequest(email, emailTemplate, new { contactname, standard, standardreference, version }), cancellationToken);
        }
        public async Task <IViewModel <ContactViewModel> > Handle(CreateContactCommand request, CancellationToken cancellationToken)
        {
            var contact = new Domain.Entities.Contact
            {
                Number = request.Number,
                UserId = request.UserId,
                Type   = request.Type
            };

            context.Contacts.Add(contact);
            await context.SaveChangesAsync(cancellationToken);

            return(await mediator.Send(new GetContactQuery(contact.Id, request.UserId)));
        }
        public async Task <int> Handle(CreateContactCommand request, CancellationToken cancellationToken)
        {
            var entity = new Domain.Entities.Contact();

            entity.Title       = request.Title;
            entity.FirstName   = request.FirstName;
            entity.LastName    = request.LastName;
            entity.Note        = request.Note;
            entity.Sex         = request.Sex;
            entity.DateOfBirth = request.DateOfBirth;

            _context.Contacts.Add(entity);

            await _context.SaveChangesAsync(cancellationToken);

            return(entity.Id);
        }
Пример #8
0
        public async Task <int> Handle(CreateContactCommand request, CancellationToken cancellationToken)
        {
            //var entity = _mapper.Map<Domain.Entities.Contact>(request);
            //entity.DomainEvents.Add(new TodoItemCreatedEvent(entity));
            var entity = new Domain.Entities.Contact()
            {
                Message = request.Message,
                Email   = request.Email,
                Name    = request.Name,
                Subject = request.Subject
            };

            _context.Contact.Add(entity);

            await _context.SaveChangesAsync(cancellationToken);

            return(entity.Id);
        }
        private async Task <bool> InviteUser(Domain.Entities.Contact contact)
        {
            // NOTE: An appropriate email will be generated by the Sign In Service.
            var invitationResult = await _dfeSignInService.InviteUser(contact.Email, contact.GivenNames, contact.FamilyName, contact.Id);

            if (!invitationResult.IsSuccess)
            {
                if (invitationResult.UserExists)
                {
                    await _contactRepository.UpdateSignInId(contact.Id, invitationResult.ExistingUserId);

                    return(true);
                }

                return(false);
            }

            return(true);
        }
        private async Task NotifyContact(Domain.Entities.Contact contactToNotify, ApplyData applyData, int sequenceNo, CancellationToken cancellationToken)
        {
            var email       = contactToNotify.Email;
            var contactname = contactToNotify.DisplayName;
            var reference   = applyData.Apply.ReferenceNumber;
            var standard    = applyData.Apply.StandardName;

            if (sequenceNo == 1)
            {
                var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(EmailTemplateNames.ApplyEPAOInitialSubmission);

                await _mediator.Send(new SendEmailRequest(email, emailTemplate, new { contactname, reference }), cancellationToken);
            }
            else if (sequenceNo == 2)
            {
                var emailTemplate = await _eMailTemplateQueryRepository.GetEmailTemplate(EmailTemplateNames.ApplyEPAOStandardSubmission);

                await _mediator.Send(new SendEmailRequest(email, emailTemplate, new { reference, standard }), cancellationToken);
            }
        }
Пример #11
0
 public UserBuilder WithContact(Domain.Entities.Contact contact)
 {
     _contact = contact;
     return(this);
 }
        private void AddSubmissionInfoToApplyData(ApplyData applyData, int sequenceNo, Domain.Entities.Contact submittingContact)
        {
            var submission = new Submission
            {
                SubmittedAt      = DateTime.UtcNow,
                SubmittedBy      = submittingContact.Id,
                SubmittedByEmail = submittingContact.Email
            };

            if (sequenceNo == ApplyConst.ORGANISATION_SEQUENCE_NO)
            {
                applyData.Apply.AddInitSubmission(submission);
            }
            else if (sequenceNo == ApplyConst.STANDARD_SEQUENCE_NO)
            {
                applyData.Apply.AddStandardSubmission(submission);
            }
            else if (sequenceNo == ApplyConst.ORGANISATION_WITHDRAWAL_SEQUENCE_NO)
            {
                applyData.Apply.AddOrganisationWithdrawalSubmission(submission);
            }
            else if (sequenceNo == ApplyConst.STANDARD_WITHDRAWAL_SEQUENCE_NO)
            {
                applyData.Apply.AddStandardWithdrawalSubmission(submission);
            }
        }
        private void AddSubmissionInfoToApplyData(ApplyData applyData, int sequenceNo, Domain.Entities.Contact submittingContact)
        {
            var submission = new Submission
            {
                SubmittedAt      = DateTime.UtcNow,
                SubmittedBy      = submittingContact.Id,
                SubmittedByEmail = submittingContact.Email
            };

            if (sequenceNo == 1)
            {
                if (applyData.Apply.InitSubmissions == null)
                {
                    applyData.Apply.InitSubmissions = new List <Submission>();
                }

                applyData.Apply.InitSubmissions.Add(submission);
                applyData.Apply.InitSubmissionsCount     = applyData.Apply.InitSubmissions.Count;
                applyData.Apply.LatestInitSubmissionDate = submission.SubmittedAt;
            }
            else if (sequenceNo == 2)
            {
                if (applyData.Apply.StandardSubmissions == null)
                {
                    applyData.Apply.StandardSubmissions = new List <Submission>();
                }

                applyData.Apply.StandardSubmissions.Add(submission);
                applyData.Apply.StandardSubmissionsCount     = applyData.Apply.StandardSubmissions.Count;
                applyData.Apply.LatestStandardSubmissionDate = submission.SubmittedAt;
            }
        }