Exemplo n.º 1
0
        public Response <StripeAccountDTO> Create(StripeAccountDTO stripeAccountDTO)
        {
            try
            {
                StripeAccountValidator validator = new StripeAccountValidator();
                ValidationResult       results   = validator.Validate(stripeAccountDTO);

                if (results.IsValid)
                {
                    var account         = StripeAccountMapper.MapStripeAccountDTOToStripeAccountModel(stripeAccountDTO);
                    var accountResponse = _stripeRepository.Add(account);
                    _stripeRepository.SaveChanges();
                    var accountEntityDTO = StripeAccountMapper.MapStripeAccountModelToStripeAccountDTO(accountResponse);
                    var response         = new Response <StripeAccountDTO>
                    {
                        DTO = accountEntityDTO
                    };
                    return(response);
                }
                else
                {
                    return(new Response <StripeAccountDTO>()
                    {
                        Errors = results.Errors.Select(x => new Error()
                        {
                            Type = ErrorType.ValidationError, Message = x.ErrorMessage
                        }).ToList()
                    });
                }
            }
            catch (Exception ex)
            {
                return(new Response <StripeAccountDTO>()
                {
                    Errors = new List <Error>()
                    {
                        new Error()
                        {
                            Type = ErrorType.Exception, Message = ex.Message
                        }
                    }
                });
            }
        }
Exemplo n.º 2
0
        public Response <TeamDTO> AddTeam(TeamDTO teamDTO)
        {
            try
            {
                TeamRequestValidator validator = new TeamRequestValidator();
                ValidationResult     results   = validator.Validate(teamDTO);


                if (results.IsValid)
                {
                    var team       = TeamMapper.MapTeamDTOToTeamModel(teamDTO);
                    var teamEntity = _repository.Add(team);

                    _repository.SaveChanges();

                    var teamEntityDTO = TeamMapper.MapTeamModelToTeamDTO(teamEntity);
                    var response      = new Response <TeamDTO>
                    {
                        DTO = teamEntityDTO
                    };
                    return(response);
                }
                else
                {
                    return(new Response <TeamDTO> {
                        Errors = results.Errors.Select(x => new Error {
                            Type = ErrorType.ValidationError, Message = x.ErrorMessage
                        }).ToList()
                    });
                }
            }
            catch (Exception ex)
            {
                return(new Response <TeamDTO> {
                    Errors = new List <Error>()
                    {
                        new Error {
                            Type = ErrorType.Exception, Message = ex.Message
                        }
                    }
                });
            }
        }
        public Response <IngevoerdAntwoordDTO> AddIngevoerdAntwoord(IngevoerdAntwoordDTO ingevoerdAntwoordDTO)
        {
            try
            {
                IngevoerdAntwoordValidator validator = new IngevoerdAntwoordValidator();

                ValidationResult results = validator.Validate(ingevoerdAntwoordDTO);

                if (results.IsValid)
                {
                    var ingevoerdAntwoord       = IngevoerdAntwoordMapper.MapIngevoerdAntwoordDTOToIngevoerdAntwoordModel(ingevoerdAntwoordDTO);
                    var ingevoerdAntwoordEntity = _repository.Add(ingevoerdAntwoord);
                    _repository.SaveChanges();
                    var returnDTO = IngevoerdAntwoordMapper.MapIngevoerdAntwoordModelToIngevoerdAntwoordDTO(ingevoerdAntwoordEntity);
                    var response  = new Response <IngevoerdAntwoordDTO>()
                    {
                        DTO = returnDTO
                    };
                    return(response);
                }
                else
                {
                    return(new Response <IngevoerdAntwoordDTO>()
                    {
                        Errors = results.Errors.Select(x => new Error()
                        {
                            Type = ErrorType.ValidationError, Message = x.ErrorMessage
                        }).ToList()
                    });
                }
            }
            catch (Exception ex) {
                return(new Response <IngevoerdAntwoordDTO>()
                {
                    Errors = new List <Error>()
                    {
                        new Error {
                            Type = ErrorType.Exception, Message = ex.Message
                        }
                    }
                });
            }
        }