def create_directory(self,
parent_directory,
name=None,
context=None,
**kw):
parent = request.env['muk_dms.directory'].sudo().browse(
parent_directory)
uname = file.unique_name(name or _("New Directory"),
parent.child_directories.mapped('name'))
directory = request.env['muk_dms.directory'].with_context(
context or request.env.context).create({
'name':
uname,
'parent_directory':
parent_directory
})
return {
'id': "directory_%s" % directory.id,
'text': directory.name,
'icon': "fa fa-folder-o",
'type': "directory",
'data': {
'odoo_id': directory.id,
'odoo_model': "muk_dms.directory",
'odoo_record': {},
'name': directory.name,
'perm_read': directory.permission_read,
'perm_create': directory.permission_create,
'perm_write': directory.permission_write,
'perm_unlink': directory.permission_unlink,
'parent': "directory_%s" % parent_directory,
},
'children': False,
}
def archive_with_structure(self, name=None, format="zip", export="binary"):
attachments = self.filtered(
lambda rec: rec.type == "binary" and rec.datas)
structure = groupby(attachments, lambda attach:
(attach.res_id, attach.res_name))
if not name:
name = uuid.uuid4().hex
tmp_dir = tempfile.mkdtemp()
try:
base_dir = os.path.join(tmp_dir, name)
os.mkdir(base_dir)
for record, attachments in structure:
dir_name = "%s_%s" % (record[0], slugify(
record[1])) if record[1] else uuid.uuid4().hex
rec_dir = os.path.join(base_dir, dir_name)
os.mkdir(rec_dir)
unames = []
for attach in attachments:
uname = uuid.uuid4().hex
if attach.datas_fname:
uname = unique_name(attach.datas_fname,
unames,
escape_suffix=True)
elif attach.mimetype:
uname = "%s%s" % (
uname, mimetypes.guess_extension(attach.mimetype))
unames.append(uname)
file_path = os.path.join(rec_dir, uname)
with closing(open(file_path, 'wb')) as writer:
writer.write(
base64.b64decode(attach.with_context({}).datas))
return archive(base_dir, tmp_dir, name, format, export)
finally:
shutil.rmtree(tmp_dir)
def _process_message(self, msg_dict, extra_values={}):
names = self.sudo().files.mapped('name')
for attachment in msg_dict['attachments']:
uname = unique_name(attachment.fname, names, escape_suffix=True)
self.env['muk_dms.file'].sudo().create({
'content': attachment.content,
'directory': self.id,
'name': uname,
})
names.append(uname)
def copy(self, default=None):
self.ensure_one()
default = dict(default or [])
names = []
if 'directory' in default:
model = self.env['muk_dms.directory']
directory = model.browse(default['directory'])
names = directory.sudo().files.mapped('name')
else:
names = self.sudo().directory.files.mapped('name')
default.update(
{'name': file.unique_name(self.name, names, self.extension)})
return super(File, self).copy(default)
def message_new(self, msg_dict, custom_values=None):
custom_values = custom_values if custom_values is not None else {}
parent_directory_id = custom_values.get('parent_directory', None)
parent_directory = self.sudo().browse(parent_directory_id)
if not parent_directory_id or not parent_directory.exists():
raise ValueError("No directory could be found!")
if parent_directory.alias_process == "files":
parent_directory._process_message(msg_dict)
return parent_directory
names = parent_directory.child_directories.mapped('name')
subject = slugify(msg_dict.get('subject', _('Alias-Mail-Extraction')),
lower=False)
defaults = dict(
{'name': unique_name(subject, names, escape_suffix=True)},
**custom_values)
directory = super(Directory, self).message_new(msg_dict,
custom_values=defaults)
directory._process_message(msg_dict)
return directory
def archive(self, name=None, format="zip", export="binary"):
unames = []
if not name:
name = uuid.uuid4().hex
tmp_dir = tempfile.mkdtemp()
try:
base_dir = os.path.join(tmp_dir, name)
os.mkdir(base_dir)
for attach in self.filtered(
lambda rec: rec.type == "binary" and rec.datas):
uname = unique_name(attach.datas_fname or uuid.uuid4().hex,
unames,
escape_suffix=True)
unames.append(uname)
file_path = os.path.join(base_dir, uname)
with closing(open(file_path, 'wb')) as writer:
writer.write(
base64.b64decode(attach.with_context({}).datas))
return archive(base_dir, tmp_dir, name, format, export)
finally:
shutil.rmtree(tmp_dir)
def copy(self, default=None):
self.ensure_one()
default = dict(default or [])
names = []
if 'root_storage' in default:
storage = self.env['muk_dms.storage'].browse(default['root_storage'])
names = storage.sudo().root_directories.mapped('name')
elif 'parent_directory' in default:
parent_directory = self.browse(default['parent_directory'])
names = parent_directory.sudo().child_directories.mapped('name')
elif self.is_root_directory:
names = self.sudo().root_storage.root_directories.mapped('name')
else:
names = self.sudo().parent_directory.child_directories.mapped('name')
default.update({'name': file.unique_name(self.name, names)})
new = super(Directory, self).copy(default)
for record in self.files:
record.copy({'directory': new.id})
for record in self.child_directories:
record.copy({'parent_directory': new.id})
return new
def test_unique_name(self):
self.assertEqual(file.unique_name("Test", ["A", "B"]), "Test")
self.assertEqual(file.unique_name("Test", ["Test"]), "Test(1)")
