Navigation

← Previous Changeset
Next Changeset →

Changeset 475

Timestamp:

06/04/08 02:02:04 (7 months ago)

Author:

thomas

Message:

Added 'quality' and 'group_hash' to TrackFile?, changed redirect after importing/uploading to djedna_trackfile_list with the appropriate group_hash which is an arbitrary field that TrackFiles? that are created/modified en-masse will share -- also added tests for the above.

Files:

trunk/djedna/catalog2/models.py (modified) (13 diffs)
trunk/djedna/catalog2/tests.py (modified) (10 diffs)
trunk/djedna/catalog2/views.py (modified) (2 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/djedna/catalog2/models.py

r474	r475
18	18	import datetime
19	19	import logging as log
	20	import md5
20	21	import mimetypes
21	22	import os
…	…
24	25	import shutil
25	26	import StringIO
	27	import time
26	28	import traceback
27	29	import urllib
…	…
73	75	absolute_path = os.path.join(media_root, relative_path)
74	76	return (relative_path, absolute_path)
	77
	78	def get_group_hash():
	79	random_code = User.objects.make_random_password(allowed_chars='ABCDEFGHJKLMNPQRSTUVWXYZ23456789')
	80	usertoken = md5.new()
	81	usertoken.update(settings.SECRET_KEY)
	82	usertoken.update(smart_str(time.time(), errors='ignore'))
	83	digest = usertoken.hexdigest()
	84	return '%s%s' % (random_code, digest)
75	85
76	86
…	…
123	133
124	134	def add_from_path(self, path):
125		added = 0
	135	group_hash = get_group_hash()
	136	added = False
126	137	relative_path, absolute_path = media_path(path)
127	138	if absolute_path:
128	139	for f in pathwalk(absolute_path):
129	140	if self.is_music_file(f):
130		track_file, created = self.get_or_create_from_path(f)
131		if created: added += 1
132		return added
	141	trackfile, created = self.get_or_create_from_path(f)
	142	if created:
	143	added = True
	144	trackfile.group_hash = group_hash
	145	trackfile.save()
	146	return (None, group_hash)[added]
133	147
134	148	def validate_all(self):
…	…
159	173	class TrackFile(models.Model):
160	174	relative_path = models.CharField(max_length=1024, unique=True)
161		~~# track = models.ForeignKey('Track', null=True, related_name="track_files")~~
162	175	is_active = models.BooleanField(default=True)
163	176	mimetype = models.CharField(max_length=256, null=True, blank=True)
	177	quality = models.CharField(max_length=256, null=True, blank=True)
164	178	file_modified = models.DateTimeField(null=True, blank=True)
	179	group_hash = models.CharField(max_length=256, null=True, blank=True)
165	180	added = models.DateTimeField(auto_now_add=True)
166	181	updated = models.DateTimeField(auto_now=True)
	182	# track = models.ForeignKey('Track', null=True, related_name="track_files")
167	183
168	184	objects = TrackFileManager()
…	…
287	303	except:
288	304	log.exception("Exception getting length from '%s'" % self.path)
	305	try:
	306	quality = str(mp3.info.bitrate)
	307	except:
	308	log.exception("Exception getting quality (bitrate) from '%s'" % self.path)
289	309	pictures = mp3.tags.getall('APIC')
290	310	if not pictures:
…	…
302	322	'number' : number,
303	323	'length' : length,
	324	'quality' : quality,
304	325	'cover_image' : cover_image}
305	326
…	…
318	339	'number' : None,
319	340	'length' : length,
	341	'quality' : 'lossless',
320	342	'cover_image' : None}
321	343
…	…
331	353	'number' : None,
332	354	'length' : None,
	355	'quality' : None,
333	356	'cover_image' : None}
334	357	info = property(_get_info)
…	…
354	377	self.file_modified = self._get_file_modified_datetime()
355	378	self.mimetype = self.file_mimetype
	379	self.quality = self.info['quality']
356	380	if not self.file_exists():
357	381	self.is_active=False
…	…
376	400	max_length=1000
377	401	)
378		trackfile = models.ForeignKey(TrackFile,
379		blank=True,
380		null=True,
381		related_name='trackfileuploads')
382		user = models.ForeignKey(User,
383		blank=True,
384		null=True,
385		related_name='trackfileuploads')
	402	trackfile = models.ForeignKey(
	403	TrackFile,
	404	blank=True,
	405	null=True,
	406	related_name='trackfileuploads'
	407	)
	408	user = models.ForeignKey(
	409	User,
	410	blank=True,
	411	null=True,
	412	related_name='trackfileuploads'
	413	)
386	414	added = models.DateTimeField(auto_now_add=True)
387	415	updated = models.DateTimeField(auto_now=True)
…	…
391	419	list_display = ['id', 'trackfile', 'user', 'added', 'updated']
392	420
	421
393	422	def __unicode__(self):
394	423	return u'%s' % self.get_uploaded_file_filename()
…	…
397	426	if not self.trackfile:
398	427	path = self.get_uploaded_file_filename()
399		trackfile, created = TrackFile.objects.get_or_create_from_path(path)
400		self.trackfile = trackfile
	428	group_hash = TrackFile.objects.add_from_path(path)
	429	trackfiles = TrackFile.objects.filter(group_hash=group_hash)
	430	self.trackfile = trackfiles[0]
401	431	super(TrackFileUpload, self).save()
402	432

trunk/djedna/catalog2/tests.py

r474	r475
20	20	import shutil
21	21	import time
	22	import urllib
22	23	import urlparse
23	24
…	…
97	98	# IMPORT DIR
98	99	IMPORTED = os.path.join(settings.FILE_ROOT, 'imported')
	100	IMPORTED_REL = os.path.join(settings.FILE_DIRNAME, 'imported')
99	101	UPLOADED = os.path.join(settings.FILE_ROOT, 'uploaded')
	102	UPLOADED_REL = os.path.join(settings.FILE_DIRNAME, 'uploaded')
100	103
101	104
…	…
168	171	self.failUnless(trackfile.is_mp3())
169	172	self.failIf(trackfile.is_wav())
	173	self.failUnlessEqual(trackfile.quality, '128000')
170	174	self.failUnlessEqual(trackfile.get_absolute_url(),
171	175	reverse('djedna_trackfile_detail',
…	…
181	185	self.failUnlessEqual(info['number'], 1)
182	186	self.failUnlessEqual(info['length'], 23)
	187	self.failUnlessEqual(info['quality'], '128000')
183	188	self.failUnless(info['cover_image'])
184	189	self.failUnless(trackfile.file_exists())
…	…
237	242	self.failUnless(trackfile.is_wav())
238	243	self.failIf(trackfile.is_mp3())
	244	self.failUnlessEqual(trackfile.quality, 'lossless')
239	245	self.failUnlessEqual(trackfile.get_absolute_url(),
240	246	reverse('djedna_trackfile_detail',
…	…
245	251	info = trackfile.info
246	252	self.failUnlessEqual(info['length'], 23)
	253	self.failUnlessEqual(info['quality'], 'lossless')
247	254	self.failIf(info['title'])
248	255	self.failIf(info['artist_name'])
…	…
326	333
327	334	def test_add_from_path(self):
328		added = TrackFile.objects.add_from_path(FILE1_MP3_REL)
329		self.failUnlessEqual(added, 1)
330		added = TrackFile.objects.add_from_path(ALBUM1_REL)
331		self.failUnlessEqual(added, 4)
332		added = TrackFile.objects.add_from_path(ALBUM2_REL)
333		self.failUnlessEqual(added, 3)
334		added = TrackFile.objects.add_from_path(ALBUM3_REL)
335		self.failUnlessEqual(added, 4)
336		added = TrackFile.objects.add_from_path(CATALOG1_REL)
337		self.failUnlessEqual(added, 0)
338		added = TrackFile.objects.add_from_path(CATALOG2_REL)
339		self.failUnlessEqual(added, 13)
	335	group_hash = TrackFile.objects.add_from_path(FILE1_MP3_REL)
	336	added = TrackFile.objects.filter(group_hash=group_hash)
	337	self.failUnlessEqual(added.count(), 1)
	338	group_hash = TrackFile.objects.add_from_path(ALBUM1_REL)
	339	added = TrackFile.objects.filter(group_hash=group_hash)
	340	self.failUnlessEqual(added.count(), 4)
	341	group_hash = TrackFile.objects.add_from_path(ALBUM2_REL)
	342	added = TrackFile.objects.filter(group_hash=group_hash)
	343	self.failUnlessEqual(added.count(), 3)
	344	group_hash = TrackFile.objects.add_from_path(ALBUM3_REL)
	345	added = TrackFile.objects.filter(group_hash=group_hash)
	346	self.failUnlessEqual(added.count(), 4)
	347	group_hash = TrackFile.objects.add_from_path(CATALOG1_REL)
	348	added = TrackFile.objects.filter(group_hash=group_hash)
	349	self.failUnlessEqual(added.count(), 0)
	350	group_hash = TrackFile.objects.add_from_path(CATALOG2_REL)
	351	added = TrackFile.objects.filter(group_hash=group_hash)
	352	self.failUnlessEqual(added.count(), 13)
340	353
341	354	def test_active(self):
…	…
449	462	self.failUnlessEqual(TrackFile.objects.active.count(), 5)
450	463	# Use nonexistent path text
451		response = self.client.post(reverse('djedna_trackfile_import'),
452		{'path_text' : '/this/should/not/exist'})
453		self.failUnlessEqual(response.status_code, 200)
454		self.assertFormError(response, 'form', 'path_text',
455		[u'The path does not exist'])
	464	response = self.client.post(
	465	reverse('djedna_trackfile_import'),
	466	{'path_text' : '/this/should/not/exist'}
	467	)
	468	self.failUnlessEqual(response.status_code, 200)
	469	self.assertFormError(
	470	response, 'form', 'path_text', [u'The path does not exist']
	471	)
456	472	self.failUnlessEqual(TrackFile.objects.active.count(), 5)
457	473	# Use the select field to select a file
458		response = self.client.post(reverse('djedna_trackfile_import'),
459		{'path_select' : FILE3_MP3})
460		self.failUnlessEqual(response.status_code, 302)
	474	response = self.client.post(
	475	reverse('djedna_trackfile_import'),
	476	{'path_select' : FILE3_MP3}
	477	)
	478	trackfile = TrackFile.objects.get(relative_path=FILE3_MP3_REL)
	479	redirect = '%s?group_hash=%s' % (
	480	reverse('djedna_trackfile_list'),
	481	urllib.urlencode({'group_hash' : trackfile.group_hash})
	482	)
	483	self.assertRedirects(response, redirect)
461	484	self.failUnlessEqual(TrackFile.objects.active.count(), 6)
462		# Use the text field to select a file
463		response = self.client.post(reverse('djedna_trackfile_import'),
464		{'path_text' : FILE3_MP3})
465		self.failUnlessEqual(response.status_code, 302)
	485	# Use the text field to select the previous file
	486	response = self.client.post(
	487	reverse('djedna_trackfile_import'),
	488	{'path_text' : FILE3_MP3}
	489	)
	490	self.assertRedirects(response, reverse('djedna_trackfile_list'))
466	491	self.failUnlessEqual(TrackFile.objects.active.count(), 6)
467	492	# Use the text field to select a directory
468		response = self.client.post(reverse('djedna_trackfile_import'),
469		{'path_text' : ALBUM3})
470		self.failUnlessEqual(response.status_code, 302)
	493	response = self.client.post(
	494	reverse('djedna_trackfile_import'),
	495	{'path_text' : ALBUM3}
	496	)
	497	trackfiles = TrackFile.objects.get_in_path(ALBUM3_REL)
	498	redirect = '%s?group_hash=%s' % (
	499	reverse('djedna_trackfile_list'),
	500	urllib.urlencode({'group_hash' : trackfiles[0].group_hash})
	501	)
	502	self.assertRedirects(response, redirect)
471	503	self.failUnlessEqual(TrackFile.objects.active.count(), 10)
472	504
…	…
480	512	{'path_text' : settings.TEST_EXT_DATA}
481	513	)
482		self.failUnlessEqual(response.status_code, 302)
	514	trackfiles = TrackFile.objects.get_in_path(IMPORTED_REL)
	515	redirect = '%s?group_hash=%s' % (
	516	reverse('djedna_trackfile_list'),
	517	urllib.urlencode({'group_hash' : trackfiles[0].group_hash})
	518	)
	519	self.assertRedirects(response, redirect)
483	520	self.failUnlessEqual(TrackFile.objects.active.count(),
484	521	5 + settings.TEST_EXT_COUNT)
…	…
496	533	{'uploaded_file' : f})
497	534	f.close()
498		~~self.failUnlessEqual(response.status_code, 302)~~
499	535	self.failUnlessEqual(TrackFile.objects.active.count(), 6)
500	536	self.failUnlessEqual(TrackFileUpload.objects.count(), 1)
501
502
	537	trackfiles = TrackFile.objects.get_in_path(UPLOADED_REL)
	538	self.assertRedirects(response, trackfiles[0].get_absolute_url())
	539
	540

trunk/djedna/catalog2/views.py

r474	r475
19	19	import mimetypes
20	20	import os
	21	import urllib
	22	import urlparse
21	23
22	24	from django.conf import settings
…	…
136	138	path = form.path
137	139	if path:
138		if os.path.isfile(path):
139		trackfile, created = TrackFile.objects.get_or_create_from_path(path)
140		if not next_page:
141		next_page = trackfile.get_absolute_url()
142		if os.path.isdir(path):
143		TrackFile.objects.add_from_path(path)
	140	group_hash = TrackFile.objects.add_from_path(path)
	141	if not next_page:
	142	next_page = reverse('djedna_trackfile_list')
	143	if group_hash:
	144	next_page = '%s?group_hash=%s' % (
	145	next_page,
	146	urllib.urlencode({'group_hash' : group_hash})
	147	)
144	148	return HttpResponseRedirect(next_page)
145	149	else: