class Media(db.get_base_model()): type = peewee.ForeignKeyField(MediaType) preview = peewee.BlobField(null=True) remote_url = peewee.CharField(null=True) local_path = peewee.CharField(null=True) data = peewee.TextField(null=True) transfer_status = peewee.IntegerField(default=0) size = peewee.IntegerField(null=True) mimetype = peewee.CharField(null=True) filehash = peewee.CharField(null=True) filename = peewee.CharField(null=True) encoding = peewee.CharField(null=True) def toDict(self): media = { "type": self.type.name, "preview": self.preview, "remote_url": self.remote_url, "local_path": self.local_path, "data": self.data, "transfer_status": self.transfer_status, "size": self.size, "mimetype": self.mimetype, "filehash": self.filehash, "filename": self.filename, "encoding": self.encoding }
class Group(db.get_base_model()): jid = peewee.CharField(null=False) picture = peewee.BlobField(null=True) subject = peewee.CharField(null=True) subject_owner_id = peewee.ForeignKeyField(Contact, null=True) subject_time = peewee.DateTimeField(null=True) created = peewee.DateTimeField(default=datetime.datetime.now())
class State(db.get_base_model()): name = peewee.CharField(unique=True) @classmethod def init(cls): cls.get_or_create(name=STATE_RECEIVED) cls.get_or_create(name=STATE_RECEIVED_REMOTE) cls.get_or_create(name=STATE_RECEIVED_READ) cls.get_or_create(name=STATE_RECEIVED_READ_REMOTE) cls.get_or_create(name=STATE_SENT_QUEUED) cls.get_or_create(name=STATE_SENT) cls.get_or_create(name=STATE_SENT_DELIVERED) cls.get_or_create(name=STATE_SENT_READ) def __unicode__(self): return self.name @classmethod def get_received_read(cls): return cls.get(State.name == STATE_RECEIVED_READ) @classmethod def get_received_read_remote(cls): return cls.get(State.name == STATE_RECEIVED_READ_REMOTE) @classmethod def get_received(cls): return cls.get(State.name == STATE_RECEIVED) @classmethod def get_received_remote(cls): return cls.get(State.name == STATE_RECEIVED_REMOTE) @classmethod def get_sent_queued(cls): return cls.get(State.name == STATE_SENT_QUEUED) @classmethod def get_sent(cls): return cls.get(State.name == STATE_SENT) @classmethod def get_sent_delivered(cls): return cls.get(State.name == STATE_SENT_DELIVERED) @classmethod def get_sent_read(cls): return cls.get(State.name == STATE_SENT_READ)
class Contact(db.get_base_model()): number = peewee.CharField(unique=False, null=True) jid = peewee.CharField(null=False, unique=False) last_seen_on = peewee.DateTimeField(null=True) status = peewee.CharField(null=True) push_name = peewee.CharField(null=True) name = peewee.CharField(null=True) picture = peewee.BlobField(null=True) def toDict(self): return { "number": self.number, "jid": self.jid, "last_seen_on": self.last_seen_on, "status": self.status, "push_name": self.push_name, "name": self.name, "picture": self.picture }
class Message(db.get_base_model()): id_gen = peewee.CharField(null=False, unique=True) conversation = peewee.ForeignKeyField(Conversation) created = peewee.DateTimeField(default=datetime.datetime.now()) t_sent = peewee.DateTimeField(default=datetime.datetime.now()) content = peewee.TextField(null=True) media = peewee.ForeignKeyField(Media, null=True) def getMediaType(self): if self.media is not None: return self.media.type def getState(self): from messagestate import MessageState return MessageState.get_state(self) @classmethod def getByState(cls, states, conversation = None): from messagestate import MessageState query = (cls.select() .join(MessageState) .join(State)) if conversation: query = query.where(State.id << [state.id for state in states], Message.conversation == conversation) else: query = query.where(State.id << [state.id for state in states]) return query def toDict(self): return { "id": self.id_gen, "conversation": self.conversation.toDict(), "created": self.created, "content": self.content, "t_sent": self.t_sent, "type": MessageProtocolEntity.MESSAGE_TYPE_TEXT if self.media is None else MessageProtocolEntity.MESSAGE_TYPE_MEDIA, "media": self.media.toDict() if self.media is not None else None, "state": self.getState().name }
class MediaType(db.get_base_model()): name = peewee.CharField() def __unicode__(self): return self.name @classmethod def init(cls): cls.get_or_create(name=TYPE_IMAGE) cls.get_or_create(name=TYPE_AUDIO) cls.get_or_create(name=TYPE_VIDEO) cls.get_or_create(name=TYPE_VCARD) cls.get_or_create(name=TYPE_LOCATION) @classmethod def get_image(cls): return cls.get_mediatype(TYPE_IMAGE) @classmethod def get_audio(cls): return cls.get_meditype(TYPE_AUDIO) @classmethod def get_video(cls): return cls.get_mediatype(TYPE_VIDEO) @classmethod def get_vcard(cls): return cls.get_mediatype(TYPE_VCARD) @classmethod def get_location(cls): return cls.get_mediatype(TYPE_LOCATION) @classmethod def get_mediatype(cls, name): return cls.get(cls.name == name)
class Conversation(db.get_base_model()): contact = peewee.ForeignKeyField(Contact, null=True) group = peewee.ForeignKeyField(Group, null=True) broadcast = peewee.ForeignKeyField(Broadcast, null=True) created = peewee.DateTimeField(default=datetime.datetime.now()) def getType(self): if self.contact: return TYPE_CONTACT if self.group: return TYPE_GROUP if self.broadcast: return TYPE_BROADCAST def toDict(self): return { "contact": self.contact.toDict() if self.contact else None, "group": self.group.toDict() if self.group else None, "broadcast": self.broadcast.toDict() if self.broadcast else None, "type": self.getType(), "created": self.created }
class Status(db.get_base_model()): text = peewee.TextField() created = peewee.DateTimeField(default=datetime.datetime.now())
class MessageState(db.get_base_model()): message = peewee.ForeignKeyField(Message) state = peewee.ForeignKeyField(State) contact = peewee.ForeignKeyField(Contact, null=True) @classmethod def get_state(cls, message): try: return MessageState.get(message=message).state except peewee.DoesNotExist: return None @classmethod def update_received_state(cls, message, state): try: mstate = MessageState.get(message=message) except peewee.DoesNotExist: mstate = MessageState(message=message) mstate.state = state mstate.save() @classmethod def set_received(cls, message): cls.update_received_state(message, State.get_received()) @classmethod def set_received_read_remote(cls, message): cls.update_received_state(message, State.get_received_read_remote()) @classmethod def set_received_read(cls, message): cls.update_received_state(message, State.get_received_read()) @classmethod def set_received_remote(cls, message): cls.update_received_state(message, State.get_received_remote()) @classmethod def set_sent(cls, message): messageState = MessageState.get_or_create( message=message, state=State.get_sent_queued())[0] messageState.state = State.get_sent() messageState.save() @classmethod def set_sent_queued(cls, message): messageState = MessageState(message=message, state=State.get_sent_queued()) messageState.save() @classmethod def set_sent_delivered(cls, message, contact=None): if contact: messageState = MessageState.get(message=message, contact=contact) else: messageState = MessageState.get(message=message) messageState.state = State.get_sent_delivered() messageState.save() @classmethod def set_sent_read(cls, message, contact=None): if contact: messageState = MessageState.get(message=message, contact=contact) else: messageState = MessageState.get(message=message) messageState.state = State.get_sent_read() messageState.save()
class Broadcast(db.get_base_model()): wId = peewee.CharField() #Can't remember so far what that was for, but it's in openwa so maybe important created = peewee.DateTimeField(default=datetime.datetime.now())
class GroupContact(db.get_base_model()): contact = peewee.ForeignKeyField(Contact) group = peewee.ForeignKeyField(Group)
class BroadcastContact(db.get_base_model()): contact = peewee.ForeignKeyField(Contact) broadcast = peewee.ForeignKeyField(Broadcast)