class Collateral(BaseModel):
name = models.CharField(max_length=256)
thumbnail = models.URLField(null=True, blank=True)
category = models.ForeignKey('product.Category',
null=True,
blank=True,
on_delete=models.PROTECT)
url = models.URLField()
collateral_type = models.CharField(max_length=16,
choices=get_choices(
Constants.COLLATERALS_TYPE))
collateral_file_type = models.CharField(max_length=32,
choices=get_choices(
Constants.COLLATERALS_CHOICES))
promocode = models.ForeignKey('users.PromoCode', on_delete=models.PROTECT)
short_descripton = models.CharField(max_length=256, null=True, blank=True)
long_descripton = models.TextField(null=True, blank=True)
order = models.IntegerField(default=0)
def __str__(self):
return '%s | %s: %s' % (self.name, self.collateral_type,
self.collateral_file_type)
class Meta:
ordering = ('order', )
class Member(BaseModel):
application = models.ForeignKey('sales.Application',
on_delete=models.CASCADE)
relation = models.CharField(max_length=128,
choices=get_choices(
Constants.RELATION_CHOICES),
db_index=True)
first_name = models.CharField(max_length=128, blank=True)
last_name = models.CharField(max_length=128, blank=True)
dob = models.DateField(null=True)
gender = models.CharField(choices=get_choices(Constants.GENDER),
max_length=16,
null=True)
occupation = models.CharField(choices=get_choices(
Constants.OCCUPATION_CHOICES),
max_length=32,
null=True,
blank=True)
height = models.FloatField(default=0.0)
weight = models.FloatField(default=0.0)
ignore = models.BooleanField(default=None, db_index=True, null=True)
def save(self, *ar, **kw):
try:
self.__class__.objects.get(pk=self.id)
except self.__class__.DoesNotExist:
if self.relation not in [
'son', 'daughter'
] and self.__class__.objects.filter(
relation=self.relation,
application_id=self.application_id).exists():
raise IntegrityError('%s relation already exists.' %
self.relation)
super(Member, self).save(*ar, **kw)
def update_fields(self, **kw):
for field in kw.keys():
setattr(self, field, kw[field])
self.save()
def get_full_name(self):
name = '%s %s' % (self.first_name, self.last_name)
return name.strip()
@property
def age(self):
if self.dob:
return int((now().today().date() - self.dob).days / 365.2425)
@property
def height_foot(self):
return int(self.height / 30.48)
@property
def height_inches(self):
return round((self.height - self.height_foot * 30.48) / 2.54, 2)
def __str__(self):
return '%s | %s' % (self.relation.title(), self.application.__str__())
class Article(BaseModel):
heading = models.CharField(max_length=256)
tags = models.CharField(max_length=32,
choices=get_choices(
Constants.CATEGORIES_AVAILABLE))
url = models.URLField()
short_descripton = models.CharField(max_length=512)
image = models.ImageField(null=True)
class KYCDocument(BaseModel):
contact = models.ForeignKey(
'crm.Contact', on_delete=models.CASCADE, null=True, blank=True)
document_number = models.CharField(max_length=64)
document_type = models.CharField(
choices=get_choices(Constants.KYC_DOC_TYPES), max_length=16)
file = models.FileField(
upload_to=get_kyc_upload_path, null=True, blank=True)
class Playlist(BaseModel):
name = models.CharField(max_length=32)
url = models.URLField()
playlist_type = models.CharField(max_length=32,
choices=get_choices(
Constants.PLAYLIST_CHOICES))
def __str__(self):
return '%s | %s: %s' % (self.name, self.playlist_type, self.url)
class ApplicationRequestLog(BaseModel):
application = models.ForeignKey('sales.application',
on_delete=models.PROTECT)
request_type = models.CharField(max_length=32,
choices=get_choices(
Constants.REQUEST_CHOICES))
url = models.URLField(null=True, blank=True)
payload = JSONField(default=dict)
response = JSONField(default=dict)
class Meta:
ordering = ('-modified', )
class Question(BaseModel):
category = models.ForeignKey('product.Category', on_delete=models.CASCADE)
title = models.CharField(max_length=32)
question_type = models.CharField(max_length=10,
choices=get_choices(
constants.QUESTION_COICES),
default="single")
question = models.TextField()
order = models.IntegerField(default=0)
ignore = models.BooleanField(default=False)
class Meta:
ordering = ('order', )
def __str__(self):
return self.title
class KYCDocument(BaseModel):
account = models.ForeignKey('users.Account', on_delete=models.CASCADE)
document_type = models.CharField(
choices=get_choices(Constants.KYC_DOC_TYPES), max_length=16)
document_number = models.CharField(max_length=64, null=True, blank=True)
file = models.FileField(upload_to=get_kyc_upload_path)
ignore = models.BooleanField(default=False)
def save(self, *args, **kwargs):
previous = self.__class__.objects.filter(
document_type=self.document_type, account_id=self.id)
if previous.exists():
previous.update(ignore=True)
super(self.__class__, self).save(*args, **kwargs)
def __str__(self):
return self.document_type
class ProposerDocument(BaseModel):
contact = models.ForeignKey('crm.Contact', on_delete=models.CASCADE)
document_number = models.CharField(max_length=64, null=True, blank=True)
document_type = models.CharField(choices=get_choices(
Constants.KYC_DOC_TYPES),
max_length=16)
file = models.FileField(upload_to=get_proposer_upload_path,
null=True,
blank=True)
ignore = models.BooleanField(default=False)
def save(self, *args, **kwargs):
previous = self.__class__.objects.filter(
document_type=self.document_type, contact_id=self.contact_id)
if previous.exists():
previous.update(ignore=True)
super(self.__class__, self).save(*args, **kwargs)
class HelpFile(BaseModel):
title = models.CharField(max_length=62, null=True, blank=True)
product_variant = models.ForeignKey('product.ProductVariant',
on_delete=models.CASCADE)
file = models.FileField(upload_to=Constants.HELP_FILES_PATH)
file_type = models.CharField(choices=get_choices(
Constants.HELP_FILES_TYPE),
default="all",
max_length=32)
def __str__(self):
return '%s: %s %s' % (
self.file_type.title().replace(
'_', ' '), self.product_variant.company_category.company.name,
self.product_variant.company_category.category.name)
class Meta:
ordering = ('-created', )
class FeatureMaster(BaseModel):
category = models.ForeignKey('product.Category',
null=True,
blank=True,
on_delete=models.CASCADE)
name = models.CharField(max_length=127, default="")
order = models.IntegerField(default=1)
feature_type = models.CharField(max_length=32,
default='Others',
choices=get_choices(
Constants.FEATURE_TYPES))
short_description = models.CharField(max_length=128, null=True, blank=True)
long_description = models.TextField(null=True, blank=True)
def __str__(self):
return "%s - %s" % (self.name, self.category.name)
class Meta:
ordering = ('order', )
class Enterprise(BaseModel):
name = models.CharField(max_length=64)
enterprise_type = models.CharField(
choices=get_choices(Constants.USER_TYPE), max_length=16,
default=Constants.DEFAULT_USER_TYPE)
companies = models.ManyToManyField('product.Company', blank=True)
categories = models.ManyToManyField('product.Category', blank=True)
hexa_code = models.CharField(max_length=8, default='#005db1')
promocode = models.ForeignKey('users.PromoCode', on_delete=models.PROTECT)
logo = models.ImageField(
upload_to=Constants.ENTERPRISE_UPLOAD_PATH,
default=Constants.DEFAULT_LOGO)
commission = models.FloatField(default=0.0)
def save(self, *args, **kwargs):
try:
current = self.__class__.objects.get(pk=self.id)
if current.promocode != self.promocode:
self.update_enterprise_type()
except self.__class__.DoesNotExist:
if self.promocode.code == 'OCOVR-1-3':
self.enterprise_type = 'pos'
super(self.__class__, self).save(*args, **kwargs)
def __str__(self):
return self.name
def update_enterprise_type(self):
users = User.objects.filter(enterprise_id=self.id)
if not users.exists():
return
user = users.get()
if self.promocode.code == 'OCOVR-1-3':
self.enterprise_type = user.user_type = 'pos'
elif self.promocode.code == 'OCOVR-2-4':
self.enterprise_type = user.user_type = 'subscriber'
else:
self.enterprise_type = user.user_type = 'enterprise'
user.save()
class Nominee(BaseModel):
application = models.ForeignKey('sales.Application',
on_delete=models.CASCADE)
relation = models.CharField(max_length=128,
choices=get_choices(
Constants.RELATION_CHOICES),
db_index=True)
first_name = models.CharField(max_length=128)
last_name = models.CharField(max_length=128)
phone_no = models.CharField(max_length=10)
ignore = models.BooleanField(default=False)
def save(self, *ar, **kw):
if not self.__class__.objects.filter(pk=self.id):
existing_nominee = self.__class__.objects.filter(
application_id=self.application.id)
if existing_nominee.exists():
existing_nominee.update(ignore=True)
super(Nominee, self).save(*ar, **kw)
def get_full_name(self):
name = '%s %s' % (self.first_name, self.last_name)
return name.strip()
class Account(AbstractUser):
phone_no = models.CharField(max_length=10)
password = models.CharField(_('password'), max_length=128, null=True)
alternate_no = models.CharField(max_length=10, null=True, blank=True)
pan_no = models.CharField(max_length=10, null=True, blank=True)
aadhar_no = models.CharField(max_length=12, null=True, blank=True)
fcm_id = models.CharField(max_length=256, null=True)
dob = models.DateField(null=True, blank=True)
gender = models.CharField(
choices=get_choices(Constants.GENDER), max_length=8,
null=True, blank=True)
address = models.ForeignKey(
'users.Address', null=True, blank=True, on_delete=models.CASCADE)
def save(self, *args, **kwargs):
user = self.get_default_user()
if user:
cache.delete('USER_DETAIL:%s' % user.id)
super(self.__class__, self).save(*args, **kwargs)
def send_notification(self, **kwargs):
return getattr(self, 'send_%s' % kwargs['type'])(kwargs)
def send_sms(self, message):
from users.tasks import send_sms
send_sms.delay(self.phone_no, message)
def get_default_user(self):
users = self.user_set.filter(is_active=True)
if not users.exists():
return False
if users.filter(user_type='enterprise').exists():
return users.earliest('created')
if users.filter(user_type='pos').exists():
return users.earliest('created')
return users.earliest('created')
def upload_docs(self, validated_data, fields):
for field in fields:
name = validated_data[field].name.split('.')
file_name = '%s_%s_%s.%s' % (
self.id, name[0], now().date().isoformat(), name[1])
doc = KYCDocument.objects.create(
document_type=field, account_id=self.id)
doc.file.save(file_name, validated_data[field])
validated_data[field] = doc.file.url
return validated_data
@classmethod
def send_otp(cls, prefix, phone_no):
from users.tasks import send_sms
return send_sms(
phone_no,
Constants.OTP_MESSAGE % (
cls.generate_otp(prefix, phone_no), SMS_OTP_HASH))
@staticmethod
def generate_otp(prefix, phone_no):
import random
otp = cache.get(prefix)
if not otp:
otp = random.randint(1000, 9999)
cache.set(prefix, otp, Constants.OTP_TTL)
return otp
@staticmethod
def verify_otp(phone_no, otp):
return otp == cache.get('OTP:%s' % phone_no)
@classmethod
def get_account(cls, phone_no, first_name, last_name):
accounts = cls.objects.filter(phone_no=phone_no)
if accounts.exists():
raise IntegrityError(Constants.DUPLICATE_ACCOUNT)
# return accounts.get()
acc = cls.objects.create(username=cls.generate_username(
first_name, last_name))
acc.phone_no = phone_no
acc.save()
return acc
@classmethod
def generate_username(cls, first_name, last_name):
username = ('%s-%s' % (first_name, last_name)).lower()
accounts = cls.objects.filter(
first_name__icontains=first_name,
last_name__icontains=last_name)
if accounts.exists() and accounts.filter(username=username).exists():
username += '-' + str(accounts.count())
return username
@property
def age(self):
days = (now().date() - self.dob).days
return '%s years and %s months' % ((days % 365) / 30, days / 365)
@property
def profile_pic(self):
docs = KYCDocument.objects.filter(
document_type='photo', account_id=self.id)
if docs.exists():
return docs.last().file
return KYCDocument.objects.filter(
document_type='photo', account_id=1).first().file
def __str__(self):
return 'Account: %s - %s' % (
self.username, self.phone_no)
class Meta:
verbose_name = _('Account')
type=str,
default='../inputs/inference_terms.csv')
parser.add_argument('--n_workers', type=int, default=0)
parser.add_argument('--split', type=str, default='test')
parser.add_argument('--crop_params',
type=int,
nargs='+',
default=(0, 0, 672, 512))
# network
parser.add_argument('--checkpoint', type=str)
parser.add_argument('--model', type=str, default='encdec2')
parser.add_argument('--height', type=int, default=672)
parser.add_argument('--width', type=int, default=512)
parser.add_argument('--channels', type=int, default=1)
parser.add_argument('--teacher_forcing_ratio', type=float, default=0.)
choices = get_choices(['', 'xavier_normal_'])
parser.add_argument('--weight_init', type=str, choices=choices, default='')
# training
parser.add_argument('--batch_size', type=int, default=1)
# misc
parser.add_argument('--random_seed', type=int, default=42)
parser.add_argument('--device', type=str, default='cuda:0')
parser.add_argument('--dump', action='store_true', default=False)
parser.add_argument('--sample_submit',
type=str,
default='../inputs/sample_submit.csv')
args, _ = parser.parse_known_args()
_logdir = '../logs/201910161515/'
args.checkpoint = os.path.join(_logdir, 'bestMAE.pt')
class Contact(BaseModel):
user = models.ForeignKey(
'users.User', on_delete=models.CASCADE, null=True, blank=True)
address = models.ForeignKey(
'users.Address', null=True, blank=True, on_delete=models.CASCADE)
gender = models.CharField(
max_length=16, choices=get_choices(Constants.GENDER),
null=True, blank=True)
phone_no = models.CharField(max_length=40, null=True, blank=True)
first_name = models.CharField(max_length=32, blank=True)
middle_name = models.CharField(max_length=32, blank=True)
last_name = models.CharField(max_length=32, blank=True)
email = models.EmailField(max_length=64, null=True, blank=True)
dob = models.DateField(null=True, blank=True)
occupation = models.CharField(
choices=get_choices(Constants.OCCUPATION_CHOICES), null=True,
default=Constants.OCCUPATION_DEFAULT_CHOICE, blank=True, max_length=32)
marital_status = models.CharField(
choices=get_choices(
Constants.MARITAL_STATUS), max_length=32, null=True, blank=True)
annual_income = models.CharField(max_length=48, null=True, blank=True)
def save(self, *args, **kwargs):
self.first_name = self.first_name.lower()
self.last_name = self.last_name.lower()
super(self.__class__, self).save(*args, **kwargs)
def __str__(self):
full_name = self.get_full_name()
return '%s - %s' % ((
full_name if full_name else 'Parent'
), self.phone_no)
def update_fields(self, **kw):
for field in kw.keys():
setattr(self, field, kw[field])
self.save()
def get_full_name(self):
full_name = '%s %s %s' % (
self.first_name, self.middle_name, self.last_name)
return full_name.strip().title()
def upload_docs(self, validated_data, fields):
from sales.models import ProposerDocument
for field in fields:
name = validated_data[field].name.split('.')
file_name = '%s_%s_%s.%s' % (
self.id, name[0], now().date().isoformat(), name[1])
doc, created = ProposerDocument.objects.get_or_create(
document_type=field, contact_id=self.id, ignore=False)
doc.file.save(file_name, validated_data[field])
validated_data[field] = doc.file.url
return validated_data
@property
def calling_no(self):
if len(self.phone_no) == 10:
return '+91%s' % self.phone_no
if '+91' in self.phone_no and len(self.phone_no) == 13:
return self.phone_no
if '91' in self.phone_no[:2] and len(self.phone_no) > 10:
return '+%s' % self.phone_no
return self.phone_no
@property
def whatsapp_no(self):
if len(self.phone_no) == 10:
return '+91%s' % self.phone_no
if '+91' in self.phone_no and len(self.phone_no) == 13:
return self.phone_no
if '91' in self.phone_no[:2] and len(self.phone_no) > 10:
return '+' % self.phone_no
return self.phone_no
class Application(BaseModel):
app_client = models.ForeignKey('crm.Lead',
on_delete=models.PROTECT,
null=True,
blank=True)
reference_no = models.CharField(max_length=10, unique=True, db_index=True)
premium = models.FloatField(default=0.0)
suminsured = models.FloatField(default=0.0)
proposer = models.ForeignKey('crm.Contact',
null=True,
on_delete=models.PROTECT)
application_type = models.CharField(max_length=32,
choices=get_choices(
Constants.APPLICATION_TYPES))
quote = models.OneToOneField('sales.Quote', on_delete=models.CASCADE)
status = models.CharField(max_length=32,
choices=Constants.APPLICATION_STATUS,
default='fresh')
stage = models.CharField(max_length=32,
default='proposer_details',
choices=get_choices(Constants.APPLICATION_STAGES))
previous_policy = models.BooleanField(default=False)
name_of_insurer = models.CharField(blank=True, max_length=128)
proposer_verified = models.BooleanField(default=False)
payment_failed = models.BooleanField(null=True, blank=True)
payment_mode = models.CharField(max_length=64, default='offline')
aggregator_error = models.CharField(max_length=256, null=True, blank=True)
terms_and_conditions = models.BooleanField(null=True)
def save(self, *args, **kwargs):
try:
current = self.__class__.objects.get(pk=self.id)
if self.status != current.status:
self.handle_status_change(current)
if (current.payment_failed != self.payment_failed and
self.payment_failed) or self.status == 'completed': # noqa
self.send_slack_notification()
if self.status == 'payment_due' and self.aggregator_error != current.aggregator_error:
self.send_slack_notification()
except self.__class__.DoesNotExist:
self.generate_reference_no()
self.application_type = self.company_category.category.name.lower(
).replace(' ', '')
super(Application, self).save(*args, **kwargs)
def handle_status_change(self, current):
if self.status == 'submitted' and self.stage == 'completed':
self.create_client()
self.create_policy()
self.create_commission(current)
if current.status == 'fresh' and self.status == 'submitted':
self.send_slack_notification()
def send_slack_notification(self):
event = None
if self.quote.opportunity.lead.user.user_type == 'subscriber':
event = 'Application created and payment process done'
elif self.payment_mode == 'offline':
event = 'Application created and payment process done'
elif self.payment_failed:
event = Constants.PAYMENT_ERROR
elif self.aggregator_error:
event = Constants.BROKER_ERROR
else:
event = Constants.PAYMENT_SUCCESS
if event:
self.send_slack_request(event)
def aggregator_operation(self):
premium = self.quote.premium
if not premium.product_variant.online_process or not premium.online_process: # noqa
return False
self.status = 'payment_due'
from aggregator.wallnut.models import Application as Aggregator
if not hasattr(self, 'application'):
Aggregator.objects.create(reference_app_id=self.id,
insurance_type=self.application_type)
self.payment_mode = 'Aggregated payment mode'
self.save()
return self.payment_mode != 'offline'
def update_fields(self, **kw):
updated = False
for field in kw.keys():
setattr(self, field, kw[field])
if not updated:
updated = True
if updated:
self.save()
def generate_reference_no(self):
self.reference_no = genrate_random_string(10)
if self.__class__.objects.filter(
reference_no=self.reference_no).exists():
while self.__class__.objects.filter(
reference_no=self.reference_no).exists():
self.reference_no = genrate_random_string(10)
def add_default_members(self):
category_opportunity = self.quote.opportunity.category_opportunity
today = now()
members = list()
def get_member_instance(gender, relation, dob=None):
instance = Member(application_id=self.id,
dob=dob,
relation=relation,
gender=gender)
if relation == 'self':
responses = Response.objects.filter(
question__category_id=self.company_category.category.id,
opportunity_id=category_opportunity.opportunity_id)
occupation_res = responses.filter(question__title='Occupation')
if occupation_res.exists():
instance.occupation = responses.latest(
'created').answer.answer.replace(' ',
'_').lower() # noqa
return instance
for member, age in category_opportunity.family.items():
member = member.split('_')[0]
gender = category_opportunity.gender if member == 'self' else 'male' # noqa
if member == 'spouse':
gender = 'male' if category_opportunity.gender == 'female' else 'female' # noqa
elif member == 'mother':
gender = 'female'
elif member in ['son', 'daughter']:
while age > 0:
members.append(
get_member_instance(
('male' if member == 'son' else 'female'), member))
age -= 1
continue
instance = get_member_instance(
gender, member,
'%s-%s-%s' % (today.year - int(age), today.month, today.day))
members.append(instance)
Member.objects.bulk_create(members)
def verify_proposer(self, otp):
from django.core.cache import cache
response = otp == cache.get('APP-%s:' % self.reference_no)
cache.delete('APP-%s:' % self.reference_no)
return response
def send_propser_otp(self):
from users.models import Account
Account.send_otp('APP-%s:' % self.reference_no, self.proposer.phone_no)
def create_policy(self):
return Policy.objects.get_or_create(application_id=self.id)
def invalidate_cache(self):
from django.core.cache import cache
cache.delete('USER_CART:%s' % self.quote.opportunity.lead.user_id)
cache.delete('USER_CONTACTS:%s' % self.quote.opportunity.lead.user_id)
cache.delete('USER_EARNINGS:%s' % self.quote.opportunity.lead.user_id)
def create_client(self, save=False):
lead = self.quote.opportunity.lead
if not lead.is_client:
lead.is_client = True
lead.save()
self.app_client_id = lead.id
def create_commission(self, current):
from earnings.models import Commission
cc = self.quote.premium.product_variant.company_category
amount = self.quote.premium.commission + cc.company.commission + cc.category.commission + self.quote.opportunity.lead.user.enterprise.commission # noqa
if not hasattr(self, 'commission'):
commission = Commission(application_id=self.id,
amount=self.premium * amount)
if current.payment_failed != self.payment_failed and self.payment_failed is False: # noqa
commission.status = 'application_submitted'
commission.save()
commission.updated = True
commission.save()
commission.earning.user.account.send_sms(
commission.earning.get_earning_message(self))
def send_slack_request(self, event, mode_type='success'):
import requests
client = self.quote.opportunity.lead
endpoint = 'https://hooks.slack.com/services/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' # noqa
link = '%s://admin.%s/sales/application/%s/change/' % (
'http' if ENV == 'localhost:8000' else 'https', ENV, self.id)
text = event
mode = self.payment_mode
if self.aggregator_error:
text += '\nError: %s' % (self.aggregator_error)
mode = 'Broker Error'
mode_type = 'error'
data = dict(attachments=[
dict(fallback='Required plain-text summary of the attachment.',
color={
'success': '#36a64f',
'warning': '#ff9966',
'error': '#cc3300'
}[mode_type],
pretext=event,
author_name=mode,
title='Open Application',
title_link=link,
text=text,
fields=[
dict(type='mrkdwn',
value="*Application id:*\n%s" % self.reference_no),
dict(type='mrkdwn',
value="*Advisor Name:*\n%s" %
client.user.get_full_name()),
dict(type='mrkdwn',
value="*Advisor phone:*\n%s" %
client.user.account.phone_no)
],
thumb_url='https://onecover.in/favicon.png',
footer='Post application flow',
footer_icon='https://onecover.in/favicon.png',
ts=now().timestamp())
])
return requests.post(endpoint, json=data)
@property
def adults(self):
return self.active_members.filter(dob__year__lte=(now().year -
18)).count()
@property
def childrens(self):
return self.active_members.count() - self.adults
@cached_property
def active_members(self):
return self.member_set.filter(ignore=False)
@cached_property
def inactive_members(self):
return self.member_set.exclude(ignore=False)
@cached_property
def company_category(self):
return self.quote.premium.product_variant.company_category
@cached_property
def people_listed(self):
return self.active_members.count()
@cached_property
def client(self):
return self.app_client
def __str__(self):
return '%s - %s - %s' % (self.reference_no, self.application_type,
self.company_category.company.name)
class Meta:
ordering = ('-created', )
class User(BaseModel):
account = models.ForeignKey('users.Account', on_delete=models.CASCADE)
user_type = models.CharField(
choices=get_choices(Constants.USER_TYPE), max_length=16,
default=Constants.DEFAULT_USER_TYPE)
campaign = models.ForeignKey(
'users.Campaign', null=True, blank=True, on_delete=models.CASCADE)
rating = models.IntegerField(default=5)
enterprise = models.ForeignKey(
'users.Enterprise', on_delete=models.PROTECT)
flag = JSONField(default=Constants.USER_FLAG)
is_active = models.BooleanField(default=False)
manager_id = models.CharField(max_length=48, null=True, blank=True)
def save(self, *args, **kwargs):
cache.delete('USER_DETAIL:%s' % self.id)
super(self.__class__, self).save(*args, **kwargs)
class Meta:
unique_together = ('user_type', 'account')
def __str__(self):
return self.account.get_full_name()
def get_authorization_key(self):
return jwt.encode(
{'user_id': str(self.id)},
JWT_SECRET, algorithm='HS256')
def get_full_name(self):
return self.account.get_full_name()
@classmethod
def get_authenticated_user(cls, token):
try:
payload = jwt.decode(token, JWT_SECRET)
return cls.objects.get(id=payload.get('user_id'))
except Exception:
pass
return None
def get_accounts(self):
return self.bankaccount_set.filter(is_active=True)
def generate_referral(self, referral_reference=None):
import random
code = ('%s%s' % (
self.account.first_name.lower()[:3], self.account.phone_no[-5:])
).upper()
if Referral.objects.filter(code=code).exists():
while Referral.objects.filter(code=code).exists():
code = ('%s%s' % (
self.account.first_name.lower()[:3],
random.randint(11111, 99999))).upper()
return Referral.objects.create(
code=code, reference_code=referral_reference,
user_id=self.id)
def get_categories(self):
categories = list()
from product.models import Category
for category in Category.objects.only(
'name', 'id', 'hexa_code', 'logo', 'is_active'):
is_active = False
categorys = self.enterprise.categories.filter(id=category.id)
if categorys.exists():
is_active = categorys.get().is_active
categories.append(dict(
id=category.id, hexa_code=category.hexa_code,
name=category.name.split(' ')[0], is_active=is_active,
logo=(
Constants.DEBUG_HOST if DEBUG else '') + category.logo.url
))
categories = sorted(
categories, key=lambda category: Constants.CATEGORY_ORDER.get(
category['name'], 1))
return categories
def get_companies(self):
return self.enterprise.companies.filter(is_active=True)
def get_applications(self, status=None):
from sales.models import Application
query = dict(quote__opportunity__lead__user_id=self.id)
if status and isinstance(status, list):
query['status__in'] = status
elif status:
query['status'] = status
return Application.objects.filter(**query)
def get_policies(self):
from sales.models import Policy
return Policy.objects.filter(
application__quote__opportunity__lead__user_id=self.id)
def get_earnings(self, earning_type=None):
from earnings.models import Earning
return Earning.get_user_earnings(self.id, earning_type)
def get_rules(self):
rules = dict.fromkeys(Constants.PROMO_RULES_KEYS, False)
rules['button_text'] = dict(
recommendation='View plan details', product_detail='Save Plan')
promo_code = self.enterprise.promocode.code.split('-')[1:]
for rule_code in promo_code:
if not rule_code.isdigit():
rule_code = 1
rules.update(Constants.PROMO_RULES[int(rule_code)])
if self.enterprise.enterprise_type != 'subscriber':
rules['kyc_allowed'] = True
rules['button_text']['recommendation'] = 'Buy Now'
rules['button_text']['product_detail'] = 'Buy Now'
return rules
def get_collaterals(self):
from content.models import Collateral
return Collateral.objects.filter(
promocode_id=self.enterprise.promocode_id)
@staticmethod
def validate_referral_code(code):
return Referral.objects.filter(code=code).exists()
@staticmethod
def validate_promo_code(code):
return PromoCode.objects.filter(code=code).exists()
@staticmethod
def get_referral_details(code):
# To Dos: Remove this
referrals = Referral.objects.filter(code=code)
if not referrals.exists():
return {
'user_type': Constants.DEFAULT_USER_TYPE,
'enterprise_id': SubcriberEnterprise.objects.get(
name=Constants.DEFAULT_ENTERPRISE).id
}
referral = referrals.get()
from earnings.models import Earning
Earning.objects.create(
user_id=referral.user.id, earning_type='referral', amount=100)
return dict(
enterprise_id=(
referral.enterprise or SubcriberEnterprise.objects.get(
name=Constants.DEFAULT_ENTERPRISE)).id)
@staticmethod
def get_promo_code_details(code, name):
promo_code = PromoCode.objects.get(code=code)
enterprises = Enterprise.objects.filter(
promocode=promo_code, enterprise_type='enterprise')
if enterprises.exists():
return dict(
user_type='enterprise', enterprise_id=enterprises.get().id)
enterprise = Enterprise.objects.create(name=name, promocode=promo_code)
from product.models import Category, Company
for category_id in Category.objects.values_list('id', flat=True):
enterprise.categories.add(category_id)
for company_id in Company.objects.values_list('id', flat=True):
enterprise.companies.add(company_id)
enterprise.save()
return dict(
user_type=enterprise.enterprise_type,
enterprise_id=enterprise.id)
@property
def account_no(self):
return self.bankaccount_set.get(default=True).account_no
@property
def ifsc(self):
return self.bankaccount_set.get(default=True).branch.ifsc
@property
def bank_name(self):
return self.bankaccount_set.get(default=True).branch.bank.name
