private async Task DeleteAttachment(Attachment attachmentToDelete) { try { // Delete the attachment. await _selectedFeature.DeleteAttachmentAsync(attachmentToDelete); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); _featureAttachments = await _selectedFeature.GetAttachmentsAsync(); UpdateUIForFeature(); ShowMessage("Successfully deleted attachment", "Success!"); } catch (Exception exception) { ShowMessage(exception.ToString(), "Error deleting attachment"); } }
private async void AddAttachment(Android.Net.Uri imageUri) { string contentType = "image/jpeg"; // Read the image into a stream. Stream stream = ContentResolver.OpenInputStream(imageUri); // Read from the stream into the byte array. byte[] attachmentData; using (var memoryStream = new MemoryStream()) { stream.CopyTo(memoryStream); attachmentData = memoryStream.ToArray(); } // Add the attachment. // The contentType string is the MIME type for JPEG files, image/jpeg. await _selectedFeature.AddAttachmentAsync(imageUri.LastPathSegment + ".jpg", contentType, attachmentData); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); _featureAttachments = await _selectedFeature.GetAttachmentsAsync(); UpdateUIForFeature(); ShowMessage("Successfully added attachment", "Success!"); }
private async void DeleteAttachment_Click(object sender, EventArgs e) { AttachmentActivityIndicator.IsVisible = true; try { // Get the attachment that should be deleted. Button sendingButton = (Button)sender; Attachment selectedAttachment = (Attachment)sendingButton.BindingContext; // Delete the attachment. await _selectedFeature.DeleteAttachmentAsync(selectedAttachment); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync(); // Show success message. await Application.Current.MainPage.DisplayAlert("Success!", "Successfully deleted attachment", "OK"); } catch (Exception exception) { await Application.Current.MainPage.DisplayAlert("Error deleting attachment", exception.ToString(), "OK"); } finally { AttachmentActivityIndicator.IsVisible = false; } }
private async void UpdateDamageType(string selectedAttributeValue) { try { // Load the feature. await _selectedFeature.LoadAsync(); // Update the attribute value. _selectedFeature.SetAttributeValue(AttributeFieldName, selectedAttributeValue); // Update the table. await _selectedFeature.FeatureTable.UpdateFeatureAsync(_selectedFeature); // Update the service. ServiceFeatureTable table = (ServiceFeatureTable)_selectedFeature.FeatureTable; await table.ApplyEditsAsync(); ShowMessage("Success!", $"Edited feature {_selectedFeature.Attributes["objectid"]}"); } catch (Exception ex) { ShowMessage("Failed to edit feature", ex.ToString()); } finally { // Clear the selection. _damageLayer.ClearSelection(); _selectedFeature = null; // Dismiss any callout. _myMapView.DismissCallout(); } }
/// <summary> /// Enables attribute editing, submits attribute edit back to the server and refreshes dynamic layer. /// </summary> private async void ChoiceList_SelectionChanged(object sender, SelectionChangedEventArgs e) { ChoiceList.SelectionChanged -= ChoiceList_SelectionChanged; var featureID = (Int64)AttributeEditor.Tag; var selected = (KeyValuePair <object, string>)ChoiceList.SelectedItem; var layer = MyMapView.Map.Layers["PoolPermit"] as ArcGISDynamicMapServiceLayer; var overlay = MyMapView.GraphicsOverlays["Highlighter"] as GraphicsOverlay; string message = null; try { if (table == null) { // Creates table based on visible layer of dynamic layer // using FeatureServer specifying has_pool field to enable editing. var id = layer.VisibleLayers[0]; var url = layer.ServiceUri.Replace("MapServer", "FeatureServer"); url = string.Format("{0}/{1}", url, id); table = await ServiceFeatureTable.OpenAsync(new Uri(url), null, MyMapView.SpatialReference); table.OutFields = new OutFields(new string[] { "has_pool" }); } // Retrieves feature identified by ID and updates its attributes. var feature = await table.QueryAsync(featureID); feature.Attributes["has_pool"] = selected.Key; await table.UpdateAsync(feature); if (table.HasEdits) { // Pushes attribute edits back to the server. var result = await table.ApplyEditsAsync(); if (result.UpdateResults == null || result.UpdateResults.Count < 1) { return; } var updateResult = result.UpdateResults[0]; if (updateResult.Error != null) { message = updateResult.Error.Message; } // Refreshes layer to reflect attribute edits. layer.Invalidate(); } } catch (Exception ex) { message = ex.Message; } finally { overlay.Graphics.Clear(); SetAttributeEditor(); } if (!string.IsNullOrWhiteSpace(message)) { MessageBox.Show(message); } }
private async void DeleteAttachment(Attachment attachmentToDelete, UITableView tableView) { try { // Delete the attachment. await _selectedFeature.DeleteAttachmentAsync(attachmentToDelete); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); _attachments = await _selectedFeature.GetAttachmentsAsync(); tableView.ReloadData(); _viewController.ShowMessage("Successfully deleted attachment", "Success!"); } catch (Exception exception) { _viewController.ShowMessage(exception.ToString(), "Error deleting attachment"); } }
private async void AddAttachment(UITableView tableView) { // Get the image to upload. Stream imageStream = await GetImageStreamAsync(); if (imageStream == null) { return; } // Convert the image stream into a byte array. byte[] attachmentData = new byte[imageStream.Length]; imageStream.Read(attachmentData, 0, attachmentData.Length); // Determine the file name. string filename = _filename ?? "iOS_image_1.jpg"; // Add the attachment. // The contentType string is the MIME type for JPEG files, image/jpeg. await _selectedFeature.AddAttachmentAsync(filename, "image/jpeg", attachmentData); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); _attachments = await _selectedFeature.GetAttachmentsAsync(); tableView.ReloadData(); _viewController.ShowMessage("Successfully added attachment", "Success!"); }
private async void DeleteButton_Click(object sender, EventArgs e) { // Reconfigure the button. DeleteButton.IsEnabled = false; DeleteButton.Text = "Delete feature"; // Guard against null. if (_tappedFeature == null) { return; } try { // Delete the feature. await _damageLayer.FeatureTable.DeleteFeatureAsync(_tappedFeature); // Sync the change with the service. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_damageLayer.FeatureTable; await serviceTable.ApplyEditsAsync(); // Show a message confirming the deletion. await Application.Current.MainPage.DisplayAlert("Success!", $"Deleted feature with ID {_tappedFeature.Attributes["objectid"]}", "OK"); } catch (Exception ex) { await Application.Current.MainPage.DisplayAlert("Error", ex.ToString(), "OK"); } }
private async void MyMapView_GeoViewTapped(object sender, Esri.ArcGISRuntime.UI.Controls.GeoViewInputEventArgs mapClickPoint) { IdentifyLayerResult idResult = await MyMapView.IdentifyLayerAsync(serviceRequestLayer, mapClickPoint.Position, 5, false); ArcGISFeature serviceRequestFeature = idResult.GeoElements.FirstOrDefault() as ArcGISFeature; if (serviceRequestFeature == null) { return; } // Create a new feature in the comments table ArcGISFeature newComment = relatedTable.CreateFeature() as ArcGISFeature; // Add comment text to the 'comments' attribute newComment.Attributes["comments"] = "Please show up on time!"; // Relate the selected service request to the new comment serviceRequestFeature.RelateFeature(newComment); await relatedTable.AddFeatureAsync(newComment); var results = await relatedTable.ApplyEditsAsync(); }
private async void DeleteButton_Click(object sender, RoutedEventArgs e) { // Dismiss the callout. MyMapView.DismissCallout(); try { // Get the feature to delete from the layer. Button deleteButton = (Button)sender; Feature featureToDelete = (Feature)deleteButton.Tag; // Delete the feature. await _damageLayer.FeatureTable.DeleteFeatureAsync(featureToDelete); // Sync the change with the service. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_damageLayer.FeatureTable; await serviceTable.ApplyEditsAsync(); // Show a message confirming the deletion. MessageBox.Show("Deleted feature with ID " + featureToDelete.Attributes["objectid"], "Success!"); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Couldn't delete feature"); } }
private async void MapView_Tapped(object sender, GeoViewInputEventArgs e) { try { // Create the feature. ArcGISFeature feature = (ArcGISFeature)_damageFeatureTable.CreateFeature(); // Get the normalized geometry for the tapped location and use it as the feature's geometry. MapPoint tappedPoint = (MapPoint)GeometryEngine.NormalizeCentralMeridian(e.Location); feature.Geometry = tappedPoint; // Set feature attributes. feature.SetAttributeValue("typdamage", "Minor"); feature.SetAttributeValue("primcause", "Earthquake"); // Add the feature to the table. await _damageFeatureTable.AddFeatureAsync(feature); // Apply the edits to the service. await _damageFeatureTable.ApplyEditsAsync(); // Update the feature to get the updated objectid - a temporary ID is used before the feature is added. feature.Refresh(); // Confirm feature addition. MessageBox.Show("Created feature " + feature.Attributes["objectid"], "Success!"); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Error adding feature"); } }
private async Task CreateFeature(Image capturedImage, int healthValue) { _helpLabel.Text = "Adding feature..."; try { // Get the geometry of the feature. MapPoint featurePoint = _graphicsOverlay.Graphics.First().Geometry as MapPoint; // Create attributes for the feature using the user selected health value. IEnumerable <KeyValuePair <string, object> > featureAttributes = new Dictionary <string, object>() { { "Health", (short)healthValue }, { "Height", 3.2 }, { "Diameter", 1.2 } }; // Ensure that the feature table is loaded. if (_featureTable.LoadStatus != Esri.ArcGISRuntime.LoadStatus.Loaded) { await _featureTable.LoadAsync(); } // Create the new feature ArcGISFeature newFeature = _featureTable.CreateFeature(featureAttributes, featurePoint) as ArcGISFeature; // Convert the Image from ARCore into a JPEG byte array. byte[] attachmentData = await ConvertImageToJPEG(capturedImage); // Add the attachment. // The contentType string is the MIME type for JPEG files, image/jpeg. await newFeature.AddAttachmentAsync("tree.jpg", "image/jpeg", attachmentData); // Add the newly created feature to the feature table. await _featureTable.AddFeatureAsync(newFeature); // Apply the edits to the service feature table. await _featureTable.ApplyEditsAsync(); // Reset the user interface. _helpLabel.Text = "Tap to create a feature"; _graphicsOverlay.Graphics.Clear(); _addButton.Enabled = false; } catch (Exception ex) { Console.WriteLine(ex.Message); ShowMessage("Could not create feature", "Error"); } }
private async void DeleteFeature(Feature featureToDelete) { try { // Delete the feature. await _damageLayer.FeatureTable.DeleteFeatureAsync(featureToDelete); // Sync the change with the service. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_damageLayer.FeatureTable; await serviceTable.ApplyEditsAsync(); // Show a message confirming the deletion. ShowMessage($"Deleted feature with ID {featureToDelete.Attributes["objectid"]}", "Success!"); } catch (Exception ex) { ShowMessage(ex.ToString(), "Couldn't delete feature"); } }
private async void DamageType_Changed(object sender, SelectionChangedEventArgs e) { // Skip if nothing is selected. if (DamageTypeDropDown.SelectedIndex == -1) { return; } try { // Get the new value. string selectedAttributeValue = DamageTypeDropDown.SelectedValue.ToString(); // Load the feature. await _selectedFeature.LoadAsync(); // Update the attribute value. _selectedFeature.SetAttributeValue(AttributeFieldName, selectedAttributeValue); // Update the table. await _selectedFeature.FeatureTable.UpdateFeatureAsync(_selectedFeature); // Update the service. ServiceFeatureTable table = (ServiceFeatureTable)_selectedFeature.FeatureTable; await table.ApplyEditsAsync(); MessageBox.Show("Edited feature " + _selectedFeature.Attributes["objectid"], "Success!"); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Failed to edit feature"); } finally { // Clear the selection. _damageLayer.ClearSelection(); _selectedFeature = null; // Update the UI. DamageTypeDropDown.IsEnabled = false; DamageTypeDropDown.SelectedIndex = -1; } }
private async void DamageType_Changed(object sender, EventArgs e) { // Skip if nothing is selected. if (DamageTypePicker.SelectedIndex == -1) { return; } try { // Get the new value. string selectedAttributeValue = DamageTypePicker.SelectedItem.ToString(); // Load the feature. await _selectedFeature.LoadAsync(); // Update the attribute value. _selectedFeature.SetAttributeValue(AttributeFieldName, selectedAttributeValue); // Update the table. await _selectedFeature.FeatureTable.UpdateFeatureAsync(_selectedFeature); // Update the service. ServiceFeatureTable table = (ServiceFeatureTable)_selectedFeature.FeatureTable; await table.ApplyEditsAsync(); await Application.Current.MainPage.DisplayAlert("Success!", $"Edited feature {_selectedFeature.Attributes["objectid"]}", "OK"); } catch (Exception ex) { await Application.Current.MainPage.DisplayAlert("Failed to edit feature", ex.ToString(), "OK"); } finally { // Clear the selection. _damageLayer.ClearSelection(); _selectedFeature = null; // Update the UI. DamageTypePicker.IsEnabled = false; DamageTypePicker.SelectedIndex = -1; } }
private async Task CreateFeature(int healthValue) { HelpLabel.Text = "Adding feature..."; try { // Get the geometry of the feature. MapPoint featurePoint = _graphicsOverlay.Graphics.First().Geometry as MapPoint; // Create attributes for the feature using the user selected health value. IEnumerable <KeyValuePair <string, object> > featureAttributes = new Dictionary <string, object>() { { "Health", (short)healthValue }, { "Height", 3.2 }, { "Diameter", 1.2 } }; // Ensure that the feature table is loaded. if (_featureTable.LoadStatus != Esri.ArcGISRuntime.LoadStatus.Loaded) { await _featureTable.LoadAsync(); } // Create the new feature ArcGISFeature newFeature = _featureTable.CreateFeature(featureAttributes, featurePoint) as ArcGISFeature; // Add the newly created feature to the feature table. await _featureTable.AddFeatureAsync(newFeature); // Apply the edits to the service feature table. await _featureTable.ApplyEditsAsync(); // Reset the user interface. HelpLabel.Text = "Tap to create a feature"; _graphicsOverlay.Graphics.Clear(); AddButton.IsEnabled = false; } catch (Exception ex) { Console.WriteLine(ex.Message); await Application.Current.MainPage.DisplayAlert("Error", "Could not create feature", "OK"); } }
private async void DeleteAttachment_Click(object sender, RoutedEventArgs e) { ActivityIndicator.Visibility = Visibility.Visible; try { // Get a reference to the button that raised the event. Button sendingButton = (Button)sender; // Get the attachment from the button's DataContext. The button's DataContext is set by the list box. Attachment selectedAttachment = (Attachment)sendingButton.DataContext; // Delete the attachment. await _selectedFeature.DeleteAttachmentAsync(selectedAttachment); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync(); // Show success message. await new MessageDialog2("Successfully deleted attachment", "Success!").ShowAsync(); } catch (Exception exception) { await new MessageDialog2(exception.ToString(), "Error deleting attachment").ShowAsync(); } finally { ActivityIndicator.Visibility = Visibility.Collapsed; } }
private async void MoveSelectedFeature(Esri.ArcGISRuntime.Xamarin.Forms.GeoViewInputEventArgs tapEventDetails) { try { // Get the MapPoint from the EventArgs for the tap. MapPoint destinationPoint = tapEventDetails.Location; // Normalize the point - needed when the tapped location is over the international date line. destinationPoint = (MapPoint)GeometryEngine.NormalizeCentralMeridian(destinationPoint); // Load the feature. await _selectedFeature.LoadAsync(); // Update the geometry of the selected feature. _selectedFeature.Geometry = destinationPoint; // Apply the edit to the feature table. await _selectedFeature.FeatureTable.UpdateFeatureAsync(_selectedFeature); // Push the update to the service. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; await serviceTable.ApplyEditsAsync(); await Application.Current.MainPage.DisplayAlert("Success!", $"Moved feature {_selectedFeature.Attributes["objectid"]}", "OK"); } catch (Exception ex) { await Application.Current.MainPage.DisplayAlert("Error when moving feature", ex.ToString(), "OK"); } finally { // Reset the selection. _damageLayer.ClearSelection(); _selectedFeature = null; } }
private async void MoveSelectedFeature(GeoViewInputEventArgs tapEventDetails) { try { // Get the MapPoint from the EventArgs for the tap. MapPoint destinationPoint = tapEventDetails.Location; // Normalize the point - needed when the tapped location is over the international date line. destinationPoint = (MapPoint)GeometryEngine.NormalizeCentralMeridian(destinationPoint); // Load the feature. await _selectedFeature.LoadAsync(); // Update the geometry of the selected feature. _selectedFeature.Geometry = destinationPoint; // Apply the edit to the feature table. await _selectedFeature.FeatureTable.UpdateFeatureAsync(_selectedFeature); // Push the update to the service. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; await serviceTable.ApplyEditsAsync(); MessageBox.Show("Moved feature " + _selectedFeature.Attributes["objectid"], "Success!"); } catch (Exception ex) { MessageBox.Show(ex.ToString(), "Error when moving feature."); } finally { // Reset the selection. _damageLayer.ClearSelection(); _selectedFeature = null; } }
private async Task ScrapeArtistInfo(FullArtist artist) { string bioUrl = $"https://open.spotify.com/artist/{artist.Id}/about"; string pageContent = ""; using (HttpClient client = new HttpClient()) { client.DefaultRequestHeaders.Add("User-Agent", "C# console program"); pageContent = await client.GetStringAsync(bioUrl); } var artistResults = _artistScraping.Extract(pageContent); var cities = artistResults["listeners-city"]; var listeners = artistResults["listeners"]; var bio = artistResults["about"]; // if there's no bio, we can't find locations :( if (bio == null) { return; } string fullBio = bio.ToString() + artistResults["more"].ToString(); int shortBioEnd = System.Math.Min(fullBio.Length, 255); string shortBio = fullBio.Substring(0, shortBioEnd); Dictionary <string, int> listenerCities = new Dictionary <string, int>(); for (int i = 0; i < listeners.Count(); i++) { string listenersString = listeners[i].ToString().Replace("LISTENERS", "").Replace(",", "").Trim(); int numListeners = int.Parse(listenersString); listenerCities.Add(cities[i].ToString(), numListeners); } string aboutArtistJson = JsonConvert.SerializeObject(fullBio, Newtonsoft.Json.Formatting.Indented); string classifiedXml = _classifier.classifyWithInlineXML(aboutArtistJson); // HACK: fix "city, state" locations that are split into two: // "<LOCATION>Logan</LOCATION>, <LOCATION>Utah</LOCATION>" => "<LOCATION>Logan, Utah</LOCATION>" classifiedXml = classifiedXml.Replace("</LOCATION>, <LOCATION>", ", "); MatchCollection locationMatches = _locationRx.Matches(classifiedXml); Dictionary <string, Graphic> artistLocations = new Dictionary <string, Graphic>(); //UNCOMMENT //// Build artist locations //for (int i = 0; i < locationMatches.Count; i++) //{ // var m = locationMatches[i]; // string loc = m.Groups[1].Value; // MapPoint geocodedLocation = await GeocodeArtistPlacename(loc); // if (geocodedLocation == null) { continue; } // // If the place name was geocoded, create a new feature to store it // // (first one is considered the hometown) :\ // if (i == 0) // { // Feature newHometownFeature = _hometownTable.CreateFeature(); // newHometownFeature.Geometry = geocodedLocation; // newHometownFeature.Attributes["placename"] = loc; // newHometownFeature.Attributes["artistname"] = artist.Name; // newHometownFeature.Attributes["artistid"] = artist.Id; // newHometownFeature.Attributes["imageurl"] = artist.Images.Last().Url; // newHometownFeature.Attributes["bioshort"] = shortBio; // await _hometownTable.AddFeatureAsync(newHometownFeature); // } // else // { // if (!artistLocations.ContainsKey(loc)) // { // Feature otherFeature = _otherPointsTable.CreateFeature(); // otherFeature.Geometry = geocodedLocation; // otherFeature.Attributes["placename"] = loc; // otherFeature.Attributes["artistname"] = artist.Name; // otherFeature.Attributes["artistid"] = artist.Id; // await _otherPointsTable.AddFeatureAsync(otherFeature); // } // } //} //// Apply edits to the hometown table (will apply other edits after adding listener cities) //await _hometownTable.ApplyEditsAsync(); //**UNCOMMENT // Create points for the listener cities int r = 0; foreach (var lc in listenerCities) { r++; MapPoint geocodedLocation = await GeocodeArtistPlacename(lc.Key); if (geocodedLocation == null) { continue; } Feature otherFeature = _listenerTable.CreateFeature(); otherFeature.Geometry = geocodedLocation; otherFeature.Attributes["placename"] = lc.Key; otherFeature.Attributes["artistname"] = artist.Name; otherFeature.Attributes["artistid"] = artist.Id; otherFeature.Attributes["listenercount"] = lc.Value; otherFeature.Attributes["listenerrank"] = r; await _listenerTable.AddFeatureAsync(otherFeature); } // Apply edits to the other locations table await _listenerTable.ApplyEditsAsync(); ArtistProgressList.Items.Add(artist.Name); }
public static async Task <ArcCrudEnum> AddBin(BinViewModel binViewModel) { IBinstance bin = binViewModel.Binstance; IEnumerable <YTYData> yTY = bin.YTYDatas; try { await _featureTable.LoadAsync(); var attributes = new Dictionary <string, object>(); attributes.Add("identifier", bin.Identifier); attributes.Add("created_by", bin.CreatedBy); attributes.Add("modified_by", bin.ModifiedBy); switch (bin.BinType) { case BinTypeEnum.RoundStorage: attributes.Add("bin_type", "round_storage"); break; case BinTypeEnum.GravityWagon: attributes.Add("bin_type", "gravity_wagon"); break; case BinTypeEnum.PolygonStructure: attributes.Add("bin_type", "polygon_structure"); break; case BinTypeEnum.FlatStructure: attributes.Add("bin_type", "flat_structure"); break; } attributes.Add("year_collected", bin.YearCollected); if (bin.IsLeased.HasValue) { attributes.Add("owned_or_leased", bin.IsLeased.Value ? "leased" : "owned"); } if (bin.HasDryingDevice.HasValue) { attributes.Add("drying_device", bin.HasDryingDevice.Value ? "true" : "false"); } if (bin.HasGrainHeightIndicator.HasValue) { attributes.Add("bin_level_indicator_device", bin.HasGrainHeightIndicator.Value ? "true" : "false"); } switch (bin.LadderType) { case Ladder.None: attributes.Add("ladder_type", "none"); break; case Ladder.Ladder: attributes.Add("ladder_type", "ladder"); break; case Ladder.Stairs: attributes.Add("ladder_type", "stairs"); break; } attributes.Add("notes", bin.Notes); //bin type specific logic below Type t = bin.GetType(); if (bin.BinType == BinTypeEnum.FlatStructure) { if (t.Equals(typeof(FlatBin))) { FlatBin flat = (FlatBin)bin; attributes.Add("crib_height", flat.CribLength); attributes.Add("crib_width", flat.CribWidth); } } else if (bin.BinType == BinTypeEnum.GravityWagon) { if (t.Equals(typeof(GravityBin))) { GravityBin gravityBin = (GravityBin)bin; attributes.Add("chute_length", gravityBin.ChuteLength); attributes.Add("hopper_height", gravityBin.HopperHeight); attributes.Add("rectangle_height", gravityBin.RectangleHeight); attributes.Add("rectangle_length", gravityBin.RectangleLength); attributes.Add("rectangle_width", gravityBin.RectangleWidth); } } else if (bin.BinType == BinTypeEnum.PolygonStructure) { if (t.Equals(typeof(PolygonBin))) { PolygonBin polygonBin = (PolygonBin)bin; attributes.Add("side_height", polygonBin.SideHeight); attributes.Add("side_width", polygonBin.SideWidth); attributes.Add("number_of_sides", polygonBin.NumberOfSides); } } else if (bin.BinType == BinTypeEnum.RoundStorage) { if (t.Equals(typeof(RoundBin))) { RoundBin round = (RoundBin)bin; if (round.HasHopper.HasValue) { attributes.Add("has_hopper", round.HasHopper.Value ? "true" : "false"); } attributes.Add("radius", round.Radius); attributes.Add("wall_height", round.WallHeight); attributes.Add("roof_height", round.RoofHeight); attributes.Add("hopper_height", round.HopperHeight); } } MapPoint mp; double lat = 0; double lon = 0; try { var locator = CrossGeolocator.Current; locator.DesiredAccuracy = 1000; var position = await locator.GetPositionAsync(); if (position == null) { Console.WriteLine("Location Service error"); } lat = position.Latitude; lon = position.Longitude; } catch { } string lonS = lon.ToString(); string[] split = lonS.Split('.'); var charArray = split[1].ToCharArray(); //seperate good location, make third if necassary string first = charArray[0].ToString(); string second = charArray[1].ToString(); string third = charArray[2].ToString(); Random random = new Random(); int addition = random.Next(25, 75); string additionS = addition.ToString(); string newLong = split[0] + '.' + first + second + third + additionS; //latitude string latS = lat.ToString(); string[] splitL = latS.Split('.'); var charArrayL = splitL[1].ToCharArray(); //seperate good location, make third if necassary string firstL = charArrayL[0].ToString(); string secondL = charArrayL[1].ToString(); string thirdL = charArrayL[2].ToString(); int additionL = random.Next(25, 75); string additionSL = additionL.ToString(); string newLat = splitL[0] + '.' + firstL + secondL + thirdL + additionSL; double clusteredLongitude = double.Parse(newLong); double clusteredLatitude = double.Parse(newLat); mp = new MapPoint(clusteredLongitude, clusteredLatitude); binViewModel.ArcGISFeature = (ArcGISFeature)_featureTable.CreateFeature(attributes, mp); await _featureTable.AddFeatureAsync(binViewModel.ArcGISFeature); await binViewModel.ArcGISFeature.LoadAsync(); if (DeviceInfo.DeviceType == DeviceType.Physical) { using (var memoryStream = new MemoryStream()) { bin.Image.GetStream().CopyTo(memoryStream); // add an attachment - pass the name, mime type, and attachment data (bytes, etc.) await binViewModel.ArcGISFeature.AddAttachmentAsync("Photo.jpg", "image/jpg", memoryStream.ToArray()); //agsFeature } } if (yTY == null) { yTY = new List <YTYData>(); } //create json string jsonString = JsonConvert.SerializeObject(yTY); byte[] byteArray = Encoding.UTF8.GetBytes(jsonString); List <Attachment> attachmentsToRemove = new List <Attachment>(); IReadOnlyList <Attachment> attachments = await binViewModel.ArcGISFeature.GetAttachmentsAsync(); foreach (Attachment attachment in attachments) { if (attachment.Name.Equals(YTY_FILE_NAME)) { attachmentsToRemove.Add(attachment); } } await binViewModel.ArcGISFeature.DeleteAttachmentsAsync(attachmentsToRemove); await binViewModel.ArcGISFeature.AddAttachmentAsync(YTY_FILE_NAME, "application/json", byteArray); //agsFeature await _featureTable.UpdateFeatureAsync(binViewModel.ArcGISFeature); //agsFeature // push to ArcGIS Online feature service IReadOnlyList <EditResult> editResults = await _featureTable.ApplyEditsAsync(); // check results for errors foreach (var er in editResults) { if (er.CompletedWithErrors) { return(ArcCrudEnum.Failure); } } return(ArcCrudEnum.Success); } catch (ArcGISWebException) { return(ArcCrudEnum.Exception); } }
/// <summary> /// Enables geometry editing, submits geometry edit back to the server and refreshes dynamic layer. /// </summary> private async void EditButton_Click(object sender, RoutedEventArgs e) { var layer = MyMapView.Map.Layers["RecreationalArea"] as ArcGISDynamicMapServiceLayer; var overlay = MyMapView.GraphicsOverlays["Highlighter"] as GraphicsOverlay; var featureID = (long)EditButton.Tag; string message = null; try { // Hides graphic from overlay and dynamic layer while its geometry is being modified. overlay.Graphics.Clear(); // Negative IDs indicate they do not exist on server yet. if (featureID > 0) { if (layer.LayerDefinitions == null) { layer.LayerDefinitions = new ObservableCollection <LayerDefinition>(); } else { layer.LayerDefinitions.Clear(); } layer.LayerDefinitions.Add(new LayerDefinition() { LayerID = layer.VisibleLayers[0], Definition = string.Format("Objectid <> {0}", featureID) }); } if (table == null) { // Creates table based on visible layer of dynamic layer // using FeatureServer specifying shape field to enable editing. var id = layer.VisibleLayers[0]; var url = layer.ServiceUri.Replace("MapServer", "FeatureServer"); url = string.Format("{0}/{1}", url, id); table = await ServiceFeatureTable.OpenAsync(new Uri(url), null, MyMapView.SpatialReference); } // Retrieves feature identified by ID and updates its geometry // using GeometryEngine to correct ring orientation. var feature = await table.QueryAsync(featureID); var geometry = await MyMapView.Editor.EditGeometryAsync(feature.Geometry); feature.Geometry = GeometryEngine.Simplify(geometry); await table.UpdateAsync(feature); if (table.HasEdits) { // Pushes geometry edits back to the server. var result = await table.ApplyEditsAsync(); if (result.UpdateResults == null || result.UpdateResults.Count < 1) { return; } var updateResult = result.UpdateResults[0]; if (updateResult.Error != null) { message = updateResult.Error.Message; } } } catch (TaskCanceledException te) { // Handles canceling out of Editor. } catch (Exception ex) { message = ex.Message; } finally { SetGeometryEditor(); if (layer.LayerDefinitions != null) { layer.LayerDefinitions.Clear(); // Refreshes layer to reflect geometry edits. layer.Invalidate(); } } if (!string.IsNullOrWhiteSpace(message)) { MessageBox.Show(message); } }
public static async Task <ArcCrudEnum> EditBin(BinViewModel binViewModel) { IBinstance bin = binViewModel.Binstance; ArcGISFeature featureToEdit = binViewModel.ArcGISFeature; try { await featureToEdit.LoadAsync(); featureToEdit.Attributes["identifier"] = bin.Identifier; featureToEdit.Attributes["modified_by"] = binViewModel.EmpoyeeNumber; switch (bin.BinType) { case BinTypeEnum.RoundStorage: featureToEdit.Attributes["bin_type"] = "round_storage"; break; case BinTypeEnum.GravityWagon: featureToEdit.Attributes["bin_type"] = "gravity_wagon"; break; case BinTypeEnum.PolygonStructure: featureToEdit.Attributes["bin_type"] = "polygon_structure"; break; case BinTypeEnum.FlatStructure: featureToEdit.Attributes["bin_type"] = "flat_structure"; break; } featureToEdit.Attributes["year_collected"] = bin.YearCollected; if (bin.IsLeased.HasValue) { featureToEdit.Attributes["owned_or_leased"] = bin.IsLeased.Value ? "leased" : "owned"; } if (bin.HasDryingDevice.HasValue) { featureToEdit.Attributes["drying_device"] = bin.HasDryingDevice.Value ? "true" : "false"; } if (bin.HasGrainHeightIndicator.HasValue) { featureToEdit.Attributes["bin_level_indicator_device"] = bin.HasGrainHeightIndicator.Value ? "true" : "false"; } switch (bin.LadderType) { case Ladder.None: featureToEdit.Attributes["ladder_type"] = "none"; break; case Ladder.Ladder: featureToEdit.Attributes["ladder_type"] = "ladder"; break; case Ladder.Stairs: featureToEdit.Attributes["ladder_type"] = "stairs"; break; } featureToEdit.Attributes["notes"] = bin.Notes; double dr; //double.TryParse(bin.BinVolume, out dr); //featureToEdit.Attributes["bin_volume"] = dr; //bin type specific logic below Type t = bin.GetType(); if (bin.BinType == BinTypeEnum.FlatStructure) { if (t.Equals(typeof(FlatBin))) { FlatBin flat = (FlatBin)bin; featureToEdit.Attributes["crib_height"] = flat.CribLength; featureToEdit.Attributes["crib_width"] = flat.CribWidth; } } else if (bin.BinType == BinTypeEnum.GravityWagon) { if (t.Equals(typeof(GravityBin))) { GravityBin gravityBin = (GravityBin)bin; featureToEdit.Attributes["chute_length"] = gravityBin.ChuteLength; featureToEdit.Attributes["hopper_height"] = gravityBin.HopperHeight; featureToEdit.Attributes["rectangle_height"] = gravityBin.RectangleHeight; featureToEdit.Attributes["rectangle_length"] = gravityBin.RectangleLength; featureToEdit.Attributes["rectangle_width"] = gravityBin.RectangleWidth; } } else if (bin.BinType == BinTypeEnum.PolygonStructure) { if (t.Equals(typeof(PolygonBin))) { PolygonBin polygonBin = (PolygonBin)bin; featureToEdit.Attributes["side_height"] = polygonBin.SideHeight; featureToEdit.Attributes["side_width"] = polygonBin.SideWidth; featureToEdit.Attributes["number_of_sides"] = polygonBin.NumberOfSides; } } else if (bin.BinType == BinTypeEnum.RoundStorage) { if (t.Equals(typeof(PolygonBin))) { RoundBin round = (RoundBin)bin; if (round.HasHopper.HasValue) { featureToEdit.Attributes["has_hopper"] = round.HasHopper.Value ? "true" : "false"; } featureToEdit.Attributes["radius"] = round.Radius; featureToEdit.Attributes["wall_height"] = round.WallHeight; featureToEdit.Attributes["roof_height"] = round.RoofHeight; featureToEdit.Attributes["hopper_height"] = round.HopperHeight; } } // can't be null if (binViewModel.Binstance.YTYDatas == null) { binViewModel.Binstance.YTYDatas = new List <YTYData>(); } //use data in _binViewModel System.Diagnostics.Debug.Print("Feature can edit attachments" + (featureToEdit.CanEditAttachments ? "Yes" : "No")); //-------- Formatting -------- //create json string jsonString = JsonConvert.SerializeObject(binViewModel.Binstance.YTYDatas); //System.Diagnostics.Debug.Print(jsonString); //System.Diagnostics.Debug.Print(((Binstance)(binViewModel.Binstance)).YTYDatasString()); // convert json to byte array byte[] byteArray = Encoding.UTF8.GetBytes(jsonString); //-------- ARC Connection -------- //remove old YTYData List <Attachment> attachmentsToRemove = new List <Attachment>(); IReadOnlyList <Attachment> attachments = await featureToEdit.GetAttachmentsAsync(); foreach (Attachment attachment in attachments) { System.Diagnostics.Debug.Print(attachment.Name); if (attachment.Name.Equals(YTY_FILE_NAME)) { System.Diagnostics.Debug.Print("Found YTY attachment"); attachmentsToRemove.Add(attachment); } } System.Diagnostics.Debug.Print("Attachments to remove:"); foreach (Attachment attachment in attachments) { System.Diagnostics.Debug.Print(attachment.Name); } if (attachmentsToRemove.Any()) { //update the json file await featureToEdit.UpdateAttachmentAsync(attachmentsToRemove.First(), YTY_FILE_NAME, "application/json", byteArray); } _featureTable = (ServiceFeatureTable)featureToEdit.FeatureTable; // update feature after attachment added await _featureTable.UpdateFeatureAsync(featureToEdit); //agsFeature System.Diagnostics.Debug.Print("Feature table updated"); // push to ArcGIS Online feature service IReadOnlyList <EditResult> editResults = await _featureTable.ApplyEditsAsync(); System.Diagnostics.Debug.Print("Arc updated"); foreach (var er in editResults) { if (er.CompletedWithErrors) { // handle error (er.Error.Message) return(ArcCrudEnum.Failure); } } return(ArcCrudEnum.Success); } catch (ArcGISWebException) { return(ArcCrudEnum.Exception); } }
private async void AddAttachment_Click(object sender, RoutedEventArgs e) { if (_selectedFeature == null) { return; } // Adjust the UI. AddAttachmentButton.IsEnabled = false; ActivityIndicator.Visibility = Visibility.Visible; try { // Show a file dialog. // Allow the user to specify a file path - create the dialog. OpenFileDialog dlg = new OpenFileDialog { DefaultExt = ".jpg", Filter = "Image Files(*.JPG;*.JPEG)|*.JPG;*.JPEG", InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyPictures) }; // Show the dialog and get the results. bool?result = dlg.ShowDialog(); // Take action if the user selected a file. if (result != true) { return; } // Get the name of the file from the full path (dlg.FileName is the full path). string filename = Path.GetFileName(dlg.FileName); // Create a stream for reading the file. FileStream fs = new FileStream(dlg.FileName, FileMode.Open, FileAccess.Read); // Create a binary reader from the stream. BinaryReader br = new BinaryReader(fs); // Populate the attachment data with the binary content. long numBytes = new FileInfo(dlg.FileName).Length; byte[] attachmentData = br.ReadBytes((int)numBytes); // Close the stream. fs.Close(); // Add the attachment. // The contentType string is the MIME type for JPEG files, image/jpeg. await _selectedFeature.AddAttachmentAsync(filename, "image/jpeg", attachmentData); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync(); MessageBox.Show("Successfully added attachment", "Success!"); } catch (Exception exception) { MessageBox.Show(exception.ToString(), "Error adding attachment"); } finally { // Adjust the UI. AddAttachmentButton.IsEnabled = true; ActivityIndicator.Visibility = Visibility.Collapsed; } }
private async void AddAttachment_Click(object sender, EventArgs e) { if (_selectedFeature == null) { return; } // Adjust the UI. AddAttachmentButton.IsEnabled = false; AttachmentActivityIndicator.IsVisible = true; // Get the file. string contentType = "image/jpeg"; try { byte[] attachmentData; string filename; // Xamarin.Plugin.FilePicker shows the iCloud picker (not photo picker) on iOS. // This iOS code shows the photo picker. #if __IOS__ Stream imageStream = await GetImageStreamAsync(); if (imageStream == null) { return; } attachmentData = new byte[imageStream.Length]; imageStream.Read(attachmentData, 0, attachmentData.Length); filename = _filename ?? "file1.jpeg"; #else // Show a file picker - this uses the Xamarin.Plugin.FilePicker NuGet package. FileData fileData = await CrossFilePicker.Current.PickFile(new[] { ".jpg", ".jpeg" }); if (fileData == null) { return; } if (!fileData.FileName.EndsWith(".jpg") && !fileData.FileName.EndsWith(".jpeg")) { await Application.Current.MainPage.DisplayAlert("Try again!", "This sample only allows uploading jpg files.", "OK"); return; } attachmentData = fileData.DataArray; filename = fileData.FileName; #endif // Add the attachment. // The contentType string is the MIME type for JPEG files, image/jpeg. await _selectedFeature.AddAttachmentAsync(filename, contentType, attachmentData); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync(); await Application.Current.MainPage.DisplayAlert("Success!", "Successfully added attachment", "OK"); } catch (Exception exception) { await Application.Current.MainPage.DisplayAlert("Error adding attachment", exception.ToString(), "OK"); } finally { // Adjust the UI. AddAttachmentButton.IsEnabled = true; AttachmentActivityIndicator.IsVisible = false; } }
private async void AddAttachment_Click(object sender, RoutedEventArgs e) { if (_selectedFeature == null) { return; } // Adjust the UI. AddAttachmentButton.IsEnabled = false; ActivityIndicator.Visibility = Visibility.Visible; // Get the file. string contentType = "image/jpeg"; byte[] attachmentData; try { // Show a file picker. // Allow the user to specify a file path - create the picker. FileOpenPicker openPicker = new FileOpenPicker(); openPicker.FileTypeFilter.Add(".jpg"); // Show the picker. StorageFile file = await openPicker.PickSingleFileAsync(); // Take action if the user selected a file. if (file == null) { return; } // Read the file contents into memory. Stream dataStream = await file.OpenStreamForReadAsync(); attachmentData = new byte[dataStream.Length]; dataStream.Read(attachmentData, 0, attachmentData.Length); dataStream.Close(); // Add the attachment. // The contentType string is the MIME type for JPEG files, image/jpeg. await _selectedFeature.AddAttachmentAsync(file.Name, contentType, attachmentData); // Get a reference to the feature's service feature table. ServiceFeatureTable serviceTable = (ServiceFeatureTable)_selectedFeature.FeatureTable; // Apply the edits to the service feature table. await serviceTable.ApplyEditsAsync(); // Update UI. _selectedFeature.Refresh(); AttachmentsListBox.ItemsSource = await _selectedFeature.GetAttachmentsAsync(); await new MessageDialog2("Successfully added attachment", "Success!").ShowAsync(); } catch (Exception exception) { await new MessageDialog2(exception.ToString(), "Error adding attachment").ShowAsync(); } finally { // Adjust the UI. AddAttachmentButton.IsEnabled = true; ActivityIndicator.Visibility = Visibility.Collapsed; } }