def postProductPurchase(ObjectList, Credential):
        feed_remark = FeedLogWithRemark(len(ObjectList.ProductPurchaseData),
                                        feed_type='Purchase Feed',
                                        action='Received', status=True)
        product_purchase_list = []
        for product in ObjectList.ProductPurchaseData:
            try:
                product_purchase_list.append({
                    'vin': product.CHASSIS,
                    'sap_customer_id': product.CUSTOMER_ID,
                    'customer_phone_number': utils.mobile_format(product.CUST_MOBILE),
                    'customer_name': product.CUSTOMER_NAME,
                    'city': product.CITY,
                    'state': product.STATE,
                    'pin_no': product.PIN_NO,
                    'product_purchase_date': product.VEH_SL_DT,
                    'engine': product.ENGINE,
                    'veh_reg_no': product.VEH_REG_NO
                })
            except Exception as ex:
                ex = "ProductPurchaseService: {0}  Error on Validating {1}".format(product, ex)
                feed_remark.fail_remarks(ex)
                logger.error(ex)

        feed_remark = save_to_db(
            feed_type='purchase', data_source=product_purchase_list,
                                                 feed_remark=feed_remark)
        feed_remark.save_to_feed_log()
        return get_response(feed_remark)
예제 #2
0
def save_sa_registration(request, groups):
    data = request.POST
    existing_sa = False
    data_source = []
    phone_number = utils.mobile_format(str(data['phone-number']))
    if data['sa-id']:
        service_advisor_id = data['sa-id']
        existing_sa = True
    else:
        service_advisor_id = TEMP_SA_ID_PREFIX + str(random.randint(10**5, 10**6))
    data_source.append(utils.create_sa_feed_data(data, request.user.username, service_advisor_id))
    logger.info('[Temporary_sa_registration]:: Initiating dealer-sa feed for ID' + service_advisor_id)
    if Roles.ASCS in groups:
        feed_type='asc_sa'
    else:
        feed_type='dealer'
    feed_remark = FeedLogWithRemark(len(data_source),
                                                feed_type='Dealer Feed',
                                                action='Received', status=True)
    sap_obj = SAPFeed()
    feed_response = sap_obj.import_to_db(feed_type=feed_type,
                        data_source=data_source, feed_remark=feed_remark)
    if feed_response.failed_feeds > 0:
        failure_msg = list(feed_response.remarks.elements())[0]
        logger.info('[Temporary_sa_registration]:: dealer-sa feed fialed ' + failure_msg)
        return json.dumps({"message": failure_msg})
    logger.info('[Temporary_sa_registration]:: dealer-sa feed completed')
    if existing_sa:
        return json.dumps({'message': SA_UPDATE_SUCCESS})
    return json.dumps({'message': SA_REGISTER_SUCCESS})
    def postDistributor(ObjectList, Credential):
        distributor_list = []
        feed_remark = FeedLogWithRemark(
            len(ObjectList.DistributorData), feed_type="Distributor Feed", action="Received", status=True
        )
        for distributor in ObjectList.DistributorData:
            try:
                distributor_list.append(
                    {
                        "id": distributor.DISTRIBUTOR_ID.upper(),
                        "name": distributor.NAME.upper(),
                        "email": distributor.EMAIL,
                        "mobile": utils.mobile_format(distributor.PHONE_NUMBER),
                        "city": distributor.CITY.upper(),
                        "asm_id": distributor.ASM_ID,
                    }
                )
            except Exception as ex:
                ex = "DistributorService: {0}  Error on Validating {1}".format(distributor, ex)
                feed_remark.fail_remarks(ex)
                logger.error(ex)
        feed_remark = save_to_db(feed_type="distributor", data_source=distributor_list, feed_remark=feed_remark)

        feed_remark.save_to_feed_log()
        return get_response(feed_remark)
    def postDealer(ObjectList, Credential):
        dealer_list = []
        feed_remark = FeedLogWithRemark(len(ObjectList.DealerData),
                                        feed_type='Dealer Feed',
                                        action='Received', status=True)
        for dealer in ObjectList.DealerData:
            try:
                dealer_list.append({
                    'id': dealer.KUNNR,
                    'address': dealer.ADDRESS,
                    'service_advisor_id': dealer.SER_ADV_ID,
                    'name': dealer.SER_ADV_NAME,
                    'phone_number': utils.mobile_format(dealer.SER_ADV_MOBILE),
                    'status': dealer.ACTIVE_FLAG,
                    'cdms_flag':dealer.CDMS_FLAG
                })
            except Exception as ex:
                ex = "DealerService: {0}  Error on Validating {1}".format(dealer, ex)
                feed_remark.fail_remarks(ex)
                logger.error(ex)
        feed_remark = save_to_db(feed_type='dealer', data_source=dealer_list,
                              feed_remark=feed_remark)

        feed_remark.save_to_feed_log()
        return get_response(feed_remark)
    def postNSM(ObjectList, Credential):
        nsm_list = []
        feed_remark = FeedLogWithRemark(len(ObjectList.NSMData), feed_type="NSM Feed", action="Received", status=True)
        for nsm in ObjectList.NSMData:
            try:
                nsm_list.append(
                    {
                        "name": nsm.NAME,
                        "email": nsm.EMAIL,
                        "phone_number": utils.mobile_format(nsm.PHONE_NUMBER),
                        "territory": nsm.TERRITORY,
                    }
                )
            except Exception as ex:
                ex = "NSMService: {0}  Error on Validating {1}".format(nsm, ex)
                feed_remark.fail_remarks(ex)
                logger.error(ex)
        feed_remark = save_to_db(feed_type="nsm", data_source=nsm_list, feed_remark=feed_remark)

        feed_remark.save_to_feed_log()
        return get_response(feed_remark)
 def postASC(ObjectList, Credential):
     asc_list = []
     feed_remark = FeedLogWithRemark(len(ObjectList.ASCData),
                                     feed_type='ASC Feed',
                                     action='Received', status=True)
     for asc_element in ObjectList.ASCData:
         try:
             asc_list.append({
                 'asc_id': asc_element.ASC_ID,
                 'name': asc_element.ASC_NAME,
                 'phone_number': utils.mobile_format(asc_element.ASC_MOBILE),
                 'address': asc_element.ASC_ADDRESS,
                 'email': asc_element.ASC_EMAIL,
                 'dealer_id': asc_element.KUNNAR
             })
         except Exception as ex:
             ex = "ASCService: {0}  Error on Validating {1}".format(asc_element, ex)
             feed_remark.fail_remarks(ex)
             logger.error(ex)
     feed_remark = save_to_db(feed_type='ASC', data_source=asc_list,
                           feed_remark=feed_remark)
     feed_remark.save_to_feed_log()
     return get_response(feed_remark)    
예제 #7
0
 def save_model(self, request, obj, form, change):
     obj.phone_number = utils.mobile_format(obj.phone_number)
     super(ASMAdmin, self).save_model(request, obj, form, change)
    def upload_mech_data(self):
        """Upload data of the mechanic"""
        print "Started uploading mech data..."
        file_list = ["MECHANIC_DATA.csv"]
        mech_list = []
        retailer = get_model("Retailer", APP)
        dist = get_model("Distributor", APP)
        user_profile = get_model("UserProfile", APP)
        mech = get_model("Member", APP)
        State = get_model("State", APP)
        for i in range(0, 1):
            with open(settings.PROJECT_DIR + "/upload_data/" + file_list[i], "r") as csvfile:
                spamreader = csv.reader(csvfile, delimiter=",")
                next(spamreader)
                for row_list in spamreader:
                    temp = {}
                    temp["form_no"] = self.empty_to_none(row_list[0].strip())
                    temp["first_name"] = row_list[1].strip()

                    temp["last_name"] = row_list[3].strip()
                    dob = row_list[4].strip()
                    if dob:
                        temp["dob"] = datetime.datetime.strptime(dob, "%d/%m/%Y")
                    else:
                        temp["dob"] = None
                    temp["shop_name"] = row_list[5].strip()
                    temp["shop_no"] = row_list[6].strip()
                    temp["shop_address"] = row_list[7].strip()
                    temp["locality"] = row_list[8].strip()
                    temp["tehsil"] = row_list[9].strip()

                    temp["district"] = (row_list[11].strip()).upper()
                    temp["state"] = row_list[12].strip()
                    temp["pincode"] = row_list[13].strip()
                    temp["dist_id"] = row_list[14].strip()
                    temp["wall_len"] = self.empty_to_none(row_list[16].strip())
                    temp["wall_width"] = self.empty_to_none(row_list[17].strip())
                    temp["mobile"] = row_list[18].strip()
                    temp["two_stroke"] = self.empty_to_none(row_list[19].strip())
                    temp["four_stroke"] = self.empty_to_none(row_list[20].strip())
                    temp["cng_lpg"] = self.empty_to_none(row_list[21].strip())
                    temp["diesel"] = self.empty_to_none(row_list[22].strip())
                    temp["spare_month"] = self.empty_to_none(row_list[23].strip())
                    temp["genuine"] = self.empty_to_none(row_list[24].strip())
                    temp["ret_name"] = row_list[26].strip()
                    temp["ret_town"] = row_list[27].strip()

                    reg = row_list[29].strip()
                    if reg:
                        temp["reg_date"] = datetime.datetime.strptime(reg, "%d/%m/%Y")
                    else:
                        temp["reg_date"] = None

                    temp["complete"] = row_list[31].strip()
                    temp["mech_id"] = row_list[32].strip()
                    mech_list.append(temp)
        for mechanic in mech_list:
            mobile = mobile_format(mechanic["mobile"])
            mech_object = mech.objects.filter(phone_number=mobile).using(APP)
            if not mech_object:
                if not mechanic["mech_id"]:
                    mech_id = generate_temp_id("TME")
                else:
                    mech_id = mechanic["mech_id"]
                if mechanic["dist_id"]:
                    dist_object = dist.objects.using(APP).get(distributor_id=mechanic["dist_id"])
                else:
                    dist_object = None

                ret_obj = retailer.objects.filter(retailer_name=mechanic["ret_name"]).using(APP)
                if not ret_obj:
                    ret_obj = retailer(retailer_name=mechanic["ret_name"], retailer_town=mechanic["ret_town"])
                    ret_obj.save(using=APP)
                else:
                    ret_obj = ret_obj[0]
                state = State.objects.using(APP).get(state_name=mechanic["state"])
                mech_object = mech(
                    registered_by_distributor=dist_object,
                    preferred_retailer=ret_obj,
                    mechanic_id=mech_id,
                    first_name=mechanic["first_name"],
                    last_name=mechanic["last_name"],
                    date_of_birth=mechanic["dob"],
                    phone_number=mobile,
                    form_number=mechanic["form_no"],
                    registered_date=mechanic["reg_date"],
                    shop_number=mechanic["shop_no"],
                    shop_name=mechanic["shop_name"],
                    shop_address=mechanic["shop_address"],
                    locality=mechanic["locality"],
                    tehsil=mechanic["tehsil"],
                    district=mechanic["district"],
                    state=state,
                    pincode=mechanic["pincode"],
                    shop_wall_length=mechanic["wall_len"],
                    shop_wall_width=mechanic["wall_width"],
                    serviced_2S=mechanic["two_stroke"],
                    serviced_4S=mechanic["four_stroke"],
                    serviced_CNG_LPG=mechanic["cng_lpg"],
                    serviced_diesel=mechanic["diesel"],
                    spare_per_month=mechanic["spare_month"],
                    genuine_parts_used=mechanic["genuine"],
                    form_status=mechanic["complete"],
                )
                mech_object.save(using=APP)
 def redeem_point(self, sms_dict, phone_number):
     '''redeem points with given upc for Member'''
     product_codes = sms_dict['product_id'].upper().split()
     try:
         
         retailer = get_model('Retailer').objects.using(settings.BRAND).filter(mobile=utils.mobile_format(phone_number))
         if retailer:
             message = self.redeem_point_retailer(product_codes, phone_number, sms_dict,retailer)
             return {'status': True, 'message': message}
         
         mechanic = get_model('Member').objects.using(settings.BRAND).filter(phone_number=utils.mobile_format(phone_number))
         if not mechanic:
             message=get_template('UNREGISTERED_USER')
             raise ValueError('Unregistered user')
         elif mechanic and  mechanic[0].form_status=='Incomplete':
             message=get_template('INCOMPLETE_FORM')
             raise ValueError('Incomplete user details')
         elif mechanic and (mechanic[0].mechanic_id!=sms_dict['member_id'] and mechanic[0].permanent_id!=sms_dict['member_id']):
             message=get_template('INVALID_MEMBER_ID').format(mechanic_name=mechanic[0].first_name)
             raise ValueError('Invalid user-ID')
         products=get_model('ProductCatalog').objects.using(settings.BRAND).filter(product_id__in=product_codes)
         redeem_points=0
         if len(products)==len(product_codes):
             for product in products:
                 redeem_points=redeem_points+product.points
             left_points=mechanic[0].total_points-redeem_points
             if left_points>=0:
                 total_points=self.update_points(mechanic[0],
                                         redeem=redeem_points)
                 transaction_ids = self.register_redemption_request(mechanic,
                                                         products)
                 message=get_template('SEND_REDEEM_POINT').format(
                                 mechanic_name=mechanic[0].first_name,
                                 transaction_id=transaction_ids,
                                 total_points=total_points)
             else:
                 if len(products)==1:
                     message=get_template('SEND_INSUFFICIENT_POINT_SINGLE').format(
                                     mechanic_name=mechanic[0].first_name,
                                     total_points=mechanic[0].total_points,
                                     shortage_points=abs(left_points))
                 else:
                     message=get_template('SEND_INSUFFICIENT_POINT_MULTIPLE').format(
                                     mechanic_name=mechanic[0].first_name,
                                     shortage_points=abs(left_points))
         else:
             message=get_template('INVALID_PRODUCT_ID')
     except Exception as ex:
         LOG.error('[redeem_point]:{0}:: {1}'.format(phone_number, ex))
     finally:
         phone_number = utils.get_phone_number_format(phone_number)
         sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
         self.queue_service(send_point, {'phone_number': phone_number,
               'message': message, "sms_client": settings.SMS_CLIENT})
     return {'status': True, 'message': message}
예제 #10
0
    def accumulate_point(self, sms_dict, phone_number):
        '''accumulate points with given upc'''
        unique_product_codes = set((sms_dict['upc'].upper()).split())
        valid_upc=[]
        valid_product_number=[]
        invalid_upcs_message=''
        try:
            if len(unique_product_codes)>constants.MAX_UPC_ALLOWED:
                message=get_template('MAX_ALLOWED_UPC').format(
                                        max_limit=constants.MAX_UPC_ALLOWED)
                raise ValueError('Maximum allowed upc exceeded')
            
            retailer = get_model('Retailer').objects.using(settings.BRAND).filter(mobile=utils.mobile_format(phone_number))
            if retailer:
                message = self.accumulate_point_retailer(retailer, phone_number, unique_product_codes)
                return  {'status': True, 'message': message}
                
            mechanic = get_model('Member').objects.using(settings.BRAND).filter(phone_number=utils.mobile_format(phone_number))
            if not mechanic:
                message=get_template('UNREGISTERED_USER')
                raise ValueError('Unregistered user')
            elif mechanic and  mechanic[0].form_status=='Incomplete':
                message=get_template('INCOMPLETE_FORM')
                raise ValueError('Incomplete user details')
            state_code= mechanic[0].state.state_code
            spares = get_model('SparePartUPC').objects.get_spare_parts(unique_product_codes)
            
            if not spares:
                message=get_template('SEND_UPC_IS_USED')
                raise ValueError('Requested UPC is already used.')
            
            added_points=0
            spare_upc_part_map={}
            total_points=mechanic[0].total_points
        
            if spares:
                for spare in spares:
                    valid_product_number.append(spare.part_number)
                    if not spare_upc_part_map.has_key(spare.part_number):
                        spare_upc_part_map[spare.part_number]=[]
                    spare_upc_part_map[spare.part_number].append(spare.unique_part_code.upper())
                spare_points = get_model('SparePartPoint').objects.get_part_number(valid_product_number, state_code)
                if spare_points:
                    accumulation_log=get_model('AccumulationRequest')(member=mechanic[0],
                                                            points=0,total_points=0)
                    accumulation_log.save(using=settings.BRAND)
                    
                    for spare_point in spare_points:
                        if spare_point.valid_from and spare_point.valid_till:
                            if self.check_date_validity(spare_point.valid_from,spare_point.valid_till):
                                added_points=added_points+(len(spare_upc_part_map[spare_point.part_number]) * spare_point.points)
                                valid_upc.extend(spare_upc_part_map[spare_point.part_number])
                        else: 
                            added_points=added_points+(len(spare_upc_part_map[spare_point.part_number]) * spare_point.points)
                            valid_upc.extend(spare_upc_part_map[spare_point.part_number])
                            
                    total_points=self.update_points(mechanic[0],
                                    accumulate=added_points)
                    valid_spares = get_model('SparePartUPC').objects.get_spare_parts(valid_upc)
                    for spare in valid_spares:
                        accumulation_log.upcs.add(spare)
                    accumulation_log.points=added_points
                    accumulation_log.total_points=total_points
                    accumulation_log.save(using=settings.BRAND)
                    valid_spares.using(settings.BRAND).update(is_used=True)
            
            invalid_upcs = list(set(unique_product_codes).difference(valid_upc))
            if invalid_upcs:
                invalid_upcs_message=' Invalid Entry... {0} does not exist in our records.'.format(
                                              (', '.join(invalid_upcs)))
                used_upcs = get_model('SparePartUPC').objects.get_spare_parts(invalid_upcs, is_used=True)
                if used_upcs:
                    accumulation_requests = get_model('AccumulationRequest').objects.using(settings.BRAND).filter(upcs__in=used_upcs).prefetch_related('upcs').select_related('upcs')
                    accumulation_dict = {}
                    try:
                        for accumulation_request in accumulation_requests:
                            for upcs in  accumulation_request.upcs.values():
                                accumulation_dict[upcs['unique_part_code']] = accumulation_request    
                        for used_upc in used_upcs:
                            discrepant_accumulation_log = get_model('DiscrepantAccumulation')(new_member=mechanic[0], upc = used_upc,
                                                                         accumulation_request=accumulation_dict[used_upc])
                            discrepant_accumulation_log.save(using=settings.BRAND)
                    except Exception as ex:
                        LOG.error('[accumulate_point]:{0}:: {1}'.format(phone_number, ex))
            if len(unique_product_codes)==1 and invalid_upcs:
                message=get_template('SEND_INVALID_UPC')
            else:
                message=get_template('SEND_ACCUMULATED_POINT').format(
                                mechanic_name=mechanic[0].first_name,
                                added_points=added_points,
                                total_points=total_points,
                                invalid_upcs=invalid_upcs_message)

        except Exception as ex:
            LOG.error('[accumulate_point]:{0}:: {1}'.format(phone_number, ex))
        finally:
            phone_number = utils.get_phone_number_format(phone_number)
            sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
            self.queue_service(send_point, {'phone_number': phone_number,
                    'message': message, "sms_client": settings.SMS_CLIENT})
        
        return {'status': True, 'message': message}
예제 #11
0
    def check_point_balance(self, sms_dict, phone_number):
        '''send balance point of the user'''
        try:
            mechanic = get_model('Member').objects.using(settings.BRAND).filter(phone_number=utils.mobile_format(phone_number))
            if not mechanic:
                message=get_template('UNREGISTERED_USER')
                raise ValueError('Unregistered user')
            elif mechanic and  mechanic[0].form_status=='Incomplete':
                message=get_template('INCOMPLETE_FORM')
                raise ValueError('Incomplete user details')

            total_points=mechanic[0].total_points
            today = datetime.now().strftime('%d/%m/%Y')
            message=get_template('SEND_BALANCE_POINT').format(
                            mechanic_name=mechanic[0].first_name,
                            total_points=total_points,
                            today=today)

        except Exception as ex:
            LOG.error('[check_point_balance]:{0}:: {1}'.format(
                                            phone_number, ex))
        finally:
            phone_number = utils.get_phone_number_format(phone_number)
            sms_log(settings.BRAND, receiver=phone_number, action=AUDIT_ACTION, message=message)
            self.queue_service(send_point, {'phone_number': phone_number,
                    'message': message, "sms_client": settings.SMS_CLIENT})
        return {'status': True, 'message': message}