def download_features(fs_url, date, out_path):
    
    #creates a empty GDB
    arcpy.workspace = cwd 
    out_folder_path = cwd + '/Shapefiles'
    out_name = "test.gdb"
    arcpy.CreateFileGDB_management(out_folder_path, out_name)
    print ("Creating a empty GDB....")
    
    '''downloads a hosted service features into a feature class'''
    agol_securityHandler = AGOLTokenSecurityHandler('Username','Password','http://company.maps.arcgis.com/')
    agol_org_obj = Administration(securityHandler=agol_securityHandler,initialize=True)

    fs = FeatureService(url=fs_url,securityHandler=agol_securityHandler,initialize=True)

    ldf = LayerDefinitionFilter()

    #CHANGE CONDITION AFTER THE "and" TO QUERY SOMETHING ELSE OTHER THAN DATE
    #e.g. "ref='EBN_BDP_006_TAP'"
    #Date format mm/dd/yyyy
    ldf.addFilter(0, where="1=1" and "date> date\'" + date + "\'")
    print ("Querying data....")
    print (fs.query(layerDefsFilter=ldf,returnCountOnly=True))

    queryResults = fs.query(layerDefsFilter=ldf,returnCountOnly=False,returnGeometry=True)
    result = queryResults[0].save(r'in_memory','SampleCities')
    print ("Saved results....")
    arcpy.CopyFeatures_management(result,out_path)
    print ("Features exported")
    print ("All done!")
Пример #2
0
    def GetLayerFromFeatureServiceByURL(self,
                                        url,
                                        layerName="",
                                        returnURLOnly=False):
        fs = None
        try:
            fs = FeatureService(url=url, securityHandler=self._securityHandler)

            return self.GetLayerFromFeatureService(fs=fs,
                                                   layerName=layerName,
                                                   returnURLOnly=returnURLOnly)
        except arcpy.ExecuteError:
            line, filename, synerror = trace()
            raise ArcRestHelperError({
                "function": "GetLayerFromFeatureServiceByURL",
                "line": line,
                "filename": filename,
                "synerror": synerror,
                "arcpyError": arcpy.GetMessages(2),
            })
        except:
            line, filename, synerror = trace()
            raise ArcRestHelperError({
                "function": "GetLayerFromFeatureServiceByURL",
                "line": line,
                "filename": filename,
                "synerror": synerror,
            })
        finally:
            fs = None

            del fs

            gc.collect()
Пример #3
0
    def GetFeatureService(self, itemId, returnURLOnly=False):
        admin = None
        item = None
        try:
            admin = arcrest.manageorg.Administration(
                securityHandler=self._securityHandler)
            if self._securityHandler.valid == False:
                self._valid = self._securityHandler.valid
                self._message = self._securityHandler.message
                return None

            item = admin.content.item(itemId=itemId)
            if item.itemType == "Feature Service":
                if returnURLOnly:
                    return item.url
                else:
                    return FeatureService(
                        url=item.url, securityHandler=self._securityHandler)
            return None

        except:
            line, filename, synerror = trace()
            raise common.ArcRestHelperError({
                "function": "GetFeatureService",
                "line": line,
                "filename": filename,
                "synerror": synerror,
            })
        finally:
            admin = None
            item = None
            del item
            del admin

            gc.collect()
Пример #4
0
from arcrest.security import AGOLTokenSecurityHandler
from arcrest.agol import FeatureService
from arcrest.common.filters import LayerDefinitionFilter

if __name__ == "__main__":
    username = "******"
    password = "******"
    url = "<Feature Service URL on AGOL>"
    proxy_port = None
    proxy_url = None
    agolSH = AGOLTokenSecurityHandler(username=username,
                                      password=password)
    fs = FeatureService(
        url=url,
        securityHandler=agolSH,
        proxy_port=proxy_port,
        proxy_url=proxy_url,
        initialize=True)
    ldf = LayerDefinitionFilter()
    ldf.addFilter(0, where="1=1")
    print fs.query(layerDefsFilter=ldf,
                   returnCountOnly=True)
    # should see something like : {'layers': [{'count': 4, 'id': 0}]}
Пример #5
0
from arcrest.security import AGOLTokenSecurityHandler
from arcrest.agol import FeatureService
from arcrest.common.filters import LayerDefinitionFilter

if __name__ == "__main__":
    username = "******"
    password = "******"
    url = "<Feature Service URL on AGOL>"
    proxy_port = None
    proxy_url = None
    agolSH = AGOLTokenSecurityHandler(username=username, password=password)
    fs = FeatureService(url=url, securityHandler=agolSH, proxy_port=proxy_port, proxy_url=proxy_url, initialize=True)
    ldf = LayerDefinitionFilter()
    ldf.addFilter(0, where="1=1")
    print fs.query(layerDefsFilter=ldf, returnCountOnly=True)
    # should see something like : {'layers': [{'count': 4, 'id': 0}]}
Пример #6
0
    def QueryAllFeatures(self,
                         url=None,
                         where="1=1",
                         out_fields="*",
                         timeFilter=None,
                         geometryFilter=None,
                         returnFeatureClass=False,
                         out_fc=None,
                         outSR=None,
                         chunksize=1000,
                         printIndent="",
                         useAGSFeatureService=False):
        """Performs an SQL query against a hosted feature service layer
        and returns all features regardless of service limit.

        Args:
            url (str): The URL of the feature service layer.
            where - the selection sql statement
            out_fields - the attribute fields to return
            timeFilter - a TimeFilter object where either the start time
                         or start and end time are defined to limit the
                         search results for a given time.  The values in
                         the timeFilter should be as UTC timestampes in
                         milliseconds.  No checking occurs to see if they
                         are in the right format.
            geometryFilter - a GeometryFilter object to parse down a given
                            query by another spatial dataset.
            returnFeatureClass - Default False. If true, query will be
                                 returned as feature class
            chunksize (int): The maximum amount of features to query at a time. Defaults to 1000.
            out_fc - only valid if returnFeatureClass is set to True.
                        Output location of query.
            useAGSFeatureService (boolean) - Whether to use an AGOL FeatureLayer 
                                                (default or AGS-hosted FeatureService.

            Output:
               A list of Feature Objects (default) or a path to the output featureclass if
               returnFeatureClass is set to True.

        """
        if (url is None):
            return
        fl = None
        try:
            if useAGSFeatureService:
                fl = FeatureService(url=url,
                                    securityHandler=self._securityHandler)
                qRes = fl.query(where=where,
                                returnIdsOnly=True,
                                timeFilter=timeFilter,
                                geometryFilter=geometryFilter)
            else:
                fl = FeatureLayer(url=url,
                                  securityHandler=self._securityHandler)
                qRes = fl.query(where=where,
                                returnIDsOnly=True,
                                timeFilter=timeFilter,
                                geometryFilter=geometryFilter)

            if 'error' in qRes:
                if isinstance(qRes, dict):
                    qRes = str(qRes)
                print(printIndent + qRes)
                return []
            elif 'objectIds' in qRes:
                oids = qRes['objectIds']
                total = len(oids)
                if total == 0:
                    return fl.query(where=where,
                                    returnGeometry=True,
                                    out_fields=out_fields,
                                    timeFilter=timeFilter,
                                    geometryFilter=geometryFilter,
                                    outSR=outSR)

                print(printIndent + "%s features to be downloaded" % total)
                chunksize = min(chunksize, fl.maxRecordCount)
                combinedResults = None
                totalQueried = 0
                for chunk in chunklist(l=oids, n=chunksize):
                    oidsQuery = ",".join(map(str, chunk))
                    if not oidsQuery:
                        continue
                    else:
                        results = fl.query(objectIds=oidsQuery,
                                           returnGeometry=True,
                                           out_fields=out_fields,
                                           timeFilter=timeFilter,
                                           geometryFilter=geometryFilter,
                                           outSR=outSR)
                        if isinstance(results, FeatureSet):
                            if combinedResults is None:
                                combinedResults = results
                            else:
                                for feature in results.features:
                                    combinedResults.features.append(feature)

                            totalQueried += len(results.features)
                            print(printIndent +
                                  "{:.0%} Completed: {}/{}".format(
                                      totalQueried /
                                      float(total), totalQueried, total))

                        else:
                            print(printIndent + results)
                if returnFeatureClass == True:
                    return combinedResults.save(*os.path.split(out_fc))
                else:
                    return combinedResults
            else:
                print(printIndent + qRes)
        except:
            line, filename, synerror = trace()
            raise common.ArcRestHelperError({
                "function": "QueryAllFeatures",
                "line": line,
                "filename": filename,
                "synerror": synerror,
            })
        finally:
            fl = None
            del fl
            gc.collect()
Пример #7
0
  This sample shows how to create a replica from a FS

"""
from arcrest.security import AGOLTokenSecurityHandler
from arcrest.agol import FeatureService
from arcrest.common.filters import LayerDefinitionFilter

if __name__ == "__main__":
    username = "******"
    password = "******"
    url = "<Feature Service URL on AGOL>"
    proxy_port = None
    proxy_url = None
    agolSH = AGOLTokenSecurityHandler(username=username,
                                      password=password)
    fs = FeatureService(
        url=url,
        securityHandler=agolSH,
        proxy_port=proxy_port,
        proxy_url=proxy_url,
        initialize=True)
    result = fs.createReplica(replicaName='Demo', layers='0,1,2,3,4', keep_replica=False, 
                              layerQueries=None, 
                              geometryFilter=None, 
                              returnAttachments=True, 
                              returnAttachmentDatabyURL=False, 
                              returnAsFeatureClass=True, 
                              out_path='C:\\temp')

    print result
    # should see something like : {'layers': [{'count': 4, 'id': 0}]}
Пример #8
0
			#check for and/or make a folder with the date
			archive_path = os.path.join(backup_path,timestamp())
			if not os.path.exists(archive_path):
				os.makedirs(archive_path)

			proxy_port = None
			proxy_url = None
			url = backups[k]["url"]

			msg2 = "Accessing service @ {0}".format(url)
			logging.info(msg2)
			print(msg2)
			fs = FeatureService(
				url=url,
				securityHandler=agolSH,
				proxy_port=proxy_port,
				proxy_url=proxy_url,
				initialize=True)

			print("Copying service to {0}".format(out_path))
			result = fs.createReplica(
				replicaName=backups[k],
				layers=backups[k]["layers"],
				keep_replica=False,
				layerQueries=None,
				geometryFilter=None,
				returnAttachments=True,
				returnAttachmentDatabyURL=False,
				returnAsFeatureClass=True,
				out_path=archive_path)
			
Пример #9
0
  This sample shows how to create a replica from a FS

"""
from arcrest.security import AGOLTokenSecurityHandler
from arcrest.agol import FeatureService
from arcrest.common.filters import LayerDefinitionFilter

if __name__ == "__main__":
    username = "******"
    password = "******"
    url = "<Feature Service URL on AGOL>"
    proxy_port = None
    proxy_url = None
    agolSH = AGOLTokenSecurityHandler(username=username, password=password)
    fs = FeatureService(url=url,
                        securityHandler=agolSH,
                        proxy_port=proxy_port,
                        proxy_url=proxy_url,
                        initialize=True)
    result = fs.createReplica(replicaName='Demo',
                              layers='0,1,2,3,4',
                              keep_replica=False,
                              layerQueries=None,
                              geometryFilter=None,
                              returnAttachments=True,
                              returnAttachmentDatabyURL=False,
                              returnAsFeatureClass=True,
                              out_path='C:\\temp')

    print result
    # should see something like : {'layers': [{'count': 4, 'id': 0}]}
Пример #10
0
from arcrest.common.filters import LayerDefinitionFilter
import os, zipfile

if __name__ == "__main__":
    username = "******"
    password = "******"
    url = "http://services1.arcgis.com/***/rest/services/yourservice/FeatureServer"
    proxy_port = None
    proxy_url = None
    agolSH = AGOLTokenSecurityHandler(username=username, password=password)
    repName = 'MyHostedFeatureLayerName'  #Name of replica and unzipped file gdb
    filelocation = 'C:\\Temp'

    fs = FeatureService(url=url,
                        securityHandler=agolSH,
                        proxy_port=proxy_port,
                        proxy_url=proxy_url,
                        initialize=True)

    result = fs.createReplica(replicaName=repName,
                              layers=[0, 1, 2, 3, 4, 5, 6, 7, 8],
                              async=True,
                              returnAttachments=True,
                              returnAttachmentsDatabyURL=True,
                              attachmentsSyncDirection='bidirectional',
                              wait=True,
                              dataFormat="filegdb",
                              out_path=filelocation)

    dzipfile = '{0}'.format(result)
    parentdirectory = os.path.dirname(os.path.abspath(dzipfile))
Пример #11
0
"""
  This sample shows how to create a replica from a FS

  ArcREST version 3.5.x
  Python 2/3

"""
from __future__ import print_function
from arcrest.security import AGOLTokenSecurityHandler
from arcrest.agol import FeatureService
from arcrest.common.filters import LayerDefinitionFilter

if __name__ == "__main__":
    username = "******"
    password = "******"
    url = "<Feature Service URL on AGOL>"
    proxy_port = None
    proxy_url = None
    agolSH = AGOLTokenSecurityHandler(username=username, password=password)
    fs = FeatureService(url=url,
                        securityHandler=agolSH,
                        proxy_port=proxy_port,
                        proxy_url=proxy_url,
                        initialize=True)
    result = fs.createReplica(replicaName='Demo',
                              layers=[0, 1, 2, 3],
                              dataFormat="filegdb",
                              out_path='C:\\temp')

    print(result)