initial check in

Author: waltertschwe

.gitignore

@@ -0,0 +1,2 @@
+*.env
+private/

LICENSE

@@ -0,0 +1,5 @@
+init:
+    pip install -r requirements.txt
+
+test:
+    py.test tests

Makefile

@@ -0,0 +1,32 @@
+Salesforce Micro Service
+========================
+
+This project provides the middleware layer between Salesforce and custom built applications
+
+Authentication
+==============
+
+This package currently supports Username and Password and JWT Bearer Token Flow::
+
+Update the .env with client credenitals for the grant type being used
+
+Required values for Username and Password grant type:
+
+::
+
+        SALESFORCE_OAUTH_CONSUMER_TOKEN
+        SALESFORCE_OAUTH_CONSUMER_SECRET
+        SALESFORCE_USER
+        SALESFORCE_PASSWORD
+        SALESFORCE_ACCESS_TOKEN_URL
+
+Required values for JWT grant type:
+
+::
+
+        SALESFORCE_OAUTH_CONSUMER_TOKEN
+        SALESFORCE_CERTIFICATE
+        SALESFORCE_USER
+        SALESFORCE_PRIVATE_KEY
+        
+

README.rst

@@ -0,0 +1,5 @@
+def main():
+    pass
+
+if __name__ == "__main__":
+    main()

__init__.py

@@ -0,0 +1,9 @@
+PyMySQL
+python-env
+dotenv==0.0.5
+simple-salesforce==0.69
+salesforce-oauth-request
+PyJWT
+cryptography
+pem
+pymongo

__main__.py

@@ -0,0 +1,2 @@
+## initialize the salesforce package
+from salesforce import *

requirements.txt

@@ -0,0 +1,128 @@
+import os 
+import time
+import jwt
+import pem
+import requests
+import json
+import base64
+from calendar import timegm
+from datetime import datetime, timedelta
+from simple_salesforce import Salesforce
+from os.path import join, dirname
+from dotenv import Dotenv
+
+""" SalesForce Authentication """
+class SalesForceOAuth:
+    
+    """ Sets up environment values for all grant types """
+    def __init__(self):
+        dotenv_path = Dotenv(join(dirname(__file__), '..', '.env'))
+        os.environ.update(dotenv_path)
+
+        self.consumer_key = os.environ.get("SALESFORCE_OAUTH_CONSUMER_TOKEN")
+        self.consumer_secret = os.environ.get("SALESFORCE_OAUTH_CONSUMER_SECRET")
+        self.api_domain = os.environ.get("SALESFORCE_API_DOMAIN")
+        self.access_token_url = os.environ.get("SALESFORCE_ACCESS_TOKEN_URL") 
+        self.username = os.environ.get("SALESFORCE_USER")
+        self.password = os.environ.get("SALESFORCE_PASSWORD") 
+
+    """ Determines OAuth Grant Type and runs method 
+        returns a dictionary consisinting of an instance_url and access_token
+    """
+    def getAccessToken(self, grant_type):
+        self.grant_type = grant_type
+        if grant_type == 'password':
+            token = self.passwordGrantType()
+        elif grant_type == 'jwt':
+            token = self.jwtGrantType()
+        elif grant_type == 'web-server':
+            self.webGrantType()
+        else:
+            pass
+        
+        return token
+
+    """ Password Grant Type for user/server credentials
+        need a client_id and client_secret
+        returns a dictionary consisting of an instance_url and access_token 
+        used to make API calls
+    """
+    def passwordGrantType(self):
+        token = dict()
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        }
+
+        post_data = {'grant_type': self.grant_type,
+                     'client_id': self.consumer_key,
+                     'client_secret': self.consumer_secret,
+                     'username': self.username,
+                     'password': self.password }
+
+        result = requests.post(self.access_token_url, data=post_data, headers=headers)
+        data = json.loads(result.text)
+        access_token = data['access_token']
+        instance_url = data['instance_url']
+        token = { 'instance_url' : instance_url, 'access_token' : access_token } 
+        return token 
+
+    """ JWT Token Grant Type - key based authentication 
+        returns a dictionary consisting of an instance_url and access_token 
+        used to make API calls
+    """
+    def jwtGrantType(self):
+        token = dict()
+        certs = pem.parse_file(os.environ.get("SALESFORCE_CERTIFICATE"))
+        certfile = os.environ.get("SALESFORCE_PRIVATE_KEY")
+
+        with open(certfile, "r") as my_cert_file:
+            cert = my_cert_file.read()
+
+        payload =  {
+                   'alg': 'RS256',
+                   'iss': self.consumer_key, 
+                   'sub': self.username, 
+                   'aud': 'https://login.salesforce.com', 
+                   'exp': timegm(datetime.utcnow().utctimetuple()) 
+                  } 
+        pay_string = (str(payload))
+
+        encoded = jwt.encode(payload, cert, algorithm='RS256')
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        }
+        grant_type = 'urn:ietf:params:oauth:grant-type:jwt-bearer'
+        post_data = { 'grant_type': grant_type, 
+                 'assertion': encoded
+               }
+
+        result = requests.post(self.access_token_url, data=post_data, headers=headers)
+        data = json.loads(result.text)
+        access_token = data['access_token']
+        instance_url = data['instance_url']
+        token = { 'instance_url' : instance_url, 'access_token' : access_token }
+        return token
+
+
+    def webGrantType(self):
+        pass
+
+    def decodeToken(self):  
+        pass
+        ##TODO:
+        #public_key="private/public.key"
+        #with open(pub_file, "r") as public_key:
+        #    pub = pub_file.read()
+        #decoded = jwt.decode(encoded, pub, audience="https://login.salesforce.com")
+        #print(decoded)
+
+sf = SalesForceOAuth()
+##jwt_token = sf.getAccessToken('jwt')
+##print(jwt_token)
+password_token = sf.getAccessToken('password')
+print(password_token)
+
+
+
+
+

salesforce/.query.py.swo

@@ -0,0 +1,15 @@
+import unittest
+from connect import SalesForceOAuth
+
+class TestSalesForceOAuth(unittest.TestCase):
+    def __init__(self, grant_type):
+        self.sf = SalesForceOAuth('password')
+
+    def test_salesforce_values(self):
+        pass
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()

salesforce/.query.py.swp

@@ -0,0 +1,8 @@
+import os
+import json
+import pymongo
+
+class MongoConnector:
+
+    def __init__():
+        pass

salesforce/__init__.py

@@ -0,0 +1,15 @@
+import unittest
+from connect import SalesForceOAuth
+
+class TestSalesForceOAuth(unittest.TestCase):
+    def __init__(self, grant_type):
+        self.sf = SalesForceOAuth('password')
+
+    def test_salesforce_values(self):
+        pass
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()

salesforce/connect.py

@@ -0,0 +1,60 @@
+import os
+import json
+from connect import SalesForceOAuth
+from simple_salesforce import Salesforce
+
+class SalesForceQuery:
+    def __init__(self, token):
+        self.instance_url = token['instance_url']
+        self.access_token = token['access_token']
+        self.sf = Salesforce(instance_url=self.instance_url, session_id=self.access_token)
+
+    def getDataById(self, dataType, salesforce_id):
+        data = self.sf.Contact.get(salesforce_id)
+        ##data = sf.(dataType).get(salesforce_id)
+        ##print(data)
+
+    def getDataByCustomField(self, dataType, custom_field):
+        contact = self.sf.Contact.get_by_custom_id('My_Custom_ID__c', '22')
+        pass
+
+    def getDataByQuery(self, query):
+        data = self.sf.query(query)
+        return data
+
+    def getDataByDateRange(self, dataType, date_range):
+        pass
+
+    def getObjectMetaData(self, obj):
+        metadata = self.sf.Contact.metadata()
+        ##print(metadata)
+
+    def describeObject(self, salesforce_obj): 
+        data = self.sf.Account.describe()
+        return data
+
+    def sfObjectToJson(self, data):
+        json_data = json.dumps(data)
+        return json_data
+
+    def getObjectType(self, salesforce_obj_type):
+        return {
+            'Contact' : 'self.sf.Contact',
+            'Account' : 'self.sf.Account'
+        }[salesforce_obj_type]
+
+
+sf = SalesForceOAuth()
+token = sf.getAccessToken('password')
+salesforce_id = '0031a00000VG4mK'
+dataType = 'Contact'
+sfq = SalesForceQuery(token)
+sfq.getDataById(dataType, salesforce_id)
+##data = sfq.getDataByQuery("SELECT Id, Email FROM Contact WHERE LastName = 'Schweitzer'")
+salesforce_obj = 'Contact'
+data = sfq.describeObject(salesforce_obj)
+for field in data['fields']:
+    print(field['name'])
+
+
+

salesforce/connect_test.py

@@ -0,0 +1,15 @@
+import unittest
+from connect import SalesForceQuery
+
+class TestSalesForceQuery(unittest.TestCase):
+    def __init__(self, grant_type):
+        self.sf = SalesForceOAuth('password')
+
+    def test_salesforce_query(self):
+        pass
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()

salesforce/mongo.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+from setuptools import setup, find_packages
+
+with open('README.rst') as f:
+    readme = f.read()
+
+with open('LICENSE') as f:
+    license = f.read()
+
+setup(
+    name='salesforce microservice',
+    version='0.0.1',
+    description='Middleware application between Salesforce and custom built Progyny projects',
+    long_description=readme,
+    author='Walter Schweitzer',
+    author_email='[email protected]',
+    url='https://github.com/waltertschwe/python-salesforce-oauth',
+    license=license,
+    packages=find_packages(exclude=('docs'))
+)