def PhoneScraper(self, pPhone):
     tPhoneUrl = 'http://www.searchpeopledirectory.com/international-reverse-phone/'
     tPhoneUrl = tPhoneUrl + pPhone
     
     request_cookies = mechanize.CookieJar()
     request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
     request_opener.addheaders = [('Content-Type', 'application/x-www-form-urlencoded')]
     mechanize.install_opener(request_opener)
     tResponse = mechanize.urlopen(url = tPhoneUrl, timeout = 25.0)
     tContent = str(urllib.unquote(tResponse.read()))
     
     try:
         tCountryRegex = re.compile(">Country: <span id=\"extra\">(?P<country>.*?)</span")
         tCountryMatch = tCountryRegex.search(tContent)
         tCountry = tCountryMatch.groupdict()['country']
         
         if(tCountry == "USA"):
             tCountry = "United States"
     except: 
         tCountry = "Unknown"
         
     try:
         tStateRegex = re.compile(">State: <span id=\"extra\">(?P<state>.*?)</span")
         tStateMatch = tStateRegex.search(tContent)
         tState = tStateMatch.groupdict()['state']
     except: 
         tState = "Unknown"
         
     tResult = {}
     tResult['country'] = tCountry
     tResult['state'] = tState
     
     return tResult
 def PostContext(self):
     tResponse = {}
     tResponse['tResponseText'] = ""
     tPaypal = VipCancelPaypalAjax()
     tResultDictionary = {}
     tPaypalPayload = {}        
     tPayload = {}
     
     pSubscriptionKey = str(self.request.get('key'))
     tSubscription = VipSubscription()
     try:
         tSubscription = VipSubscription.get(pSubscriptionKey)
     except:
         tResponse['tResponseText'] = "Not Found"
         return tResponse
     #logging.debug("Subscription found with owner: " + tSubscription.subscriptionOwner)
     
     if (tSubscription):            
                 
         tPaypalPayload['METHOD'] = "ManageRecurringPaymentsProfileStatus"
         tPaypalPayload['PROFILEID'] = str(tSubscription.subscriptionId) 
         tPaypalPayload['ACTION'] = 'Cancel'
         
         tPayloadEncoded = tPaypal.GeneratePayload(tPaypalPayload)                
         
         request_cookies = mechanize.CookieJar()
         request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
         request_opener.addheaders = [('Content-Type', 'application/x-www-form-urlencoded')]
         mechanize.install_opener(request_opener)
             
         tResponse = mechanize.urlopen(url = tUrl, timeout = 25.0, data = tPayloadEncoded)
         tResult = str(urllib.unquote(tResponse.read()))
         
         #logging.debug("Mechanize Package")
         #logging.debug("Url: " + tUrl)
         #logging.debug("Data: " + str(tPaypalPayload))
         #logging.debug("Response: " + tResult)
         
         tResultSplit = tResult.split('&')
         
         for tPair in tResultSplit:
             tSplitPair = tPair.split("=")
             tResultDictionary[tSplitPair[0]] = tSplitPair[1]
         
         tResponse['tResponseText'] = "Cancelled"
         
         tSubscription.subscriptionIsActive = False
         tSubscription.subscriptionEnd = datetime.datetime.now()        
         tSubscription.subscriptionNeedsUpgrade = False
         tSubscription.subscriptionNeedsCancel = False
         tSubscription.put()    
         
         tSubscriber = VipSubscriber()
         tSubscriber.subscriberActiveSubscription = ""
         tSubscriber.subscriberHasActiveSubscription = False
         tSubscriber.put()
         
     return tResponse
示例#3
0
    def post(self):
        tUrl = "https://api-3t.paypal.com/nvp"
        tPaypalPayload = {}
        tPaypal = PaypalRefund()
        tAgent = Agent()
        tOrder = Order()
        tUser = users.get_current_user()

        tTransId = str(self.request.get('orderid'))

        tAgentEmail = str(tUser.email())
        tAgent = Agent().GetAgentByEmail(tAgentEmail)
        tRefundAgent = tAgentEmail

        tOrderQuery = Order.all()
        tOrderQuery.filter("orderTransactionId", tTransId)
        #logging.debug("Transaction id: " + tTransId)
        tOrder = tOrderQuery.get()

        if (tOrder.orderDeliver != 'True'):

            tPaypalPayload['METHOD'] = "RefundTransaction"
            tPaypalPayload['TRANSACTIONID'] = tTransId

            tPayloadEncoded = tPaypal.GeneratePayload(tPaypalPayload)

            request_cookies = mechanize.CookieJar()
            request_opener = mechanize.build_opener(
                mechanize.HTTPCookieProcessor(request_cookies))
            request_opener.addheaders = [('Content-Type',
                                          'application/x-www-form-urlencoded')]
            mechanize.install_opener(request_opener)

            tResponse = mechanize.urlopen(url=tUrl,
                                          timeout=25.0,
                                          data=tPayloadEncoded)
            #logging.debug("Mechanize Package")
            #logging.debug("Url: " + tUrl)
            #logging.debug("Data: " + str(tPaypalPayload))

            tResult = tResponse.read()
            #logging.debug(tResult)

            tOrder.orderIsRefunded = "True"
            tOrder.orderRefundAgent = tRefundAgent
            tOrder.orderLocked = "True"
            tOrder.orderRefundId = ""
            tOrder.put()

            self.response.out.write("Order Locked and Refunded")
示例#4
0
    def post(self):
        tUrl = "https://api-3t.paypal.com/nvp"
        tPaypalPayload = {}
        tPaypal = PaypalRefund()
        tAgent = Agent()
        tOrder = Order()
        tUser = users.get_current_user()

        tTransId = str(self.request.get("orderid"))

        tAgentEmail = str(tUser.email())
        tAgent = Agent().GetAgentByEmail(tAgentEmail)
        tRefundAgent = tAgentEmail

        tOrderQuery = Order.all()
        tOrderQuery.filter("orderTransactionId", tTransId)
        # logging.debug("Transaction id: " + tTransId)
        tOrder = tOrderQuery.get()

        if tOrder.orderDeliver != "True":

            tPaypalPayload["METHOD"] = "RefundTransaction"
            tPaypalPayload["TRANSACTIONID"] = tTransId

            tPayloadEncoded = tPaypal.GeneratePayload(tPaypalPayload)

            request_cookies = mechanize.CookieJar()
            request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
            request_opener.addheaders = [("Content-Type", "application/x-www-form-urlencoded")]
            mechanize.install_opener(request_opener)

            tResponse = mechanize.urlopen(url=tUrl, timeout=25.0, data=tPayloadEncoded)
            # logging.debug("Mechanize Package")
            # logging.debug("Url: " + tUrl)
            # logging.debug("Data: " + str(tPaypalPayload))

            tResult = tResponse.read()
            # logging.debug(tResult)

            tOrder.orderIsRefunded = "True"
            tOrder.orderRefundAgent = tRefundAgent
            tOrder.orderLocked = "True"
            tOrder.orderRefundId = ""
            tOrder.put()

            self.response.out.write("Order Locked and Refunded")
 def post(self):
     tUrl = "https://api-3t.paypal.com/nvp"
     tOperation = "GetTransactionDetails"
     tPaypal = PaypalRefund()
     tResultDictionary = {}
     tPaypalPayload = {}        
     tPayload = {}
     
     #logging.debug("Transaction id: " + str(self.request.get('transactionid')))
     #logging.debug("Gold amount: " + str(self.request.get('gold')))
     #logging.debug("Name: " + str(self.request.get('name')))
     #logging.debug("Email: " + str(self.request.get('email')))
     #logging.debug("Mobile" + str(self.request.get('mobile')))
     #logging.debug("RS Name: " + str(self.request.get('rsname')))
     #logging.debug("Combat: " + str(self.request.get('cblvl')))
     #logging.debug("Promocode: " + str(self.request.get('promotion')))
     #logging.debug("Ip: " + str(self.request.get('customerip')))
     
     tPaypalPayload['METHOD'] = tOperation
     tPaypalPayload['TRANSACTIONID'] = str(self.request.get('transactionid'))
     
     tPayloadEncoded = tPaypal.GeneratePayload(tPaypalPayload)
     
     request_cookies = mechanize.CookieJar()
     request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
     request_opener.addheaders = [('Content-Type', 'application/x-www-form-urlencoded')]
     mechanize.install_opener(request_opener)
         
     tResponse = mechanize.urlopen(url = tUrl, timeout = 25.0, data = tPayloadEncoded)
     tResult = str(urllib.unquote(tResponse.read()))
     
     #logging.debug("Mechanize Package")
     #logging.debug("Url: " + tUrl)
     #logging.debug("Data: " + str(tPaypalPayload))
     #logging.debug("Response: " + tResult)
     
     tResultSplit = tResult.split('&')
     
     for tPair in tResultSplit:
         tSplitPair = tPair.split("=")
         tResultDictionary[tSplitPair[0]] = tSplitPair[1]
示例#6
0
    def ProcessOrder(self, pArgumentDic):
        tOrderHandler = OrderHandler()
        tCustomerHandler = CustomerHandler()
        tCustomer = Customer()
        tPaypalOrder = PaypalOrder()
        tArgumentDic = pArgumentDic

        #Assign Values from POST from Paypal IPN
        tTransactionId = tArgumentDic['txn_id']
        tAlphaMatch = re.compile('[^A-Za-z0-9]+')
        tAlphaSpaceMatch = re.compile('[^A-Za-z0-9 ]+')

        #Short circuits the order process for special PA page
        if ('payer_email' in tArgumentDic.keys()):
            if (tArgumentDic['payer_email'] == '*****@*****.**'):
                tPaypalOrder.ProcessPlayerAuctions(tArgumentDic)
                return

        try:
            tGoldAmount = tArgumentDic['option_name7']
        except:
            tGoldAmount = ""

        try:
            tCustomerFirstName = tAlphaSpaceMatch.sub(
                '', tArgumentDic['first_name'])
        except:
            tCustomerFirstName = ""

        try:
            tCustomerLastName = tAlphaSpaceMatch.sub('',
                                                     tArgumentDic['last_name'])
        except:
            tCustomerLastName = ""

        try:
            tCustomerName = tAlphaSpaceMatch.sub('',
                                                 tArgumentDic['option_name1'])
        except:
            tCustomerName = ""

        try:
            tEmail = tArgumentDic['option_name2']
        except:
            tEmail = ""
        tPaypalEmail = str(tArgumentDic['payer_email']).lower()
        try:
            tMobilePhone = tArgumentDic['option_name3']
            tMobilePhone = re.sub(r'\D', '', tMobilePhone)
        except:
            tMobilePhone = ""
        try:
            tRsName = tArgumentDic['option_name4'].strip().lower()
            tRsName = tRsName.replace(' ', '_')
            tRsName = tRsName.replace('-', '_')
        except:
            tRsName = ""
        try:
            tCombatLevel = ""
        except:
            tCombatLevel = ""

        #try:
        #tReferCode = str(tArgumentDic['option_name5']).strip()
        #except:
        tReferCode = ""

        try:
            tPromotionCode = str(tArgumentDic['option_name5']).strip()
        except:
            tPromotionCode = ""

        tOrderIp = tArgumentDic['custom']
        tMembers = ""

        try:
            tOrderQuery = Order.all().filter('orderTransactionId',
                                             tTransactionId)
            tOrder = tOrderQuery.fetch(1)[0]
        except:
            tOrder = Order()

        if ('fake' in tArgumentDic.keys()):
            #logging.debug('Fake key hit')
            #logging.debug(str(tArgumentDic['fake']))
            if (tArgumentDic['fake'] == 'True'):
                tOrder.orderIsGenerated = True

        tOrder.orderFormName = tCustomerName
        tOrder.orderCombatLevel = tCombatLevel

        if (len(tGoldAmount) == 0):
            tUrl = "https://api-3t.paypal.com/nvp"
            #tOperation = "AddressVerify"
            tOperation = "GetTransactionDetails"
            #Get Paypal Information
            #tPaypal = PaypalTrigger()
            tResultDictionary = {}
            tPaypalPayload = {}
            tPayload = {}
            tPaypalPayload['METHOD'] = tOperation
            tPaypalPayload['TRANSACTIONID'] = tTransactionId

            tPayloadEncoded = tOrderHandler.GeneratePayload(tPaypalPayload)
            request_cookies = mechanize.CookieJar()
            request_opener = mechanize.build_opener(
                mechanize.HTTPCookieProcessor(request_cookies))
            request_opener.addheaders = [('Content-Type',
                                          'application/x-www-form-urlencoded')]
            mechanize.install_opener(request_opener)
            tResponse = mechanize.urlopen(url=tUrl,
                                          timeout=25.0,
                                          data=tPayloadEncoded)
            tResult = str(urllib.unquote(tResponse.read()))
            tResultSplit = tResult.split('&')

            for tPair in tResultSplit:
                tSplitPair = tPair.split("=")
                if (len(tSplitPair) == 1):
                    tSplitPair.append("")
                tResultDictionary[tSplitPair[0]] = tSplitPair[1]
                logging.debug(tSplitPair[0] + "    " + tSplitPair[1])
            tGoldAmountString = tResultDictionary['L_NAME0']
            logging.debug("Gold amount string %s".format(tGoldAmountString))
            try:
                tGoldRegex = re.compile("([0-9]*?[m|M]).T")
                tGoldMatch = tGoldRegex.findall(tGoldAmountString)
                #logging.debug("Backup gold amount parser hit, string " + tGoldAmountString + "   Match: " + tGoldMatch[0])
                tGoldAmount = tGoldMatch[0]
            except:
                tGoldRegex = re.compile("([0-9]*?[m|M]).T")
                tGoldMatch = tGoldRegex.findall(tGoldAmountString)
                try:
                    #logging.debug("Backup gold amount parser hit, string " + tGoldAmountString + "   Match: " + tGoldMatch[0])
                    tGoldAmount = tGoldMatch[0]
                except:
                    #logging.debug("No gold match")
                    tGoldAmount = ""

        tOrder.orderQuantity = NumberToGp.ConvertBetToInt(tGoldAmount)
        tOrder.orderSimpleGoldAmount = tGoldAmount
        tOrder.orderFormEmail = tEmail
        tOrder.orderAccountName = tRsName
        tOrder.orderMobileNumber = tMobilePhone
        tOrder.orderPromotionalCode = tPromotionCode.lower()
        tOrder.orderIp = tOrderIp
        if (tMembers == "yes"):
            tOrder.orderCustomerIsMember = True
        else:
            tOrder.orderCustomerIsMember = False

        #Paypal Info
        tOrder.orderTransactionId = tTransactionId

        tOrder.orderPaypalFirstName = tCustomerFirstName
        tOrder.orderPaypalLastName = tCustomerLastName

        tOrder.orderCost = float(tArgumentDic['payment_gross'])
        tOrder.orderCustomerPaypalId = tArgumentDic['payer_id']
        tOrder.orderPaypalEmail = str(tPaypalEmail).lower()

        tAssignedAgentNick = tPaypalOrder.GetAssignedAgent(tOrder)
        tOrder.orderAssignedAgent = tAssignedAgentNick
        #logging.debug("Order assigned to agent: " + str(tAssignedAgentNick))

        tOrder.orderReferralCode = tReferCode

        tOrder.orderDeliver = 'False'

        if (tOrder.orderVerificationCode == None
                or tOrder.orderVerificationCode == ''):
            tOrder.orderVerificationCode = re.sub(r'\W', '',
                                                  str(uuid.uuid4())).lower()

        tCurrentEocPrices = PriceContainer.GetCurrentPriceDic()
        tCurrent07Prices = PriceContainer.GetCurrentPriceDic07()

        tSkip07 = False
        if tOrder.orderSimpleGoldAmount in tCurrentEocPrices.keys():
            if str(tOrder.orderCost) == str(
                    tCurrentEocPrices[tOrder.orderSimpleGoldAmount]):
                tOrder.orderGoldType = 'eoc'
                tSkip07 = True

        if not tSkip07:
            if tOrder.orderSimpleGoldAmount in tCurrent07Prices.keys():
                if str(tOrder.orderCost) == str(
                        tCurrent07Prices[tOrder.orderSimpleGoldAmount]):
                    tOrder.orderGoldType = '07'

        tOrderKey = str(tOrder.put())

        #logging.debug("Order Saved: " + str(tOrderKey))

        taskqueue.add(url="/iplookup",
                      countdown=1,
                      params={
                          "ip": tOrderIp,
                          "transid": tTransactionId
                      })

        tUsedBonus = []
        tCustomerList = tCustomerHandler.GetCustomerByPpid(
            tOrder.orderCustomerPaypalId)
        if (len(tCustomerList) == 1):
            tCustomer = tCustomerList[0]
            tIpList = tCustomer.customerIpAddresses
            tIpList.append(tOrderIp)
            tCustomer.customerIpAddresses = tIpList

            tOrderList = tCustomer.customerOrders
            tOrderList.append(tOrderKey)
            tCustomer.customerOrders = tOrderList

            tCustomer.customerOrderCount = int(
                tCustomer.customerOrderCount) + 1
            #tUsedBonus = tCustomer.customerUsedBonus
            tUsedBonus = Order.GetCustomerPromoCodes(
                tCustomer.customerPaypalId)

            #tOrder.orderCustomer = str(tCustomer.key())
        elif (len(tCustomerList) == 0):
            tCustomer.customerEmail = str(tOrder.orderPaypalEmail).lower()
            tCustomer.customerName = tCustomerName
            tCustomer.customerFirstName = tOrder.orderPaypalFirstName
            tCustomer.customerLastName = tOrder.orderPaypalLastName
            tCustomer.customerIpAddresses = [tOrderIp]
            tCustomer.customerOrders = [tOrderKey]
            tCustomer.customerOrderCount = 1
            tCustomer.customerPhone = tMobilePhone
            tCustomer.customerEmailVerified = False
            tCustomer.customerPhoneVerified = False
            tCustomer.customerIdVerified = False
            tCustomer.customerPaypalId = tOrder.orderCustomerPaypalId
            tCustomer.customerIsGlobalBlacklisted = False
            tCustomer.customerIsPaBlacklisted = False

        tPromoCode = ""
        tPromoCode = tOrder.orderPromotionalCode
        #logging.debug("Order Promo Code: " + str(tOrder.orderPromotionalCode))
        tPromo = Promo()
        tPromoCode = tPromoCode.lower()
        try:
            logging.debug("Promo Code: " + str(tPromoCode))
            tPromo = Promo.GetPromoByCode(tPromoCode)
            logging.debug("Promo: " + str(tPromo))
            tGoldAmount = tOrder.orderQuantity
            logging.debug("Gold Amount: " + str(tGoldAmount))
            logging.debug("Promo is active: " + str(tPromo.promoIsActive))

            if ((tPromo.promoIsActive)
                    and (tPromo.promoUses <= tPromo.promoLimit)):
                if (tPromo.promoLimit != 0):
                    tPromo.promoUses = tPromo.promoUses + 1

                if ((tPromoCode in tUsedBonus) == True):
                    tPercentBonus = 0.0
                else:
                    tPercentBonus = tGoldAmount * tPromo.promoPercentage
                    #tUsedBonus.append(tPromoCode)

                tGoldAmount = tGoldAmount + tPercentBonus
                tGoldAmount = tGoldAmount + tPromo.promoGoldAmount
                tTotalBonusFloat = tPercentBonus + tPromo.promoGoldAmount
                logging.debug("Bonus float: " + str(tTotalBonusFloat))
                tOrder.orderBonusQuantity = int(tTotalBonusFloat)

                logging.debug("Total Bonus Float " + str(tTotalBonusFloat))
                logging.debug("Promo Gold Amount " +
                              str(tPromo.promoGoldAmount))
                logging.debug("Promo Percentage " + str(tPercentBonus))
        except:
            tOrder.orderBonusQuantity = 0

        #tCustomer.customerUsedBonus = tUsedBonus

        tCustomerKey = str(tCustomer.put())
        tOrder.orderCustomer = tCustomerKey
        tOrderKey = str(tOrder.put())

        if (tCustomerName == ""):
            tCustomerName = tCustomerFirstName + " " + tCustomerLastName

        if (tGoldAmount == None or len(str(tGoldAmount)) == 0):
            tGoldAmount = tGoldAmountString

        response = taskqueue.add(url="/emailnotify",
                                 countdown=1,
                                 params={
                                     "email": tPaypalEmail,
                                     "gold": tGoldAmount,
                                     "name": tCustomerName,
                                     'key': tOrderKey
                                 })
        logging.debug(str(response))
    def PostContext(self):
        tOrder = {}
        tContext = {}
        tPriceDictionary = PriceContainer.GetCurrentPriceDic()
        
        tType = str(self.request.get('type'))
        #logging.debug("Type: " + tType)
        
        tRandomAmount = ""
        tRandomPrice = ""
        tRandomAmount = random.choice(tPriceDictionary.keys())
        tRandomPrice = tPriceDictionary[tRandomAmount]
        tRandomNumberList = [str(random.randrange(0,9)) for i in range(0,9)]
        
        #valid for all types of orders
        tOrder['mc_currency'] = 'USD'
        tOrder['receiver_email'] = '*****@*****.**'
        tOrder['receiver_id'] = 'NSKCXUXQEMPBG'
        tOrder['residence_country'] = 'US'
        tOrder['address_city'] = 'Beverly Hills'
        tOrder['address_country'] = 'United States'
        tOrder['address_country_code'] = 'US'
        tOrder['address_name'] = 'Test Address'
        tOrder['address_state'] = 'California'
        tOrder['address_street'] = '9876 Wilshire Boulevard'
        tOrder['address_zip'] = '90210'
        tOrder['notify_version'] = '3.4'
        
        #logging.debug(str(tOrder))
        
        tAvailableEligibility = ["Ineligible","Partially Eligible - INR Only","Eligible"]
        tOrder['protection_eligibility'] = random.choice(tAvailableEligibility)
        
        tAvailableStatus = ["verified","unverified"]
        tOrder['payer_status'] = random.choice(tAvailableStatus)
        
        if(tType == "random" or tType == "me"):                    
            tOrder['mc_gross'] = tRandomPrice
            tOrder['payment_gross'] = tRandomPrice
            tOrder['txn_type'] = 'web_accept'
            tOrder['discount'] = '0.0'
            tOrder['handling_amount'] = '0.0'
            tOrder['insurance_amount'] = '0.0'
            tOrder['item_number'] = '1'
            tOrder['mc_fee'] = '0.0'
            tOrder['COUNTRYCODE'] = 'US'
            tOrder['address_country'] = 'United States'
            tOrder['payment_fee'] = '0.0'
            tOrder['quantity'] = "1"
            tOrder['shipping'] = "0.0"
            tOrder['shipping_discount'] = "0.0"
            tOrder['shipping_method'] = "Default"
            tOrder['tax'] = "0.0"
            
            tOrder['item_name'] = tRandomAmount.upper() + "Transfer Code"
            
            tReferralCodes = ["", "69a8e184"]
            tRandomReferral = random.choice(tReferralCodes)
            
            tPromoCodes = ["SMELITE10"]
            tRandomPromoCode = random.choice(tPromoCodes)   
            
            tOrder['option_name1'] = 'Test Order Name'      #name    
            tOrder['option_name4'] = 'RS Test Name'         #rs name 
            tOrder['option_name5'] = tRandomReferral        #referral
            tOrder['option_name5'] = tRandomPromoCode       #promocode formerly option 6
            tOrder['option_name7'] = tRandomAmount          #gold amount
            
        #logging.debug(str(tOrder))
        if(tType == "random" or tType == "viprandom"):
            tRandomEmail = 'sm-test-email-' + "".join(tRandomNumberList) + "@smokinmils.com"
            tOrder['payer_email'] = tRandomEmail
            tOrder['payer_id'] = "".join(tRandomNumberList) + "-testid"
            tOrder['txn_id'] = "".join(tRandomNumberList)        
            tOrder['custom'] = '65.91.31.0'
            tOrder['option_name2'] = tRandomEmail           #email
            tOrder['option_name3'] = '310-274-7777'         #number
            tOrder['transaction_subject'] = '65.91.31.0'
        #logging.debug(str(tOrder))
        if(tType == "me" or tType == "vipme"):
            tOrder['custom'] = '75.138.80.254'
            tOrder['payer_email'] = '*****@*****.**'
            tOrder['payer_id'] = 'FE6TJMYCTZ9CA'
            tOrder['txn_id'] = "".join(tRandomNumberList)        
            tOrder['option_name2'] = '*****@*****.**'
            tOrder['option_name3'] = '678-499-6457'   
            tOrder['transaction_subject'] = '75.138.80.254'
        #logging.debug(str(tOrder))
        if(tType == "viprandom" or tType == "vipme"):
            tOrder['payment_gross'] = "8.99"
            tOrder['transaction_subject'] = "VIP Membership"
            tOrder['item_name'] = "VIP Membership"
            tOrder['item_number'] = "VIP"
            tOrder['mc_gross'] = "8.99"
            tOrder['txn_type'] = "subscr_payment"
            tOrder['subscr_id'] = "".join(tRandomNumberList)
        #logging.debug(str(tOrder))
        tOrder['payment_status'] = 'Completed'
        tOrder['payment_type'] = 'Instant'
        tOrder['last_name'] = "Pleco"
        tOrder['first_name'] = "Kort"
        
        tOrder['fake'] = 'True'        
        #logging.debug("Last call: " + str(tOrder))
        tPayloadEncoded = urllib.urlencode(tOrder)

        #logging.debug("Encoded: " + str(tPayloadEncoded))

        tUrl = "http://smokin-goldshop.appspot.com/paypalipn"
        #logging.debug("Url: " + str(tUrl))
        
        request_cookies = mechanize.CookieJar()
        request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
        request_opener.addheaders = [('Content-Type', 'application/x-www-form-urlencoded')]
        
        mechanize.install_opener(request_opener)
        tResponse = mechanize.urlopen(url = tUrl, timeout = 25.0, data = tPayloadEncoded)
        
        
        tOrderQuery = Order().all()
        tOrderQuery.filter("orderIsGenerated", True)
        tOrderQuery.order("-orderCreated")
        tOrderList = tOrderQuery.fetch(limit=30)
        
        tContext['orders'] = tOrderList        
        
        #logging.debug("Response: " + str(tResponse))
        return tContext
 def GetContext(self):
     tUser = self.GetUser()
     
     tCustomerOrders = []
     tOrderData = {}
     tContext = {}
     
     tOrder = Order()
     tCustomer = Customer()
     tIpHandler = IpLookup()
     tIpInfo = IpInfo()
     
     tDeliveryAgent = Agent()
     tRefundAgent = Agent()
     tAssignedAgent = Agent()
     
     tPriceDic = PriceContainer.GetCurrentPriceDic()
     tCountryDic = CountryContainer.GetCurrentCountryCodes()
     tOrderKey = str(urllib.unquote(self.request.get('key')))
     
     if(tOrderKey != None and len(tOrderKey) > 0):
         tOrder = Order.get(tOrderKey)
     if(tOrder):
         tOrderHandler = OrderHandler()
         
         tResultDictionary = {}
         tPaypalPayload = {}        
         tPayload = {}
         
         tUrl = "https://api-3t.paypal.com/nvp"
         tOperation = "GetTransactionDetails"            
         tCustomer = Customer.get(tOrder.orderCustomer)
                     
         # disabled to try to trace the "empty order" bug
         #if tOrder.orderVerificationCode is None:
             #tOrder.orderVerificationCode = str(uuid.uuid4())
             #tOrder.put()                    
         
         try:
             tIpInfo = tIpHandler.GetIp(tOrder.orderIp)[0]
         except:
             tIpInfo.ipCountry = "Loading"
             tIpInfo.ipState = "Loading"
             tIpInfo.ipHost = "Loading"
             tIpInfo.ipProxy = "Loading"
             tIpInfo.ipIsp = "Loading"
             tIpInfo.ipType = "Loading"
         
         if (tIpInfo.ipProxy == ""):
             tIpInfo.ipProxy = 'No Proxy'
         tContext['tDisplayDeliver'] = 'True'
                     
         #Get Paypal Information
         tPaypalPayload['METHOD'] = tOperation
         tPaypalPayload['TRANSACTIONID'] = tOrder.orderTransactionId
         
         #logging.debug("Order Paypal Email: " + tOrder.orderPaypalEmail)
         
         try:
             tPayloadEncoded = tOrderHandler.GeneratePayload(tPaypalPayload)
             request_cookies = mechanize.CookieJar()
             request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
             request_opener.addheaders = [('Content-Type', 'application/x-www-form-urlencoded')]
             mechanize.install_opener(request_opener)
             tResponse = mechanize.urlopen(url = tUrl, timeout = 25.0, data = tPayloadEncoded)
         except: 
             tContext['error'] = 'Unable to Connect to Paypal, Try Refreshing'
             tContext['showerror'] = 'True'
             #tmpl = os.path.join(os.path.dirname(__file__), '../views/order.html')
             #self.response.out.write(render(tmpl, tContext))
             return tContext
             
         tResult = str(urllib.unquote(tResponse.read()))
         tResultSplit = tResult.split('&')
         
         for tPair in tResultSplit:
             tSplitPair = tPair.split("=")
             try:
                 tResultDictionary[tSplitPair[0]] = tSplitPair[1]
                 #logging.debug(tSplitPair[0] + "    " + tSplitPair[1])
             except:
                 logging.error("Error splitting item: " + str(tPair))
         
         if('COUNTRYCODE' in tResultDictionary.keys()):
             tCountryCode = tResultDictionary['COUNTRYCODE']
             tPaypalCountry = tCountryDic[tCountryCode]
         else:
             tPaypalCountry = 'UNKNOWN'
             
         tOrderData['paypalcountry'] = tPaypalCountry                    
         
         if 'PROTECTIONELIGIBILITYTYPE' in tResultDictionary.keys():
             tProtectionEligibility = tResultDictionary['PROTECTIONELIGIBILITYTYPE']
             
             if tProtectionEligibility == 'ItemNotReceivedEligible,UnauthorizedPaymentEligible':
                 tProtectionEligibility = 'Eligible'
                 
             if tProtectionEligibility != 'Eligible':
                 tProtectionEligibility = 'Not Eligible'
                 
             tContext['PROTECTIONELIGIBILITYTYPE'] = tProtectionEligibility
         else:
             tProtectionEligibility = 'UNKNOWN'
             
         #Display address fields
         if 'ADDRESSSTATUS' in tResultDictionary.keys():
             tContext['ADDRESSSTATUS'] = tResultDictionary['ADDRESSSTATUS']
         else:
             tContext['ADDRESSSTATUS'] = 'UNKNOWN'
         
         if 'SHIPTONAME' in tResultDictionary.keys():
             tContext['SHIPTONAME'] = tResultDictionary['SHIPTONAME']
         else:
             tContext['SHIPTONAME'] = 'UNKNOWN'
             
         if 'SHIPTOSTREET' in tResultDictionary.keys():
             tContext['SHIPTOSTREET'] = tResultDictionary['SHIPTOSTREET']
         else:
             tContext['SHIPTOSTREET'] = 'UNKNOWN'
             
         if 'SHIPTOSTREET2' in tResultDictionary.keys():
             tContext['SHIPTOSTREET2'] = tResultDictionary['SHIPTOSTREET2']
         else:
             tContext['SHIPTOSTREET2'] = 'UNKNOWN'
             
         if 'SHIPTOCITY' in tResultDictionary.keys():
             tContext['SHIPTOCITY'] = tResultDictionary['SHIPTOCITY']
         else:
             tContext['SHIPTOCITY'] = 'UNKNOWN'
             
         if 'SHIPTOSTATE' in tResultDictionary.keys():
             tContext['SHIPTOSTATE'] = tResultDictionary['SHIPTOSTATE']
         else:
             tContext['SHIPTOSTATE'] = 'UNKNOWN'
                         
         if 'SHIPTOZIP' in tResultDictionary.keys():
             tContext['SHIPTOZIP'] = tResultDictionary['SHIPTOZIP']
         else:
             tContext['SHIPTOZIP'] = 'UNKNOWN'
             
         if 'SHIPTOCOUNTRYCODE' in tResultDictionary.keys():
             tContext['SHIPTOCOUNTRYCODE'] = tResultDictionary['SHIPTOCOUNTRYCODE']
         else:
             tContext['SHIPTOCOUNTRYCODE'] = 'UNKNOWN'
             
         if 'SHIPTOPHONENUM' in tResultDictionary.keys():
             tContext['SHIPTOPHONENUM'] = tResultDictionary['SHIPTOPHONENUM']
         else:
             tContext['SHIPTOPHONENUM'] = 'UNKNOWN'
             
         
         #Get order amount to add to dated totals
         tCurrentCost = float(tOrder.orderCost)
         
         #Get date 30 days ago
         tStartDate = tOrder.orderCreated
         tIncrement = datetime.timedelta(days = -30)
         tEndDate = tStartDate + tIncrement
         tCustomerOrderQuery = Order.all()
         tCustomerOrderQuery.filter("orderCreated >", tEndDate)
         tCustomerOrderQuery.filter("orderCustomer", tOrder.orderCustomer)
         tCustomerOrderQuery.filter("orderDeliver", 'True')
         tCustomerOrders = tCustomerOrderQuery.fetch(1000)
         #logging.debug("30 day date: " + str(tEndDate))
         #logging.debug("30 day orders: " + str(len(tCustomerOrders)))
         tCustomerOrderTotal = 0.0
         for tCustomerOrder in tCustomerOrders:
             tCustomerOrderTotal += float(tCustomerOrder.orderCost)
         if (tOrder.orderDeliver == 'False'):
             tCustomerOrderTotal += tCurrentCost
         tOrderData['orderTotal'] = str("%.2f"% tCustomerOrderTotal)
         
         #Get date 24 hours ago
         tStartDate = tOrder.orderCreated
         tIncrement = datetime.timedelta(days = -1)
         tEndDate = tStartDate + tIncrement
         tCustomerOrderQuery = Order.all().filter("orderCreated >", tEndDate)
         tCustomerOrderQuery.filter("orderCustomer", tOrder.orderCustomer)
         tCustomerOrderQuery.filter("orderDeliver", 'True')
         tCustomerOrders = tCustomerOrderQuery.fetch(1000)
         #logging.debug("24 hour date: " + str(tEndDate))
         #logging.debug("24 hour orders: " + str(len(tCustomerOrders)))
         tCustomerOrderTotal24 = 0.0
         for tCustomerOrder in tCustomerOrders:
             tCustomerOrderTotal24 += float(tCustomerOrder.orderCost)
             
         if (tOrder.orderDeliver == 'False'):
             tCustomerOrderTotal24 += tCurrentCost
         tOrderData['orderTotal24'] = str("%.2f" % tCustomerOrderTotal24)
         
         #Get date 15 days ago
         tStartDate = tOrder.orderCreated
         tIncrement = datetime.timedelta(days = -15)
         tEndDate = tStartDate + tIncrement
         tCustomerOrderQuery = Order.all().filter("orderCreated >", tEndDate)
         tCustomerOrderQuery.filter("orderCustomer", tOrder.orderCustomer)
         tCustomerOrderQuery.filter("orderDeliver", 'True')
         tCustomerOrders = tCustomerOrderQuery.fetch(1000)
         #logging.debug("15 day date: " + str(tEndDate))
         #logging.debug("15 day orders: " + str(len(tCustomerOrders)))
         tCustomerOrderTotal15 = 0.0
         for tCustomerOrder in tCustomerOrders:
             tCustomerOrderTotal15 += float(tCustomerOrder.orderCost)
             
         if (tOrder.orderDeliver == 'False'):
             tCustomerOrderTotal15 += tCurrentCost
         tOrderData['orderTotal15'] = str("%.2f" % tCustomerOrderTotal15)
         
         #===== Begin Location Matching =====
         try:
             tPhoneHandler = PhoneLookup()
             tPhoneInfo = tPhoneHandler.GetPhone(tOrder.orderCustomer)[0]
         except:
             tPhoneInfo = Phone()
             tPhoneInfo.phoneState = "Unknown"
             tPhoneInfo.phoneCountry = "Unknown"
         
         #logging.debug("Ip country: " + str(tIpInfo.ipCountry))
         #logging.debug("Paypal country: " + str(tPaypalCountry))
         
         if (str(tIpInfo.ipCountry) == str(tPaypalCountry)):
             tOrderData['locationmatch'] = 'True'
         else:
             tOrderData['locationmatch'] = 'False'
             
         if (str(tIpInfo.ipCountry) == "United Kingdom" and str(tPaypalCountry) == "Great Britain (UK)"):
             tOrderData['locationmatch'] = 'True'
             
         #Agent Instructions
         #logging.debug("Order Total 24: " + str(tCustomerOrderTotal24))
         #logging.debug("Order Total: " + str(tCustomerOrderTotal))
         #logging.debug("Customer email verified: " + str(tCustomer.customerEmailVerified))
         #logging.debug("Customer phone verified: " + str(tCustomer.customerPhoneVerified))
         #logging.debug("Customer id verified: " + str(tCustomer.customerIdVerified))
         
         #Protection Eligibility Filter 
         tCountryEligibilityCode = tContext['SHIPTOCOUNTRYCODE']
         tOrderData['instructions'] = "No verification required" # default value
         if tCountryEligibilityCode in ('US', 'UK', 'CA', 'GB'):  
             if tOrder.orderCost > 10:              
                 if tProtectionEligibility == 'Eligible':
                     if tCustomerOrderTotal24 > 1000.0 or tCustomerOrderTotal > 4000.0:
                         tOrderData['instructions'] = "<span style='color:red'>$$$ Call Corowns $$$</span>"   
                 else: # not payment eligible
                     tOrderData['instructions'] = "<span style='color:red'>Refund - No Seller Protection</span>"
                     tContext['tDisplayDeliver'] = 'False'
         else: # international customer
             #if( tCustomerOrderTotal24 < 30.0 and tCustomerOrderTotal < 60.0):
             
             if tIpInfo.ipType == "Corporate":
                 tOrderData['instructions'] = tOrderData['instructions'] + "<br /><span style='color:red'>Refer to PA - Corporate IP</span>"
                 tOrderData['tDisplayDeliver'] = 'False'
                 
             if (tIpInfo.ipProxy):
                 if ("Confirmed proxy server" == tIpInfo.ipProxy):
                     tOrderData['instructions'] = tOrderData['instructions'] + "<br /><span style='color:red'>Refer to PA - Proxy</span>"
                     tContext['tDisplaydeliver'] = 'False'
             
             if tCustomerOrderTotal24 > 200.0 or tCustomerOrderTotal > 400.0:
                 tOrderData['instructions'] = "<span style='color:red'>Refer to PA - Limit Exceeded</span>"
                 tOrderData['tDisplayDeliver'] = 'False'                   
             elif tCustomerOrderTotal24 > 90.0 or tCustomerOrderTotal > 180.0:
                 if tCustomer.customerIdVerified != True:
                     tOrderData['instructions'] = "<span style='color:red'>Verify Photo ID</span>"        
             elif tCustomerOrderTotal24 > 30.0 or tCustomerOrderTotal > 60.0:
                 if tCustomer.customerPhoneVerified != True:
                     tOrderData['instructions'] = "<span style='color:red'>Verify Phone Number</span>"
             
         if(tOrderData['locationmatch'] != 'True'):
             tOrderData['instructions'] = tOrderData['instructions'] + "<br /><span style='color:red'>Verify Country Match</span>"
                             
         #logging.debug("Order Data Instructions: " + str(tOrderData['instructions']))
         #logging.debug("Location Match" + str(tOrderData['locationmatch']))
         
         tCustomerOrderQuery = db.GqlQuery("SELECT * FROM Order WHERE orderCustomer = '" + tOrder.orderCustomer + "'")
         tTotalCustomerOrders = []
         tTotalCustomerOrders = tCustomerOrderQuery.fetch(50)
         for tCustomerOrder in tTotalCustomerOrders:
             if (tCustomerOrder.orderChargeback == True):
                 tChargeBack = True
             else:
                 tChargeBack = False
                 
         tOrderData['chargeback'] = tChargeBack if (tChargeBack) else False
         tOrderData['chargeback'] = str(tOrderData['chargeback'])
         
         tIpChargebacks = tIpHandler.GetChargebacks(tOrder.orderIp)
         tOrderData['ipchargeback'] = len(tIpChargebacks)
                         
         try:
             tTotalBonusString = NumberToGp.ConvertIntToBet(int(tOrder.orderBonusQuantity))
             #logging.debug("Total Bonus String " + tTotalBonusString)
         except:
             tTotalBonusString = ""
             
         if (tCustomer.customerIsPaBlacklisted == True):
             tOrderData['instructions'] = tOrderData['instructions'] + "<br /><span style='color:red'>Refer to PA - Blacklist</span>"
             tContext['tDisplayDeliver'] = 'False'
             
         if (tCustomer.customerIsGlobalBlacklisted == True):
             tOrderData['instructions'] = tOrderData['instructions'] + "<br /><span style='color:red'>Do Not Deliver - Blacklist</span>"
             tContext['tDisplayDeliver'] = 'False'
         
         #normalize unicode
         try:
             tSimpleGold = unicodedata.normalize("NFC", tOrder.orderSimpleGoldAmount).encode("ascii", "ignore")
         except:
             tSimpleGold = tOrder.orderSimpleGoldAmount
         
         #logging.debug(str(tPriceDic[tSimpleGold]))
         #logging.debug(str(tOrder.orderCost))
         tCurrentEocPrices = PriceContainer.GetCurrentPriceDic()
         tCurrent07Prices = PriceContainer.GetCurrentPriceDic07()
                     
         #logging.debug(str(tCurrent07Prices))
         #logging.debug(str(tCurrentEocPrices))
         
         tSkip07 = False
         tValidOrder = False
         if tOrder.orderSimpleGoldAmount in tCurrentEocPrices.keys():
             if str(tOrder.orderCost) == str(tCurrentEocPrices[tOrder.orderSimpleGoldAmount]):
                 tOrder.orderGoldType = 'eoc'
                 tSkip07 = True
                 tValidOrder = True
         
         if not tSkip07:
             if tOrder.orderSimpleGoldAmount in tCurrent07Prices.keys():
                 if str(tOrder.orderCost) == str(tCurrent07Prices[tOrder.orderSimpleGoldAmount]):
                     tOrder.orderGoldType = '07'
                     tValidOrder = True
         
         #logging.debug("skip07 {}".format(tSkip07))
         #logging.debug("valid {}".format(tValidOrder))
         #logging.debug("order simple gold amount {}".format(tOrder.orderSimpleGoldAmount))
         #logging.debug("order value {}".format(tOrderData['orderTotal']))
         #logging.debug("gold type {}".format(tContext['gold_type']))
                     
         if not tValidOrder:
             tOrderData['instructions'] = tOrderData['instructions'] + '<br /><span style="color:red">Do Not Deliver - Bad Payment</span>'
             #tOrderData['tDisplayDeliver'] = 'False'
             #tOrder.orderLocked = 'True'
             #tOrder.put()
         
         #logging.debug(str(tOrder.orderIsGenerated))
         if(tOrder.orderIsGenerated == True):
             tOrder.orderLocked = 'False'
             tOrder.orderIsRefunded = 'False'
             tOrder.orderDeliver = 'False'
             tOrderData['tDisplayDeliver'] = 'True'
             
         try:
             tDeliveryAgent = Agent.GetAgentByEmail(tOrder.orderDeliveryAgent)
             tContext['tDeliveryAgent'] = tDeliveryAgent
         except:
             pass
         
         try:
             tAssignedAgent = Agent.GetAgentByEmail(tOrder.orderAssignedAgent)
             tContext['tAssignedAgent'] = tAssignedAgent
         except:
             pass
         
         try:
             tRefundAgent = Agent.GetAgentByEmail(tOrder.orderRefundAgent)
             tContext['tRefundAgent'] = tRefundAgent
         except:
             pass            
         tOrderData['bonus'] = tTotalBonusString
         
         tOrderData['phoneverified'] = str(tCustomer.customerPhoneVerified)
         tOrderData['emailverified'] = str(tCustomer.customerEmailVerified)
         tOrderData['idverified'] = str(tCustomer.customerIdVerified)
         
         tContext['tOrder'] = tOrder
         tContext['tOrderData'] = tOrderData
         tContext['tCustomer'] = tCustomer
         tContext['tIpInfo'] = tIpInfo
         tContext['tPhoneInfo'] = tPhoneInfo
     
     
     if ((tOrder.orderDeliveryAgent == "" or tOrder.orderDeliveryAgent == None) and tOrder.orderDeliver == 'True'):
         tAgentKey = tOrder.orderAgent
         tAgentId = Agent()
         tAgentId = Agent.get(tAgentKey)
         tOrder.orderDeliveryAgent = str(tAgentId.agentId)
                     
     #logging.debug(str(tOrderData))
     return tContext
示例#9
0
    def ProcessOrder(self, pArgumentDic):
        tOrderHandler = OrderHandler()
        tCustomerHandler = CustomerHandler()
        tCustomer = Customer()
        tPaypalOrder = PaypalOrder()
        tArgumentDic = pArgumentDic

        # Assign Values from POST from Paypal IPN
        tTransactionId = tArgumentDic["txn_id"]
        tAlphaMatch = re.compile("[^A-Za-z0-9]+")
        tAlphaSpaceMatch = re.compile("[^A-Za-z0-9 ]+")

        # Short circuits the order process for special PA page
        if "payer_email" in tArgumentDic.keys():
            if tArgumentDic["payer_email"] == "*****@*****.**":
                tPaypalOrder.ProcessPlayerAuctions(tArgumentDic)
                return

        try:
            tGoldAmount = tArgumentDic["option_name7"]
        except:
            tGoldAmount = ""

        try:
            tCustomerFirstName = tAlphaSpaceMatch.sub("", tArgumentDic["first_name"])
        except:
            tCustomerFirstName = ""

        try:
            tCustomerLastName = tAlphaSpaceMatch.sub("", tArgumentDic["last_name"])
        except:
            tCustomerLastName = ""

        try:
            tCustomerName = tAlphaSpaceMatch.sub("", tArgumentDic["option_name1"])
        except:
            tCustomerName = ""

        try:
            tEmail = tArgumentDic["option_name2"]
        except:
            tEmail = ""
        tPaypalEmail = str(tArgumentDic["payer_email"]).lower()
        try:
            tMobilePhone = tArgumentDic["option_name3"]
            tMobilePhone = re.sub(r"\D", "", tMobilePhone)
        except:
            tMobilePhone = ""
        try:
            tRsName = tArgumentDic["option_name4"].strip().lower()
            tRsName = tRsName.replace(" ", "_")
            tRsName = tRsName.replace("-", "_")
        except:
            tRsName = ""
        try:
            tCombatLevel = ""
        except:
            tCombatLevel = ""

        # try:
        # tReferCode = str(tArgumentDic['option_name5']).strip()
        # except:
        tReferCode = ""

        try:
            tPromotionCode = str(tArgumentDic["option_name5"]).strip()
        except:
            tPromotionCode = ""

        tOrderIp = tArgumentDic["custom"]
        tMembers = ""

        try:
            tOrderQuery = Order.all().filter("orderTransactionId", tTransactionId)
            tOrder = tOrderQuery.fetch(1)[0]
        except:
            tOrder = Order()

        if "fake" in tArgumentDic.keys():
            # logging.debug('Fake key hit')
            # logging.debug(str(tArgumentDic['fake']))
            if tArgumentDic["fake"] == "True":
                tOrder.orderIsGenerated = True

        tOrder.orderFormName = tCustomerName
        tOrder.orderCombatLevel = tCombatLevel

        if len(tGoldAmount) == 0:
            tUrl = "https://api-3t.paypal.com/nvp"
            # tOperation = "AddressVerify"
            tOperation = "GetTransactionDetails"
            # Get Paypal Information
            # tPaypal = PaypalTrigger()
            tResultDictionary = {}
            tPaypalPayload = {}
            tPayload = {}
            tPaypalPayload["METHOD"] = tOperation
            tPaypalPayload["TRANSACTIONID"] = tTransactionId

            tPayloadEncoded = tOrderHandler.GeneratePayload(tPaypalPayload)
            request_cookies = mechanize.CookieJar()
            request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
            request_opener.addheaders = [("Content-Type", "application/x-www-form-urlencoded")]
            mechanize.install_opener(request_opener)
            tResponse = mechanize.urlopen(url=tUrl, timeout=25.0, data=tPayloadEncoded)
            tResult = str(urllib.unquote(tResponse.read()))
            tResultSplit = tResult.split("&")

            for tPair in tResultSplit:
                tSplitPair = tPair.split("=")
                if len(tSplitPair) == 1:
                    tSplitPair.append("")
                tResultDictionary[tSplitPair[0]] = tSplitPair[1]
                logging.debug(tSplitPair[0] + "    " + tSplitPair[1])
            tGoldAmountString = tResultDictionary["L_NAME0"]
            logging.debug("Gold amount string %s".format(tGoldAmountString))
            try:
                tGoldRegex = re.compile("([0-9]*?[m|M]).T")
                tGoldMatch = tGoldRegex.findall(tGoldAmountString)
                # logging.debug("Backup gold amount parser hit, string " + tGoldAmountString + "   Match: " + tGoldMatch[0])
                tGoldAmount = tGoldMatch[0]
            except:
                tGoldRegex = re.compile("([0-9]*?[m|M]).T")
                tGoldMatch = tGoldRegex.findall(tGoldAmountString)
                try:
                    # logging.debug("Backup gold amount parser hit, string " + tGoldAmountString + "   Match: " + tGoldMatch[0])
                    tGoldAmount = tGoldMatch[0]
                except:
                    # logging.debug("No gold match")
                    tGoldAmount = ""

        tOrder.orderQuantity = NumberToGp.ConvertBetToInt(tGoldAmount)
        tOrder.orderSimpleGoldAmount = tGoldAmount
        tOrder.orderFormEmail = tEmail
        tOrder.orderAccountName = tRsName
        tOrder.orderMobileNumber = tMobilePhone
        tOrder.orderPromotionalCode = tPromotionCode.lower()
        tOrder.orderIp = tOrderIp
        if tMembers == "yes":
            tOrder.orderCustomerIsMember = True
        else:
            tOrder.orderCustomerIsMember = False

        # Paypal Info
        tOrder.orderTransactionId = tTransactionId

        tOrder.orderPaypalFirstName = tCustomerFirstName
        tOrder.orderPaypalLastName = tCustomerLastName

        tOrder.orderCost = float(tArgumentDic["payment_gross"])
        tOrder.orderCustomerPaypalId = tArgumentDic["payer_id"]
        tOrder.orderPaypalEmail = str(tPaypalEmail).lower()

        tAssignedAgentNick = tPaypalOrder.GetAssignedAgent(tOrder)
        tOrder.orderAssignedAgent = tAssignedAgentNick
        # logging.debug("Order assigned to agent: " + str(tAssignedAgentNick))

        tOrder.orderReferralCode = tReferCode

        tOrder.orderDeliver = "False"

        if tOrder.orderVerificationCode == None or tOrder.orderVerificationCode == "":
            tOrder.orderVerificationCode = re.sub(r"\W", "", str(uuid.uuid4())).lower()

        tCurrentEocPrices = PriceContainer.GetCurrentPriceDic()
        tCurrent07Prices = PriceContainer.GetCurrentPriceDic07()

        tSkip07 = False
        if tOrder.orderSimpleGoldAmount in tCurrentEocPrices.keys():
            if str(tOrder.orderCost) == str(tCurrentEocPrices[tOrder.orderSimpleGoldAmount]):
                tOrder.orderGoldType = "eoc"
                tSkip07 = True

        if not tSkip07:
            if tOrder.orderSimpleGoldAmount in tCurrent07Prices.keys():
                if str(tOrder.orderCost) == str(tCurrent07Prices[tOrder.orderSimpleGoldAmount]):
                    tOrder.orderGoldType = "07"

        tOrderKey = str(tOrder.put())

        # logging.debug("Order Saved: " + str(tOrderKey))

        taskqueue.add(url="/iplookup", countdown=1, params={"ip": tOrderIp, "transid": tTransactionId})

        tUsedBonus = []
        tCustomerList = tCustomerHandler.GetCustomerByPpid(tOrder.orderCustomerPaypalId)
        if len(tCustomerList) == 1:
            tCustomer = tCustomerList[0]
            tIpList = tCustomer.customerIpAddresses
            tIpList.append(tOrderIp)
            tCustomer.customerIpAddresses = tIpList

            tOrderList = tCustomer.customerOrders
            tOrderList.append(tOrderKey)
            tCustomer.customerOrders = tOrderList

            tCustomer.customerOrderCount = int(tCustomer.customerOrderCount) + 1
            # tUsedBonus = tCustomer.customerUsedBonus
            tUsedBonus = Order.GetCustomerPromoCodes(tCustomer.customerPaypalId)

            # tOrder.orderCustomer = str(tCustomer.key())
        elif len(tCustomerList) == 0:
            tCustomer.customerEmail = str(tOrder.orderPaypalEmail).lower()
            tCustomer.customerName = tCustomerName
            tCustomer.customerFirstName = tOrder.orderPaypalFirstName
            tCustomer.customerLastName = tOrder.orderPaypalLastName
            tCustomer.customerIpAddresses = [tOrderIp]
            tCustomer.customerOrders = [tOrderKey]
            tCustomer.customerOrderCount = 1
            tCustomer.customerPhone = tMobilePhone
            tCustomer.customerEmailVerified = False
            tCustomer.customerPhoneVerified = False
            tCustomer.customerIdVerified = False
            tCustomer.customerPaypalId = tOrder.orderCustomerPaypalId
            tCustomer.customerIsGlobalBlacklisted = False
            tCustomer.customerIsPaBlacklisted = False

        tPromoCode = ""
        tPromoCode = tOrder.orderPromotionalCode
        # logging.debug("Order Promo Code: " + str(tOrder.orderPromotionalCode))
        tPromo = Promo()
        tPromoCode = tPromoCode.lower()
        try:
            logging.debug("Promo Code: " + str(tPromoCode))
            tPromo = Promo.GetPromoByCode(tPromoCode)
            logging.debug("Promo: " + str(tPromo))
            tGoldAmount = tOrder.orderQuantity
            logging.debug("Gold Amount: " + str(tGoldAmount))
            logging.debug("Promo is active: " + str(tPromo.promoIsActive))

            if (tPromo.promoIsActive) and (tPromo.promoUses <= tPromo.promoLimit):
                if tPromo.promoLimit != 0:
                    tPromo.promoUses = tPromo.promoUses + 1

                if (tPromoCode in tUsedBonus) == True:
                    tPercentBonus = 0.0
                else:
                    tPercentBonus = tGoldAmount * tPromo.promoPercentage
                    # tUsedBonus.append(tPromoCode)

                tGoldAmount = tGoldAmount + tPercentBonus
                tGoldAmount = tGoldAmount + tPromo.promoGoldAmount
                tTotalBonusFloat = tPercentBonus + tPromo.promoGoldAmount
                logging.debug("Bonus float: " + str(tTotalBonusFloat))
                tOrder.orderBonusQuantity = int(tTotalBonusFloat)

                logging.debug("Total Bonus Float " + str(tTotalBonusFloat))
                logging.debug("Promo Gold Amount " + str(tPromo.promoGoldAmount))
                logging.debug("Promo Percentage " + str(tPercentBonus))
        except:
            tOrder.orderBonusQuantity = 0

        # tCustomer.customerUsedBonus = tUsedBonus

        tCustomerKey = str(tCustomer.put())
        tOrder.orderCustomer = tCustomerKey
        tOrderKey = str(tOrder.put())

        if tCustomerName == "":
            tCustomerName = tCustomerFirstName + " " + tCustomerLastName

        if tGoldAmount == None or len(str(tGoldAmount)) == 0:
            tGoldAmount = tGoldAmountString

        response = taskqueue.add(
            url="/emailnotify",
            countdown=1,
            params={"email": tPaypalEmail, "gold": tGoldAmount, "name": tCustomerName, "key": tOrderKey},
        )
        logging.debug(str(response))
示例#10
0
    def IpInfoScraper(self, pIp):
        tIpUrl = 'http://whatismyipaddress.com/ip/'
        tIpUrl = tIpUrl + pIp
        #logging.debug("Ip Url: " + tIpUrl)
        request_cookies = mechanize.CookieJar()
        request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
        request_opener.addheaders = [('Content-Type', 'application/x-www-form-urlencoded')]
        mechanize.install_opener(request_opener)
        tResponse = mechanize.urlopen(url = tIpUrl, timeout = 25.0)
        tContent = str(urllib.unquote(tResponse.read()))
        #logging.debug(str(tContent))
        tCity = ""
        tCountry = ""
        tProxy = ""
        tHost = ""
        tIsp = ""
        tState = ""
        tType = ""
        
        try:
            tCountryRegex = re.compile("<th>Country:</th><td>(?P<country>.*) <img")
            tCountryMatch = tCountryRegex.search(tContent)
            tCountry = tCountryMatch.groupdict()['country']
        except:
            logging.debug("Country Storing Failed")
        
        try:
            tHostRegex = re.compile("<th>Hostname:</th><td>(?P<host>.*)</td></tr><tr><th>I")
            tHostMatch = tHostRegex.search(tContent)
            tHost = tHostMatch.groupdict()['host']
        except:
            logging.debug("Host Storing Failed")
        
        try:
            tStateRegex = re.compile("<th>State/Region:</th><td>(?P<state>.*)</td></tr>")
            tStateMatch = tStateRegex.search(tContent)
            tState = tStateMatch.groupdict()['state']
        except:
            logging.debug("State Storing Failed")
        
        try:
            tCityRegex = re.compile("<th>City:</th><td>(?P<city>.*)</td></tr>")
            tCityMatch = tCityRegex.search(tContent)
            tCity = tCityMatch.groupdict()['city']
        except:
            logging.debug("City Storing Failed")
        
        try:
            tIspRegex = re.compile("<th>ISP:</th><td>(?P<isp>.*)</td></tr><tr><th>Or")
            tIspMatch = tIspRegex.search(tContent)
            tIsp = tIspMatch.groupdict()['isp']
        except:
            logging.debug("ISP Storing Failed")

        try:
            tProxyRegex = re.compile("<th>Services:</th><td>(?P<proxy>.*)</td></tr><tr><th>T")
            tProxyMatch = tProxyRegex.search(tContent)
            tProxy = tProxyMatch.groupdict()['proxy']
            if(tProxy[0] == "<"):
                tProxyRegex = re.compile('<a href="/ip-services">(?P<proxy>.*)</a>')
                tProxyMatch = tProxyRegex.search(tProxy)
                tProxy = tProxyMatch.groupdict()['proxy']
        except:
            logging.debug("Proxy Storing Failed")
        
        try:
            tTypeRegex = re.compile("<th>Type:</th><td><a.+href=[\'|\"](.+)[\'|\"].*?>(?P<type>.*)</a></td></tr><tr><th>A")
            tTypeMatch = tTypeRegex.search(tContent)
            tType = tTypeMatch.groupdict()['type']
        except:
            logging.debug("Type Storing Failed")
        
        tResult = {}
        tResult['country'] = tCountry
        tResult['host'] = tHost
        tResult['state'] = tState
        tResult['isp'] = tIsp
        tResult['proxy'] = tProxy
        tResult['type'] = tType
        
        return tResult
示例#11
0
    def PostContext(self):
        tOrder = {}
        tContext = {}
        tPriceDictionary = PriceContainer.GetCurrentPriceDic()

        tType = str(self.request.get('type'))
        #logging.debug("Type: " + tType)

        tRandomAmount = ""
        tRandomPrice = ""
        tRandomAmount = random.choice(tPriceDictionary.keys())
        tRandomPrice = tPriceDictionary[tRandomAmount]
        tRandomNumberList = [str(random.randrange(0, 9)) for i in range(0, 9)]

        #valid for all types of orders
        tOrder['mc_currency'] = 'USD'
        tOrder['receiver_email'] = '*****@*****.**'
        tOrder['receiver_id'] = 'NSKCXUXQEMPBG'
        tOrder['residence_country'] = 'US'
        tOrder['address_city'] = 'Beverly Hills'
        tOrder['address_country'] = 'United States'
        tOrder['address_country_code'] = 'US'
        tOrder['address_name'] = 'Test Address'
        tOrder['address_state'] = 'California'
        tOrder['address_street'] = '9876 Wilshire Boulevard'
        tOrder['address_zip'] = '90210'
        tOrder['notify_version'] = '3.4'

        #logging.debug(str(tOrder))

        tAvailableEligibility = [
            "Ineligible", "Partially Eligible - INR Only", "Eligible"
        ]
        tOrder['protection_eligibility'] = random.choice(tAvailableEligibility)

        tAvailableStatus = ["verified", "unverified"]
        tOrder['payer_status'] = random.choice(tAvailableStatus)

        if (tType == "random" or tType == "me"):
            tOrder['mc_gross'] = tRandomPrice
            tOrder['payment_gross'] = tRandomPrice
            tOrder['txn_type'] = 'web_accept'
            tOrder['discount'] = '0.0'
            tOrder['handling_amount'] = '0.0'
            tOrder['insurance_amount'] = '0.0'
            tOrder['item_number'] = '1'
            tOrder['mc_fee'] = '0.0'
            tOrder['COUNTRYCODE'] = 'US'
            tOrder['address_country'] = 'United States'
            tOrder['payment_fee'] = '0.0'
            tOrder['quantity'] = "1"
            tOrder['shipping'] = "0.0"
            tOrder['shipping_discount'] = "0.0"
            tOrder['shipping_method'] = "Default"
            tOrder['tax'] = "0.0"

            tOrder['item_name'] = tRandomAmount.upper() + "Transfer Code"

            tReferralCodes = ["", "69a8e184"]
            tRandomReferral = random.choice(tReferralCodes)

            tPromoCodes = ["SMELITE10"]
            tRandomPromoCode = random.choice(tPromoCodes)

            tOrder['option_name1'] = 'Test Order Name'  #name
            tOrder['option_name4'] = 'RS Test Name'  #rs name
            tOrder['option_name5'] = tRandomReferral  #referral
            tOrder[
                'option_name5'] = tRandomPromoCode  #promocode formerly option 6
            tOrder['option_name7'] = tRandomAmount  #gold amount

        #logging.debug(str(tOrder))
        if (tType == "random" or tType == "viprandom"):
            tRandomEmail = 'sm-test-email-' + "".join(
                tRandomNumberList) + "@smokinmils.com"
            tOrder['payer_email'] = tRandomEmail
            tOrder['payer_id'] = "".join(tRandomNumberList) + "-testid"
            tOrder['txn_id'] = "".join(tRandomNumberList)
            tOrder['custom'] = '65.91.31.0'
            tOrder['option_name2'] = tRandomEmail  #email
            tOrder['option_name3'] = '310-274-7777'  #number
            tOrder['transaction_subject'] = '65.91.31.0'
        #logging.debug(str(tOrder))
        if (tType == "me" or tType == "vipme"):
            tOrder['custom'] = '75.138.80.254'
            tOrder['payer_email'] = '*****@*****.**'
            tOrder['payer_id'] = 'FE6TJMYCTZ9CA'
            tOrder['txn_id'] = "".join(tRandomNumberList)
            tOrder['option_name2'] = '*****@*****.**'
            tOrder['option_name3'] = '678-499-6457'
            tOrder['transaction_subject'] = '75.138.80.254'
        #logging.debug(str(tOrder))
        if (tType == "viprandom" or tType == "vipme"):
            tOrder['payment_gross'] = "8.99"
            tOrder['transaction_subject'] = "VIP Membership"
            tOrder['item_name'] = "VIP Membership"
            tOrder['item_number'] = "VIP"
            tOrder['mc_gross'] = "8.99"
            tOrder['txn_type'] = "subscr_payment"
            tOrder['subscr_id'] = "".join(tRandomNumberList)
        #logging.debug(str(tOrder))
        tOrder['payment_status'] = 'Completed'
        tOrder['payment_type'] = 'Instant'
        tOrder['last_name'] = "Pleco"
        tOrder['first_name'] = "Kort"

        tOrder['fake'] = 'True'
        #logging.debug("Last call: " + str(tOrder))
        tPayloadEncoded = urllib.urlencode(tOrder)

        #logging.debug("Encoded: " + str(tPayloadEncoded))

        tUrl = "http://smokin-goldshop.appspot.com/paypalipn"
        #logging.debug("Url: " + str(tUrl))

        request_cookies = mechanize.CookieJar()
        request_opener = mechanize.build_opener(
            mechanize.HTTPCookieProcessor(request_cookies))
        request_opener.addheaders = [('Content-Type',
                                      'application/x-www-form-urlencoded')]

        mechanize.install_opener(request_opener)
        tResponse = mechanize.urlopen(url=tUrl,
                                      timeout=25.0,
                                      data=tPayloadEncoded)

        tOrderQuery = Order().all()
        tOrderQuery.filter("orderIsGenerated", True)
        tOrderQuery.order("-orderCreated")
        tOrderList = tOrderQuery.fetch(limit=30)

        tContext['orders'] = tOrderList

        #logging.debug("Response: " + str(tResponse))
        return tContext
示例#12
0
    def IpInfoScraper(self, pIp):
        tIpUrl = 'http://whatismyipaddress.com/ip/'
        tIpUrl = tIpUrl + pIp
        #logging.debug("Ip Url: " + tIpUrl)
        request_cookies = mechanize.CookieJar()
        request_opener = mechanize.build_opener(
            mechanize.HTTPCookieProcessor(request_cookies))
        request_opener.addheaders = [('Content-Type',
                                      'application/x-www-form-urlencoded')]
        mechanize.install_opener(request_opener)
        tResponse = mechanize.urlopen(url=tIpUrl, timeout=25.0)
        tContent = str(urllib.unquote(tResponse.read()))
        #logging.debug(str(tContent))
        tCity = ""
        tCountry = ""
        tProxy = ""
        tHost = ""
        tIsp = ""
        tState = ""
        tType = ""

        try:
            tCountryRegex = re.compile(
                "<th>Country:</th><td>(?P<country>.*) <img")
            tCountryMatch = tCountryRegex.search(tContent)
            tCountry = tCountryMatch.groupdict()['country']
        except:
            logging.debug("Country Storing Failed")

        try:
            tHostRegex = re.compile(
                "<th>Hostname:</th><td>(?P<host>.*)</td></tr><tr><th>I")
            tHostMatch = tHostRegex.search(tContent)
            tHost = tHostMatch.groupdict()['host']
        except:
            logging.debug("Host Storing Failed")

        try:
            tStateRegex = re.compile(
                "<th>State/Region:</th><td>(?P<state>.*)</td></tr>")
            tStateMatch = tStateRegex.search(tContent)
            tState = tStateMatch.groupdict()['state']
        except:
            logging.debug("State Storing Failed")

        try:
            tCityRegex = re.compile("<th>City:</th><td>(?P<city>.*)</td></tr>")
            tCityMatch = tCityRegex.search(tContent)
            tCity = tCityMatch.groupdict()['city']
        except:
            logging.debug("City Storing Failed")

        try:
            tIspRegex = re.compile(
                "<th>ISP:</th><td>(?P<isp>.*)</td></tr><tr><th>Or")
            tIspMatch = tIspRegex.search(tContent)
            tIsp = tIspMatch.groupdict()['isp']
        except:
            logging.debug("ISP Storing Failed")

        try:
            tProxyRegex = re.compile(
                "<th>Services:</th><td>(?P<proxy>.*)</td></tr><tr><th>T")
            tProxyMatch = tProxyRegex.search(tContent)
            tProxy = tProxyMatch.groupdict()['proxy']
            if (tProxy[0] == "<"):
                tProxyRegex = re.compile(
                    '<a href="/ip-services">(?P<proxy>.*)</a>')
                tProxyMatch = tProxyRegex.search(tProxy)
                tProxy = tProxyMatch.groupdict()['proxy']
        except:
            logging.debug("Proxy Storing Failed")

        try:
            tTypeRegex = re.compile(
                "<th>Type:</th><td><a.+href=[\'|\"](.+)[\'|\"].*?>(?P<type>.*)</a></td></tr><tr><th>A"
            )
            tTypeMatch = tTypeRegex.search(tContent)
            tType = tTypeMatch.groupdict()['type']
        except:
            logging.debug("Type Storing Failed")

        tResult = {}
        tResult['country'] = tCountry
        tResult['host'] = tHost
        tResult['state'] = tState
        tResult['isp'] = tIsp
        tResult['proxy'] = tProxy
        tResult['type'] = tType

        return tResult
 def post(self):
     tUrl = "https://api-3t.paypal.com/nvp"
     tOperation = "TransactionSearch"
     tOrderList = []
     tPaypalPayload = {}        
     tPayload = {}
     tPaypal = PaypalTrigger()
     tPostDate = self.request.get('date')
     
     if (tPostDate == None):
         tPostDate = datetime.datetime(2011, 2, 1, 1, 01, 01)
         
     tStartDate = tPaypal.StringToDatetime(tPostDate)
     try:
         tIncrement = datetime.timedelta(days = 1)
         tEndDate = tStartDate + tIncrement
         if(int(tEndDate.day) > 31):
             tEndDate = datetime.datetime(tStartDate.year, str(int(tStartDate.month) + 1), "01",
                                          tStartDate.hour, tStartDate.minute, tStartDate.second)
         #logging.debug("Fetching Items for Date: " + str(tPaypal.DatetimeToString(tStartDate)))
         
         tPaypalPayload['TRANSACTIONCLASS'] = "Received"
         tPaypalPayload['STATUS'] = "Success"
         tPaypalPayload['METHOD'] = tOperation
         tPaypalPayload['STARTDATE'] = tStartDate
         tPaypalPayload['ENDDATE'] = tEndDate
         tPayloadEncoded = tPaypal.GeneratePayload(tPaypalPayload)
         
         request_cookies = mechanize.CookieJar()
         request_opener = mechanize.build_opener(mechanize.HTTPCookieProcessor(request_cookies))
         request_opener.addheaders = [('Content-Type', 'application/x-www-form-urlencoded')]
         mechanize.install_opener(request_opener)
         
         tResponse = mechanize.urlopen(url = tUrl, timeout = 25.0, data = tPayloadEncoded)
         #logging.debug("Mechanize Package")
         #logging.debug("Url: " + tUrl)
         #logging.debug("Data: " + str(tPaypalPayload))
         
         tResult = tResponse.read()
         #logging.debug(tResult)
     except:
         logging.error("Paypal Timed Out: " + str(tPaypal.DatetimeToString(tStartDate)))
         tEndDate = tStartDate
         tResult = ""
         
     tPayload['date'] = tPaypal.DatetimeToString(tEndDate)
     
     tTimestampRegex = re.compile("L_TIMESTAMP(?P<objectnumber>\d*)=(?P<timestamp>.*?)Z&")
     tTimestampMatches = tTimestampRegex.findall(tResult)
     
     for tTimestamp in tTimestampMatches:
         tTempOrder = Order()
         tTimestampDecoded = urllib.unquote(tTimestamp[1])
         tTimestampSplit = str(tTimestampDecoded).split('T')
         tTimestampDate = tTimestampSplit[0]
         tTimestampTime = tTimestampSplit[1]
         tTimestampDateSplit = tTimestampDate.split('-')
         tTimestampTimeSplit = tTimestampTime.split(':')
         
         tOrderTime = datetime.datetime(int(tTimestampDateSplit[0]), int(tTimestampDateSplit[1]), 
                                        int(tTimestampDateSplit[2]), int(tTimestampTimeSplit[0]),
                                        int(tTimestampTimeSplit[1]), int(tTimestampTimeSplit[2]))
         
         tTempOrder.orderCreated = tOrderTime
         tOrderList.append(tTempOrder)
     
     tTypeRegex = re.compile("L_TYPE(?P<objectnumber>\d*)=(?P<type>.*?)&")
     tTypeMatches = tTypeRegex.findall(tResult)
     
     for tType in tTypeMatches:
         tTempOrder = tOrderList[int(tType[0])]
         tTempOrder.orderPaypalType = urllib.unquote(tType[1])
         tOrderList[int(tType[0])] = tTempOrder
     
     tEmailRegex = re.compile("L_EMAIL(?P<objectnumber>\d*)=(?P<email>.*?)&")
     tEmailMatches = tEmailRegex.findall(tResult)
     
     for tEmail in tEmailMatches:
         tTempOrder = tOrderList[int(tEmail[0])]
         tTempOrder.orderCustomerEmail = urllib.unquote(tEmail[1])
         tOrderList[int(tEmail[0])] = tTempOrder
         
     tNameRegex = re.compile("L_NAME(?P<objectnumber>\d*)=(?P<name>.*?)&")
     tNameMatches = tNameRegex.findall(tResult)
         
     for tName in tNameMatches:
         tTempOrder = tOrderList[int(tName[0])]
         tTempOrder.orderCustomerName = urllib.unquote(tName[1])
         tOrderList[int(tName[0])] = tTempOrder
         
     tTransactionIdRegex = re.compile("L_TRANSACTIONID(?P<objectnumber>\d*)=(?P<transactionid>.*?)&")
     tTransactionIdMatches = tTransactionIdRegex.findall(tResult)
     
     for tTransactionId in tTransactionIdMatches:
         tTempOrder = tOrderList[int(tTransactionId[0])]
         tTempOrder.orderPaypalId = urllib.unquote(tTransactionId[1])
         tOrderList[int(tTransactionId[0])] = tTempOrder
         
     tStatusRegex = re.compile("L_STATUS(?P<objectnumber>\d*)=(?P<status>.*?)&")
     tStatusMatches = tStatusRegex.findall(tResult)
     
     for tStatus in tStatusMatches:
         tTempOrder = tOrderList[int(tStatus[0])]
         tTempOrder.orderPaypalStatus = urllib.unquote(tStatus[1])
         tOrderList[int(tStatus[0])] = tTempOrder
         
     for tOrder in tOrderList:
         try:
             tOrder.put()
         except:
             logging.error("============= Order Storing FAILED =============")
             logging.error("orderPaypalStatus: " + str(tOrder.orderPaypalStatus))
             logging.error("orderPaypalId: " + str(tOrder.orderPaypalId))
             logging.error("orderCustomerName: " + str(tOrder.orderCustomerName))
             logging.error("orderCustomerEmail: " + str(tOrder.orderCustomerEmail))
             logging.error("orderCreated: " + str(tPaypal.DatetimeToString(tOrder.orderCreated)))
         
     tFormerCount = int(self.request.get('former'))
     tOrderCount = len(tOrderList)
     #logging.debug("Former Count: " + str(tFormerCount) + "    Order Count: " + str(tOrderCount))
     if (tOrderCount == 0):
         tFormerCount += 1
     else:
         tFormerCount = 0
         
     tPayload['former'] = tFormerCount
         
     if (tFormerCount < 100):
         taskqueue.add(url = '/paypaltrigger', countdown = 10, params = tPayload)
    def PostContext(self):
        tResponse = {}
        tResponse['tResponseText'] = ""
        tPaypal = VipCancelPaypalAjax()
        tResultDictionary = {}
        tPaypalPayload = {}
        tPayload = {}

        pSubscriptionKey = str(self.request.get('key'))
        tSubscription = VipSubscription()
        try:
            tSubscription = VipSubscription.get(pSubscriptionKey)
        except:
            tResponse['tResponseText'] = "Not Found"
            return tResponse
        #logging.debug("Subscription found with owner: " + tSubscription.subscriptionOwner)

        if (tSubscription):

            tPaypalPayload['METHOD'] = "ManageRecurringPaymentsProfileStatus"
            tPaypalPayload['PROFILEID'] = str(tSubscription.subscriptionId)
            tPaypalPayload['ACTION'] = 'Cancel'

            tPayloadEncoded = tPaypal.GeneratePayload(tPaypalPayload)

            request_cookies = mechanize.CookieJar()
            request_opener = mechanize.build_opener(
                mechanize.HTTPCookieProcessor(request_cookies))
            request_opener.addheaders = [('Content-Type',
                                          'application/x-www-form-urlencoded')]
            mechanize.install_opener(request_opener)

            tResponse = mechanize.urlopen(url=tUrl,
                                          timeout=25.0,
                                          data=tPayloadEncoded)
            tResult = str(urllib.unquote(tResponse.read()))

            #logging.debug("Mechanize Package")
            #logging.debug("Url: " + tUrl)
            #logging.debug("Data: " + str(tPaypalPayload))
            #logging.debug("Response: " + tResult)

            tResultSplit = tResult.split('&')

            for tPair in tResultSplit:
                tSplitPair = tPair.split("=")
                tResultDictionary[tSplitPair[0]] = tSplitPair[1]

            tResponse['tResponseText'] = "Cancelled"

            tSubscription.subscriptionIsActive = False
            tSubscription.subscriptionEnd = datetime.datetime.now()
            tSubscription.subscriptionNeedsUpgrade = False
            tSubscription.subscriptionNeedsCancel = False
            tSubscription.put()

            tSubscriber = VipSubscriber()
            tSubscriber.subscriberActiveSubscription = ""
            tSubscriber.subscriberHasActiveSubscription = False
            tSubscriber.put()

        return tResponse
示例#15
0
    def GetContext(self):
        tUser = self.GetUser()

        tCustomerOrders = []
        tOrderData = {}
        tContext = {}

        tOrder = Order()
        tCustomer = Customer()
        tIpHandler = IpLookup()
        tIpInfo = IpInfo()

        tDeliveryAgent = Agent()
        tRefundAgent = Agent()
        tAssignedAgent = Agent()

        tPriceDic = PriceContainer.GetCurrentPriceDic()
        tCountryDic = CountryContainer.GetCurrentCountryCodes()
        tOrderKey = str(urllib.unquote(self.request.get('key')))

        if (tOrderKey != None and len(tOrderKey) > 0):
            tOrder = Order.get(tOrderKey)
        if (tOrder):
            tOrderHandler = OrderHandler()

            tResultDictionary = {}
            tPaypalPayload = {}
            tPayload = {}

            tUrl = "https://api-3t.paypal.com/nvp"
            tOperation = "GetTransactionDetails"
            tCustomer = Customer.get(tOrder.orderCustomer)

            # disabled to try to trace the "empty order" bug
            #if tOrder.orderVerificationCode is None:
            #tOrder.orderVerificationCode = str(uuid.uuid4())
            #tOrder.put()

            try:
                tIpInfo = tIpHandler.GetIp(tOrder.orderIp)[0]
            except:
                tIpInfo.ipCountry = "Loading"
                tIpInfo.ipState = "Loading"
                tIpInfo.ipHost = "Loading"
                tIpInfo.ipProxy = "Loading"
                tIpInfo.ipIsp = "Loading"
                tIpInfo.ipType = "Loading"

            if (tIpInfo.ipProxy == ""):
                tIpInfo.ipProxy = 'No Proxy'
            tContext['tDisplayDeliver'] = 'True'

            #Get Paypal Information
            tPaypalPayload['METHOD'] = tOperation
            tPaypalPayload['TRANSACTIONID'] = tOrder.orderTransactionId

            #logging.debug("Order Paypal Email: " + tOrder.orderPaypalEmail)

            try:
                tPayloadEncoded = tOrderHandler.GeneratePayload(tPaypalPayload)
                request_cookies = mechanize.CookieJar()
                request_opener = mechanize.build_opener(
                    mechanize.HTTPCookieProcessor(request_cookies))
                request_opener.addheaders = [
                    ('Content-Type', 'application/x-www-form-urlencoded')
                ]
                mechanize.install_opener(request_opener)
                tResponse = mechanize.urlopen(url=tUrl,
                                              timeout=25.0,
                                              data=tPayloadEncoded)
            except:
                tContext[
                    'error'] = 'Unable to Connect to Paypal, Try Refreshing'
                tContext['showerror'] = 'True'
                #tmpl = os.path.join(os.path.dirname(__file__), '../views/order.html')
                #self.response.out.write(render(tmpl, tContext))
                return tContext

            tResult = str(urllib.unquote(tResponse.read()))
            tResultSplit = tResult.split('&')

            for tPair in tResultSplit:
                tSplitPair = tPair.split("=")
                try:
                    tResultDictionary[tSplitPair[0]] = tSplitPair[1]
                    #logging.debug(tSplitPair[0] + "    " + tSplitPair[1])
                except:
                    logging.error("Error splitting item: " + str(tPair))

            if ('COUNTRYCODE' in tResultDictionary.keys()):
                tCountryCode = tResultDictionary['COUNTRYCODE']
                tPaypalCountry = tCountryDic[tCountryCode]
            else:
                tPaypalCountry = 'UNKNOWN'

            tOrderData['paypalcountry'] = tPaypalCountry

            if 'PROTECTIONELIGIBILITYTYPE' in tResultDictionary.keys():
                tProtectionEligibility = tResultDictionary[
                    'PROTECTIONELIGIBILITYTYPE']

                if tProtectionEligibility == 'ItemNotReceivedEligible,UnauthorizedPaymentEligible':
                    tProtectionEligibility = 'Eligible'

                if tProtectionEligibility != 'Eligible':
                    tProtectionEligibility = 'Not Eligible'

                tContext['PROTECTIONELIGIBILITYTYPE'] = tProtectionEligibility
            else:
                tProtectionEligibility = 'UNKNOWN'

            #Display address fields
            if 'ADDRESSSTATUS' in tResultDictionary.keys():
                tContext['ADDRESSSTATUS'] = tResultDictionary['ADDRESSSTATUS']
            else:
                tContext['ADDRESSSTATUS'] = 'UNKNOWN'

            if 'SHIPTONAME' in tResultDictionary.keys():
                tContext['SHIPTONAME'] = tResultDictionary['SHIPTONAME']
            else:
                tContext['SHIPTONAME'] = 'UNKNOWN'

            if 'SHIPTOSTREET' in tResultDictionary.keys():
                tContext['SHIPTOSTREET'] = tResultDictionary['SHIPTOSTREET']
            else:
                tContext['SHIPTOSTREET'] = 'UNKNOWN'

            if 'SHIPTOSTREET2' in tResultDictionary.keys():
                tContext['SHIPTOSTREET2'] = tResultDictionary['SHIPTOSTREET2']
            else:
                tContext['SHIPTOSTREET2'] = 'UNKNOWN'

            if 'SHIPTOCITY' in tResultDictionary.keys():
                tContext['SHIPTOCITY'] = tResultDictionary['SHIPTOCITY']
            else:
                tContext['SHIPTOCITY'] = 'UNKNOWN'

            if 'SHIPTOSTATE' in tResultDictionary.keys():
                tContext['SHIPTOSTATE'] = tResultDictionary['SHIPTOSTATE']
            else:
                tContext['SHIPTOSTATE'] = 'UNKNOWN'

            if 'SHIPTOZIP' in tResultDictionary.keys():
                tContext['SHIPTOZIP'] = tResultDictionary['SHIPTOZIP']
            else:
                tContext['SHIPTOZIP'] = 'UNKNOWN'

            if 'SHIPTOCOUNTRYCODE' in tResultDictionary.keys():
                tContext['SHIPTOCOUNTRYCODE'] = tResultDictionary[
                    'SHIPTOCOUNTRYCODE']
            else:
                tContext['SHIPTOCOUNTRYCODE'] = 'UNKNOWN'

            if 'SHIPTOPHONENUM' in tResultDictionary.keys():
                tContext['SHIPTOPHONENUM'] = tResultDictionary[
                    'SHIPTOPHONENUM']
            else:
                tContext['SHIPTOPHONENUM'] = 'UNKNOWN'

            #Get order amount to add to dated totals
            tCurrentCost = float(tOrder.orderCost)

            #Get date 30 days ago
            tStartDate = tOrder.orderCreated
            tIncrement = datetime.timedelta(days=-30)
            tEndDate = tStartDate + tIncrement
            tCustomerOrderQuery = Order.all()
            tCustomerOrderQuery.filter("orderCreated >", tEndDate)
            tCustomerOrderQuery.filter("orderCustomer", tOrder.orderCustomer)
            tCustomerOrderQuery.filter("orderDeliver", 'True')
            tCustomerOrders = tCustomerOrderQuery.fetch(1000)
            #logging.debug("30 day date: " + str(tEndDate))
            #logging.debug("30 day orders: " + str(len(tCustomerOrders)))
            tCustomerOrderTotal = 0.0
            for tCustomerOrder in tCustomerOrders:
                tCustomerOrderTotal += float(tCustomerOrder.orderCost)
            if (tOrder.orderDeliver == 'False'):
                tCustomerOrderTotal += tCurrentCost
            tOrderData['orderTotal'] = str("%.2f" % tCustomerOrderTotal)

            #Get date 24 hours ago
            tStartDate = tOrder.orderCreated
            tIncrement = datetime.timedelta(days=-1)
            tEndDate = tStartDate + tIncrement
            tCustomerOrderQuery = Order.all().filter("orderCreated >",
                                                     tEndDate)
            tCustomerOrderQuery.filter("orderCustomer", tOrder.orderCustomer)
            tCustomerOrderQuery.filter("orderDeliver", 'True')
            tCustomerOrders = tCustomerOrderQuery.fetch(1000)
            #logging.debug("24 hour date: " + str(tEndDate))
            #logging.debug("24 hour orders: " + str(len(tCustomerOrders)))
            tCustomerOrderTotal24 = 0.0
            for tCustomerOrder in tCustomerOrders:
                tCustomerOrderTotal24 += float(tCustomerOrder.orderCost)

            if (tOrder.orderDeliver == 'False'):
                tCustomerOrderTotal24 += tCurrentCost
            tOrderData['orderTotal24'] = str("%.2f" % tCustomerOrderTotal24)

            #Get date 15 days ago
            tStartDate = tOrder.orderCreated
            tIncrement = datetime.timedelta(days=-15)
            tEndDate = tStartDate + tIncrement
            tCustomerOrderQuery = Order.all().filter("orderCreated >",
                                                     tEndDate)
            tCustomerOrderQuery.filter("orderCustomer", tOrder.orderCustomer)
            tCustomerOrderQuery.filter("orderDeliver", 'True')
            tCustomerOrders = tCustomerOrderQuery.fetch(1000)
            #logging.debug("15 day date: " + str(tEndDate))
            #logging.debug("15 day orders: " + str(len(tCustomerOrders)))
            tCustomerOrderTotal15 = 0.0
            for tCustomerOrder in tCustomerOrders:
                tCustomerOrderTotal15 += float(tCustomerOrder.orderCost)

            if (tOrder.orderDeliver == 'False'):
                tCustomerOrderTotal15 += tCurrentCost
            tOrderData['orderTotal15'] = str("%.2f" % tCustomerOrderTotal15)

            #===== Begin Location Matching =====
            try:
                tPhoneHandler = PhoneLookup()
                tPhoneInfo = tPhoneHandler.GetPhone(tOrder.orderCustomer)[0]
            except:
                tPhoneInfo = Phone()
                tPhoneInfo.phoneState = "Unknown"
                tPhoneInfo.phoneCountry = "Unknown"

            #logging.debug("Ip country: " + str(tIpInfo.ipCountry))
            #logging.debug("Paypal country: " + str(tPaypalCountry))

            if (str(tIpInfo.ipCountry) == str(tPaypalCountry)):
                tOrderData['locationmatch'] = 'True'
            else:
                tOrderData['locationmatch'] = 'False'

            if (str(tIpInfo.ipCountry) == "United Kingdom"
                    and str(tPaypalCountry) == "Great Britain (UK)"):
                tOrderData['locationmatch'] = 'True'

            #Agent Instructions
            #logging.debug("Order Total 24: " + str(tCustomerOrderTotal24))
            #logging.debug("Order Total: " + str(tCustomerOrderTotal))
            #logging.debug("Customer email verified: " + str(tCustomer.customerEmailVerified))
            #logging.debug("Customer phone verified: " + str(tCustomer.customerPhoneVerified))
            #logging.debug("Customer id verified: " + str(tCustomer.customerIdVerified))

            #Protection Eligibility Filter
            tCountryEligibilityCode = tContext['SHIPTOCOUNTRYCODE']
            tOrderData[
                'instructions'] = "No verification required"  # default value
            if tCountryEligibilityCode in ('US', 'UK', 'CA', 'GB'):
                if tOrder.orderCost > 10:
                    if tProtectionEligibility == 'Eligible':
                        if tCustomerOrderTotal24 > 1000.0 or tCustomerOrderTotal > 4000.0:
                            tOrderData[
                                'instructions'] = "<span style='color:red'>$$$ Call Corowns $$$</span>"
                    else:  # not payment eligible
                        tOrderData[
                            'instructions'] = "<span style='color:red'>Refund - No Seller Protection</span>"
                        tContext['tDisplayDeliver'] = 'False'
            else:  # international customer
                #if( tCustomerOrderTotal24 < 30.0 and tCustomerOrderTotal < 60.0):

                if tIpInfo.ipType == "Corporate":
                    tOrderData['instructions'] = tOrderData[
                        'instructions'] + "<br /><span style='color:red'>Refer to PA - Corporate IP</span>"
                    tOrderData['tDisplayDeliver'] = 'False'

                if (tIpInfo.ipProxy):
                    if ("Confirmed proxy server" == tIpInfo.ipProxy):
                        tOrderData['instructions'] = tOrderData[
                            'instructions'] + "<br /><span style='color:red'>Refer to PA - Proxy</span>"
                        tContext['tDisplaydeliver'] = 'False'

                if tCustomerOrderTotal24 > 200.0 or tCustomerOrderTotal > 400.0:
                    tOrderData[
                        'instructions'] = "<span style='color:red'>Refer to PA - Limit Exceeded</span>"
                    tOrderData['tDisplayDeliver'] = 'False'
                elif tCustomerOrderTotal24 > 90.0 or tCustomerOrderTotal > 180.0:
                    if tCustomer.customerIdVerified != True:
                        tOrderData[
                            'instructions'] = "<span style='color:red'>Verify Photo ID</span>"
                elif tCustomerOrderTotal24 > 30.0 or tCustomerOrderTotal > 60.0:
                    if tCustomer.customerPhoneVerified != True:
                        tOrderData[
                            'instructions'] = "<span style='color:red'>Verify Phone Number</span>"

            if (tOrderData['locationmatch'] != 'True'):
                tOrderData['instructions'] = tOrderData[
                    'instructions'] + "<br /><span style='color:red'>Verify Country Match</span>"

            #logging.debug("Order Data Instructions: " + str(tOrderData['instructions']))
            #logging.debug("Location Match" + str(tOrderData['locationmatch']))

            tCustomerOrderQuery = db.GqlQuery(
                "SELECT * FROM Order WHERE orderCustomer = '" +
                tOrder.orderCustomer + "'")
            tTotalCustomerOrders = []
            tTotalCustomerOrders = tCustomerOrderQuery.fetch(50)
            for tCustomerOrder in tTotalCustomerOrders:
                if (tCustomerOrder.orderChargeback == True):
                    tChargeBack = True
                else:
                    tChargeBack = False

            tOrderData['chargeback'] = tChargeBack if (tChargeBack) else False
            tOrderData['chargeback'] = str(tOrderData['chargeback'])

            tIpChargebacks = tIpHandler.GetChargebacks(tOrder.orderIp)
            tOrderData['ipchargeback'] = len(tIpChargebacks)

            try:
                tTotalBonusString = NumberToGp.ConvertIntToBet(
                    int(tOrder.orderBonusQuantity))
                #logging.debug("Total Bonus String " + tTotalBonusString)
            except:
                tTotalBonusString = ""

            if (tCustomer.customerIsPaBlacklisted == True):
                tOrderData['instructions'] = tOrderData[
                    'instructions'] + "<br /><span style='color:red'>Refer to PA - Blacklist</span>"
                tContext['tDisplayDeliver'] = 'False'

            if (tCustomer.customerIsGlobalBlacklisted == True):
                tOrderData['instructions'] = tOrderData[
                    'instructions'] + "<br /><span style='color:red'>Do Not Deliver - Blacklist</span>"
                tContext['tDisplayDeliver'] = 'False'

            #normalize unicode
            try:
                tSimpleGold = unicodedata.normalize(
                    "NFC",
                    tOrder.orderSimpleGoldAmount).encode("ascii", "ignore")
            except:
                tSimpleGold = tOrder.orderSimpleGoldAmount

            #logging.debug(str(tPriceDic[tSimpleGold]))
            #logging.debug(str(tOrder.orderCost))
            tCurrentEocPrices = PriceContainer.GetCurrentPriceDic()
            tCurrent07Prices = PriceContainer.GetCurrentPriceDic07()

            #logging.debug(str(tCurrent07Prices))
            #logging.debug(str(tCurrentEocPrices))

            tSkip07 = False
            tValidOrder = False
            if tOrder.orderSimpleGoldAmount in tCurrentEocPrices.keys():
                if str(tOrder.orderCost) == str(
                        tCurrentEocPrices[tOrder.orderSimpleGoldAmount]):
                    tOrder.orderGoldType = 'eoc'
                    tSkip07 = True
                    tValidOrder = True

            if not tSkip07:
                if tOrder.orderSimpleGoldAmount in tCurrent07Prices.keys():
                    if str(tOrder.orderCost) == str(
                            tCurrent07Prices[tOrder.orderSimpleGoldAmount]):
                        tOrder.orderGoldType = '07'
                        tValidOrder = True

            #logging.debug("skip07 {}".format(tSkip07))
            #logging.debug("valid {}".format(tValidOrder))
            #logging.debug("order simple gold amount {}".format(tOrder.orderSimpleGoldAmount))
            #logging.debug("order value {}".format(tOrderData['orderTotal']))
            #logging.debug("gold type {}".format(tContext['gold_type']))

            if not tValidOrder:
                tOrderData['instructions'] = tOrderData[
                    'instructions'] + '<br /><span style="color:red">Do Not Deliver - Bad Payment</span>'
                #tOrderData['tDisplayDeliver'] = 'False'
                #tOrder.orderLocked = 'True'
                #tOrder.put()

            #logging.debug(str(tOrder.orderIsGenerated))
            if (tOrder.orderIsGenerated == True):
                tOrder.orderLocked = 'False'
                tOrder.orderIsRefunded = 'False'
                tOrder.orderDeliver = 'False'
                tOrderData['tDisplayDeliver'] = 'True'

            try:
                tDeliveryAgent = Agent.GetAgentByEmail(
                    tOrder.orderDeliveryAgent)
                tContext['tDeliveryAgent'] = tDeliveryAgent
            except:
                pass

            try:
                tAssignedAgent = Agent.GetAgentByEmail(
                    tOrder.orderAssignedAgent)
                tContext['tAssignedAgent'] = tAssignedAgent
            except:
                pass

            try:
                tRefundAgent = Agent.GetAgentByEmail(tOrder.orderRefundAgent)
                tContext['tRefundAgent'] = tRefundAgent
            except:
                pass
            tOrderData['bonus'] = tTotalBonusString

            tOrderData['phoneverified'] = str(tCustomer.customerPhoneVerified)
            tOrderData['emailverified'] = str(tCustomer.customerEmailVerified)
            tOrderData['idverified'] = str(tCustomer.customerIdVerified)

            tContext['tOrder'] = tOrder
            tContext['tOrderData'] = tOrderData
            tContext['tCustomer'] = tCustomer
            tContext['tIpInfo'] = tIpInfo
            tContext['tPhoneInfo'] = tPhoneInfo

        if ((tOrder.orderDeliveryAgent == ""
             or tOrder.orderDeliveryAgent == None)
                and tOrder.orderDeliver == 'True'):
            tAgentKey = tOrder.orderAgent
            tAgentId = Agent()
            tAgentId = Agent.get(tAgentKey)
            tOrder.orderDeliveryAgent = str(tAgentId.agentId)

        #logging.debug(str(tOrderData))
        return tContext