filer.models.foldermodels: 180 total statements, 0.0% covered

Generated: Wed 2013-03-13 10:33 CET

Source file: /media/Envs/Envs/filer-gallery/lib/python2.7/site-packages/filer/models/foldermodels.py

Stats: 0 executed, 146 missed, 34 excluded, 119 ignored

1. #-*- coding: utf-8 -*-
2. from django.contrib.auth import models as auth_models
3. from django.core import urlresolvers
4. from django.core.exceptions import ValidationError
5. from django.db import models
6. from django.db.models import Q
7. from django.utils.translation import ugettext_lazy as _
8. from filer.models import mixins
9. from filer import settings as filer_settings
11. import mptt
14. class FolderManager(models.Manager):
15. def with_bad_metadata(self):
16. return self.get_query_set().filter(has_all_mandatory_data=False)
19. class FolderPermissionManager(models.Manager):
20. """
21. Theses methods are called by introspection from "has_generic_permisison" on
22. the folder model.
23. """
24. def get_read_id_list(self, user):
25. """
26. Give a list of a Folders where the user has read rights or the string
27. "All" if the user has all rights.
28. """
29. return self.__get_id_list(user, "can_read")
31. def get_edit_id_list(self, user):
32. return self.__get_id_list(user, "can_edit")
34. def get_add_children_id_list(self, user):
35. return self.__get_id_list(user, "can_add_children")
37. def __get_id_list(self, user, attr):
38. if user.is_superuser or not filer_settings.FILER_ENABLE_PERMISSIONS:
39. return 'All'
40. allow_list = set()
41. deny_list = set()
42. group_ids = user.groups.all().values_list('id', flat=True)
43. q = Q(user=user) | Q(group__in=group_ids) | Q(everybody=True)
44. perms = self.filter(q).order_by('folder__tree_id', 'folder__level',
45. 'folder__lft')
46. for perm in perms:
47. p = getattr(perm, attr)
49. if p is None:
50. # Not allow nor deny, we continue with the next permission
51. continue
53. if not perm.folder:
54. assert perm.type == FolderPermission.ALL
56. if p == FolderPermission.ALLOW:
57. allow_list.update(Folder.objects.all().values_list('id', flat=True))
58. else:
59. deny_list.update(Folder.objects.all().values_list('id', flat=True))
61. continue
63. folder_id = perm.folder.id
65. if p == FolderPermission.ALLOW:
66. allow_list.add(folder_id)
67. else:
68. deny_list.add(folder_id)
70. if perm.type == FolderPermission.CHILDREN:
71. if p == FolderPermission.ALLOW:
72. allow_list.update(perm.folder.get_descendants().values_list('id', flat=True))
73. else:
74. deny_list.update(perm.folder.get_descendants().values_list('id', flat=True))
76. # Deny has precedence over allow
77. return allow_list - deny_list
80. class Folder(models.Model, mixins.IconsMixin):
81. """
82. Represents a Folder that things (files) can be put into. Folders are *NOT*
83. mirrored in the Filesystem and can have any unicode chars as their name.
84. Other models may attach to a folder with a ForeignKey. If the related name
85. ends with "_files" they will automatically be listed in the
86. folder.files list along with all the other models that link to the folder
87. in this way. Make sure the linked models obey the AbstractFile interface
88. (Duck Type).
89. """
90. file_type = 'Folder'
91. is_root = False
92. can_have_subfolders = True
93. _icon = 'plainfolder'
95. parent = models.ForeignKey('self', verbose_name=('parent'), null=True, blank=True,
96. related_name='children')
97. name = models.CharField(_('name'), max_length=255)
99. owner = models.ForeignKey(auth_models.User, verbose_name=('owner'),
100. related_name='filer_owned_folders',
101. null=True, blank=True)
103. uploaded_at = models.DateTimeField(_('uploaded at'), auto_now_add=True)
105. created_at = models.DateTimeField(_('created at'), auto_now_add=True)
106. modified_at = models.DateTimeField(_('modified at'),auto_now=True)
108. objects = FolderManager()
110. @property
111. def file_count(self):
112. if not hasattr(self, '_file_count_cache'):
113. self._file_count_cache = self.files.count()
114. return self._file_count_cache
116. @property
117. def children_count(self):
118. if not hasattr(self, '_children_count_cache'):
119. self._children_count_cache = self.children.count()
120. return self._children_count_cache
122. @property
123. def item_count(self):
124. return self.file_count + self.children_count
126. @property
127. def files(self):
128. return self.all_files.all()
130. @property
131. def logical_path(self):
132. """
133. Gets logical path of the folder in the tree structure.
134. Used to generate breadcrumbs
135. """
136. folder_path = []
137. if self.parent:
138. folder_path.extend(self.parent.get_ancestors())
139. folder_path.append(self.parent)
140. return folder_path
142. @property
143. def pretty_logical_path(self):
144. return u"/%s" % u"/".join([f.name for f in self.logical_path+[self]])
146. def has_edit_permission(self, request):
147. return self.has_generic_permission(request, 'edit')
149. def has_read_permission(self, request):
150. return self.has_generic_permission(request, 'read')
152. def has_add_children_permission(self, request):
153. return self.has_generic_permission(request, 'add_children')
155. def has_generic_permission(self, request, permission_type):
156. """
157. Return true if the current user has permission on this
158. folder. Return the string 'ALL' if the user has all rights.
159. """
160. user = request.user
161. if not user.is_authenticated():
162. return False
163. elif user.is_superuser:
164. return True
165. elif user == self.owner:
166. return True
167. else:
168. if not hasattr(self, "permission_cache") or\
169. permission_type not in self.permission_cache or \
170. request.user.pk != self.permission_cache['user'].pk:
171. if not hasattr(self, "permission_cache") or request.user.pk != self.permission_cache['user'].pk:
172. self.permission_cache = {
173. 'user': request.user,
174. }
176. # This calls methods on the manager i.e. get_read_id_list()
177. func = getattr(FolderPermission.objects,
178. "get_%s_id_list" % permission_type)
179. permission = func(user)
180. if permission == "All":
181. self.permission_cache[permission_type] = True
182. self.permission_cache['read'] = True
183. self.permission_cache['edit'] = True
184. self.permission_cache['add_children'] = True
185. else:
186. self.permission_cache[permission_type] = self.id in permission
187. return self.permission_cache[permission_type]
189. def get_admin_url_path(self):
190. return urlresolvers.reverse('admin:filer_folder_change',
191. args=(self.id,))
193. def get_admin_directory_listing_url_path(self):
194. return urlresolvers.reverse('admin:filer-directory_listing',
195. args=(self.id,))
197. def __unicode__(self):
198. return u"%s" % (self.name,)
200. def contains_folder(self, folder_name):
201. try:
202. self.children.get(name=folder_name)
203. return True
204. except Folder.DoesNotExist:
205. return False
207. class Meta:
208. unique_together = (('parent', 'name'),)
209. ordering = ('name',)
210. permissions = (("can_use_directory_listing",
211. "Can use directory listing"),)
212. app_label = 'filer'
213. verbose_name = _("Folder")
214. verbose_name_plural = _("Folders")
216. # MPTT registration
217. try:
218. mptt.register(Folder)
219. except mptt.AlreadyRegistered:
220. pass
223. class FolderPermission(models.Model):
224. ALL = 0
225. THIS = 1
226. CHILDREN = 2
228. ALLOW = 1
229. DENY = 0
231. TYPES = (
232. (ALL, _('all items')),
233. (THIS, _('this item only')),
234. (CHILDREN, _('this item and all children')),
235. )
237. PERMISIONS = (
238. (ALLOW, _('allow')),
239. (DENY, _('deny')),
240. )
242. folder = models.ForeignKey(Folder, verbose_name=('folder'), null=True, blank=True)
244. type = models.SmallIntegerField(_('type'), choices=TYPES, default=ALL)
245. user = models.ForeignKey(auth_models.User,
246. related_name="filer_folder_permissions",
247. verbose_name=_("user"), blank=True, null=True)
248. group = models.ForeignKey(auth_models.Group,
249. related_name="filer_folder_permissions",
250. verbose_name=_("group"), blank=True, null=True)
251. everybody = models.BooleanField(_("everybody"), default=False)
253. can_edit = models.SmallIntegerField(_("can edit"), choices=PERMISIONS, blank=True, null=True, default=None)
254. can_read = models.SmallIntegerField(_("can read"), choices=PERMISIONS, blank=True, null=True, default=None)
255. can_add_children = models.SmallIntegerField(_("can add children"), choices=PERMISIONS, blank=True, null=True, default=None)
257. objects = FolderPermissionManager()
259. def __unicode__(self):
260. if self.folder:
261. name = u'%s' % self.folder
262. else:
263. name = u'All Folders'
265. ug = []
266. if self.everybody:
267. ug.append('Everybody')
268. else:
269. if self.group:
270. ug.append(u"Group: %s" % self.group)
271. if self.user:
272. ug.append(u"User: %s" % self.user)
273. usergroup = " ".join(ug)
274. perms = []
275. for s in ['can_edit', 'can_read', 'can_add_children']:
276. perm = getattr(self, s)
277. if perm == self.ALLOW:
278. perms.append(s)
279. elif perm == self.DENY:
280. perms.append('!%s' % s)
281. perms = ', '.join(perms)
282. return u"Folder: '%s'->%s [%s] [%s]" % (
283. name, unicode(self.TYPES[self.type][1]),
284. perms, usergroup)
286. def clean(self):
287. if self.type == self.ALL and self.folder:
288. raise ValidationError('Folder cannot be selected with type "all items".')
289. if self.type != self.ALL and not self.folder:
290. raise ValidationError('Folder has to be selected when type is not "all items".')
291. if self.everybody and (self.user or self.group):
292. raise ValidationError('User or group cannot be selected together with "everybody".')
293. if not self.user and not self.group and not self.everybody:
294. raise ValidationError('At least one of user, group, or "everybody" has to be selected.')
296. class Meta:
297. verbose_name = _('folder permission')
298. verbose_name_plural = _('folder permissions')
299. app_label = 'filer'