internal functions to store and get time records from redmine, including model. supporting tests

Author: Paul Philion

data/enumerations/time_entry_activities.json

@@ -0,0 +1,22 @@
+{
+  "time_entry_activities": [
+    {
+      "id": 15,
+      "name": "Community Networks (General)",
+      "is_default": true,
+      "active": true
+    },
+    {
+      "id": 16,
+      "name": "Grant: Seattle TMF 2023-4",
+      "is_default": false,
+      "active": true
+    },
+    {
+      "id": 17,
+      "name": "Grant: Benton Fellowship 2024",
+      "is_default": false,
+      "active": true
+    }
+  ]
+}

netbot/cog_tickets.py

@@ -806,3 +806,27 @@ async def parent(self, ctx: discord.ApplicationContext, parent_ticket:int):
     @ticket.command(name="help", description="Display help about ticket management")
     async def help(self, ctx: discord.ApplicationContext):
         await ctx.respond(embed=self.bot.formatter.help_embed(ctx))
+
+
+    @discord.slash_command(name="testime", description="Record time against a program")
+    async def recordTime(self, ctx: discord.ApplicationContext, hours: float, program: str, note: str = ""):
+        log.info(f">>> {hours} {program} {note}")
+        redmine: Client = ctx.bot.redmine
+
+        user = redmine.user_mgr.find(ctx.user.name)
+        if not user:
+            await ctx.respond(f"User {ctx.user.name} not mapped to redmine. Use `/scn add` to create the mapping.") # error
+            return
+
+        autoresolve = False
+        ticket_id = NetBot.parse_thread_title(ctx.channel.name)
+        if ticket_id is None:
+            # create a ticket and thread
+            ticket_cog = ctx.bot.get_cog('TicketsCog')
+            if ticket_cog:
+                await ticket_cog.create_new_ticket(ctx, note)
+                autoresolve = True
+
+        redmine.ticket_mgr.record_time(ticket_id, user, hours, program, note)
+        if autoresolve:
+            redmine.ticket_mgr.resolve(ticket_id)

redmine/model.py

@@ -562,3 +562,56 @@ def asdict(self):
     @property
     def json(self):
         return json.dumps(self.asdict(), indent=4, default=vars)
+
+
+@dataclass
+class TimeEntry:
+    id: int
+    project: NamedId
+    issue: map
+    user: NamedId
+    activity: NamedId
+    hours: float
+    comments: str
+    spent_on: dt.date
+    created_on: dt.datetime
+    updated_on: dt.datetime
+    ticket_id: int = -1
+
+    def __post_init__(self):
+        self.user = NamedId(**self.user)
+        self.project = NamedId(**self.project)
+        self.activity =  NamedId(**self.activity)
+        self.ticket_id = self.issue['id']
+
+        if self.created_on and isinstance(self.created_on, str):
+            self.created_on = synctime.parse_str(self.created_on)
+        if self.updated_on and isinstance(self.updated_on, str):
+            self.updated_on = synctime.parse_str(self.updated_on)
+
+    def asdict(self):
+        return dataclasses.asdict(self)
+
+    @property
+    def json(self):
+        return json.dumps(self.asdict(), indent=4, default=vars)
+
+
+@dataclass
+class TimeEntryResults:
+    """Encapsulates a set of tickets"""
+    total_count: int
+    limit: int
+    offset: int
+    time_entries: list[TimeEntry]
+
+    def __post_init__(self):
+        if self.time_entries and len(self.time_entries) > 0 and isinstance(self.time_entries[0], dict):
+            self.time_entries = [TimeEntry(**entry) for entry in self.time_entries]
+
+    def asdict(self):
+        return dataclasses.asdict(self)
+
+    @property
+    def json(self):
+        return json.dumps(self.asdict(), indent=4, default=vars)

redmine/tickets.py

@@ -7,7 +7,7 @@
 import json
 import urllib.parse
 
-from redmine.model import TO_CC_FIELD_NAME, User, Message, NamedId, Team, Ticket, TicketNote, TicketsResult, TicketStatus, SYNC_FIELD_NAME
+from redmine.model import TO_CC_FIELD_NAME, TimeEntry, TimeEntryResults, User, Message, NamedId, Team, Ticket, TicketNote, TicketsResult, TicketStatus, SYNC_FIELD_NAME
 from redmine.session import RedmineSession, RedmineException
 from redmine import synctime
 
@@ -37,7 +37,9 @@ def __init__(self, session: RedmineSession, default_project:int):
         self.trackers = {}
         self.custom_fields = {}
         self.statuses = {}
+        self.programs = {} # grants and tracked SCN projects
         self.default_project:int = default_project
+        self.default_program:int = -1
 
         self.reindex()
 
@@ -47,6 +49,7 @@ def reindex(self):
         self.statuses = self.load_statuses()
         self.trackers = self.load_trackers()
         self.custom_fields = self.load_custom_fields()
+        self.programs = self.load_programs()
 
 
     def sanity_check(self) -> dict[str, bool]:
@@ -76,6 +79,24 @@ def get_custom_field(self, name:str) -> NamedId | None:
         return self.custom_fields.get(name, None)
 
 
+    def load_programs(self) -> dict[str,int]:
+        programs: dict[str,int] = {}
+
+        resp = self.session.get("/enumerations/time_entry_activities.json")
+        for activity in resp['time_entry_activities']:
+            if activity.get('active', False): # use fallback=false for active
+                programs[activity['name']] = activity['id']
+            if activity.get('is_default', False):
+                self.default_program = activity['id']
+
+        log.debug(f"Loaded programs: {programs}, default: {self.default_program}")
+        return programs
+
+
+    def get_program(self, program_name: str) -> int:
+        return self.programs.get(program_name, self.default_program)
+
+
     def load_priorities(self) -> dict[str,NamedId]:
         """load active priorities"""
 
@@ -603,6 +624,50 @@ def resolve(self, ticket_id, user_id=None):
         return self.update(ticket_id, {"status_id": "3"}, user_id) # '3' is the status_id, it doesn't accept "Resolved"
 
 
+    def record_time(self, ticket_id:int, user:User, hours:float, program:str, note:str) -> TimeEntry:
+        # time_entry (required): a hash of the time entry attributes, including:
+        # issue_id or project_id (only one is required): the issue id or project id to log time on (both are integers); note that project ids can only be found using the API (e.g. at /projects.json)
+        # spent_on: the date the time was spent (default to the current date); format is e.g. 2020-12-24
+        # hours (required): the number of spent hours
+        # activity_id: the id of the time activity. This parameter is required unless a default activity is defined in Redmine.
+        # comments: short description for the entry (255 characters max)
+        # user_id: user id to be specified in need of posting time on behalf of another user
+        time_entry = {
+            'time_entry': {
+                'issue_id': ticket_id,
+                # 'spent_on': "2020-12-24", # (default to the current date)
+                'hours': hours,
+                'activity_id': self.get_program(program),
+                'comments': note,
+                'user_id': user.id,
+            }
+        }
+
+        response = self.session.post("/time_entries.json", json.dumps(time_entry), user.login)
+        if response:
+            return TimeEntry(**response['time_entry'])
+        else:
+            raise RedmineException(
+                f"create_ticket failed, status=[{response.status_code}] {response.reason}",
+                response.headers['X-Request-Id'])
+
+
+    # project_id
+    # issue_id
+    # activity_id
+    #  user_id
+    # from 2019-01-01
+    # to 2019-01-03
+    # spent_on - specific date?
+    def get_time_records(self, **kwargs) -> TimeEntryResults|None:
+        response = self.session.get(f"/time_entries.json?{urllib.parse.urlencode(kwargs)}")
+        if response:
+            return TimeEntryResults(**response)
+        else:
+            log.error(f"Error querying time records: params: {kwargs}, response={response}")
+            return None
+
+
     def update_sync_record(self, record:synctime.SyncRecord):
         log.debug(f"Updating sync record in redmine: {record}")
         fields = {

tests/test_cog_tickets.py

@@ -583,3 +583,30 @@ async def test_parent_command(self):
                 # delete the ticket and confirm
                 self.redmine.ticket_mgr.remove(parent_ticket.id)
                 self.assertIsNone(self.redmine.ticket_mgr.get(parent_ticket.id))
+
+
+    async def test_record_time(self):
+        try:
+            ticket = self.create_test_ticket()
+            ctx = self.build_context()
+            ctx.channel = unittest.mock.AsyncMock(discord.TextChannel)
+            ctx.channel.name = f"Ticket #{ticket.id}"
+            ctx.channel.id = ticket.id
+
+            activity = "Development"
+            notes = "this is a test"
+            await self.cog.recordTime(ctx, 2.33, activity, notes)
+
+            records = self.redmine.ticket_mgr.get_time_records(issue_id=ticket.id)
+            self.assertIsNotNone(records)
+            self.assertEqual(records.total_count, 1)
+            self.assertEqual(records.time_entries[0].project.id, 1)
+            self.assertEqual(records.time_entries[0].ticket_id, ticket.id)
+            self.assertEqual(records.time_entries[0].user.id, self.user.id)
+            self.assertEqual(records.time_entries[0].activity.name, activity)
+            self.assertEqual(records.time_entries[0].comments, notes)
+        finally:
+            if ticket:
+               # delete the ticket and confirm
+               self.redmine.ticket_mgr.remove(ticket.id)
+               self.assertIsNone(self.redmine.ticket_mgr.get(ticket.id))