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