Extend and integrate ArcGIS Survey123 Field App

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from arcgis.gis import GIS
from arcgis.features import FeatureLayer

try:
    # Connect to ArcGIS Online
    gis = GIS("https://www.arcgis.com", username="your_username", password="your_password")

    # Access survey data through feature layer
    survey_layer = FeatureLayer("https://services.arcgis.com/.../FeatureServer/0", gis=gis)
    responses = survey_layer.query()

    # Process and analyze data
    if responses.features:
        for feature in responses.features:
            # Custom data processing logic
            attributes = feature.attributes
            geometry = feature.geometry
            print(f"Processing survey ID: {attributes.get('objectid')}")
            # Add your custom processing here
    else:
        print("No survey responses found")

except Exception as e:
    print(f"Error accessing survey data: {str(e)}")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// Poll for new survey submissions
function checkForNewSubmissions(featureLayerUrl, token, lastCheckTime) {
  const queryUrl = `${featureLayerUrl}/query`;
  const params = new URLSearchParams({
    where: `CreationDate > timestamp '${lastCheckTime}'`,
    outFields: '*',
    returnGeometry: true,
    f: 'json',
    token: token
  });

  fetch(`${queryUrl}?${params}`)
    .then(response => response.json())
    .then(data => {
      if (data.features && data.features.length > 0) {
        // Process new survey submissions
        data.features.forEach(feature => {
          processNewSubmission(feature.attributes);
        });
      }
    })
    .catch(error => {
      console.error('Error checking for submissions:', error);
    });
}

// Poll every 30 seconds
setInterval(() => {
  checkForNewSubmissions(
    "https://services.arcgis.com/.../FeatureServer/0",
    "YOUR_TOKEN",
    new Date(Date.now() - 30000).toISOString()
  );
}, 30000);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Launch Survey123 Field App from web application
function launchSurveyApp(surveyId, prefillData) {
  // Use app link format for better cross-platform compatibility
  const baseUrl = "https://survey123.arcgis.app";
  const params = new URLSearchParams({
      itemID: surveyId,
      callback: window.location.href
  });

  // Add prefill data
  if (prefillData) {
      for (const key in prefillData) {
          params.append(key, prefillData[key]);
      }
  }

  const surveyUrl = baseUrl + "?" + params.toString();

  // Open the survey
  window.location.href = surveyUrl;

  // Optional: Detect if app is not installed (mobile only)
  setTimeout(() => {
      if (document.hidden) {
          // App opened successfully
          console.log("Survey app launched");
      } else {
          // On mobile, redirect to app store if app not installed
          const userAgent = navigator.userAgent || navigator.vendor || window.opera;
          if (/android/i.test(userAgent)) {
              window.location.href = "https://play.google.com/store/apps/details?id=com.esri.survey123";
          } else if (/iPad|iPhone|iPod/.test(userAgent) && !window.MSStream) {
              window.location.href = "https://apps.apple.com/app/arcgis-survey123/id993015031";
          }
      }
  }, 1500);
}

// Example usage
launchSurveyApp("abc123def456ghi789", {
  "inspector_name": "John Doe",
  "date": new Date().toISOString()
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Configure webhook using ArcGIS REST API
const featureLayerUrl = "https://services.arcgis.com/your_org/arcgis/rest/services/your_survey/FeatureServer/0";
const webhookPayload = {
  name: "Survey123 Submission Webhook",
  hookUrl: "https://your-system.com/webhook/survey123",
  changeTypes: "INSERT,UPDATE,DELETE",
  signatureKey: "your-signature-key",
  active: true,
  f: "json",
  token: "YOUR_ACCESS_TOKEN"
};

// POST to create webhook
fetch(`${featureLayerUrl}/createWebhook`, {
  method: "POST",
  headers: {
    "Content-Type": "application/x-www-form-urlencoded"
  },
  body: new URLSearchParams(webhookPayload)
})
.then(response => response.json())
.then(result => {
  console.log("Webhook created:", result);
})
.catch(error => {
  console.error("Error creating webhook:", error);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Process incoming webhook from Survey123
app.post('/webhook/survey123', function(req, res) {
  var eventType = req.body.eventType;
  var surveyInfo = req.body.surveyInfo;
  var feature = req.body.feature;
  var userInfo = req.body.userInfo;

  if (eventType === 'addData') {
    // Process new survey submission from Field App
    processNewSubmission(feature.attributes);

    // Example: Create workflow task
    createWorkflowTask(feature.attributes);

    // Example: Send notification
    sendNotification(surveyInfo.name, userInfo.username);
  }

  res.status(200).send('OK');
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# Export survey data from Field App
import requests
import pandas as pd
import json

def exportSurveyData(featureLayerUrl, token, outputFormat='json'):
    """
    Export survey data from ArcGIS Survey123 Field App

    Args:
        featureLayerUrl: URL of the feature layer containing survey data
        token: Authentication token
        outputFormat: Export format ('json', 'csv', 'geojson')

    Returns:
        Exported data or None if error occurs
    """
    try:
        # Query survey data
        url = f"{featureLayerUrl}/query"
        params = {
            'where': '1=1',
            'outFields': '*',
            'returnGeometry': True,
            'f': 'json',
            'token': token
        }

        response = requests.get(url, params=params)
        response.raise_for_status()
        data = response.json()

        if 'error' in data:
            print(f"Error querying data: {data['error']}")
            return None

        # Process based on output format
        if outputFormat == 'csv':
            # Convert to CSV using pandas
            features = data.get('features', [])
            if features:
                df = pd.DataFrame([f['attributes'] for f in features])
                df.to_csv('survey_export.csv', index=False)
                print(f"Exported {len(features)} records to survey_export.csv")
                return df

        elif outputFormat == 'geojson':
            # Convert to GeoJSON
            geojson = {
                'type': 'FeatureCollection',
                'features': []
            }
            for feature in data.get('features', []):
                geojson['features'].append({
                    'type': 'Feature',
                    'properties': feature['attributes'],
                    'geometry': feature.get('geometry')
                })

            with open('survey_export.geojson', 'w') as f:
                json.dump(geojson, f)
            print(f"Exported {len(geojson['features'])} records to survey_export.geojson")
            return geojson

        else:  # JSON format
            with open('survey_export.json', 'w') as f:
                json.dump(data, f, indent=2)
            print(f"Exported {len(data.get('features', []))} records to survey_export.json")
            return data

    except requests.exceptions.RequestException as e:
        print(f"Network error: {str(e)}")
        return None
    except Exception as e:
        print(f"Error exporting survey data: {str(e)}")
        return None

# Example usage
if __name__ == "__main__":
    feature_layer_url = "https://services.arcgis.com/your_org/arcgis/rest/services/your_survey/FeatureServer/0"
    access_token = "YOUR_ACCESS_TOKEN"

    # Export as CSV
    exportSurveyData(feature_layer_url, access_token, 'csv')

    # Export as GeoJSON
    exportSurveyData(feature_layer_url, access_token, 'geojson')