public static UpsStatus TryCreate(IEnumerable <string> lines, ILogger logger)
        {
            ImmutableArray <string> actualLines = lines?.ToImmutableArray() ?? ImmutableArray <string> .Empty;

            if (PowerStatus.TryParse(actualLines,
                                     out PowerStatus status,
                                     out ImmutableArray <ParseError> parseErrors))
            {
                return(new UpsStatus(status));
            }

            logger.Error("Could not get status from lines {Lines}", actualLines);

            return(Invalid(string.Join(", ", parseErrors.Select(e => e.Error))));
        }
Example #2
0
        public static bool TryParse(
            IEnumerable <string> values,
            out PowerStatus status,
            out ImmutableArray <ParseError> errors)
        {
            ImmutableArray <string> array = values?.ToImmutableArray() ?? ImmutableArray <string> .Empty;

            if (array.Length == 0)
            {
                status = default;
                errors = new[] { new ParseError("Array is empty") }.ToImmutableArray();
                return(false);
            }

            if (!array.Any(line => line.StartsWith($"{BatteryCharge}:", StringComparison.OrdinalIgnoreCase)))
            {
                errors = new[] { new ParseError($"Missing property {BatteryCharge}") }.ToImmutableArray();
                status = default;
                return(false);
            }

            string PropertyValue(string lookup)
            {
                string[] matchingLines = array
                                         .Where(line => !string.IsNullOrWhiteSpace(line) &&
                                                line.StartsWith($"{lookup}:", StringComparison.OrdinalIgnoreCase))
                                         .ToArray();

                if (matchingLines.Length != 1)
                {
                    return(null);
                }

                string propertyAndValue = matchingLines[0];

                if (!propertyAndValue.Contains(':'))
                {
                    return(null);
                }

                string[] strings = propertyAndValue.Split(':');

                if (strings.Length != 2)
                {
                    return(null);
                }

                return(strings[1].Trim());
            }

            double?NumericValue(string value)
            {
                if (string.IsNullOrWhiteSpace(value))
                {
                    return(null);
                }

                if (int.TryParse(value, out int numericInteger))
                {
                    return(numericInteger);
                }

                if (!double.TryParse(value, out double numeric))
                {
                    return(null);
                }

                return(numeric);
            }

            ImmutableDictionary <string, string> properties = array
                                                              .Where(line => line.Contains(".") && line.Contains(":"))
                                                              .Select(line =>
            {
                string[] parts = line.Split(':');

                if (parts.Length != 2)
                {
                    return(default);
        public UpsStatus(PowerStatus status)
        {
            Succeeded = status != null;

            PowerStatus = status ?? new PowerStatus();
        }