public override TestResult Execute(int paramSetId)
{
try
{
var param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
_resourceService.DeleteResource(resId);
return(TestResult.FromByteReader(null));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
var param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "OWNER", param);
_unitTestVm.ReadParameterValue(paramSetId, "INCLUDEDESCENDANTS", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
_resourceService.ChangeResourceOwner(resId, param["OWNER"], (param["INCLUDEDESCENDANTS"] == "1"));
return(TestResult.FromByteReader(null));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
var param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "SOURCE", param);
_unitTestVm.ReadParameterValue(paramSetId, "DESTINATION", param);
MgResourceIdentifier srcId = null;
if (param["SOURCE"] != null)
{
srcId = new MgResourceIdentifier(param["SOURCE"]);
}
MgResourceIdentifier dstId = null;
if (param["DESTINATION"] != null)
{
dstId = new MgResourceIdentifier(param["DESTINATION"]);
}
_resourceService.CopyResource(srcId, dstId, false);
return(TestResult.FromByteReader(null));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
var param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "CONTENT", param, true);
_unitTestVm.ReadParameterValue(paramSetId, "HEADER", param, true);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
MgByteReader content = CommonUtility.GetByteReaderFromPath(param["CONTENT"]);
MgByteReader header = CommonUtility.GetByteReaderFromPath(param["HEADER"]);
_resourceService.SetResource(resId, content, header);
return(TestResult.FromByteReader(null));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
//----------------------------------------------------------------------------------------
// �� �ܣ� ��Mapguide���ص�����ת��ΪKML
//
// �� �ߣ�
//
//
// �� �ڣ�2007.05.#
//
//-----------------------------------------------------------------------------------------
public String createMuniMarker()
{
StringBuilder outString = new StringBuilder();
MgGeometryFactory geoFactory = new MgGeometryFactory();
outString.Append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
MgFeatureService featureService = (MgFeatureService)siteConnection.CreateService(MgServiceType.FeatureService);
MgResourceIdentifier resId = new MgResourceIdentifier("Library://MgTutorial/Data/WheatonMunicipalities.FeatureSource");
MgFeatureReader featureReader = featureService.SelectFeatures(resId, "WheatonMunicipalities", null);
outString.Append("<markers>");
MgAgfReaderWriter geoReader = new MgAgfReaderWriter();
while (featureReader.ReadNext())
{
String muniName = featureReader.GetString("MUNINAME");
MgByteReader byteReader = featureReader.GetGeometry("Geometry");
MgGeometry geo = geoReader.Read(byteReader);
MgPoint pt = geo.GetCentroid();
double x = pt.GetCoordinate().GetX();
double y = pt.GetCoordinate().GetY();
outString.Append("<marker lat=\"" + y + "\" lng=\"" + x + "\" info=\"" + muniName + "\" />");
}
featureReader.Close();
outString.Append("</markers>");
return outString.ToString();
}
public void CreateBufferFeatureSource(MgFeatureService featureService, String wkt, MgResourceIdentifier bufferFeatureResId)
{
MgClassDefinition bufferClass = new MgClassDefinition();
bufferClass.SetName("BufferClass");
MgPropertyDefinitionCollection properties = bufferClass.GetProperties();
MgDataPropertyDefinition idProperty = new MgDataPropertyDefinition("ID");
idProperty.SetDataType(MgPropertyType.Int32);
idProperty.SetReadOnly(true);
idProperty.SetNullable(false);
idProperty.SetAutoGeneration(true);
properties.Add(idProperty);
MgGeometricPropertyDefinition polygonProperty = new MgGeometricPropertyDefinition("BufferGeometry");
polygonProperty.SetGeometryTypes(MgFeatureGeometricType.Surface);
polygonProperty.SetHasElevation(false);
polygonProperty.SetHasMeasure(false);
polygonProperty.SetReadOnly(false);
polygonProperty.SetSpatialContextAssociation("defaultSrs");
properties.Add(polygonProperty);
MgPropertyDefinitionCollection idProperties = bufferClass.GetIdentityProperties();
idProperties.Add(idProperty);
bufferClass.SetDefaultGeometryPropertyName("BufferGeometry");
MgFeatureSchema bufferSchema = new MgFeatureSchema("BufferLayerSchema", "temporary schema to hold a buffer");
bufferSchema.GetClasses().Add(bufferClass);
MgCreateSdfParams sdfParams = new MgCreateSdfParams("defaultSrs", wkt, bufferSchema);
featureService.CreateFeatureSource(bufferFeatureResId, sdfParams);
}
public override TestResult Execute(int paramSetId)
{
try
{
var param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "TYPE", param);
_unitTestVm.ReadParameterValue(paramSetId, "DEPTH", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
MgByteReader byteReader = _resourceService.EnumerateResources(resId, Convert.ToInt32(param["DEPTH"]), param["TYPE"] ?? "");
return(TestResult.FromByteReader(byteReader, "GETRESOURCEDATA"));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public bool ClearSpatialFilter()
{
bool result = true;
MgUserInformation userInfo = new MgUserInformation(Request["SESSION"]);
MgSiteConnection siteConnection = new MgSiteConnection();
siteConnection.Open(userInfo);
MgResourceIdentifier sdfResId = new MgResourceIdentifier("Session:" + Request["SESSION"] + "//Filter.FeatureSource");
MgResourceService resourceService = siteConnection.CreateService(MgServiceType.ResourceService) as MgResourceService;
MgFeatureService featureService = siteConnection.CreateService(MgServiceType.FeatureService) as MgFeatureService;
MgMap map = new MgMap();
map.Open(resourceService, Request["MAPNAME"]);
MgFeatureCommandCollection updateCommands = new MgFeatureCommandCollection();
MgLayer layer = null;
MgLayerCollection layers = map.GetLayers();
if (layers.Contains("_QuerySpatialFilter"))
{
layer = (MgLayer)layers.GetItem("_QuerySpatialFilter");
updateCommands.Add(new MgDeleteFeatures("Filter", "ID > 0"));
featureService.UpdateFeatures(sdfResId, updateCommands, false);
layers.Remove(layer);
map.Save(resourceService);
}
return result;
}
public void TestEnd()
{
try
{
var fact = new MgdServiceFactory();
MgdResourceService service = (MgdResourceService)fact.CreateService(MgServiceType.ResourceService);
MgResourceIdentifier mapres1 = new MgResourceIdentifier("Library://UnitTests/Data/Shuttle.DrawingSource");
service.DeleteResource(mapres1);
if (service.ResourceExists(resourceIdentifier))
{
service.DeleteResource(resourceIdentifier);
}
if (service.ResourceExists(resourceIdentifier2))
{
service.DeleteResource(resourceIdentifier2);
}
if (service.ResourceExists(resourceIdentifier3))
{
service.DeleteResource(resourceIdentifier3);
}
if (service.ResourceExists(resourceIdentifier4))
{
service.DeleteResource(resourceIdentifier4);
}
}
catch (MgException ex)
{
ex.Dispose();
}
}
public override void Invoke()
{
var provider = this.Viewer.GetProvider();
var mdfId = new MgResourceIdentifier(this.MapDefinition);
var map = provider.CreateMap(mdfId, mdfId.GetName());
provider.LoadMap(map);
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgdRenderingService renSvc = (MgdRenderingService)fact.CreateService(MgServiceType.RenderingService);
MgResourceIdentifier mdfId = new MgResourceIdentifier(txtMapDefinition.Text);
var sw = new Stopwatch();
sw.Start();
MgdMap map = new MgdMap(mdfId);
sw.Stop();
Trace.TraceInformation("Runtime map created in {0}ms", sw.ElapsedMilliseconds);
map.SetViewScale(Convert.ToDouble(txtScale.Text));
sw.Reset();
sw.Start();
MgByteReader response = renSvc.RenderTile(map, txtBaseGroup.Text, Convert.ToInt32(txtCol.Text), Convert.ToInt32(txtRow.Text));
sw.Stop();
Trace.TraceInformation("RenderTile executed in {0}ms", sw.ElapsedMilliseconds);
new ImageResponseDialog(response).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
}
}
internal NameValueCollection GetPropertyMappings(MgLayerBase layer)
{
MgResourceIdentifier resId = layer.GetLayerDefinition();
string resIdStr = resId.ToString();
if (_propertyMappings.ContainsKey(resIdStr))
{
return(_propertyMappings[resIdStr]);
}
MgByteReader content = _resSvc.GetResourceContent(resId);
XmlDocument doc = new XmlDocument();
string xml = content.ToString();
doc.LoadXml(xml);
XmlNodeList propMaps = doc.GetElementsByTagName("PropertyMapping"); //NOXLATE
if (propMaps.Count > 0)
{
NameValueCollection propertyMappings = new NameValueCollection();
foreach (XmlNode pm in propMaps)
{
propertyMappings[pm["Name"].InnerText] = pm["Value"].InnerText; //NOXLATE
}
_propertyMappings[resIdStr] = propertyMappings;
}
else
{
//NULL is a legit dictionary value
_propertyMappings[resIdStr] = null;
}
return(_propertyMappings[resIdStr]);
}
// GET: Home
public ActionResult Index()
{
MgUserInformation user = new MgUserInformation("Anonymous", "");
MgSiteConnection conn = new MgSiteConnection();
conn.Open(user);
MgResourceService resSvc = (MgResourceService)conn.CreateService(MgServiceType.ResourceService);
var vm = new HomeViewModel()
{
HasSampleResources = true,
AjaxLayout = AJAX_LAYOUT,
FlexLayout = FLEX_LAYOUT
};
MgResourceIdentifier mdfId = new MgResourceIdentifier("Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition");
MgResourceIdentifier sample1 = new MgResourceIdentifier(vm.AjaxLayout);
MgResourceIdentifier sample2 = new MgResourceIdentifier(vm.FlexLayout);
vm.HasSampleResources = resSvc.ResourceExists(mdfId) &&
resSvc.ResourceExists(sample1) &&
resSvc.ResourceExists(sample2);
return(View(vm));
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgdRenderingService renSvc = (MgdRenderingService)fact.CreateService(MgServiceType.RenderingService);
MgResourceIdentifier mdfId = new MgResourceIdentifier(txtMapDefinition.Text);
var sw = new Stopwatch();
sw.Start();
MgdMap map = new MgdMap(mdfId);
sw.Stop();
Trace.TraceInformation("Runtime map created in {0}ms", sw.ElapsedMilliseconds);
map.SetViewScale(Convert.ToDouble(txtScale.Text));
sw.Reset();
sw.Start();
MgByteReader response = renSvc.RenderTile(map, txtBaseGroup.Text, Convert.ToInt32(txtCol.Text), Convert.ToInt32(txtRow.Text));
sw.Stop();
Trace.TraceInformation("RenderTile executed in {0}ms", sw.ElapsedMilliseconds);
new ImageResponseDialog(response).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
}
}
internal void DeleteLayer(RedlineLayer layer)
{
var regId = GetRegistryFeatureSource();
MgFeatureCommandCollection commands = new MgFeatureCommandCollection();
MgDeleteFeatures delete = new MgDeleteFeatures("Default:MarkupRegistry", "ResourceId = '" + layer.FeatureSource + "'");
commands.Add(delete);
MgPropertyCollection results = _featSvc.UpdateFeatures(regId, commands, false);
MgInt32Property deleteResult = results.GetItem(0) as MgInt32Property;
if (deleteResult != null && deleteResult.GetValue() > 0)
{
var ldfId = new MgResourceIdentifier(layer.LayerDefinition);
var fsId = new MgResourceIdentifier(layer.FeatureSource);
if (_resSvc.ResourceExists(ldfId))
{
_resSvc.DeleteResource(ldfId);
}
if (_resSvc.ResourceExists(fsId))
{
_resSvc.DeleteResource(fsId);
}
}
}
public override TestResult Execute(int paramSetId)
{
try
{
NameValueCollection param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "SCHEMANAME", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
MgStringCollection result = _featureService.GetClasses(resId, param["SCHEMANAME"]);
return(new TestResult(CommonUtility.MgStringCollectionToString(result), "text/plain"));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public static void SetResourceFromXml(HtzMgHelper helper, MgResourceIdentifier resourceId, XmlDocument doc)
{
byte[] layerDef = new UTF8Encoding().GetBytes(doc.InnerXml);
MgByteSource byteSource = new MgByteSource(layerDef, layerDef.Length);
byteSource.SetMimeType("text/xml");
helper.ResourceService.SetResource(resourceId, byteSource.GetReader(), null);
}
public override TestResult Execute(int paramSetId)
{
try
{
NameValueCollection param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "LONGTRANSACTIONNAME", param);
_unitTestVm.ReadParameterValue(paramSetId, "CREATESESSION", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
if (param["CREATESESSION"] == "TRUE")
{
string sessionId = _creator.CreateSession();
_apply.SetSessionId(sessionId);
}
bool bRes = _featureService.SetLongTransaction(resId, param["LONGTRANSACTIONNAME"]);
return(new TestResult(CommonUtility.BooleanToString(bRes), "text/plain"));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
NameValueCollection param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
bool bRes = false;
MgResourceIdentifier resId = null;
if (!string.IsNullOrEmpty(param["RESOURCEID"]))
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
bRes = _featureService.TestConnection(resId);
}
else
{
_unitTestVm.ReadParameterValue(paramSetId, "PROVIDER", param);
_unitTestVm.ReadParameterValue(paramSetId, "CONNECTIONSTRING", param);
bRes = _featureService.TestConnection(param["PROVIDER"] ?? "", param["CONNECTIONSTRING"] ?? "");
}
return(new TestResult(CommonUtility.BooleanToString(bRes), "text/plain"));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
NameValueCollection param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "SQL", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
MgSqlDataReader reader = _featureService.ExecuteSqlQuery(resId, param["SQL"]);
MgByteReader byteReader = reader.ToXml();
reader.Close();
return(TestResult.FromByteReader(byteReader));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
NameValueCollection param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "ACTIVEONLY", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
MgLongTransactionReader reader = _featureService.GetLongTransactions(resId, (param["ACTIVEONLY"] == "1"));
MgByteReader byteReader = reader.ToXml();
reader.Close();
return(TestResult.FromByteReader(byteReader));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
NameValueCollection param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "SCHEMA", param);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
string result = _featureService.DescribeSchemaAsXml(resId, param["SCHEMA"]);
return(new TestResult(result, "text/xml"));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public override TestResult Execute(int paramSetId)
{
try
{
this.CreateMapFromResource(paramSetId);
_unitTestVm.Execute("Select ParamValue from Params WHERE ParamSet={0} AND ParamName=\"LAYERDEFINITION\"", paramSetId);
string layerDefinition = _unitTestVm.GetString("ParamValue");
_unitTestVm.Execute("Select ParamValue from Params WHERE ParamSet={0} AND ParamName=\"GROUPNAME\"", paramSetId);
string groupName = _unitTestVm.GetString("ParamValue");
var ldfId = new MgResourceIdentifier(layerDefinition);
var layer = _creator.CreateLayer(ldfId);
if (!string.IsNullOrEmpty(groupName))
{
var groups = _map.GetLayerGroups();
var gidx = groups.IndexOf(groupName);
if (gidx >= 0)
{
layer.SetGroup(groups.GetItem(gidx));
}
}
var layers = _map.GetLayers();
layers.Add(layer);
return(new TestResult(layers.GetCount().ToString(), "text/plain"));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
}
public IEnumerable<RedlineObject> GetAllFeatures()
{
MgMapBase map = _viewer.GetMap();
MgLayerCollection layers = map.GetLayers();
MgLayerBase redlineLayer = layers.GetItem(_layer.SystemName);
MgResourceIdentifier resId = new MgResourceIdentifier(redlineLayer.GetFeatureSourceId());
MgFeatureReader reader = null;
try
{
reader = _featSvc.SelectFeatures(resId, RedlineSchemaFactory.CLASS_NAME, null);
//HACK: Another leaky abstraction. SHP will always choose FeatId, so once again
//use the class definition to determine the identity property name
MgClassDefinition cls = reader.GetClassDefinition();
MgPropertyDefinitionCollection idProps = cls.GetIdentityProperties();
MgPropertyDefinition keyProp = idProps.GetItem(0);
string idName = keyProp.GetName();
while (reader.ReadNext())
{
int id = reader.GetInt32(idName);
string text = reader.IsNull(RedlineSchemaFactory.TEXT_NAME) ? string.Empty : reader.GetString(RedlineSchemaFactory.TEXT_NAME);
yield return new RedlineObject(id, text);
}
}
finally
{
if (reader != null)
reader.Close();
}
}
private MgByteReader Plot(MapGuideViewerInputModel input, bool useLayout, double?scale)
{
MgSiteConnection conn = CreateConnection(input);
MgMap map = new MgMap(conn);
map.Open(input.MapName);
MgPoint center = map.ViewCenter;
MgCoordinate coord = center.Coordinate;
MgMappingService mappingService = (MgMappingService)conn.CreateService(MgServiceType.MappingService);
MgDwfVersion dwfVersion = new MgDwfVersion("6.01", "1.2");
MgPlotSpecification plotSpec = new MgPlotSpecification(8.5f, 11f, MgPageUnitsType.Inches, 0f, 0f, 0f, 0f);
plotSpec.SetMargins(0.5f, 0.5f, 0.5f, 0.5f);
MgLayout layout = null;
if (useLayout)
{
MgResourceIdentifier layoutRes = new MgResourceIdentifier("Library://Samples/Sheboygan/Layouts/SheboyganMap.PrintLayout");
layout = new MgLayout(layoutRes, "City of Sheboygan", MgPageUnitsType.Inches);
}
if (!scale.HasValue)
{
return(mappingService.GeneratePlot(map, plotSpec, layout, dwfVersion));
}
else
{
MgCoordinate mapCenter = map.GetViewCenter().GetCoordinate();
return(mappingService.GeneratePlot(map, mapCenter, scale.Value, plotSpec, layout, dwfVersion));
}
}
public MgMapBase CreateMap(MgResourceIdentifier mapDefinition, string mapName, int width, int height, double x, double y, double scale, int dpi)
{
var map = new MgMap(_siteConn);
map.Create(mapDefinition, mapName, width, height, x, y, scale, dpi);
return(map);
}
public MgMapBase CreateMap(MgResourceIdentifier mapDefinition)
{
var map = new MgMap(_siteConn);
map.Create(mapDefinition, mapDefinition.Name);
return(map);
}
// GET: Home
public ActionResult Index()
{
MgUserInformation user = new MgUserInformation("Anonymous", "");
MgSiteConnection conn = new MgSiteConnection();
conn.Open(user);
MgResourceService resSvc = (MgResourceService)conn.CreateService(MgServiceType.ResourceService);
var vm = new HomeViewModel()
{
HasSampleResources = true,
AjaxLayout = AJAX_LAYOUT,
FlexLayout = FLEX_LAYOUT
};
MgResourceIdentifier mdfId = new MgResourceIdentifier("Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition");
MgResourceIdentifier sample1 = new MgResourceIdentifier(vm.AjaxLayout);
MgResourceIdentifier sample2 = new MgResourceIdentifier(vm.FlexLayout);
vm.HasSampleResources = resSvc.ResourceExists(mdfId) &&
resSvc.ResourceExists(sample1) &&
resSvc.ResourceExists(sample2);
return View(vm);
}
private void btnCreateFile_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
var featureSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);
var param = new MgFileFeatureSourceParams();
param.CoordinateSystemWkt = txtCoordinateSystemWkt.Text;
param.FileName = txtFileName.Text;
var schemas = featureSvc.XmlToSchema(File.ReadAllText(txtSchemaXml.Text));
param.FeatureSchema = schemas.GetItem(0);
param.ProviderName = txtProvider.Text;
param.SpatialContextDescription = "Created from MgFileFeatureSourceParams";
param.SpatialContextName = txtCoordinateSystemName.Text;
param.XYTolerance = double.Parse(txtXYTolerance.Text);
param.ZTolerance = double.Parse(txtZTolerance.Text);
var fsId = new MgResourceIdentifier(txtResourceId.Text);
featureSvc.CreateFeatureSource(fsId, param);
MessageBox.Show("Success");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public void LoadMap(MgResourceIdentifier resId)
{
var map = new MgdMap(resId);
viewer.Init(new MgDesktopMapViewerProvider(map));
//viewer.RefreshMap();
}
private void btnCreateFile_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
var featureSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);
var param = new MgFileFeatureSourceParams();
param.CoordinateSystemWkt = txtCoordinateSystemWkt.Text;
param.FileName = txtFileName.Text;
var schemas = featureSvc.XmlToSchema(File.ReadAllText(txtSchemaXml.Text));
param.FeatureSchema = schemas.GetItem(0);
param.ProviderName = txtProvider.Text;
param.SpatialContextDescription = "Created from MgFileFeatureSourceParams";
param.SpatialContextName = txtCoordinateSystemName.Text;
param.XYTolerance = double.Parse(txtXYTolerance.Text);
param.ZTolerance = double.Parse(txtZTolerance.Text);
var fsId = new MgResourceIdentifier(txtResourceId.Text);
featureSvc.CreateFeatureSource(fsId, param);
MessageBox.Show("Success");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgFeatureService featSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);
MgFeatureQueryOptions query = new MgFeatureQueryOptions();
string[] propNames = txtProps.Text.Split(',');
foreach (var p in propNames)
{
if (string.IsNullOrEmpty(p))
continue;
query.AddFeatureProperty(p);
}
foreach (Pair p in lstComputed.Items)
{
query.AddComputedProperty(p.Name, p.Expr);
}
if (!string.IsNullOrEmpty(txtFilter.Text.Trim()))
query.SetFilter(txtFilter.Text.Trim());
MgResourceIdentifier fsId = new MgResourceIdentifier(txtFeatureSource.Text);
MgFeatureReader reader = featSvc.SelectFeatures(fsId, txtClass.Text, query);
new ReaderResponseDialog(reader).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private MgByteReader Plot(MapGuideViewerInputModel input, bool useLayout, double? scale)
{
MgSiteConnection conn = CreateConnection(input);
MgMap map = new MgMap(conn);
map.Open(input.MapName);
MgPoint center = map.ViewCenter;
MgCoordinate coord = center.Coordinate;
MgMappingService mappingService = (MgMappingService)conn.CreateService(MgServiceType.MappingService);
MgDwfVersion dwfVersion = new MgDwfVersion("6.01", "1.2");
MgPlotSpecification plotSpec = new MgPlotSpecification(8.5f, 11f, MgPageUnitsType.Inches, 0f, 0f, 0f, 0f);
plotSpec.SetMargins(0.5f, 0.5f, 0.5f, 0.5f);
MgLayout layout = null;
if (useLayout)
{
MgResourceIdentifier layoutRes = new MgResourceIdentifier("Library://Samples/Sheboygan/Layouts/SheboyganMap.PrintLayout");
layout = new MgLayout(layoutRes, "City of Sheboygan", MgPageUnitsType.Inches);
}
if (!scale.HasValue)
{
return mappingService.GeneratePlot(map, plotSpec, layout, dwfVersion);
}
else
{
MgCoordinate mapCenter = map.GetViewCenter().GetCoordinate();
return mappingService.GeneratePlot(map, mapCenter, scale.Value, plotSpec, layout, dwfVersion);
}
}
private void AddRedlineLayerToMap(MgResourceIdentifier ldfId)
{
MgLayerGroup group = null;
var layers = _map.GetLayers();
var groups = _map.GetLayerGroups();
if (groups.Contains(GROUP_NAME))
{
group = groups.GetItem(GROUP_NAME);
}
else
{
group = new MgLayerGroup(GROUP_NAME);
group.SetVisible(true);
group.SetLegendLabel(Strings.RedlineLayerGroupLabel);
group.SetDisplayInLegend(true);
groups.Add(group);
}
var provider = _viewer.GetProvider();
var newLayer = provider.CreateLayer(ldfId);
newLayer.SetDisplayInLegend(true);
newLayer.SetName("_" + ldfId.Name);
newLayer.SetLegendLabel(ldfId.Name);
newLayer.SetSelectable(true);
newLayer.SetGroup(group);
layers.Insert(0, newLayer);
}
public override TestResult Execute(int paramSetId)
{
try
{
var param = new NameValueCollection();
_unitTestVm.ReadParameterValue(paramSetId, "RESOURCEID", param);
_unitTestVm.ReadParameterValue(paramSetId, "DATANAME", param);
_unitTestVm.ReadParameterValue(paramSetId, "DATATYPE", param);
_unitTestVm.ReadParameterValue(paramSetId, "DATA", param, true);
MgResourceIdentifier resId = null;
if (param["RESOURCEID"] != null)
{
resId = new MgResourceIdentifier(param["RESOURCEID"]);
}
string extension = CommonUtility.GetExtension(param["DATANAME"]);
string mimeType = CommonUtility.GetMimeType(extension);
MgByteSource dataSource = new MgByteSource(param["DATA"]);
dataSource.SetMimeType(mimeType);
MgByteReader dataReader = dataSource.GetReader();
_resourceService.SetResourceData(resId, param["DATANAME"], param["DATATYPE"], dataReader);
return(TestResult.FromByteReader(null));
}
catch (MgException ex)
{
return(TestResult.FromMgException(ex));
}
catch (Exception ex)
{
return(TestResult.FromException(ex));
}
}
public void TestEnd()
{
try
{
var fact = new MgdServiceFactory();
MgdResourceService service = (MgdResourceService)fact.CreateService(MgServiceType.ResourceService);
MgResourceIdentifier mapres1 = new MgResourceIdentifier("Library://UnitTests/Data/Shuttle.DrawingSource");
service.DeleteResource(mapres1);
if (service.ResourceExists(resourceIdentifier))
service.DeleteResource(resourceIdentifier);
if (service.ResourceExists(resourceIdentifier2))
service.DeleteResource(resourceIdentifier2);
if (service.ResourceExists(resourceIdentifier3))
service.DeleteResource(resourceIdentifier3);
if (service.ResourceExists(resourceIdentifier4))
service.DeleteResource(resourceIdentifier4);
}
catch (MgException ex)
{
ex.Dispose();
}
}
private void btnSinglePlot_Click(object sender, EventArgs e)
{
MgdMap map = (MgdMap)_viewer.GetMap();
MgMapViewerProvider provider = _viewer.GetProvider();
MgdMappingService mappingSvc = (MgdMappingService)provider.CreateService(MgServiceType.MappingService);
MgResourceIdentifier layoutId = new MgResourceIdentifier("Library://Samples/Sheboygan/Layouts/SheboyganMap.PrintLayout");
using (SaveFileDialog save = new SaveFileDialog())
{
save.Filter = "DWF Files (*.dwf)|*.dwf";
if (save.ShowDialog() == DialogResult.OK)
{
MgdDwfVersion dwfVer = new MgdDwfVersion("6.01", "1.2");
MgdLayout layout = new MgdLayout(layoutId, "City of Sheboygan", MgdPageUnitsType.Inches);
MgdPlotSpecification plotSpec = new MgdPlotSpecification(8.5f, 11.0f, MgdPageUnitsType.Inches, 0.5f, 0.5f, 0.5f, 0.5f);
MgByteReader result = mappingSvc.GeneratePlot(map, plotSpec, layout, dwfVer);
MgByteSink sink = new MgByteSink(result);
sink.ToFile(save.FileName);
MessageBox.Show("Saved to " + save.FileName);
}
}
}
private void btnDisplaySpatialReference_Click(object sender, EventArgs e)
{
MgMapBase map = _viewer.GetMap();
MgResourceIdentifier resId = map.MapDefinition;
string mapSrs = map.GetMapSRS();
MessageBox.Show("Map: (" + resId.ToString() + ") uses this reference system: " + Environment.NewLine + Environment.NewLine + mapSrs);
}
private static void LoadResourceData(MgResourceService resSvc, string resIdStr, string dataName, string dataType, string path)
{
MgResourceIdentifier resId = new MgResourceIdentifier(resIdStr);
MgByteSource bs = new MgByteSource(path);
MgByteReader br = bs.GetReader();
resSvc.SetResourceData(resId, dataName, dataType, br);
}
private static void LoadResource(MgResourceService resSvc, string resIdStr, string path)
{
MgResourceIdentifier resId = new MgResourceIdentifier(resIdStr);
MgByteSource bs = new MgByteSource(path);
MgByteReader br = bs.GetReader();
resSvc.SetResource(resId, br, null);
}
public static void ClearDataSource(MgFeatureService featSvc, MgResourceIdentifier fsId, String featureName)
{
MgDeleteFeatures deleteCmd = new MgDeleteFeatures(featureName, "ID >= 0"); //NOXLATE
MgFeatureCommandCollection commands = new MgFeatureCommandCollection();
commands.Add(deleteCmd);
featSvc.UpdateFeatures(fsId, commands, false);
}
public override void Invoke()
{
var provider = this.Viewer.GetProvider();
var mdfId = new MgResourceIdentifier(this.MapDefinition);
var map = provider.CreateMap(mdfId, mdfId.GetName());
provider.LoadMap(map);
}
private void btnReload_Click(object sender, EventArgs e)
{
_viewer.ClearSelection();
MgResourceIdentifier mdfId = new MgResourceIdentifier("Library://Samples/Sheboygan/Maps/Sheboygan.MapDefinition");
MgdMap map = new MgdMap(mdfId);
MgDesktopMapViewerProvider provider = new MgDesktopMapViewerProvider(map);
Shell.Instance.ReloadViewer(provider);
}
// Methods
public static XmlDocument GetResourceXml(HtzMgHelper helper, MgResourceIdentifier resourceId)
{
XmlDocument result = new XmlDocument();
if (resourceId != null)
{
result.LoadXml(helper.ResourceService.GetResourceContent(resourceId).ToString());
}
return result;
}
public static void AddPointFeature(string FeatureName, MgPropertyCollection featureProps, MgPoint geom, MgFeatureService featureSrvc, MgResourceIdentifier dataSourceId)
{
MgByteReader geomReader = new MgAgfReaderWriter().Write(geom);
MgGeometryProperty geometryProp = new MgGeometryProperty("GEOM", geomReader);
featureProps.Add(geometryProp);
MgInsertFeatures cmd = new MgInsertFeatures(FeatureName, featureProps);
MgFeatureCommandCollection commands = new MgFeatureCommandCollection();
commands.Add(cmd);
ReleaseReader(featureSrvc.UpdateFeatures(dataSourceId, commands, false));
}
public HtzMgHelper(string userName, string userPass, string layoutId, string mapDefinition)
{
Init();
this._connection = new MgSiteConnection();
this._connection.Open(new MgUserInformation(userName, userPass));
this._sessionId = this._connection.GetSite().CreateSession();
this._map = new MgMap();
MgResourceIdentifier mapDef = new MgResourceIdentifier(mapDefinition);
this._map.Create(this.ResourceService, mapDef, mapDef.Name);
this._layoutId = layoutId;
}
static void Main(string [] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
//Must call MgPlatform.Initialize() before we can work with anything from the MapGuide API
try
{
var sw = new Stopwatch();
sw.Start();
MgdPlatform.Initialize("Platform.ini");
sw.Stop();
Trace.TraceInformation("Platform initialization took {0}ms", sw.ElapsedMilliseconds);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
return;
}
//MgAppWindow is our Main Window class full of drag-and-drop component goodness. Go ahead and
//take a look at MgAppWindow.cs source, not much code there except for the 3 generic invoke components and the
//single custom selection handler. Everything else is encapsulated by designer-friendly drag and drop components
//Most of the work is dragging and dropping components into the designer surface, and setting lots of properties
var frm = new MgAppWindow();
//We can initialize without specifying a map (allowing for components that do not
//require a loaded map to still be used). You just have to call LoadMap() on the MgMapViewer
//instance when ready (not demonstrated here). So if you do load a package here, you will
//have to restart the application
MgResourceIdentifier resId = null;
if (args.Length == 1)
{
resId = new MgResourceIdentifier(args[0]);
resId.Validate();
}
var fact = new MgdServiceFactory();
var resSvc = (MgdResourceService)fact.CreateService(MgServiceType.ResourceService);
MgdMap map = null;
if (resId != null && resSvc.ResourceExists(resId))
map = new MgdMap(resId);
//This is just a pass-through call to MgMapViewer.Init()
frm.LoadMap(new MgDesktopMapViewerProvider(map));
Application.ApplicationExit += new EventHandler(OnAppExit);
Application.Run(frm);
}
// Methods
public HtzMaintenanceHelper(HtzMgHelper helper, MgLayer parentLayer, string uidKey)
{
this.ModuleAllowed = true;
this.InitDefaultInfraTypes();
this._helper = helper;
this._uidKey = string.IsNullOrEmpty(uidKey) ? "UID" : uidKey;
this._parentLayer = parentLayer;
//if (this._helper.Configuration != null)
//{
// this._config = this._helper.Configuration.GetProperties("FeatureCard");
// Dictionary<string, string> tmp = new Dictionary<string, string>();
// foreach (KeyValuePair<string, string> item in this._infraTypes)
// {
// if (!this._config.ContainsKey("ShowMaintFor" + item.Key))
// {
// this._helper.Configuration.RegisterPropertyDefinition("FeatureCard", "ShowMaintFor" + item.Key, item.Value, ConfigPropertyType.Boolean, "תחזוקה - הצגת שכבות", false);
// }
// else if ((bool)this._config["ShowMaintFor" + item.Key].Value)
// {
// tmp.Add(item.Key, item.Value);
// }
// }
// this._infraTypes = tmp;
//}
string mapPath = this._helper.Map.MapDefinition.Path;
if (mapPath.LastIndexOf("/Maps") < 0)
{
this.ModuleAllowed = false;
}
else
{
this._maintenancePath = mapPath.Substring(0, mapPath.IndexOf("/Maps"));
this._sdfResId = new MgResourceIdentifier(string.Format("Library://{0}/Maintenance/Data/Maintenance.FeatureSource", this._maintenancePath));
this._layersResId = new List<MgResourceIdentifier>();
if (!this._helper.ResourceService.ResourceExists(this._sdfResId))
{
this.CreateSdf(this._sdfResId);
}
foreach (KeyValuePair<string, string> item in this._infraTypes)
{
MgResourceIdentifier resId = new MgResourceIdentifier(string.Format("Library://{0}/Maintenance/Layers/Maint_{1}.LayerDefinition", this._maintenancePath, item.Key));
this._layersResId.Add(resId);
if (!this._helper.ResourceService.ResourceExists(resId))
{
this.CreateLayer(resId, string.Format("InfrastructureType='{0}'", item.Value));
}
}
this.AttachLayers();
this._infraTypes.Add("none", "בחר מרשימה");
}
}
// Create a temporary Feature Source to store geocode results.
public void CreateLocationMarkerFeatureSource(MgFeatureService featureService, MgResourceIdentifier locationMarkerDataResId, MgMap map)
{
//String ll84Wkt = "GEOGCS[\"LL84\",DATUM[\"WGS_1984\",SPHEROID[\"WGS 84\",6378137,298.25722293287],TOWGS84[0,0,0,0,0,0,0]],PRIMEM[\"Greenwich\",0],UNIT[\"Degrees\",1]]";
//string ll84Wkt = "LOCAL_CS[\"*XY-MT*\",LOCAL_DATUM[\"*X-Y*\",10000],UNIT[\"Meter\", 1],AXIS[\"X\",EAST],AXIS[\"Y\",NORTH]] ";
MgCoordinateSystemFactory sysCoordsFactory = new MgCoordinateSystemFactory();
string srsDefMap = map.GetMapSRS();
string mapSrsUnits = string.Empty;
srsDefMap = !string.IsNullOrEmpty(srsDefMap) ? srsDefMap : "LOCAL_CS[\"*XY-MT*\",LOCAL_DATUM[\"*X-Y*\",10000],UNIT[\"Meter\", 1],AXIS[\"X\",EAST],AXIS[\"Y\",NORTH]] ";
MgCoordinateSystem srsMap = sysCoordsFactory.Create(srsDefMap);
MgClassDefinition locationClass = new MgClassDefinition();
locationClass.SetName("LocationMarker");
MgPropertyDefinitionCollection properties = locationClass.GetProperties();
MgDataPropertyDefinition idProperty = new MgDataPropertyDefinition("ID");
idProperty.SetDataType(MgPropertyType.Int32);
idProperty.SetReadOnly(true);
idProperty.SetNullable(false);
idProperty.SetAutoGeneration(true);
properties.Add(idProperty);
MgDataPropertyDefinition addressProperty = new MgDataPropertyDefinition("Address");
addressProperty.SetDataType(MgPropertyType.String);
addressProperty.SetLength(512);
properties.Add(addressProperty);
MgGeometricPropertyDefinition locationProperty = new MgGeometricPropertyDefinition("Location");
locationProperty.SetGeometryTypes(MgGeometryType.Point);
locationProperty.SetHasElevation(false);
locationProperty.SetHasMeasure(false);
locationProperty.SetReadOnly(false);
locationProperty.SetSpatialContextAssociation(srsMap.GetCsCode());
properties.Add(locationProperty);
MgPropertyDefinitionCollection idProperties = locationClass.GetIdentityProperties();
idProperties.Add(idProperty);
locationClass.SetDefaultGeometryPropertyName("Location");
MgFeatureSchema locationSchema = new MgFeatureSchema();
locationSchema.SetName("LocationMarkerSchema");
locationSchema.GetClasses().Add(locationClass);
MgCreateSdfParams sdfParams = new MgCreateSdfParams(srsMap.GetCsCode(), srsDefMap, locationSchema);
featureService.CreateFeatureSource(locationMarkerDataResId, sdfParams);
}
public MgdLayer CreateBufferLayer(MgResourceService resourceService, MgResourceIdentifier bufferFeatureResId, String sessionId)
{
// Load the layer definition template into
// a XmlDocument object, find the "ResourceId" element, and
// modify its content to reference the temporary
// feature source.
XmlDocument doc = new XmlDocument();
doc.LoadXml(Layers.BufferLayerDefinition);
XmlNode featureSourceNode = doc.GetElementsByTagName("ResourceId")[0];
featureSourceNode.InnerText = bufferFeatureResId.ToString();
// Get the updated layer definition from the XmlDocument
// and save it to the session repository using the
// ResourceService object.
MgByteSource byteSource = null;
using (MemoryStream ms = new MemoryStream())
{
doc.Save(ms);
ms.Position = 0L;
//Note we do this to ensure our XML content is free of any BOM characters
byte[] layerDefinition = ms.ToArray();
Encoding utf8 = Encoding.UTF8;
String layerDefStr = new String(utf8.GetChars(layerDefinition));
layerDefinition = new byte[layerDefStr.Length - 1];
int byteCount = utf8.GetBytes(layerDefStr, 1, layerDefStr.Length - 1, layerDefinition, 0);
byteSource = new MgByteSource(layerDefinition, layerDefinition.Length);
byteSource.SetMimeType(MgMimeType.Xml);
}
MgResourceIdentifier tempLayerResId = new MgResourceIdentifier("Session:" + sessionId + "//Buffer.LayerDefinition");
resourceService.SetResource(tempLayerResId, byteSource.GetReader(), null);
// Create an MgLayer object based on the new layer definition
// and return it to the caller.
MgdLayer bufferLayer = new MgdLayer(tempLayerResId, resourceService);
bufferLayer.SetName("Buffer");
bufferLayer.SetLegendLabel("Buffer");
bufferLayer.SetDisplayInLegend(true);
bufferLayer.SetSelectable(false);
return bufferLayer;
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgResourceService resSvc = (MgResourceService)fact.CreateService(MgServiceType.ResourceService);
MgResourceIdentifier resId = new MgResourceIdentifier(textBox1.Text);
resSvc.DeleteResourceData(resId, textBox2.Text);
MessageBox.Show("Success");
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgFeatureService featSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);
MgResourceIdentifier fsId = new MgResourceIdentifier(txtFeatureSource.Text);
bool res = featSvc.TestConnection(fsId);
MessageBox.Show("Result: " + res);
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgResourceService resSvc = (MgResourceService)fact.CreateService(MgServiceType.ResourceService);
MgResourceIdentifier resId = new MgResourceIdentifier(textBox1.Text);
MgByteReader response = resSvc.EnumerateResourceData(resId);
new XmlResponseDialog(response).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgFeatureService featSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);
MgResourceIdentifier fsId = new MgResourceIdentifier(textBox1.Text);
MgSpatialContextReader response = featSvc.GetSpatialContexts(fsId, checkBox1.Checked);
new SpatialContextResultDialog(response).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgResourceService resSvc = (MgResourceService)fact.CreateService(MgServiceType.ResourceService);
MgResourceIdentifier resId = new MgResourceIdentifier(textBox1.Text);
bool exists = resSvc.ResourceExists(resId);
MessageBox.Show("Exists: " + exists);
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
public ActionResult LoadSampleData(SetupInputModel input)
{
MgUserInformation user = new MgUserInformation(input.Username, input.Password);
MgSiteConnection conn = new MgSiteConnection();
conn.Open(user);
MgResourceService resSvc = (MgResourceService)conn.CreateService(MgServiceType.ResourceService);
//Load the package file if specified
if (input.Package != null && input.Package.ContentLength > 0)
{
var path = Path.GetTempFileName();
try
{
input.Package.SaveAs(path);
MgByteSource bs = new MgByteSource(path);
MgByteReader br = bs.GetReader();
resSvc.ApplyResourcePackage(br);
}
finally
{
try
{
if (System.IO.File.Exists(path))
System.IO.File.Delete(path);
}
catch { }
}
}
//Load in our sample-specific resources
MgResourceIdentifier sample1 = new MgResourceIdentifier(AJAX_LAYOUT);
MgResourceIdentifier sample2 = new MgResourceIdentifier(FLEX_LAYOUT);
MgByteSource bs1 = new MgByteSource(Server.MapPath("~/App_Data/SheboyganAspMvc.WebLayout.xml"));
MgByteReader br1 = bs1.GetReader();
resSvc.SetResource(sample1, br1, null);
MgByteSource bs2 = new MgByteSource(Server.MapPath("~/App_Data/SheboyganAspMvc.ApplicationDefinition.xml"));
MgByteReader br2 = bs2.GetReader();
resSvc.SetResource(sample2, br2, null);
return RedirectToAction("Index");
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgFeatureService featSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);
MgResourceIdentifier resId = new MgResourceIdentifier(textBox1.Text);
string sql = textBox2.Text;
int res = featSvc.ExecuteSqlNonQuery(resId, sql);
MessageBox.Show(res + " results affected");
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgFeatureService featSvc = (MgdFeatureService)fact.CreateService(MgServiceType.FeatureService);
MgResourceIdentifier fsId = new MgResourceIdentifier(textBox1.Text);
string sql = textBox2.Text;
MgSqlDataReader reader = featSvc.ExecuteSqlQuery(fsId, sql);
new ReaderResponseDialog(reader).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgResourceService resSvc = (MgResourceService)fact.CreateService(MgServiceType.ResourceService);
MgResourceIdentifier resId = new MgResourceIdentifier(txtResourceId.Text);
string type = txtType.Text;
int depth = Convert.ToInt32(txtDepth.Text);
MgByteReader response = resSvc.EnumerateResources(resId, depth, type);
new XmlResponseDialog(response).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgdRenderingService renSvc = (MgdRenderingService)fact.CreateService(MgServiceType.RenderingService);
MgResourceIdentifier resId = new MgResourceIdentifier(textBox1.Text);
MgdMap map = new MgdMap(resId);
double x;
double y;
if (double.TryParse(textBox2.Text, out x) &&
double.TryParse(textBox3.Text, out y))
{
map.SetViewCenterXY(x, y);
}
int w;
int h;
if (int.TryParse(txtWidth.Text, out w) &&
int.TryParse(txtHeight.Text, out h))
{
map.SetDisplaySize(w, h);
}
double scale;
if (double.TryParse(textBox4.Text, out scale))
{
map.SetViewScale(scale);
}
var sw = new Stopwatch();
sw.Start();
MgByteReader response = renSvc.RenderMap(map, null, textBox5.Text);
sw.Stop();
Trace.TraceInformation("RenderMap executed in {0}ms", sw.ElapsedMilliseconds);
new ImageResponseDialog(response).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
