docs: def AssignTasksToClient(self, client_id):
      """Examines our rules and starts up flows based on the client.
  
      Args:
        client_id: Client id of the client for tasks to be assigned.
  
      Returns:
        Number of assigned tasks.
      """
      rules = self.Get(self.Schema.RULES)
      if not rules:
        return 0
  
      if data_store.RelationalDBEnabled():
        last_foreman_run = self._GetLastForemanRunTimeRelational(client_id)
      else:
        last_foreman_run = self._GetLastForemanRunTime(client_id)
  
      latest_rule = max(rule.created for rule in rules)
  
      if latest_rule <= last_foreman_run:
        return 0
  
      # Update the latest checked rule on the client.
      if data_store.RelationalDBEnabled():
        try:
          self._SetLastForemanRunTimeRelational(client_id, latest_rule)
        except db.UnknownClientError:
          pass
  
      # If the relational db is used for reads, we don't have to update the
      # aff4 object.
      if not data_store.RelationalDBEnabled():
        self._SetLastForemanRunTime(client_id, latest_rule)
  
      relevant_rules = []
      expired_rules = False
  
      now = time.time() * 1e6
  
      for rule in rules:
        if rule.expires < now:
          expired_rules = True
          continue
        if rule.created <= int(last_foreman_run):
          continue
  
        relevant_rules.append(rule)
  
      if data_store.RelationalDBEnabled():
        client_data = data_store.REL_DB.ReadClientFullInfo(client_id)
        if client_data is None:
          return
      else:
        client_data = aff4.FACTORY.Open(client_id, mode="rw", token=self.token)
  
      actions_count = 0
      for rule in relevant_rules:
        if self._EvaluateRules(rule, client_data):
          actions_count += self._RunActions(rule, client_id)
  
      if expired_rules:
        self.ExpireRules()
  
      return actions_count