135 lines
5.4 KiB
Python
135 lines
5.4 KiB
Python
import csv
|
|
from helix.constants.file_validation_error import FileValidationError, FileValidationMessage
|
|
from helix.calculators.coordinates_calculator import CoordinatesCalculator
|
|
from helix.models.coordinate import Coordinate
|
|
|
|
|
|
class CsvInputValidator(object):
|
|
|
|
def __init__(self, user_values):
|
|
self.user_values = user_values
|
|
|
|
def validate(self, csv_input):
|
|
try:
|
|
headers, rows = self.parse_cad_input(csv_input)
|
|
|
|
if len(headers) < 5:
|
|
return FileValidationError(FileValidationMessage.InvalidHeaders, 0)
|
|
if len(rows) == 0:
|
|
return FileValidationError(FileValidationMessage.InvalidRowCount, 0)
|
|
|
|
for row_index, row in enumerate(rows):
|
|
chain = [
|
|
CsvInputValidator.validate_for_csv,
|
|
CsvInputValidator.validate_for_wind_zones,
|
|
CsvInputValidator.validate_for_panel_type,
|
|
]
|
|
result = self.run_validation_chain(headers, row, chain)
|
|
if result:
|
|
return FileValidationError(result, row_index + 1)
|
|
|
|
file_validation_chain = [
|
|
CsvInputValidator.validate_file_for_panel_types,
|
|
CsvInputValidator.validate_for_spacing,
|
|
]
|
|
result = self.run_validation_chain(headers, rows, file_validation_chain)
|
|
if result:
|
|
return FileValidationError(result, None)
|
|
|
|
return None
|
|
except Exception as inst:
|
|
return FileValidationError(FileValidationMessage.Generic, None)
|
|
|
|
# Row Validators
|
|
|
|
def validate_for_csv(self, headers, row):
|
|
if len(row) != len(headers):
|
|
return FileValidationMessage.Generic
|
|
return None
|
|
|
|
def validate_for_wind_zones(self, headers, row):
|
|
valid_wind_zones = self.user_values.system_type().system_constants().wind_zones
|
|
if row[2] not in valid_wind_zones:
|
|
return FileValidationMessage.invalid_wind_zones(self.user_values.system_type())
|
|
return None
|
|
|
|
def validate_for_panel_type(self, headers, row):
|
|
valid_panel_types = range(1, 5)
|
|
if int(row[3]) not in valid_panel_types:
|
|
return FileValidationMessage.PanelTypeOutOfBounds
|
|
return None
|
|
|
|
# File Validators
|
|
|
|
def validate_file_for_panel_types(self, headers, rows):
|
|
panel_type_counts_per_subarray = {}
|
|
for row in rows:
|
|
subarray = int(row[4])
|
|
panel_type_counts = panel_type_counts_per_subarray.get(subarray) or {}
|
|
panel_type = int(row[3])
|
|
count = panel_type_counts.get(panel_type) or 0
|
|
panel_type_counts[panel_type] = count + 1
|
|
panel_type_counts_per_subarray[subarray] = panel_type_counts
|
|
|
|
minimum_module_count = self.user_values.system_type().system_constants().minimum_corner_module_count
|
|
|
|
for panel_type_counts in panel_type_counts_per_subarray.values():
|
|
if (panel_type_counts.get(1) or 0) < minimum_module_count:
|
|
return FileValidationMessage.panel_type_too_few_corners(self.user_values.system_type())
|
|
return None
|
|
|
|
def validate_for_spacing(self, headers, rows):
|
|
try:
|
|
|
|
if len(headers) < 13:
|
|
return None
|
|
|
|
coordinates_calculator = CoordinatesCalculator(self.user_values)
|
|
|
|
scaling_factor = self.user_values.module_system_constants().tolerance + 1
|
|
spacing_x, spacing_y = self.user_values.module_system_constants().panel_spacing
|
|
|
|
spacing_coordinates = Coordinate(spacing_x*scaling_factor, spacing_y*scaling_factor,0)
|
|
spacing_coordinates_scaled = coordinates_calculator.scale(spacing_coordinates)
|
|
|
|
for row_index, row in enumerate(rows):
|
|
first_panel = Coordinate(float(row[11]), float(row[12]), float(row[13]))
|
|
first_panel_rotated = coordinates_calculator.rotate(first_panel)
|
|
first_panel_scaled = coordinates_calculator.scale(first_panel_rotated)
|
|
for row_index2, row2 in enumerate(rows):
|
|
if row_index2 <= row_index:
|
|
continue
|
|
|
|
second_panel = Coordinate(float(row2[11]), float(row2[12]), float(row2[13]))
|
|
second_panel_rotated = coordinates_calculator.rotate(second_panel)
|
|
second_panel_scaled = coordinates_calculator.scale(second_panel_rotated)
|
|
|
|
x_diff = round(abs(first_panel_scaled.x - second_panel_scaled.x),3)
|
|
y_diff = round(abs(first_panel_scaled.y - second_panel_scaled.y),3)
|
|
|
|
if (x_diff < spacing_coordinates_scaled.x) and (y_diff < spacing_coordinates_scaled.y):
|
|
return FileValidationMessage.PanelsTooClose
|
|
|
|
return None
|
|
|
|
except Exception as inst:
|
|
print("ERROR !!! ")
|
|
print(inst)
|
|
return FileValidationMessage.Generic
|
|
|
|
# Helpers
|
|
|
|
def run_validation_chain(self, headers, data, chain):
|
|
result = None
|
|
chain = list(chain)
|
|
while not result and len(chain) > 0:
|
|
method = chain.pop()
|
|
result = method(self, headers, data)
|
|
return result
|
|
|
|
def parse_cad_input(self, cad_input):
|
|
reader = csv.reader(cad_input.splitlines(), dialect='excel-tab')
|
|
headers = next(reader)
|
|
rows = [row for row in reader]
|
|
return headers, rows
|