1244 lines
33 KiB
Lua
1244 lines
33 KiB
Lua
-- The Mailbox class represents a mailbox that resides in an IMAP account.
|
|
|
|
Mailbox = {}
|
|
|
|
Mailbox._mt = {}
|
|
setmetatable(Mailbox, Mailbox._mt)
|
|
|
|
|
|
Mailbox._mt.__call = function (self, account, mailbox)
|
|
local object = {}
|
|
|
|
object._type = 'mailbox'
|
|
|
|
for key, value in pairs(Mailbox) do
|
|
if (type(value) == 'function') then
|
|
object[key] = value
|
|
end
|
|
end
|
|
|
|
object._mt = {}
|
|
object._mt.__index = object._attach_message
|
|
setmetatable(object, object._mt)
|
|
|
|
object._account = account
|
|
object._mailbox = mailbox
|
|
|
|
return object
|
|
end
|
|
|
|
|
|
function Mailbox._attach_message(self, uid)
|
|
self[uid] = Message(self._account, self, uid)
|
|
return self[uid]
|
|
end
|
|
|
|
function Mailbox._detach_message(self, uid)
|
|
self[uid] = nil
|
|
end
|
|
|
|
|
|
function Mailbox._cached_select(self, account, mbox)
|
|
if (account._mailbox == nil or account._mailbox ~= mbox) then
|
|
if (ifcore.select(self._account._imap, mbox) == true) then
|
|
account._mailbox = mbox
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
else
|
|
return true
|
|
end
|
|
end
|
|
|
|
function Mailbox._cached_close(self, account)
|
|
account._mailbox = nil
|
|
return ifcore.close(self._account._imap)
|
|
end
|
|
|
|
|
|
function Mailbox._send_query(self, criteria, charset)
|
|
_check_optional(criteria, { 'string', 'table' })
|
|
_check_optional(charset, 'string')
|
|
|
|
local query
|
|
if (criteria == nil) then
|
|
query = 'ALL'
|
|
elseif (type(criteria) == 'string') then
|
|
query = 'ALL ' .. criteria
|
|
else
|
|
query = _make_query(criteria)
|
|
end
|
|
|
|
if (charset == nil) then
|
|
if (type(options) == 'table' and type(options.charset) == 'string') then
|
|
charset = options.charset
|
|
else
|
|
charset = ''
|
|
end
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return {}
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return {}
|
|
end
|
|
|
|
local _, results = ifcore.search(self._account._imap, query, charset)
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
if (results == nil) then
|
|
return {}
|
|
end
|
|
|
|
local t = {}
|
|
for n in string.gmatch(results, '%d+') do
|
|
table.insert(t, { self, tonumber(n) })
|
|
end
|
|
|
|
return t
|
|
end
|
|
|
|
|
|
function Mailbox._flag_messages(self, mode, flags, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local f = ''
|
|
if (#flags ~= 0) then
|
|
f = table.concat(flags, ' ')
|
|
end
|
|
|
|
local m = _make_range(messages)
|
|
local n = #m
|
|
local r = false
|
|
for i = 1, n, 50 do
|
|
j = i + 49
|
|
if (n < j) then
|
|
j = n
|
|
end
|
|
r = ifcore.store(self._account._imap, table.concat(m, ',', i, j),
|
|
mode, f)
|
|
if r == false then
|
|
break
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
|
|
function Mailbox._copy_messages(self, dest, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
local r = false
|
|
if (self._account._imap == dest._account._imap) then
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~= true) then
|
|
return
|
|
end
|
|
|
|
local m = _make_range(messages)
|
|
local n = #m
|
|
for i = 1, n, 50 do
|
|
j = i + 49
|
|
if (n < j) then
|
|
j = n
|
|
end
|
|
r = ifcore.copy(self._account._imap, table.concat(m, ',', i, j),
|
|
dest._mailbox)
|
|
if r == false then
|
|
break
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
else
|
|
local fast = self._fetch_fast(self, messages)
|
|
local mesgs = self._fetch_message(self, messages)
|
|
|
|
if (dest._account._login_user(dest._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
for i in pairs(fast) do
|
|
for k, v in ipairs(fast[i]['flags']) do
|
|
if (string.lower(v) == '\\recent') then
|
|
table.remove(fast[i]['flags'], k)
|
|
end
|
|
end
|
|
|
|
r = ifcore.append(dest._account._imap, dest._mailbox, mesgs[i],
|
|
table.concat(fast[i]['flags'], ' '), fast[i]['date'])
|
|
end
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
|
|
function Mailbox._fetch_fast(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
local _, flags, date, size = ifcore.fetchfast(self._account._imap,
|
|
tostring(m))
|
|
if (flags ~= nil and date ~= nil and size ~= nil ) then
|
|
local f = {}
|
|
for s in string.gmatch(flags, '%S+') do
|
|
table.insert(f, s)
|
|
end
|
|
results[m] = {}
|
|
results[m]['flags'] = f
|
|
results[m]['date'] = date
|
|
results[m]['size'] = size
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_flags(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
local _, flags = ifcore.fetchflags(self._account._imap, tostring(m))
|
|
if (flags ~= nil) then
|
|
local f = {}
|
|
for s in string.gmatch(flags, '%S+') do
|
|
table.insert(f, s)
|
|
end
|
|
results[m] = f
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_date(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
if (type(options) == 'table' and options.cache == true and
|
|
self[m]._date) then
|
|
results[m] = self[m]._date
|
|
else
|
|
local _, date = ifcore.fetchdate(self._account._imap, tostring(m))
|
|
if (date ~= nil) then
|
|
results[m] = date
|
|
if (type(options) == 'table' and options.cache == true) then
|
|
self[m]._date = date
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_size(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
if (type(options) == 'table' and options.cache == true and
|
|
self[m]._size) then
|
|
results[m] = self[m]._size
|
|
else
|
|
local _, size = ifcore.fetchsize(self._account._imap, tostring(m))
|
|
if (size ~= nil) then
|
|
results[m] = tonumber(size)
|
|
if (type(options) == 'table' and options.cache == true) then
|
|
self[m]._size = tonumber(size)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_header(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
if (type(options) == 'table' and options.cache == true and
|
|
self[m]._header) then
|
|
results[m] = self[m]._header
|
|
else
|
|
local _, header = ifcore.fetchheader(self._account._imap,
|
|
tostring(m))
|
|
if (header ~= nil) then
|
|
results[m] = header
|
|
if (type(options) == 'table' and options.cache == true) then
|
|
self[m]._header = header
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_body(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
if (type(options) == 'table' and options.cache == true and
|
|
self[m]._body) then
|
|
results[m] = self[m]._body
|
|
else
|
|
local _, body = ifcore.fetchbody(self._account._imap, tostring(m))
|
|
if (body ~= nil) then
|
|
results[m] = body
|
|
if (type(options) == 'table' and options.cache == true) then
|
|
self[m]._body = body
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_message(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
local header = self._fetch_header(self, messages)
|
|
local body = self._fetch_body(self, messages)
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
if (header[m] == nil) then
|
|
results[m] = nil
|
|
elseif (body[m] == nil) then
|
|
results[m] = header[m]
|
|
else
|
|
results[m] = header[m] .. body[m]
|
|
end
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
|
|
function Mailbox._fetch_fields(self, fields, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
results[m] = ''
|
|
for _, f in ipairs(fields) do
|
|
if (type(options) == 'table' and options.cache == true and
|
|
self[m]._fields[f]) then
|
|
results[m] = results[m] .. self[m]._fields[f]
|
|
else
|
|
local _, field = ifcore.fetchfields(self._account._imap,
|
|
tostring(m), f)
|
|
if (field ~= nil) then
|
|
field = string.gsub(field, "\r\n\r\n$", "\n")
|
|
results[m] = results[m] .. field
|
|
if (type(options) == 'table' and options.cache == true) then
|
|
self[m]._fields[f] = field
|
|
end
|
|
end
|
|
end
|
|
end
|
|
results[m] = string.gsub(results[m], "\n$", "")
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_structure(self, messages)
|
|
if (not messages or #messages == 0) then
|
|
return
|
|
end
|
|
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, m in ipairs(messages) do
|
|
if (type(options) == 'table' and options.cache == true and
|
|
self[m]._structure) then
|
|
results[m] = self[m]._structure
|
|
else
|
|
local _, structure = ifcore.fetchstructure(self._account._imap,
|
|
tostring(m))
|
|
if (structure ~= nil) then
|
|
local parsed = _parse_structure({ ['s'] = structure, ['i'] = 1 })
|
|
results[m] = parsed
|
|
if (type(options) == 'table' and options.cache == true) then
|
|
self[m]._structure = parsed
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
function Mailbox._fetch_parts(self, parts, message)
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return
|
|
end
|
|
|
|
local results = {}
|
|
for _, part in ipairs(parts) do
|
|
results[part] = ''
|
|
if (type(options) == 'table' and options.cache == true and
|
|
self[message]._parts[part]) then
|
|
results[part] = self[message]._parts[part]
|
|
else
|
|
local _, bodypart = ifcore.fetchpart(self._account._imap,
|
|
tostring(message), part)
|
|
if (bodypart ~= nil) then
|
|
results[part] = bodypart
|
|
self[message]._parts[part] = bodypart
|
|
end
|
|
end
|
|
end
|
|
|
|
if (type(options) == 'table' and options.close == true) then
|
|
self._cached_close(self, self._account._imap)
|
|
end
|
|
|
|
return results
|
|
end
|
|
|
|
|
|
function Mailbox.check_status(self)
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return
|
|
end
|
|
|
|
local _, exist, recent, unseen, uidnext = ifcore.status(self._account._imap,
|
|
self._mailbox)
|
|
|
|
if (type(options) == 'table' and options.info == true) then
|
|
print(string.format("%d messages, %d recent, %d unseen, in %s@%s/%s.",
|
|
exist, recent, unseen,
|
|
self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return exist, recent, unseen, uidnext
|
|
end
|
|
|
|
|
|
function Mailbox.send_query(self, criteria, charset)
|
|
return Set(self._send_query(self, criteria, charset))
|
|
end
|
|
|
|
function Mailbox.select_all(self)
|
|
return self.send_query(self)
|
|
end
|
|
|
|
|
|
function Mailbox.add_flags(self, flags, messages)
|
|
_check_required(flags, 'table')
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'add', flags, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages flagged in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.remove_flags(self, flags, messages)
|
|
_check_required(flags, 'table')
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'remove', flags, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages flagged in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.replace_flags(self, flags, messages)
|
|
_check_required(flags, 'table')
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'replace', flags, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages flagged in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
|
|
function Mailbox.mark_answered(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'add', { '\\Answered' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages marked answered in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
|
|
function Mailbox.mark_deleted(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'add', { '\\Deleted' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages marked deleted in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.mark_draft(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'add', { '\\Draft' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages marked draft in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.mark_flagged(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'add', { '\\Flagged' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages marked flagged in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.mark_seen(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'add', { '\\Seen' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages marked seen in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.unmark_answered(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'remove', { '\\Answered' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages unmarked answered in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.unmark_deleted(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'remove', { '\\Deleted' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages unmarked deleted in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.unmark_draft(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'remove', { '\\Draft' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages unmarked draft in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.unmark_flagged(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'remove', { '\\Flagged' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages unmarked flagged in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
function Mailbox.unmark_seen(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'remove', { '\\Seen' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages unmarked seen in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
|
|
function Mailbox.delete_messages(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._flag_messages(self, 'add', { '\\Deleted' }, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages deleted in %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
|
|
function Mailbox.copy_messages(self, dest, messages)
|
|
_check_required(dest, 'table')
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local r = self._copy_messages(self, dest, mesgs)
|
|
|
|
if (type(options) == 'table' and options.info == true and r == true) then
|
|
print(string.format("%d messages copied from %s@%s/%s to %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox,
|
|
dest._account._imap.username,
|
|
dest._account._imap.server,
|
|
dest._mailbox))
|
|
end
|
|
|
|
return r
|
|
end
|
|
|
|
|
|
function Mailbox.move_messages(self, dest, messages)
|
|
_check_required(dest, 'table')
|
|
_check_required(messages, 'table')
|
|
|
|
local mesgs = _extract_messages(self, messages)
|
|
|
|
local rc = self._copy_messages(self, dest, mesgs)
|
|
local rf = false
|
|
if (rc == true) then
|
|
rf = self._flag_messages(self, 'add', { '\\Deleted' }, mesgs)
|
|
end
|
|
|
|
if (type(options) == 'table' and options.info == true and
|
|
rc == true and rf == true) then
|
|
print(string.format("%d messages moved from %s@%s/%s to %s@%s/%s.",
|
|
#mesgs, self._account._imap.username,
|
|
self._account._imap.server, self._mailbox,
|
|
dest._account._imap.username,
|
|
dest._account._imap.server,
|
|
dest._mailbox))
|
|
end
|
|
|
|
return rc == true and rf == true
|
|
end
|
|
|
|
|
|
function Mailbox.fetch_flags(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_flags(self, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_date(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_date(self, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_size(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_size(self, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_header(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_header(self, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_body(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_body(self, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_message(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_message(self, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_fields(self, fields, messages)
|
|
_check_required(fields, 'table')
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_fields(self, fields, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_structure(self, messages)
|
|
_check_required(messages, 'table')
|
|
|
|
return self._fetch_structure(self, _extract_messages(self, messages))
|
|
end
|
|
|
|
function Mailbox.fetch_parts(self, parts, message)
|
|
_check_required(parts, 'table')
|
|
_check_required(message, 'number')
|
|
|
|
return self._fetch_parts(self, parts, message)
|
|
end
|
|
|
|
|
|
function Mailbox.is_answered(self)
|
|
return self.send_query(self, 'ANSWERED')
|
|
end
|
|
|
|
function Mailbox.is_deleted(self)
|
|
return self.send_query(self, 'DELETED')
|
|
end
|
|
|
|
function Mailbox.is_draft(self)
|
|
return self.send_query(self, 'DRAFT')
|
|
end
|
|
|
|
function Mailbox.is_flagged(self)
|
|
return self.send_query(self, 'FLAGGED')
|
|
end
|
|
|
|
function Mailbox.is_new(self)
|
|
return self.send_query(self, 'NEW')
|
|
end
|
|
|
|
function Mailbox.is_old(self)
|
|
return self.send_query(self, 'OLD')
|
|
end
|
|
|
|
function Mailbox.is_recent(self)
|
|
return self.send_query(self, 'RECENT')
|
|
end
|
|
|
|
function Mailbox.is_seen(self)
|
|
return self.send_query(self, 'SEEN')
|
|
end
|
|
|
|
function Mailbox.is_unanswered(self)
|
|
return self.send_query(self, 'UNANSWERED')
|
|
end
|
|
|
|
function Mailbox.is_undeleted(self)
|
|
return self.send_query(self, 'UNDELETED')
|
|
end
|
|
|
|
function Mailbox.is_undraft(self)
|
|
return self.send_query(self, 'UNDRAFT')
|
|
end
|
|
|
|
function Mailbox.is_unflagged(self)
|
|
return self.send_query(self, 'UNFLAGGED')
|
|
end
|
|
|
|
function Mailbox.is_unseen(self)
|
|
return self.send_query(self, 'UNSEEN')
|
|
end
|
|
|
|
function Mailbox.is_larger(self, size)
|
|
_check_required(size, 'number')
|
|
|
|
return self.send_query(self, 'LARGER ' .. tostring(size))
|
|
end
|
|
|
|
function Mailbox.is_smaller(self, size)
|
|
_check_required(size, 'number')
|
|
|
|
return self.send_query(self, 'SMALLER ' .. tostring(size))
|
|
end
|
|
|
|
|
|
function Mailbox.arrived_on(self, date)
|
|
_check_required(date, 'string')
|
|
|
|
return self.send_query(self, 'ON ' .. date)
|
|
end
|
|
|
|
function Mailbox.arrived_before(self, date)
|
|
_check_required(date, 'string')
|
|
|
|
return self.send_query(self, 'BEFORE ' .. date)
|
|
end
|
|
|
|
function Mailbox.arrived_since(self, date)
|
|
_check_required(date, 'string')
|
|
|
|
return self.send_query(self, 'SINCE ' .. date)
|
|
end
|
|
|
|
function Mailbox.sent_on(self, date)
|
|
_check_required(date, 'string')
|
|
|
|
return self.send_query(self, 'SENTON ' .. date)
|
|
end
|
|
|
|
function Mailbox.sent_before(self, date)
|
|
_check_required(date, 'string')
|
|
|
|
return self.send_query(self, 'SENTBEFORE ' .. date)
|
|
end
|
|
|
|
function Mailbox.sent_since(self, date)
|
|
_check_required(date, 'string')
|
|
|
|
return self.send_query(self, 'SENTSINCE ' .. date)
|
|
end
|
|
|
|
function Mailbox.is_newer(self, days)
|
|
_check_required(days, 'number')
|
|
|
|
return self.send_query(self, 'SINCE ' .. form_date(days))
|
|
end
|
|
|
|
function Mailbox.is_older(self, days)
|
|
_check_required(days, 'number')
|
|
|
|
return self.send_query(self, 'BEFORE ' .. form_date(days))
|
|
end
|
|
|
|
|
|
function Mailbox.has_flag(self, flag)
|
|
_check_required(flag, 'string')
|
|
|
|
return self.send_query(self, 'KEYWORD "' .. flag .. '"')
|
|
end
|
|
|
|
|
|
function Mailbox.contain_field(self, field, string)
|
|
_check_required(field, 'string')
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'HEADER ' .. field .. ' "' .. string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_bcc(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'BCC "' .. string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_cc(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'CC "' .. string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_from(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'FROM "' .. string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_subject(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'SUBJECT "' .. string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_to(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'TO "' .. string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_header(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'TEXT "' .. string .. '" NOT BODY "' ..
|
|
string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_body(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'BODY "' .. string .. '"')
|
|
end
|
|
|
|
function Mailbox.contain_message(self, string)
|
|
_check_required(string, 'string')
|
|
|
|
return self.send_query(self, 'TEXT "' .. string .. '"')
|
|
end
|
|
|
|
|
|
function Mailbox.match_field(self, field, pattern, messages)
|
|
_check_required(field, 'string')
|
|
_check_required(pattern, 'string')
|
|
|
|
if not messages then
|
|
messages = self._send_query(self)
|
|
end
|
|
local mesgs = _extract_messages(self, messages)
|
|
local fields = self._fetch_fields(self, { field }, mesgs)
|
|
|
|
if (#mesgs == 0 or fields == nil) then
|
|
return Set({})
|
|
end
|
|
|
|
local results = {}
|
|
for m, f in pairs(fields) do
|
|
if (regex_search(pattern, f)) then
|
|
table.insert(results, {self, m})
|
|
end
|
|
end
|
|
|
|
return Set(results)
|
|
end
|
|
|
|
function Mailbox.match_bcc(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
return self.match_field(self, 'Bcc', pattern, messages)
|
|
end
|
|
|
|
function Mailbox.match_cc(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
return self.match_field(self, 'Cc', pattern, messages)
|
|
end
|
|
|
|
function Mailbox.match_from(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
return self.match_field(self, 'From', pattern, messages)
|
|
end
|
|
|
|
function Mailbox.match_subject(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
return self.match_field(self, 'Subject', pattern, messages)
|
|
end
|
|
|
|
function Mailbox.match_to(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
return self.match_field(self, 'To', pattern, messages)
|
|
end
|
|
|
|
function Mailbox.match_header(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
if not messages then
|
|
messages = self._send_query(self)
|
|
end
|
|
local mesgs = _extract_messages(self, messages)
|
|
local header = self._fetch_header(self, mesgs)
|
|
|
|
if (#mesgs == 0 or header == nil) then
|
|
return Set({})
|
|
end
|
|
|
|
local results = {}
|
|
for m, h in pairs(header) do
|
|
if (regex_search(pattern, h)) then
|
|
table.insert(results, {self, m})
|
|
end
|
|
end
|
|
|
|
return Set(results)
|
|
end
|
|
|
|
function Mailbox.match_body(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
if not messages then
|
|
messages = self._send_query(self)
|
|
end
|
|
local mesgs = _extract_messages(self, messages)
|
|
local body = self._fetch_body(self, mesgs)
|
|
|
|
if (#mesgs == 0 or body == nil) then
|
|
return Set({})
|
|
end
|
|
|
|
local results = {}
|
|
for m, b in pairs(body) do
|
|
if (regex_search(pattern, b)) then
|
|
table.insert(results, {self, m})
|
|
end
|
|
end
|
|
|
|
return Set(results)
|
|
end
|
|
|
|
function Mailbox.match_message(self, pattern, messages)
|
|
_check_required(pattern, 'string')
|
|
|
|
if not messages then
|
|
messages = self._send_query(self)
|
|
end
|
|
local mesgs = _extract_messages(self, messages)
|
|
local full = self._fetch_message(self, mesgs)
|
|
|
|
if (#mesgs == 0 or full == nil) then
|
|
return Set({})
|
|
end
|
|
|
|
local results = {}
|
|
for m, f in pairs(full) do
|
|
if (regex_search(pattern, f)) then
|
|
table.insert(results, {self, m})
|
|
end
|
|
end
|
|
|
|
return Set(results)
|
|
end
|
|
|
|
function Mailbox.enter_idle(self)
|
|
if (self._account._login_user(self._account) ~= true) then
|
|
return false
|
|
end
|
|
|
|
if (self._cached_select(self, self._account._imap, self._mailbox) ~=
|
|
true) then
|
|
return false
|
|
end
|
|
|
|
return ifcore.idle(self._account._imap)
|
|
end
|
|
|
|
Mailbox._mt.__index = function () end
|
|
Mailbox._mt.__newindex = function () end
|