Ejemplo n.º 1
0
        private static async Task <ServiceResultDto[]> GetResultsAsync(ServiceIdentifierDto[] identifiers)
        {
            using (var repository = new ServiceProviderRepository())
            {
                var tasks = identifiers
                            .Select(async item =>
                {
                    try
                    {
                        var serviceMapping = await repository.GetAsync(it => it.Service.Name == item.Name &&
                                                                       it.Group == item.Group).ConfigureAwait(false);

                        var addr = new ServiceInfoDto
                        {
                            Name    = item.Name,
                            Group   = item.Group,
                            Address = serviceMapping.Address,
                            Data    = serviceMapping.Data,
                        };

                        var result = new ServiceResultDto
                        {
                            Identifier   = item,
                            ServiceInfos = new[] { addr }
                        };

                        return(result);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                    return(null);
                })
                            .ToArray();

                await Task.WhenAll(tasks).ConfigureAwait(false);

                var results = tasks
                              .Select(it => it.Result)
                              .Where(it => it != null)
                              .ToArray();
                return(results);
            }
        }
Ejemplo n.º 2
0
        public async Task <ServiceResultDto> SendQueryAsync(string host)
        {
            if (String.IsNullOrEmpty(host))
            {
                return new ServiceResultDto()
                       {
                           ServiceType = ServiceType(), Status = QueryStatusTypes.Error
                       }
            }
            ;



            ServiceResultDto result = new ServiceResultDto();

            result.ServiceType = ServiceType();
            result.Uid         = Guid.NewGuid();

            try
            {
                using (HttpClient res = new HttpClient())
                {
                    res.Timeout = new TimeSpan(0, 0, 5);
                    HttpResponseMessage response = await res.GetAsync($"{url}{host}");

                    result.Result = await response.Content.ReadAsStringAsync();

                    result.Status = (response.StatusCode == System.Net.HttpStatusCode.OK) ? QueryStatusTypes.Success : QueryStatusTypes.Error;
                }
            }
            catch (Exception ex)
            {
                return(new ServiceResultDto()
                {
                    ServiceType = ServiceType(), Status = QueryStatusTypes.Error
                });
            }


            return(result);
        }
    }
Ejemplo n.º 3
0
            public async Task <ServiceResultDto <string> > Handle(Command command, CancellationToken cancellationToken)
            {
                var response = new ServiceResultDto <string>();

                var isValidUser = await this.authRepo.ValidateUserIdAndPasswordAsync(command.Email, command.Password);

                if (isValidUser)
                {
                    response.IsSuccess = true;

                    var user = await this.userRepo.GetUserByEmailIdAsync(command.Email);

                    response.Data = this.jwtAuthHelper.GenerateToken(user.Id, user.Email, user.Role);
                }
                else
                {
                    response.IsSuccess = false;
                    response.Error     = Messages.InvalidCredentials;
                }

                return(response);
            }