class DogRegistration(models.Model):
exhibition = models.ForeignKey(Exhibition,
verbose_name="Выставка",
on_delete=models.CASCADE)
owner = models.ForeignKey(DogOwner,
verbose_name="Хозяин",
on_delete=models.CASCADE)
dog = ChainedForeignKey(Dog,
verbose_name="Собака",
chained_field="owner",
chained_model_field="owner",
show_all=False,
auto_choose=True,
sort=True)
# dog = models.ForeignKey(
# Dog,
# verbose_name="Собака",
# on_delete=models.CASCADE)
is_paid = models.BooleanField(verbose_name="Оплата")
def __str__(self):
return str(self.exhibition) + " " + str(self.dog)
class Answer(models.Model):
PA = 'PA'
SA = 'SA'
TYPE_OF_ANSWERS = [(PA, 'Вариант ответа'),
(SA, 'Ответ вводимый через текстовое поле')]
test = models.ForeignKey('Test',
null=True,
blank=True,
on_delete=models.CASCADE,
verbose_name='Тест')
question = ChainedForeignKey('Question',
chained_field='test',
chained_model_field="test",
show_all=False,
auto_choose=True,
sort=True,
on_delete=models.CASCADE,
verbose_name='Вопрос')
# question = models.ForeignKey('Question', on_delete=models.CASCADE)
type_of_answer = models.CharField(choices=TYPE_OF_ANSWERS,
default=PA,
max_length=50)
answer = models.CharField(max_length=200,
blank=True,
null=True,
verbose_name='Ответ')
def __str__(self):
return self.answer
class Meta:
verbose_name = 'Ответ'
verbose_name_plural = 'Ответы'
class ManageProduct(models.Model):
category = models.ForeignKey(ProductCategory,
on_delete=models.DO_NOTHING,
default='')
subategory = ChainedForeignKey(
ProductSubCategory,
chained_field="category",
chained_model_field="Category",
show_all=False,
auto_choose=True,
)
Brand = models.ForeignKey(ManageBrand,
on_delete=models.CASCADE,
default='')
Product_Name = models.CharField(max_length=50)
Description = models.CharField(max_length=50)
Image = models.ImageField(upload_to='images')
Product_SKU = models.CharField(max_length=50)
Product_Price = models.IntegerField()
Discount_On_Price = models.IntegerField()
Related_Products = models.CharField(max_length=50)
active = ((1, 'Deactive'), (0, 'Active'))
Status = models.BooleanField(default=True, choices=active)
def is_ManageProduct(self):
if self.Status == 1:
return True
return False
is_ManageProduct.boolean = True
class Meta:
ordering = ('Product_Name', )
class Qualification(models.Model):
qualification_id = models.AutoField(primary_key=True)
qualification_classification_id = models.ForeignKey(
'QualificationClassification', on_delete=models.CASCADE, null=True)
country_id = models.ForeignKey('country_information',
on_delete=models.CASCADE)
candidate_type_id = models.ForeignKey('CandidateType',
on_delete=models.CASCADE,
null=True)
qualification = models.CharField(max_length=128, null=True)
# qualification_level = models.IntegerField(null=True)
qualification_level = ChainedForeignKey(
QualificationClassification,
related_name='qualification_level_new',
chained_field="qualification_classification_id",
chained_model_field="qualification_classification_id",
show_all=False,
auto_choose=True,
sort=True,
null=True)
description = models.CharField(max_length=255, null=True)
acronym = models.CharField(max_length=128, null=True)
english_translation = models.CharField(max_length=128, null=True)
specialist_registration_reqd = models.BooleanField(default=False,
null=True)
by_exam = models.BooleanField(default=False)
course_duration_reqd = models.BooleanField(default=False, null=True)
comments = models.CharField(default=False, null=True, max_length=128)
allow_subject_input = models.BooleanField(default=False, null=True)
display_order = models.IntegerField(null=True)
equivalent_qualification = models.BooleanField(default=False, null=True)
def __str__(self) -> str:
return self.qualification
class QuizCompletedFeedback(Assistant):
"""Defines the actions of sending feedback when a student has completed a quiz."""
quiz = ChainedForeignKey(Quiz,
chained_field="course",
chained_model_field="course",
show_all=False,
auto_choose=True,
sort=True)
name = 'quiz_completed_feedback'
event = "http://adlnet.gov/expapi/verbs/completed"
question_feedback = models.BooleanField(verbose_name='Feedback on individual questions', default=False)
threshold = models.IntegerField(verbose_name='threshold for quiz feedback', default=55,
help_text='If a student scores below this threshold, he/she will receive feedback.'
' Enter a value between 0 and 100. The score is in percentages.',
validators=[MinValueValidator(0), MaxValueValidator(100)])
def save(self, *args, **kwargs):
"""Use the save function inherited from Assistant but alter two variables."""
self.context['quiz_id'] = str(self.quiz.external_id)
self.query_template = 'assistants/quiz_completed_query.json'
super().save(*args, **kwargs)
class Meta:
verbose_name = "quiz completed feedback assistant"
class LeagueTableData(models.Model):
league = models.ForeignKey(LeagueTable, on_delete=models.CASCADE)
#team = models.ForeignKey(Team, on_delete=models.CASCADE, default="1")
team = ChainedForeignKey(Team,
chained_field="league",
chained_model_field="teams",
show_all=False,
auto_choose=True,
sort=True,
related_name='table_team')
wins = models.IntegerField()
loss = models.IntegerField()
draw = models.IntegerField()
sf = models.IntegerField()
sa = models.IntegerField()
sq = models.IntegerField()
pf = models.IntegerField()
pa = models.IntegerField()
pe = models.IntegerField()
pq = models.IntegerField()
points = models.IntegerField()
def __str__(self):
return '%s - %s' % (self.league, self.team)
def get_api_url(self, request=None):
return api_reverse('api-leagues:leaguetabledata-rud',
kwargs={'pk': self.pk},
request=request)
class News(models.Model):
title = models.CharField(max_length=150, verbose_name="Başlık")
slug = models.SlugField(unique=True, null=True, blank=True, max_length=255)
spot = models.CharField(max_length=255)
detail = RichTextField(verbose_name="İçerik")
date = models.DateTimeField(auto_now_add=True)
image = models.ImageField(upload_to="News")
user = models.ForeignKey(User, on_delete=None)
category = models.ForeignKey("Category", on_delete=models.CASCADE)
sub_category = ChainedForeignKey("SubCategory", chained_field='category', chained_model_field='parent')
video_url = models.CharField(max_length=200, default="0",
help_text="Eğer video eklemek istemiyorsanız burası 0 olarak kalmalı")
active = models.BooleanField(default=True)
viewed = models.IntegerField(verbose_name="Görüntülenme Sayısı", default=0)
tags = models.CharField(max_length=200,
help_text="Lütfen kelimelerin arasında virgül kullanınız ve boşluk kullanmayınız")
def __str__(self):
return self.title
def tags_split(self):
return self.tags.split(',')
class Meta:
ordering = ('title','pk')
class CashMovements(models.Model):
class Meta:
verbose_name_plural = "Cash Movements"
author = models.ForeignKey(User,
null=True,
editable=False,
on_delete=models.CASCADE)
protocol = models.IntegerField(unique=True,
editable=False,
default=protocolgen)
annulled = models.BooleanField(default=True,
help_text='[Deselect for cancel entry]',
verbose_name="Validation")
recived = models.NullBooleanField(default=False, verbose_name="Recived")
operation_date = models.DateField(verbose_name="Operation Date",
default=timezone.now)
document_date = models.DateField(blank=True,
null=True,
verbose_name="Document Date")
cashdesk = models.ForeignKey('settings.CashDesk',
verbose_name="Cash Service",
on_delete=models.CASCADE)
causal = models.ForeignKey('settings.MovementsCausal',
verbose_name="Causal",
on_delete=models.CASCADE)
mv_type = models.ForeignKey('settings.MovementsType',
verbose_name="Type",
null=True,
blank=True,
on_delete=models.CASCADE)
supplier = models.CharField(max_length=500,
verbose_name="Supplier",
null=True)
amount = models.DecimalField(max_digits=10,
decimal_places=2,
verbose_name="Amount",
help_text='(Use "." as decimal separator)')
customer = models.ForeignKey('settings.Customer',
null=True,
blank=True,
editable=False,
verbose_name="Service Customer",
on_delete=models.CASCADE)
note = models.CharField(max_length=200, blank=True, verbose_name="Note")
sign = ChainedForeignKey('settings.OperatorNew',
verbose_name="Sign",
chained_field='cashdesk',
chained_model_field='services',
null=True,
on_delete=models.CASCADE)
def publish(self):
self.published_date = timezone.now()
self.save()
def __str__(self):
# return u'%s %s %s %s' % (self.operation_date, self.amount, self.causal, self.cashdesk)
return u'%s' % (self.protocol)
class Emprendimiento(models.Model, BaseUpdateUrl):
attr_query = 'emprendimiento'
persona = models.ForeignKey('personas.Persona')
tipo_negocio = models.ForeignKey(TipoNegocio)
negocio = ChainedForeignKey(Negocio,
chained_field='tipo_negocio',
chained_model_field='tipo_negocio')
ficha_caracterizacion = models.BooleanField(default=False)
ingreso_promedio_ventas = models.PositiveIntegerField(default=0)
ingreso_promedio_ventas_finales = models.PositiveIntegerField(default=0)
tipo_unidad_productova = models.ForeignKey(TipoUnidadProductiva)
sector = models.ForeignKey(Sector)
capital_semilla = models.PositiveIntegerField(default=0)
inscrito_en = models.CharField(max_length=50,
choices=(('Fortalecimiento Empresarial',
'Fortalecimiento Empresarial'),
('Emprendimiento',
'Emprendimiento')))
class Meta:
unique_together = ['persona', 'negocio']
verbose_name = 'Emprendimiento'
verbose_name_plural = 'Emprendimientos'
def __str__(self):
return 'emprendimiento #{}, {} a nombre de {}'.format(
self.pk, self.negocio.nombre, self.negocio.propietario)
class Casa(CantidadPersonas, models.Model):
direccion_casa = models.CharField(max_length=30, unique=True)
numero_casa = models.SmallIntegerField()
numero_telefono = models.CharField(max_length=15, blank=True, null=True)
numero_telefono_2 = models.CharField(max_length=15, blank=True, null=True)
tipo_manzana = models.ForeignKey(TipoManzana)
numero_manzana = ChainedForeignKey(Manzana,
chained_field='tipo_manzana',
chained_model_field='tipo_manzana')
tipo_vivienda = models.ForeignKey(TipoVivienda)
class Meta:
verbose_name = 'Manzana'
verbose_name_plural = 'Manzanas'
def __str__(self):
return 'casa {} manzana {} - {}'.format(self.numero_casa,
self.numero_manzana,
self.direccion_casa)
def get_update_url(self):
return reverse_lazy('personas:editar_casa', kwargs={'pk': self.pk})
def personas(self):
return Persona.objects.filter(casa=self)
class Item(models.Model):
item_name = models.CharField(max_length=50)
image = models.ImageField(upload_to='image/', blank=True)
category = models.ForeignKey(Category, on_delete=models.PROTECT)
subcategory = ChainedForeignKey(SubCategory,
chained_field='category',
chained_model_field='category',
show_all=False,
auto_choose=True,
on_delete=models.PROTECT,
sort=True)
item_unit = models.ForeignKey(Unit,
on_delete=models.PROTECT,
related_name='item_unit')
available_quantity = models.DecimalField(max_digits=8, decimal_places=2)
rate = models.DecimalField(max_digits=8,
decimal_places=2,
verbose_name='Sales Rate')
purchase_price_multiplier = models.DecimalField(max_digits=4,
decimal_places=2,
default=1.30)
history = HistoricalRecords()
def __str__(self):
return self.item_name + ' ' + '( ₹ ' + str(self.rate) + ' / ' + str(
self.item_unit) + ' )'
class Meta:
verbose_name_plural = ' Items (Sales)'
class configuracion_talla_detpedido(models.Model):
pedido_fk = models.ForeignKey(pedido, verbose_name="Pedido")
detalle_pedido_fk = ChainedForeignKey(Detalle_predido,
chained_field="pedido_fk",
chained_model_field="pedido",
show_all=False,
auto_choose=False,
verbose_name="Pedido")
talla_fk = models.CharField(max_length=50, verbose_name="Talla")
cantidad = models.PositiveIntegerField(verbose_name="Cantidad")
taller_fk = models.ForeignKey(Taller,
verbose_name="Taller",
null=True,
blank=True)
order = models.PositiveIntegerField(verbose_name="Orden")
fecha_creacion = models.DateTimeField(auto_now_add=True,
null=True,
blank=True,
verbose_name="Fecha creacion")
def __unicode__(self):
return "%s" % (self.talla_fk)
class Meta:
verbose_name = u'Configuracion talla pedido'
verbose_name_plural = u'Configuracion tallas pedidos'
class Criminal(models.Model):
criminal_id = models.AutoField(primary_key=True)
name = models.CharField(max_length=30)
age = models.IntegerField()
physical_description = models.TextField(blank=True)
date = models.DateField()
state = models.ForeignKey('upload.States',
on_delete=models.CASCADE,
default=11)
city = ChainedForeignKey(Cities,
chained_field="state",
chained_model_field="state",
show_all=False,
auto_choose=True,
sort=True)
crime_type = models.CharField(max_length=30)
arresting_agency = models.CharField(max_length=30)
photo = models.ImageField(blank=True,
upload_to='criminals/',
default='criminals/missing.jpeg')
rating = models.FloatField(default=0)
def __str__(self):
return self.name
def location(self):
return self.city.name + ', ' + self.state.name
class Product(models.Model):
title = models.CharField(max_length=100)
price = models.PositiveIntegerField()
discounted_price = models.PositiveIntegerField(null=True, blank=True)
picture = models.ImageField(upload_to='products/', blank=True, null=True)
quantity = models.PositiveIntegerField(default=0)
description = models.TextField()
status = models.CharField(choices=STATUS_CHOICES,
default='standard',
max_length=20)
updated_at = models.DateTimeField(auto_now=True)
expire_date = models.DateTimeField(null=True, blank=True)
category = models.ForeignKey(Category,
on_delete=models.CASCADE,
blank=True,
null=True)
subcategories = ChainedForeignKey(Subcategory,
chained_field="category",
chained_model_field="category",
show_all=False,
auto_choose=True,
sort=True,
on_delete=models.CASCADE,
blank=True,
null=True)
objects = models.Manager()
discount = DiscountManager()
new_product = NewProductManager()
day_product = ProductOfTheDayManager()
def __unicode__(self):
return self.title
class SubscribedEventType(ActiveModel):
subscriber = models.ForeignKey(Subscriber,null=False,related_name="event_types",on_delete=models.PROTECT)
publisher = models.ForeignKey(Publisher,null=False,related_name="subscribed_publisher_event_types",on_delete=models.PROTECT)
event_type = ChainedForeignKey(EventType,
chained_field="publisher", chained_model_field="publisher",
show_all=False, auto_choose=True, null=False,on_delete=models.PROTECT)
category = models.SmallIntegerField(default=MANAGED,choices=CATEGORY_CHOICES)
event_processing_module = models.ForeignKey(EventProcessingModule,null=True,on_delete=models.PROTECT,blank=True)
parameters = JSONField(null=True,blank=True)
replay_missed_events = models.BooleanField(editable=True,default=True)
replay_failed_events = models.BooleanField(editable=True,default=True)
last_dispatched_event = models.ForeignKey(Event,null=True,on_delete=models.PROTECT,editable=False)
last_dispatched_time = models.DateTimeField(null=True,editable=False)
last_listening_time = models.DateTimeField(null=True,editable=False)
@property
def is_system_event_type(self):
return self.category == SYSTEM
@property
def is_editable(self):
return self.category in (MANAGED,TESTING)
def __str__(self):
return "{} subscribes {}".format(self.subscriber,self.event_type)
class Meta(object):
db_table = "subscribed_event_type"
unique_together = [('subscriber','publisher','event_type')]
class ProductInCart(models.Model):
id = models.AutoField(primary_key=True)
product = models.ForeignKey(Product)
cart = models.ForeignKey('ProductCart')
count = models.IntegerField()
price_correction = ChainedForeignKey(ProductPriceCorrector,
chained_field="product",
chained_model_field="product",
show_all=False,
auto_choose=True,
null=True,
blank=True)
def price(self):
sale = 1
if self.product.sale:
sale = 1 - (self.product.sale.percent / 100)
margin = 1
if self.product.margin:
margin = 1 - (self.product.margin.percent / 100)
if self.price_correction:
return self.price_correction.new_price * self.count * sale / margin
return self.product.default_price * self.count * sale / margin
def __str__(self):
return str.format("{0} ({1}) = {2}", self.product, self.count,
self.price())
class Meta:
db_table = 'products_in_carts'
verbose_name = 'Product in Cart'
verbose_name_plural = 'Products in Carts'
class FirmLocation(models.Model):
firm = models.ForeignKey(Firm, on_delete=models.CASCADE)
state = models.ForeignKey(State, on_delete=models.CASCADE)
city = ChainedForeignKey(City,
chained_field='state',
chained_model_field='state',
show_all=False,
auto_choose=True,
sort=True)
# city = GroupedForeignKey(City, "state")
street = models.CharField(max_length=50)
def validate_unique(self, exclude=None):
super().validate_unique(exclude=exclude)
qs = self.__class__._default_manager.filter(firm=self.firm,
city=self.city)
if self._state.adding and qs.exists():
raise ValidationError('The firm location already exists.')
def clean(self):
if self.city.state != self.state:
raise ValidationError(
f"State '{self.state}' and City '{self.city}' are inconsistent"
)
def __str__(self):
return f'{self.firm}: {self.city}'
class Container(models.Model):
number = models.CharField(max_length=12,
validators=[
RegexValidator(
regex=r'[a-zA-Z]{4}\d{6}\-\d{1}',
message="Please enter in the format\
: ABCD123456-7.")
])
pickup_date = models.DateField()
load_date = models.DateField(null=True, blank=True)
departure_date = models.DateField(null=True, blank=True)
steamship = models.ForeignKey(
Steamship,
on_delete=models.CASCADE,
)
booking = ChainedForeignKey(Booking,
chained_field='steamship',
chained_model_field='steamship',
show_all=False,
auto_choose=True,
blank=True,
null=True)
railyard = models.CharField(max_length=20, choices=RAILYARD)
size = models.CharField(max_length=20, choices=CONTAINER_SIZE)
status = models.CharField(max_length=10,
choices=STATUS,
default='Pre-Shipment',
blank=True)
def __str__(self):
return "{}".format(self.number)
class JobSeekersProfile(models.Model):
jobseeker = models.OneToOneField(JobSeekers, on_delete=models.CASCADE)
linkedin_profile = models.CharField(max_length=200,
blank=True,
default='',
null=True)
pref_job_loc = models.CharField(max_length=100,
blank=True,
default='',
null=True)
resume = models.FileField(blank=True,
upload_to='resume',
default='',
null=True)
category = models.ForeignKey(Category,
on_delete=models.SET_NULL,
null=True)
subcategory = ChainedForeignKey(SubCategory,
chained_field="category",
chained_model_field="category",
show_all=False,
auto_choose=True,
sort=True,
null=True)
designation = models.CharField(max_length=30, blank=False, null=True)
key_skills = models.TextField(blank=False, default='', null=True)
total_workexp = models.CharField(max_length=20,
blank=False,
default='',
null=True)
current_drawn_sal = models.PositiveIntegerField(blank=True, default=0)
def __str__(self):
return self.jobseeker.user.username
class Material(models.Model):
dept_name = models.ForeignKey(Department,
on_delete=models.CASCADE,
blank=True,
null=True)
code = ChainedForeignKey(
Subject,
chained_field="dept_name",
chained_model_field="dept_name",
show_all=False,
auto_choose=False,
sort=True,
)
type = models.CharField(max_length=50,
choices=Material_CHOICES,
default='books')
material_desc = models.CharField(max_length=50,
blank=False,
null=False,
default='code')
material_link = models.CharField(max_length=1000, blank=True)
material_file = models.FileField(blank=True)
def clean(self):
if self.material_link == '' and self.material_file is None:
raise ValidationError(_('Chose any one of Options'))
if self.material_link is not None and self.material_file is not None:
raise ValidationError(_('Chose any one of the option'))
def get_absolute_url(self):
return '/'
def __str__(self):
return 'Course: {} {}'.format(self.code, self.material_desc)
class ComplianceManagementSystemGroup(models.Model):
#name = models.CharField(max_length=150, unique=True)
name = models.CharField(max_length=200,
choices=settings.GROUP_NAME_CHOICES)
region = models.ForeignKey(Region, null=True, on_delete=models.PROTECT)
district = ChainedForeignKey(
District,
on_delete=models.PROTECT,
chained_field='region',
chained_model_field='region',
show_all=False,
null=True,
)
group_email = models.CharField(max_length=255, blank=True)
class Meta:
app_label = 'wildlifecompliance'
unique_together = [['name', 'region', 'district']]
verbose_name = 'CM_Compliance Management System Group'
verbose_name_plural = 'CM_Compliance Management System Groups'
def __str__(self):
return "{}, {}, {}".format(self.get_name_display(), self.region,
self.district)
def get_members(self):
return [
perm.emailuser for perm in
self.compliancemanagementsystemgrouppermission_set.all()
]
def add_member(self, user):
ComplianceManagementSystemGroupPermission.objects.create(
group=self, emailuser=user)
class ColetaArticulacao(models.Model):
class Meta:
verbose_name = u'Articulação da Coleta'
verbose_name_plural = u'Articuladores da Coleta'
UF = models.ForeignKey(UF, verbose_name=u'UF')
municipio = ChainedForeignKey(Municipio,
chained_fields={
'UF': 'uf',
},
show_all=False,
auto_choose=False,
verbose_name=u'Município',
null=True,
blank=True)
zona = models.IntegerField(u'Zona', null=True, blank=True)
articulador = models.ForeignKey(Membro, verbose_name=u'Articulador')
def clean(self):
if not self.municipio:
if not self.articulador.usuario or self.articulador.usuario.groups.filter(
name=u'Cadastro'):
raise ValidationError(
u'O campo Município é obrigatório para esse Articulador.')
return super(ColetaArticulacao, self).clean()
def __unicode__(self):
return u'%s' % self.articulador
class PqrHeader(models.Model):
pqr_header_id = models.AutoField(primary_key=True)
country_id = models.ForeignKey('country_information',
on_delete=models.CASCADE)
# issue_authority_id = models.ForeignKey('IssueAuthority', on_delete=models.CASCADE)
issue_authority_id = ChainedForeignKey(
IssueAuthority,
related_name='new_country',
chained_field="country_id",
chained_model_field="issue_country_id",
show_all=False,
auto_choose=True,
sort=True,
null=True)
pqr_name = models.CharField(null=True, max_length=128)
issue_date = models.DateField(null=True)
version_no = models.IntegerField(null=True)
description = models.CharField(null=True, max_length=255)
comments = models.CharField(null=True, max_length=255)
# country = relationship('CountryInfo')
# issue_authority = relationship('IssueAuthority')
# @property
# def country_name(self):
# if self.country_id:
# return self.country.country_name
# @property
# def issue_authority_name(self):
# if self.issue_authority_id:
# return self.issue_authority.authority_name
def __str__(self):
return self.pqr_name
class Encuesta(models.Model):
''' Modelo de encuesta principal
'''
fecha = models.IntegerField("año de encuesta")
municipio = models.ForeignKey(Municipio, verbose_name="Nombre del Municipio")
#comarca = models.ForeignKey(Comarca, verbose_name="Nombre de la comarca/barrio")
comarca = ChainedForeignKey(
Comarca,
chained_field="municipio",
chained_model_field="municipio",
show_all=False,
auto_choose=True
)
beneficiario = models.CharField('Nombre del Beneficiario/a', max_length=200)
encuestador = models.ForeignKey(Recolector, verbose_name="Nombre del encuestador")
contraparte = models.ForeignKey(Contraparte, null=True, blank=True)
usuario = models.ForeignKey(User)
#campos ocultos para efectos de querys
sexo_jefe = models.IntegerField(default=0, editable=False)
#credito si: 1, credito no: 2
credito = models.IntegerField(default=2, editable=False)
def __unicode__(self):
return self.beneficiario
class Meta:
verbose_name_plural = "Encuesta Linea base"
class Location(models.Model):
continent = models.ForeignKey(Continent, on_delete="", db_column="continent")
country = ChainedForeignKey(
Country,
chained_field="continent",
chained_model_field="continent",
show_all=False,
auto_choose=True,
sort=True, db_column="country")
# country = ChainedForeignKey(Country, chained_field="Continent", chained_model_field="name")
# country = GroupedForeignKey(Country, "continent", db_column="country")
area = models.CharField(primary_key=True, max_length=200)
city = models.CharField(max_length=100, blank=True, null=True)
street = models.CharField(max_length=200, blank=True, null=True)
def __str__(self):
return Location
class Meta:
managed = False
db_table = 'location'
class Aplicacion(models.Model):
taplicacion = models.ForeignKey(
TAplicacion,
verbose_name="Tipo Aplic",
help_text="Selecciona el tipo de aplicacion")
vaplicacion = ChainedForeignKey(
VAplicacion,
chained_field="taplicacion",
chained_model_field="taplicacion",
verbose_name="Version de Aplic",
help_text="Selecciona la version de la aplicacion")
descripcion = models.TextField(help_text="Descripcion de la aplicacion")
ruta = models.CharField(max_length=200,
unique=False,
verbose_name="Ruta instalacion",
help_text="Donde esta instalado")
maquina = models.ManyToManyField(Maquina)
servicio = models.ForeignKey(Servicio, verbose_name='Servicios')
def _get_tvaplicacion(self):
return '%s %s' % (self.taplicacion, self.vaplicacion)
class Meta:
ordering = ['taplicacion']
verbose_name_plural = "Aplicaciones"
tvaplicacion = property(_get_tvaplicacion)
class ApplicationVersionCloudConfig(models.Model):
application_version = models.ForeignKey(ApplicationVersion, related_name="app_version_config")
cloud = models.ForeignKey(Cloud, related_name="app_version_config")
image = ChainedForeignKey(CloudImage, chained_field="cloud", chained_model_field="cloud")
default_instance_type = models.CharField(max_length=256, blank=True, null=True)
# Userdata max length is 16KB
default_launch_config = models.TextField(max_length=1024 * 16, help_text="Cloud "
"specific initial configuration data to parameterize the launch with.",
blank=True, null=True)
class Meta:
unique_together = (("application_version", "cloud"),)
def save(self, *args, **kwargs):
# validate user data
if self.default_launch_config:
try:
json.loads(self.default_launch_config)
except Exception as e:
raise Exception("Invalid JSON syntax. Launch config must be in JSON format. Cause: {0}".format(e))
return super(ApplicationVersionCloudConfig, self).save()
def compute_merged_config(self):
default_appwide_config = json.loads(self.application_version.application.default_launch_config or "{}")
default_version_config = json.loads(self.application_version.default_launch_config or "{}")
default_cloud_config = json.loads(self.default_launch_config or "{}")
default_combined_config = jsonmerge.merge(default_appwide_config, default_version_config)
return jsonmerge.merge(default_combined_config, default_cloud_config)
class Alumnus(models.Model):
enrollment_no = models.CharField('Enrollment No.',
max_length=12,
primary_key=True,
default='AXXXXXXXXXXX')
name = models.CharField(max_length=50)
gender = models.CharField(default='Gender',
max_length=1,
choices=GENDER_CHOICE)
dob = models.DateField('Date of Birth', default='1994-01-01')
contactno = models.IntegerField('Contact No.')
image = models.ImageField('Add Image', upload_to=upload_location)
fblink = models.CharField('Facebook ID Link',
default='http://www.facebook.com/',
max_length=100)
linkedin = models.CharField('LinkedIn Link',
default='http://www.linkedin.com/',
max_length=100)
email = models.EmailField('Email ID', )
campus = models.ForeignKey(campus_select)
branch = ChainedForeignKey('branch_select',
chained_field="from_campus",
chained_model_field="from_campus",
show_all=True,
auto_choose=True)
batch = models.IntegerField('Passout Year', default='%d' % now.year)
placed = models.CharField('Presently Placed at',
max_length=100,
default='Where are you presently working?')
class Meta:
ordering = ('name', 'batch')
def __unicode__(self):
return self.name
class Proveedor(models.Model):
razon = models.CharField(max_length=200)
cuit = models.CharField(max_length=13,
validators=[
RegexValidator(
r'^[0-9]{2}-[0-9]{8}-[0-9]$',
'El número ingresado es incorrecto',
'Número incorrecto')
])
telefono = models.CharField(
max_length=10,
validators=[
RegexValidator(
r'^(?:(?:00)?549?)?0?(?:11|[2368]\d)(?:(?=\d{0,2}15)\d{2})??\d{8}$',
'El número ingresado es incorrecto', 'Número incorrecto')
])
email = models.EmailField(blank=True, verbose_name='e-mail')
domicilio = models.CharField(max_length=50)
provincia = models.ForeignKey(Provincia, on_delete=models.PROTECT)
localidad = ChainedForeignKey(Localidad,
chained_field="provincia",
chained_model_field="provincia",
show_all=False,
auto_choose=True,
sort=True,
on_delete=models.PROTECT)
contacto = models.CharField(blank=True, max_length=100)
activo = models.BooleanField(default=True)
class Meta:
verbose_name_plural = "Proveedores"
def __str__(self):
return self.razon
class GeneralWishlistItem(Model):
category = ForeignKey(WishlistItemCategory)
item = ChainedForeignKey(WishlistItem, chained_field="category",
chained_model_field="category", show_all=False, null=True, blank=True)
position = PositiveSmallIntegerField(
"Position", default=0, blank=True, null=True)
have_other = BooleanField(default=False)
other_item = CharField(max_length=100, null=True, blank=True)
notes = CharField(max_length=200, null=True, blank=True)
quantity = PositiveSmallIntegerField(default=1)
quantity_pledged = PositiveSmallIntegerField(default=0)
class Meta:
ordering = ('position', )
def __unicode__(self):
desc = ''
if self.category:
desc += self.category.category + ': '
if self.item:
desc += self.item.item_name + ' '
if self.other_item:
desc += self.other_item
desc += '(' + str(self.quantity) + ' requested)'
return desc
