/////////////////////////////////////////////////////////////////////////////// /// \brief /// Return currently defined locale for user, or default locale. /// STRING MgException::GetLocale() throw() { STRING locale; MG_TRY() if (NULL != sm_localeCallbackFunc) { locale = (*sm_localeCallbackFunc)(); } MG_CATCH_AND_RELEASE() if (locale.empty()) { MG_TRY() MgConfiguration* configuration = MgConfiguration::GetInstance(); if (NULL != configuration && configuration->IsFileLoaded()) { configuration->GetStringValue( MgFoundationConfigProperties::GeneralPropertiesSection, MgFoundationConfigProperties::GeneralPropertyDefaultMessageLocale, locale, MgFoundationConfigProperties::DefaultGeneralPropertyDefaultMessageLocale); } MG_CATCH_AND_RELEASE() if (locale.empty()) { locale = MgResources::DefaultMessageLocale; } }
/// <summary> /// Initializes the common parameters and parameters specific to this request. /// </summary> /// <param name="name">Input /// MgHttpRequest /// This contains all the parameters of the request. /// </param> /// <returns> /// nothing /// </returns> MgHttpMoveResource::MgHttpMoveResource(MgHttpRequest *hRequest) { InitializeCommonParameters(hRequest); Ptr<MgHttpRequestParam> hrParam = m_hRequest->GetRequestParam(); assert(hrParam != 0); // Get Source Resource Id name m_sourceResourceId = hrParam->GetParameterValue(MgHttpResourceStrings::reqSourceResourceId); // Get Destination Resource Id name m_destResourceId = hrParam->GetParameterValue(MgHttpResourceStrings::reqDestinationResourceId); // Get the flag to determine whether or not the destination resource // should be overwritten if it exists. m_overwrite = ::atoi(MgUtil::WideCharToMultiByte( hrParam->GetParameterValue( MgHttpResourceStrings::reqOverwrite)).c_str()) != 0; // In order to maintain backward compatibility, the Cascade flag // will be set to false by default if it is not specified. STRING cascadeParam = hrParam->GetParameterValue(MgHttpResourceStrings::reqCascade); m_cascade = (!cascadeParam.empty() && 0 != MgUtil::StringToInt32(cascadeParam)); }
void MgServerSiteService::ValidateAuthorOrSelf(CREFSTRING user, CREFSTRING group) { bool bAllowed = false; Ptr<MgUserInformation> userInfo = MgUserInformation::GetCurrentUserInfo(); STRING currUser = userInfo->GetUserName(); if (currUser.empty()) { currUser = GetUserForSession(); } // Is user an Author or Admin? Ptr<MgSecurityCache> securityCache = GetResourceService().CreateSecurityCache(); Ptr<MgStringCollection> roles = new MgStringCollection; roles->Add(MgRole::Administrator); roles->Add(MgRole::Author); if (securityCache->IsUserInRoles(currUser, roles)) { bAllowed = true; } // Are we looking ourselves up? if (group.empty() && currUser == user) { bAllowed = true; } if (!bAllowed) { throw new MgUnauthorizedAccessException(L"MgServerSiteService.ValidateAuthorOrSelf", __LINE__, __WFILE__, NULL, L"", NULL); } }
void UnescapeHex(const STRING& str, size_t& i, STRING& Ret, BOOL Unicode) { STRING Num; // hexadecimal if (iswxdigit(str[i])) { Num += str[i]; ++i; if (iswxdigit(str[i])) { Num += str[i]; ++i; if (Unicode) { if (iswxdigit(str[i])) { Num += str[i]; ++i; if (iswxdigit(str[i])) { Num += str[i]; ++i; } } } } } if (!Num.empty()) { Ret += (WCHAR)wcstoul(&Num[0], NULL, 16); } }
STRING MgServerSiteService::GetUserForSession() { STRING session; STRING userId; Ptr<MgUserInformation> currUserInfo = MgUserInformation::GetCurrentUserInfo(); assert(NULL != currUserInfo); MG_SITE_SERVICE_TRY() MG_LOG_TRACE_ENTRY(L"MgServerSiteService::GetUserForSession()"); session = currUserInfo->GetMgSessionId(); if (!session.empty()) { userId = MgSessionManager::GetUserName(session); } else { MgStringCollection arguments; arguments.Add(L"1"); arguments.Add(session); throw new MgInvalidArgumentException(L"MgServerSiteService.GetUserForSession()", __LINE__, __WFILE__, &arguments, L"MgInvalidSessionsId", NULL); } MG_SITE_SERVICE_CATCH_AND_THROW(L"MgServerSiteService.GetUserForSession") return userId; }
/* * Constructor. */ CAnimation::CAnimation(const STRING file): m_users(1) { extern STRING g_projectPath; renderFrame = &CAnimation::renderAnmFrame; if (!file.empty()) { const STRING ext = getExtension(file); if (_ftcsicmp(ext.c_str(), _T("anm")) == 0) { m_data.open(g_projectPath + MISC_PATH + file); } else if (_ftcsicmp(ext.c_str(), _T("gif")) == 0) { m_data.loadFromGif(resolve(g_projectPath + MISC_PATH + file)); renderFrame = &CAnimation::renderFileFrame; m_data.filename = file; } } freeCanvases(); m_canvases.resize(m_data.frameCount, NULL); }
void UnescapeOther(const STRING& str, size_t& i, STRING& Ret) { STRING Num; // check octal if (L'0' <= str[i] && str[i] < L'8') { Num += str[i]; ++i; if (L'0' <= str[i] && str[i] < L'8') { Num += str[i]; ++i; if (L'0' <= str[i] && str[i] < L'8') { Num += str[i]; ++i; } } } if (Num.empty()) { Ret += str[i]; ++i; } else { // octal Ret += (WCHAR)wcstoul(&Num[0], NULL, 8); } }
VOID CActionItem_ChatMood::DoAction() { STRING strKey = SCRIPT_SANDBOX::Talk::s_Talk.FindTalkActKey(GetPosIndex()); if(!strKey.empty()) { CEventSystem::GetMe()->PushEvent(GE_CHAT_ACTSET, strKey.c_str()); } }
/////////////////////////////////////////////////////////////////////////////// /// \brief /// Appends a slash to non-empty string /// STRING MgUnmanagedDataManager::FormatSubdir(CREFSTRING subdir) { STRING result = subdir; if (!result.empty()) { MgFileUtil::AppendSlashToEndOfPath(result); } return result; }
// clears the tile cache for the given map void MgdTileCache::Clear(MgMapBase* map) { if (map != NULL) { STRING basePath = GetBasePath(map); // delete main map directory if (!basePath.empty()) MgFileUtil::DeleteDirectory(basePath, true, false); } }
void PolyObjectBuffer::EnableObjectVerticesTrace(BOOL enableTrace, STRING traceFile) { traceVertices = enableTrace; if (traceVertices) { assert(!traceFile.empty()); traceFileName = traceFile; } } // end: EnableBoundaryTraversalTrace()
void IntersectionList::EnableIntersectionTrace(BOOL enableTrace, STRING traceFile) { traceIntersections = enableTrace; if (traceIntersections) { assert(!traceFile.empty()); intersectionTraceFileName = traceFile; } } // end: EnableIntersectionTrace()
/// <summary> /// Initializes the common parameters and parameters specific to this request. /// </summary> /// <param name="name">Input /// MgHttpRequest /// This contains all the parameters of the request. /// </param> /// <returns> /// nothing /// </returns> MgHttpKmlGetLayer::MgHttpKmlGetLayer(MgHttpRequest *hRequest) { InitializeCommonParameters(hRequest); Ptr<MgHttpRequestParam> params = hRequest->GetRequestParam(); // Get the layer definition m_layerDefinition = params->GetParameterValue(MgHttpResourceStrings::reqKmlLayerDefinition); // Get the map agent Uri m_agentUri = hRequest->GetAgentUri(); // Get the bounding box m_boundingBox = params->GetParameterValue(MgHttpResourceStrings::reqKmlBoundingBox); // Get the requested format m_format = params->GetParameterValue(MgHttpResourceStrings::reqKmlFormat); // Get the map image width STRING width = params->GetParameterValue(MgHttpResourceStrings::reqKmlWidth); m_width = MgUtil::StringToInt32(width); // Get the map image height STRING height = params->GetParameterValue(MgHttpResourceStrings::reqKmlHeight); m_height = MgUtil::StringToInt32(height); // Get the map resolution STRING dpi = params->GetParameterValue(MgHttpResourceStrings::reqKmlDpi); if(!dpi.empty()) { m_dpi = MgUtil::StringToDouble(dpi); } else { m_dpi = 96; // default } // Get the draw order STRING drawOrder = params->GetParameterValue(MgHttpResourceStrings::reqKmlDrawOrder); m_drawOrder = drawOrder.empty() ? 0 : MgUtil::StringToInt32(drawOrder); }
// clears the tile cache for the given map void MgdTileCache::Clear(MgResourceIdentifier* mapDef) { // the resource must be a map definition if (mapDef != NULL && mapDef->GetResourceType() == MgResourceType::MapDefinition) { STRING basePath = GetBasePath(mapDef); // delete main map directory if (!basePath.empty()) MgFileUtil::DeleteDirectory(basePath, true, false); } }
VOID CGameInterface::PacketItem_UserItem(tActionItem* pActionItem, int targetServerID, fVector2& fvPos) { //空物品 if(!pActionItem || pActionItem->GetType() != AOT_ITEM) return; CObject_Item* pItem = (CObject_Item*)(((CActionItem_Item*)pActionItem)->GetItemImpl()); if(!pItem) return; //必须是能够使用的物品 if(pItem->GetItemClass()!=ICLASS_COMITEM && pItem->GetItemClass()!=ICLASS_TASKITEM) return; //特殊物品不能在背包中直接使用,例如,宠物技能书 STRING strTemp; if(!CObject_Item::CheckUseInPackage(pItem, strTemp)) { if(!strTemp.empty()) CGameProcedure::s_pEventSystem->PushEvent(GE_NEW_DEBUGMESSAGE, strTemp.c_str()); return; } //组队跟随中... if(CObjectManager::GetMe()->GetMySelf()->GetCharacterData()->Get_TeamFollowFlag()) return; //检查目前选中的目标 CObject* pObj = (CObject*)CObjectManager::GetMe()->FindServerObject(targetServerID); //检查物品是否能够直接使用 int objID; PET_GUID_t petID; bool bCanuseDir = ((CObject_Item_Medicine*)pItem)->IsValidTarget(pObj, fvPos, objID, petID); if(bCanuseDir) { WORLD_POS posTarget(fvPos.x, fvPos.y); //能够直接使用 CGUseItem msg; msg.SetBagIndex( pItem->GetPosIndex() ); msg.SetTargetObjID(objID); msg.SetTargetPetGUID(petID); msg.SetTargetPos(&posTarget); CNetManager::GetMe()->SendPacket( &msg ); return; } //如果已经选中目标,说明目标不合适,如果是用在自己宠物上的物品,说明宠物没有释放 if(pObj || ((CObject_Item_Medicine*)pItem)->IsTargetOne()) { CGameProcedure::s_pEventSystem->PushEvent(GE_NEW_DEBUGMESSAGE, "无效目标"); return; } //需要选中目标,在鼠标上挂上物品 CActionSystem::GetMe()->SetDefaultAction(pActionItem); }
/////////////////////////////////////////////////////////////////////////////// /// \brief /// Provides the long transaction name associated with the specified /// resource. Returns false if no session was active for the current /// request, or if no long transaction name was found. /// bool MgLongTransactionManager::GetLongTransactionName(MgResourceIdentifier* featureSourceId, REFSTRING longTransactionName) { ACE_MT(ACE_GUARD_RETURN(ACE_Recursive_Thread_Mutex, ace_mon, sm_mutex, false)); STRING sessionId; Ptr<MgUserInformation> userInfo = MgUserInformation::GetCurrentUserInfo(); if (userInfo != NULL) sessionId = userInfo->GetMgSessionId(); if (sessionId.empty()) return false; return MgLongTransactionManager::GetLongTransactionName(sessionId, featureSourceId, longTransactionName); }
void uninitialisePakFile() { // Return if this isn't a pak file. if (g_pakTempPath.empty()) return; deleteTree(g_pakTempPath); ZIPClose(); // If we are a standalone game, also delete the tag on archive. if (g_bStandalone) { unlink(g_pakFile.c_str()); } }
/////////////////////////////////////////////////////////////////////////////// /// \brief /// Initializes the package status information. /// void MgResourcePackageHandler::InitializeStatus(CREFSTRING packageApiName, CREFSTRING packagePathname, bool logActivities) { m_packagePathname = packagePathname; // Create the package log writer. if (logActivities) { m_packageLogWriter = new MgPackageLogWriter(packageApiName, m_packagePathname); } if (m_packageLogWriter != NULL) { m_opsSucceeded = 0; m_opsReceived = 0; MgServerManager* serverManager = MgServerManager::GetInstance(); ACE_ASSERT(NULL != serverManager && serverManager->IsSiteServer()); MgPackageStatusInformation& statusInfo = m_packageLogWriter->GetStatusInfo(); Ptr<MgDateTime> startTime = new MgDateTime(); statusInfo.SetEndTime(startTime); Ptr<MgUserInformation> currUserInfo = m_repositoryManager.GetCurrentUserInfo(); ACE_ASSERT(NULL != currUserInfo.p); if (NULL != currUserInfo) { statusInfo.SetUserName(currUserInfo->GetUserName()); } STRING serverName = serverManager->GetServerName(); STRING serverAddress = serverManager->GetLocalServerAddress(); if (serverName.empty()) { MgIpUtil::HostAddressToName(serverAddress, serverName, false); } statusInfo.SetServerName(serverName); statusInfo.SetServerAddress(serverAddress); // Write the log file. m_packageLogWriter->UpdateLog(); } }
void MgWmsFeatureInfo::GenerateDefinitions(MgUtilDictionary& dictionary) { if(m_propertyCollection != NULL && m_index >= 0 && m_index < m_propertyCollection->GetCount()) { Ptr<MgPropertyCollection> props = m_propertyCollection->GetItem(m_index); if(props->Contains(kpszLayerNameProperty)) { Ptr<MgStringProperty> layerNameProp = (MgStringProperty*)props->GetItem(kpszLayerNameProperty); STRING value = MgUtil::ReplaceEscapeCharInXml(layerNameProp->GetValue()); if(!value.empty()) { dictionary.AddDefinition(kpszDefinitionFeatureInfoLayerName, value); } } } }
// gets the base path to use with the tile cache for the given map definition resource STRING MgdTileCache::GetBasePath(MgResourceIdentifier* mapDef) { assert(mapDef != NULL); assert(mapDef->GetResourceType() == MgResourceType::MapDefinition); STRING mapPath; if (mapDef->GetRepositoryType() == MgRepositoryType::Library) { // for maps in the library repository the path+name is unique mapPath = mapDef->GetPath(); mapPath += L"_"; mapPath += mapDef->GetName(); } else if (mapDef->GetRepositoryType() == MgRepositoryType::Session) { // for maps in the session repository we use the session + path + map name mapPath = mapDef->GetRepositoryName(); mapPath += L"_"; STRING resourcePath = mapDef->GetPath(); if (!resourcePath.empty()) { mapPath += resourcePath; mapPath += L"_"; } mapPath += mapDef->GetName(); } else { // shouldn't get here assert(false); return mapPath; } // for safety mapPath = MgUtil::ReplaceString(mapPath, L"/", L"_"); mapPath = MgUtil::ReplaceString(mapPath, L":", L"_"); // Build the base path using format "%ls%ls": // <basePath> = <tileCachePath><mapPath> STRING basePath = sm_path; basePath += mapPath; return basePath; }
Handle ResourceManager::NewResource(BaseResource* r, char tag) { assert(r); STRING filename = r->GetFilename(); if(!filename.empty() && g_nameHandleTable.find(filename) != g_nameHandleTable.end()) { return Handle(g_nameHandleTable[filename]); } Handle h; h.Init(r->GetHash(), tag); g_nameHandleTable[filename] = h.GetHandle(); g_handleResTable[h.GetHandle()] = r; return h; }
void EditDlg_OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify) { WCHAR szValue[MAX_STRING]; STRING str; INT i; switch (id) { case IDOK: GetDlgItemTextW(hwnd, cmb2, szValue, _countof(szValue)); str = szValue; trim(str); if (str.empty()) { WCHAR sz[MAX_STRING]; SendDlgItemMessageW(hwnd, cmb2, CB_SETEDITSEL, 0, MAKELPARAM(0, -1)); SetFocus(GetDlgItem(hwnd, cmb2)); LoadStringW(g_hInstance, IDS_ENTERNAME2, sz, _countof(sz)); MessageBoxW(hwnd, sz, NULL, MB_ICONERROR); return; } g_Items[g_iItem].m_CharSet2 = DEFAULT_CHARSET; i = SendDlgItemMessageW(hwnd, cmb4, CB_GETCURSEL, 0, 0); if (i != CB_ERR) { g_Items[g_iItem].m_CharSet2 = g_CharSetList[i].CharSet; } g_Items[g_iItem].m_Substitute = str; g_bModified = TRUE; EndDialog(hwnd, IDOK); break; case IDCANCEL: EndDialog(hwnd, IDCANCEL); break; case psh1: LV_OnDelete(g_hListView, g_iItem); EndDialog(hwnd, psh1); break; } }
void MgResourceDefinitionManager::ValidateDocument(XmlDocument& xmlDoc) { MG_RESOURCE_SERVICE_TRY() MgResourceIdentifier resource(MgUtil::MultiByteToWideChar(xmlDoc.getName())); // Skip XML schema validation on runtime resources. if (!resource.IsRuntimeResource()) { std::string xmlContent; MgXmlUtil xmlUtil(xmlDoc.getContent(xmlContent)); DOMElement* rootNode = xmlUtil.GetRootNode(); if(NULL != rootNode) { assert(NULL != rootNode); STRING rootName; const XMLCh* tag = rootNode->getTagName(); if (NULL != tag) { rootName = X2W(tag); assert(!rootName.empty()); } STRING schemaName; const XMLCh* attr = rootNode->getAttribute(X("xsi:noNamespaceSchemaLocation")); if (NULL != attr) { schemaName = X2W(attr); } ValidateDocument(resource, rootName, schemaName); } } MG_RESOURCE_CONTAINER_CATCH_AND_THROW(L"MgResourceDefinitionManager.ValidateDocument") }
/// <summary> /// Initializes the common parameters and parameters specific to this request. /// </summary> /// <param name="name">Input /// MgHttpRequest /// This contains all the parameters of the request. /// </param> /// <returns> /// nothing /// </returns> MgHttpEnumerateResources::MgHttpEnumerateResources(MgHttpRequest *hRequest) { InitializeCommonParameters(hRequest); Ptr<MgHttpRequestParam> hrParam = m_hRequest->GetRequestParam(); // Get resource id m_resourceId = hrParam->GetParameterValue(MgHttpResourceStrings::reqResourceId); // Get depth m_depth = MgUtil::StringToInt32(hrParam->GetParameterValue(MgHttpResourceStrings::reqDepth)); // Get type m_type = hrParam->GetParameterValue(MgHttpResourceStrings::reqType); // In order to maintain backward compatibility, the Compute Children flag // will be set to true by default if it is not specified. STRING computeChildrenParam = hrParam->GetParameterValue(MgHttpResourceStrings::reqComputeChildren); m_computeChildren = (computeChildrenParam.empty() || 0 != MgUtil::StringToInt32(computeChildrenParam)); }
STRING MgServerSiteService::CreateSession() { STRING session; Ptr<MgUserInformation> currUserInfo = MgUserInformation::GetCurrentUserInfo(); assert(NULL != currUserInfo); MG_SITE_SERVICE_TRY() MG_LOG_TRACE_ENTRY(L"MgServerSiteService::CreateSession()"); session = currUserInfo->GetMgSessionId(); if (session.empty()) { MgSiteManager* siteManager = MgSiteManager::GetInstance(); Ptr<MgSiteInfo> siteInfo = siteManager->GetSiteInfo(0); session = currUserInfo->CreateMgSessionId(siteInfo); currUserInfo->SetMgSessionId(session); } else { throw new MgDuplicateSessionException( L"MgServerSiteService.CreateSession", __LINE__, __WFILE__, NULL, L"", NULL); } // Note that if an error occurs, the abandoned session repositry will // be eventually deleted by the internal session cleanup event timer. MgResourceIdentifier resource(MgRepositoryType::Session, session, L"", L"", MgResourceType::Folder); MgSessionManager::AddSession(session, currUserInfo->GetUserName()); GetResourceService().CreateRepository(&resource, NULL, NULL); MG_SITE_SERVICE_CATCH_AND_THROW(L"MgServerSiteService.CreateSession") return session; }
////////////////////////////////////////////////////////////////// // Processes a GetMap request from the Viewer and returns // a DWF containing an EMap that fully describes the map // but does not yet contain any layer graphics // MgByteReader* MgDwfController::GetMap(MgResourceIdentifier* mapDefinition, CREFSTRING dwfVersion, CREFSTRING eMapVersion, MgPropertyCollection* mapViewCommands) { //create a session id to associate with this map STRING sessionId; Ptr<MgUserInformation> userInfo = m_siteConn->GetUserInfo(); if (userInfo.p != NULL) sessionId = userInfo->GetMgSessionId(); if (sessionId.empty()) { Ptr<MgSite> site = m_siteConn->GetSite(); sessionId = site->CreateSession(); userInfo->SetMgSessionId(sessionId); } //get an instance of the resource service Ptr<MgResourceService> resourceService = (MgResourceService*)GetService(MgServiceType::ResourceService); //instantiate a map object and let it load itself from the map definition in the resource repository Ptr<MgMap> map = new MgMap(); map->Create(resourceService, mapDefinition, mapDefinition->GetName()); m_operation = get; //apply commands ApplyMapViewCommands(map, mapViewCommands); //save the map state in the session repository Ptr<MgResourceIdentifier> resId = new MgResourceIdentifier(L"Session:" + sessionId + L"//" + mapDefinition->GetName() + L"." + MgResourceType::Map); map->Save(resourceService.p, resId.p); Ptr<MgDwfVersion> dwfv = new MgDwfVersion(dwfVersion, eMapVersion); //get an instance of the mapping service and call the GetMap API Ptr<MgMappingService> mappingService = (MgMappingService*)GetService(MgServiceType::MappingService); return mappingService->GenerateMap(map, sessionId, m_mapAgentUri, dwfv); }
TestProfilingService::TestProfilingService() { // Initialize service objects. MgServiceManager* serviceManager = MgServiceManager::GetInstance(); m_svcResource = dynamic_cast<MgResourceService*>( serviceManager->RequestService(MgServiceType::ResourceService)); assert(m_svcResource != NULL); m_svcProfiling = dynamic_cast<MgProfilingService*>( serviceManager->RequestService(MgServiceType::ProfilingService)); assert(m_svcProfiling != NULL); // Initialize a site connection. Ptr<MgServerSiteService> svcSite = dynamic_cast<MgServerSiteService*>( serviceManager->RequestService(MgServiceType::SiteService)); assert(svcSite != NULL); Ptr<MgUserInformation> userInfo = new MgUserInformation( L"Administrator", L"admin"); userInfo->SetLocale(TEST_LOCALE); // Set the current MgUserInformation // This must be done before calling CreateSession() MgUserInformation::SetCurrentUserInfo(userInfo); STRING session = svcSite->CreateSession(); assert(!session.empty()); userInfo->SetMgSessionId(session); // Set the current MgUserInformation MgUserInformation::SetCurrentUserInfo(userInfo); m_siteConnection = new MgSiteConnection(); m_siteConnection->Open(userInfo); }
/////////////////////////////////////////////////////////////////////////////// /// \brief /// Returns unmanaged data /// MgByteReader* MgUnmanagedDataManager::EnumerateUnmanagedData(CREFSTRING path, bool recursive, CREFSTRING type, CREFSTRING filter) { Ptr<MgByteReader> byteReader; MG_TRY() ACE_TRACE("MgUnmanagedDataManager::EnumerateUnmanagedData"); Ptr<MgPropertyCollection> unmanagedDataMappings = GetUnmanagedDataMappings(); if (NULL != unmanagedDataMappings.p) { // this XML follows the ResourceList-1.0.0.xsd schema string list = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"; list += "<UnmanagedDataList xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:noNamespaceSchemaLocation=\"UnmanagedDataList-1.0.0.xsd\">\n"; // check arguments... // pull out the mapping name from the path // path must be in the form of: // "" // "[alias1]" // "[alias1]subfolder1" // "[alias1]subfolder1/" // "[alias1]subfolder1/subfolder2/" STRING mappingName = L"", subfolder = L""; if (!MgUnmanagedDataManager::ParsePath(path, mappingName, subfolder)) { MgStringCollection arguments; arguments.Add(L"1"); arguments.Add(path); throw new MgInvalidArgumentException(L"MgUnmanagedDataManager.EnumerateUnmanagedData", __LINE__, __WFILE__, &arguments, L"", NULL); } // type must be: // "FOLDERS" // "FILES" // "BOTH" bool storeFolders = ACE_OS::strcasecmp(type.c_str(), MgResourceUnmanagedDataType::Folders.c_str()) == 0 || ACE_OS::strcasecmp(type.c_str(), MgResourceUnmanagedDataType::Both.c_str()) == 0; bool storeFiles = ACE_OS::strcasecmp(type.c_str(), MgResourceUnmanagedDataType::Files.c_str()) == 0 || ACE_OS::strcasecmp(type.c_str(), MgResourceUnmanagedDataType::Both.c_str()) == 0; ACE_ASSERT(storeFolders || storeFiles); // filter is ignored if type = "FOLDERS" // filter can be: // "" // ".sdf" // ".sdf;.pdf;.shp" // "sdf" // "sdf;dwf;png" MgStringCollection filters; if (storeFiles) ParseFilter(filter, &filters); // are we looking in a specific path? if (!mappingName.empty()) { Ptr<MgStringProperty> stringProp = dynamic_cast<MgStringProperty*>(unmanagedDataMappings->FindItem(mappingName)); if (stringProp != NULL) { // we have a match! STRING mappingDir = stringProp->GetValue(); // get the files and/or folders from that folder and subfolder (recursive) GetFilesAndFolders(list, mappingName, mappingDir, subfolder, &filters, storeFolders, storeFiles, recursive); } else { MgStringCollection arguments; arguments.Add(L"1"); arguments.Add(path); throw new MgInvalidArgumentException(L"MgUnmanagedDataManager.EnumerateUnmanagedData", __LINE__, __WFILE__, &arguments, L"", NULL); } } else { // getting files starting from virtual root (all mappings) // iterate thru mappings for (int i = 0; i < unmanagedDataMappings->GetCount(); i++) { Ptr<MgStringProperty> stringProp = dynamic_cast<MgStringProperty*>(unmanagedDataMappings->GetItem(i)); STRING mapName = stringProp->GetName(); STRING mapDir = stringProp->GetValue(); if (MgFileUtil::IsDirectory(mapDir)) { if (storeFolders) { MgDateTime createdDate = MgFileUtil::GetFileCreationTime(mapDir); MgDateTime modifiedDate = MgFileUtil::GetFileModificationTime(mapDir); INT32 numFolders = 0; INT32 numFiles = 0; GetNumberOfFilesAndSubfolders(mapDir, numFolders, numFiles); // add top-level mappings AddFolder(list, mapName, L"", L"", numFolders, numFiles, createdDate, modifiedDate); } if (recursive) GetFilesAndFolders(list, mapName, mapDir, L"", &filters, storeFolders, storeFiles, recursive); } } } list += "</UnmanagedDataList>"; Ptr<MgByteSource> byteSource = new MgByteSource( (unsigned char*)list.c_str(), (INT32)list.length()); byteSource->SetMimeType(MgMimeType::Xml); byteReader = byteSource->GetReader(); } MG_CATCH_AND_THROW(L"MgUnmanagedDataManager.EnumerateUnmanagedData") return byteReader.Detach(); }
MgByteReader* MgHtmlController::CollectQueryMapFeaturesResult(MgResourceService* resourceService, INT32 requestData, MgFeatureInformation* featInfo, MgSelection* selectionSet, MgBatchPropertyCollection* attributes, MgByteReader* inlineSelection) { STRING xml; STRING tooltip; STRING hyperlink; STRING xmlSelection = selectionSet? selectionSet->ToXml(false): L""; if (NULL != featInfo) { tooltip = featInfo->GetTooltip(); hyperlink = featInfo->GetHyperlink(); } // TODO: Stil haven't defined a schema for v2.6. Should we? xml.append(L"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<FeatureInformation>\n"); size_t len = xmlSelection.length(); if(len > 0) { xml.reserve(len + 2048); xml.append(xmlSelection); } else { xml.reserve(2048); xml.append(L"<FeatureSet />\n"); } if (((requestData & REQUEST_TOOLTIP) == REQUEST_TOOLTIP) && !tooltip.empty()) { xml.append(L"<Tooltip>"); xml.append(MgUtil::ReplaceEscapeCharInXml(tooltip)); xml.append(L"</Tooltip>\n"); } else xml.append(L"<Tooltip />\n"); if (((requestData & REQUEST_HYPERLINK) == REQUEST_HYPERLINK) && !hyperlink.empty()) { xml.append(L"<Hyperlink>"); xml.append(MgUtil::ReplaceEscapeCharInXml(hyperlink)); xml.append(L"</Hyperlink>\n"); } else xml.append(L"<Hyperlink />\n"); if (((requestData & REQUEST_INLINE_SELECTION) == REQUEST_INLINE_SELECTION) && NULL != inlineSelection) { xml.append(L"<InlineSelectionImage>\n"); xml.append(L"<MimeType>"); xml.append(inlineSelection->GetMimeType()); xml.append(L"</MimeType>\n"); xml.append(L"<Content>"); MgByteSink sink(inlineSelection); Ptr<MgByte> bytes = sink.ToBuffer(); Ptr<MgMemoryStreamHelper> streamHelper = new MgMemoryStreamHelper((INT8*) bytes->Bytes(), bytes->GetLength(), false); std::string b64 = streamHelper->ToBase64(); STRING wb64 = MgUtil::MultiByteToWideChar(b64); xml.append(wb64); xml.append(L"</Content>\n"); xml.append(L"</InlineSelectionImage>\n"); } else xml.append(L"<InlineSelectionImage />\n"); if (((requestData & REQUEST_ATTRIBUTES) == REQUEST_ATTRIBUTES) && NULL != attributes) { xml.append(L"<SelectedFeatures>\n"); WriteSelectedFeatureAttributes(resourceService, selectionSet, attributes, xml); xml.append(L"</SelectedFeatures>\n"); } else xml.append(L"<SelectedFeatures />\n"); xml.append(L"</FeatureInformation>\n"); string xmlDoc = MgUtil::WideCharToMultiByte(xml); STRING mimeType = L"text/xml"; return MgUtil::GetByteReader(xmlDoc, &mimeType); }
MgSpatialContextData* MgServerGetSpatialContexts::GetSpatialContextData( FdoISpatialContextReader* spatialReader, MgSpatialContextInfo* spatialContextInfo) { Ptr<MgSpatialContextData> spatialData = new MgSpatialContextData(); // Name must exist FdoString* name = spatialReader->GetName(); CHECKNULL((FdoString*)name, L"MgServerGetSpatialContexts.GetSpatialContexts"); spatialData->SetName(STRING(name)); STRING coordSysName = L""; FdoString* csName = spatialReader->GetCoordinateSystem(); Ptr<MgCoordinateSystemFactory> csFactory; // WKT for co-ordinate system FdoString* csWkt = NULL; STRING srsWkt = L""; bool haveValidCoordSys = false; if(NULL != csName && *csName != '\0') { coordSysName = STRING(csName); } else { csWkt = spatialReader->GetCoordinateSystemWkt(); if (csWkt != NULL && *csWkt != '\0') { srsWkt = csWkt; try { csFactory = new MgCoordinateSystemFactory(); coordSysName = csFactory->ConvertWktToCoordinateSystemCode(srsWkt); haveValidCoordSys = (coordSysName.size() != 0); } catch (MgException* e) { SAFE_RELEASE(e); } catch(...) { } } } bool spatialContextDefined = !coordSysName.empty(); bool coordSysOverridden = false; // look for coordinate system override if (NULL != spatialContextInfo) { // Perform substitution of missing coordinate system with // the spatial context mapping defined in feature source document MgSpatialContextInfo::const_iterator iter = spatialContextInfo->find(name); if (spatialContextInfo->end() != iter) { csName = (iter->second).c_str(); coordSysOverridden = true; } } if (csName != NULL && *csName != '\0') { spatialData->SetCoordinateSystem(STRING(csName)); } // Desc for spatial context STRING desc = L""; // This flag is obsolete and will be deprecated. bool isActive = spatialReader->IsActive(); if (coordSysOverridden) { srsWkt = csName; desc = MgServerFeatureUtil::GetMessage(L"MgCoordinateSystemOverridden"); } else if (spatialContextDefined && !coordSysOverridden) { // avoid looking one more time after CS in case we have a valid one... if (!haveValidCoordSys) { csWkt = spatialReader->GetCoordinateSystemWkt(); if(NULL != csWkt && *csWkt != '\0') srsWkt = csWkt; if (srsWkt.empty()) { try { if (csFactory == NULL) csFactory = new MgCoordinateSystemFactory(); // Check if the spatial context coordinate system data represents an EPSG // code. If this is the case the WKT data for the EPSG code has to be // retrieved. if (IsEpsgCodeRepresentation(csName)) { // This is an EPSG code FdoString* p = NULL; if ((csName[0] == L'E') || (csName[0] == L'e')) p = csName+5; else p = csName; INT32 epsgCode = (INT32)wcstol(p, NULL, 10); // Convert the EPSG numerical code to WKT srsWkt = csFactory->ConvertEpsgCodeToWkt(epsgCode); } else { srsWkt = csFactory->ConvertCoordinateSystemCodeToWkt(STRING(csName)); } } catch (MgException* e) { SAFE_RELEASE(e); } catch(...) { // Just use the empty WKT. } } } FdoString* fdoDesc = spatialReader->GetDescription(); if(NULL != fdoDesc) desc = STRING(fdoDesc); } // retrieve other values from spatialReader FdoSpatialContextExtentType extentType = spatialReader->GetExtentType(); FdoPtr<FdoByteArray> byteArray = spatialReader->GetExtent(); double xyTol = spatialReader->GetXYTolerance(); double zTol = spatialReader->GetZTolerance(); spatialData->SetCoordinateSystemWkt(srsWkt); spatialData->SetDescription(desc); spatialData->SetExtentType((INT32)extentType); if (byteArray.p != NULL) { INT32 size = (INT32)byteArray->GetCount(); BYTE_ARRAY_IN bytes = (BYTE_ARRAY_IN)byteArray->GetData(); Ptr<MgByte> extent = new MgByte(bytes, size); spatialData->SetExtent(extent); } // XY Tolerance spatialData->SetXYTolerance(xyTol); // Z Tolerance spatialData->SetZTolerance(zTol); // This flag is obsolete and will be deprecated. spatialData->SetActiveStatus(isActive); return spatialData.Detach(); }