class Task(AttributedDocument):
meta = {
"db_alias":
Database.backend,
"strict":
strict,
"indexes": [
"created",
"started",
"completed",
{
"name":
"%s.task.main_text_index" % Database.backend,
"fields": [
"$name",
"$id",
"$comment",
"$execution.model",
"$output.model",
"$script.repository",
"$script.entry_point",
],
"default_language":
"english",
"weights": {
"name": 10,
"id": 10,
"comment": 10,
"execution.model": 2,
"output.model": 2,
"script.repository": 1,
"script.entry_point": 1,
},
},
],
}
id = StringField(primary_key=True)
name = StrippedStringField(required=True,
user_set_allowed=True,
sparse=False,
min_length=3)
type = StringField(required=True, choices=get_options(TaskType))
status = StringField(default=TaskStatus.created,
choices=get_options(TaskStatus))
status_reason = StringField()
status_message = StringField()
status_changed = DateTimeField()
comment = StringField(user_set_allowed=True)
created = DateTimeField(required=True, user_set_allowed=True)
started = DateTimeField()
completed = DateTimeField()
published = DateTimeField()
parent = StringField()
project = StringField(reference_field=Project, user_set_allowed=True)
output = EmbeddedDocumentField(Output, default=Output)
execution: Execution = EmbeddedDocumentField(Execution, default=Execution)
tags = ListField(StringField(required=True), user_set_allowed=True)
system_tags = ListField(StringField(required=True), user_set_allowed=True)
script = EmbeddedDocumentField(Script)
last_worker = StringField()
last_worker_report = DateTimeField()
last_update = DateTimeField()
last_iteration = IntField(default=DEFAULT_LAST_ITERATION)
last_metrics = SafeMapField(
field=SafeMapField(EmbeddedDocumentField(MetricEvent)))
class Garden(Document):
name = StringField()
username = StringField(unique_with="name")
location = GeoPointField()
width = IntField()
height = IntField()
class Person(Document):
name = StringField(required=True)
age = IntField(min_value=1, required=True)
class ConversationMessage(EmbeddedDocument): timestamp = IntField(required=True) message = StringField(required=True) owner = ReferenceField(User)
class Page(Document):
page_num = IntField()
title = StringField(required=True, max_length=50)
body = StringField(max_length=1250)
class CASI(Request):
full_name = 'Cancelación de Asignaturas'
CN_ANSWER_NO_DILIGENTE = 'ND'
CN_ANSWER_MOTIVOS_LABORALES = 'ML'
CN_ANSWER_INFORMACION_FALSA = 'TR'
CN_ANSWER_SOPORTES_NO_SOPORTAN = 'SN'
CN_ANSWER_FALTA_DE_CONOCIMIENTO = 'FC'
CN_ANSWER_ARGUMENTOS_INSUFICIENTES = 'AI'
CN_ANSWER_INCOHERENTE_O_INCONSECUENTE = 'II'
CN_ANSWER_OTRO = 'OT'
CN_ANSWER_CHOICES = ((CN_ANSWER_NO_DILIGENTE, 'No diligente'),
(CN_ANSWER_MOTIVOS_LABORALES,
'Motivos Laborales'), (CN_ANSWER_INFORMACION_FALSA,
'Información Falsa'),
(CN_ANSWER_SOPORTES_NO_SOPORTAN,
'Argumento cuando los soportes no soportan'),
(CN_ANSWER_FALTA_DE_CONOCIMIENTO,
'Falta de conocimiento'),
(CN_ANSWER_ARGUMENTOS_INSUFICIENTES,
'Argumentos insuficientes'),
(CN_ANSWER_INCOHERENTE_O_INCONSECUENTE,
'Incoherente o no consecuente'), (CN_ANSWER_OTRO,
'Otro'))
subjects = EmbeddedDocumentListField(Subject,
required=True,
display='Asignaturas')
advance = FloatField(required=True, display='% de Avance')
enrolled_academic_periods = IntField(required=True,
display='# Periodos Matriculados')
papa = FloatField(required=True, display='PAPA')
available_credits = IntField(required=True, display='Creditos Disponibles')
current_credits = IntField(required=True, display='Creditos Inscritos')
nrc_answer = StringField(choices=CN_ANSWER_CHOICES,
default=CN_ANSWER_OTRO,
display='Motivo de rechazo')
regulation_list = ['008|2008|CSU'] # List of regulations
str_cm = [
'cancelar la(s) siguiente(s) asignatura(s) inscrita(s) del periodo académico {}',
'porque {}justifica debidamente la solicitud.'
]
str_pcm = [
'SIA: Porcentaje de avance en el plan: {}. Número de matrículas: {}. PAPA: {}.',
'SIA: Créditos disponibles: {}.',
'SIA: Al aprobar la cancelación de la asignatura {} ({}) el estudiante quedaría con {} cr'
+ 'éditos inscritos.'
]
str_pcmap = [
' cancelar la(s) siguiente(s) asignatura(s) inscrita(s) del periodo académico {}, ',
]
str_pcma_cap = ['porque se justifica debidamente la solicitud.']
str_pcma_cna = [
'porque no existe coherencia entre la documentación y justificación que presenta.',
'porque lo expuesto es un hecho de su conocimiento desde el inicio del periodo académico'
+
'; tuvo la oportunidad de resolverlo oportunamente hasta el 50% del periodo académico, p'
+
'or tanto, no constituye causa extraña que justifique la cancelación de la(s) asignatura'
+ '(s).',
'porque de acuerdo con la documentación que presenta, su situación laboral no le impide '
+
'asistir a las clases y tiene el tiempo suficiente para responder por las actividades ac'
+ 'adémicas de la(s) asignatura(s). ',
'porque verificada la información de los soportes, se encontró que el contenido de los m'
+ 'ismos no coincide con lo que en ellos se afirma.',
'poque es responsabilidad del estudiante indagar sobre el conocimiento requerido y la pr'
+
'eparación necesaria para cursar la(s) asignatura(s) antes de inscribir.',
'porque lo expuesto no es un hecho que constituya causa extraña que justifique la cancel'
+ 'ación de la(s) asignatura(s).',
'porque de la documentación aportada, se tiene que no hay justificación para acceder a l'
+ 'o pedido. '
]
def cm(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
self.cm_answer(paragraph)
table_subjects(docx, Subject.subjects_to_array(self.subjects))
def cm_answer(self, paragraph):
paragraph.add_run(self.str_council_header + ' ')
paragraph.add_run(
# pylint: disable=no-member
self.get_approval_status_display().upper() + ' ').font.bold = True
paragraph.add_run(self.str_cm[0].format(self.academic_period) + ', ')
if self.is_affirmative_response_approval_status():
self.cm_ap(paragraph)
else:
self.cm_na(paragraph)
paragraph.add_run('({}).'.format(self.regulations['008|2008|CSU'][0]))
def pcm(self, docx):
self.pcm_analysis(docx)
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_answer + ': ').bold = True
self.pcm_answer(paragraph)
table_subjects(docx, Subject.subjects_to_array(self.subjects))
def pcm_answer(self, paragraph):
paragraph.add_run(self.str_comittee_header)
paragraph.add_run(
# pylint: disable=no-member
' ' + self.get_advisor_response_display().upper()).font.bold = True
paragraph.add_run(self.str_pcmap[0].format(self.academic_period))
if self.is_affirmative_response_advisor_response():
self.pcm_answers_cr(paragraph)
else:
self.pcm_answers_cn(paragraph)
def cm_ap(self, paragraph):
paragraph.add_run(self.str_cm[1].format('') + ' ')
def cm_na(self, paragraph):
paragraph.add_run(self.str_cm[1].format('no ') + ' ')
def pcm_analysis(self, docx):
analysis_list = []
analysis_list += [
self.str_pcm[0].format(self.advance,
self.enrolled_academic_periods, self.papa)
]
analysis_list += [self.str_pcm[1].format(self.available_credits)]
analysis_list += self.pcm_analysis_subject_list()
analysis_list += self.extra_analysis
add_analysis_paragraph(docx, analysis_list)
def pcm_analysis_subject_list(self):
analysis_subject_list = []
for subject in self.subjects:
current_credits = self.current_credits
subject_credits = subject.credits
subject_info = {
'remaining': int(current_credits) - int(subject_credits),
'code': subject.code,
'name': subject.name
}
analysis_subject_list += [
self.str_pcm[2].format(subject_info['name'],
subject_info['code'],
subject_info['remaining'])
]
return analysis_subject_list
def pcm_answers_cr(self, paragraph):
paragraph.add_run(self.str_pcma_cap[0])
paragraph.add_run(' ({}).'.format(self.regulations['008|2008|CSU'][0]))
def pcm_answers_cn(self, paragraph):
if self.nrc_answer == self.CN_ANSWER_INCOHERENTE_O_INCONSECUENTE:
paragraph.add_run(self.str_pcma_cna[0] + ' ')
elif self.nrc_answer == self.CN_ANSWER_NO_DILIGENTE:
paragraph.add_run(self.str_pcma_cna[1] + ' ')
elif self.nrc_answer == self.CN_ANSWER_MOTIVOS_LABORALES:
paragraph.add_run(self.str_pcma_cna[2] + ' ')
elif self.nrc_answer == self.CN_ANSWER_INFORMACION_FALSA:
paragraph.add_run(self.str_pcma_cna[3] + ' ')
elif self.nrc_answer == self.CN_ANSWER_FALTA_DE_CONOCIMIENTO:
paragraph.add_run(self.str_pcma_cna[4] + ' ')
elif self.nrc_answer == self.CN_ANSWER_ARGUMENTOS_INSUFICIENTES:
paragraph.add_run(self.str_pcma_cna[5] + ' ')
elif self.nrc_answer == self.CN_ANSWER_SOPORTES_NO_SOPORTAN:
paragraph.add_run(self.str_pcma_cna[6] + ' ')
elif self.nrc_answer == self.CN_ANSWER_OTRO:
paragraph.add_run(self.str_pcma_cna[6] + ' ')
else:
raise AssertionError(
self.assertionerror['CHOICES'].format('NRC_answer'))
paragraph.add_run(' ({}).'.format(self.regulations['008|2008|CSU'][0]))
class UserRate(Document):
uid=IntField(required=True,default=0)
mediaid=IntField(required=True,default=0)
score = FloatField(required=True)
ratedate = DateTimeField(default=datetime.utcnow)
class TeamWork(EmbeddedDocument):
id = UUIDField(required=True)
description = StringField()
type = IntField(required=True) # see TEAM_SHOW_TYPE
uri = StringField()
create_time = DateTimeField(default=get_now())
class TeamScore(EmbeddedDocument):
type = IntField(default=0)
score = IntField(required=True, min_value=0)
reason = StringField()
score_date = DateTimeField(default=get_now())
judge = ReferenceField(User)
class NetworkConfigTemplate(HDocumentBase):
""" Network config for generate K8s yml"""
name = StringField(required=True, unique=True)
protocol = StringField()
port = IntField(max_value=65535)
class HackathonStat(HDocumentBase):
type = StringField() # class HACKATHON_STAT
count = IntField(min_value=0)
hackathon = ReferenceField(Hackathon)
class River(Document):
name = StringField()
continent = StringField()
length = IntField()
class MongoEvent(Document):
server_ip = StringField() # track server that the event belongs to
key = StringField()
value = StringField()
event_type = StringField()
version = SequenceField() # use 'version' as the auto increase id
create_time = IntField()
context = StringField()
namespace = StringField()
uuid = StringField()
def to_dict(self):
return {
"key": self.key,
"value": self.value,
"event_type": self.event_type,
"version": int(self.version),
"create_time": self.create_time,
"context": self.context,
"namespace": self.namespace
}
def to_base_event(self):
base_event = BaseEvent(**self.to_dict())
return base_event
@classmethod
def convert_to_base_events(cls, mongo_events: list = None):
if not mongo_events:
return []
base_events = []
for mongo_event in mongo_events:
base_events.append(mongo_event.to_base_event())
return base_events
@classmethod
def get_base_events_by_version(cls,
start_version: int,
end_version: int = None):
conditions = dict()
conditions["version__gt"] = start_version
if end_version is not None and end_version > 0:
conditions["version__lte"] = end_version
mongo_events = cls.objects(**conditions).order_by("version")
return cls.convert_to_base_events(mongo_events)
@classmethod
def get_base_events(cls,
key: Tuple[str],
version: int = None,
event_type: str = None,
start_time: int = None,
namespace: str = None):
conditions = dict()
if len(key) == 1:
conditions["key"] = key[0]
elif len(key) > 1:
conditions["key__in"] = list(key)
if version is not None and version > 0:
conditions["version__gt"] = version
if event_type is not None:
conditions["event_type"] = event_type
if start_time is not None and start_time > 0:
conditions["start_time_gte"] = start_time
conditions["namespace"] = namespace
mongo_events = cls.objects(**conditions).order_by("version")
return cls.convert_to_base_events(mongo_events)
@classmethod
def get_base_events_by_time(cls, create_time: int = None):
mongo_events = cls.objects(
create_time__gte=create_time).order_by("version")
return cls.convert_to_base_events(mongo_events)
@classmethod
def get_by_key(cls,
key: str = None,
start: int = None,
end: int = None,
sort_key: str = "version"):
if key:
return cls.objects(key=key).order_by(sort_key)[start:end]
else:
raise Exception("key is empty, please provide valid key")
@classmethod
def delete_by_client(cls, server_ip):
cls.objects(server_ip=server_ip).delete()
class Campaign(CritsBaseAttributes, CritsActionsDocument, Document):
"""
Campaign Class.
"""
meta = {
"collection": settings.COL_CAMPAIGNS,
"crits_type": 'Campaign',
"latest_schema_version": 3,
"schema_doc": {
'schema_version':
'Version of the Campaign schema doc',
'active':
'Enabled in the UI (on/off)',
'aliases':
'List [] of aliases this Campaign goes by',
'domain_count':
'Domains tagged with Campaign. Added by MapReduce',
'email_count':
'Emails tagged with Campaign. Added by MapReduce',
'event_count':
'Events tagged with Campaign. Added by MapReduce',
'indicator_count': ('Indicators tagged with Campaign. Added by '
'MapReduce'),
'ip_count':
'IPs tagged with Campaign. Added by MapReduce',
'name':
'Name this Campaign goes by',
'pcap_count':
'PCAPs tagged with Campaign. Added by MapReduce',
'sample_count':
'Samples tagged with Campaign. Added by MapReduce',
'ttps':
'List [] of TTPs this Campaign is associated with',
},
"jtable_opts": {
'details_url':
'crits.campaigns.views.campaign_details',
'details_url_key':
'name',
'default_sort':
"name ASC",
'searchurl':
'crits.campaigns.views.campaigns_listing',
'fields': [
"name", "aliases", "actor_count", "backdoor_count",
"exploit_count", "indicator_count", "email_count",
"domain_count", "sample_count", "event_count", "ip_count",
"pcap_count", "modified", "id", "status"
],
'jtopts_fields': [
"details", "name", "aliases", "status", "actors", "backdoors",
"exploits", "indicators", "emails", "domains", "samples",
"events", "ips", "pcaps", "modified", "favorite", "id"
],
'hidden_fields': [],
'linked_fields': [],
'details_link':
'details',
'no_sort': ['details']
}
}
active = StringField(default="on")
aliases = ListField(StringField(), default=[])
actor_count = IntField(default=0)
backdoor_count = IntField(default=0)
domain_count = IntField(default=0)
email_count = IntField(default=0)
event_count = IntField(default=0)
exploit_count = IntField(default=0)
indicator_count = IntField(default=0)
ip_count = IntField(default=0)
name = StringField(default=0)
pcap_count = IntField(default=0)
sample_count = IntField(default=0)
ttps = ListField(EmbeddedDocumentField(EmbeddedTTP), default=[])
def migrate(self):
"""
Migrate the Campaign to the latest schema version.
"""
migrate_campaign(self)
def activate(self):
"""
Set the Campaign as active.
"""
self.active = "on"
def deactivate(self):
"""
Set the Campaign as inactive.
"""
self.active = "off"
def edit_description(self, description):
"""
Set the Campaign description.
:param description: The campaign description.
:type description: str
"""
self.description = description
def edit_name(self, name):
"""
Change the Campaign name.
:param name: The new campaign name.
:type name: str
"""
self.name = name
def add_alias(self, alias):
"""
Add a Campaign alias.
:param alias: The campaign alias(es)
:type alias: string or list of strings.
"""
if isinstance(alias, basestring):
alias = [alias]
for a in alias:
if a not in self.aliases and isinstance(a, basestring):
self.aliases.append(a)
def remove_alias(self, alias):
"""
Remove a Campaign alias.
:param alias: The alias to remove.
:type alias: str
"""
self.aliases.remove(alias)
def set_aliases(self, aliases):
"""
Set the Campaign aliases to a specified list.
:param aliases: The alias to set.
:type alias: list
"""
if isinstance(aliases, list):
self.aliases = aliases
def get_aliases(self):
"""
Get the list of Campaign aliases.
:returns: list of aliases.
"""
return [alias for alias in self._data['aliases']]
def add_ttp(self, ttp_item):
"""
Add a TTP to this Campaign.
:param ttp_item: The TTP to add.
:type ttp_item: EmbeddedTTP
"""
if isinstance(ttp_item, EmbeddedTTP):
found = False
for ttp in self.ttps:
if ttp.ttp == ttp_item.ttp:
found = True
if not found:
self.ttps.append(ttp_item)
def edit_ttp(self, old_ttp=None, new_ttp=None):
"""
Edit an existing TTP for this Campaign.
:param old_ttp: The old TTP value.
:type old_ttp: str
:param new_ttp: The new TTP value.
:type new_ttp: str
"""
if old_ttp and new_ttp:
for c, ttp in enumerate(self.ttps):
if ttp.ttp == old_ttp:
self.ttps[c].ttp = new_ttp
def remove_ttp(self, ttp_value=None):
"""
Remove a TTP from this Campaign.
:param ttp_value: The TTP value to remove.
:type ttp_value: str
"""
if ttp_value:
for c, ttp in enumerate(self.ttps):
if ttp_value == ttp.ttp:
self.ttps.remove(ttp)
break
class EmbeddedStatus(EmbeddedDocument):
status = IntField()
operated_at = DateTimeField()
class TeamMember(EmbeddedDocument):
join_time = DateTimeField()
status = IntField() # 0:unaudit ,1:audit_passed, 2:audit_refused
user = ReferenceField(User)
class EBAP(Request):
full_name = 'Eliminación de la historia académica BAPI'
commite_cm = IntField(default=1, display='Acta de comité')
commite_cm_date = DateField(display='Fecha acta de comité',
default=datetime.date.today)
regulation_list = ['008|2008|CSU'] # List of regulations
str_cm = [
'eliminar la historia académica BAPI, debido a que {}realiza debidamente la solicitud.',
]
str_pcm = [
'Modalidad de trabajo de grado: Asignaturas de posgrado. Acta de comité {}, del {} de {} '
+ 'del {}.'
]
def cm(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
self.cm_answer(paragraph)
paragraph.add_run(' ({}). '.format(
self.regulations[self.regulation_list[0]][0]))
def cm_answer(self, paragraph):
paragraph.add_run(self.str_council_header + ' ')
paragraph.add_run(
# pylint: disable=no-member
self.get_approval_status_display().upper() + ' ').font.bold = True
paragraph.add_run(self.str_cm[0].format(
'' if self.is_affirmative_response_approval_status() else 'no ') +
'.')
def pcm(self, docx):
self.pcm_analysis(docx)
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_answer + ': ').bold = True
self.pcm_answer(paragraph)
def pcm_analysis(self, docx):
analysis_list = []
analysis_list += [
self.str_pcm[0].format(
# pylint: disable=no-member
self.commite_cm,
self.commite_cm_date.day,
num_to_month(self.commite_cm_date.month),
self.commite_cm_date.year)
]
analysis_list += self.extra_analysis
add_analysis_paragraph(docx, analysis_list)
def pcm_answer(self, paragraph):
paragraph.add_run(self.str_comittee_header + ' ')
paragraph.add_run(
# pylint: disable=no-member
self.get_advisor_response_display().upper() + ' ').font.bold = True
paragraph.add_run(self.str_cm[0].format(
'' if self.is_affirmative_response_advisor_response() else 'no '))
class AzureEndPoint(DynamicEmbeddedDocument):
name = StringField()
protocol = StringField()
public_port = IntField()
private_port = IntField()
url = StringField()
class CRITsConfig(CritsDocument, Document):
"""
CRITs Configuration Class.
"""
from django.conf import settings
meta = {
"collection": settings.COL_CONFIG,
"crits_type": 'Config',
"latest_schema_version": 1,
"schema_doc": {
},
}
allowed_hosts = ListField(StringField(), default=['*'])
classification = StringField(default='unclassified')
company_name = StringField(default='My Company')
create_unknown_user = BooleanField(default=False)
crits_message = StringField(default='')
crits_email = StringField(default='')
crits_email_subject_tag = StringField(default='')
crits_email_end_tag = BooleanField(default=True)
# This is actually the internal DB version, but is named crits_version
# for historical reasons.
crits_version = StringField(required=True,
default=settings.CRITS_VERSION)
debug = BooleanField(default=True)
depth_max = IntField(default=10)
email_host = StringField(default='')
email_port = StringField(default='')
enable_api = BooleanField(default=False)
enable_toasts = BooleanField(default=False)
git_repo_url = StringField(default='https://github.com/crits/crits')
http_proxy = StringField(default='')
instance_name = StringField(default='My Instance')
instance_url = StringField(default='')
invalid_login_attempts = IntField(default=3)
language_code = StringField(default='en-us')
ldap_auth = BooleanField(default=False)
ldap_tls = BooleanField(default=False)
ldap_server = StringField(default='')
ldap_usercn = StringField(default='')
ldap_userdn = StringField(default='')
ldap_update_on_login = BooleanField(default=False)
log_directory = StringField(default=os.path.join(settings.SITE_ROOT, 'logs'))
log_level = StringField(default='INFO')
password_complexity_desc = StringField(default='8 characters, at least 1 capital, 1 lowercase and 1 number/special')
password_complexity_regex = StringField(default='(?=^.{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$')
query_caching = BooleanField(default=False)
rar_path = StringField(default='/usr/bin/unrar')
rel_max = IntField(default=50)
remote_user = BooleanField(default=False)
rt_url = StringField(default='')
secure_cookie = BooleanField(default=True)
service_dirs = ListField(StringField())
service_model = StringField(default='process')
service_pool_size = IntField(default=12)
session_timeout = IntField(default=12)
splunk_search_url = StringField(default='')
temp_dir = StringField(default='/tmp')
timezone = StringField(default='America/New_York')
total_max = IntField(default=250)
totp_web = StringField(default='Disabled')
totp_cli = StringField(default='Disabled')
zip7_path = StringField(default='/usr/bin/7za')
def migrate(self):
"""
Migrate the Configuration Schema to the latest version.
"""
pass
class RDEF(Request):
full_name = 'Retiro definitivo del programa'
advance = FloatField(required=True, display='% de Avance', default=0.0)
enrolled_academic_periods = IntField(
required=True, display='# Periodos Matriculados', default=0)
papa = FloatField(required=True, display='PAPA', default=0.0)
regulation_list = [] # List of regulations
str_cm = ['presentar con concepto positivo a la División de Registro y Matrícula, ' +
'el retiro voluntario del programa {} ({})',
'debido a que']
list_analysis = [
'SIA: Porcentaje de avance en el plan: {}%',
'SIA: Número de matrículas: {}',
'SIA: P.A.P.A.: {}'
]
def cm(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
self.cm_answer(paragraph)
def cm_answer(self, paragraph):
paragraph.add_run(self.str_council_header + ' ')
# pylint: disable=no-member
paragraph.add_run(
self.get_approval_status_display().upper() + ' ').font.bold = True
paragraph.add_run(self.str_cm[0].format(
self.get_academic_program_display(), self.academic_program))
if not self.is_affirmative_response_approval_status():
paragraph.add_run(
' ' + self.str_cm[1] + ' ' + self.council_decision)
paragraph.add_run('.')
def pcm(self, docx):
self.pcm_analysis(docx)
self.pcm_answer(docx)
def pcm_answer(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_answer + ': ').font.bold = True
paragraph.add_run(self.str_comittee_header + ' ')
# pylint: disable=no-member
paragraph.add_run(
self.get_advisor_response_display().upper() + ' ').font.bold = True
paragraph.add_run(self.str_cm[0].format(
self.get_academic_program_display(), self.academic_program))
if not self.is_affirmative_response_approval_status():
paragraph.add_run(
' ' + self.str_cm[1] + ' ' + self.council_decision)
paragraph.add_run('.')
def pcm_analysis(self, docx):
final_analysis = []
final_analysis += [self.list_analysis[0].format(self.advance)]
final_analysis += [self.list_analysis[1]
.format(self.enrolled_academic_periods)]
final_analysis += [self.list_analysis[2].format(self.papa)]
for extra_a in self.extra_analysis:
final_analysis += [extra_a]
add_analysis_paragraph(docx, final_analysis)
class Message(Document):
topicid = IntField()
comments = ListField(ReferenceField(Comment))
class PasteFile(Document):
id = SequenceField(primary_key=True)
filename = StringField(max_length=5000, null=False)
filehash = StringField(max_length=128, null=False, unique=True)
filemd5 = StringField(max_length=128, null=False, unique=True)
uploadtime = DateTimeField(null=False)
mimetype = StringField(max_length=128, null=False)
size = IntField(null=False)
meta = {'collection': 'paste_file'} # 自定义集合的名字
def __init__(self,
filename='',
mimetype='application/octet-stream',
size=0,
filehash=None,
filemd5=None,
*args,
**kwargs):
# 初始化父类的__init__方法
super(PasteFile, self).__init__(filename=filename,
mimetype=mimetype,
size=size,
filehash=filehash,
filemd5=filemd5,
*args,
**kwargs)
self.uploadtime = datetime.now()
self.mimetype = mimetype
self.size = int(size)
self.filehash = filehash if filehash else self._hash_filename(filename)
self.filename = filename if filename else self.filehash
self.filemd5 = filemd5
@staticmethod
def _hash_filename(filename):
_, _, suffix = filename.rpartition('.')
return '%s.%s' % (uuid.uuid4().hex, suffix)
@cached_property
def symlink(self):
return short_url.encode_url(self.id)
@classmethod
def get_by_symlink(cls, symlink, code=404):
id = short_url.decode_url(symlink)
return cls.objects.get_or_404(id=id)
@classmethod
def get_by_filehash(cls, filehash, code=404):
return cls.objects.get_or_404(filehash=filehash)
@classmethod
def get_by_md5(cls, filemd5):
rs = cls.objects(filemd5=filemd5)
return rs[0] if rs else None
@classmethod
def create_by_upload_file(cls, uploaded_file):
rst = cls(uploaded_file.filename, uploaded_file.mimetype, 0)
uploaded_file.save(rst.path)
with open(rst.path) as f:
filemd5 = get_file_md5(f)
uploaded_file = cls.get_by_md5(filemd5)
if uploaded_file:
os.remove(rst.path)
return uploaded_file
filestat = os.stat(rst.path)
rst.size = filestat.st_size
rst.filemd5 = filemd5
return rst
@classmethod
def create_by_old_paste(cls, filehash):
filepath = get_file_path(filehash)
mimetype = magic.from_file(filepath, mime=True)
filestat = os.stat(filepath)
size = filestat.st_size
rst = cls(filehash, mimetype, size, filehash=filehash)
return rst
@property
def path(self):
return get_file_path(self.filehash)
def get_url(self, subtype, is_symlink=False):
hash_or_link = self.symlink if is_symlink else self.filehash
return 'http://{host}/{subtype}/{hash_or_link}'.format(
subtype=subtype, host=request.host, hash_or_link=hash_or_link)
@property
def url_i(self):
return self.get_url('i')
@property
def url_p(self):
return self.get_url('p')
@property
def url_s(self):
return self.get_url('s', is_symlink=True)
@property
def url_d(self):
return self.get_url('d')
@property
def image_size(self):
if self.is_image:
im = Image.open(self.path)
return im.size
return (0, 0)
@property
def quoteurl(self):
return urllib.quote(self.url_i)
@classmethod
def rsize(cls, old_paste, weight, height):
assert old_paste.is_image, TypeError('Unsupported Image Type.')
img = cropresize2.crop_resize(Image.open(old_paste.path),
(int(weight), int(height)))
rst = cls(old_paste.filename, old_paste.mimetype, 0)
img.save(rst.path)
filestat = os.stat(rst.path)
rst.size = filestat.st_size
return rst
@property
def is_image(self):
return self.mimetype in IMAGE_MIMES
@property
def is_audio(self):
return self.mimetype in AUDIO_MIMES
@property
def is_video(self):
return self.mimetype in VIDEO_MIMES
@property
def is_pdf(self):
return self.mimetype == 'application/pdf'
@property
def type(self):
for t in ('image', 'pdf', 'video', 'audio'):
if getattr(self, 'is_' + t):
return t
return 'binary'
class System(Document, BrewtilsSystem):
"""Mongo-Backed BREWMASTER System Object"""
name = StringField(required=True)
description = StringField()
version = StringField(required=True)
max_instances = IntField(default=1)
instances = ListField(ReferenceField(Instance, reverse_delete_rule=PULL))
commands = ListField(ReferenceField(Command, reverse_delete_rule=PULL))
icon_name = StringField()
display_name = StringField()
metadata = DictField()
meta = {
"auto_create_index":
False, # We need to manage this ourselves
"index_background":
True,
"indexes": [{
"name": "unique_index",
"fields": ["name", "version"],
"unique": True
}],
}
def __str__(self):
return BrewtilsSystem.__str__(self)
def __repr__(self):
return BrewtilsSystem.__repr__(self)
def clean(self):
"""Validate before saving to the database"""
if len(self.instances) > self.max_instances > -1:
raise ModelValidationError(
"Can not save System %s: Number of instances (%s) "
"exceeds system limit (%s)" %
(str(self), len(self.instances), self.max_instances))
if len(self.instances) != len(
set(instance.name for instance in self.instances)):
raise ModelValidationError(
"Can not save System %s: Duplicate instance names" % str(self))
def upsert_commands(self, commands):
"""Updates or inserts a list of commands.
Assumes the commands passed in are more important than what is currently in the db. It
will delete commands that are not listed in the dictionary.
:param commands: The list of new commands
:return: None
"""
old_commands = Command.objects(system=self)
old_names = {command.name: command.id for command in old_commands}
new_commands = copy.copy(commands)
for command in new_commands:
# If this command is already in the DB we want to preserve the ID
if command.name in list(old_names.keys()):
command.id = old_names[command.name]
command.system = self
command.save()
# Clean up orphan commands
new_names = [command.name for command in new_commands]
for command in old_commands:
if command.name not in new_names:
command.delete()
self.commands = new_commands
self.save()
def deep_save(self):
"""Deep save. Saves Commands, Instances, and the System
Mongoengine cannot save bidirectional references in one shot because
'You can only reference documents once they have been saved to the database'
So we must mangle the System to have no Commands, save it, save the individual Commands
with the System reference, update the System with the Command list, and then save the
System again
"""
# Note if this system is already saved
delete_on_error = self.id is None
# Save these off here so we can 'revert' in case of an exception
temp_commands = self.commands
temp_instances = self.instances
try:
# Before we start saving things try to make sure everything will validate correctly
# This means multiple passes through the collections, but we want to minimize the
# chances of having to bail out after saving something since we don't have transactions
# However, we have to start by saving the System. We need it in the database so the
# Commands will validate against it correctly (the ability to undo this is why we
# saved off delete_on_error earlier) The reference lists must be empty or else we
# encounter the bidirectional reference issue
self.commands = []
self.instances = []
self.save()
# Make sure all commands have the correct System reference
for command in temp_commands:
command.system = self
# Now validate
for command in temp_commands:
command.validate()
for instance in temp_instances:
instance.validate()
# All validated, now save everything
for command in temp_commands:
command.save(validate=False)
for instance in temp_instances:
instance.save(validate=False)
self.commands = temp_commands
self.instances = temp_instances
self.save()
# Since we don't have actual transactions we are not in a good position here, try our
# best to 'roll back'
except Exception:
self.commands = temp_commands
self.instances = temp_instances
if delete_on_error and self.id:
self.delete()
raise
def deep_delete(self):
"""Completely delete a system"""
self.delete_commands()
self.delete_instances()
return self.delete()
def delete_commands(self):
"""Delete all commands associated with this system"""
for command in self.commands:
command.delete()
def delete_instances(self):
"""Delete all instances associated with this system"""
for instance in self.instances:
instance.delete()
@classmethod
def find_unique(cls, name, version):
"""Find a unique system using its name and version
:param name: The name
:param version: The version
:return: One system instance if found, None otherwise
"""
try:
return cls.objects.get(name=name, version=version)
except DoesNotExist:
return None
class Certificate(CritsBaseAttributes, CritsSourceDocument, Document):
"""
Certificate Class.
"""
meta = {
"collection": settings.COL_CERTIFICATES,
"crits_type": 'Certificate',
"latest_schema_version": 1,
"schema_doc": {
'filename': 'The filename of the certificate',
'filetype': 'The filetype of the certificate',
'md5': 'The MD5 of the certificate file',
'size': 'The filesize of the certificate',
'description': 'Description of what the certificate contains',
'source': 'List [] of source information about who provided the certificate'
},
"jtable_opts": {
'details_url': 'crits.certificates.views.certificate_details',
'details_url_key': 'md5',
'default_sort': "modified DESC",
'searchurl': 'crits.certificates.views.certificates_listing',
'fields': [ "filename", "description", "filetype",
"size", "modified", "source", "campaign",
"id", "md5", "status" ],
'jtopts_fields': [ "details",
"filename",
"description",
"filetype",
"size",
"modified",
"source",
"campaign",
"status",
"md5",
"favorite",
"id" ],
'hidden_fields': ["md5"],
'linked_fields': ["source", "campaign"],
'details_link': 'details',
'no_sort': ['details']
},
}
description = StringField()
filedata = getFileField(collection_name=settings.COL_CERTIFICATES)
filename = StringField(required=True)
filetype = StringField(required=True)
size = IntField(default=0)
md5 = StringField()
def migrate(self):
"""
Migrate the Certificate tot he latest schema version.
"""
pass
def add_file_data(self, file_data):
"""
Add the Certificate to GridFS.
:param file_data: The Certificate.
:type file_data: str
"""
self._generate_file_metadata(file_data)
self.filedata = file_data
def add_file_obj(self, file_obj):
"""
Add the Certificate to GridFS.
:param file_obj: The Certificate.
:type file_data: file handle
"""
data = file_obj.read()
self._generate_file_metadata(data)
self.filedata = data
def _generate_file_metadata(self, data):
"""
Set the filetype, size, and MD5 of the Certificate.
:param data: The Certificate.
:type data: str
"""
import magic
from hashlib import md5
self.filetype = magic.from_buffer(data)
self.size = len(data)
# this is a shard key. you can't modify it once it's set.
# MongoEngine will still mark the field as modified even if you set it
# to the same value.
if not self.md5:
self.md5 = md5(data).hexdigest()
def discover_binary(self):
"""
Queries GridFS for a matching binary to this Certificate document.
"""
from crits.core.mongo_tools import mongo_connector
fm = mongo_connector("%s.files" % self._meta['collection'])
objectid = fm.find_one({'md5': self.md5}, {'_id': 1})
if objectid:
self.filedata.grid_id = objectid['_id']
self.filedata._mark_as_changed()
class Nonce(Document, NonceMixin):
"""One use numbers"""
server_url = StringField(max_length=255)
timestamp = IntField()
salt = StringField(max_length=40)
class Target(CritsBaseAttributes, CritsActionsDocument, Document):
"""
Target class.
"""
meta = {
"collection": settings.COL_TARGETS,
"auto_create_index": False,
"crits_type": 'Target',
"latest_schema_version": 3,
"schema_doc": {
'department': 'Target department name',
'division': 'Target division',
'email_address': 'Target email address',
'email_count': 'Emails destined for this user. Added by MapReduce',
'organization_id': 'Target organization ID number',
'firstname': 'Target first name',
'lastname': 'Target last name',
'title': 'Target job title',
'note': 'Custom note about target'
},
"jtable_opts": {
'details_url': 'crits-targets-views-target_info',
'details_url_key': 'email_address',
'default_sort': "email_count DESC",
'searchurl': 'crits-targets-views-targets_listing',
'fields': [ "email_address","firstname", "lastname",
"email_count", "department", "division",
"status", "id"],
'jtopts_fields': [ "details",
"email_address",
"firstname",
"lastname",
"email_count",
"department",
"division",
"status",
"favorite",
"id"],
'hidden_fields': [],
'linked_fields': [ "department", "division" ],
'details_link': 'details',
'no_sort': ['details']
}
}
email_address = EmailField(required=True)
email_count = IntField(default=0)
department = StringField()
division = StringField()
organization_id = StringField()
firstname = StringField()
lastname = StringField()
title = StringField()
note = StringField()
def migrate(self):
migrate_target(self)
def find_emails(self, username):
sources = user_sources(username)
emails = Email.objects(to__iexact=self.email_address,
source__name__in=sources)
return emails
class ContentUnit(Document):
"""
The base class for all content units.
All classes inheriting from this class must override the unit_type_id and _ns to ensure
they are populated properly.
:ivar id: content unit id
:type id: mongoengine.StringField
:ivar last_updated: last time this unit was updated (since epoch, zulu time)
:type last_updated: mongoengine.IntField
:ivar user_metadata: Bag of User supplied data to go along with this unit
:type user_metadata: mongoengine.DictField
:ivar storage_path: Location on disk where the content associated with this unit lives
:type storage_path: mongoengine.StringField
:ivar _ns: (Deprecated), Contains the name of the collection this model represents
:type _ns: mongoengine.StringField
:ivar unit_type_id: content unit type
:type unit_type_id: mongoengine.StringField
"""
id = StringField(primary_key=True)
last_updated = IntField(db_field='_last_updated', required=True)
user_metadata = DictField(db_field='pulp_user_metadata')
storage_path = StringField(db_field='_storage_path')
# For backward compatibility
_ns = StringField(required=True)
unit_type_id = StringField(db_field='_content_type_id', required=True)
meta = {
'abstract': True,
}
_NAMED_TUPLE = None
@classmethod
def attach_signals(cls):
"""
Attach the signals to this class.
This is provided as a class method so it can be called on subclasses
and all the correct signals will be applied.
"""
signals.post_init.connect(cls.post_init_signal, sender=cls)
signals.pre_save.connect(cls.pre_save_signal, sender=cls)
# Create the named tuple here so it happens during server startup
cls.NAMED_TUPLE = namedtuple(cls.unit_type_id.default,
cls.unit_key_fields)
@classmethod
def post_init_signal(cls, sender, document):
"""
The signal that is triggered before a unit is initialized
This is used to validate that the unit_key_fields attribute is set properly
:param sender: sender class
:type sender: object
:param document: Document that sent the signal
:type document: ContentUnit
:raises: PLP0035 if the unit_key_fields attribute has not been defined
"""
if not hasattr(document, 'unit_key_fields'):
class_name = type(document).__name__
raise exceptions.PulpCodedException(error_codes.PLP0035,
class_name=class_name)
@classmethod
def pre_save_signal(cls, sender, document, **kwargs):
"""
The signal that is triggered before a unit is saved, this is used to
support the legacy behavior of generating the unit id and setting
the last_updated timestamp
:param sender: sender class
:type sender: object
:param document: Document that sent the signal
:type document: ContentUnit
"""
if not document.id:
document.id = str(uuid.uuid4())
document.last_updated = dateutils.now_utc_timestamp()
def get_repositories(self):
"""
Get an iterable of Repository models for all the repositories that contain this unit
:return: Repositories that contain this content unit
:rtype: iterable of Repository
"""
content_list = RepositoryContentUnit.objects(unit_id=self.id)
id_list = [item.repo_id for item in content_list]
return Repository.objects(repo_id__in=id_list)
@property
def unit_key(self):
"""
Dictionary representation of the unit key
"""
return dict((key, getattr(self, key)) for key in self.unit_key_fields)
@property
def unit_key_str(self):
"""
The unit key represented as a string ordered by unit key fields alphabetically
"""
return str(sorted([getattr(self, key)
for key in self.unit_key_fields]))
@property
def unit_key_as_named_tuple(self):
"""
The unit key represented as a named_tuple by field name
"""
return self.NAMED_TUPLE(**self.unit_key)
def __hash__(self):
"""
This should provide a consistent and unique hash where units of the same
type and the same unit key will get the same hash value.
"""
return hash(self.unit_type_id + self.unit_key_str)
def __init__(self, *args, **kwargs):
super(ModelLabels, self).__init__(field=IntField(), *args, **kwargs)
class MissionStep(Document):
mission = ReferenceField(Mission)
order = IntField(required=True)
command = StringField(required=True, max_length=50)
sleep = FloatField(required=False)
class Category1(Document):
primary = IntField(primary_key=True)
name = StringField()
