class User(Model):
email = models.TextField()
is_active = models.BooleanField(default=True)
is_superuser = models.BooleanField(default=False)
settings = JSONField(null=True)
is_authenticated = True
is_anonymous = False
objects = UserManager()
# Make Django happy
REQUIRED_FIELDS = ()
USERNAME_FIELD = "email"
class Meta:
# Create this explicit UNIQUE on `email` since
# Django's default behavior for `unique=True` is to
# also add a stupid text_pattern_ops index which
# isn't needed because we'll never do LIKE queries
unique_together = ("email", )
__repr__ = sane_repr("id", "email")
def __str__(self):
return self.email
class File(Model):
checksum = models.BinaryField()
size = models.PositiveIntegerField()
time_created = models.DateTimeField()
objects = FileManager()
__repr__ = sane_repr("id", "hexdigest")
class Meta:
unique_together = ("checksum", )
def hexdigest(self):
d = self.checksum
if isinstance(d, memoryview):
d = bytes(d)
return d.hex()
def get_public_url(self):
return f"https://{settings.GOOGLE_STORAGE_BUCKET}.storage.googleapis.com/files/{self.hexdigest()}"
def delete(self):
from google.cloud.exceptions import NotFound
try:
get_bucket().delete_blob(self.hexdigest())
except NotFound:
pass
return super().delete()
class SongMeta(Model):
@enum.unique
class Source(enum.IntEnum):
YouTube = 0
Soundcloud = 1
class DataUnsynced(Exception):
pass
source = models.PositiveSmallIntegerField(choices=[(s.name, s.value)
for s in Source])
identifier = models.TextField()
data = JSONField(null=True)
date_created = models.DateTimeField(auto_now_add=True)
last_synced = models.DateTimeField(null=True, db_index=True)
class Meta:
unique_together = ("source", "identifier")
__repr__ = sane_repr("source", "identifier", "is_complete")
@property
def resolver(self):
try:
resolver = {
SongMeta.Source.YouTube: YouTubeResolver,
SongMeta.Source.Soundcloud: SoundcloudResolver,
}[self.source]
except KeyError:
raise NotImplementedError
return resolver(self)
@property
def is_complete(self):
return self.data is not None and self.last_synced is not None
class OrganizationDomain(Model):
organization = models.ForeignKey(Organization, models.CASCADE)
domain = models.TextField()
date_created = models.DateTimeField(auto_now_add=True)
__repr__ = sane_repr("organization_id", "domain")
class Meta:
unique_together = ("domain", )
class LockitronUser(Model):
user_id = models.TextField()
email = models.TextField()
first_name = models.TextField(null=True)
last_name = models.TextField(null=True)
date_created = models.DateTimeField(auto_now_add=True)
__repr__ = sane_repr("user_id", "email")
class Meta:
unique_together = ("user_id",)
class Organization(Model):
name = models.TextField()
slug = models.SlugField()
settings = JSONField(null=True)
date_created = models.DateTimeField(auto_now_add=True)
objects = OrganizationManager()
__repr__ = sane_repr("name", "slug")
class Meta:
unique_together = ("slug", )
def associate_device(self, device):
from strut.models import DeviceAssociation
return DeviceAssociation.objects.get_or_create(organization=self,
device=device)
class DeviceActivity(Model):
@enum.unique
class Type(enum.IntEnum):
API_PING = 0
API_BOOTSTRAP = 1
WS_CONNECT = 2
WS_DISCONNECT = 3
device = models.ForeignKey(Device, models.CASCADE)
type = models.PositiveSmallIntegerField(choices=[(t.name, t.value)
for t in Type],
db_index=True)
message = JSONField(null=True)
ip_address = models.GenericIPAddressField()
datetime = models.DateTimeField(auto_now_add=True, db_index=True)
__repr__ = sane_repr("type", "ip_address", "message", "datetime",
"device_id")
class Song(Model):
meta = models.ForeignKey(SongMeta, models.CASCADE)
file = models.ForeignKey("File", models.CASCADE, null=True)
start = models.PositiveIntegerField()
length = models.PositiveIntegerField()
date_created = models.DateTimeField(auto_now_add=True)
is_active = models.BooleanField(default=False)
objects = SongQuerySet.as_manager()
class Meta:
unique_together = ("meta", "start", "length")
__repr__ = sane_repr("meta_id", "file_id", "start", "length")
def save(self, *args, **kwargs):
assert self.meta.is_complete
assert (self.start + self.length) <= self.meta.resolver.duration
assert self.length > 0
return super().save(*args, **kwargs)
def process(self, user=None, force=False, sync=False):
if not force:
assert not self.is_active
sj = SongJob.objects.create(song=self, user=user)
from strut import tasks
if sync:
from strut.tasks.music import process_songjob
process_songjob(job_id=sj.id)
else:
tasks.enqueue(func="strut.tasks.music.process_songjob",
kwargs={"job_id": sj.id})
return sj