class PostLike(Document):
member = ReferenceField(Member, required=True, description='글쓴이(member_id)')
post = ReferenceField(Post, required=True, description='게시물 아이디')
status = StringField(description='좋아요 상태')
class GroupMembership(me.Document):
user = ReferenceField(User)
group = ReferenceField(Group)
class Comment(EmbeddedDocument):
cid = ObjectIdField(default=lambda: ObjectId())
author = ReferenceField(User)
content = StringField()
reply = ObjectIdField()
class Sockets(Document):
client = ReferenceField(Client, required=True)
fd = IntField(unique=True, required=True)
class User(Document, BaseEventumDocument):
"""A user model.
The :class:`User` object is only created once the user logs in for the
first time and confirms the details of their account.
:ivar date_created: :class:`mongoengine.fields.DateTimeField` - The date
that this user was created.
:ivar date_modified: :class:`mongoengine.fields.DateTimeField` - The date
the this user was last modified.
:ivar gplus_id: :class:`mongoengine.fields.StringField` - The Google+ ID
for this user. It's what we use in the Google+ authentication.
:ivar name: :class:`mongoengine.fields.StringField` - The user's name.
:ivar slug: :class:`mongoengine.fields.StringField` - A URL slug their
internal profile page.
:ivar email: :class:`mongoengine.fields.EmailField` - The user's email
address.
:ivar roles: :class:`mongoengine.fields.ListField` of
:class:`mongoengine.fields.StringField` - A list of roles that the user
has.
:ivar privileges: :class:`mongoengine.fields.DictField` - A dictionary of
privileges that the user has. Often determined soley by their
``user_type``.
:ivar image_url: :class:`mongoengine.fields.URLField` - The URL of the
profile picture for the user's profile picture.
:ivar image: :class:`mongoengine.fields.ReferenceField` - The local image
for the user's profile picture.
:ivar user_type: :class:`mongoengine.fields.StringField` - The type of the
user. Can either be ``"fake_user"``, ``"editor"``, ``"publisher"``, or
``"admin"``. The selection of user type determines their
``privileges``.
:ivar last_logon: :class:`mongoengine.fields.DateTimeField` - The date of
this user's last logon.
"""
date_created = DateTimeField(required=True, default=now)
date_modified = DateTimeField(required=True, default=now)
gplus_id = StringField(required=True, unique=True)
name = StringField(required=True, max_length=510)
slug = StringField(required=True,
max_length=510,
unique=True,
regex=Regex.SLUG_REGEX)
email = EmailField(required=True, unique=True)
roles = ListField(StringField(db_field="role"), default=list)
privileges = DictField(required=True, default={})
image_url = URLField()
image = ReferenceField('Image')
user_type = StringField(default='editor', regex=USER_TYPE_REGEX)
last_logon = DateTimeField()
# MongoEngine ORM metadata
meta = {'allow_inheritance': True, 'indexes': ['email', 'gplus_id']}
def can(self, privilege):
"""Returns True if the user has ``privilege``.
:returns: True if the user has ``privilege``
:rtype: bool
"""
return self.privileges.get(privilege)
def get_profile_picture(self, size=50):
"""Returns the url to the profile picture for the user.
TODO: This method needs major fixing. What's going on with that URL?
:param int size: The size of the image to pass, if the size can be
changed.
:returns: The URL of the image.
:rtype: str
"""
if self.image:
return self.image.url()
if not self.image_url:
# Import app in the function body to avoid importing `None` when
# the module is first loaded.
return url_for(
'eventum.static',
filename=current_app.config['EVENTUM_DEFAULT_PROFILE_PICTURE'])
if "googleusercontent.com" in self.image_url:
return self.image_url + str(size)
return self.image_url
def register_login(self):
"""Update the model as having logged in."""
self.last_logon = now()
def clean(self):
"""Called by Mongoengine on every ``.save()`` to the object.
Update date_modified and apply privileges shorthand notation.
:raises: :class:`wtforms.validators.ValidationError`
"""
self.date_modified = now()
# Update self.privileges with one of the USER_TYPES dictionaries
self.privileges.update(USER_TYPES[self.user_type])
# Update the slug for the user (used in URLs)
new_slug = self.name.lower().replace(' ', '-')
new_slug = re.sub(r"\'|\.|\_|", "", new_slug)
if User.objects(slug=new_slug).count() > 0:
i = 2
new_slug = new_slug + "-{}".format(i)
while User.objects(slug=new_slug).count() > 0:
i += 1
new_slug = re.sub(r"-([0-9])*$", "-{}".format(i), new_slug)
self.slug = new_slug
if self.image_url and "googleusercontent.com" in self.image_url:
self.image_url = re.sub(r"sz=([0-9]*)$", "sz=", self.image_url)
def id_str(self):
"""The id of this object, as a string.
:returns: The id
:rtype: str
"""
return str(self.id)
def role(self):
"""Returns the role of the user, in plain English. It is either
``"Admin"``, ``"Publisher"``, ``"Editor"``, or ``"Fake User"``.
:returns: The role.
:rtype: str
"""
if self.can('admin'):
return "Admin"
if self.can('publish'):
return "Publisher"
if self.can('edit'):
return "Editor"
return "Fake User"
def __repr__(self):
"""The representation of this user.
:returns: The user's details.
:rtype: str
"""
return ('User(id=%r, name=%r, email=%r, roles=%r, privileges=%r, '
'gplus_id=%r, date_created=%r)' %
(self.id, self.name, self.email, self.roles, self.privileges,
self.gplus_id, self.date_created))
def __unicode__(self):
"""This user, as a unicode string.
:returns: The user encoded as a string.
:rtype: str
"""
if self.can('admin'):
return '%r <%r> (Admin)' % (self.name, self.email)
if self.can('publish'):
return '%r <%r> (Publisher)' % (self.name, self.email)
if self.can('edit'):
return '%r <%r> (Editor)' % (self.name, self.email)
else:
return '%r <%r> (Fake User)' % (self.name, self.email)
class RunningModule(EmbeddedDocument):
module = ReferenceField('Module')
version = StringField()
class SummonerDoc(Document):
name = StringField()
game_refs = ListField(ReferenceField('GameDoc'))
class Tip(Document):
from_user = ReferenceField(User, required=True)
to_user = ReferenceField(User, required=True)
amount = LongField(required=True)
date = DateTimeField(required=True)
tx_hash = StringField()
class Withdrawal(Document):
user = ReferenceField(User, required=True)
amount = LongField(required=True)
date = DateTimeField(required=True)
tx_hash = StringField()
class Signatures(Document):
tx_id = ReferenceField(Swap, required=True)
signed_tx = StringField(required=True)
signer = StringField(required=True)
creation = DateTimeField(default=datetime.now, required=True)
class Offer(BaseDocument):
TYPE_CREDIT = 'credit'
TYPE_FUTURES = 'futures'
TYPE_FACTORING = 'factoring'
salesman = ReferenceField('User',
reverse_delete_rule=mongoengine.NULLIFY,
default=None)
type = StringField(choices=(TYPE_CREDIT, TYPE_FUTURES, TYPE_FACTORING),
default=None)
description = StringField(default=None)
zip_code = StringField(default=None)
reg_service = StringField(default=None)
options = DictField(default={})
price = IntField(default=None)
bc_hash = StringField(default=None)
ru_card = DictField(default=None)
en_card = DictField(default=None)
creation_date = DateTimeField()
update_date = DateTimeField()
@property
def fprice(self):
try:
return '{:,}'.format(self.price).replace(',', ' ')
except:
return ''
def process(self, bot):
offer_type = bot.match_command(
bot.t(['SELL_CREDIT', 'SELL_FUTURES', 'SELL_FACTORING']))
if offer_type and self.type is None:
self.set_type(bot, offer_type.get('command'))
if self.type == self.TYPE_CREDIT:
return bot.send(bot.t('CREDIT_ENTER_DESC'),
reply_markup=ReplyKeyboardHide())
elif self.type == self.TYPE_FUTURES:
return bot.send(bot.t('FUTURES_ENTER_DESC'),
reply_markup=ReplyKeyboardHide())
elif self.type == self.TYPE_FACTORING:
return bot.send(bot.t('FACTORING_ENTER_DESC'),
reply_markup=ReplyKeyboardHide())
if self.type == self.TYPE_CREDIT:
self._process_credit(bot)
elif self.type == self.TYPE_FUTURES:
self._process_futures(bot)
elif self.type == self.TYPE_FACTORING:
self._process_factoring(bot)
def _process_credit(self, bot):
if self.description is None:
self.description = bot.text
bot.send(bot.t('CREDIT_ENTER_ZIP'))
elif self.zip_code is None:
self.zip_code = bot.text
bot.send(bot.t('CREDIT_ENTER_REG_SERVICE'))
elif self.reg_service is None:
self.reg_service = bot.text
bot.send(bot.t('CREDIT_ENTER_LOAN_ID'))
elif self.options.get('loan_id') is None:
self.options['loan_id'] = bot.text
bot.send(bot.t('CREDIT_ENTER_LOAN_AMOUNT'))
elif self.options.get('loan_amount') is None:
self.options['loan_amount'] = utils.to_int(bot.text, None)
if self.options['loan_amount'] is None:
return bot.send(bot.t('ENTER_NUMBER'))
bot.send(bot.t('CREDIT_ENTER_INTEREST_RATE'))
elif self.options.get('interest_rate') is None:
self.options['interest_rate'] = bot.text
bot.send(bot.t('CREDIT_ENTER_LOAN_LENGTH'))
elif self.options.get('loan_length') is None:
self.options['loan_length'] = bot.text
bot.send(bot.t('CREDIT_ENTER_LOAN_STATUS'),
reply_markup=ReplyKeyboard([[bot.t('LOAN_STATUS_EARLY')],
[bot.t('LOAN_STATUS_NORMAL')],
[bot.t('LOAN_STATUS_LATE')]]))
elif self.options.get('loan_status') is None:
self.options['loan_status'] = bot.text
bot.send(bot.t('CREDIT_ENTER_SELLERS_WARRANTY'),
reply_markup=ReplyKeyboard([[
bot.t('WARRANTY_FULL'),
bot.t('WARRANTY_PARTLY'),
bot.t('WARRANTY_NONE')
]],
one_time_keyboard=True))
elif self.options.get('sellers_warranty') is None:
self.options['sellers_warranty'] = bot.text
bot.send(bot.t('CREDIT_ENTER_PRICE'),
reply_markup=ReplyKeyboardHide())
elif self.price is None:
self.price = utils.to_int(bot.text, None)
if self.price is None:
return bot.send(bot.t('ENTER_NUMBER'))
self._create_contract_send(bot)
else:
self._create_contract_process(bot)
def _process_futures(self, bot):
if self.description is None:
self.description = bot.text
bot.send(bot.t('FUTURES_ENTER_ZIP'))
elif self.zip_code is None:
self.zip_code = bot.text
bot.send(bot.t('FUTURES_ENTER_REG_SERVICE'))
elif self.reg_service is None:
self.reg_service = bot.text
bot.send(bot.t('FUTURES_ENTER_LOAN_ID'))
elif self.options.get('loan_id') is None:
self.options['loan_id'] = bot.text
bot.send(bot.t('FUTURES_CHOOSE_CONTRACT_TYPE'),
reply_markup=ReplyKeyboard([
[bot.t('FUTURES_TYPE_SETTLEMENT')],
[bot.t('FUTURES_TYPE_DELIVERABLE')],
],
one_time_keyboard=True))
elif self.options.get('contract_type') is None:
self.options['contract_type'] = bot.text
bot.send(bot.t('FUTURES_ENTER_CONTRACT_SIZE'),
reply_markup=ReplyKeyboardHide())
elif self.options.get('contract_size') is None:
self.options['contract_size'] = bot.text
bot.send(bot.t('FUTURES_CONTRACT_MATURITY'))
elif self.options.get('contract_maturity') is None:
self.options['contract_maturity'] = bot.text
bot.send(bot.t('FUTURES_ENTER_DELIVERY_DATE'))
elif self.options.get('delivery_date') is None:
self.options['delivery_date'] = bot.text
bot.send(bot.t('FUTURES_PRICE'))
elif self.price is None:
self.price = utils.to_int(bot.text, None)
if self.price is None:
return bot.send(bot.t('ENTER_NUMBER'))
self._create_contract_send(bot)
else:
self._create_contract_process(bot)
def _process_factoring(self, bot):
if self.description is None:
self.description = bot.text
bot.send(bot.t('FACTORING_ENTER_ZIP'))
elif self.zip_code is None:
self.zip_code = bot.text
bot.send(bot.t('FACTORING_ENTER_REG_SERVICE'))
elif self.reg_service is None:
self.reg_service = bot.text
bot.send(bot.t('FACTORING_ENTER_LOAN_ID'))
elif self.options.get('loan_id') is None:
self.options['loan_id'] = bot.text
bot.send(bot.t('FACTORING_PAY_REQS'),
reply_markup=ReplyKeyboard([
[bot.t('FACTORING_REGRESS')],
[bot.t('FACTORING_NO_REGRESS')],
],
one_time_keyboard=True))
elif self.options.get('pay_reqs') is None:
self.options['pay_reqs'] = bot.text
bot.send(bot.t('FACTORING_TITLE_SUPPLIER'),
reply_markup=ReplyKeyboardHide())
elif self.options.get('title_supplier') is None:
self.options['title_supplier'] = bot.text
bot.send(bot.t('FACTORING_SUM_REQS'))
elif self.options.get('sum_reqs') is None:
self.options['sum_reqs'] = bot.text
bot.send(bot.t('FACTORING_DATE_REQS_PAY'))
elif self.options.get('date_reqs_pay') is None:
self.options['date_reqs_pay'] = bot.text
bot.send(bot.t('FACTORING_PRICE'))
elif self.price is None:
self.price = utils.to_int(bot.text, None)
if self.price is None:
return bot.send(bot.t('ENTER_NUMBER'))
self._create_contract_send(bot)
else:
self._create_contract_process(bot)
@gen.coroutine
def _create_contract_send(self, bot):
try:
bot.send(bot.t('GENERATE_PREVIEW_START'))
yield self.generate_img(lang=bot.user.lang)
path = self.get_image_path(bot.user.lang)
if not path:
raise Exception
with open(path, 'rb') as f:
yield bot.send_photo(files=(('photo', path, f.read()), ),
caption=bot.t('GENERATE_PREVIEW_END'))
except Exception as e:
bot.send(bot.t('GENERATE_PREVIEW_FAIL'))
traceback.print_exc()
bot.send(bot.t('SAIL_YOU_CREATE_CONTRACT'),
reply_markup=ReplyKeyboard([[
bot.t('YES_APPROVE'),
bot.t('NO_FEAR'),
bot.t('WHAT_IS_BLOCKCHAIN')
]],
one_time_keyboard=False))
@gen.coroutine
def _create_contract_process(self, bot):
if bot.match_command(bot.t('YES_APPROVE')):
bot.send(bot.t('REGISTER_BC_BEGIN'),
reply_markup=ReplyKeyboardHide())
# рега в реестре
yield gen.sleep(1)
self.bc_hash = PasswordHelper.get_hash(datetime.now().isoformat())
# генерация картинок
yield self.generate_img()
self.salesman = self.salesman
self.save()
bot._on_start(welcome_text=bot.t('REGISTER_BC_END'),
keyboard=ReplyKeyboard([[bot.t('THNX_UNDERSTAND')]]))
elif bot.match_command(bot.t('NO_FEAR')):
bot._on_start(welcome_text=bot.t('FEAR_BLOCKCHAIN_WIKI'))
elif bot.match_command(bot.t('WHAT_IS_BLOCKCHAIN')):
bot.send(bot.t('WHAT_IS_BLOCKCHAIN_WIKI'))
@gen.coroutine
def generate_img(self, sync=False, *args, **kwargs):
if sync:
client = HTTPClient()
else:
client = AsyncHTTPClient()
if kwargs.get('lang') in [None, Text.LANG_RU]:
# генерация русской карточки
req = HTTPRequest(
get_screenshot_img_url(self.get_id(), Text.LANG_RU))
if sync:
res = client.fetch(req)
else:
res = yield client.fetch(req)
ru_path = gen_path()
mkdir(ru_path.get('folder'))
with open(ru_path.get('fullname'), "wb") as f:
f.write(res.body)
self.ru_card = ru_path
if kwargs.get('lang') in [None, Text.LANG_EN]:
# генерация английской карточки
req = HTTPRequest(
get_screenshot_img_url(self.get_id(), Text.LANG_EN))
if sync:
res = client.fetch(req)
else:
res = yield client.fetch(req)
en_path = gen_path()
mkdir(en_path.get('folder'))
with open(en_path.get('fullname'), "wb") as f:
f.write(res.body)
self.en_card = en_path
def get_image_path(self, lang):
path = None
if lang == Text.LANG_RU:
if self.ru_card is None:
return False
path = self.ru_card.get('relname')
elif lang == Text.LANG_EN:
if self.en_card is None:
return False
path = self.en_card.get('relname')
if path is None:
return False
return '%s/%s' % (options.upload_path, path)
def set_type(self, bot, offer_type):
if offer_type == bot.t('SELL_CREDIT'):
self.type = Offer.TYPE_CREDIT
elif offer_type == bot.t('SELL_FUTURES'):
self.type = Offer.TYPE_FUTURES
elif offer_type == bot.t('SELL_FACTORING'):
self.type = Offer.TYPE_FACTORING
def save(self, *args, **kwargs):
if not self.creation_date:
self.creation_date = datetime.now(tz=timezone('UTC'))
self.update_date = datetime.now(tz=timezone('UTC'))
return super(Offer, self).save(*args, **kwargs)
def to_dict_impl(self, **kwargs):
return {
'id': self.get_id(),
'type': self.type,
'description': self.description,
'creation_date': self.creation_date,
'zip_code': self.zip_code,
'reg_service': self.reg_service,
'options': self.options,
'price': self.price,
'salesman': self.salesman.to_dict() if self.salesman else None,
'bc_hash': self.bc_hash
}
class Account(Document, BaseModel):
created_at = date_now()
updated_at = DateTimeField()
estado: Enum = EnumField(Estado, default=Estado.created)
nombre = StringField()
apellido_paterno = StringField()
apellido_materno = StringField(required=False)
cuenta = StringField(unique=True)
rfc_curp = StringField()
telefono = StringField()
genero = EnumField(Genero, required=False) # type: ignore
fecha_nacimiento = DateTimeField(required=False)
entidad_federativa = IntField(required=False)
actividad_economica = IntField(required=False)
calle = StringField(required=False)
numero_exterior = StringField(required=False)
numero_interior = StringField(required=False)
colonia = StringField(required=False)
alcaldia_municipio = StringField(required=False)
cp = StringField(required=False)
pais = IntField(required=False)
email = StringField(required=False)
id_identificacion = StringField(required=False)
events = ListField(ReferenceField(Event))
def create_account(self) -> CuentaFisica:
self.estado = Estado.submitted
self.save()
optionals = dict(
apellidoMaterno=self.apellido_materno,
genero=self.genero,
fechaNacimiento=self.fecha_nacimiento,
entidadFederativa=self.entidad_federativa,
actividadEconomica=self.actividad_economica,
calle=self.calle,
numeroExterior=self.numero_exterior,
numeroInterior=self.numero_interior,
colonia=self.colonia,
alcaldiaMunicipio=self.alcaldia_municipio,
cp=self.cp,
pais=self.pais,
email=self.email,
idIdentificacion=self.id_identificacion,
)
# remove if value is None
optionals = {key: val for key, val in optionals.items() if val}
try:
cuenta = stpmex_client.cuentas.alta(
nombre=self.nombre,
apellidoPaterno=self.apellido_paterno,
cuenta=self.cuenta,
rfcCurp=self.rfc_curp,
telefono=self.telefono,
**optionals,
)
except Exception as e:
self.events.append(Event(type=EventType.error, metadata=str(e)))
self.estado = Estado.error
self.save()
raise e
else:
self.estado = Estado.succeeded
self.save()
return cuenta
def update_account(self, account: 'Account') -> None:
optionals = dict(
apellidoMaterno=account.apellido_materno,
genero=account.genero,
fechaNacimiento=account.fecha_nacimiento,
entidadFederativa=account.entidad_federativa,
actividadEconomica=account.actividad_economica,
calle=account.calle,
numeroExterior=account.numero_exterior,
numeroInterior=account.numero_interior,
colonia=account.colonia,
alcaldiaMunicipio=account.alcaldia_municipio,
cp=account.cp,
pais=account.pais,
email=account.email,
idIdentificacion=account.id_identificacion,
)
# remove if value is None
optionals = {key: val for key, val in optionals.items() if val}
self.rfc_curp = account.rfc_curp
self.nombre = account.nombre
self.apellido_paterno = account.apellido_paterno
self.apellido_materno = account.apellido_materno
self.genero = account.genero
self.fecha_nacimiento = account.fecha_nacimiento
self.actividad_economica = account.actividad_economica
self.calle = account.calle
self.numero_exterior = account.numero_exterior
self.numero_interior = account.numero_interior
self.colonia = account.colonia
self.alcaldia_municipio = account.alcaldia_municipio
self.cp = account.cp
self.pais = account.pais
self.email = account.email
self.id_identificacion = account.id_identificacion
self.estado = Estado.succeeded
self.save()
class ServicePort(Document):
port = IntField(default=0)
ip = StringField(default="")
name = StringField(default="")
cluster = ReferenceField(Cluster, reverse_delete_rule=CASCADE)
class Container(Document):
id = StringField(default="", primary_key=True)
name = StringField(default="")
cluster = ReferenceField(Cluster, reverse_delete_rule=CASCADE)
class Habit(Document):
name = StringField(max_length=120, required=True)
description = StringField(max_length=5000)
user = ReferenceField(User, reverse_delete_rule=CASCADE)
num_Days = IntField(default=30)
repeat = ListField(StringField(max_length=10))
streak = 0
is_public = StringField(requried=True, default="false", max_length=120)
string_start = StringField(required=True,
default=datetime.datetime.strftime(
datetime.datetime.now(), "%B %m, %Y"))
start_Date = DateTimeField(required=True, default=datetime.datetime.now())
curr_Date = DateTimeField(required=True, default=datetime.datetime.now())
end_Date = DateTimeField(required=True, default=datetime.datetime.now())
habit_data = ListField(ListField(max_length=3, required=True))
complete = 0
monthDict = {
1: 31,
2: 28,
3: 31,
4: 30,
5: 31,
6: 30,
7: 31,
8: 31,
9: 30,
10: 31,
11: 30,
12: 31
}
def Habit(self, name, days, end_Date):
self.name = name
self.days = days
self.start_Date = [
timer.strftime("%m"), timer.strftime("%d")
] #A list with the month in mm format and day in the dd format
self.start_Day = int(timer.day())
self.curr_Day = int(timer.day())
self.end_Date = end_Date
# def habits(self, name, days, end_Date):
# self.name = name
# self.days = days
# self.start_Date = [timer.strftime("%m"), timer.strftime("%d")] #A list with the month in mm format and day in the dd format
# self.start_Day = int(timer.day())
# self.curr_Day = int(timer.day())
# self.end_Date = end_Date
def setName(self, name):
self.name = name
def getName(self):
return self.name
def setDays(self, days):
self.days = days
def getDays(self):
return self.days
def setStreak(self, num):
self.streak = num
def getStreak(self):
return self.streak
def setStartDay(self, day):
self.start_Day = day
def getStartDay(self):
return self.start_Day
def setStartDate(self, date):
self.start_Date = date
def getStartDate(self):
return self.start_Date
def setEndDate(self, date):
self.end_Date = date
def getEndDate(self):
return self.end_Date
def calculate():
day1 = start_Date[1]
daycurr = curr_Date[1]
day2 = end_Date[1]
if (int(end_Date[1]) > int(start_Date[1])):
day2 += monthDict[end_Date[1]]
if (int(curr_Date[1]) > int(start_Date[1])):
daycurr += monthDict[curr_Date[1]]
fromStart = daycurr - day1
totalDays = day2 - day1
return str(round(fromStart / totalDays, 2))
def streak():
if (self.timer.day > self.curr_Date):
if (self.complete == 1):
self.streak += 1
self.curr_Date += 1
self.complete = 0
return self.streak
else:
return 0
else:
return self.streak
def to_public_json(self):
entry = {
"id": str(self.id),
"user": {
"id": str(self.user.id),
"username": self.user.username
},
"name": self.name,
"description": self.description,
"num_Days": self.num_Days,
"repeat": self.repeat,
"string_start": self.string_start,
"start_Date": self.start_Date,
"curr_Date": self.curr_Date,
"end_Date": self.end_Date,
"is_public": self.is_public,
"habit_data": self.habit_data
}
return entry
class Request(MongoModel, Document):
brewtils_model = brewtils.models.Request
# These fields are duplicated for job types, changes to this field
# necessitate a change to the RequestTemplateSchema in brewtils.
TEMPLATE_FIELDS = {
"system": {"field": StringField, "kwargs": {"required": True}},
"system_version": {"field": StringField, "kwargs": {"required": True}},
"instance_name": {"field": StringField, "kwargs": {"required": True}},
"namespace": {"field": StringField, "kwargs": {"required": False}},
"command": {"field": StringField, "kwargs": {"required": True}},
"command_type": {"field": StringField, "kwargs": {}},
"parameters": {"field": DictField, "kwargs": {}},
"comment": {"field": StringField, "kwargs": {"required": False}},
"metadata": {"field": DictField, "kwargs": {}},
"output_type": {"field": StringField, "kwargs": {}},
}
for field_name, field_info in TEMPLATE_FIELDS.items():
locals()[field_name] = field_info["field"](**field_info["kwargs"])
# Shared field with RequestTemplate, but it is required when saving Request
namespace = StringField(required=True)
parent = ReferenceField(
"Request", dbref=True, required=False, reverse_delete_rule=CASCADE
)
children = DummyField(required=False)
output = StringField()
output_gridfs = FileField()
output_type = StringField(choices=BrewtilsCommand.OUTPUT_TYPES)
status = StringField(choices=BrewtilsRequest.STATUS_LIST, default="CREATED")
command_type = StringField(choices=BrewtilsCommand.COMMAND_TYPES)
created_at = DateTimeField(default=datetime.datetime.utcnow, required=True)
updated_at = DateTimeField(default=None, required=True)
error_class = StringField(required=False)
has_parent = BooleanField(required=False)
hidden = BooleanField(required=False)
requester = StringField(required=False)
parameters_gridfs = FileField()
meta = {
"auto_create_index": False, # We need to manage this ourselves
"index_background": True,
"indexes": [
# These are used for sorting all requests
{"name": "command_index", "fields": ["command"]},
{"name": "command_type_index", "fields": ["command_type"]},
{"name": "system_index", "fields": ["system"]},
{"name": "instance_name_index", "fields": ["instance_name"]},
{"name": "namespace_index", "fields": ["namespace"]},
{"name": "status_index", "fields": ["status"]},
{"name": "created_at_index", "fields": ["created_at"]},
{"name": "updated_at_index", "fields": ["updated_at"]},
{"name": "comment_index", "fields": ["comment"]},
{"name": "parent_ref_index", "fields": ["parent"]},
{"name": "parent_index", "fields": ["has_parent"]},
# These are for sorting parent requests
{"name": "parent_command_index", "fields": ["has_parent", "command"]},
{"name": "parent_system_index", "fields": ["has_parent", "system"]},
{
"name": "parent_instance_name_index",
"fields": ["has_parent", "instance_name"],
},
{"name": "parent_status_index", "fields": ["has_parent", "status"]},
{"name": "parent_created_at_index", "fields": ["has_parent", "created_at"]},
{"name": "parent_comment_index", "fields": ["has_parent", "comment"]},
# These are used for filtering all requests while sorting on created time
{"name": "created_at_command_index", "fields": ["-created_at", "command"]},
{"name": "created_at_system_index", "fields": ["-created_at", "system"]},
{
"name": "created_at_instance_name_index",
"fields": ["-created_at", "instance_name"],
},
{"name": "created_at_status_index", "fields": ["-created_at", "status"]},
# These are used for filtering parent while sorting on created time
{
"name": "parent_created_at_command_index",
"fields": ["has_parent", "-created_at", "command"],
},
{
"name": "parent_created_at_system_index",
"fields": ["has_parent", "-created_at", "system"],
},
{
"name": "parent_created_at_instance_name_index",
"fields": ["has_parent", "-created_at", "instance_name"],
},
{
"name": "parent_created_at_status_index",
"fields": ["has_parent", "-created_at", "status"],
},
# These are used for filtering hidden while sorting on created time
# I THINK this makes the set of indexes above superfluous, but I'm keeping
# both as a safety measure
{
"name": "hidden_parent_created_at_command_index",
"fields": ["hidden", "has_parent", "-created_at", "command"],
},
{
"name": "hidden_parent_created_at_system_index",
"fields": ["hidden", "has_parent", "-created_at", "system"],
},
{
"name": "hidden_parent_created_at_instance_name_index",
"fields": ["hidden", "has_parent", "-created_at", "instance_name"],
},
{
"name": "hidden_parent_created_at_status_index",
"fields": ["hidden", "has_parent", "-created_at", "status"],
},
# This is used for text searching
{
"name": "text_index",
"fields": [
"$system",
"$command",
"$command_type",
"$comment",
"$status",
"$instance_name",
],
},
],
}
logger = logging.getLogger(__name__)
def pre_serialize(self):
encoding = "utf-8"
"""If string output was over 16MB it was spilled over to the GridFS storage solution"""
if self.output_gridfs:
self.logger.debug("~~~Retrieving output from gridfs")
self.output = self.output_gridfs.read().decode(encoding)
self.output_gridfs = None
if self.parameters_gridfs:
self.logger.debug("~~~Retrieving parameters from gridfs")
self.parameters = json.loads(self.parameters_gridfs.read().decode(encoding))
self.parameters_gridfs = None
def save(self, *args, **kwargs):
self.updated_at = datetime.datetime.utcnow()
max_size = 15 * 1_000_000
encoding = "utf-8"
parameter_size = sys.getsizeof(self.parameters)
if self.output:
parameter_size = sys.getsizeof(self.parameters)
if parameter_size > max_size:
self.logger.info("~~~Parameter size too big, storing in gridfs")
self.parameters_gridfs.put(
json.dumps(self.parameters), encoding=encoding
)
self.parameters = None
parameter_size = 0
# If the output size is too large, we switch it over
# Max size for Mongo is 16MB, switching over at 15MB to be safe
if self.output and (sys.getsizeof(self.output) + parameter_size) > max_size:
self.logger.info("~~~Output size too big, storing in gridfs")
self.output_gridfs.put(self.output, encoding=encoding)
self.output = None
super(Request, self).save(*args, **kwargs)
def clean(self):
"""Validate before saving to the database"""
if self.status not in BrewtilsRequest.STATUS_LIST:
raise ModelValidationError(
f"Can not save Request {self}: Invalid status '{self.status}'"
)
if (
self.command_type is not None
and self.command_type not in BrewtilsRequest.COMMAND_TYPES
):
raise ModelValidationError(
f"Can not save Request {self}: Invalid command type '{self.command_type}'"
)
if (
self.output_type is not None
and self.output_type not in BrewtilsRequest.OUTPUT_TYPES
):
raise ModelValidationError(
f"Can not save Request {self}: Invalid output type '{self.output_type}'"
)
def clean_update(self):
"""Ensure that the update would not result in an illegal status transition"""
# Get the original status
old_status = Request.objects.get(id=self.id).status
if self.status != old_status:
if old_status in BrewtilsRequest.COMPLETED_STATUSES:
raise RequestStatusTransitionError(
f"Status for a request cannot be updated once it has been "
f"completed. Current: {old_status}, Requested: {self.status}"
)
if (
old_status == "IN_PROGRESS"
and self.status not in BrewtilsRequest.COMPLETED_STATUSES
):
raise RequestStatusTransitionError(
f"Request status can only transition from IN_PROGRESS to a "
f"completed status. Requested: {self.status}, completed statuses "
f"are {BrewtilsRequest.COMPLETED_STATUSES}."
)
class Track(Document):
"""
Track is a reference to a playable medium stored in an external,
online source.
It has common meta data (title, year, album name, artist name, ...)
and is optionally linked to Musicbrainz DB via the track's MBID,
artist's MBID, or/and album MBID.
It is an "item" in FRBR's parlance.
It is a "recording" in MB's parlance.
http://en.wikipedia.org/wiki/FRBR
http://musicbrainz.org/doc/MusicBrainz_Database/Schema
It has `source` which determines where the medium is physically stored.
"""
# User is optional as tracks can exist and be in no one's music collection.
# However, as soon a user adds it to their collection, an editable copy
# of the track with the user assigned is created.
user = ReferenceField(User,
dbref=False,
required=False,
reverse_delete_rule=CASCADE)
# All MBIDs are optional as they are filled only when possible.
mbid = StringField()
artist_mbid = StringField()
album_mbid = StringField()
title = StringField(required=True)
# artist and album names
artist = StringField()
album = StringField()
number = IntField()
# set = IntField()
year = IntField()
# Source metadata.
source = StringField(required=True, choices=['youtube', 'dropbox'])
dropbox = EmbeddedDocumentField(DropboxTrack)
youtube = EmbeddedDocumentField(YoutubeTrack)
meta = {
'collection': 'tracks',
'allow_inheritance': False,
'indexes': [
'user',
'mbid',
'artist_mbid',
'album_mbid',
]
}
def __unicode__(self):
return self.title
def to_json(self):
data = {
'id': str(self.pk),
'title': self.title,
'artist': self.artist or UNTITLED_ARTIST,
'album': self.album or UNTITLED_ALBUM,
'number': self.number,
'source': self.source[0],
}
if self.source == 'youtube':
data['sourceId'] = self.youtube.id
return data
class SystemGardenMapping(MongoModel, Document):
system = ReferenceField("System")
garden = ReferenceField("Garden")
class OrderedProduct(EmbeddedDocument):
quantity = IntField(required=True)
product = ReferenceField(Product, required=True)
class EntityMixin(object):
"""A document mixin which attaches each document to an entity"""
#: The entity that owns the document
entity = ReferenceField('Entity', required=True, dbref=False)
class Room(Document):
name = StringField(required=True, unique=True)
members = ListField(ReferenceField(Client))
class ZabbixAgent(DynamicDocument):
""" Zabbix Agent model representation
"""
# Retrieve node hostname to set default value of 'hostname' field
default_hostname = get_hostname()
enabled = BooleanField(default=False,
verbose_name=_('Enable service'),
required=True,
help_text=_('Enable agent service'))
servers = StringField(
verbose_name=_('Server(s)'),
required=True,
default='127.0.0.1,::127.0.0.1,::ffff:127.0.0.1',
help_text=
_('List of comma delimited IP addresses (or hostnames) of Zabbix servers.'
))
listeners = ListField(
ReferenceField('Listener', reverse_delete_rule=PULL),
verbose_name=_("Listen address(es)"),
required=True,
help_text=_('List of IP addresses that the agent should listen on.'))
port = IntField(
default=10050,
required=True,
min_value=1024,
max_value=65535,
verbose_name=_("Listen port"),
help_text=_(
'Agent will listen on this port for connections from the server.'))
active_servers = StringField(
verbose_name=_('Active Server(s)'),
required=True,
default="127.0.0.1:20051,zabbix.domain,[::1]:30051,::1,[12fc::1]",
help_text=_(
'List of comma delimited IP:port (or hostname:port) pairs of Zabbix'
' servers for active checks.'))
hostname = StringField(
verbose_name=_('Hostname'),
required=True,
default=default_hostname,
help_text=_('Required for active checks and must match hostname'
' as configured on the server.'))
allow_root = BooleanField(verbose_name=_('Allow root'),
required=True,
default=False,
help_text=_('Allow the agent to run as "root".'))
tls_accept = StringField(
verbose_name=_('TLS Accept'),
default='unencrypted',
choices=ENCRYPTION_TYPE,
required=True,
help_text=_('What incoming connections to accept.'))
tls_connect = StringField(
verbose_name=_('TLS Connect'),
required=True,
default='unencrypted',
choices=ENCRYPTION_TYPE,
help_text=
_('How the agent should connect to server or proxy. Used for active checks.'
))
tls_cert = ReferenceField(
'SSLCertificate',
reverse_delete_rule=PULL,
verbose_name=_('Agent certificate'),
required=False,
help_text=_('Certificate used by "TLS Accept" and/or "TLS Connect"'))
tls_server_subject = StringField(
verbose_name=_('Server certificate subject'),
required=False,
help_text=_('Allowed server certificate subject.'))
tls_server_issuer = StringField(
verbose_name=_('Server certificate issuer'),
required=False,
help_text=_('Allowed server certificate issuer.'))
psk_identity = StringField(
verbose_name=_('Agent PSK identity '),
required=False,
help_text=_(
'Unique, case sensitive string used to identify the pre-shared key.'
))
psk_key = StringField(
verbose_name=_('Agent PSK string '),
required=False,
help_text=_('Pre-shared key used by agent to verify connection.'))
enable_remote_commands = BooleanField(
verbose_name=_('Enable remote commands'),
required=True,
default=False,
help_text=_('Whether remote commands from Zabbix server are allowed.'))
log_remote_commands = BooleanField(
verbose_name=_('Log remote commands'),
required=True,
default=False,
help_text=_('Enable logging of executed shell commands as warnings.'))
start_agents = IntField(
default=3,
required=True,
min_value=0,
max_value=100,
verbose_name=_("Start Agents"),
help_text=
_('Number of pre-forked instances of zabbix_agentd that process passive checks.'
'If set to 0, disables passive checks and the agent will not listen on any TCP '
'port.'))
refresh_active_checks = IntField(
default=120,
required=True,
min_value=60,
max_value=3600,
verbose_name=_("Refresh active checks"),
help_text=_(
'How often list of active checks is refreshed, in seconds.'))
timeout_process = IntField(
default=3,
required=True,
min_value=1,
max_value=30,
verbose_name=_("Timeout"),
help_text=_('Spend no more than Timeout seconds on processing.'))
buffer_send = IntField(
default=5,
required=True,
min_value=1,
max_value=3600,
verbose_name=_("Buffer send"),
help_text=_('Do not keep data longer than N seconds in buffer.'))
buffer_size = IntField(
default=100,
required=True,
min_value=2,
max_value=65535,
verbose_name=_("Buffer size"),
help_text=_(
'Maximum number of values in a memory buffer. The agent will send all '
'collected data to Zabbix Server/Proxy if the buffer is full.'))
def to_template(self):
""" Dictionary used to create configuration file.
:return: Dictionary of configuration parameters
"""
# Convert self attributes into dict
zabbix_settings = self.to_mongo()
# Convert listeners list into string
zabbix_settings['listeners'] = ','.join([l.ip for l in self.listeners])
# Convert Boolean fields into int (0 or 1)
bool_to_int = {
True: 1,
False: 0,
# 'True': 1,
# 'False': 0
}
attrs_to_convert = {
'allow_root': self.allow_root,
'enable_remote_commands': self.enable_remote_commands,
'log_remote_commands': self.log_remote_commands,
}
for attr_name, attr in attrs_to_convert.items():
zabbix_settings[attr_name] = bool_to_int[attr]
return zabbix_settings
def __str__(self):
return "Zabbix-Agent Settings"
class Transaction(Document, BaseModel):
created_at = date_now()
updated_at = DateTimeField()
stp_id = IntField()
fecha_operacion = DateTimeField()
institucion_ordenante = StringField()
institucion_beneficiaria = StringField()
clave_rastreo = StringField()
monto = IntField()
nombre_ordenante = StringField()
tipo_cuenta_ordenante = IntField()
cuenta_ordenante = StringField()
rfc_curp_ordenante = StringField()
nombre_beneficiario = StringField()
tipo_cuenta_beneficiario = IntField()
cuenta_beneficiario = StringField()
rfc_curp_beneficiario = StringField()
concepto_pago = StringField()
referencia_numerica = IntField()
empresa = StringField()
estado: Enum = EnumField(Estado, default=Estado.created)
version = IntField()
speid_id = StringField()
folio_origen = StringField()
tipo_pago = IntField()
email_beneficiario = StringField()
tipo_cuenta_beneficiario2 = StringField()
nombre_beneficiario2 = StringField()
cuenta_beneficiario2 = StringField()
rfc_curpBeneficiario2 = StringField()
concepto_pago2 = StringField()
clave_cat_usuario1 = StringField()
clave_cat_usuario2 = StringField()
clave_pago = StringField()
referencia_cobranza = StringField()
tipo_operacion = StringField()
topologia = StringField()
usuario = StringField()
medio_entrega = IntField()
prioridad = IntField()
compound_key = StringField()
events = ListField(ReferenceField(Event))
meta = {
'indexes': [
'+stp_id',
'+speid_id',
'+clave_rastreo',
# The Unique-Sparse index skips over any document that is missing
# the indexed field (null values)
{'fields': ['+compound_key'], 'unique': True, 'sparse': True},
]
}
def set_state(self, state: Estado):
callback_helper.set_status_transaction(self.speid_id, state.value)
self.estado = state
self.events.append(Event(type=EventType.completed))
def confirm_callback_transaction(self):
response = ''
self.events.append(Event(type=EventType.created))
self.save()
self.estado = Estado.succeeded
callback_helper.send_transaction(self.to_dict())
self.events.append(
Event(type=EventType.completed, metadata=str(response))
)
def create_order(self) -> Orden:
# Validate account has already been created
if not SKIP_VALIDATION_PRIOR_SEND_ORDER:
try:
account = Account.objects.get(cuenta=self.cuenta_ordenante)
assert account.estado is Estado.succeeded
except (DoesNotExist, AssertionError):
self.estado = Estado.error
self.save()
raise MalformedOrderException(
f'Account has not been registered: {self.cuenta_ordenante}'
f', stp_id: {self.stp_id}'
)
# Don't send if stp_id already exists
if self.stp_id:
return Orden( # type: ignore
id=self.stp_id,
monto=self.monto / 100.0,
conceptoPago=self.concepto_pago,
nombreBeneficiario=self.nombre_beneficiario,
cuentaBeneficiario=self.cuenta_beneficiario,
institucionContraparte=self.institucion_beneficiaria,
cuentaOrdenante=self.cuenta_ordenante,
)
optionals = dict(
institucionOperante=self.institucion_ordenante,
claveRastreo=self.clave_rastreo,
referenciaNumerica=self.referencia_numerica,
rfcCurpBeneficiario=self.rfc_curp_beneficiario,
medioEntrega=self.medio_entrega,
prioridad=self.prioridad,
tipoPago=self.tipo_pago,
topologia=self.topologia,
)
# remove if value is None
remove = []
for k, v in optionals.items():
if v is None:
remove.append(k)
for k in remove:
optionals.pop(k)
try:
order = stpmex_client.ordenes.registra(
monto=self.monto / 100.0,
conceptoPago=self.concepto_pago,
nombreBeneficiario=self.nombre_beneficiario,
cuentaBeneficiario=self.cuenta_beneficiario,
institucionContraparte=self.institucion_beneficiaria,
tipoCuentaBeneficiario=self.tipo_cuenta_beneficiario,
nombreOrdenante=self.nombre_ordenante,
cuentaOrdenante=self.cuenta_ordenante,
rfcCurpOrdenante=self.rfc_curp_ordenante,
**optionals,
)
except (Exception) as e: # Anything can happen here
self.events.append(Event(type=EventType.error, metadata=str(e)))
self.estado = Estado.error
self.save()
raise e
else:
self.clave_rastreo = self.clave_rastreo or order.claveRastreo
self.rfc_curp_beneficiario = (
self.rfc_curp_beneficiario or order.rfcCurpBeneficiario
)
self.referencia_numerica = (
self.referencia_numerica or order.referenciaNumerica
)
self.empresa = self.empresa or STP_EMPRESA
self.stp_id = order.id
self.events.append(
Event(type=EventType.completed, metadata=str(order))
)
self.estado = Estado.submitted
self.save()
return order
class Post(Document):
text = StringField()
user = ReferenceField(User, required=True)
comments = ListField(StringField())
comments_by = ListField(ReferenceField("User"))
keyword = ListField(StringField())
reaction = ListField(StringField())
hilarious = ListField(ReferenceField("User"))
well_written = ListField(ReferenceField("User"))
amazing_story = ListField(ReferenceField("User"))
grammar_king = ReferenceField("User")
group = IntField()
assignment_id = ReferenceField("Assignment")
submit = BooleanField(default=False)
@staticmethod
def create(text, assignment_id):
post = Post(text=text,
user=current_user['id'],
assignment_id=ObjectId(assignment_id),
submit=True)
post.save()
return post
@staticmethod
def add_reaction(post_id, hilarious="", well_written="", amazing=""):
post = Post.objects(pk=ObjectId(post_id), submit=True)
if hilarious.lower() == 'true':
post.update(add_to_set__hilarious=current_user['id'])
if well_written.lower() == 'true':
post.update(add_to_set__well_written=current_user['id'])
if amazing.lower() == 'true':
post.update(add_to_set__amazing_story=current_user['id'])
return True
@staticmethod
def submit_assigment(text, assignment_id):
assignment = Post.objects(user=current_user['id'],
assignment_id=ObjectId(assignment_id))
if assignment:
assignment.update(text=text, submit=True)
return assignment
else:
post = Post.create(text, assignment_id)
post.save()
return post
def get_json(self):
#print(self.user.pk)
user_name = User.objects(pk=self.user.pk, name__exists=True)
u_name = 'sample'
if user_name:
for u in user_name:
u_name = u['name']
dict_list = []
for i in range(len(self.comments)):
diction = {'comment': '', 'name': ''}
diction['comment'] = self.comments[i]
name = User.objects(pk=self.comments_by[i].pk, name__exists=True)
another_name = ''
if name:
for n in name:
another_name = n['name']
diction['name'] = another_name
dict_list.append(diction)
jstring = ''
jstring = '{\n"text": ' + json.dumps(self.text) + ',\n' \
+ '"name": ' + json.dumps(str(u_name)) + ',\n' \
+ '"mongoid": ' + json.dumps(str(self.pk)) + ',\n' \
+ '"comments": ' + json.dumps(dict_list) + ',\n' \
+ '"hilarious": ' + json.dumps(str(len(self.hilarious))) + ',\n' \
+ '"well_written": ' + json.dumps(str(len(self.well_written))) + ',\n' \
+ '"amazing_story": ' + json.dumps(str(len(self.amazing_story))) + "}\n"
return jstring
@staticmethod
def add_comments(post_id, comment):
post = Post.objects(pk=ObjectId(post_id)).first()
if (post):
Post.objects(pk=ObjectId(post_id)).update_one(
push__comments=comment, push__comments_by=current_user['id'])
return post
class DepositRecord(Document):
club = ReferenceField(Club)
value = FloatField()
handler = ReferenceField(Member)
remark = StringField()
meta = {'strict': False}
class Home(Document):
dad = ReferenceField(
AbstractHuman) # Referencing the abstract class
address = StringField()
class Physician(Staff):
name_initials = StringField(required=True)
is_licenced = BooleanField()
reference_number = StringField()
main_speciality = ReferenceField(MedicalSpeciality, required=True)
auxiliary_speciality = ListField(ReferenceField(MedicalSpeciality))
class Human(Document):
meta = {"abstract": True}
creator = ReferenceField("self", dbref=True)
class Campaign(Document):
name = StringField(max_length=100, required=True)
slug = StringField(required=True, primary_key=True)
description = StringField()
creator = ReferenceField('Admin', required=True)
subscribers = ListField(ReferenceField('Admin'))
creation_time = DateTimeField(default=datetime.now)
last_update = DateTimeField(default=datetime.now)
wiki_page = StringField()
tasks = ListField(ReferenceField('BaseTask'))
# either a CSV Corpus or a corpus folder
corpus: BaseCorpus = ReferenceField('BaseCorpus', required=True)
# the audio file is being served in the starter zip
serve_audio = BooleanField(default=False)
# this object stores the campaign annotation checking scheme
checking_scheme: TextGridCheckingScheme = ReferenceField(
'TextGridCheckingScheme')
# if this is false, textgrid aren't checked (except for the merge part)
check_textgrids = BooleanField(default=True)
# updated on trigger
stats: CampaignStats = EmbeddedDocumentField(CampaignStats)
def validate(self, clean=True):
if isinstance(self.corpus, CSVCorpus) and self.serve_audio:
raise ValidationError("Can't serve audio files with a csv corpus")
super().validate(clean)
def launch_gamma_update(self):
"""Launches a subprocess that computes the gamma statistics for
that campaign. Does not wait for the subprocess to finish"""
process = subprocess.Popen(["campaign-gamma", self.slug])
self.stats.gamma_updating = True
self.stats.can_update_gamma = False
self.save()
def update_stats(self, gamma_only=False):
if self.stats is None:
self.stats = CampaignStats()
if gamma_only:
self.stats.update_gamma_stats(self)
else:
self.stats.update_stats(self)
self.save()
@classmethod
def post_delete_cleanup(cls, sender, document: 'Campaign', **kwargs):
"""Called upon a post_delete event. Takes care of cleaning up stuff, deleting the campaigns's
child tasks and removing notifications related to that campaign"""
for task in document.tasks:
task.delete()
from .users import Notification
Notification.objects(
Q(object_id=document.slug)
& (Q(object_type="campaign") | Q(object_type="dashboard")))
def tasks_for_file(self, audio_file: str):
tasks = [task for task in self.tasks]
return len([task for task in tasks if task.data_file == audio_file])
@property
def active_tasks(self):
return BaseTask.objects(campaign=self.id, is_done=False)
@property
def annotators(self):
return self.stats.annotators
def gen_template_tg(self, filename: str) -> SingleAnnotatorTextGrid:
"""Generates the template textgrid (pregenerated tiers and tg length)
for that campaign"""
audio_file = self.corpus.get_file(filename)
if self.checking_scheme is None:
tg = TextGrid(name=filename, maxTime=audio_file.duration)
else:
tg = self.checking_scheme.gen_template_tg(audio_file.duration,
filename)
return SingleAnnotatorTextGrid.from_textgrid(tg, [self.creator], None)
def gen_summary_csv(self, only_gamma=False) -> str:
str_io = StringIO()
fields = [
"task_file", "time_created", "time_completed", "time_started",
"annotators"
]
if self.stats is not None and self.stats.can_compute_gamma:
write_gamma = True
for tier_name in self.stats.tiers_gamma.keys():
fields.append(f"gamma_{tier_name}")
else:
write_gamma = False
csv_writer = csv.DictWriter(str_io, fields, delimiter="\t")
csv_writer.writeheader()
for task in self.tasks:
task: BaseTask
task_row = {
"task_file":
task.data_file,
"time_created":
task.creation_time,
"time_completed":
task.finish_time,
"time_started":
task.start_time,
"annotators":
",".join(annotator.username for annotator in task.annotators)
}
if isinstance(task, DoubleAnnotatorTask) and write_gamma:
for tier_name, gamma in task.tiers_gamma.items():
task_row[f"gamma_{tier_name}"] = gamma
# if we only want the gamma rows, skipping single annotators tasks
if only_gamma and not isinstance(task, DoubleAnnotatorTask):
continue
csv_writer.writerow(task_row)
str_io.flush()
return str_io.getvalue()
def get_full_annots_archive(self) -> bytes:
"""Generates the full annotations zip archive for that campaign, to be
then sent to the client"""
buffer = BytesIO()
# TODO: integrate the csv summary generator from above
with zipfile.ZipFile(buffer, "w", zipfile.ZIP_STORED) as zfile:
zip_folder: Path = Path(self.slug)
# writing full summary
summary_path = zip_folder / Path("summary.csv")
zfile.writestr(str(summary_path), self.gen_summary_csv())
# then writing tasks textgrids and per-task summary
for task in self.tasks:
task_annotators = "-".join(
[annotator.username for annotator in task.annotators])
task_datafile = task.data_file.strip(
Path(task.data_file).suffix)
task_folder = (zip_folder / Path(task_datafile) /
Path(task_annotators))
for tg_name, tg_doc in task.textgrids.items():
if tg_doc is not None:
tg_archpath = task_folder / Path(tg_name + ".TextGrid")
zfile.writestr(str(tg_archpath), tg_doc.to_str())
return buffer.getvalue()
@property
def short_profile(self):
return {"slug": self.slug, "name": self.name}
@property
def status(self):
if self.stats is None:
self.update_stats()
return {
"slug":
self.slug,
"name":
self.name,
"description":
self.description,
"creator":
self.creator.short_profile,
"stats":
self.stats.to_msg(),
"corpus_path":
self.corpus.name,
"tiers_number":
len(self.checking_scheme.tiers_specs)
if self.checking_scheme is not None else None,
"check_textgrids":
self.check_textgrids,
"annotators":
[annotator.short_profile for annotator in self.annotators],
"subscribers": [user.username for user in self.subscribers],
"creation_time":
self.creation_time,
"last_update_time":
self.last_update,
}
class Rail(Document):
_created_date = DateTimeField(default=datetime.datetime.now)
_key_created_user = ObjectIdField()
_last_modified_date = DateTimeField(default=datetime.datetime.now)
_key_last_modified_user = ObjectIdField()
_key_owner_user = ObjectIdField()
analysis_date = DateTimeField(default=datetime.datetime.now)
_key_organization = ReferenceField(Organization, required=True, reverse_delete_rule=2)
_key_brand = ReferenceField(Brand, required=True, reverse_delete_rule=3)
_key_kur_cinsi = ReferenceField(Currency, required=True, reverse_delete_rule=3)
_key_iskonto = ReferenceField(Discount, required=True, reverse_delete_rule=3)
_key_rail_size_1 = ReferenceField(RailSize, required=True, reverse_delete_rule=3)
_key_rail_size_2 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_size_3 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_size_4 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_size_5 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_size_6 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_size_7 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_size_8 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_flans_size_1 = ReferenceField(RailSize, required=True, reverse_delete_rule=3)
_key_rail_flans_size_2 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_flans_size_3 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_flans_size_4 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_flans_size_5 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_flans_size_6 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_flans_size_7 = ReferenceField(RailSize, reverse_delete_rule=1)
_key_rail_flans_size_8 = ReferenceField(RailSize, reverse_delete_rule=1)
birim_fiyat = DecimalField(required=True)
