supersamApp.controller('FasadSettingsController', [
  '$scope',
  '$http',
  '$timeout',
  'config',
  '$filter',
  'Upload',
  function($scope,
  $http,
  $timeout,
  config,
  $filter,
  Upload) {
    var fasadSettings;
    fasadSettings = (function() {
      class fasadSettings {
        constructor() {
          this.getSheetFullDimensions = this.getSheetFullDimensions.bind(this);
          this.saveSettingsGroup = this.saveSettingsGroup.bind(this);
          this.borderDimensionModal = this.borderDimensionModal.bind(this);
          this.addBorderDimension = this.addBorderDimension.bind(this);
          this.editBorderDimension = this.editBorderDimension.bind(this);
          this.confirmBorderDimensionEdit = this.confirmBorderDimensionEdit.bind(this);
          this.deleteBorderDimension = this.deleteBorderDimension.bind(this);
          this.sheetDimensionModal = this.sheetDimensionModal.bind(this);
          this.addSheetDimension = this.addSheetDimension.bind(this);
          this.editSheetDimension = this.editSheetDimension.bind(this);
          this.confirmSheetDimensionEdit = this.confirmSheetDimensionEdit.bind(this);
          this.deleteSheetDimension = this.deleteSheetDimension.bind(this);
          this.sheetModal = this.sheetModal.bind(this);
          this.addSheet = this.addSheet.bind(this);
          this.editSheet = this.editSheet.bind(this);
          this.confirmSheetEdit = this.confirmSheetEdit.bind(this);
          this.deleteSheet = this.deleteSheet.bind(this);
          this.borderModal = this.borderModal.bind(this);
          this.addBorder = this.addBorder.bind(this);
          this.editBorder = this.editBorder.bind(this);
          this.confirmBorderEdit = this.confirmBorderEdit.bind(this);
          this.deleteBorder = this.deleteBorder.bind(this);
          this.deleteBorderAvailableDimension = this.deleteBorderAvailableDimension.bind(this);
          this.addBorderAvailableDimension = this.addBorderAvailableDimension.bind(this);
          this.isBorderDimensionAlreadyAdded = this.isBorderDimensionAlreadyAdded.bind(this);
          this.getBorderDimensionLabel = this.getBorderDimensionLabel.bind(this);
          this.uploadImage = this.uploadImage.bind(this);
          $scope.utilities.showContentOnLoad();
          config.sortFields = {
            sheets: {
              field: 'label',
              direction: 'asc'
            },
            borders: {
              field: 'label',
              direction: 'asc'
            },
            borderDimensions: {
              field: 'label',
              direction: 'asc'
            },
            sheetDimensions: {
              field: 'id',
              direction: 'asc'
            }
          };
        }

        getSheetFullDimensions(sheetDimensionId) {
          var i, label, len, ref, selectedSheetDimensions, v;
          label = "";
          ref = config.sheetDimensions;
          for (i = 0, len = ref.length; i < len; i++) {
            v = ref[i];
            if (v.id === sheetDimensionId) {
              selectedSheetDimensions = v;
            }
          }
          if (selectedSheetDimensions) {
            label = selectedSheetDimensions.width + 'x' + selectedSheetDimensions.height + 'x' + selectedSheetDimensions.thick;
          }
          return label;
        }

        saveSettingsGroup(group) {
          var dataToSend, settings;
          if (!this.isSubmitting) {
            this.isSubmitting = true;
            dataToSend = {
              action: 'saveGroup',
              settingsGroup: group
            };
            switch (group) {
              case "prices":
                settings = {
                  prices: config.prices,
                  groovePrices: config.groovePrices,
                  cornerPrices: config.cornerPrices
                };
                break;
              case "common":
                settings = {
                  common: config.common,
                  cornerDefaults: config.cornerDefaults,
                  grooveDefaults: config.grooveDefaults
                };
                break;
              default:
                settings = {};
                settings[group] = config[group];
            }
            dataToSend.settings = settings;
            return $http({
              method: 'POST',
              url: config.urls.fasadSaveSettings,
              data: dataToSend,
              timeout: 30000
            }).then((response) => {
              var data;
              this.isSubmitting = false;
              if (response.data) {
                data = response.data;
                if (data.status && (data.status === "success")) {
                  toastr.success("Настройки были успешно сохранены.");
                  $scope.utilities.setUpdateDates(group, data, config.fasad_updates);
                  return $scope[group + 'EditForm'].$setPristine();
                } else {
                  if (data.warning) {
                    toastr.warning(data.warning);
                  }
                  if (data.error) {
                    return toastr.warning(data.error);
                  }
                }
              }
            }).catch(() => {
              this.isSubmitting = false;
              return toastr.error(config.global_labels.defaultErrorMessage.value);
            });
          }
        }

        borderDimensionModal(action) {
          $timeout(() => {
            return angular.element("#borderDimensionModal").modal(action);
          });
          this.warning = "";
          this.error = "";
          return $scope.borderDimensionForm.$setPristine();
        }

        addBorderDimension() {
          this.borderDimensionModalData = {
            is_active: true
          };
          return this.borderDimensionModal("show");
        }

        editBorderDimension(borderDimension) {
          this.borderDimensionModalData = angular.copy(borderDimension);
          this.borderDimensionModalData.current_is_active = this.borderDimensionModalData.is_active;
          return this.borderDimensionModal("show");
        }

        confirmBorderDimensionEdit() {
          if (!this.isSubmitting) {
            this.isSubmitting = true;
            this.warning = "";
            this.error = "";
            return $http({
              method: 'POST',
              url: config.urls.fasadAddUpdateBorderDimension,
              data: this.borderDimensionModalData,
              timeout: 30000
            }).then((response) => {
              var data;
              this.isSubmitting = false;
              if (response.data) {
                data = response.data;
                if (data.status && (data.status === "success")) {
                  if (this.borderDimensionModalData.id) {
                    toastr.success("Данные толщины кромки были успешно обновлены");
                  } else {
                    toastr.success("Толщина кромки была успешно добавлена");
                  }
                  if (data.borders) {
                    config.borders = angular.copy(data.borders);
                  }
                  if (data.sheets) {
                    config.sheets = angular.copy(data.sheets);
                  }
                  config.borderDimensions = angular.copy(data.borderDimensions);
                  $scope.utilities.setUpdateDates("borderDimensions", data, config.fasad_updates);
                  $scope.utilities.setUpdateDates("borders", data, config.fasad_updates);
                  $scope.utilities.setUpdateDates("sheets", data, config.fasad_updates);
                  return this.borderDimensionModal("hide");
                } else {
                  if (data.warning) {
                    this.warning = data.warning;
                  }
                  if (data.error) {
                    return this.error = data.error;
                  }
                }
              }
            }).catch(() => {
              this.isSubmitting = false;
              return toastr.error(config.global_labels.defaultErrorMessage.value);
            });
          }
        }

        deleteBorderDimension(deleteBorderDimension) {
          var dataToSend;
          if (!this.isSubmitting) {
            if (confirm("Вы уверены, что хотите удалить данную толщину кромки?")) {
              this.isSubmitting = true;
              dataToSend = {
                id: deleteBorderDimension.id
              };
              return $http({
                method: 'POST',
                url: config.urls.fasadDeleteBorderDimension,
                data: dataToSend,
                timeout: 30000
              }).then((response) => {
                var borderDimension, data, key, ref;
                this.isSubmitting = false;
                if (response.data) {
                  data = response.data;
                  if (data.status && (data.status === "success")) {
                    ref = config.borderDimensions;
                    for (key in ref) {
                      borderDimension = ref[key];
                      if (borderDimension.id === deleteBorderDimension.id) {
                        config.borderDimensions.splice(key, 1);
                      }
                    }
                    $scope.utilities.setUpdateDates("borderDimensions", data, config.fasad_updates);
                    return toastr.success("Толщина кромки была успешно удалена");
                  } else {
                    if (data.warning) {
                      toastr.warning(data.warning);
                    }
                    if (data.error) {
                      return toastr.warning(data.error);
                    }
                  }
                }
              }).catch(() => {
                this.isSubmitting = false;
                return toastr.error(config.global_labels.defaultErrorMessage.value);
              });
            }
          }
        }

        sheetDimensionModal(action) {
          $timeout(() => {
            return angular.element("#sheetDimensionModal").modal(action);
          });
          this.warning = "";
          this.error = "";
          return $scope.sheetDimensionForm.$setPristine();
        }

        addSheetDimension() {
          this.sheetDimensionModalData = {
            is_active: true
          };
          return this.sheetDimensionModal("show");
        }

        editSheetDimension(sheetDimension) {
          this.sheetDimensionModalData = angular.copy(sheetDimension);
          this.sheetDimensionModalData.current_is_active = this.sheetDimensionModalData.is_active;
          return this.sheetDimensionModal("show");
        }

        confirmSheetDimensionEdit() {
          if (!this.isSubmitting) {
            this.isSubmitting = true;
            this.warning = "";
            this.error = "";
            return $http({
              method: 'POST',
              url: config.urls.fasadAddUpdateSheetDimension,
              data: this.sheetDimensionModalData,
              timeout: 30000
            }).then((response) => {
              var data;
              this.isSubmitting = false;
              if (response.data) {
                data = response.data;
                if (data.status && (data.status === "success")) {
                  if (this.sheetDimensionModalData.id) {
                    toastr.success("Данные размера листа были успешно обновлены");
                  } else {
                    toastr.success("Размер листа был успешно добавлен");
                  }
                  if (data.sheets) {
                    config.sheets = angular.copy(data.sheets);
                  }
                  config.sheetDimensions = angular.copy(data.sheetDimensions);
                  $scope.utilities.setUpdateDates("sheetDimensions", data, config.fasad_updates);
                  $scope.utilities.setUpdateDates("sheets", data, config.fasad_updates);
                  return this.sheetDimensionModal("hide");
                } else {
                  if (data.warning) {
                    this.warning = data.warning;
                  }
                  if (data.error) {
                    return this.error = data.error;
                  }
                }
              }
            }).catch(() => {
              this.isSubmitting = false;
              return toastr.error(config.global_labels.defaultErrorMessage.value);
            });
          }
        }

        deleteSheetDimension(deleteSheetDimension) {
          var dataToSend;
          if (!this.isSubmitting) {
            if (confirm("Вы уверены, что хотите удалить данные размер листа?")) {
              this.isSubmitting = true;
              dataToSend = {
                id: deleteSheetDimension.id
              };
              return $http({
                method: 'POST',
                url: config.urls.fasadDeleteSheetDimension,
                data: dataToSend,
                timeout: 30000
              }).then((response) => {
                var data, key, ref, sheetDimension;
                this.isSubmitting = false;
                if (response.data) {
                  data = response.data;
                  if (data.status && (data.status === "success")) {
                    ref = config.sheetDimensions;
                    for (key in ref) {
                      sheetDimension = ref[key];
                      if (sheetDimension.id === deleteSheetDimension.id) {
                        config.sheetDimensions.splice(key, 1);
                      }
                    }
                    $scope.utilities.setUpdateDates("sheetDimensions", data, config.fasad_updates);
                    return toastr.success("Размер листа был успешно удален");
                  } else {
                    if (data.warning) {
                      toastr.warning(data.warning);
                    }
                    if (data.error) {
                      return toastr.warning(data.error);
                    }
                  }
                }
              }).catch(() => {
                this.isSubmitting = false;
                return toastr.error(config.global_labels.defaultErrorMessage.value);
              });
            }
          }
        }

        sheetModal(action) {
          $timeout(() => {
            return angular.element("#sheetModal").modal(action);
          });
          this.warning = "";
          this.error = "";
          return $scope.sheetForm.$setPristine();
        }

        addSheet() {
          var i, len, ref, sheetDimension;
          this.sheetModalData = {
            is_active: true,
            sheet_dimension_id: null,
            default_border_id: null
          };
          config.editSheetSheetDimensions = [];
          ref = config.sheetDimensions;
          for (i = 0, len = ref.length; i < len; i++) {
            sheetDimension = ref[i];
            if (sheetDimension.is_active) {
              config.editSheetSheetDimensions.push(sheetDimension);
            }
          }
          return this.sheetModal("show");
        }

        editSheet(sheet) {
          this.sheetModalData = angular.copy(sheet);
          config.editSheetSheetDimensions = angular.copy(config.sheetDimensions);
          return this.sheetModal("show");
        }

        confirmSheetEdit() {
          if (!this.isSubmitting) {
            this.isSubmitting = true;
            this.warning = "";
            this.error = "";
            return $http({
              method: 'POST',
              url: config.urls.fasadAddUpdateSheet,
              data: this.sheetModalData,
              timeout: 30000
            }).then((response) => {
              var data, key, ref, results, sheet;
              this.isSubmitting = false;
              if (response.data) {
                data = response.data;
                if (data.status && (data.status === "success")) {
                  config.sheets = angular.copy(data.sheets);
                  $scope.utilities.setUpdateDates("sheets", data, config.fasad_updates);
                  if (this.sheetModalData.id) {
                    toastr.success("Данные ДСП были успешно обновлены");
                    return this.sheetModal("hide");
                  } else {
                    toastr.success("ДСП была успешно добавлена");
                    $scope.sheetForm.$setPristine();
                    ref = config.sheets;
                    results = [];
                    for (key in ref) {
                      sheet = ref[key];
                      if (sheet.id === data.newSheetId) {
                        results.push(this.sheetModalData = angular.copy(sheet));
                      } else {
                        results.push(void 0);
                      }
                    }
                    return results;
                  }
                } else {
                  if (data.warning) {
                    this.warning = data.warning;
                  }
                  if (data.error) {
                    return this.error = data.error;
                  }
                }
              }
            }).catch(() => {
              this.isSubmitting = false;
              return toastr.error(config.global_labels.defaultErrorMessage.value);
            });
          }
        }

        deleteSheet(deleteSheet) {
          var dataToSend;
          if (!this.isSubmitting) {
            if (confirm("Вы уверены, что хотите удалить данную ДСП?")) {
              this.isSubmitting = true;
              dataToSend = {
                id: deleteSheet.id
              };
              return $http({
                method: 'POST',
                url: config.urls.fasadDeleteSheet,
                data: dataToSend,
                timeout: 30000
              }).then((response) => {
                var data, key, ref, sheet;
                this.isSubmitting = false;
                if (response.data) {
                  data = response.data;
                  if (data.status && (data.status === "success")) {
                    ref = config.sheets;
                    for (key in ref) {
                      sheet = ref[key];
                      if (sheet.id === deleteSheet.id) {
                        config.sheets.splice(key, 1);
                      }
                    }
                    $scope.utilities.setUpdateDates("sheets", data, config.fasad_updates);
                    return toastr.success("ДСП была успешно удалена");
                  } else {
                    if (data.warning) {
                      toastr.warning(data.warning);
                    }
                    if (data.error) {
                      return toastr.warning(data.error);
                    }
                  }
                }
              }).catch(() => {
                this.isSubmitting = false;
                return toastr.error(config.global_labels.defaultErrorMessage.value);
              });
            }
          }
        }

        borderModal(action) {
          $timeout(() => {
            return angular.element("#borderModal").modal(action);
          });
          this.warning = "";
          this.error = "";
          this.addBorderAvailableDimensionId = config.borderDimensions[0].id;
          return $scope.borderForm.$setPristine();
        }

        addBorder() {
          this.borderModalData = {
            is_active: true,
            available_dimensions: []
          };
          return this.borderModal("show");
        }

        editBorder(border) {
          this.borderModalData = angular.copy(border);
          return this.borderModal("show");
        }

        confirmBorderEdit() {
          if (!this.isSubmitting) {
            this.isSubmitting = true;
            this.warning = "";
            this.error = "";
            return $http({
              method: 'POST',
              url: config.urls.fasadAddUpdateBorder,
              data: this.borderModalData,
              timeout: 30000
            }).then((response) => {
              var border, data, key, ref, results;
              this.isSubmitting = false;
              if (response.data) {
                data = response.data;
                if (data.status && (data.status === "success")) {
                  config.borders = angular.copy(data.borders);
                  $scope.utilities.setUpdateDates("borders", data, config.fasad_updates);
                  if (this.borderModalData.id) {
                    toastr.success("Данные кромки были успешно обновлены");
                    return this.borderModal("hide");
                  } else {
                    toastr.success("Кромка была успешно добавлена");
                    $scope.borderForm.$setPristine();
                    ref = config.borders;
                    results = [];
                    for (key in ref) {
                      border = ref[key];
                      if (border.id === data.newBorderId) {
                        results.push(this.borderModalData = angular.copy(border));
                      } else {
                        results.push(void 0);
                      }
                    }
                    return results;
                  }
                } else {
                  if (data.warning) {
                    this.warning = data.warning;
                  }
                  if (data.error) {
                    return this.error = data.error;
                  }
                }
              }
            }).catch(() => {
              this.isSubmitting = false;
              return toastr.error(config.global_labels.defaultErrorMessage.value);
            });
          }
        }

        deleteBorder(deleteBorder) {
          var dataToSend;
          if (!this.isSubmitting) {
            if (confirm("Вы уверены, что хотите удалить данную кромку?")) {
              this.isSubmitting = true;
              dataToSend = {
                id: deleteBorder.id
              };
              return $http({
                method: 'POST',
                url: config.urls.fasadDeleteBorder,
                data: dataToSend,
                timeout: 30000
              }).then((response) => {
                var border, data, key, ref;
                this.isSubmitting = false;
                if (response.data) {
                  data = response.data;
                  if (data.status && (data.status === "success")) {
                    ref = config.borders;
                    for (key in ref) {
                      border = ref[key];
                      if (border.id === deleteBorder.id) {
                        config.borders.splice(key, 1);
                      }
                    }
                    $scope.utilities.setUpdateDates("borders", data, config.fasad_updates);
                    return toastr.success("Кромка была успешно удалена");
                  } else {
                    if (data.warning) {
                      toastr.warning(data.warning);
                    }
                    if (data.error) {
                      return toastr.warning(data.error);
                    }
                  }
                }
              }).catch(() => {
                this.isSubmitting = false;
                return toastr.error(config.global_labels.defaultErrorMessage.value);
              });
            }
          }
        }

        deleteBorderAvailableDimension(deleteAvailableDimension) {
          var availableDimension, key, ref, results;
          ref = this.borderModalData.available_dimensions;
          results = [];
          for (key in ref) {
            availableDimension = ref[key];
            if (availableDimension.border_dimension_id === deleteAvailableDimension.border_dimension_id) {
              this.borderModalData.available_dimensions.splice(key, 1);
              results.push($scope.borderForm.$setDirty());
            } else {
              results.push(void 0);
            }
          }
          return results;
        }

        addBorderAvailableDimension() {
          if (!this.isBorderDimensionAlreadyAdded()) {
            return this.borderModalData.available_dimensions.push({
              border_dimension_id: this.addBorderAvailableDimensionId
            });
          }
        }

        isBorderDimensionAlreadyAdded() {
          var availableDimension, borderDimensionAlreadyAdded, i, len, ref;
          borderDimensionAlreadyAdded = false;
          if (this.borderModalData.available_dimensions) {
            ref = this.borderModalData.available_dimensions;
            for (i = 0, len = ref.length; i < len; i++) {
              availableDimension = ref[i];
              if (availableDimension.border_dimension_id === this.addBorderAvailableDimensionId) {
                borderDimensionAlreadyAdded = true;
              }
            }
          }
          return borderDimensionAlreadyAdded;
        }

        getBorderDimensionLabel(borderDimensionId) {
          var i, label, len, ref, selectedBorderDimension, v;
          label = "";
          ref = config.borderDimensions;
          for (i = 0, len = ref.length; i < len; i++) {
            v = ref[i];
            if (v.id === borderDimensionId) {
              selectedBorderDimension = v;
            }
          }
          if (selectedBorderDimension) {
            label = selectedBorderDimension.label;
          }
          return label;
        }

        uploadImage(files, id, type) {
          if (!this.isSubmitting) {
            if (files && files[0]) {
              this.isSubmitting = true;
              return Upload.upload({
                url: config.urls.fasadUploadImage,
                data: {
                  file: files[0],
                  id: id,
                  type: type
                }
              }).then((response) => {
                var border, data, key, ref, ref1, ref2, results, results1, results2, sheet;
                this.isSubmitting = false;
                data = response.data;
                if (data.status && data.status === "success") {
                  switch (type) {
                    case 'sheetImage':
                      $scope.utilities.setUpdateDates("sheets", data, config.fasad_updates);
                      this.sheetModalData.image = data.image;
                      ref = config.sheets;
                      results = [];
                      for (key in ref) {
                        sheet = ref[key];
                        if (sheet.id === id) {
                          results.push(sheet.image = data.image);
                        } else {
                          results.push(void 0);
                        }
                      }
                      return results;
                      break;
                    case 'sheetThumb':
                      $scope.utilities.setUpdateDates("sheets", data, config.fasad_updates);
                      this.sheetModalData.thumb = data.image;
                      ref1 = config.sheets;
                      results1 = [];
                      for (key in ref1) {
                        sheet = ref1[key];
                        if (sheet.id === id) {
                          results1.push(sheet.thumb = data.image);
                        } else {
                          results1.push(void 0);
                        }
                      }
                      return results1;
                      break;
                    case 'borderImage':
                      $scope.utilities.setUpdateDates("borders", data, config.fasad_updates);
                      this.borderModalData.image = data.image;
                      ref2 = config.borders;
                      results2 = [];
                      for (key in ref2) {
                        border = ref2[key];
                        if (border.id === id) {
                          results2.push(border.image = data.image);
                        } else {
                          results2.push(void 0);
                        }
                      }
                      return results2;
                  }
                } else {
                  return toastr.error('Произошла ошибка при загрузке изображения, повторите позднее!');
                }
              }).catch(() => {
                this.isSubmitting = false;
                return toastr.error('Произошла ошибка при загрузке изображения, повторите позднее!');
              });
            }
          }
        }

      };

      fasadSettings.prototype.isSubmitting = false;

      fasadSettings.prototype.borderModalData = {};

      fasadSettings.prototype.borderDimensionModalData = {};

      fasadSettings.prototype.error = "";

      fasadSettings.prototype.warning = "";

      fasadSettings.prototype.addBorderAvailableDimensionId = null;

      return fasadSettings;

    }).call(this);
    $scope.config = config;
    $scope.utilities = new UtilitiesClass(config,
  $filter,
  $timeout);
    return $scope.settings = new fasadSettings();
  }
]);