<?php

IncludeModuleLangFile(__FILE__);

use Bitrix\Main\Config\Option;
use Bitrix\Main\Context;
use Bitrix\Main\Loader;
use Bitrix\Main\ModuleManager;
use Bitrix\Main\Text\Emoji;
use Bitrix\Socialnetwork\FeatureTable;
use Bitrix\Socialnetwork\Helper\Workgroup;
use Bitrix\Socialnetwork\Helper\Path;
use Bitrix\Socialnetwork\Internals\Registry\GroupRegistry;
use Bitrix\Socialnetwork\Item\Workgroup\AvatarType;
use Bitrix\Socialnetwork\Item\Workgroup\Type;
use Bitrix\Socialnetwork\UserToGroupTable;
use Bitrix\Tasks\Util\Restriction\Bitrix24Restriction\Limit\ProjectLimit;
use Bitrix\Tasks\Util\Restriction\Bitrix24Restriction\Limit\ScrumLimit;
use Bitrix\Tasks\Control\Tag;
use Bitrix\Socialnetwork\Internals\EventService;

class CAllSocNetGroup
{
	protected static $staticCache = array();

	/***************************************/
	/********  DATA MODIFICATION  **********/
	/***************************************/
	public static function CheckFields($ACTION, &$arFields, $ID = 0): bool
	{
		global $DB, $APPLICATION, $USER_FIELD_MANAGER, $arSocNetAllowedInitiatePerms, $arSocNetAllowedSpamPerms;

		if ($ACTION !== "ADD" && (int)$ID <= 0)
		{
			$APPLICATION->ThrowException("System error 870164", "ERROR");
			return false;
		}

		if(
			($ID === 0 && !is_set($arFields, "SITE_ID"))
			||
			(
				is_set($arFields, "SITE_ID")
				&& (
					(is_array($arFields["SITE_ID"]) && count($arFields["SITE_ID"]) <= 0)
					||
					(!is_array($arFields["SITE_ID"]) && $arFields["SITE_ID"] == '')
				)
			)
		)
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GG_EMPTY_SITE_ID"), "EMPTY_SITE_ID");
			return false;
		}
		elseif(is_set($arFields, "SITE_ID"))
		{
			if(!is_array($arFields["SITE_ID"]))
				$arFields["SITE_ID"] = array($arFields["SITE_ID"]);

			foreach($arFields["SITE_ID"] as $v)
			{
				$r = CSite::GetByID($v);
				if(!$r->Fetch())
				{
					$APPLICATION->ThrowException(str_replace("#ID#", $v, GetMessage("SONET_GG_ERROR_NO_SITE")), "ERROR_NO_SITE");
					return false;
				}
			}
		}

		if ((is_set($arFields, "NAME") || $ACTION === "ADD") && ($arFields["NAME"] ?? '') === '')
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GB_EMPTY_NAME"), "EMPTY_NAME");
			return false;
		}

		if (is_set($arFields, "DATE_CREATE") && (!$DB->IsDate($arFields["DATE_CREATE"], false, LANG, "FULL")))
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GB_EMPTY_DATE_CREATE"), "EMPTY_DATE_CREATE");
			return false;
		}

		if (is_set($arFields, "DATE_UPDATE") && (!$DB->IsDate($arFields["DATE_UPDATE"], false, LANG, "FULL")))
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GB_EMPTY_DATE_UPDATE"), "EMPTY_DATE_UPDATE");
			return false;
		}

		if (is_set($arFields, "DATE_ACTIVITY") && (!$DB->IsDate($arFields["DATE_ACTIVITY"], false, LANG, "FULL")))
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GB_EMPTY_DATE_ACTIVITY"), "EMPTY_DATE_ACTIVITY");
			return false;
		}

		if ((is_set($arFields, "OWNER_ID") || $ACTION === "ADD") && (int)$arFields["OWNER_ID"] <= 0)
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GB_EMPTY_OWNER_ID"), "EMPTY_OWNER_ID");
			return false;
		}

		if (is_set($arFields, "OWNER_ID"))
		{
			$dbResult = CUser::GetByID($arFields["OWNER_ID"]);
			if (!$dbResult->Fetch())
			{
				$APPLICATION->ThrowException(GetMessage("SONET_GB_ERROR_NO_OWNER_ID"), "ERROR_NO_OWNER_ID");
				return false;
			}
		}

		if ((is_set($arFields, "SUBJECT_ID") || $ACTION === "ADD") && (int)$arFields["SUBJECT_ID"] <= 0)
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GB_EMPTY_SUBJECT_ID"), "EMPTY_SUBJECT_ID");
			return false;
		}

		if (is_set($arFields, "SUBJECT_ID"))
		{
			$arResult = CSocNetGroupSubject::GetByID($arFields["SUBJECT_ID"]);
			if ($arResult == false)
			{
				$APPLICATION->ThrowException(GetMessage("SONET_GB_ERROR_NO_SUBJECT_ID"), "ERROR_NO_SUBJECT_ID");
				return false;
			}
		}

		if ((is_set($arFields, "ACTIVE") || $ACTION === "ADD") && $arFields["ACTIVE"] !== "Y" && $arFields["ACTIVE"] !== "N")
		{
			$arFields["ACTIVE"] = "Y";
		}

		if (
			(is_set($arFields, "VISIBLE") || $ACTION === "ADD")
			&& ($arFields["VISIBLE"] ?? null) !== "Y"
			&& ($arFields["VISIBLE"] ?? null) !== "N"
		)
		{
			$arFields["VISIBLE"] = "Y";
		}

		if (
			(is_set($arFields, "OPENED") || $ACTION === "ADD")
			&& ($arFields["OPENED"] ?? null) !== "Y"
			&& ($arFields["OPENED"] ?? null) !== "N"
		)
		{
			$arFields["OPENED"] = "N";
		}

		if (
			(is_set($arFields, "CLOSED") || $ACTION=="ADD")
			&& ($arFields["CLOSED"] ?? null) != "Y"
			&& ($arFields["CLOSED"] ?? null) !== "N"
		)
		{
			$arFields["CLOSED"] = "N";
		}

		if ((is_set($arFields, "INITIATE_PERMS") || $ACTION === "ADD") && $arFields["INITIATE_PERMS"] == '')
		{
			$APPLICATION->ThrowException(GetMessage("SONET_UG_EMPTY_INITIATE_PERMS"), "EMPTY_INITIATE_PERMS");
			return false;
		}

		if (is_set($arFields, "INITIATE_PERMS") && !in_array($arFields["INITIATE_PERMS"], $arSocNetAllowedInitiatePerms))
		{
			$APPLICATION->ThrowException(str_replace("#ID#", $arFields["INITIATE_PERMS"], GetMessage("SONET_UG_ERROR_NO_INITIATE_PERMS")), "ERROR_NO_INITIATE_PERMS");
			return false;
		}

		if ((is_set($arFields, "SPAM_PERMS") || $ACTION === "ADD") && $arFields["SPAM_PERMS"] == '')
		{
			$APPLICATION->ThrowException(GetMessage("SONET_UG_EMPTY_SPAM_PERMS"), "EMPTY_SPAM_PERMS");
			return false;
		}

		if (is_set($arFields, "SPAM_PERMS") && !in_array($arFields["SPAM_PERMS"], $arSocNetAllowedSpamPerms))
		{
			$APPLICATION->ThrowException(str_replace("#ID#", $arFields["SPAM_PERMS"], GetMessage("SONET_UG_ERROR_NO_SPAM_PERMS")), "ERROR_NO_SPAM_PERMS");
			return false;
		}

		if (
			is_set($arFields, "IMAGE_ID")
			&& is_array($arFields["IMAGE_ID"])
			&& ($arFields["IMAGE_ID"]["name"] ?? '') == ''
			&& (($arFields["IMAGE_ID"]["del"] ?? null) == '' || $arFields["IMAGE_ID"]["del"] !== "Y")
		)
		{
			unset($arFields["IMAGE_ID"]);
		}

		if (is_set($arFields, "IMAGE_ID"))
		{
			$arResult = CFile::CheckImageFile($arFields["IMAGE_ID"]);
			if ($arResult <> '')
			{
				$APPLICATION->ThrowException(GetMessage("SONET_GP_ERROR_IMAGE_ID").": ".$arResult, "ERROR_IMAGE_ID");
				return false;
			}
		}

		$avatarType = $arFields['AVATAR_TYPE'] ?? null;
		if (
			is_set($arFields, 'AVATAR_TYPE')
			&& !array_key_exists($arFields['AVATAR_TYPE'], Workgroup::getAvatarTypes())
		)
		{
			unset($arFields['AVATAR_TYPE']);
		}

		$canSetEmptyAvatarType =
			($arFields['TYPE'] ?? null) === Type::Collab->value
			&& $avatarType === AvatarType::None->value
		;

		if ($canSetEmptyAvatarType)
		{
			$arFields['AVATAR_TYPE'] = '';
		}

		if (!$USER_FIELD_MANAGER->CheckFields("SONET_GROUP", $ID, $arFields))
		{
			return false;
		}

		if (!empty($arFields['NAME']))
		{
			$arFields['NAME'] = Emoji::encode($arFields['NAME']);
		}

		if (isset($arFields['NAME']))
		{
			$isCollab = $arFields['TYPE'] === Bitrix\Socialnetwork\Item\Workgroup\Type::Collab->value;
			$isCheckNameNeeded = $isCollab || (Option::get('socialnetwork', 'check_group_name_enable', 'Y') === 'Y');

			if ($isCheckNameNeeded)
			{
				$groupProvider = Bitrix\Socialnetwork\Provider\GroupProvider::getInstance();

				if ($groupProvider->isExistingGroup($arFields['NAME'], $ID))
				{
					$APPLICATION->ThrowException(GetMessage("SONET_ERROR_SAME_GROUP_NAME_EXISTS"), 'ERROR_GROUP_NAME_EXISTS');
					return false;
				}
			}
		}

		if (!empty($arFields['DESCRIPTION']))
		{
			$arFields['DESCRIPTION'] = Emoji::encode($arFields['DESCRIPTION']);
		}

		if (isset($arFields['TYPE']))
		{
			if (!Type::isValid($arFields['TYPE']))
			{
				$APPLICATION->ThrowException('Wrong type', 'WRONG_GROUP_TYPE');
				return false;
			}

			$arFields['TYPE'] = Type::getValue($arFields['TYPE']);
		}

		if (!is_string($arFields['KEYWORDS'] ?? ''))
		{
			unset($arFields['KEYWORDS']);
		}

		return true;
	}

	public static function Delete($ID)
	{
		global $DB, $APPLICATION, $CACHE_MANAGER, $USER_FIELD_MANAGER;

		if (!CSocNetGroup::__ValidateID($ID))
		{
			return false;
		}

		$ID = intval($ID);

		$db_events = GetModuleEvents("socialnetwork", "OnBeforeSocNetGroupDelete");
		while ($arEvent = $db_events->Fetch())
		{
			if (ExecuteModuleEventEx($arEvent, array($ID))===false)
			{
				return false;
			}
		}

		$queryObject = \Bitrix\Socialnetwork\WorkgroupTable::getList([
			'filter' => ['ID' => $ID],
			'select' => ['IMAGE_ID', 'NAME', 'PROJECT', 'TYPE'],
		]);
		$arGroup = $queryObject->fetch();
		if (!$arGroup)
		{
			$APPLICATION->ThrowException(GetMessage("SONET_NO_GROUP"), "ERROR_NO_GROUP");
			return false;
		}

		$isCollab = $arGroup['TYPE'] === Type::Collab->value;

		$DB->StartTransaction();

		$events = GetModuleEvents("socialnetwork", "OnSocNetGroupDelete");
		while ($arEvent = $events->Fetch())
		{
			ExecuteModuleEventEx($arEvent, array($ID));
		}

		EventService\Service::addEvent(EventService\EventDictionary::EVENT_WORKGROUP_DELETE, [
			'GROUP_ID' => $ID,
		]);

		$res = UserToGroupTable::getList([
			'filter' => [
				'=GROUP_ID' => $ID
			],
			'select' => [ 'USER_ID' ]
		]);
		while($relationFields = $res->fetch())
		{
			CSocNetSearch::onUserRelationsChange($relationFields['USER_ID']);
		}
		$bSuccess = $DB->Query("DELETE FROM b_sonet_user2group WHERE GROUP_ID = ".$ID, true);

		if ($bSuccess)
		{
			if (!$isCollab)
			{
				Bitrix\Socialnetwork\Integration\Im\Chat\Workgroup::unlinkChat([
					'group_id' => $ID,
					'group_name' => $arGroup['NAME'],
					'group_project' => $arGroup['PROJECT'],
				]);
			}

			$bSuccessTmp = true;
			$dbResult = CSocNetFeatures::GetList(
				array(),
				array("ENTITY_ID" => $ID, "ENTITY_TYPE" => SONET_ENTITY_GROUP)
			);
			while ($arResult = $dbResult->Fetch())
			{
				$bSuccessTmp = $DB->Query("DELETE FROM b_sonet_features2perms WHERE FEATURE_ID = ".$arResult["ID"]."", true);
				if (!$bSuccessTmp)
				{
					break;
				}
			}
			if (!$bSuccessTmp)
			{
				$bSuccess = false;
			}
		}
		if ($bSuccess)
		{
			$bSuccess = $DB->Query("DELETE FROM b_sonet_features WHERE ENTITY_ID = ".$ID." AND ENTITY_TYPE = '".$DB->ForSql(SONET_ENTITY_GROUP, 1)."'", true);
		}
		if ($bSuccess)
		{
			$dbResult = CSocNetLog::GetList(
				array(),
				array("ENTITY_ID" => $ID, "ENTITY_TYPE" => SONET_ENTITY_GROUP),
				false,
				false,
				array("ID")
			);
			while ($arResult = $dbResult->Fetch())
			{
				$bSuccessTmp = $DB->Query("DELETE FROM b_sonet_log_site WHERE LOG_ID = ".$arResult["ID"]."", true);
				if (!$bSuccessTmp)
				{
					break;
				}

				$bSuccessTmp = $DB->Query("DELETE FROM b_sonet_log_right WHERE LOG_ID = ".$arResult["ID"]."", true);
				if (!$bSuccessTmp)
				{
					break;
				}
			}
			if (!$bSuccessTmp)
			{
				$bSuccess = false;
			}
		}
		if ($bSuccess)
		{
			$bSuccess = $DB->Query("DELETE FROM b_sonet_log WHERE ENTITY_TYPE = '".SONET_ENTITY_GROUP."' AND ENTITY_ID = ".$ID."", true);
		}
		if ($bSuccess)
		{
			$bSuccess = CSocNetLog::DeleteSystemEventsByGroupID($ID);
		}
		if ($bSuccess)
		{
			$bSuccess = $DB->Query("DELETE FROM b_sonet_log_events WHERE ENTITY_TYPE = 'G' AND ENTITY_ID = ".$ID."", true);
		}
		if ($bSuccess)
		{
			$bSuccess = $DB->Query("DELETE FROM b_sonet_group_site WHERE GROUP_ID = ".$ID."", true);
		}
		if ($bSuccess)
		{
			$bSuccess = $DB->Query("DELETE FROM b_sonet_log_right WHERE GROUP_CODE LIKE 'OSG".$ID."\_%'", true);
		}
		if ($bSuccess)
		{
			$bSuccess = $DB->Query("DELETE FROM b_sonet_log_right WHERE GROUP_CODE LIKE 'SG".$ID."\_%'", true);
		}
		if ($bSuccess)
		{
			$bSuccess = $DB->Query("DELETE FROM b_sonet_log_right WHERE GROUP_CODE = 'SG".$ID."'", true);
		}
		if ($bSuccess)
		{
			$bSuccess = CSocNetSubscription::DeleteEx(false, "SG".$ID);
		}
		if ($bSuccess)
		{
			$bSuccess = \Bitrix\Socialnetwork\WorkgroupTagTable::deleteByGroupId(['groupId' => $ID]);
		}

		if ($bSuccess)
		{
			CFile::Delete($arGroup["IMAGE_ID"]);
			$bSuccess = $DB->Query("DELETE FROM b_sonet_group WHERE ID = ".$ID."", true);
		}

		$sonetGroupCache = self::getStaticCache();

		if ($bSuccess)
		{
			CUserOptions::DeleteOption("socialnetwork", "~menu_".SONET_ENTITY_GROUP."_".$ID, false, 0);

			unset($sonetGroupCache[$ID]);
			self::setStaticCache($sonetGroupCache);
			GroupRegistry::getInstance()->invalidate($ID);
			FeatureTable::cleanCache();
		}

		if ($bSuccess)
		{
			$DB->Commit();
		}
		else
		{
			$DB->Rollback();
		}

		if ($bSuccess)
		{
			unset($sonetGroupCache[$ID]);
			self::setStaticCache($sonetGroupCache);

			if(defined("BX_COMP_MANAGED_CACHE"))
			{
				$CACHE_MANAGER->ClearByTag("sonet_user2group_G".$ID);
				$CACHE_MANAGER->ClearByTag("sonet_user2group");
				$CACHE_MANAGER->ClearByTag("sonet_group_".$ID);
				$CACHE_MANAGER->ClearByTag("sonet_group");
			}
		}

		if (
			$bSuccess
			&& CModule::IncludeModule("search")
		)
		{
			CSearch::DeleteIndex("socialnetwork", "G".$ID);
		}

		if ($bSuccess)
		{
			$DB->Query("DELETE FROM b_sonet_event_user_view WHERE ENTITY_TYPE = '".SONET_ENTITY_GROUP."' AND ENTITY_ID = ".$ID, true);
		}

		if ($bSuccess)
		{
			$USER_FIELD_MANAGER->Delete("SONET_GROUP", $ID);
		}

		$groupId = (int)$ID;
		if ($bSuccess && $groupId > 0)
		{
			GroupRegistry::getInstance()->invalidate($groupId);
		}

		if (Loader::includeModule('tasks'))
		{
			$tagService = new Tag(0);
			$tagService->deleteGroupTags($ID);
		}

		return $bSuccess;
	}

	public static function DeleteNoDemand($userID): bool
	{
		global $APPLICATION;

		if (!CSocNetGroup::__ValidateID($userID))
		{
			return false;
		}

		$userID = intval($userID);

		$err = "";
		$dbResult = CSocNetGroup::GetList(array(), array("OWNER_ID" => $userID), false, false, array("ID", "NAME"));
		while ($arResult = $dbResult->GetNext())
		{
			$err .= Emoji::decode($arResult["NAME"]) . "<br>";
		}

		if ($err == '')
		{
			return true;
		}
		else
		{
			$err = GetMessage("SONET_GG_ERROR_CANNOT_DELETE_USER_1").$err;
			$err .= GetMessage("SONET_GG_ERROR_CANNOT_DELETE_USER_2");
			$APPLICATION->ThrowException($err);
			return false;
		}
	}

	public static function SetStat($ID, int $currentUserId = 0): void
	{
		if (!CSocNetGroup::__ValidateID($ID))
			return;

		$ID = intval($ID);

		$num = CSocNetUserToGroup::GetList(
			array(),
			array(
				"GROUP_ID" => $ID,
				"USER_ACTIVE" => "Y",
				"<=ROLE" => SONET_ROLES_USER
			),
			array()
		);

		$num_mods = CSocNetUserToGroup::GetList(
			array(),
			array(
				"GROUP_ID" => $ID,
				"USER_ACTIVE" => "Y",
				"<=ROLE" => SONET_ROLES_MODERATOR
			),
			array()
		);

		CSocNetGroup::Update(
			$ID,
			array(
				"NUMBER_OF_MEMBERS" => $num,
				"NUMBER_OF_MODERATORS" => $num_mods,
				'INITIATED_BY_USER_ID' => $currentUserId,
			),
			true,
			false,
			false
		);
	}

	public static function SetLastActivity($ID, $date = false): void
	{
		global $DB, $CACHE_MANAGER;

		if (!CSocNetGroup::__ValidateID($ID))
		{
			return;
		}

		$ID = intval($ID);

		CSocNetGroup::Update($ID, (
			$date
				? array("DATE_ACTIVITY" => $date)
				: array("=DATE_ACTIVITY" => $DB->CurrentTimeFunction())
			),
			true,
			false,
			false
		);

		if (defined("BX_COMP_MANAGED_CACHE"))
		{
			$CACHE_MANAGER->clearByTag("sonet_group_activity");
		}
	}

	/***************************************/
	/**********  DATA SELECTION  ***********/
	/***************************************/
	public static function getById($id, $checkPermissions = false, array $options = [])
	{
		global $USER, $CACHE_MANAGER;

		$id = (int)$id;

		if (!CSocNetGroup::__ValidateID($id))
		{
			return false;
		}

		$staticCacheKey = implode('_', array_merge([
			($checkPermissions ? 'Y' : 'N'),
		], $options));

		$sonetGroupCache = self::getStaticCache();

		if (
			is_array($sonetGroupCache)
			&& is_array(($sonetGroupCache[$id] ?? null))
			&& is_array(($sonetGroupCache[$id][$staticCacheKey] ?? null))
		)
		{
			return $sonetGroupCache[$id][$staticCacheKey];
		}

		$cache = false;
		$cachePath = false;

		if (!$checkPermissions)
		{
			$cache = new CPHPCache;
			$cacheTime = 31536000;
			$cacheId = implode('_', array_merge([
				'group',
				$id,
				LANGUAGE_ID,
				CTimeZone::getOffset(),
				Context::getCurrent()->getCulture()->getDateTimeFormat()
			], $options));
			$cachePath = '/sonet/group/' . $id . '/';
		}

		if (
			$cache
			&& $cache->initCache($cacheTime, $cacheId, $cachePath)
		)
		{
			$cacheVars = $cache->getVars();
			$result = $cacheVars['FIELDS'];
		}
		else
		{
			if ($cache)
			{
				$cache->startDataCache($cacheTime, $cacheId, $cachePath);
			}

			$filter = [
				'ID' => $id,
			];

			if (
				$checkPermissions
				&& is_object($USER)
				&& ($USER->GetID() > 0)
			)
			{
				$filter['CHECK_PERMISSIONS'] = $USER->getId();
			}

			$select = [
				"ID", "SITE_ID", "NAME", "DESCRIPTION", "DATE_CREATE", "DATE_UPDATE", "ACTIVE", "VISIBLE", "OPENED", "CLOSED", "SUBJECT_ID", "OWNER_ID", "KEYWORDS",
				'IMAGE_ID', 'AVATAR_TYPE',
				"NUMBER_OF_MEMBERS", "NUMBER_OF_MODERATORS",
				"INITIATE_PERMS", "SPAM_PERMS",
				"DATE_ACTIVITY", "SUBJECT_NAME", 'TYPE', "UF_*",
			];
			if (ModuleManager::isModuleInstalled('intranet'))
			{
				$select = array_merge($select, [ "PROJECT", "PROJECT_DATE_START", "PROJECT_DATE_FINISH" ]);
			}
			if (ModuleManager::isModuleInstalled('landing'))
			{
				$select = array_merge($select, [ "LANDING" ]);
			}
			if (ModuleManager::isModuleInstalled('tasks'))
			{
				$select = array_merge($select, [ "SCRUM_OWNER_ID", "SCRUM_MASTER_ID", "SCRUM_SPRINT_DURATION", "SCRUM_TASK_RESPONSIBLE" ]);
			}
			$res = CSocNetGroup::getList(
				[],
				$filter,
				false,
				false,
				$select
			);
			if ($result = $res->getNext())
			{
				if (
					defined('BX_COMP_MANAGED_CACHE')
					&& $cache
				)
				{
					$CACHE_MANAGER->StartTagCache($cachePath);
					$CACHE_MANAGER->RegisterTag('sonet_group_' . $id);
					$CACHE_MANAGER->RegisterTag('sonet_group');
				}

				if (!empty($result['NAME']))
				{
					$result['NAME'] = Emoji::decode($result['NAME']);
				}
				if (!empty($result['DESCRIPTION']))
				{
					$result['DESCRIPTION'] = Emoji::decode($result['DESCRIPTION']);
				}

				$result['NAME_FORMATTED'] = $result['NAME'];

				if (($options['getSites'] ?? false))
				{
					$result['SITE_LIST'] = [];
					$res = CSocNetGroup::getSite($id);
					while ($groupSiteFields = $res->fetch())
					{
						$result['SITE_LIST'][] = $groupSiteFields['LID'];
					}
				}

				$result['SCRUM'] = (isset($result['SCRUM_MASTER_ID']) && (int)$result['SCRUM_MASTER_ID'] > 0 ? 'Y' : 'N');
				$result['SCRUM_PROJECT'] = $result['SCRUM'];
			}
			else
			{
				$result = false;
			}

			if ($cache)
			{
				$cacheData = [
					'FIELDS' => $result,
				];
				$cache->EndDataCache($cacheData);
				if (defined('BX_COMP_MANAGED_CACHE'))
				{
					$CACHE_MANAGER->EndTagCache();
				}
			}
		}

		if (!is_array($sonetGroupCache))
		{
			$sonetGroupCache = [];
		}
		if (
			!array_key_exists($id, $sonetGroupCache)
			|| !is_array($sonetGroupCache[$id])
		)
		{
			$sonetGroupCache[$id] = [];
		}
		$sonetGroupCache[$id][$staticCacheKey] = $result;

		self::setStaticCache($sonetGroupCache);

		return $result;
	}

	protected static function getStaticCache(): array
	{
		return self::$staticCache;
	}

	protected static function setStaticCache($cache = array())
	{
		self::$staticCache = $cache;
	}

	/***************************************/
	/**********  COMMON METHODS  ***********/
	/***************************************/
	public static function CanUserInitiate($userID, $groupID): bool
	{
		$userID = intval($userID);
		$groupID = intval($groupID);
		if ($groupID <= 0)
			return false;

		$userRoleInGroup = CSocNetUserToGroup::GetUserRole($userID, $groupID);
		if ($userRoleInGroup == false)
			return false;

		$arGroup = CSocNetGroup::GetById($groupID);
		if ($arGroup == false)
			return false;

		if ($arGroup["INITIATE_PERMS"] == SONET_ROLES_MODERATOR)
		{
			if ($userRoleInGroup == SONET_ROLES_MODERATOR || $userRoleInGroup == SONET_ROLES_OWNER)
				return true;
			else
				return false;
		}
		elseif ($arGroup["INITIATE_PERMS"] == SONET_ROLES_USER)
		{
			if ($userRoleInGroup == SONET_ROLES_MODERATOR || $userRoleInGroup == SONET_ROLES_OWNER || $userRoleInGroup == SONET_ROLES_USER)
				return true;
			else
				return false;
		}
		elseif ($arGroup["INITIATE_PERMS"] == SONET_ROLES_OWNER)
		{
			if ($userRoleInGroup == SONET_ROLES_OWNER)
				return true;
			else
				return false;
		}

		return false;
	}

	public static function CanUserViewGroup($userID, $groupID): bool
	{
		$userID = intval($userID);
		$groupID = intval($groupID);
		if ($groupID <= 0)
			return false;

		$arGroup = CSocNetGroup::GetById($groupID);
		if ($arGroup == false)
			return false;

		if ($arGroup["VISIBLE"] == "Y")
			return true;

		$userRoleInGroup = CSocNetUserToGroup::GetUserRole($userID, $groupID);
		if ($userRoleInGroup == false)
			return false;

		return in_array($userRoleInGroup, array(SONET_ROLES_OWNER, SONET_ROLES_MODERATOR, SONET_ROLES_USER));
	}

	public static function CanUserReadGroup($userID, $groupID): bool
	{
		$userID = intval($userID);
		$groupID = intval($groupID);
		if ($groupID <= 0)
			return false;

		$arGroup = CSocNetGroup::GetById($groupID);
		if ($arGroup == false)
			return false;

		if ($arGroup["OPENED"] == "Y")
			return true;

		$userRoleInGroup = CSocNetUserToGroup::GetUserRole($userID, $groupID);
		if ($userRoleInGroup == false)
			return false;

		return in_array($userRoleInGroup, array(SONET_ROLES_OWNER, SONET_ROLES_MODERATOR, SONET_ROLES_USER));
	}

	/***************************************/
	/************  ACTIONS  ****************/
	/***************************************/
	public static function createGroup($ownerID, $arFields, $bAutoSubscribe = true)
	{
		global $APPLICATION, $DB;

		$ownerID = (int)$ownerID;
		if ($ownerID <= 0)
		{
			$APPLICATION->ThrowException(GetMessage("SONET_UR_EMPTY_OWNERID").". ", "ERROR_OWNERID");
			return false;
		}

		if (!isset($arFields) || !is_array($arFields))
		{
			$APPLICATION->ThrowException(GetMessage("SONET_UR_EMPTY_FIELDS").". ", "ERROR_FIELDS");
			return false;
		}

		if (!empty($arFields['SCRUM_MASTER_ID']) && CModule::includeModule("tasks"))
		{
			$isScrumLimitExceeded = ScrumLimit::isLimitExceeded() || !ScrumLimit::isFeatureEnabled();
			if (ScrumLimit::canTurnOnTrial())
			{
				$isScrumLimitExceeded = false;
			}
			if ($isScrumLimitExceeded)
			{
				$APPLICATION->ThrowException("Scrum limit exceeded");

				return false;
			}
		}
		elseif (isset($arFields['TYPE']) && $arFields['TYPE'] === 'collab')
		{
			if (!\Bitrix\Socialnetwork\Collab\CollabFeature::isFeatureEnabled())
			{
				$APPLICATION->ThrowException('Collab feature not available');

				return false;
			}
		}
		elseif (empty($arFields['SCRUM_MASTER_ID']) && CModule::includeModule("tasks"))
		{
			$isProjectLimitExceeded = !ProjectLimit::isFeatureEnabled();
			if (ProjectLimit::canTurnOnTrial())
			{
				$isProjectLimitExceeded = false;
			}
			if ($isProjectLimitExceeded)
			{
				$APPLICATION->ThrowException("Project limit exceeded");

				return false;
			}
		}

		$DB->StartTransaction();

		if (!isset($arFields["DATE_CREATE"]))
		{
			$arFields["=DATE_CREATE"] = CDatabase::currentTimeFunction();
		}

		if (!isset($arFields["DATE_UPDATE"]))
		{
			$arFields["=DATE_UPDATE"] = CDatabase::currentTimeFunction();
		}

		if (!isset($arFields["DATE_ACTIVITY"]))
		{
			$arFields["=DATE_ACTIVITY"] = CDatabase::currentTimeFunction();
		}

		if (!isset($arFields['TYPE']))
		{
			$arFields['TYPE'] = static::getTypeByFields($arFields);
		}

		$arFields["ACTIVE"] = "Y";
		$arFields["OWNER_ID"] = $ownerID;

		if (!is_set($arFields, "SPAM_PERMS") || $arFields["SPAM_PERMS"] == '')
		{
			$arFields["SPAM_PERMS"] = SONET_ROLES_OWNER;
		}

		$groupID = CSocNetGroup::add($arFields);

		if (
			!$groupID
			|| $groupID <= 0
		)
		{
			$errorMessage = $errorID = "";
			if ($e = $APPLICATION->getException())
			{
				$errorMessage = $e->GetString();
				$errorID = $e->GetID();

				if (
					$errorID == ''
					&& isset($e->messages)
					&& is_array($e->messages)
					&& is_array($e->messages[0])
					&& array_key_exists("id", $e->messages[0])
				)
				{
					$errorID = $e->messages[0]["id"];
				}
			}

			if ($errorMessage == '')
			{
				$errorMessage = GetMessage("SONET_UR_ERROR_CREATE_GROUP").". ";
			}

			if ($errorID == '')
			{
				$errorID = "ERROR_CREATE_GROUP";
			}

			$APPLICATION->ThrowException($errorMessage, $errorID);
			$DB->Rollback();

			return false;
		}

		$arFields1 = array(
			"USER_ID" => $ownerID,
			"GROUP_ID" => $groupID,
			"ROLE" => SONET_ROLES_OWNER,
			"=DATE_CREATE" => $DB->CurrentTimeFunction(),
			"=DATE_UPDATE" => $DB->CurrentTimeFunction(),
			"INITIATED_BY_TYPE" => SONET_INITIATED_BY_USER,
			"INITIATED_BY_USER_ID" => $ownerID,
			"MESSAGE" => false
		);

		if (!CSocNetUserToGroup::Add($arFields1))
		{
			$errorMessage = "";
			if ($e = $APPLICATION->GetException())
			{
				$errorMessage = $e->GetString();
			}

			if ($errorMessage == '')
			{
				$errorMessage = GetMessage("SONET_UR_ERROR_CREATE_U_GROUP").". ";
			}

			$APPLICATION->ThrowException($errorMessage, "ERROR_CREATE_GROUP");
			$DB->Rollback();
			return false;
		}

		if ($bAutoSubscribe)
		{
			CSocNetLogEvents::AutoSubscribe($ownerID, SONET_ENTITY_GROUP, $groupID);
		}

		CSocNetSubscription::Set($ownerID, "SG".$groupID, "Y");

		$DB->Commit();

		return $groupID;
	}

	/***************************************/
	/*************  UTILITIES  *************/
	/***************************************/
	public static function __ValidateID($ID): bool
	{
		global $APPLICATION;

		if (intval($ID)."|" == $ID."|")
			return true;

		$APPLICATION->ThrowException(GetMessage("SONET_WRONG_PARAMETER_ID"), "ERROR_NO_ID");
		return false;
	}

	public static function GetFilterOperation($key): array
	{
		$strNegative = "N";
		if (mb_substr($key, 0, 1) == "!")
		{
			$key = mb_substr($key, 1);
			$strNegative = "Y";
		}

		$strOrNull = "N";
		if (mb_substr($key, 0, 1) == "+")
		{
			$key = mb_substr($key, 1);
			$strOrNull = "Y";
		}

		if (mb_substr($key, 0, 2) == ">=")
		{
			$key = mb_substr($key, 2);
			$strOperation = ">=";
		}
		elseif (mb_substr($key, 0, 1) == ">")
		{
			$key = mb_substr($key, 1);
			$strOperation = ">";
		}
		elseif (mb_substr($key, 0, 2) == "<=")
		{
			$key = mb_substr($key, 2);
			$strOperation = "<=";
		}
		elseif (mb_substr($key, 0, 1) == "<")
		{
			$key = mb_substr($key, 1);
			$strOperation = "<";
		}
		elseif (mb_substr($key, 0, 1) == "@")
		{
			$key = mb_substr($key, 1);
			$strOperation = "IN";
		}
		elseif (mb_substr($key, 0, 1) == "~")
		{
			$key = mb_substr($key, 1);
			$strOperation = "LIKE";
		}
		elseif (mb_substr($key, 0, 1) == "%")
		{
			$key = mb_substr($key, 1);
			$strOperation = "QUERY";
		}
		else
		{
			$strOperation = "=";
		}

		return array("FIELD" => $key, "NEGATIVE" => $strNegative, "OPERATION" => $strOperation, "OR_NULL" => $strOrNull);
	}

	public static function PrepareSql(&$arFields, $arOrder, $arFilter, $arGroupBy, $arSelectFields, $arUF = array()): array
	{
		global $DB;

		$obUserFieldsSql = false;

		if (is_array($arUF) && array_key_exists("ENTITY_ID", $arUF))
		{
			$obUserFieldsSql = new CUserTypeSQL;
			$obUserFieldsSql->SetEntity($arUF["ENTITY_ID"], $arFields["ID"]["FIELD"]);
			$obUserFieldsSql->SetSelect($arSelectFields);
			$obUserFieldsSql->SetFilter($arFilter);
			$obUserFieldsSql->SetOrder($arOrder);
		}

		$strSqlSelect = "";
		$strSqlFrom = "";
		$strSqlWhere = "";
		$strSqlGroupBy = "";

		$arGroupByFunct = array("COUNT", "AVG", "MIN", "MAX", "SUM");

		$arAlreadyJoined = array();

		// GROUP BY -->
		if (is_array($arGroupBy) && count($arGroupBy)>0)
		{
			$arSelectFields = $arGroupBy;
			foreach ($arGroupBy as $key => $val)
			{
				$val = mb_strtoupper($val);
				$key = mb_strtoupper($key);
				if (array_key_exists($val, $arFields) && !in_array($key, $arGroupByFunct))
				{
					if ($strSqlGroupBy <> '')
						$strSqlGroupBy .= ", ";
					$strSqlGroupBy .= $arFields[$val]["FIELD"];

					if (isset($arFields[$val]["FROM"])
						&& $arFields[$val]["FROM"] <> ''
						&& !in_array($arFields[$val]["FROM"], $arAlreadyJoined))
					{
						if ($strSqlFrom <> '')
							$strSqlFrom .= " ";
						$strSqlFrom .= $arFields[$val]["FROM"];
						$arAlreadyJoined[] = $arFields[$val]["FROM"];
					}
				}
			}
		}
		// <-- GROUP BY

		// WHERE -->
		$arAlreadyJoinedOld = $arAlreadyJoined;

		if (
			isset($arFilter['ID'])
			&& is_array($arFilter['ID'])
		)
		{
			$arFilter['@ID'] = $arFilter['ID'];
			unset($arFilter['ID']);
		}
		if (
			isset($arFilter['!ID'])
			&& is_array($arFilter['!ID'])
		)
		{
			$arFilter['!@ID'] = $arFilter['!ID'];
			unset($arFilter['!ID']);
		}

		$strSqlWhere .= CSqlUtil::PrepareWhere($arFields, $arFilter, $arAlreadyJoined);
		$arAlreadyJoinedDiff = array_diff($arAlreadyJoined, $arAlreadyJoinedOld);

		foreach($arAlreadyJoinedDiff as $from_tmp)
		{
			if ($strSqlFrom <> '')
				$strSqlFrom .= " ";
			$strSqlFrom .= $from_tmp;
		}

		if ($obUserFieldsSql)
		{
			$r = $obUserFieldsSql->GetFilter();
			if($r <> '')
				$strSqlWhere .= ($strSqlWhere <> '' ? " AND" : "")." (".$r.") ";
		}
		// <-- WHERE

		// ORDER BY -->
		$arSqlOrder = Array();
		foreach ($arOrder as $by => $order)
		{
			$by = mb_strtoupper($by);
			$order = mb_strtoupper($order);

			if ($order != "ASC")
				$order = "DESC";
			else
				$order = "ASC";

			if (array_key_exists($by, $arFields))
			{
				if ($arFields[$by]["TYPE"] == "datetime" || $arFields[$by]["TYPE"] == "date")
				{
					$arSqlOrder[] = " ".$by."_X1 ".$order." ";
					if (!is_array($arSelectFields) || !in_array($by, $arSelectFields))
						$arSelectFields[] = $by;
				}
				else
					$arSqlOrder[] = " ".$arFields[$by]["FIELD"]." ".$order." ";

				if (isset($arFields[$by]["FROM"])
					&& $arFields[$by]["FROM"] <> ''
					&& !in_array($arFields[$by]["FROM"], $arAlreadyJoined))
				{
					if ($strSqlFrom <> '')
						$strSqlFrom .= " ";
					$strSqlFrom .= $arFields[$by]["FROM"];
					$arAlreadyJoined[] = $arFields[$by]["FROM"];
				}
			}
			elseif($obUserFieldsSql && $s = $obUserFieldsSql->GetOrder($by))
				$arSqlOrder[$by] = " ".$s." ".$order." ";
		}

		$strSqlOrderBy = "";
		DelDuplicateSort($arSqlOrder);
		$tmp_count = count($arSqlOrder);
		for ($i=0; $i < $tmp_count; $i++)
		{
			if ($strSqlOrderBy <> '')
				$strSqlOrderBy .= ", ";

			if($DB->type == "ORACLE")
			{
				if(mb_substr($arSqlOrder[$i], -3) == "ASC")
					$strSqlOrderBy .= $arSqlOrder[$i]." NULLS FIRST";
				else
					$strSqlOrderBy .= $arSqlOrder[$i]." NULLS LAST";
			}
			else
				$strSqlOrderBy .= $arSqlOrder[$i];
		}
		// <-- ORDER BY

		// SELECT -->
		$arFieldsKeys = array_keys($arFields);

		if (is_array($arGroupBy) && count($arGroupBy)==0)
			$strSqlSelect = "COUNT(%%_DISTINCT_%% ".$arFields[$arFieldsKeys[0]]["FIELD"].") as CNT ";
		else
		{
			if (isset($arSelectFields) && !is_array($arSelectFields) && is_string($arSelectFields) && $arSelectFields <> '' && array_key_exists($arSelectFields, $arFields))
				$arSelectFields = array($arSelectFields);

			if (!isset($arSelectFields)
				|| !is_array($arSelectFields)
				|| count($arSelectFields) <= 0
				|| in_array("*", $arSelectFields))
			{
				$tmp_count = count($arFieldsKeys);
				for ($i = 0; $i < $tmp_count; $i++)
				{
					if (isset($arFields[$arFieldsKeys[$i]]["WHERE_ONLY"])
						&& $arFields[$arFieldsKeys[$i]]["WHERE_ONLY"] == "Y")
						continue;

					if ($strSqlSelect <> '')
						$strSqlSelect .= ", ";

					if ($arFields[$arFieldsKeys[$i]]["TYPE"] == "datetime")
					{
						if (array_key_exists($arFieldsKeys[$i], $arOrder))
							$strSqlSelect .= $arFields[$arFieldsKeys[$i]]["FIELD"]." as ".$arFieldsKeys[$i]."_X1, ";

						$strSqlSelect .= $DB->DateToCharFunction($arFields[$arFieldsKeys[$i]]["FIELD"])." as ".$arFieldsKeys[$i];
					}
					elseif ($arFields[$arFieldsKeys[$i]]["TYPE"] == "date")
					{
						if (array_key_exists($arFieldsKeys[$i], $arOrder))
							$strSqlSelect .= $arFields[$arFieldsKeys[$i]]["FIELD"]." as ".$arFieldsKeys[$i]."_X1, ";

						$strSqlSelect .= $DB->DateToCharFunction($arFields[$arFieldsKeys[$i]]["FIELD"], "SHORT")." as ".$arFieldsKeys[$i];
					}
					else
						$strSqlSelect .= $arFields[$arFieldsKeys[$i]]["FIELD"]." as ".$arFieldsKeys[$i];

					if (isset($arFields[$arFieldsKeys[$i]]["FROM"])
						&& $arFields[$arFieldsKeys[$i]]["FROM"] <> ''
						&& !in_array($arFields[$arFieldsKeys[$i]]["FROM"], $arAlreadyJoined))
					{
						if ($strSqlFrom <> '')
							$strSqlFrom .= " ";
						$strSqlFrom .= $arFields[$arFieldsKeys[$i]]["FROM"];
						$arAlreadyJoined[] = $arFields[$arFieldsKeys[$i]]["FROM"];
					}
				}
			}
			else
			{
				foreach ($arSelectFields as $key => $val)
				{
					$val = mb_strtoupper($val);
					$key = mb_strtoupper($key);
					if (array_key_exists($val, $arFields))
					{
						if ($strSqlSelect <> '')
							$strSqlSelect .= ", ";

						if (in_array($key, $arGroupByFunct))
							$strSqlSelect .= $key."(".$arFields[$val]["FIELD"].") as ".$val;
						else
						{
							if (($arFields[$val]["TYPE"] ?? null) === "datetime")
							{
								if (array_key_exists($val, $arOrder))
									$strSqlSelect .= $arFields[$val]["FIELD"]." as ".$val."_X1, ";

								$strSqlSelect .= $DB->DateToCharFunction($arFields[$val]["FIELD"])." as ".$val;
							}
							elseif (($arFields[$val]["TYPE"] ?? null) === "date")
							{
								if (array_key_exists($val, $arOrder))
									$strSqlSelect .= $arFields[$val]["FIELD"]." as ".$val."_X1, ";

								$strSqlSelect .= $DB->DateToCharFunction($arFields[$val]["FIELD"], "SHORT")." as ".$val;
							}
							else
								$strSqlSelect .= $arFields[$val]["FIELD"]." as ".$val;
						}

						if (isset($arFields[$val]["FROM"])
							&& $arFields[$val]["FROM"] <> ''
							&& !in_array($arFields[$val]["FROM"], $arAlreadyJoined))
						{
							if ($strSqlFrom <> '')
								$strSqlFrom .= " ";
							$strSqlFrom .= $arFields[$val]["FROM"];
							$arAlreadyJoined[] = $arFields[$val]["FROM"];
						}
					}
				}
			}

			if ($obUserFieldsSql)
				$strSqlSelect .= ($strSqlSelect == '' ? $arFields["ID"]["FIELD"] : "").$obUserFieldsSql->GetSelect();

			if ($strSqlGroupBy <> '')
			{
				if ($strSqlSelect <> '')
				{
					$strSqlSelect .= ", ";
				}
				$strSqlSelect .= "COUNT(%%_DISTINCT_%% ".$arFields[$arFieldsKeys[0]]["FIELD"].") as CNT";
			}
			else
			{
				$strSqlSelect = "%%_DISTINCT_%% ".$strSqlSelect;
			}
		}
		// <-- SELECT

		if ($obUserFieldsSql)
		{
			$strSqlFrom .= " ".$obUserFieldsSql->GetJoin($arFields["ID"]["FIELD"]);
		}

		return array(
			"SELECT" => $strSqlSelect,
			"FROM" => $strSqlFrom,
			"WHERE" => $strSqlWhere,
			"GROUPBY" => $strSqlGroupBy,
			"ORDERBY" => $strSqlOrderBy
		);
	}

	/***************************************/
	/*************    *************/
	/***************************************/

	public static function GetSite($group_id)
	{
		global $DB;

		if (is_array($group_id))
		{
			if (empty($group_id))
			{
				return false;
			}

			$strVal = "";

			foreach ($group_id as $val)
			{
				if ($strVal <> '')
				{
					$strVal .= ', ';
				}
				$strVal .= intval($val);
			}
			$strSql = "SELECT L.*, SGS.* FROM b_sonet_group_site SGS, b_lang L WHERE L.LID=SGS.SITE_ID AND SGS.GROUP_ID IN (".$strVal.")";
		}
		else
		{
			$strSql = "SELECT L.*, SGS.* FROM b_sonet_group_site SGS, b_lang L WHERE L.LID=SGS.SITE_ID AND SGS.GROUP_ID=".intval($group_id);
		}

		return $DB->Query($strSql);
	}

	public static function GetDefaultSiteId($groupId, $siteId = false)
	{
		$groupSiteId = ($siteId ?: SITE_ID);

		if (CModule::IncludeModule("extranet"))
		{
			$extranetSiteId = CExtranet::GetExtranetSiteID();

			$rsGroupSite = CSocNetGroup::GetSite($groupId);
			while ($arGroupSite = $rsGroupSite->Fetch())
			{
				if (
					!$extranetSiteId
					|| $arGroupSite["LID"] != $extranetSiteId
				)
				{
					$groupSiteId = $arGroupSite["LID"];
					break;
				}
			}
		}

		return $groupSiteId;
	}

	public static function OnBeforeLangDelete($lang): bool
	{
		global $APPLICATION, $DB;
		$r = $DB->Query("
			SELECT GROUP_ID
			FROM b_sonet_group_site
			WHERE SITE_ID='".$DB->ForSQL($lang, 2)."'
			ORDER BY GROUP_ID
		");
		$arSocNetGroups = array();
		while($a = $r->Fetch())
			$arSocNetGroups[] = $a["GROUP_ID"];
		if(count($arSocNetGroups) > 0)
		{
			$APPLICATION->ThrowException(GetMessage("SONET_GROUP_SITE_LINKS_EXISTS", array("#ID_LIST#" => implode(", ", $arSocNetGroups))));
			return false;
		}
		else
			return true;
	}

	public static function SearchIndex($groupId, $arSiteID = array(), $arGroupOld = array()): void
	{
		if (intval($groupId) <= 0)
		{
			return;
		}

		if (CModule::IncludeModule("search"))
		{
			$arGroupNew = CSocNetGroup::GetByID($groupId);
			if ($arGroupNew)
			{
				if (
					$arGroupNew["ACTIVE"] == "N"
					&& isset($arGroupOld)
					&& is_array($arGroupOld)
					&& isset($arGroupOld["ACTIVE"])
					&& $arGroupOld["ACTIVE"] == "Y"
				)
				{
					CSearch::DeleteIndex("socialnetwork", "G".$groupId);
				}
				elseif ($arGroupNew["ACTIVE"] == "Y")
				{
					$BODY = CSocNetTextParser::killAllTags($arGroupNew["~DESCRIPTION"]);
					$BODY .= $GLOBALS["USER_FIELD_MANAGER"]->OnSearchIndex("SONET_GROUP", $groupId);

					$arSearchIndexSiteID = array();
					if (
						is_array($arSiteID)
						&& !empty($arSiteID)
					)
					{
						foreach ($arSiteID as $site_id_tmp)
						{
							$arSearchIndexSiteID[$site_id_tmp] = str_replace("#group_id#", $groupId, Path::get('group_path_template', $site_id_tmp));
						}
					}
					else
					{
						$rsGroupSite = CSocNetGroup::GetSite($groupId);
						while ($arGroupSite = $rsGroupSite->Fetch())
						{
							$arSearchIndexSiteID[$arGroupSite["LID"]] = str_replace("#group_id#", $groupId, Path::get('group_path_template', $arGroupSite['LID']));
						}
					}

					$arSearchIndex = array(
						"SITE_ID" => $arSearchIndexSiteID,
						"LAST_MODIFIED" => $arGroupNew["DATE_ACTIVITY"],
						"PARAM1" => $arGroupNew["SUBJECT_ID"],
						"PARAM2" => $groupId,
						"PARAM3" => "GROUP",
						"PERMISSIONS" => (
							$arGroupNew["VISIBLE"] == "Y"?
								array('G2')://public
								array(
									'SG'.$groupId.'_A',//admins
									'SG'.$groupId.'_E',//moderators
									'SG'.$groupId.'_K',//members
								)
						),
						"PARAMS" =>array(
							"socnet_group" 	=> $groupId,
							"entity" 		=> "socnet_group",
						),
						"TITLE" => $arGroupNew["~NAME"],
						"BODY" => $BODY,
						"TAGS" => $arGroupNew["~KEYWORDS"],
					);

					CSearch::Index("socialnetwork", "G".$groupId, $arSearchIndex, True);
				}
			}
		}
	}

	public static function ConfirmAllRequests($groupId, $bAutoSubscribe = true, $currentUserId = 0)
	{
		$dbRequests = CSocNetUserToGroup::GetList(
			array(),
			array(
				"GROUP_ID" => $groupId,
				"ROLE" => SONET_ROLES_REQUEST,
				"INITIATED_BY_TYPE" => SONET_INITIATED_BY_USER
			),
			false,
			false,
			array("ID")
		);
		if ($dbRequests)
		{
			$arIDs = array();
			while ($arRequests = $dbRequests->GetNext())
			{
				$arIDs[] = $arRequests["ID"];
			}

			if (!$currentUserId)
			{
				$currentUserId = \Bitrix\Socialnetwork\Helper\User::getCurrentUserId();
			}

			CSocNetUserToGroup::ConfirmRequestToBeMember(
				$currentUserId,
				$groupId,
				$arIDs,
				$bAutoSubscribe,
			);
		}
	}

	private static function getTypeByFields(array $fields): Type
	{
		if (isset($fields['SCRUM_MASTER_ID']))
		{
			return Type::Scrum;
		}

		if (($fields['PROJECT'] ?? 'N') === 'Y')
		{
			return Type::Project;
		}

		return Type::getDefault();
	}

}