Updates to ActionKit, S3, and NGPVan

parsons/action_kit/action_kit.py

@@ -700,6 +700,41 @@ def update_order(self, order_id, **kwargs):
                                data=json.dumps(kwargs))
         logger.info(f'{resp.status_code}: {order_id}')
 
+    def cancel_orderrecurring(self, recurring_id):
+        """
+        Cancel a recurring order.
+
+        `Args:`
+            recurring_id: int
+                The id of the recurring order to update (NOT the order_id)
+        `Returns:`
+            ``None``
+        """
+
+        resp = self.conn.post(self._base_endpoint('orderrecurring', str(recurring_id)+'/cancel'))
+        logger.info(f'{resp.status_code}: {recurring_id}')
+        return resp
+
+    def update_paymenttoken(self, paymenttoken_id, **kwargs):
+        """
+        Update a saved payment token.
+
+        `Args:`
+            paymenttoken_id: int
+                The id of the payment token to update
+            **kwargs:
+                Optional arguments and fields to pass to the client. A full list can be found
+                in the `ActionKit API Documentation <https://roboticdogs.actionkit.com/docs/\
+                manual/api/rest/actionprocessing.html>`_.
+        `Returns:`
+            ``HTTP response``
+        """
+
+        resp = self.conn.patch(self._base_endpoint('paymenttoken', paymenttoken_id),
+                               data=json.dumps(kwargs))
+        logger.info(f'{resp.status_code}: {paymenttoken_id}')
+        return resp
+
     def get_page_followup(self, page_followup_id):
         """
         Get a page followup.
@@ -784,6 +819,21 @@ def update_survey_question(self, survey_question_id, **kwargs):
                                data=json.dumps(kwargs))
         logger.info(f'{resp.status_code}: {survey_question_id}')
 
+    def create_transaction(self, **kwargs):
+        """
+        Create a transaction.
+
+        `Args:`
+            **kwargs:
+                Optional arguments and fields to pass to the client.
+        `Returns:`
+            Transaction json object
+        """
+
+        return self._base_post(
+            endpoint='transaction', exception_message='Could not create transaction', **kwargs
+        )
+
     def update_transaction(self, transaction_id, **kwargs):
         """
         Update a transaction.

parsons/aws/lambda_distribute.py

@@ -35,8 +35,8 @@ class S3Storage:
     inside this file rather than s3.py
     """
 
-    def __init__(self):
-        self.s3 = S3()
+    def __init__(self, use_env_token=True):
+        self.s3 = S3(use_env_token=use_env_token)
 
     def put_object(self, bucket, key, object_bytes, **kwargs):
         return self.s3.client.put_object(Bucket=bucket, Key=key, Body=object_bytes, **kwargs)
@@ -65,7 +65,8 @@ def distribute_task_csv(csv_bytes_utf8, func_to_run, bucket,
                         func_class_kwargs=None,
                         catch=False,
                         group_count=100,
-                        storage='s3'):
+                        storage='s3',
+                        use_s3_env_token=True):
     """
     The same as distribute_task, but instead of a table, the
     first argument is bytes of a csv encoded into utf8.
@@ -98,7 +99,9 @@ def distribute_task_csv(csv_bytes_utf8, func_to_run, bucket,
 
     response = None
     if storage == 's3':
-        response = S3Storage().put_object(bucket, storagekey, csv_bytes_utf8)
+        response = S3Storage(use_env_token=use_s3_env_token).put_object(
+            bucket, storagekey, csv_bytes_utf8
+        )
     else:
         response = FAKE_STORAGE.put_object(bucket, storagekey, csv_bytes_utf8)
 
@@ -107,7 +110,7 @@ def distribute_task_csv(csv_bytes_utf8, func_to_run, bucket,
         maybe_async_run(
             process_task_portion,
             [bucket, storagekey, grp[0], grp[1], func_name, header,
-             storage, func_kwargs, catch, func_class_kwargs],
+             storage, func_kwargs, catch, func_class_kwargs, use_s3_env_token],
             # if we are using local storage, then it must be run locally, as well
             # (good for testing/debugging)
             remote_aws_lambda_function_name='FORCE_LOCAL' if storage == 'local' else None
@@ -125,7 +128,8 @@ def distribute_task(table, func_to_run,
                     func_class_kwargs=None,
                     catch=False,
                     group_count=100,
-                    storage='s3'):
+                    storage='s3',
+                    use_s3_env_token=True):
     """
     Distribute processing rows in a table across multiple AWS Lambda invocations.
 
@@ -165,6 +169,8 @@ def distribute_task(table, func_to_run,
         storage: str
            Debugging option: Defaults to "s3". To test distribution locally without s3,
            set to "local".
+        use_s3_env_token: str
+           If storage is set to "s3", sets the use_env_token parameter on the S3 storage.
     `Returns:`
         Debug information -- do not rely on the output, as it will change
         depending on how this method is invoked.
@@ -184,19 +190,22 @@ def distribute_task(table, func_to_run,
                                func_class_kwargs=func_class_kwargs,
                                catch=catch,
                                group_count=group_count,
-                               storage=storage)
+                               storage=storage,
+                               use_s3_env_token=use_s3_env_token)
 
 
 def process_task_portion(bucket, storagekey, rangestart, rangeend, func_name, header,
                          storage='s3', func_kwargs=None, catch=False,
-                         func_class_kwargs=None):
+                         func_class_kwargs=None, use_s3_env_token=True):
     global FAKE_STORAGE
 
     logger.debug(f'process_task_portion func_name {func_name}, '
                  f'storagekey {storagekey}, byterange {rangestart}-{rangeend}')
     func = import_and_get_task(func_name, func_class_kwargs)
     if storage == 's3':
-        filedata = S3Storage().get_range(bucket, storagekey, rangestart, rangeend)
+        filedata = S3Storage(use_env_token=use_s3_env_token).get_range(
+            bucket, storagekey, rangestart, rangeend
+        )
     else:
         filedata = FAKE_STORAGE.get_range(bucket, storagekey, rangestart, rangeend)
 

parsons/databases/redshift/redshift.py

@@ -58,11 +58,16 @@ class Redshift(RedshiftCreateTable, RedshiftCopyTable, RedshiftTableUtilities, R
         iam_role: str
             AWS IAM Role ARN string -- an optional, different way for credentials to
             be provided in the Redshift copy command that does not require an access key.
+        use_env_token: bool
+            Controls use of the ``AWS_SESSION_TOKEN`` environment variable for S3. Defaults
+            to ``True``. Set to ``False`` in order to ignore the ``AWS_SESSION_TOKEN`` environment
+            variable even if the ``aws_session_token`` argument was not passed in.
     """
 
     def __init__(self, username=None, password=None, host=None, db=None, port=None,
                  timeout=10, s3_temp_bucket=None,
-                 aws_access_key_id=None, aws_secret_access_key=None, iam_role=None):
+                 aws_access_key_id=None, aws_secret_access_key=None, iam_role=None,
+                 use_env_token=True):
         super().__init__()
 
         try:
@@ -85,6 +90,7 @@ def __init__(self, username=None, password=None, host=None, db=None, port=None,
             split_temp_bucket_name = self.s3_temp_bucket.split('/', 1)
             self.s3_temp_bucket = split_temp_bucket_name[0]
             self.s3_temp_bucket_prefix = split_temp_bucket_name[1]
+        self.use_env_token = use_env_token
         # We don't check/load the environment variables for aws_* here
         # because the logic in S3() and rs_copy_table.py does already.
         self.aws_access_key_id = aws_access_key_id
@@ -353,7 +359,8 @@ def copy_s3(self, table_name, bucket, key, manifest=False, data_type='csv',
                     # Grab the object from s3
                     from parsons.aws.s3 import S3
                     s3 = S3(aws_access_key_id=aws_access_key_id,
-                            aws_secret_access_key=aws_secret_access_key)
+                            aws_secret_access_key=aws_secret_access_key,
+                            use_env_token=self.use_env_token)
 
                     local_path = s3.get_file(bucket, key)
                     if data_type == 'csv':
@@ -712,7 +719,8 @@ def generate_manifest(self, buckets, aws_access_key_id=None, aws_secret_access_k
 
         from parsons.aws import S3
         s3 = S3(aws_access_key_id=aws_access_key_id,
-                aws_secret_access_key=aws_secret_access_key)
+                aws_secret_access_key=aws_secret_access_key,
+                use_env_token=self.use_env_token)
 
         # Deal with a single bucket being passed, rather than list.
         if isinstance(buckets, str):

parsons/databases/redshift/rs_copy_table.py

@@ -14,9 +14,8 @@ class RedshiftCopyTable(object):
     aws_secret_access_key = None
     iam_role = None
 
-    def __init__(self):
-
-        pass
+    def __init__(self, use_env_token=True):
+        self.use_env_token = use_env_token
 
     def copy_statement(self, table_name, bucket, key, manifest=False,
                        data_type='csv', csv_delimiter=',', max_errors=0,
@@ -113,7 +112,7 @@ def get_creds(self, aws_access_key_id, aws_secret_access_key):
 
         else:
 
-            s3 = S3()
+            s3 = S3(use_env_token=self.use_env_token)
             creds = s3.aws.session.get_credentials()
             aws_access_key_id = creds.access_key
             aws_secret_access_key = creds.secret_key
@@ -135,7 +134,7 @@ def temp_s3_copy(self, tbl, aws_access_key_id=None, aws_secret_access_key=None,
         aws_secret_access_key = aws_secret_access_key or self.aws_secret_access_key
 
         self.s3 = S3(aws_access_key_id=aws_access_key_id,
-                     aws_secret_access_key=aws_secret_access_key)
+                     aws_secret_access_key=aws_secret_access_key, use_env_token=self.use_env_token)
 
         hashed_name = hash(time.time())
         key = f"{S3_TEMP_KEY_PREFIX}/{hashed_name}.csv.gz"

parsons/ngpvan/contact_notes.py

@@ -0,0 +1,55 @@
+"""NGPVAN Contact Notes Endpoints"""
+
+from parsons.etl.table import Table
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ContactNotes(object):
+
+    def __init__(self, van_connection):
+        self.connection = van_connection
+
+    def get_contact_notes(self, van_id):
+        """
+        Get custom fields.
+
+        `Args:`
+            van_id : str
+                VAN ID for the person to get notes for.
+        `Returns:`
+            Parsons Table
+                See :ref:`parsons-table` for output options.
+        """
+
+        tbl = Table(self.connection.get_request(f'people/{van_id}/notes'))
+        logger.info(f'Found {tbl.num_rows} custom fields.')
+        return tbl
+
+    def create_contact_note(self, van_id, text, is_view_restricted, note_category_id=None):
+        """
+        Create a contact note
+
+        `Args:`
+            van_id: str
+                VAN ID for the person this note will be applied to.
+            text: str
+                The content of the note.
+            is_view_restricted: bool
+                Set to true if the note should be restricted only to certain users within
+                the current context; set to false if the note may be viewed by any user
+                in the current context.
+            note_category_id: int
+                Optional; if set, the note category for this note.
+        `Returns:`
+            int
+              The note ID.
+        """
+        note = {'text': text, 'isViewRestricted': is_view_restricted}
+        if note_category_id is not None:
+            note['category'] = {'noteCategoryId': note_category_id}
+
+        r = self.connection.post_request(f'people/{van_id}/notes', json=note)
+        logger.info(f'Contact note {r} created.')
+        return r

parsons/ngpvan/van.py

@@ -13,6 +13,7 @@
 from parsons.ngpvan.locations import Locations
 from parsons.ngpvan.bulk_import import BulkImport
 from parsons.ngpvan.changed_entities import ChangedEntities
+from parsons.ngpvan.contact_notes import ContactNotes
 from parsons.ngpvan.custom_fields import CustomFields
 from parsons.ngpvan.targets import Targets
 
@@ -21,7 +22,7 @@
 
 class VAN(People, Events, SavedLists, Folders, ExportJobs, ActivistCodes, CanvassResponses,
           SurveyQuestions, Codes, Scores, FileLoadingJobs, SupporterGroups, Signups, Locations,
-          BulkImport, ChangedEntities, CustomFields, Targets):
+          BulkImport, ChangedEntities, ContactNotes, CustomFields, Targets):
     """
     Returns the VAN class
 

test/test_action_kit.py

@@ -450,6 +450,29 @@ def test_update_survey_question(self):
             data=json.dumps({'question_html': 'test'})
         )
 
+    def test_create_transaction(self):
+        # Test create transaction
+
+        # Mock resp and status code
+        resp_mock = mock.MagicMock()
+        type(resp_mock.post()).status_code = mock.PropertyMock(return_value=201)
+        self.actionkit.conn = resp_mock
+
+        self.actionkit.create_transaction(
+            account='Account', amount=1, amount_converted=1, currency='USD', failure_code='',
+            failure_description='', failure_message='', order='/rest/v1/order/1/',
+            status='completed', success=True, test_mode=False, trans_id='abc123', type='sale'
+        )
+        self.actionkit.conn.post.assert_called_with(
+            'https://domain.actionkit.com/rest/v1/transaction/',
+            data=json.dumps({
+                'account': 'Account', 'amount': 1, 'amount_converted': 1, 'currency': 'USD',
+                'failure_code': '', 'failure_description': '', 'failure_message': '',
+                'order': '/rest/v1/order/1/', 'status': 'completed', 'success': True,
+                'test_mode': False, 'trans_id': 'abc123', 'type': 'sale'
+            })
+        )
+
     def test_update_transaction(self):
         # Test update transaction