PHP ArrayUtil::resolveArrayToLowerCase方法代码示例

 public function __construct($modelClassName, $attributeName)
 {
     parent::__construct($modelClassName, $attributeName);
     assert('$attributeName == null');
     $states = $this->resolveStates();
     $this->states = ArrayUtil::resolveArrayToLowerCase($states);
 }

 /**
  * @see DataAnalyzerInterface::runAndMakeMessages()
  */
 public function runAndMakeMessages(AnalyzerSupportedDataProvider $dataProvider, $columnName)
 {
     assert('is_string($columnName)');
     $customFieldData = CustomFieldDataModelUtil::getDataByModelClassNameAndAttributeName($this->modelClassName, $this->attributeName);
     $dropDownValues = unserialize($customFieldData->serializedData);
     $dropDownValues = ArrayUtil::resolveArrayToLowerCase($dropDownValues);
     $data = $dataProvider->getCountDataByGroupByColumnName($columnName);
     $count = 0;
     $missingDropDowns = null;
     foreach ($data as $valueCountData) {
         if ($valueCountData[$columnName] == null) {
             continue;
         }
         if ($missingDropDowns != null) {
             $lowerCaseMissingValuesToMap = ArrayUtil::resolveArrayToLowerCase($missingDropDowns);
         } else {
             $lowerCaseMissingValuesToMap = array();
         }
         if (!in_array(strtolower($valueCountData[$columnName]), $dropDownValues) && !in_array(strtolower($valueCountData[$columnName]), $lowerCaseMissingValuesToMap)) {
             $missingDropDowns[] = $valueCountData[$columnName];
             $count++;
         }
     }
     if ($count > 0) {
         $label = '{count} dropdown value(s) are missing from the field. ';
         $label .= 'These values will be added upon import.';
         $this->addMessage(Zurmo::t('ImportModule', $label, array('{count}' => $count)));
     }
     if ($missingDropDowns != null) {
         $instructionsData = array(DropDownSanitizerUtil::ADD_MISSING_VALUE => $missingDropDowns);
         $this->setInstructionsData($instructionsData);
     }
 }

 /**
  * @param RedBean_OODBBean $rowBean
  */
 public function analyzeByRow(RedBean_OODBBean $rowBean)
 {
     $resolvedAcceptableValues = ArrayUtil::resolveArrayToLowerCase(static::getAcceptableValues());
     if (!in_array(strtolower($rowBean->{$this->columnName}), $resolvedAcceptableValues)) {
         $label = Zurmo::t('ImportModule', '{attributeLabel} specified is invalid and this row will be skipped during import.', array('{attributeLabel}' => ProductTemplate::getAnAttributeLabel('sellPriceFormula')));
         $this->shouldSkipRow = true;
         $this->analysisMessages[] = $label;
     }
 }

 /**
  * @param RedBean_OODBBean $rowBean
  */
 public function analyzeByRow(RedBean_OODBBean $rowBean)
 {
     $states = $this->resolveStates();
     $states = ArrayUtil::resolveArrayToLowerCase($states);
     if ($rowBean->{$this->columnName} != null && !in_array(strtolower($rowBean->{$this->columnName}), $states)) {
         $label = Zurmo::t('ImportModule', 'Is invalid.');
         $this->shouldSkipRow = true;
         $this->analysisMessages[] = $label;
     }
 }

 /**
  * @see BatchAttributeValueDataAnalyzer::analyzeByValue()
  */
 protected function analyzeByValue($value)
 {
     if ($value != null) {
         $lowerCaseMissingValuesToMap = ArrayUtil::resolveArrayToLowerCase($this->missingDropDownInstructions[DropDownSanitizerUtil::ADD_MISSING_VALUE]);
         if (!in_array(strtolower($value), $this->dropDownValues) && !in_array(strtolower($value), $lowerCaseMissingValuesToMap)) {
             $this->missingDropDownInstructions[DropDownSanitizerUtil::ADD_MISSING_VALUE][] = $value;
             $this->messageCountData[static::INVALID]++;
         }
     }
 }

 /**
  * (non-PHPdoc)
  * @see DropDownBatchAttributeValueDataAnalyzer::analyzeByValue()
  */
 protected function analyzeByValue($value)
 {
     if ($value != null) {
         $customFieldValues = MultiSelectDropDownSanitizerUtil::getCustomFieldValuesFromValueString($value);
         foreach ($customFieldValues as $aValue) {
             $lowerCaseMissingValuesToMap = ArrayUtil::resolveArrayToLowerCase($this->missingDropDownInstructions[DropDownSanitizerUtil::ADD_MISSING_VALUE]);
             if (!in_array(strtolower($aValue), $this->dropDownValues) && !in_array(strtolower($aValue), $lowerCaseMissingValuesToMap)) {
                 $this->missingDropDownInstructions[DropDownSanitizerUtil::ADD_MISSING_VALUE][] = $aValue;
                 $this->messageCountData[static::INVALID]++;
             }
         }
     }
 }

 public function sanitizeValue($value)
 {
     $resolvedAcceptableValues = ArrayUtil::resolveArrayToLowerCase(static::getAcceptableValues());
     if ($value != null) {
         if (!in_array(strtolower($value), $resolvedAcceptableValues)) {
             return null;
         }
         return $value;
     }
     if (isset($this->mappingRuleData['defaultValue']) && $this->mappingRuleData['defaultValue'] != null) {
         if (!in_array(strtolower($this->mappingRuleData['defaultValue']), $resolvedAcceptableValues)) {
             return null;
         }
         return $this->mappingRuleData['defaultValue'];
     }
 }

 public function sanitizeValue($value)
 {
     $resolvedAcceptableValues = ArrayUtil::resolveArrayToLowerCase(static::getAcceptableValues());
     if ($value != null) {
         if (!in_array(strtolower($value), $resolvedAcceptableValues)) {
             return null;
         }
         $currency = Currency::getByCode($value);
         if ($currency != null) {
             return $currency;
         }
     }
     if (isset($this->mappingRuleData['defaultValue']) && $this->mappingRuleData['defaultValue'] != null) {
         $currency = Currency::getById(intval($this->mappingRuleData['defaultValue']));
         if ($currency != null) {
             return $currency;
         }
     }
 }

 /**
  * @see LinkedToMappingRuleDataAnalyzerInterface::runAndMakeMessages()
  */
 public function runAndMakeMessages(AnalyzerSupportedDataProvider $dataProvider, $columnName, $mappingRuleType, $mappingRuleData)
 {
     assert('is_string($columnName)');
     assert('is_string($mappingRuleType)');
     assert('is_array($mappingRuleData)');
     assert('is_int($mappingRuleData["type"])');
     assert('$mappingRuleData["type"] == UserValueTypeModelAttributeMappingRuleForm::ZURMO_USER_ID ||
                 $mappingRuleData["type"] == UserValueTypeModelAttributeMappingRuleForm::EXTERNAL_SYSTEM_USER_ID ||
                 $mappingRuleData["type"] == UserValueTypeModelAttributeMappingRuleForm::ZURMO_USERNAME');
     $this->type = $mappingRuleData["type"];
     if ($mappingRuleData['type'] == UserValueTypeModelAttributeMappingRuleForm::ZURMO_USER_ID) {
         $this->acceptableValues = UserValueTypeSanitizerUtil::getUserIds();
     } elseif ($mappingRuleData['type'] == UserValueTypeModelAttributeMappingRuleForm::EXTERNAL_SYSTEM_USER_ID) {
         $this->acceptableValues = UserValueTypeSanitizerUtil::getUserExternalSystemIds();
     } else {
         $acceptableValues = UserValueTypeSanitizerUtil::getUsernames();
         $this->acceptableValues = ArrayUtil::resolveArrayToLowerCase($acceptableValues);
     }
     $this->processAndMakeMessage($dataProvider, $columnName);
 }

 public function runAndMakeMessages(AnalyzerSupportedDataProvider $dataProvider, $columnName)
 {
     assert('is_string($columnName)');
     $dropDownValues = $this->resolveStates();
     $dropDownValues = ArrayUtil::resolveArrayToLowerCase($dropDownValues);
     $data = $dataProvider->getCountDataByGroupByColumnName($columnName);
     $count = 0;
     foreach ($data as $valueCountData) {
         if ($valueCountData[$columnName] == null) {
             continue;
         }
         if (!in_array(strtolower($valueCountData[$columnName]), $dropDownValues)) {
             $count++;
         }
     }
     if ($count > 0) {
         $label = '{count} value(s) are not valid. ';
         $label .= 'Rows that have these values will be skipped during import.';
         $this->addMessage(Zurmo::t('ContactsModule', $label, array('{count}' => $count)));
     }
 }

 /**
  * Given a value, resolve that the value is a valid custom field data value. If the value does not exist yet,
  * check the import instructions data to determine how to handle the missing value.
  *
  * Example of importInstructionsData
  * array('DropDown' => array(DropDownSanitizerUtil::ADD_MISSING_VALUE => array('neverPresent', 'notPresent')))
  *
  * @param string $modelClassName
  * @param string $attributeName
  * @param mixed $value
  * @param array $mappingRuleData
  * @param array $importInstructionsData
  */
 public static function sanitizeValueWithInstructions($modelClassName, $attributeName, $value, $mappingRuleData, $importInstructionsData)
 {
     assert('is_string($modelClassName)');
     assert('is_string($attributeName)');
     assert('$mappingRuleData == null');
     if (!isset($importInstructionsData["DropDown"][DropDownSanitizerUtil::ADD_MISSING_VALUE])) {
         $importInstructionsData["DropDown"][DropDownSanitizerUtil::ADD_MISSING_VALUE] = array();
     }
     if ($value == null) {
         return $value;
     }
     $customFieldData = CustomFieldDataModelUtil::getDataByModelClassNameAndAttributeName($modelClassName, $attributeName);
     $dropDownValues = unserialize($customFieldData->serializedData);
     $lowerCaseDropDownValues = ArrayUtil::resolveArrayToLowerCase($dropDownValues);
     $generateMissingPickListError = false;
     //does the value already exist in the custom field data
     if (in_array(TextUtil::strToLowerWithDefaultEncoding($value), $lowerCaseDropDownValues)) {
         $keyToUse = array_search(TextUtil::strToLowerWithDefaultEncoding($value), $lowerCaseDropDownValues);
         $resolvedValueToUse = $dropDownValues[$keyToUse];
     } else {
         //if the value does not already exist, then check the instructions data.
         $lowerCaseValuesToAdd = ArrayUtil::resolveArrayToLowerCase($importInstructionsData['DropDown'][DropDownSanitizerUtil::ADD_MISSING_VALUE]);
         if (in_array(TextUtil::strToLowerWithDefaultEncoding($value), $lowerCaseValuesToAdd)) {
             $keyToAddAndUse = array_search(TextUtil::strToLowerWithDefaultEncoding($value), $lowerCaseValuesToAdd);
             $resolvedValueToUse = $importInstructionsData['DropDown'][DropDownSanitizerUtil::ADD_MISSING_VALUE][$keyToAddAndUse];
             $unserializedData = unserialize($customFieldData->serializedData);
             $unserializedData[] = $resolvedValueToUse;
             $customFieldData->serializedData = serialize($unserializedData);
             $saved = $customFieldData->save();
             assert('$saved');
         } elseif (isset($importInstructionsData['DropDown'][DropDownSanitizerUtil::MAP_MISSING_VALUES])) {
             $lowerCaseMissingValuesToMap = ArrayUtil::resolveArrayToLowerCase($importInstructionsData['DropDown'][DropDownSanitizerUtil::MAP_MISSING_VALUES]);
             if (isset($lowerCaseMissingValuesToMap[TextUtil::strToLowerWithDefaultEncoding($value)])) {
                 $keyToUse = array_search($lowerCaseMissingValuesToMap[TextUtil::strToLowerWithDefaultEncoding($value)], $lowerCaseDropDownValues);
                 if ($keyToUse === false) {
                     $message = 'Pick list value specified is missing from existing pick list, has a specified mapping value' . ', but the mapping value is not a valid value.';
                     throw new InvalidValueToSanitizeException(Zurmo::t('ImportModule', $message));
                 } else {
                     $resolvedValueToUse = $dropDownValues[$keyToUse];
                 }
             } else {
                 $generateMissingPickListError = true;
             }
         } else {
             $generateMissingPickListError = true;
         }
         if ($generateMissingPickListError) {
             $message = 'Pick list value specified is missing from existing pick list and no valid instructions' . ' were provided on how to resolve this.';
             throw new InvalidValueToSanitizeException(Zurmo::t('ImportModule', $message));
         }
     }
     $customField = new OwnedCustomField();
     $customField->value = $resolvedValueToUse;
     $customField->data = $customFieldData;
     return $customField;
 }

 protected function getAcceptableValues()
 {
     if ($this->mappingRuleData['type'] == UserValueTypeModelAttributeMappingRuleForm::ZURMO_USER_ID) {
         return UserValueTypeSanitizerUtil::getUserIds();
     } elseif ($this->mappingRuleData['type'] == UserValueTypeModelAttributeMappingRuleForm::EXTERNAL_SYSTEM_USER_ID) {
         return UserValueTypeSanitizerUtil::getUserExternalSystemIds();
     } else {
         $acceptableValues = UserValueTypeSanitizerUtil::getUsernames();
         return ArrayUtil::resolveArrayToLowerCase($acceptableValues);
     }
 }

 protected static function processMissingValueToMapAndGetResolvedValueToUse($aValue, &$generateMissingPickListError, array $customFieldsInstructionData, array $dropDownValues, array $lowerCaseDropDownValues)
 {
     assert('is_string($aValue)');
     assert('is_bool($generateMissingPickListError)');
     $lowerCaseMissingValuesToMap = ArrayUtil::resolveArrayToLowerCase($customFieldsInstructionData[CustomFieldsInstructionData::MAP_MISSING_VALUES]);
     if (isset($lowerCaseMissingValuesToMap[mb_strtolower($aValue)])) {
         $keyToUse = array_search($lowerCaseMissingValuesToMap[mb_strtolower($aValue)], $lowerCaseDropDownValues);
         if ($keyToUse === false) {
             throw new InvalidValueToSanitizeException(Zurmo::t('ImportModule', 'Pick list value specified is ' . 'missing from existing pick list, has a specified mapping value, ' . 'but the mapping value is not a valid value.'));
         } else {
             return $dropDownValues[$keyToUse];
         }
     } else {
         $generateMissingPickListError = true;
     }
 }

 /**
  * Check whether the specified value corresponds to a valid username of a user model.
  * @param AnalyzerSupportedDataProvider $dataProvider
  * @param string $columnName
  */
 protected function resolveForTypeUsername(AnalyzerSupportedDataProvider $dataProvider, $columnName)
 {
     assert('is_string($columnName)');
     $usernameValues = UserValueTypeSanitizerUtil::getUsernames();
     $usernameValues = ArrayUtil::resolveArrayToLowerCase($usernameValues);
     $data = $dataProvider->getCountDataByGroupByColumnName($columnName);
     $count = 0;
     foreach ($data as $valueCountData) {
         if ($valueCountData[$columnName] == null) {
             continue;
         }
         if (!in_array(TextUtil::strToLowerWithDefaultEncoding($valueCountData[$columnName]), $usernameValues)) {
             $count++;
         }
     }
     if ($count > 0) {
         $label = '{count} username(s) specified were not found. ';
         $label .= 'These values will not be used during the import.';
         $this->addMessage(Zurmo::t('ImportModule', $label, array('{count}' => $count)));
     }
 }

 protected static function processMissingValueToMapAndGetResolvedValueToUse($aValue, &$generateMissingPickListError, $importInstructionsData)
 {
     assert('is_string($aValue)');
     assert('is_bool($generateMissingPickListError)');
     assert('is_array($importInstructionsData)');
     $lowerCaseMissingValuesToMap = ArrayUtil::resolveArrayToLowerCase($importInstructionsData['MultiSelectDropDown'][DropDownSanitizerUtil::MAP_MISSING_VALUES]);
     if (isset($lowerCaseMissingValuesToMap[mb_strtolower($aValue)])) {
         $keyToUse = array_search($lowerCaseMissingValuesToMap[mb_strtolower($aValue)], $lowerCaseDropDownValues);
         if ($keyToUse === false) {
             $message = 'Pick list value specified is missing from existing pick list, has a specified mapping value' . ', but the mapping value is not a valid value.';
             throw new InvalidValueToSanitizeException(Zurmo::t('ImportModule', $message));
         } else {
             return $dropDownValues[$keyToUse];
         }
     } else {
         $generateMissingPickListError = true;
     }
 }