PHP CCrmOwnerType类代码示例

 protected static function save()
 {
     $ary = array();
     foreach (self::$items as $entityTypeID => $time) {
         $ary[\CCrmOwnerType::ResolveName($entityTypeID)] = $time->format(\DateTime::ISO8601);
     }
     Main\Config\Option::set('crm', 'crm_uf_history', serialize($ary), '');
 }

 function __CrmDedupeListErrorText(Merger\EntityMergerException $e)
 {
     __IncludeLang(dirname(__FILE__) . '/lang/' . LANGUAGE_ID . '/' . basename(__FILE__));
     $entityTypeID = $e->getEntityTypeID();
     $entityID = $e->getEntityID();
     $code = $e->getCode();
     if ($code === Merger\EntityMergerException::GENERAL) {
         return GetMessage('CRM_DEDUPE_LIST_MERGE_GENERAL_ERROR');
     } elseif ($code === Merger\EntityMergerException::NOT_FOUND) {
         return GetMessage('CRM_DEDUPE_LIST_MERGE_ERROR_NOT_FOUND', array('#ID#' => $entityID));
     }
     $title = CCrmOwnerType::GetCaption($entityTypeID, $entityID, false);
     if (strlen($title) > 20) {
         $title = substr($title, 0, 17) . '...';
     }
     if ($code === Merger\EntityMergerException::READ_DENIED) {
         return GetMessage('CRM_DEDUPE_LIST_MERGE_ERROR_READ_DENIED', array('#TITLE#' => $title, '#ID#' => $entityID));
     } elseif ($code === Merger\EntityMergerException::UPDATE_DENIED) {
         return GetMessage('CRM_DEDUPE_LIST_MERGE_ERROR_UPDATE_DENIED', array('#TITLE#' => $title, '#ID#' => $entityID));
     } elseif ($code === Merger\EntityMergerException::DELETE_DENIED) {
         return GetMessage('CRM_DEDUPE_LIST_MERGE_ERROR_DELETE_DENIED', array('#TITLE#' => $title, '#ID#' => $entityID));
     } elseif ($code === Merger\EntityMergerException::UPDATE_FAILED) {
         return GetMessage('CRM_DEDUPE_LIST_MERGE_ERROR_UPDATE_FAILED', array('#TITLE#' => $title, '#ID#' => $entityID));
     } elseif ($code === Merger\EntityMergerException::DELETE_FAILED) {
         return GetMessage('CRM_DEDUPE_LIST_MERGE_ERROR_DELETE_FAILED', array('#TITLE#' => $title, '#ID#' => $entityID));
     }
     return $e->getMessage();
 }

 public static function GetDocumentNames($ownerTypeID, $ownerID)
 {
     if (!(IsModuleInstalled('bizproc') && CModule::IncludeModule('bizproc'))) {
         return false;
     }
     $ownerTypeID = intval($ownerTypeID);
     $ownerID = intval($ownerID);
     $docName = self::ResolveDocumentName($ownerTypeID);
     if ($docName === '') {
         return array();
     }
     $ownerTypeName = CCrmOwnerType::ResolveName($ownerTypeID);
     if ($ownerTypeName === '') {
         return array();
     }
     /*$arDocumentStates = CBPDocument::GetDocumentStates(
     			array('crm', $docName, $ownerTypeName),
     			array('crm', $docName, $ownerTypeName.'_'.$ownerID)
     		);*/
     $arDocumentStates = CBPStateService::GetDocumentStates(array('crm', $docName, $ownerTypeName . '_' . $ownerID));
     $result = array();
     foreach ($arDocumentStates as $arDocumentState) {
         if ($arDocumentState['ID'] !== '' && $arDocumentState['TEMPLATE_NAME'] !== '') {
             $result[] = $arDocumentState['TEMPLATE_NAME'];
         }
     }
     return $result;
 }

 public function execute(array $contextData = null)
 {
     /** @var DealConverter $converter */
     $converter = $this->converter;
     if (is_array($contextData) && !empty($contextData)) {
         $converter->setContextData(array_merge($converter->getContextData(), $contextData));
     }
     $result = false;
     try {
         $converter->initialize();
         do {
             $converter->executePhase();
         } while ($converter->moveToNextPhase());
         $resultData = $converter->getResultData();
         if (isset($resultData[\CCrmOwnerType::InvoiceName])) {
             $this->redirectUrl = \CCrmOwnerType::GetEditUrl(\CCrmOwnerType::Invoice, $resultData[\CCrmOwnerType::InvoiceName], false);
         } elseif (isset($resultData[\CCrmOwnerType::QuoteName])) {
             $this->redirectUrl = \CCrmOwnerType::GetEditUrl(\CCrmOwnerType::Quote, $resultData[\CCrmOwnerType::QuoteName], false);
         }
         $result = true;
     } catch (EntityConversionException $e) {
         $this->exception = $e;
         if ($e->getTargetType() === EntityConversionException::TARG_DST) {
             $this->redirectUrl = \CCrmOwnerType::GetEditUrl($e->getDestinationEntityTypeID(), 0, false) . '?conv_deal_id=' . $converter->getEntityID();
         }
     } catch (\Exception $e) {
         $this->errorText = $e->getMessage();
     }
     $this->save();
     return $result;
 }

 public function __construct($entityTypeID, $seedID, $targID, $typeID)
 {
     if (!is_int($entityTypeID)) {
         $entityTypeID = (int) $entityTypeID;
     }
     if (!\CCrmOwnerType::IsDefined($entityTypeID)) {
         throw new Main\ArgumentException('Is not defined', 'entityTypeID');
     }
     $this->entityTypeID = $entityTypeID;
     if (!is_int($seedID)) {
         $seedID = (int) $seedID;
     }
     if ($seedID <= 0) {
         throw new Main\ArgumentException('Must be greater than zero', 'seedID');
     }
     $this->seedID = $seedID;
     if (!is_int($targID)) {
         $targID = (int) $targID;
     }
     if ($targID <= 0) {
         throw new Main\ArgumentException('Must be greater than zero', 'targID');
     }
     $this->targID = $targID;
     if (!is_int($typeID)) {
         $typeID = (int) $typeID;
     }
     if (!self::isTypeDefined($typeID)) {
         throw new Main\ArgumentException('Is not defined', 'typeID');
     }
     $this->typeID = $typeID;
 }

 public function __construct($dstEntityTypeID, $srcEntityTypeID, $srcEntityID)
 {
     parent::__construct($dstEntityTypeID);
     $this->srcEntityTypeID = $srcEntityTypeID;
     $this->srcEntityTypeName = \CCrmOwnerType::ResolveName($srcEntityTypeID);
     $this->srcEntityID = $srcEntityID;
 }

 public static function CheckImportPermission($enitityType, $userPermissions = null)
 {
     $enitityTypeName = is_numeric($enitityType) ? CCrmOwnerType::ResolveName($enitityType) : strtoupper(strval($enitityType));
     if (!$userPermissions) {
         $userPermissions = self::GetUserPermissions();
     }
     return !$userPermissions->HavePerm($enitityTypeName, BX_CRM_PERM_NONE, 'IMPORT');
 }

 protected function __construct($entityTypeID)
 {
     if (!is_int($entityTypeID)) {
         throw new Main\ArgumentTypeException('entityTypeID', 'integer');
     }
     if (!\CCrmOwnerType::IsDefined($entityTypeID)) {
         throw new Main\NotSupportedException("Entity ID: '{$entityTypeID}' is not supported in current context");
     }
     $this->entityTypeID = $entityTypeID;
 }

 /**
  * Create conversion map for destination entity type
  * @static
  * @param int $entityTypeID Destination Entity Type ID
  * @return EntityConversionMap
  */
 public static function createMap($entityTypeID)
 {
     if (!is_int($entityTypeID)) {
         $entityTypeID = (int) $entityTypeID;
     }
     if (!\CCrmOwnerType::IsDefined($entityTypeID)) {
         throw new Main\ArgumentOutOfRangeException('dstEntityTypeID', \CCrmOwnerType::FirstOwnerType, \CCrmOwnerType::LastOwnerType);
     }
     if ($entityTypeID !== \CCrmOwnerType::Deal && $entityTypeID !== \CCrmOwnerType::Invoice) {
         $dstEntityTypeName = \CCrmOwnerType::ResolveName($entityTypeID);
         throw new Main\NotSupportedException("Entity type: '{$dstEntityTypeName}' is not supported in current context");
     }
     $map = new EntityConversionMap(\CCrmOwnerType::Quote, $entityTypeID);
     if ($entityTypeID === \CCrmOwnerType::Deal) {
         //region Deal Map Static Field Bindings
         $map->createItem('TITLE');
         $map->createItem('COMMENTS');
         $map->createItem('ASSIGNED_BY_ID');
         $map->createItem('OPENED');
         $map->createItem('OPPORTUNITY');
         $map->createItem('CURRENCY_ID');
         $map->createItem('TAX_VALUE');
         $map->createItem('EXCH_RATE');
         $map->createItem('LOCATION_ID');
         $map->createItem('LEAD_ID');
         $map->createItem('COMPANY_ID');
         $map->createItem('CONTACT_ID');
         $map->createItem('PRODUCT_ROWS');
         //endregion
         //region Invoice Map User Field Bindings
         $intersections = UserFieldSynchronizer::getIntersection(\CCrmOwnerType::Quote, \CCrmOwnerType::Deal);
         foreach ($intersections as $intersection) {
             $map->createItem($intersection['SRC_FIELD_NAME'], $intersection['DST_FIELD_NAME']);
         }
         //endregion
     }
     if ($entityTypeID === \CCrmOwnerType::Invoice) {
         //region Invoice Map Static Field Bindings
         $map->createItem('TITLE', 'ORDER_TOPIC');
         $map->createItem('COMPANY_ID', 'UF_COMPANY_ID');
         $map->createItem('CONTACT_ID', 'UF_CONTACT_ID');
         $map->createItem('DEAL_ID', 'UF_DEAL_ID');
         $map->createItem('ASSIGNED_BY_ID', 'RESPONSIBLE_ID');
         $map->createItem('COMMENTS');
         $map->createItem('PRODUCT_ROWS');
         //endregion
         //region Invoice Map User Field Bindings
         $intersections = UserFieldSynchronizer::getIntersection(\CCrmOwnerType::Quote, \CCrmOwnerType::Invoice);
         foreach ($intersections as $intersection) {
             $map->createItem($intersection['SRC_FIELD_NAME'], $intersection['DST_FIELD_NAME']);
         }
         //endregion
     }
     return $map;
 }

 public function internalize(array $params)
 {
     $this->items = array();
     foreach ($params as $k => $v) {
         $entityTypeID = \CCrmOwnerType::ResolveID($k);
         if ($entityTypeID !== \CCrmOwnerType::Undefined) {
             $item = new EntityConversionConfigItem($entityTypeID);
             $item->internalize($v);
             $this->addItem($item);
         }
     }
 }

 /**
  * @return Duplicate
  */
 public function createDuplicate($entityTypeID, $rootEntityID, $userID, $enablePermissionCheck, $enableRanking, $limit = 0)
 {
     if ($entityTypeID !== \CCrmOwnerType::Lead && $entityTypeID !== \CCrmOwnerType::Contact && $entityTypeID !== \CCrmOwnerType::Company) {
         throw new Main\NotSupportedException("Entity type: '" . \CCrmOwnerType::ResolveName($entityTypeID) . "' is not supported in current context");
     }
     /** @var Duplicate $dup **/
     $dup = new Duplicate($this, array());
     $query = static::createQuery();
     $query->addSelect('ENTITY_ID');
     $query->addFilter('=ENTITY_TYPE_ID', $entityTypeID);
     static::setQueryFilter($query, $this->getMatches());
     if ($enablePermissionCheck) {
         $permissions = isset($params['PERMISSIONS']) ? $params['PERMISSIONS'] : null;
         if ($permissions === null) {
             $permissions = \CCrmPerms::GetUserPermissions($userID);
         }
         $permissionSql = \CCrmPerms::BuildSql(\CCrmOwnerType::ResolveName($entityTypeID), '', 'READ', array('RAW_QUERY' => true, 'PERMS' => $permissions));
         if ($permissionSql === false) {
             //Access denied;
             return null;
         }
         if ($permissionSql !== '') {
             $query->addFilter('@ENTITY_ID', new Main\DB\SqlExpression($permissionSql));
         }
     }
     if ($limit > 0) {
         $query->setLimit($limit);
     }
     if ($rootEntityID > 0) {
         $dup->setRootEntityID($rootEntityID);
         $query->addFilter('!ENTITY_ID', $rootEntityID);
         $query->addFilter('!@ENTITY_ID', DuplicateIndexMismatch::prepareQueryField($this, $entityTypeID, $rootEntityID, $userID));
     }
     $dbResult = $query->exec();
     $rankings = array();
     while ($fields = $dbResult->fetch()) {
         $entityID = isset($fields['ENTITY_ID']) ? intval($fields['ENTITY_ID']) : 0;
         if ($entityID <= 0) {
             continue;
         }
         $entity = new DuplicateEntity($entityTypeID, $entityID);
         if ($enableRanking) {
             $rankings[] = $entity->getRanking();
         }
         $dup->addEntity($entity);
     }
     $this->onAfterDuplicateCreated($dup, $entityTypeID, $userID, $enablePermissionCheck, $enableRanking, $rankings);
     if ($enableRanking) {
         DuplicateEntityRanking::initializeBulk($rankings, array('CHECK_PERMISSIONS' => $enablePermissionCheck, 'USER_ID' => $userID));
     }
     return $dup;
 }

 protected function preparePermissionSql()
 {
     if ($this->permissionSql !== null) {
         return $this->permissionSql;
     }
     $userID = $this->getUserID();
     if (\CCrmPerms::IsAdmin($userID)) {
         $this->permissionSql = '';
     } else {
         $this->permissionSql = \CCrmPerms::BuildSql(\CCrmOwnerType::ResolveName($this->getEntityTypeID()), '', 'READ', array('RAW_QUERY' => true, 'PERMS' => \CCrmPerms::GetUserPermissions($userID)));
     }
     return $this->permissionSql;
 }

 public function setEntityTypeID($entityTypeID)
 {
     if (!is_integer($entityTypeID)) {
         $entityTypeID = intval($entityTypeID);
     }
     if (!\CCrmOwnerType::IsDefined($entityTypeID)) {
         $entityTypeID = \CCrmOwnerType::Undefined;
     }
     if ($this->entityTypeID === $entityTypeID) {
         return;
     }
     $this->entityTypeID = $entityTypeID;
 }

 public static function ParseEntityKey($key, &$entityInfo)
 {
     if (preg_match(self::$ENTITY_KEY, strval($key), $match) !== 1) {
         $entityInfo = array();
         return false;
     }
     $entityTypeAbbr = strtoupper($match[1]);
     $entityID = intval($match[2]);
     $entityTypeID = CCrmOwnerType::ResolveID($entityTypeAbbr);
     $entityTypeName = CCrmOwnerType::ResolveName($entityTypeID);
     $entityInfo = array('ENTITY_TYPE_ABBR' => $entityTypeAbbr, 'ENTITY_TYPE_ID' => $entityTypeID, 'ENTITY_TYPE_NAME' => $entityTypeName, 'ENTITY_ID' => $entityID);
     return true;
 }

 public static function GetDefaultGrigID($entityTypeID)
 {
     $entityTypeID = (int) $entityTypeID;
     if (!CCrmOwnerType::IsDefined($entityTypeID)) {
         return '';
     }
     if ($entityTypeID === CCrmOwnerType::Lead) {
         return 'CRM_LEAD_LIST_V12';
     } elseif ($entityTypeID === CCrmOwnerType::Deal) {
         return 'CRM_DEAL_LIST_V12';
     } elseif ($entityTypeID === CCrmOwnerType::Contact) {
         return 'CRM_CONTACT_LIST_V12';
     } elseif ($entityTypeID === CCrmOwnerType::Company) {
         return 'CRM_COMPANY_LIST_V12';
     }
     return '';
 }