def create_group(self, user_id, session_id, node_name, group_id,
                  post_access, read_access, delete_access,
                  posting_key_hash, reading_key_hash, delete_key_hash,
                  quota_allocated, when_space_exhausted,
                  max_post_size,
                  public_key_hash, passphrase=None):
 
     method = 'POST'
     path = '/proxy/group'
     body = uc.encode(
             {'node_name' : node_name,
              'group_id' : group_id,
              'post_access' : post_access,
              'read_access' : read_access,
              'delete_access' : delete_access,
              'posting_key_hash' : posting_key_hash,
              'reading_key_hash' : reading_key_hash,
              'delete_key_hash' : delete_key_hash,
              'quota_allocated' : quota_allocated,
              'when_space_exhausted' : when_space_exhausted,
              'max_post_size' : max_post_size,
              'public_key_hash' : public_key_hash,
              'passphrase' : passphrase})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]

 def read_version(self, node_name):
 
     method = 'GET'
     url = '/version?' + uc.encode(
             {'node_name' : node_name})
 
     return self.send_and_getter.send_and_get(self.conn, method, url)

 def create_group(
         self,
         timestamp, node_name, group_id, owner_id,
         post_access, read_access, delete_access,
         posting_key_type, posting_pub_key,
         reading_key_type, reading_pub_key,
         delete_key_type, delete_pub_key,
         quota_allocated, when_space_exhausted,
         max_post_size,
         public_key_hash, signature):
 
     method = 'POST'
     url = '/group'
     body = uc.encode(
             {'timestamp' : timestamp,
              'node_name' : node_name,
              'group_id' : group_id,
              'owner_id' : owner_id,
              'post_access' : post_access,
              'read_access' : read_access,
              'delete_access' : delete_access,
              'posting_key_type' : posting_key_type,
              'posting_pub_key' : posting_pub_key,
              'reading_key_type' : reading_key_type,
              'reading_pub_key' : reading_pub_key,
              'delete_key_type' : delete_key_type,
              'delete_pub_key' : delete_pub_key,
              'quota_allocated' : quota_allocated,
              'when_space_exhausted' : when_space_exhausted,
              'max_post_size' : max_post_size,
              'public_key_hash' : public_key_hash,
              'signature' : signature})
 
     return self.send_and_getter.send_and_get(self.conn, method, url, body)

 def create_user(self, node_name, user_id,
                 key_type, public_key, public_key_hash, revoke_date,
                 default_message_access, when_mail_exhausted,
                 quota_size, mail_quota_size,
                 max_message_size,
                 user_class, auth_token):
 
     method = 'POST'
     url = '/user'
     body = uc.encode(
             {'node_name' : node_name,
              'user_id' : user_id,
              'key_type' : key_type,
              'public_key' : public_key,
              'public_key_hash' : public_key_hash,
              'revoke_date' : revoke_date,
              'default_message_access' : default_message_access,
              'when_mail_exhausted' : when_mail_exhausted,
              'quota_size' : quota_size,
              'mail_quota_size' : mail_quota_size,
              'max_message_size' : max_message_size,
              'user_class' : user_class,
              'auth_token' : auth_token})
 
     return self.send_and_getter.send_and_get(self.conn, method, url, body)

    def query_user(self, node_name, user_id):

        method = 'GET'
        url = '/query-user?' + uc.encode(
                {'node_name' : node_name,
                 'user_id' : user_id})
    
        return self.send_and_getter.send_and_get(self.conn, method, url)

 def read_node_addr(self, user_id, session_id, node_name):
 
     method = 'GET'
     path = '/local/node-addr?' + uc.encode(
             {'node_name' : node_name})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]

 def read_quota_available(self, node_name, user_class):
 
     method = 'GET'
     url = '/quota-available?' + uc.encode(
             {'node_name' : node_name,
              'user_class' : user_class})
 
     return self.send_and_getter.send_and_get(self.conn, method, url)

    def list_user_keys(self, user_id, session_id, node_name=None):

        method = 'GET'
        path = '/local/list-user-keys?' + uc.encode(
                {'node_name' : node_name})
        cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})

        return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]

 def read_public_key(self, user_id, session_id, public_key_hash):
 
     method = 'GET'
     path = '/local/public-key?' + uc.encode(
             {'public_key_hash' : public_key_hash})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]

 def delete_node_addr(self, user_id, session_id, node_name):
 
     method = 'DELETE'
     path = '/local/node-addr'
     body = uc.encode(
             {'node_name' : node_name})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]

    def query_user(self, user_id, session_id, node_name, other_user_id):

        method = 'GET'
        path = '/proxy/query-user?' + uc.encode(
                {'node_name' : node_name,
                 'other_user_id' : other_user_id})
        cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})

        return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]

 def delete_public_key(self, user_id, session_id, public_key_hash):
 
     method = 'DELETE'
     path = '/local/public-key'
     body = uc.encode(
             {'public_key_hash' : public_key_hash})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]

 def create_local_user(self, user_id, password):
 
     method = 'POST'
     path = '/local/user'
     body = uc.encode(
             {'user_id' : user_id,
              'password' : password})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=None)

 def read_quota_available(self, user_id, session_id, node_name, user_class):
 
     method = 'GET'
     path = '/proxy/quota-available?' + uc.encode(
             {'node_name' : node_name,
              'user_class' : user_class})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]

 def read_private_key(self, user_id, session_id, public_key_hash, only_public_part=None, allow_private_user_key=None):
 
     method = 'GET'
     path = '/local/private-key?' + uc.encode(
             {'public_key_hash' : public_key_hash,
              'only_public_part' : only_public_part,
              'allow_private_user_key' : allow_private_user_key})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]

    def encrypt(self, user_id, session_id, public_key_hash, plaintext):

        method = 'POST'
        path = '/local/crypt/encrypt'
        body = uc.encode(
                {'public_key_hash' : public_key_hash,
                 'plaintext' : plaintext})
        cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})

        return self.send_and_getter.send_and_get(self.conn, method, path, body, cookies)[0]

 def read_message_quota(self, user_id, session_id, node_name, public_key_hash, passphrase=None):
 
     method = 'GET'
     path = '/proxy/message-quota?' + uc.encode(
             {'node_name' : node_name,
              'public_key_hash' : public_key_hash,
              'passphrase' : passphrase})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]

 def assign_user_key(self, user_id, session_id, node_name, public_key_hash):
 
     method = 'POST'
     path = '/local/user-key'
     body = uc.encode(
             {'node_name' : node_name,
              'public_key_hash' : public_key_hash})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=body, cookies=cookies)[0]

 def read_max_post_size(self, timestamp, node_name, group_id, owner_id, post_signature):
     method = 'GET'
     url = '/max-post-size?' + uc.encode(
             {'timestamp' : timestamp,
              'node_name' : node_name,
              'group_id' : group_id,
              'owner_id' : owner_id,
              'post_signature' : post_signature})
 
     return self.send_and_getter.send_and_get(self.conn, method, url)

 def read_local_message_access(self, user_id, session_id, to_user, node_name, from_user_key_hash):
 
     method = 'GET'
     path = '/local/message-access?' + uc.encode(
             {'to_user' : to_user,
              'node_name' : node_name,
              'from_user_key_hash' : from_user_key_hash})
     cookies = co.SimpleCookie({'user_id' : user_id, 'session_id' : session_id})
 
     return self.send_and_getter.send_and_get(self.conn, method, path, body=None, cookies=cookies)[0]