pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pysimplesat"
-version = "0.1.7"
+version = "0.1.1"
 authors = [
   { name="Peter Annabel", email="peter.annabel@gmail.com" },
 ]

src/pysimplesat/endpoints/simplesat/AnswersSearchEndpoint.py

@@ -25,6 +25,7 @@ class AnswersSearchEndpoint(
     def paginated(
         self,
         page: int,
+        limit: int,
         params: SimpleSatRequestParams | None = None,
     ) -> PaginatedResponse[Answer]:
         """
@@ -32,20 +33,23 @@ class AnswersSearchEndpoint(
 
         Parameters:
             page (int): The page number to request.
+            limit (int): The number of results to return per page.
             params (dict[str, int | str]): The parameters to send in the request query string.
         Returns:
             PaginatedResponse[Answer]: The initialized PaginatedResponse object.
         """
         if params:
-            params["page"] = page
+            params["page[number]"] = page
+            params["page[size]"] = limit
         else:
-            params = {"page": page}
+            params = {"page[number]": page, "page[size]": limit}
         return PaginatedResponse(
             super()._make_request("POST", params=params),
             Answer,
             self,
             "answers",
             page,
+            limit,
             params,
         )
 

src/pysimplesat/endpoints/simplesat/QuestionsEndpoint.py

@@ -1,10 +1,8 @@
 from pysimplesat.endpoints.base.base_endpoint import SimpleSatEndpoint
 from pysimplesat.interfaces import (
     IGettable,
-    IPaginateable,
 )
 from pysimplesat.models.simplesat import Question
-from pysimplesat.responses.paginated_response import PaginatedResponse
 from pysimplesat.types import (
     JSON,
     SimpleSatRequestParams,
@@ -14,39 +12,10 @@ from pysimplesat.types import (
 class QuestionsEndpoint(
     SimpleSatEndpoint,
     IGettable[Question, SimpleSatRequestParams],
-    IPaginateable[Question, SimpleSatRequestParams],
 ):
     def __init__(self, client, parent_endpoint=None) -> None:
         SimpleSatEndpoint.__init__(self, client, "questions", parent_endpoint=parent_endpoint)
         IGettable.__init__(self, Question)
-        IPaginateable.__init__(self, Question)
-
-    def paginated(
-        self,
-        page: int,
-        params: SimpleSatRequestParams | None = None,
-    ) -> PaginatedResponse[Question]:
-        """
-        Performs a GET request against the /questions endpoint and returns an initialized PaginatedResponse object.
-
-        Parameters:
-            page (int): The page number to request.
-            params (dict[str, int | str]): The parameters to send in the request query string.
-        Returns:
-            PaginatedResponse[Question]: The initialized PaginatedResponse object.
-        """
-        if params:
-            params["page"] = page
-        else:
-            params = {"page": page}
-        return PaginatedResponse(
-            super()._make_request("GET", params=params),
-            Question,
-            self,
-            "questions",
-            page,
-            params,
-        )
 
     def get(
         self,
@@ -62,6 +31,7 @@ class QuestionsEndpoint(
         Returns:
             Question: The parsed response data.
         """
+        print("get")
         return self._parse_many(
             Question,
             super()._make_request("GET", data=data, params=params).json().get('questions', {}),

src/pysimplesat/endpoints/simplesat/ResponsesSearchEndpoint.py

@@ -25,6 +25,7 @@ class ResponsesSearchEndpoint(
     def paginated(
         self,
         page: int,
+        limit: int,
         params: SimpleSatRequestParams | None = None,
     ) -> PaginatedResponse[Response]:
         """
@@ -32,23 +33,28 @@ class ResponsesSearchEndpoint(
 
         Parameters:
             page (int): The page number to request.
+            limit (int): The number of results to return per page.
             params (dict[str, int | str]): The parameters to send in the request query string.
         Returns:
             PaginatedResponse[Response]: The initialized PaginatedResponse object.
         """
         if params:
-            params["page"] = page
+            params["page[number]"] = page
+            params["page[size]"] = limit
         else:
-            params = {"page[number]": page}
+            params = {"page[number]": page, "page[size]": limit}
         return PaginatedResponse(
             super()._make_request("POST", params=params),
             Response,
             self,
             "responses",
             page,
+            limit,
             params,
         )
 
+
+    #TODO: How do I paginate a post?
     def post(self, data: JSON | None = None, params: SimpleSatRequestParams | None = None) -> Response:
         """
         Performs a POST request against the /responses/search endpoint.

src/pysimplesat/endpoints/simplesat/SurveysEndpoint.py

@@ -45,6 +45,7 @@ class SurveysEndpoint(
         Returns:
             Survey: The parsed response data.
         """
+        print("get")
         return self._parse_many(
             Survey,
             super()._make_request("GET", data=data, params=params).json().get('surveys', {}),

src/pysimplesat/interfaces.py

@@ -30,7 +30,8 @@ class IPaginateable(IMethodBase, Generic[TModel, TRequestParams]):
     @abstractmethod
     def paginated(
         self,
-        page: int | None = 1,
+        page: int,
+        page_size: int,
         params: TRequestParams | None = None,
     ) -> PaginatedResponse[TModel]:
         pass

src/pysimplesat/models/simplesat/__init__.py

@@ -53,19 +53,6 @@ class TeamMember(SimpleSatModel):
     custom_attributes: dict[str, str | int] | None = Field(default=None, alias="CustomAttributes")
 
 class Response(SimpleSatModel):
-    id: int | None = Field(default=None, alias="Id")
-    survey: dict[str, str | int] | None = Field(default=None, alias="Survey")
-    tags: list[str] | None = Field(default=None, alias="Tags")
-    created: datetime | None = Field(default=None, alias="Created")
-    modified: datetime | None = Field(default=None, alias="Modified")
-    ip_address: str | None = Field(default=None, alias="IPAddress")
-    ticket: dict[str, Any] | None = Field(default=None, alias="Ticket")
-    team_members: list[dict[str, Any]] | None = Field(default=None, alias="TeamMembers")
-    customer: dict[str, Any] | None = Field(default=None, alias="Customer")
-    answers: list[dict[str, Any]] | None = Field(default=None, alias="Answers")
-    source: str | None = Field(default=None, alias="Source")
-
-class ResponseCreatePost(SimpleSatModel):
     survey_id: int | None = Field(default=None, alias="SurveyId")
     tags: list | None = Field(default=None, alias="Tags")
     answers: list[dict[str, Any]] | None = Field(default=None, alias="Answers")
@@ -81,17 +68,6 @@ class Survey(SimpleSatModel):
     survey_type: str | None = Field(default=None, alias="SurveyType")
     brand_name: str | None = Field(default=None, alias="BrandName")
 
-class Question(SimpleSatModel):
-    id: int | None = Field(default=None, alias="Id")
-    survey: dict[str, int | str] | None = Field(default=None, alias="Survey")
-    order: int | None = Field(default=None, alias="Order")
-    metric: str | None = Field(default=None, alias="Metric")
-    text: str | None = Field(default=None, alias="Text")
-    rating_scale: bool | None = Field(default=None, alias="RatingScale")
-    required: bool | None = Field(default=None, alias="Required")
-    choices: list[str] | None = Field(default=None, alias="Choices")
-    rules: list[dict[str, Any]] | None = Field(default=None, alias="Rules")
-
 class CustomerBulk(SimpleSatModel):
     request_id: str | None = Field(default=None, alias="RequestId")
     detail: str | None = Field(default=None, alias="Detail")

src/pysimplesat/responses/paginated_response.py

@@ -42,6 +42,7 @@ class PaginatedResponse(Generic[TModel]):
         endpointmodel: IPaginateable,
         endpoint: str,
         page: int,
+        limit: int,
         params: RequestParams | None = None,
     ) -> None:
         """
@@ -57,7 +58,7 @@ class PaginatedResponse(Generic[TModel]):
         expected model type for the response data. This allows for type-safe handling
         of model instances throughout the class.
         """
-        self._initialize(response, response_model, endpointmodel, endpoint, page, params)
+        self._initialize(response, response_model, endpointmodel, endpoint, page, limit, params)
 
     def _initialize(
         self,
@@ -66,6 +67,7 @@ class PaginatedResponse(Generic[TModel]):
         endpointmodel: IPaginateable,
         endpoint: str,
         page: int,
+        limit: int,
         params: RequestParams | None = None,
     ):
         """
@@ -75,25 +77,35 @@ class PaginatedResponse(Generic[TModel]):
             response: The raw response object from the API.
             endpointmodel (SimpleSatEndpoint[TModel]): The endpointmodel associated with the response.
             endpoint: The endpoint url to extract the data
+            limit (int): The number of items per page.
         """
         self.response = response
         self.response_model = response_model
         self.endpointmodel = endpointmodel
         self.endpoint = endpoint
+        self.limit = limit
         # Get page data from the response body
-        self.parsed_pagination_response = parse_response_body(json.loads(response.content.decode('utf-8')))
+        try:
+            self.parsed_pagination_response = parse_response_body(json.loads(response.content.decode('utf-8')).get('pagination', {}))
+        except:
+            self.parsed_pagination_response = parse_response_body(json.loads(response.content.decode('utf-8')).get('meta.page', {}))
+        self.params = params
         if self.parsed_pagination_response is not None:
             # SimpleSat API gives us a handy response to parse for Pagination
             self.has_next_page: bool = self.parsed_pagination_response.get("has_next_page", False)
             self.has_prev_page: bool = self.parsed_pagination_response.get("has_prev_page", False)
+            self.first_page: int = self.parsed_pagination_response.get("first_page", None)
             self.prev_page: int = self.parsed_pagination_response.get("prev_page", None)
             self.next_page: int = self.parsed_pagination_response.get("next_page", None)
+            self.last_page: int = self.parsed_pagination_response.get("last_page", None)
         else:
+            # Haven't worked on this yet
             self.has_next_page: bool = True
             self.has_prev_page: bool = page > 1
+            self.first_page: int = 1
             self.prev_page = page - 1 if page > 1 else 1
             self.next_page = page + 1
-        self.params = params
+            self.last_page = 999999
         self.data: list[TModel] = [response_model.model_validate(d) for d in response.json().get(endpoint, {})]
         self.has_data = self.data and len(self.data) > 0
         self.index = 0
@@ -110,13 +122,14 @@ class PaginatedResponse(Generic[TModel]):
             self.has_data = False
             return self
 
-        next_response = self.endpointmodel.paginated(self.next_page, self.params)
+        next_response = self.endpointmodel.paginated(self.next_page, self.limit, self.params)
         self._initialize(
             next_response.response,
             next_response.response_model,
             next_response.endpointmodel,
             next_response.endpoint,
             self.next_page,
+            next_response.limit,
             self.params,
         )
         return self
@@ -133,12 +146,13 @@ class PaginatedResponse(Generic[TModel]):
             self.has_data = False
             return self
 
-        prev_response = self.endpointmodel.paginated(self.prev_page, self.params)
+        prev_response = self.endpointmodel.paginated(self.prev_page, self.limit, self.params)
         self._initialize(
             prev_response.response,
             prev_response.response_model,
             prev_response.endpointmodel,
             self.prev_page,
+            prev_response.limit,
             self.params,
         )
         return self

src/pysimplesat/types.py

@@ -21,6 +21,7 @@ class SimpleSatRequestParams(TypedDict):
     customFieldConditions: NotRequired[str]
     page_token: NotRequired[str]
     page: NotRequired[int]
+    limit: NotRequired[int]
     organization_id: NotRequired[int]
     platform: NotRequired[str]
     status: NotRequired[str]

src/pysimplesat/utils/helpers.py

@@ -2,7 +2,6 @@ import re
 import math
 from datetime import datetime
 from typing import Any
-from urllib.parse import parse_qs, urlparse
 
 from requests.structures import CaseInsensitiveDict
 
@@ -53,36 +52,64 @@ def parse_response_body(
         print(pagination_info)
         # Output: {'first_page': 1, 'next_page': 2, 'has_next_page': True}
     """
-    #what goes out
+    if body.get("current_page") is None:
+        return None
     has_next_page: bool = False
     has_prev_page: bool = False
-    previous_page: int | None = None
+    first_page: int | None = None
+    prev_page: int | None = None
+    current_page: int | None = None
+    current_page_count: int | None = None
+    limit: int | None = None
+    total_count: int | None = None
     next_page: int | None = None
-    
+    next_page_url: str | None = None
-    #what comes in
+    next_page_token: str | None = None
-    count: int | None = None
+    last_page: int | None = None
-    next: str | None = None
-    previous: str | None = None
 
     result = {}
-    if body["previous"] is not None:
-        try:
-            result["prev_page"] = parse_qs(urlparse(body["previous"]).query)['page'][0]
-        except:
-            result["prev_page"] = 1
 
-    if body["next"] is not None:
+    if body.get("first_page") is not None:
-        result["next_page"] = parse_qs(urlparse(body["next"]).query)['page'][0]
+        result["first_page"] = body.get("first_page")
 
-    if body["next"] is not None:
+    if body.get("prev_page") is not None:
+        result["prev_page"] = body.get("prev_page")
+    elif body.get("current_page") is not None:
+        if body.get("current_page") > 1:
+            result["prev_page"] = body.get("current_page") - 1
+    elif body.get("currentPage") is not None:
+        if body.get("currentPage") > 1:
+            result["prev_page"] = body.get("currentPage") - 1
+
+    if body.get("next_page") is not None:
+        result["next_page"] = body.get("next_page")
+    elif body.get("currentPage") is not None and body.get("currentPage") < body.get("lastPage"):
+        result["next_page"] = body.get("currentPage") + 1
+
+    if body.get("last_page") is not None:
+        result["last_page"] = body.get("last_page")
+    elif body.get("lastPage") is not None:
+        result["last_page"] = body.get("lastPage")
+    elif body.get("last_page") is None and body.get("current_page") is not None:
+        result["last_page"] = math.ceil(body.get("total_count")/body.get("limit"))
+
+    if body.get("has_next_page"):
+        result["has_next_page"] = body.get("has_next_page")
+    elif body.get("current_page") is not None and body.get("next_page") is not None:
         result["has_next_page"] = True
-    else:
+    elif body.get("current_page") is not None and body.get("next_page") is None:
         result["has_next_page"] = False
+    elif body.get("currentPage") is not None and body.get("currentPage") < body.get("lastPage"):
+        result["has_next_page"] = True
     
-    if body["previous"] is not None:
+    if body.get("has_prev_page"):
-        result["has_prev_page"] = True
+        result["has_prev_page"] = body.get("has_prev_page")
-    else:
+    elif body.get("current_page") is not None:
-        result["has_prev_page"] = False
+        if body.get("current_page") > 1:
+            result["has_prev_page"] = True
+    elif body.get("currentPage") is not None:
+        if body.get("currentPage") > 1:
+            result["has_prev_page"] = True
 
     return result
     

src/simplesat_scratchpad.py

@@ -14,8 +14,6 @@ simplesat_api_client = SimpleSatAPIClient(
 #surveys = simplesat_api_client.surveys.get()
 #print(surveys)
 
-page_responses = simplesat_api_client.responses.search.paginated(1)
+answers = simplesat_api_client.responses.search.paginated(1,5)
-responses = page_responses.all()
+print(answers)
-print(responses)
+print(answers.data)
-for response in responses:
-    print(response.id)