class Bot(MongoModel):
_id = fields.BigIntegerField(required=True, primary_key=True)
bot_token = fields.CharField(required=True,
verbose_name='bot_token',
mongo_name='botToken')
bot_id = fields.BigIntegerField(required=True,
verbose_name='bot_id',
mongo_name='botId')
owner = fields.ReferenceField(User,
on_delete=fields.ReferenceField.CASCADE,
verbose_name='owner',
mongo_name='owner',
required=True)
name = fields.CharField(verbose_name='bot_name',
mongo_name='botName',
default=None)
username = fields.CharField(verbose_name='bot_username',
mongo_name='botUsername',
default=None,
validators=[validate_username])
profile_photo = fields.CharField(verbose_name='user_profile_photo',
mongo_name='profilePhoto',
default=None)
profile_thumbnail = fields.CharField(verbose_name='user_profile_thumbnail',
mongo_name='profileThumb',
default=None)
is_deleted = fields.BooleanField(verbose_name='bot_is_deleted',
mongo_name='isDeleted',
default=False)
join_date = fields.DateTimeField(verbose_name='bot_join_date',
mongo_name='joinedDate',
required=True)
deleted_date = fields.DateTimeField(verbose_name='bot_deleted_date',
mongo_name='deletedDate',
default=None)
class Meta:
connection_alias = 'Users'
collection_name = 'bots'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
indexes = [
IndexModel('botUsername',
name='botUsernameIndex',
unique=True,
sparse=True),
IndexModel('userId', name='botIdIndex', unique=True, sparse=True),
IndexModel('botToken',
name='botTokenIndex',
unique=True,
sparse=True)
]
ignore_unknown_fields = True
class EmpleadoModel(MongoModel):
nombre = fields.CharField()
paterno = fields.CharField()
materno = fields.CharField()
fecha_nacimiento = fields.DateTimeField()
fecha_contratacion = fields.DateTimeField()
direccion = fields.CharField()
ciudad = fields.CharField()
codigo_postal = fields.IntegerField()
telefono_movil = fields.BigIntegerField()
telefono_casa = fields.BigIntegerField()
correo = fields.EmailField()
puesto = fields.EmbeddedDocumentField(EmpleadoPuestoModel)
class User(MongoModel):
_id = fields.BigIntegerField(required=True, primary_key=True)
uid = fields.BigIntegerField(required=True,
verbose_name='user_id',
mongo_name='userId')
first_name = fields.CharField(verbose_name='user_first_name',
mongo_name='firstName',
default=None)
last_name = fields.CharField(verbose_name='user_first_name',
mongo_name='lastName',
default=None)
username = fields.CharField(verbose_name='user_username',
mongo_name='userUsername',
default=None,
validators=[validate_username])
profile_photo = fields.CharField(verbose_name='user_profile_photo',
mongo_name='profilePhoto',
default=None)
profile_thumbnail = fields.CharField(verbose_name='user_profile_thumbnail',
mongo_name='profileThumb',
default=None)
is_deleted = fields.BooleanField(verbose_name='user_is_deleted',
mongo_name='isDeleted',
default=False)
join_date = fields.DateTimeField(verbose_name='user_join_date',
mongo_name='joinedDate',
required=True)
deleted_date = fields.DateTimeField(verbose_name='user_deleted_date',
mongo_name='deletedDate',
default=None)
user_secure = fields.BinaryField(required=True,
verbose_name='user_secure',
mongo_name='secure')
class Meta:
connection_alias = 'Users'
collection_name = 'users'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
indexes = [
IndexModel('userUsername',
name='usernameIndex',
unique=True,
sparse=True),
IndexModel('userId', name='userIdIndex', unique=True, sparse=True)
]
ignore_unknown_fields = True
class PartyRequest(BasePyModelModel):
_COLLECTION_NAME = "party_requests"
class Meta:
final = True
collection_name = "party_requests"
STATUS_PENDING = "p"
STATUS_DECLINED = "d"
STATUS_ACCEPTED = "a"
STATUS_CANCELLED = "c"
PARTY_STATUSES = (
STATUS_PENDING,
STATUS_DECLINED,
STATUS_CANCELLED,
STATUS_ACCEPTED,
)
id = fields.BigIntegerField(primary_key=True)
from_ga = fields.ReferenceField(GuestAccount, required=True)
party = fields.ReferenceField(Party, required=True)
status = fields.CharField(choices=PARTY_STATUSES,
required=True,
default=STATUS_PENDING)
accepted_ts = fields.DateTimeField(blank=True)
class TwitterAccount(MongoModel):
"""
Schema for a twitter user
Properties:
phone_number -- note: will represent unique id
type: String
access_token -- access token
type: String
access_token_secret -- access token secret
type: String
api_key -- api key
type: String
api_secret_key -- api secret key
type: String
"""
access_token = fields.CharField(required=True)
access_token_secret = fields.CharField(required=True)
api_key = fields.CharField(required=True)
api_secret_key = fields.CharField(required=True)
last_msg = fields.BigIntegerField(required=False)
class User(MongoModel):
email = fields.EmailField(required=False, mongo_name='email')
name = fields.CharField(required=False, mongo_name='name')
mobile_no = fields.CharField(min_length=10,
max_length=10,
required=False,
mongo_name='mobile_no')
role = fields.CharField(choices=('mentor', 'student', 'admin'),
required=False,
mongo_name='role')
photo_url = fields.CharField(mongo_name='photo_url', default=None)
uploaded_photo_url = fields.CharField(mongo_name='uploaded_photo_url',
default=None)
user_token = fields.CharField(mongo_name='user_token')
user_group = fields.CharField(mongo_name='user_group', default=None)
nickname = fields.CharField(mongo_name='nickname')
preferences = fields.ListField(mongo_name='preferences')
created_at = fields.DateTimeField(mongo_name='created_at')
updated_at = fields.DateTimeField(mongo_name='updated_at')
linkedin = fields.CharField(mongo_name='linkedin')
certificates = fields.CharField(mongo_name='certificates')
courses = fields.CharField(mongo_name='courses')
background = fields.CharField(mongo_name='background')
mentor_verified = fields.BooleanField(mongo_name='mentor_verified',
default=False)
hours_per_day = fields.CharField(mongo_name='hours_per_day')
login_status = fields.BooleanField(mongo_name='login_status', default=True)
sessions = fields.BigIntegerField(mongo_name='sessions', default=0)
class Meta:
write_concern = WriteConcern(j=True)
ignore_unknown_fields = True
connection_alias = 'onx-app'
final = True
def clean(self):
if self.email != None:
self.check_duplicate_user()
self.validate_user_group()
def check_duplicate_user(self):
try:
User.objects.get({'email': self.email})
raise ValidationError('User with this email already exist')
except User.DoesNotExist:
pass
def validate_user_group(self):
try:
if self.user_group != None:
group = CorporateGroup.objects.get({'code': self.user_group})
self.user_group = str(group._id)
else:
pass
except Exception as e:
message = "Invalid corporate code." if str(e) == "" else str(e)
raise ValidationError(message)
class PremioModel(MongoModel):
# _id = fields.ObjectId()
nombre = fields.CharField()
puntos = fields.IntegerField()
codigo_barras = fields.BigIntegerField()
codigo_qr = fields.CharField()
imagen_icon = fields.CharField()
imagen_display = fields.CharField()
fecha_creacion = fields.DateTimeField()
fecha_vigencia = fields.DateTimeField()
vidas = fields.IntegerField(blank=True, required=False, default=1)
# TODO: Default 1 es correcto?: Por ahora hace match con el acoplamiento anterior del sistema pero, ¿hay EdgeCases?
# fecha_redencion = fields.DateTimeField()
#id_producto = fields.ReferenceField(Producto)
# id_participante = fields.ReferenceField(ParticipanteModel) Quita al poner la segmentación: "ninguna"
@classmethod
def find_by_id(cls, _Objectid: str) -> "PremioModel":
try:
oid = ObjectId(_Objectid)
notif = cls.objects.get({'_id': oid})
print(notif)
return notif
except cls.DoesNotExist:
return None
# Filtros es una lista de ids de participantes a los cuales se les enviara la notificacion
@classmethod
def send_to_participantes(cls, n):
try:
filtersObids = []
if not "filtros" in n:
return {
"message":
"Error: Sin destinatarios, debe haber al menos un participante a quien enviarle esta acción"
}
for fil in n.filtros:
filtersObids.append(ObjectId(fil))
# Enviar a todos los participantes
for par in ParticipanteModel.objects.raw(
{"_id": {
"$in": filtersObids
}}):
# part_id = ObjectId(id)
notif = PremioParticipanteModel(
id_participante=par._id,
id_premio=n.link,
fecha_creacion=dt.datetime.now(),
estado=0,
# Estado puede servir para actualizar tambien OJO! ahora esta fijo, pero podrías ser variable
).save()
return {"status": 200, "total": len(filtersObids)}
# PYMODM no tiene soporte transaccional, en un futuro migrar a PYMONGO, que sí tiene soporte
# return {"message": "Notificacion guardada con éxito."}
except ValidationError as exc:
print(exc.message)
return {"status": 404}
class ProveedorModel(MongoModel):
nombre_compania = fields.CharField()
nombre_contacto = fields.CharField()
direccion = fields.CharField()
ciudad = fields.CharField()
region = fields.CharField()
codigo_postal = fields.IntegerField()
pais = fields.CharField()
telefono = fields.BigIntegerField()
imagen = fields.CharField()
class GuestAccount(BasePyModelModel):
_COLLECTION_NAME = "guest_accounts"
class Meta:
final = True
collection_name = "guest_accounts"
id = fields.BigIntegerField(primary_key=True)
first_name = fields.CharField(required=True)
last_name = fields.CharField(required=True)
email = fields.EmailField(required=True)
class Reaction(EmbeddedMongoModel):
"""
"""
reactions = fields.EmbeddedDocumentListField(ReactionObj,
verbose_name='reactions_list',
mongo_name='reactions')
total_count = fields.BigIntegerField(required=True,
verbose_name='total_count',
mongo_name='totalCount',
min_value=0,
default=0)
class Party(BasePyModelModel):
_COLLECTION_NAME = "parties"
class Meta:
final = True
collection_name = "parties"
id = fields.BigIntegerField(primary_key=True)
title = fields.CharField(required=True)
address = fields.CharField(blank=True)
start_time = fields.DateTimeField(blank=True)
end_time = fields.DateTimeField(blank=True)
owner_ga = fields.ReferenceField(GuestAccount, required=True)
class Patient(MongoModel):
"""
Data Class used by MongoDB
"""
from pymodm import fields
patient_id = fields.BigIntegerField(primary_key=True)
attending_email = fields.EmailField()
user_age = fields.IntegerField()
last_heart_rate = fields.IntegerField()
last_timestamp = fields.DateTimeField()
heart_rates = fields.ListField()
timestamps = fields.ListField()
class Channel(MongoModel):
_id = fields.BigIntegerField(required=True, primary_key=True)
chid = fields.BigIntegerField(required=True, verbose_name='channel_id', mongo_name='channelId')
title = fields.CharField(verbose_name='channel_title', mongo_name='channelTitle', default='')
description = fields.CharField(verbose_name='channel_description', mongo_name='channelDescription', default=None)
username = fields.CharField(verbose_name='channel_username',
mongo_name='channelUsername', default=None, validators=[validate_username])
private_link = fields.CharField(verbose_name='channel_private_link', mongo_name='channelPrivateLink',
default=None)
photo_id = fields.CharField(verbose_name='channel_photo', mongo_name='channelPhoto', default=None)
creator = fields.ReferenceField(User, on_delete=fields.ReferenceField.CASCADE,
verbose_name='channel_creator', mongo_name='channelCreator', required=True)
channel_bot = fields.ReferenceField(Bot, on_delete=fields.ReferenceField.NULLIFY, verbose_name='channel_bot',
mongo_name='channelBot', default=None)
authorized_admins = fields.EmbeddedDocumentListField(ChannelAdmin,
verbose_name='authorized_channel_admins',
mongo_name='channelAdmins')
is_deleted = fields.BooleanField(verbose_name='channel_is_deleted', mongo_name='isDeleted', default=False)
added_date = fields.DateTimeField(verbose_name='channel_added_date', mongo_name='joinDate', required=True)
deleted_date = fields.DateTimeField(verbose_name='user_deleted_date', mongo_name='deletedDate', default=None)
class Meta:
connection_alias = 'Channels'
collection_name = 'channels'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
indexes = [
IndexModel('channelUsername', name='channelUsernameIndex', unique=True, sparse=True),
IndexModel('channelId', name='channelIdIndex', unique=True, sparse=True),
IndexModel('channelCreator', name='channelCreatorIndex', sparse=True),
IndexModel('channelAdmins', name='channelAdminsIndex', sparse=True),
IndexModel('channelBot', name='channelBotIndex', sparse=True)
]
ignore_unknown_fields = True
class GlobalPostAnalytics(MongoModel):
_id = fields.IntegerField(required=True, primary_key=True, default=0)
created_posts = fields.BigIntegerField(required=True,
verbose_name='created_posts',
mongo_name='createdPosts',
min_value=0,
default=0)
added_posts = fields.BigIntegerField(required=True,
verbose_name='added_posts',
mongo_name='addedPosts',
min_value=0,
default=0)
edited_posts = fields.BigIntegerField(required=True,
verbose_name='edited_posts',
mongo_name='editedPosts',
min_value=0,
default=0)
deleted_posts = fields.BigIntegerField(required=True,
verbose_name='deleted_posts',
mongo_name='deletedPosts',
min_value=0,
default=0)
global_reactions = fields.BigIntegerField(required=True,
verbose_name='global_reactions',
mongo_name='globalReactions',
min_value=0,
default=0)
class Meta:
connection_alias = 'Posts'
collection_name = 'global_analytics'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
ignore_unknown_fields = True
class PartyChatMessage(BasePyModelModel):
_COLLECTION_NAME = "party_chat_messages"
class Meta:
final = True
collection_name = "party_chat_messages"
id = fields.BigIntegerField(primary_key=True)
from_ga = fields.ReferenceField(GuestAccount, required=True)
party = fields.ReferenceField(Party, required=True)
message = fields.CharField(blank=True)
# This could be used when you have to introduce reply to message and so ?
parent_chat_message = fields.ReferenceField("PartyChatMessage",
required=False,
blank=True)
class __ApplicationAdministration(MongoModel):
_id = fields.IntegerField(required=True, primary_key=True, default=0)
created_apps = fields.BigIntegerField(required=True,
verbose_name='created_apps',
mongo_name='createdApps',
min_value=0,
default=0)
class Meta:
connection_alias = 'Application'
collection_name = 'appsMeta'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
ignore_unknown_fields = True
class UserReaction(MongoModel):
"""
"""
user_id = fields.BigIntegerField(verbose_name='user_id',
mongo_name='userId',
required=True)
post = fields.ReferenceField(PostModel,
on_delete=fields.ReferenceField.CASCADE,
verbose_name='post_id',
mongo_name='postId',
required=True)
reaction_index = fields.IntegerField(required=True,
verbose_name='reaction_index',
mongo_name='reactionIndex',
min_value=0,
max_value=3)
reaction_date = fields.DateTimeField(required=True,
verbose_name='reaction_date',
mongo_name='reactionDate')
class Meta:
connection_alias = 'Posts'
collection_name = 'reactions'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
indexes = [
IndexModel('userId', name='userReactionUserIdIndex', sparse=True),
IndexModel('reactionIndex',
name='userReactionReactionIndexIndex',
sparse=True),
IndexModel('reactionDate',
name='userReactionDateIndex',
sparse=True),
IndexModel('postId', name='postIdIndex', sparse=True)
]
ignore_unknown_fields = True
class Tweet(MongoModel):
idPrimary = fields.BigIntegerField(primary_key=True)
idTweet = fields.CharField()
idUsername = fields.CharField()
tweet = fields.CharField()
date_created = fields.DateTimeField()
hashtags = fields.ListField()
location = fields.CharField()
favorite = fields.IntegerField()
retweet = fields.IntegerField()
users_mentioned = fields.ListField()
posemote = fields.IntegerField()
negemote = fields.IntegerField()
unigram = fields.ListField()
bigram = fields.ListField()
trigram = fields.ListField()
cand_ana = fields.ListField()
class Meta:
write_concern = WriteConcern(j=True)
connection_alias = 'athenaDB'
class PostModel(BasePostModel):
from .reactions_model import Reaction
"""
Generic Post Model, should not be directly used, there are
fields that needs to be implemented for normal Posts.
"""
message_id = fields.BigIntegerField(required=True,
verbose_name='post_message_id',
mongo_name='messageId')
mime_type = fields.CharField(verbose_name='post_mime_type',
mongo_name='mimeType',
default=None)
type = fields.CharField(verbose_name='post_type',
mongo_name='type',
required=True,
choices=('image', 'text', 'video', 'animation',
'document', 'video_note', 'voice',
'audio', 'location', 'venue'))
group_hash = fields.CharField(verbose_name='group_hash',
mongo_name='groupHash',
default=None)
created_date = fields.DateTimeField(required=True,
verbose_name='post_created_date',
mongo_name='createdDate')
tags = fields.ListField(field=fields.CharField(),
verbose_name='tags',
mongo_name='tags',
default=None)
source = fields.EmbeddedDocumentField(Link,
verbose_name='source',
mongo_name='source',
default=None)
links = fields.EmbeddedDocumentField(LinkList,
verbose_name='links',
mongo_name='links',
default=None)
reactions = fields.EmbeddedDocumentField(Reaction,
verbose_name='reactions',
mongo_name='reactions',
default=None)
is_deleted = fields.BooleanField(verbose_name='post_is_deleted',
mongo_name='isDeleted',
default=False)
deleted_date = fields.DateTimeField(verbose_name='post_deleted_date',
mongo_name='deletedDate',
default=None)
class Meta:
connection_alias = 'Posts'
collection_name = 'posts'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
indexes = [
IndexModel('creator', name='postCreatorIndex', sparse=True),
IndexModel('postId', name='postIdIndex', unique=True, sparse=True),
IndexModel('groupHash',
name='postGroupHashIndex',
unique=True,
sparse=True),
IndexModel('messageId', name='postMessageIdIndex', sparse=True),
IndexModel('channelId', name='postChannelIdIndex', sparse=True),
IndexModel('createdDate', name='postCreatedDateIndex', sparse=True)
]
ignore_unknown_fields = True
@property
def dict(self):
return dict(post_id=self.post_id,
message_id=self.message_id,
creator=self.creator,
channel=self.channel,
type=self.type,
mime_type=self.mime_type,
group=self.group_hash,
created_date=self.created_date,
tags=self.tags,
links=dict(links_per_row=self.links.links_per_row,
links=[{
'label': i.label,
'url': i.url
} for i in self.links.links]),
source=dict(label=self.source.label, url=self.source.url),
reactions=[
dict(emoji=i.emoji, count=i.count)
for i in self.reactions.reactions
])
class User(MongoModel):
patient_id = fields.IntegerField(primary_key=True)
attending_email = fields.EmailField()
user_age = fields.FloatField()
heart_rate = fields.ListField(field=fields.BigIntegerField())
time_stamp = fields.ListField(field=fields.DateTimeField())
class Stock(MongoModel):
key = fields.CharField(blank=False, primary_key=True)
ticker = fields.CharField(blank=False)
close = fields.FloatField(blank=True)
volume = fields.BigIntegerField(blank=True)
date = fields.DateTimeField(blank=False)
class CommentRank(EmbeddedMongoModel):
rank_up_count = fields.BigIntegerField(verbose_name='rank_up_count', mongo_name='upCount', min_value=0,
default=0)
rank_down_count = fields.BigIntegerField(verbose_name='rank_down_count', mongo_name='downCount', min_value=0,
default=0)
