private bool IsEndpointValid(Configuration configuration)
        {
            // endpoint needs to be a valid URL
            try
            {
                // ReSharper disable once ObjectCreationAsStatement
                new Uri(configuration.Api.Endpoint);
            }
            catch
            {
                Program.WriteError(string.Format("'{0}' is not a valid endpoint URI.", configuration.Api.Endpoint));
                return(false);
            }

            // endpoint must respond to ping
            var apiClient = ApiClientFactory.GetClient(configuration);

            try
            {
                new PingRequest().LoadResult(apiClient);
            }
            catch (Exception ex)
            {
                Program.WriteError("API endpoint not found: " + ex.Message);
                return(false);
            }

            // endpoint must return valid mandator response
            try
            {
                new MandatorRequest().LoadResult(apiClient);
            }
            catch (Exception ex)
            {
                Program.WriteError("Unable to access API: " + ex.Message);
                return(false);
            }

            return(true);
        }
        public Configuration ReadAndVerify(out bool hasErrors, out bool hasWarnings)
        {
            hasWarnings = false;
            Configuration configuration;

            // parse the JSON and check if we get a filled configuration back
            try
            {
                configuration =
                    JsonConvert.DeserializeObject <Configuration>(
                        File.ReadAllText(_commandLineArguments.ConfigurationFile));
                if (configuration == null ||
                    configuration.Api == null ||
                    configuration.Columns == null ||
                    configuration.Columns.Any(x => x == null))
                {
                    throw new ApplicationException("Configuration invalid or missing.");
                }
            }
            catch (Exception ex)
            {
                Program.WriteError("Unable to deserialize JSON: " + ex.Message);
                configuration = new Configuration();
                hasErrors     = true;
                return(configuration);
            }

            hasErrors = !IsEndpointValid(configuration);
            if (hasErrors)
            {
                return(configuration);
            }

            var apiClient = ApiClientFactory.GetClient(configuration);

            hasWarnings = !IsEntireConfigurationValid(configuration) || !IsEveryColumnValid(configuration, apiClient);
            return(configuration);
        }
 public CsvService([NotNull] CommandLineArguments commandLineArguments, [NotNull] Configuration configuration)
 {
     _commandLineArguments = commandLineArguments;
     _configuration        = configuration;
     _apiClient            = ApiClientFactory.GetClient(configuration);
 }
        public void RunImport(out bool hasErrors)
        {
            hasErrors = false;

            var apiClient = ApiClientFactory.GetClient(_configuration);

            var count = 0;
            var total = _csv.Values.Count();

            foreach (var row in _csv.Values)
            {
                ApplicantParameter applicantParameter;
                ApplicantResponse  applicantResponse;

                var idColumn            = _configuration.Columns.FirstOrDefault(x => x.Type == ColumnType.Id);
                int?existingApplicantId = null;
                if (idColumn != null && row.ContainsKey(idColumn.Header) && row[idColumn.Header].ToString().IsInt())
                {
                    existingApplicantId = row[idColumn.Header].ToString().GetInt();
                    Program.Write($"Updating applicant #{existingApplicantId} {++count}/{total} ...");

                    applicantResponse  = new ApplicantGetRequest(existingApplicantId.Value).LoadResult(apiClient);
                    applicantParameter = new ApplicantParameter(applicantResponse);
                }
                else
                {
                    Program.Write($"Creating applicant {++count}/{total} ...");
                    applicantParameter = new ApplicantParameter
                    {
                        FirstName = "First-Name",
                        LastName  = "Last-Name",
                        IsActive  = true
                    };
                }

                try
                {
                    foreach (var c in _configuration.Columns)
                    {
                        var column = ColumnFactory.GetColumn(c);
                        column.SetValueBeforeCreate(row.ContainsKey(c.Header) ? row[c.Header] as string : null,
                                                    applicantParameter, apiClient);
                    }

                    if (existingApplicantId.HasValue)
                    {
                        applicantResponse =
                            new ApplicantPostRequest(existingApplicantId.Value, applicantParameter).LoadResult(apiClient);
                        Program.Write(
                            $"Applicant '#{applicantResponse.Id} {applicantResponse.FirstName} {applicantResponse.LastName}' updated. Setting additional attributes ...");
                    }
                    else
                    {
                        applicantResponse =
                            new ApplicantPutRequest(applicantParameter, false, new Uri("http://does_not_matter"))
                            .LoadResult(apiClient);
                        Program.Write(
                            $"Applicant '#{applicantResponse.Id} {applicantResponse.FirstName} {applicantResponse.LastName}' created. Setting additional attributes ...");
                    }

                    foreach (var c in _configuration.Columns)
                    {
                        var column = ColumnFactory.GetColumn(c);
                        column.SetValueAfterCreate(row.ContainsKey(c.Header) ? row[c.Header] as string : null,
                                                   applicantResponse, apiClient);
                    }

                    Program.Write("");
                }
                catch (Exception ex)
                {
                    Program.WriteError("Unable to import applicant: " + ex.Message);
                    hasErrors = true;
                    return;
                }
            }
        }