django-restit 4.2.172__py3-none-any.whl → 4.2.174__py3-none-any.whl

account/models/group.py

@@ -118,6 +118,7 @@ class Group(models.Model, RestModel, MetaDataModel):
                 "kind",
                 ("metadata__timezone", "timezone"),
                 ("metadata__eod", "end_of_day"),
+                ("parent__pk", "parent_id"),
                 ("parent__name", "parent"),
                 ("location.line1", "address_line1"),
                 ("location.line2", "address_line2"),
@@ -171,7 +172,7 @@ class Group(models.Model, RestModel, MetaDataModel):
             if item:
                 return item.thumbnail_url()
         return None
-        
+
     @classmethod
     def on_rest_list_filter(cls, request, qset=None):
         if not request.member.hasPermission("view_all_groups"):
@@ -231,7 +232,7 @@ class Group(models.Model, RestModel, MetaDataModel):
                 raise RestValidationError("cannot set self as parent", 1101)
             value = Group.objects.filter(pk=value).last()
         self.parent = value
-    
+
     def set_child_of(self, value):
         # this is a helper to add this group to another group
         parent = Group.objects.filter(pk=value).last()
@@ -321,7 +322,7 @@ class Group(models.Model, RestModel, MetaDataModel):
                 return True
         return False
 
-    def notifyMembers(self, subject, message=None, template=None, context=None, 
+    def notifyMembers(self, subject, message=None, template=None, context=None,
                       email_only=False, sms_msg=None, perms=None, force=False,
                       from_email=None, exclude_member=None):
         if perms is not None:
@@ -436,19 +437,19 @@ class Group(models.Model, RestModel, MetaDataModel):
         qset = self.memberships.filter(state__gte=-10)
         if perms:
             qset = qset.filter(
-                Q(properties__category="permissions", 
-                  properties__key__in=perms, 
-                  properties__value__in=TRUE_VALUES) | 
-                Q(member__properties__category="permissions", 
-                  member__properties__key__in=perms, 
+                Q(properties__category="permissions",
+                  properties__key__in=perms,
+                  properties__value__in=TRUE_VALUES) |
+                Q(member__properties__category="permissions",
+                  member__properties__key__in=perms,
                   member__properties__value__in=TRUE_VALUES))
         if notify:
             qset = qset.filter(
-                Q(properties__category="notify", 
-                  properties__key__in=notify, 
-                  properties__value__in=TRUE_VALUES) | 
-                Q(member__properties__category="notify", 
-                  member__properties__key__in=notify, 
+                Q(properties__category="notify",
+                  properties__key__in=notify,
+                  properties__value__in=TRUE_VALUES) |
+                Q(member__properties__category="notify",
+                  member__properties__key__in=notify,
                   member__properties__value__in=TRUE_VALUES))
 
         if role:
@@ -495,7 +496,7 @@ class Group(models.Model, RestModel, MetaDataModel):
             # enable again?
             ms.set_state(0)
             ms.save()
-            
+
         if MEMBERSHIP_ROLES:
             perms = MEMBERSHIP_ROLES.get(role, [])
             for k in perms:
@@ -601,12 +602,8 @@ class Group(models.Model, RestModel, MetaDataModel):
         if credentials.kind == "member":
             if msg.pk is not None:
                 return credentials.instance.isMemberOf(msg.pk)
-        return False         
+        return False
 
 
 class GroupMetaData(MetaDataBase):
     parent = models.ForeignKey(Group, related_name="properties", on_delete=models.CASCADE)
-
-
-
-

auditlog/models.py

@@ -55,10 +55,11 @@ class PersistentLog(models.Model, RestModel):
     class RestMeta:
         DEFAULT_SORT = "-when"
         CAN_SAVE = False
+        ESTIMATE_COUNTS = True
         GROUP_FIELD = None  # do this so when we sort by group it is always exact
         QUERY_FIELDS = [
-            "level", "component", "pkey", "action", 
-            "request_method", "request_path", 
+            "level", "component", "pkey", "action",
+            "request_method", "request_path",
             "session__ip", "user",
             "tid", "group", "user__username"]
         SEARCH_FIELDS = ["user__username", "user__last_name", "message", "session__ip", "request_path"]

{django_restit-4.2.172.dist-info → django_restit-4.2.174.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-restit
-Version: 4.2.172
+Version: 4.2.174
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

{django_restit-4.2.172.dist-info → django_restit-4.2.174.dist-info}/RECORD

@@ -28,7 +28,7 @@ account/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 account/models/__init__.py,sha256=cV_lMnT2vL_mjiYtT4hlcIHo52ocFbGSNVkOIHHLXZY,385
 account/models/device.py,sha256=8D-Sbv9PZWAnX6UVpp1lNJ03P24fknNnN1VOhqY7RVg,6306
 account/models/feeds.py,sha256=vI7fG4ASY1M0Zjke24RdnfDcuWeATl_yR_25jPmT64g,2011
-account/models/group.py,sha256=N9Ow7AtV4xN5zSE9E5-msthJy0G5-3DEr2MTmvFO1kU,22887
+account/models/group.py,sha256=JVyMIakLskUuGXBJFyessw4LlD9Fl6AsHtpo1yZEYjk,22884
 account/models/legacy.py,sha256=zYdtv4LC0ooxPVqWM-uToPwV-lYWQLorSE6p6yn1xDw,2720
 account/models/member.py,sha256=qmLCOVbNTRr4L-E7BbOMtv4V64QN7K-0pXDgnuB-AbY,54722
 account/models/membership.py,sha256=90EpAhOsGaqphDAkONP6j_qQ0OWSRaQsI8H7E7fgMkE,9249
@@ -69,7 +69,7 @@ auditlog/middleware.py,sha256=Q4bXg8rnm8y2fMnAsN6ha3Fz6TW8jIzLnvpu4H9SpWE,1537
 auditlog/migrations/0001_initial.py,sha256=X171gKQZIaTO9FGNG1yKTjGSZS0ZjZj5gvimF9-_kks,3309
 auditlog/migrations/0002_alter_persistentlog_session.py,sha256=DkkcIobbHdbniKg5bOlRmiF-Nc4hX55Y6KuQySrCcJ8,541
 auditlog/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-auditlog/models.py,sha256=skDAiuzR4chC-WNIaH2nm_VVcbnDD6ZtUxBwhk7UY8U,16517
+auditlog/models.py,sha256=kRoWpOout2DYW70jsZLHj7GJBssqbrR75fx0_-hrsaM,16546
 auditlog/periodic.py,sha256=AUhDeVsZtC47BJ-lklvYEegHoxAzj1RpIvRFSsM7g5E,363
 auditlog/rpc.py,sha256=gJgj3Wiar5pVsw8tuhy0jXLkqFkOr3Z-oI2DKelMRAQ,5592
 auditlog/tq.py,sha256=ROcCjQhCavOgW3-8yjLrboNTAYEC5Pu2UCoenom0Law,2478
@@ -114,9 +114,9 @@ incident/migrations/0015_rule_title_template_alter_incident_state.py,sha256=FPUD
 incident/migrations/0016_rule_notify_template.py,sha256=4WGdMxiELujLIy9bzHovHWbAORupodN1Ty3vsy3mLjg,425
 incident/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 incident/models/__init__.py,sha256=NMphuhb0RTMf7Ov4QkNv7iv6_I8Wtr3xQ54yjX_a31M,209
-incident/models/event.py,sha256=FEzEKKQKLkdRrPCvv-3Um9E2UPQjyIJp314Zr2LHuiw,7976
-incident/models/incident.py,sha256=dSveWs0VawYePeFxwZT8ni85CS_4jxpGV8nXPVGXokk,22607
-incident/models/ossec.py,sha256=eUDRGawzuLWobKEVGKfdZisDnyjS_Hlxi0T_GCSLCCI,2252
+incident/models/event.py,sha256=JEUdVUxqz2nRcfGC2GHo3baIg5JntK5cSL6_MesFLeA,7967
+incident/models/incident.py,sha256=oxwLDJYGmk26zf7AD_e7nKcoJw3gXibjrX3DlByNAT8,22580
+incident/models/ossec.py,sha256=g7cc2vYdYEB8zomohwqbo0ekyPt1v_qA67y35sBn2YY,2244
 incident/models/rules.py,sha256=PPp8oJDW1gop9i_21lhP50qgt_TrdWErp2mYqZCMfd4,7065
 incident/models/ticket.py,sha256=S3kqGQpYLE6Y4M9IKu_60sgW-f592xNr8uufqHnvDoU,2302
 incident/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -356,7 +356,7 @@ metrics/migrations/0003_metrics_expires.py,sha256=_g4oRv4NHW-4iCQx2s1SiF38LLyFf8
 metrics/migrations/0004_eodmetrics.py,sha256=Ky6ZVMZqa0F_SUp_QFWY7ZKBgVhy9CS4wZcsEhrkSgc,3271
 metrics/migrations/0005_alter_metrics_v1_alter_metrics_v10_alter_metrics_v11_and_more.py,sha256=pmwJfpPJ1RUX_CqM66l6vvV-nrAUPo_GIan0Pc9mQHs,2358
 metrics/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-metrics/models.py,sha256=O29Cud4VAwIAWnmQymFti0-ibOEoGmTWGxWsbtzcZHQ,14162
+metrics/models.py,sha256=v3SKizBcKVQ8eFIT18fPr6XveQ1cLJZqLKiitncz5-0,14175
 metrics/periodic.py,sha256=IayBLLat40D8FB-A3bYBW9lxm9-IzcugQunojThQ_OU,661
 metrics/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 metrics/providers/aws.py,sha256=dIBGFE1Fvszy6rmVrn_Fm1zUDv345q4dBsg9Iit-XCc,8358
@@ -379,7 +379,7 @@ pushit/utils.py,sha256=IeTCGa-164nmB1jIsK1lu1O1QzUhS3BKfuXHGjCW-ck,2121
 rest/.gitignore,sha256=TbEvWRMnAiajCTOdhiNrd9eeCAaIjRp9PRjE_VkMM5g,118
 rest/README.md,sha256=V3ETc-cJu8PZIbKr9xSe_pA4JEUpC8Dhw4bQeVCDJPw,5460
 rest/RemoteEvents.py,sha256=nL46U7AuxIrlw2JunphR1tsXyqi-ep_gD9CYGpYbNgE,72
-rest/__init__.py,sha256=8TNkWn1IUaIq_YXkkpS9iccJHxoxu2RQlJ1uqRRibr0,122
+rest/__init__.py,sha256=j76Rqm_TIvJvezmNJkUripR1cpoqTtqZAXhwIQ0t_Uk,122
 rest/arc4.py,sha256=y644IbF1ec--e4cUJ3KEYsewTCITK0gmlwa5mJruFC0,1967
 rest/cache.py,sha256=1Qg0rkaCJCaVP0-l5hZg2CIblTdeBSlj_0fP6vlKUpU,83
 rest/crypto/__init__.py,sha256=Tl0U11rgj1eBYqd6OXJ2_XSdNLumW_JkBZnaJqI6Ldw,72
@@ -412,12 +412,12 @@ rest/middleware/request.py,sha256=JchRNy5L-bGd-7h-KFYekGRvREe2eCkZXKOYqIkP2hI,41
 rest/middleware/session.py,sha256=zHSoQpIzRLmpqr_JvW406wzpvU3W3gDbm5JhtzLAMlE,10240
 rest/middleware/session_store.py,sha256=1nSdeXK8PyuYgGgIufqrS6j6QpIrQ7zbMNT0ol75e6U,1901
 rest/models/__init__.py,sha256=M8pvFDq-WCF-QcM58X7pMufYYe0aaQ3U0PwGe9TKbbY,130
-rest/models/base.py,sha256=eOvVDwHgKDdBJAnaK2xavGfkjkfpk5Oqy1KfKRjtu6o,72072
+rest/models/base.py,sha256=oPj4m4-fnmjYUqd9dru17ulyh8jdFbXtWJt1CiuiBls,72633
 rest/models/cacher.py,sha256=eKz8TINVhWEqKhJGMsRkKZTtBUIv5rN3NHbZwOC56Uk,578
 rest/models/metadata.py,sha256=ni8-BRF07lv4CdPUWnUdfPTOClQAVEeRZvO-ic623HU,12904
 rest/net.py,sha256=LcB2QV6VNRtsSdmiQvYZgwQUDwOPMn_VBdRiZ6OpI-I,2974
 rest/regexes.yaml,sha256=VoGb4E-P_K9f82Yzcpltgzekpt9usRtwu9PYlo46nUw,149463
-rest/requestex.py,sha256=N56056vV3zWkAP-QrYsCu7SdpPzE5kLuPoxGIuZAKt0,16127
+rest/requestex.py,sha256=hv0ss8n2wojoBD70cx1DkUj1Msuhd5Nr8bdaYQNIPC0,16123
 rest/rpc.py,sha256=WXZe5CLdYMeSXRH6wuzl-_riPPRnmtFNVJB9dfY1GSo,2965
 rest/search.py,sha256=QVjk2b5tZLgf1zM2MHvJTyRjwUbY5ZD7HXSTmSPXtvU,8362
 rest/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -429,8 +429,9 @@ rest/serializers/legacy.py,sha256=a5O-x2PqMKX8wYWrhCmdcivVbkPnru7UdyLbrhCaAdY,61
 rest/serializers/localizers.py,sha256=BegaCvTQVaruhWzvGHq3zWeVFmtBChatquRqAtkke10,410
 rest/serializers/model.py,sha256=08HJeqpmytjxvyiJFfsSRRG0uH-iK2mXCw6w0oMfWrI,8598
 rest/serializers/profiler.py,sha256=OxOimhEyvCAuzUBC9Q1dz2xaakjAqmSnekMATsjduXM,997
-rest/serializers/response.py,sha256=nUUFITnTKPDtqD5qtSRzYHFqhsG1TxO7thH81Bq-8Vk,7602
+rest/serializers/response.py,sha256=aSZ9bvhsYGHR26NA6sin7fGqFptjTsBhmIcDKrqeeoY,8656
 rest/serializers/util.py,sha256=-In89fpuVTd6_Ul8nwEUt3DjVKdpeoEyAxudlyB8K6Y,2734
+rest/service.py,sha256=jl8obnMDEUzB8y3LROGPvmfKKoFU_SzOvywUQjoQZpg,4046
 rest/settings_helper.py,sha256=_Vn9nmL5_GPss9zIsXzacbTQkn99NbO42CqvOZC3ge4,1532
 rest/ssl_check.py,sha256=kH4Pk4upUEwKTAnBLR0DIKezNJHjkW3g2TdQAObEgW4,1419
 rest/static/lib/jquery.js,sha256=VAvG3sHdS5LqTT-5A_aeq_bZGa_Uj04xKxY8KM_w9EE,95786
@@ -445,7 +446,7 @@ rest/templates/rest_html.html,sha256=utOzvXEE6LiHFUvcAQUDOQ0yl3J_2F3-22r0K611eTQ
 rest/ua.py,sha256=0wwOtJPWCiCxUKzWKyMApRbSaiuAxCCk0Pe3OwzYBhE,185398
 rest/uberdict.py,sha256=ivDpzfchQqX8dM2_TtuyMW7NNO-j7zDmxkdKixQxvU4,17064
 rest/url_docs.py,sha256=O8O_CQso3fB-7o-huidIT1BRGv5R6lDW-yKHnsGyAPk,11881
-rest/urls.py,sha256=HkmRhZVpOpzJDt6fZ16SJ54WBq34E15nt3cJ8qg-e8I,1870
+rest/urls.py,sha256=MGMTDU_SN5ZO3HeomFsE6szKnMzE_X9vzh_J0YL0KGA,1866
 rest/views.py,sha256=WUjHQMCzw2f4Te2X4Kh40ksfoVAAlrWC2pbt8nhcIYA,1115
 sessionlog/.gitignore,sha256=TbEvWRMnAiajCTOdhiNrd9eeCAaIjRp9PRjE_VkMM5g,118
 sessionlog/README.md,sha256=vQEVJ_8u3Vv19VwPfscjCiHFu61ZSrEM-KIuBpUXhws,62
@@ -461,7 +462,7 @@ taskqueue/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 taskqueue/admin.py,sha256=E6zXoToS_ea3MdoGjZzF1JiepWFtDSoZUQdan8H-pXI,208
 taskqueue/migrations/0001_initial.py,sha256=JwYib8CK5ftSXlfxKZUcKEEVsXktNB5q3h-2tu9inGk,4738
 taskqueue/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-taskqueue/models.py,sha256=aRy5TFc2zAu6xcb3jcMf-bfma-dmrh55hQoktCLT0Us,23894
+taskqueue/models.py,sha256=XqgQDKaxKAfqSkom0VF2HeUwFXpvM46ikZdvKXUKAz8,23843
 taskqueue/periodic.py,sha256=hpXnunJL_cuVQLAKpjTbABbsQ4fvdsV9_gyyK-_53Sk,3844
 taskqueue/rpc.py,sha256=Lf5VUoqCRkfWUAIvx_s508mjAtDPwpiWyxg0ryqWbQA,5793
 taskqueue/tq.py,sha256=PzSoDrawYcqZylruEgsK95gcJ4J_VhdM6rxg9V6_X8E,942
@@ -471,7 +472,7 @@ taskqueue/transports/http.py,sha256=AzliUnw_LuyO2zZZOoUAJGFcTV-Gxt1iE3hCVnIiyGQ,
 taskqueue/transports/s3.py,sha256=fMosL893u1iQdo6Y1djwb7KEoNo6TTsDPJl13OJdJP8,1913
 taskqueue/transports/sftp.py,sha256=jT1_krjTHA7DCAukD85aGYRCg9m0cEH9EWzOC-wJGdk,1891
 taskqueue/transports/sms.py,sha256=H1-LIGEMfbUNqJD9amRcsvKUSwtz9yBj1QNfB7EHjHE,142
-taskqueue/worker.py,sha256=641Z6C9JTps0mx99JiqnnCrhkfmeqs4AE-zuJh6B6jA,15699
+taskqueue/worker.py,sha256=H7KfcIj-lNd8K5Wn7tlw4rXYPqVdkxv2B5X5kbEcIbk,16054
 telephony/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 telephony/admin.py,sha256=iOdsBfFFbBisdqKSZ36bIrh_z5sU0Wx_PkaFi8wd1iA,243
 telephony/decorators.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -515,7 +516,7 @@ ws4redis/servers/uwsgi.py,sha256=VyhoCI1DnVFqBiJYHoxqn5Idlf6uJPHvfBKgkjs34mo,172
 ws4redis/settings.py,sha256=KKq00EwoGnz1yLwCZr5Dfoq2izivmAdsNEEM4EhZwN4,1610
 ws4redis/utf8validator.py,sha256=S0OlfjeGRP75aO6CzZsF4oTjRQAgR17OWE9rgZdMBZA,5122
 ws4redis/websocket.py,sha256=R0TUyPsoVRD7Y_oU7w2I6NL4fPwiz5Vl94-fUkZgLHA,14848
-django_restit-4.2.172.dist-info/LICENSE.md,sha256=VHN4hhEeVOoFjtG-5fVv4jesA4SWi0Z-KgOzzN6a1ps,1068
-django_restit-4.2.172.dist-info/METADATA,sha256=iGWUZqAmN7YQzXkMWtkuODNttINTNwwqseRaOrJpbfE,7714
-django_restit-4.2.172.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-django_restit-4.2.172.dist-info/RECORD,,
+django_restit-4.2.174.dist-info/LICENSE.md,sha256=VHN4hhEeVOoFjtG-5fVv4jesA4SWi0Z-KgOzzN6a1ps,1068
+django_restit-4.2.174.dist-info/METADATA,sha256=r1t8GFE4qKAq75b6CnYkpJCE6BbfW7-t2qt2dy-XkaA,7714
+django_restit-4.2.174.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+django_restit-4.2.174.dist-info/RECORD,,

incident/models/event.py

@@ -18,8 +18,8 @@ INCIDENT_EVENT_GRANULARITY = settings.get("INCIDENT_EVENT_GRANULARITY", "hourly"
 EVENT_TO_INCIDENT_LEVEL = settings.get("EVENT_TO_INCIDENT_LEVEL", 4)
 EVENT_DETAIL_TEMPLATES = settings.get("EVENT_DETAIL_TEMPLATES", None)
 EVENT_META_KEYWORDS = settings.get("EVENT_META_KEYWORDS", [
-        "path", "ip", "reporter_ip", "code", 
-        "reason", "buid", "merchant", "tid", 
+        "path", "ip", "reporter_ip", "code",
+        "reason", "buid", "merchant", "tid",
         "group", "http_user_agent", "user_agent",
         "app_url", "isp", "city", "state", "country",
         "username"
@@ -28,7 +28,7 @@ EVENT_META_KEYWORDS = settings.get("EVENT_META_KEYWORDS", [
 logger = log.getLogger("incident", filename="incident.log")
 
 """
-very generic 
+very generic
 external system can post an event
 {
      "description": "Critical Test Event",
@@ -77,15 +77,15 @@ class Event(JSONMetaData, rm.RestModel):
     # code = models.IntegerField(default=0, db_index=True)
 
     group = models.ForeignKey(
-        "account.Group", on_delete=models.SET_NULL, 
+        "account.Group", on_delete=models.SET_NULL,
         related_name="+", null=True, default=None)
- 
+
     component = models.SlugField(max_length=250, null=True, blank=True, default=None)
     component_id = models.IntegerField(null=True, blank=True, default=None)
 
     # this allows us to bundle multiple events to an incident
     incident = models.ForeignKey(
-        Incident, null=True, default=None, 
+        Incident, null=True, default=None,
         related_name="events", on_delete=models.SET_NULL)
 
     def runRules(self):
@@ -170,14 +170,14 @@ class Event(JSONMetaData, rm.RestModel):
             # logger.info(f"ignore event {self.pk} {self.description}")
             return
 
-        # always create an incident 
+        # always create an incident
         if incident is None:
             incident = Incident(
                 rule=hit_rule, priority=priority,
                 reporter_ip=self.reporter_ip,
                 category=self.category,
                 group=self.group,
-                component=self.component, 
+                component=self.component,
                 component_id=self.component_id,
                 hostname=self.hostname)
             if self.group is None and hit_rule is not None:
@@ -211,4 +211,3 @@ class Event(JSONMetaData, rm.RestModel):
             incident.triggerAction()
         except Exception:
             logger.exception()
-

incident/models/incident.py

@@ -92,7 +92,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
 
     group = models.ForeignKey("account.Group", on_delete=models.SET_NULL, null=True, default=None)
     assigned_to = models.ForeignKey("account.Member", on_delete=models.SET_NULL, null=True, default=None)
-    
+
     priority = models.IntegerField(default=0)  # 1-10, 1 being the highest
     # 0=new, 1=opened, 2=paused, 3=ignore, 4=resolved, 5=pending
     state = models.IntegerField(default=0, choices=INCIDENT_STATES)
@@ -160,7 +160,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
 
         if event.details:
             self.setProperty("details", event.details)
-    
+
         if event.metadata.geoip and event.metadata.geoip.city:
             self.setProperty("city", event.metadata.geoip.city)
             self.setProperty("state", event.metadata.geoip.state)
@@ -209,7 +209,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
                 self.save()
             elif self.rule.action.startswith("firewall_block"):
                 if settings.FIREWALL_GLOBAL_BLOCK:
-                    Task.Publish("incident", "firewall_block", 
+                    Task.Publish("incident", "firewall_block",
                                  dict(ip=self.reporter_ip),
                                  channel="tq_broadcast")
 
@@ -348,7 +348,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
             member.sendSMS(sms_msg)
         members = group.getMembers(perms=email_perms, as_member=True)
         for member in members:
-            member.sendEmail(subject, body)       
+            member.sendEmail(subject, body)
 
     def notifyWith(self, perm):
         # logger.info("notifyWith", perm)
@@ -407,7 +407,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
             if request != None and "DATA" in request and "note" in request.DATA:
                 self.logHistory(kind="note", note=request.DATA.get("note"), request=request)
 
-    def logHistory(self, kind="history", note=None, media=None, 
+    def logHistory(self, kind="history", note=None, media=None,
                    request=None, member=None, notify=True):
         if request is None:
             request = self.getActiveRequest()
@@ -493,7 +493,7 @@ class Incident(models.Model, rm.RestModel, rm.MetaDataModel):
                 email_only=True,
                 from_email=INCIDENT_EMAIL_FROM)
         else:
-            # notitfy everyone but the sender          
+            # notitfy everyone but the sender
             if history.by is None:
                 members = Member.GetWithPermission(perm, ignore_disabled_email=True).exclude(pk=history.by.pk)
                 if members.count() == 0:

incident/models/ossec.py

@@ -46,8 +46,8 @@ class ServerOssecAlert(models.Model, rm.RestModel):
     level       = models.IntegerField(default=0)
     title       = models.CharField(max_length=200, blank=True, null=True, default=None)
     geoip       = models.ForeignKey("location.GeoIP", blank=True, null=True, default=None, on_delete=models.DO_NOTHING)
-    
+
     metadata = None
-    
+
     def __str__(self):
         return f'{self.hostname}: {self.title}'

metrics/models.py

@@ -43,14 +43,14 @@ def metric(
         elif granularity in ["minutes", "seconds"]:
             expires = datetime.now() + timedelta(days=7)
         m, created = Metrics.objects.get_or_create(
-            uuid=key, 
+            uuid=key,
             defaults=dict(
                 granularity=granularity, slug=slug, expires=expires,
                 group=group, start=utils.date_for_granulatiry(date, granularity)))
         m.updateMetrics(keys, data, created)
 
 
-def gauge(slug, keys, data, granularity="daily", group=None, date=None, 
+def gauge(slug, keys, data, granularity="daily", group=None, date=None,
           timezone=None, slug_append=None, max_granularity=None):
     # guage does not accumulate but just stores the data like a cache
     # if calledf on the same time period it will just update the current numbers
@@ -72,7 +72,7 @@ def gauge(slug, keys, data, granularity="daily", group=None, date=None,
         elif gran == "daily":
             expires = datetime.now() + timedelta(days=METRICS_EXPIRE_DAILY)
         m, created = Metrics.objects.get_or_create(
-            uuid=key, 
+            uuid=key,
             defaults=dict(
                 granularity=gran, slug=slug, expires=expires,
                 group=group, start=utils.date_for_granulatiry(date, gran)))
@@ -99,7 +99,7 @@ def get_qset(slug, granularity, start=None, end=None,
         start = group.getLocalTime(start)
     elif settings.METRICS_TIMEZONE:
         start = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, start)
-  
+
     start = utils.date_for_granulatiry(start, granularity)
     if end is None:
         if granularity == "hourly":
@@ -133,7 +133,7 @@ def get_totals(slug, keys, granularity, start=None, end=None, group=None):
         start = group.getLocalTime(start)
     elif settings.METRICS_TIMEZONE:
         start = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, start)
-  
+
     start = utils.date_for_granulatiry(start, granularity)
     if end is None:
         end = start + timedelta(minutes=5)
@@ -141,7 +141,7 @@ def get_totals(slug, keys, granularity, start=None, end=None, group=None):
         end = group.getLocalTime(end)
     elif settings.METRICS_TIMEZONE:
         end = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, end)
-    
+
     qset = Metrics.objects.filter(
         slug=slug, granularity=granularity,
         group=group, start__gte=start, start__lte=end)
@@ -162,7 +162,7 @@ def get_metric(slug, granularity, start, group=None):
         start = group.getLocalTime(start)
     elif settings.METRICS_TIMEZONE:
         start = date_util.convertToLocalTime(settings.METRICS_TIMEZONE, start)
-  
+
     start = utils.date_for_granulatiry(start, granularity)
     qset = Metrics.objects.filter(
         slug=slug, granularity=granularity, start__gte=start, start__lte=start, group=group)
@@ -226,7 +226,7 @@ def get_metrics(slug, granularity, start, end=None, group=None, samples=None):
             for k in keys:
                 data[k].append(0)
             continue
-        for k in keys: 
+        for k in keys:
             data[k].append(result["values"].get(k, 0))
         period_values.remove(result)
     return objict(periods=periods, data=data)
@@ -241,7 +241,7 @@ def get_chart_periods(slug, granularity, start, end=None, group=None):
         periods.append(period)
     if granularity != "weekly":
         periods.reverse()
-    return periods   
+    return periods
 
 
 def get_adjusted_date_range(granularity, start, end, group=None, samples=None):
@@ -282,6 +282,7 @@ def generate_uuid(slug, group, slug_append=None):
 class Metrics(models.Model, rm.RestModel):
     class RestMeta:
         QUERY_FIELDS = ["group__kind", "all_fields"]
+        ESTIMATE_COUNTS = True
         GRAPHS = {
             "detailed": {
                 "fields": [
@@ -310,7 +311,7 @@ class Metrics(models.Model, rm.RestModel):
     # allow to group metrics by a group
     group = models.ForeignKey("account.Group", related_name="+", on_delete=models.CASCADE, null=True, default=None)
 
-    # now we create a set of k/v 
+    # now we create a set of k/v
     k1 = models.SlugField(max_length=64, null=True, default=None)
     v1 = models.BigIntegerField(default=0)
 

rest/__init__.py

@@ -1,4 +1,4 @@
 from .uberdict import UberDict  # noqa: F401
 from .settings_helper import settings  # noqa: F401
 
-__version__ = "4.2.172"
+__version__ = "4.2.174"

rest/models/base.py

@@ -7,6 +7,7 @@ import importlib
 from django.db import models as dm
 from django.db.transaction import atomic
 from django.apps import apps
+from django.db import connection
 
 from rest import helpers as rh
 from rest import errors as re
@@ -876,7 +877,7 @@ class RestModel(object):
         if not graph and request is not None:
             graph = request.DATA.get("graph", "default")
         return GRAPH_HELPERS.restList(
-            request, qset, sort=sort, totals=totals, 
+            request, qset, sort=sort, totals=totals,
             return_httpresponse=return_httpresponse,
             response_params=dict(graph=graph),
             **cls.getGraph(graph))
@@ -896,6 +897,17 @@ class RestModel(object):
             request = cls.getActiveRequest()
         return cls.restList(request, qset, graph, totals, False)
 
+    @classmethod
+    def restListEstimatedCount(cls, request, qset):
+        # TODO attempt to make this work with the qset,
+        # right now it gets an estimated count of the entire table
+        if getattr(cls.RestMeta, "ESTIMATE_COUNTS", False):
+            if connection.vendor == 'postgresql':
+                with connection.cursor() as cursor:
+                    cursor.execute(f"SELECT reltuples::bigint FROM pg_class WHERE relname = '{cls._meta.db_table}'")
+                    return cursor.fetchone()[0]
+        return qset.count()
+
     def restStatus(self, request, status, **kwargs):
         RestModel._setupGraphHelpers()
         return GRAPH_HELPERS.restStatus(request, status, **kwargs)
@@ -959,7 +971,7 @@ class RestModel(object):
         has_perms = True
         if perms is not None:
             has_perms = cls.on_rest_list_has_perms(request, perms, qset)
-        
+
         if request.group:
             qset = cls.on_rest_filter_children(request, qset)
         if not has_perms:
@@ -1040,7 +1052,7 @@ class RestModel(object):
         elif dr_offset > 0:
             dr_start = dr_start + timedelta(minutes=dr_offset)
             dr_end = dr_end + timedelta(minutes=dr_offset)
-    
+
         rh.debug("tr_end changing", str(dr_start), str(dr_end))
         dr_field = request.DATA.get("dr_field", getattr(cls.RestMeta, "DATE_RANGE_FIELD", "created"))
         q = dict()
@@ -1145,7 +1157,7 @@ class RestModel(object):
             cls._boundRest()
             if format.startswith("json"):
                 return GRAPH_HELPERS.views.restJSON(
-                    request, qset, fields, 
+                    request, qset, fields,
                     name, format_size, localize=localize)
             elif format.startswith("csv"):
                 return GRAPH_HELPERS.views.restCSV(
@@ -1159,7 +1171,7 @@ class RestModel(object):
                 return GRAPH_HELPERS.views.restFlat(
                     request, qset, fields,
                     name, format_size, localize=localize)
-    
+
     @classmethod
     def on_rest_list_summary(cls, request, qset):
         cls._boundRest()
@@ -1589,7 +1601,7 @@ class RestModel(object):
                 "group": "group__kind"
             }
 
-        QUERY_FIELDS can be used to restrict what fields can be queried 
+        QUERY_FIELDS can be used to restrict what fields can be queried
         and add special fields:
 
         ?group__kind=iso
@@ -1600,7 +1612,7 @@ class RestModel(object):
         or
         <field_name>__<operator>=value
 
-        You cannot do <field_name>__<sub_field>__<operator> unless 
+        You cannot do <field_name>__<sub_field>__<operator> unless
          <field_name>__<sub_field> is
 
         allowed <operator>s

rest/requestex.py

@@ -18,12 +18,12 @@ SAFE_ASCII = set(string.printable)
 def createFakeRequest(method="GET", **kwargs):
     member = kwargs.get("member", objict(is_authenticated=True, is_staff=True, is_superuser=True))
     return objict(
-        META={}, 
+        META={},
         user=member,
         member=member,
         group=kwargs.get("group", None),
-        method=method, 
-        _started=0, 
+        method=method,
+        _started=0,
         DATA=RequestData(data=kwargs))
 
 
@@ -284,7 +284,6 @@ class RequestData(object):
             if value == '':
                 if field_type in [int, float]:
                     return field_type(0)
-
             if field_type in [int, str, float, str]:
                 value = field_type(value)
             elif field_type is datetime:

rest/serializers/response.py

@@ -1,6 +1,8 @@
 from django.http import HttpResponse
 from django.shortcuts import render
 from django.db.models.query import QuerySet
+from django.core.cache import cache
+import hashlib
 
 from rest import settings
 from version import VERSION
@@ -13,6 +15,27 @@ from . import csv
 from . import excel
 # from . import profiler
 STATUS_ON_PERM_DENIED = settings.get("STATUS_ON_PERM_DENIED", 403)
+REST_LIST_CACHE_COUNT = settings.get("REST_LIST_CACHE_COUNT", True)
+
+
+def get_query_hash(queryset):
+    """Generate a unique hash based on the queryset's SQL query and params."""
+    sql_query = str(queryset.query)
+    return hashlib.sha256(sql_query.encode()).hexdigest()
+
+
+def get_cached_count(queryset, hash=None, timeout=1800):
+    """
+    Retrieves the cached count for a queryset or calculates & caches it.
+    """
+    if hash is None:
+        hash = get_query_hash(queryset)
+    cache_key = f"rest_hash_{hash}"
+    count = cache.get(cache_key)
+    if count is None:
+        count = queryset.count()
+        cache.set(cache_key, count, timeout=timeout)
+    return count
 
 
 def restStatus(request, status, data={}, **kwargs):
@@ -41,13 +64,20 @@ def restGet(request, obj, fields=None, extra=[], exclude=[], recurse_into=[], **
     data["elapsed"] = get_request_elapsed(request)
     return restResult(request, data)
 
+
 # @profiler.timeit
 def restList(request, qset, size=25, start=0, sort=None, fields=None, extra=[], exclude=[], recurse_into=[], **kwargs):
-    count = 0
-    if isinstance(qset, QuerySet):
-        count = qset.count()
-    elif isinstance(qset, list):
-        count = len(qset)
+    count = kwargs.get('count', 0)
+    hash = None
+    if count == 0:
+        if isinstance(qset, QuerySet):
+            if REST_LIST_CACHE_COUNT and not request.DATA.get("no_cache", False):
+                hash = get_query_hash(qset)
+                count = get_cached_count(qset, hash)
+            else:
+                count = qset.count()
+        elif isinstance(qset, list):
+            count = len(qset)
     start = request.DATA.get("start", start, field_type=int)
     size = request.DATA.get("size", size, field_type=int)
     sort = request.DATA.get("sort", sort)
@@ -56,6 +86,8 @@ def restList(request, qset, size=25, start=0, sort=None, fields=None, extra=[],
     data["datetime"] = int(time.time())
     data["elapsed"] = get_request_elapsed(request)
     data["count"] = count
+    if hash is not None:
+        data["hash"] = hash
     if "response_params" in kwargs:
         for k, v in kwargs.get("response_params").items():
             data[k] = v

rest/service.py

@@ -0,0 +1,135 @@
+import os
+import signal
+import time
+import argparse
+import logging
+import daemon
+from daemon import pidfile
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+
+class Service(FileSystemEventHandler):
+    def __init__(self, name, pid_file, watch_file=None, require_user=None, logger=None):
+        self.name = name
+        self.pid_file = pid_file
+        self.watch_file = os.path.realpath(watch_file) if watch_file else None
+        self.require_user = require_user
+        self.observer = None
+
+    def log_info(self, *args):
+        if self.logger:
+            self.log_info(*args)
+
+    def start(self):
+        if self.is_running():
+            self.log_info("Service is already running.")
+            return
+
+        self.log_info(f"Starting {self.name}...")
+
+        with daemon.DaemonContext(
+            pidfile=pidfile.TimeoutPIDLockFile(self.pid_file),
+            stdout=open('/tmp/service.log', 'a+'),
+            stderr=open('/tmp/service_error.log', 'a+'),
+            signal_map={
+                signal.SIGTERM: self.stop,
+                signal.SIGHUP: self.restart
+            }
+        ):
+            self.run()
+
+    def stop(self, *args):
+        pid = self.get_pid()
+        if not pid:
+            self.log_info("Service is not running.")
+            return
+
+        self.log_info(f"Stopping {self.name} (PID: {pid})...")
+        try:
+            os.kill(pid, signal.SIGTERM)
+            time.sleep(1)
+            if self.is_running():
+                os.kill(pid, signal.SIGKILL)
+            if os.path.exists(self.pid_file):
+                os.remove(self.pid_file)
+            self.log_info("Service stopped.")
+        except OSError:
+            self.logger.error(f"Failed to stop process {pid}")
+
+    def restart(self, *args):
+        self.log_info("Restarting service...")
+        self.stop()
+        time.sleep(1)
+        self.start()
+
+    def status(self):
+        if self.is_running():
+            print(f"{self.name} is running (PID: {self.get_pid()})")
+        else:
+            print(f"{self.name} is not running")
+
+    def is_running(self):
+        """Check if the process is running using os.kill(pid, 0)"""
+        pid = self.get_pid()
+        if pid:
+            try:
+                os.kill(pid, 0)  # Does not kill, just checks if process exists
+                return True
+            except OSError:
+                return False
+        return False
+
+    def get_pid(self):
+        if os.path.exists(self.pid_file):
+            try:
+                with open(self.pid_file, "r") as f:
+                    pid = int(f.read().strip())
+                return pid
+            except ValueError:
+                return None
+        return None
+
+    def run(self):
+        """Main daemon loop"""
+        self.log_info(f"{self.name} is running in background.")
+        if self.watch_file:
+            self.start_watcher()
+        self.on_run()
+
+    def on_run(self):
+        while True:
+            time.sleep(5)
+
+    def start_watcher(self):
+        self.log_info(f"Watching file: {self.watch_file}")
+        self.observer = Observer()
+        self.observer.schedule(self, path=os.path.dirname(self.watch_file), recursive=False)
+        self.observer.start()
+
+    def on_modified(self, event):
+        if self.watch_file and event.src_path == self.watch_file:
+            self.log_info("Config file changed, restarting service...")
+            self.restart()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Manage the service daemon")
+    parser.add_argument("command", choices=["start", "stop", "restart", "status", "run"])
+    args = parser.parse_args()
+
+    service = Service(name="MyDaemon", pid_file="/tmp/mydaemon.pid")
+
+    if args.command == "start":
+        service.start()
+    elif args.command == "stop":
+        service.stop()
+    elif args.command == "restart":
+        service.restart()
+    elif args.command == "status":
+        service.status()
+    elif args.command == "run":
+        service.run()
+
+if __name__ == "__main__":
+    main()

rest/urls.py

@@ -63,7 +63,3 @@ for app in settings.INSTALLED_APPS:
             sub_modules = getattr(module, "RPC_MODULES")
             for m in sub_modules:
                 load_app(m, module)
-
-
-
-

taskqueue/models.py

@@ -166,8 +166,8 @@ class Task(models.Model, RestModel):
             self.retry_now()
         elif value == "cancel":
             request = self.getActiveRequest()
-            self.reason = "cancel request by {}".format(request.member.username)
-            self.cancel(request.DATA.get("reason", "canceled by {}".format(request.member.username)))
+            self.reason = f"cancel request by {request.member.username}"
+            self.cancel(request.DATA.get("reason", f"canceled by {request.member.username}"))
 
     # def auditlog(self, action, message, request=None, path=None, component="taskqueue.Task"):
     #     # message, level=0, request=None, component=None, pkey=None, action=None, group=None, path=None, method=None
@@ -183,7 +183,7 @@ class Task(models.Model, RestModel):
                 level = 21
             elif kind == "error":
                 level = 17
-            PLOG.log(message=text, action=f"taskqueue_{kind}", 
+            PLOG.log(message=text, action=f"taskqueue_{kind}",
                      level=level,
                      method=self.fname, path=self.model,
                      tid=self.data.log_tid,
@@ -290,7 +290,7 @@ class Task(models.Model, RestModel):
         try:
             import incident
             incident.event_now(
-                category, description=subject, details=msg, 
+                category, description=subject, details=msg,
                 level=3, **metadata)
         except Exception as err:
             self.log(str(err), kind="error")
@@ -395,7 +395,7 @@ class Task(models.Model, RestModel):
         task.save()
         task.publish()
         return task
-    
+
     @classmethod
     def S3Request(cls, bucket, data, folder, aws, secret, filename, when,
                   log_component=None, log_pk=None, log_tid=None):
@@ -458,7 +458,6 @@ class TaskWorkerClient:
         uid = crypto.randomString(16)
         self.recv_channel = f"tq:{uid}:{settings.HOSTNAME}"
         self.send_channel = f"tq:host:{hostname}"
-            
         self.client = None
         self.pubsub = None
 
@@ -480,7 +479,7 @@ class TaskWorkerClient:
         data["hostname"] = settings.HOSTNAME
         data["response_channel"] = self.recv_channel
         redis.publish(
-            self.send_channel, 
+            self.send_channel,
             data, self.client)
 
     def recv(self, timeout=5.0):
@@ -492,7 +491,7 @@ class TaskWorkerClient:
         if msg.data:
             msg.data = nobjict.fromJSON(msg.data)
         return msg.data
-            
+
     def ping(self):
         start = time.perf_counter()
         self.send(dict(action="ping"))
@@ -644,6 +643,3 @@ class TaskHook(models.Model, RestModel, MetaDataModel):
 
 class TaskHookMetaData(MetaDataBase):
     parent = models.ForeignKey(TaskHook, related_name="properties", on_delete=models.CASCADE)
-
-
-

taskqueue/worker.py

@@ -46,23 +46,23 @@ class WorkManager(object):
         self.lock = threading.RLock()
         if not self.logger:
             self.logger = getLogger("root", filename="tq_worker.log")
-        self.logger.info("starting manager, workers: {}".format(self.worker_count))
-        self.logger.info("handling: {}".format(self.subscribe_to))
+        self.logger.info(f"starting manager, workers: {self.worker_count}")
+        self.logger.info(f"handling: {self.subscribe_to}")
         if USE_THREADS:
             self._pool = futures.ThreadPoolExecutor(max_workers=self.worker_count)
         else:
             self._pool = futures.ProcessPoolExecutor(max_workers=self.worker_count)
 
     def updateCounts(self):
-        self.logger.info("running: {} --- pending: {}".format(self._running_count, self._pending_count))
+        self.logger.info(f"running: {self._running_count} --- pending: {self._pending_count}")
 
     def addTask(self, task):
         if task.is_stale:
-            self.logger.warning("task({}) is now stale".format(task.id))
+            self.logger.warning(f"task({task.id}) is now stale")
             task.failed("stale")
             return
         if task.id in self._scheduled_tasks:
-            self.logger.error("task({}) is already scheduled".format(task.id))
+            self.logger.error(f"task({task.id}) is already scheduled")
             return
         task.manager = self
         with self.lock:
@@ -76,7 +76,7 @@ class WorkManager(object):
         # self.logger.info("processing event", event)
         if event.type == "subscribe":
             # confirmation we subscribed
-            self.logger.info("succesfully subscribed to: {}".format(event.channel))
+            self.logger.info(f"succesfully subscribed to: {event.channel}")
             return
 
         self.logger.info(f"new_event@{event.channel}")
@@ -84,10 +84,10 @@ class WorkManager(object):
         if event.channel == "tq_restart":
             self.restart()
             return
-        
+
         if event.data:
             event.data = nobjict.fromJSON(event.data)
-        
+
         if event.channel == self.host_channel:
             self.on_host_event(event)
             return
@@ -118,7 +118,7 @@ class WorkManager(object):
         cached_task = self._scheduled_tasks.get(task.id, None)
         if not cached_task:
             # task is not scheduled
-            self.logger.warning("canceling non scheduled task({})".format(task.id))
+            self.logger.warning(f"canceling non scheduled task({task.id})")
             task.state = -2
             task.reason = reason
             task.save()
@@ -130,11 +130,11 @@ class WorkManager(object):
         task = cached_task
         if task.future.running():
             # right now we don't support canceling a running task but we will try!
-            self.logger.warning("attempting to stop running task({})".format(task.id))
+            self.logger.warning(f"attempting to stop running task({task.id})")
             if self.killWorker(task._thread_id):
                 time.sleep(2.0)
                 if task.future.done():
-                    self.logger.info("succesfully killed task({}@{})".format(task.id, task._thread_id))
+                    self.logger.info(f"succesfully killed task({task.id}@{task._thread_id})")
                     task.state = -2
                     task.reason = reason
                     task.save()
@@ -144,14 +144,14 @@ class WorkManager(object):
                 self.logger.warning("failed to kill worker")
         else:
             if task.future.cancel():
-                self.logger.info("succesfully canceled task({})".format(task.id))
+                self.logger.info(f"succesfully canceled task({task.id})")
                 task.state = -2
                 task.reason = reason
                 task.save()
                 self.removeTask(task)
                 return
             else:
-                self.logger.error("failed to cancel task({})".format(task.id))
+                self.logger.error(f"failed to cancel task({task.id})")
 
     def killWorker(self, thread_id):
         import ctypes
@@ -175,16 +175,16 @@ class WorkManager(object):
         for task in tasks:
             if task.channel in self.subscribe_to:
                 if task.cancel_requested:
-                    self.logger.info("task has cancel request {}".format(task.id))
+                    self.logger.info(f"task has cancel request {task.id}")
                     task.state = -2
                     if not task.reason:
                         task.reason = "task canceled"
                     task.save()
                     continue
-                self.logger.debug("resubmitting job {}".format(task.id))
+                self.logger.debug(f"resubmitting job {task.id}")
                 self.addTask(task)
             else:
-                self.logger.warning("ignore job {}:{}".format(task.id, task.channel))
+                self.logger.warning(f"ignore job {task.id}:{task.channel}")
 
     def _on_webrequest(self, task):
         if http.REQUEST(task):
@@ -198,6 +198,7 @@ class WorkManager(object):
             task.failed("max attempts")
 
     def _on_hookrequest(self, task):
+        resp = None
         if task.model == "tq_email_request":
             resp = email.SEND(task)
         elif task.model == "tq_sms_request":
@@ -223,7 +224,7 @@ class WorkManager(object):
             redis.publish(
                 event.data.response_channel,
                 dict(action="restarting", hostname=settings.HOSTNAME))
-            self.restart() 
+            self.restart()
         elif action == "get_stats":
             data = nobjict(action="stats", hostname=settings.HOSTNAME)
             data.uptime = time.time() - self.started_at
@@ -240,84 +241,108 @@ class WorkManager(object):
             task.worker_running = True
             self._running_count += 1
             self._pending_count -= 1
+            # remove the task from scheduled
+            del self._scheduled_tasks[task.id]
             self.updateCounts()
 
     def on_task_ended(self, task):
         with self.lock:
             task.worker_running = False
-            del self._scheduled_tasks[task.id]
             self._running_count -= 1
             self.updateCounts()
 
     def on_run_task(self, task):
-        self.logger.info("running task({})".format(task.id))
+        """ Handles execution of a task with structured error handling and refactored logic. """
 
-        # check if its canceled
+        self.logger.info(f"running task({task.id})")
+
+        # Start task and handle cancel/stale conditions early
+        if not self._initialize_task(task):
+            return
+
+        # Get the appropriate handler for the task
+        handler = self._get_task_handler(task)
+        if handler is None:
+            task.failed("failed to find handler")
+            return self._end_task(task)
+
+        # Execute task
+        self._execute_task(task, handler)
+
+    def _initialize_task(self, task):
+        """ Initializes task and checks if it should run. Returns False if the task should stop. """
         try:
             self.on_task_started(task)
             task.refresh_from_db()
             task._thread_id = threading.current_thread().ident
-            self.logger.debug("running on thread:{}".format(task._thread_id))
+            self.logger.debug(f"running on thread:{task._thread_id}")
+
             if task.state not in [0, 1, 2, 10] or task.cancel_requested:
-                self.logger.info("task({}) was canceled?".format(task.id))
-                self.on_task_ended(task)
-                return
+                self.logger.info(f"task({task.id}) was canceled?")
+                return self._end_task(task)
 
             if task.is_stale:
-                self.logger.warning("task({}) is now stale".format(task.id))
+                self.logger.warning(f"task({task.id}) is now stale")
                 task.failed("stale")
-                self.on_task_ended(task)
-                return
+                return self._end_task(task)
+
+            return True
         except Exception as err:
             self.logger.exception(err)
-            return
+            return False
 
-        handler = None
-        if task.model == "tq_web_request":
-            handler = self._on_webrequest
-        elif task.model in ["tq_sftp_request", "tq_email_request", "tq_sms_request", "tq_s3_request"]:
-            handler = self._on_hookrequest
-        else:
-            try:
-                handler = task.getHandler()
-            except Exception as err:
-                self.logger.exception(err)
-                task.log_exception(err)
-                task.failed(str(err))
-                self.on_task_ended(task)
-                return
+    def _get_task_handler(self, task):
+        """ Determines the appropriate handler for the task. """
+        task_handlers = {
+            "tq_web_request": self._on_webrequest,
+            "tq_sftp_request": self._on_hookrequest,
+            "tq_email_request": self._on_hookrequest,
+            "tq_sms_request": self._on_hookrequest,
+            "tq_s3_request": self._on_hookrequest,
+        }
 
-        if handler is None:
-            self.logger.error("failed to find handler: task({})".format(task.id))
-            task.failed("failed to find handler")
-            self.on_task_ended(task)
-            return
+        handler = task_handlers.get(task.model)
+        if handler:
+            return handler
+
+        try:
+            return task.getHandler()
+        except Exception as err:
+            self.logger.exception(err)
+            task.log_exception(err)
+            task.failed(str(err))
+            self._end_task(task)
+            return None
 
-        # self.logger.debug("task.started()")
+    def _execute_task(self, task, handler):
+        """ Runs the task handler and manages exceptions. """
         task.started()
         try:
-            # self.logger.debug("task({}) calling handler".format(task.id))
             handler(task)
             if task.state == TASK_STATE_STARTED:
                 task.completed()
-            # self.logger.debug("task({}) handler finished".format(task.id))
         except Exception as err:
-            self.logger.exception(err, "task({}) had exception".format(task.id))
-            task.log_exception(err)
-            if "connection already closed" in str(err).lower():
-                # this is a nasty little bug in django when forking django db connections
-                # we will schedule the task to retry later
-                task.retry_later()
-                # let us try and close db connections?
-                hack_closeDjangoDB()
-                # or should we restart the task queue?
-            else:
-                task.failed(str(err))
+            self._handle_task_exception(task, err)
         except SystemExit:
-            self.logger.error("task({}) was killed".format(task.id))
+            self.logger.error(f"task({task.id}) was killed")
         finally:
-            self.on_task_ended(task)
-        self.logger.info("task({}) finished with state {}".format(task.id, task.state))
+            self._end_task(task)
+
+    def _handle_task_exception(self, task, err):
+        """ Handles exceptions during task execution. """
+        self.logger.exception(f"task({task.id}) had exception: {err}")
+        task.log_exception(err)
+
+        if "connection already closed" in str(err).lower():
+            task.retry_later()
+            hack_closeDjangoDB()
+        else:
+            task.failed(str(err))
+
+    def _end_task(self, task):
+        """ Ensures proper cleanup and logging at the end of the task. """
+        self.on_task_ended(task)
+        self.logger.info(f"task({task.id}) finished with state {task.state}")
 
     def run_forever(self):
         self.logger.info("starting work manager...")
@@ -354,7 +379,7 @@ class WorkManager(object):
         if self.host_channel not in self.subscribe_to:
             self.subscribe_to.append(self.host_channel)
         for key in self.subscribe_to:
-            self.logger.info("subscribing to: {}".format(key))
+            self.logger.info(f"subscribing to: {key}")
             self.pubsub.subscribe(key)
         self.pubsub.subscribe("tq_cancel")
         self.pubsub.subscribe("tq_restart")
@@ -394,7 +419,7 @@ class WorkManager(object):
         except Exception as err:
             self.logger.exception(err)
 
-        self.logger.info("waiting for {} running tasks, timeout: {}".format(self._running_count, timeout))
+        self.logger.info(f"waiting for {self._running_count} running tasks, timeout: {timeout}")
         time.sleep(1.0)
         self.__close()
         timeout_at = time.time() + timeout
@@ -420,5 +445,3 @@ def hack_closeDjangoDB():
     from django.db import connections
     for conn in connections.all():
         conn.close_if_unusable_or_obsolete()
-
-