def create(self, validated_data):

        consumptions_data_check = validated_data.get('withdraw_lines')

        tracks_data = validated_data.pop('withdraw_lines')

        transaction = Transaction.objects.create(
            types=1,
            created_user=self.context['request'].user,
            last_modified_users=self.context['request'].user,
            **validated_data)
        transaction.created_date = validated_data["date"]
        transaction.save()
        for track_data in tracks_data:
            withdraw_instance = WithdrawDetail.objects.create(
                transaction=transaction,
                created_user=self.context['request'].user,
                last_modified_users=self.context['request'].user,
                **track_data)
            withdraw_instance.created_date = validated_data["date"]
            withdraw_instance.save()

            if withdraw_instance != None:
                withdraw_stock(track_data, withdraw_instance, 1)

        if 'test' not in sys.argv:
            transaction_log_sync()
        return transaction
Esempio n. 2
0
    def create(self, validated_data):
        consumptions_data_check = validated_data.get('return_lines')

        tracks_data = validated_data.pop('return_lines')
        transaction = Transaction.objects.create(types=3, created_user=self.context['request'].user,
                                                 last_modified_users=self.context['request'].user, **validated_data)
        transaction.created_date = validated_data["date"]
        transaction.save()

        for track_data in tracks_data:

            if track_data.get("array") != None:
                array = track_data.pop("array")
            else:
                array = None

            return_instance = ReturnDetail.objects.create(transaction=transaction,
                                                          created_user=self.context['request'].user,
                                                          last_modified_users=self.context['request'].user,
                                                          **track_data)
            return_instance.created_date = validated_data["date"]
            return_instance.save()

            if return_instance != None:
                if array != None:
                    withdraw_stock_withoutfifo(track_data, return_instance, 3, array)
                else:
                    withdraw_stock(track_data, return_instance, 3)

        if 'test' not in sys.argv:
            transaction_log_sync()
        return transaction
Esempio n. 3
0
def tradeOperation(request, *args, **kwargs):
    initParam = kwargs.get('initParam')
    transaction = kwargs.get('transaction')
    if transaction and request.method == 'POST':
        delivery = request.POST.get('delivery')
        if delivery and delivery == 'confirm_delivery':
            if transaction.status == 3:
                transaction.status = 4
                transaction.end_time = datetime.datetime.now()
                transaction.save()
                #Log transaction
                transactionsLog = models.TransactionLog()
                transactionsLog.transaction = transaction
                transactionsLog.app = transaction.app
                transactionsLog.status = transaction.status
                transactionsLog.buyer = transaction.buyer
                transactionsLog.save()
                #Send email to seller and buyer
                notificationViews.closedTradeInform(transaction=transaction)
                return transaction
            else:
                initParam['error_msg'] = _('Transaction can not be confirmed delivery.')
                log.error(_('Transaction: %(param1)s, status: %(param2)s can not confirm delivery.')
                      % {'param1': transaction.id, 'param2': transaction.status})
        #TODO:if no complain, then increase credit point.
        #Increase seller and buyer credit point
        # point = common.getSystemParam(key='cp_closed_trade', default=50)
        # creditViews.increaseCreditPoint(user=transaction.buyer, point=point)
        # creditViews.increaseCreditPoint(user=transaction.seller, point=point)
    return None
Esempio n. 4
0
def get_platform_wallet():
    """
    Returns the wallet used by the platform to transfer bitcoins
    to other wallets of the platform, or to receive bitcoins from
    profits.
    """
    platform_user = get_platform_user()
    last_updated = timezone.now()
    platform_wallet, created = Wallet.objects.get_or_create(
        address=settings.PLATFORM_WALLET_ADDRESS,
        user=platform_user,
        defaults={
            "address": settings.PLATFORM_WALLET_ADDRESS,
            "user": platform_user,
            "alias": "Platform Wallet",
            "last_updated": last_updated,
        },
    )
    # Add some BTCs
    transaction = Transaction(
        wallet_to=platform_wallet,
        transaction_type=Transaction.PLATFORM,
        amount=1000,
        details="Initial funds",
        created_at=last_updated,
    )
    transaction.save()
    return platform_wallet
Esempio n. 5
0
def initTransaction(request, *args, **kwargs):
    """Init transaction model data, when seller pay the service fee."""
    app = kwargs.get('app')
    if app:
        transactions = models.Transaction.objects.filter(app_id=app.id, seller_id=request.user.id, is_active=True)
        if transactions:
            transaction = transactions[0]
            transaction.buyer = None
            transaction.price = None
            transaction.end_time = None
            transaction.buy_type = None
            transaction.seller_price = None
            transaction.appswalk_price = None
            transaction.gateway = None
            transaction.buyer_account = None
            transaction.seller_account = None
            transaction.appswalk_account = None
            transaction.pay_key = None
        else:
            transaction = models.Transaction()
            transaction.app = app
            transaction.seller = request.user
            transaction.is_active = True
        transaction.status = 1
        transaction.save()
    return transaction
Esempio n. 6
0
def create_recurring_exchanges():
    messages = []
    for repeat_period in ledger.RepeatPeriod.objects.filter(active=True):
        exchange = repeat_period.exchanges.order_by('-date').select_related()[0]
        transactions = exchange.transactions.all()
        while exchange.date + repeat_period.delta() <= datetime.date.today():
            exchange.id = None
            exchange.date += repeat_period.delta()
            if exchange.date_due:
                exchange.date_due += repeat_period.delta()
            exchange.delivered = False
            exchange.save(force_insert=True)
            url_kwargs = {
                'exchange_id': exchange.id,
                'exchange_type_slug': exchange.type.slug,
            }
            
            messages.append('%s%s' % (
                settings.APP_URL_BASE,
                reverse('edit_exchange', kwargs=url_kwargs),
            ))
            for transaction in transactions:
                transaction.id = None
                transaction.exchange = exchange
                transaction.date = exchange.date
                transaction.debit_reconciled = False
                transaction.credit_reconciled = False
                transaction.save(force_insert=True)
    
    if messages:
        messages.insert(0, 'created the following exchanges:')
    return messages
Esempio n. 7
0
    def on_commit():
        instance = kwargs.get('instance')
        if instance:
            if instance.status == "Accepted":
                transaction_tag = "bank_payment_{id}".format(id=instance.id)
                if Transaction.objects.filter(
                        identifiers__value=transaction_tag).exists():
                    transactions = Transaction.objects.filter(
                        identifiers__value=transaction_tag)
                    for tran in transactions:
                        tran.delete()

                transaction = Transaction.objects.create(
                    debit=True,
                    pocket=instance.pocket,
                    amount=instance.amount,
                    datetime=datetime.now())

                tag = UniqueIdentifier.objects.get_or_create(
                    name="transaction_tag", value=transaction_tag)[0]
                transaction.identifiers.add(tag)
                instance.identifiers.add(tag)
                instance.transactions.add(transaction)

            elif instance.status in ["Declined", "Canceled"]:
                for transaction in instance.transactions.all():
                    transaction.active = False
                    transaction.save()
Esempio n. 8
0
def tradeOperation(request, *args, **kwargs):
    initParam = kwargs.get('initParam')
    transaction = kwargs.get('transaction')
    if transaction and request.method == 'POST':
        delivery = request.POST.get('delivery')
        if delivery and delivery == 'confirm_delivery':
            if transaction.status == 3:
                transaction.status = 4
                transaction.end_time = datetime.datetime.now()
                transaction.save()
                #Log transaction
                transactionsLog = models.TransactionLog()
                transactionsLog.transaction = transaction
                transactionsLog.app = transaction.app
                transactionsLog.status = transaction.status
                transactionsLog.buyer = transaction.buyer
                transactionsLog.save()
                #Send email to seller and buyer
                notificationViews.closedTradeInform(transaction=transaction)
                return transaction
            else:
                initParam['error_msg'] = _(
                    'Transaction can not be confirmed delivery.')
                log.error(
                    _('Transaction: %(param1)s, status: %(param2)s can not confirm delivery.'
                      ) % {
                          'param1': transaction.id,
                          'param2': transaction.status
                      })
        #TODO:if no complain, then increase credit point.
        #Increase seller and buyer credit point
        # point = common.getSystemParam(key='cp_closed_trade', default=50)
        # creditViews.increaseCreditPoint(user=transaction.buyer, point=point)
        # creditViews.increaseCreditPoint(user=transaction.seller, point=point)
    return None
Esempio n. 9
0
def closedTrade(request, *args, **kwargs):
    """Need update end_time to now."""
    initParam = {}
    transaction = get_object_or_404(models.Transaction,
                                    pk=kwargs.get('txn_id'),
                                    buyer_id=kwargs.get('buyer_id'),
                                    is_active=True)
    transaction.status = 4
    transaction.end_date = datetime.datetime.now()
    transaction.save()
    #Log transaction
    transactionsLog = models.TransactionLog()
    transactionsLog.transaction = transaction
    transactionsLog.app = transaction.app
    transactionsLog.status = transaction.status
    transactionsLog.buyer = transaction.buyer
    transactionsLog.save()
    #Increase seller and buyer credit point
    point = common.getSystemParam(key='cp_closed_trade', default=50)
    creditViews.increaseCreditPoint(user=transaction.buyer, point=point)
    creditViews.increaseCreditPoint(user=transaction.seller, point=point)
    #Send email to seller and buyer
    notificationViews.closedTradeInform(transaction=transaction)

    initParam['transaction'] = transaction
    return render_to_response('transaction/trade_action.html',
                              initParam,
                              context_instance=RequestContext(request))
Esempio n. 10
0
 def CreateDebit(user, fromAccountNumber, amount):
     print("Do Debit Here")
     try:
         amount = int(amount.strip())
         fromAccountNumber = int(fromAccountNumber.strip())
     except:
         raise SecureBankException(
             'Error in format of account number/amount')
     if (amount <= 0):
         raise SecureBankException('Negative Ammount')
     fromAccount = Account.objects.filter(AccountNumber=fromAccountNumber)
     if len(fromAccount) == 0:
         raise SecureBankException("Account belongs to someone else")
     fromAccount = fromAccount[0]
     if fromAccount.AccountHolder.user.username != user.username:
         raise SecureBankException("Trying to access someones else account")
     if fromAccount.Balance < amount:
         raise SecureBankException("Insufficient Funds")
     #STATUS as O - OTP
     transaction = Transaction(FromAccount=fromAccount,
                               ToAccount=None,
                               Amount=amount,
                               Status='O',
                               Type='D')
     #fromAccount.Debit(amount)
     transaction.save()
     print("Done")
     return transaction
Esempio n. 11
0
    def post(self, request, pk):
        caterer = get_object_or_404(Caterer, pk=pk)
        consumer = get_object_or_404(Consumer,
                                     pk=self.request.user.catruser.id)

        try:
            transaction = consumer.history.transaction_set\
                                  .exclude(tray__exact=None)\
                                  .get(caterer_id=caterer.id)

        except (KeyError, Transaction.DoesNotExist):
            transaction = Transaction(transaction_date=timezone.now())
            tray = Tray(tray_cumulative_price=0, created_date=timezone.now())
            tray.save()
            transaction.transaction_is_completed = False
            transaction.tray = tray
            transaction.history = consumer.history
            transaction.caterer = caterer
            transaction.save()

        tray = transaction.tray

        # find the key that matches an integer, which should be the menu_id

        for key in request.POST:
            if re.match("^[0-9]+$", key):
                try:
                    menu_id = int(key)
                    queried_menu_item = get_object_or_404(Menu, pk=menu_id)
                    pass

                except (KeyError, Menu):
                    return render(
                        request, 'orders/book.html', {
                            'menu':
                            Menu.objects.filter(caterer_id=caterer.id),
                            'packages': [
                                menu.package for menu in
                                caterer.menu_set.distinct('package')
                            ],
                            'item_set':
                            tray.item_set.all(),
                            'tray':
                            tray
                        })

                else:
                    item = Item()
                    item.menu = queried_menu_item
                    tray.tray_cumulative_price += Decimal(request.POST[key +
                                                                       'x'])
                    tray.save()
                    item.tray = tray
                    item.item_quantity = request.POST[key + 'z']
                    # logger.error(tray)
                    # logger.error(item.tray)
                    item.save()
                    # logger.error(item.tray.tray_cumulative_price)

        return redirect(reverse('orders:book', args=(pk, )))
Esempio n. 12
0
    def awaiting_deposit(self, request, pk=None, deposit_pk=None, **kwargs):
        """
        Gets or updates awaiting deposit by id.
        """
        goal = self.get_object()

        sr_id = SupportRequest.get_current(request)
        try:
            transaction = Transaction.objects.get(
                Q(pk=deposit_pk),
                Q(status=Transaction.STATUS_AWAITING_APPROVAL),
                Q(to_goal=goal))
        except ObjectDoesNotExist:
            raise ValidationError(
                'Can not find specified awaiting one-time deposit')

        if request.method == 'GET':
            serializer = serializers.TransactionSerializer(transaction)
            headers = self.get_success_headers(serializer.data)
            return Response(serializer.data,
                            status=status.HTTP_200_OK,
                            headers=headers)
        elif request.method == 'PUT':
            client = goal.account.primary_owner
            site = get_current_site(request)

            serializer = serializers.TransactionSerializer(transaction,
                                                           data=request.data)
            serializer.is_valid(raise_exception=True)
            if site.config().plaid_enabled:
                # make sure user has connected a plaid_user
                target_user = client.user
                plaid_user = getattr(target_user, 'plaid_user', False)
                if not plaid_user:
                    logger.error(
                        'Deposit attempted by %s but no plaid_user found' %
                        request.user)
                    raise ValidationError('Client has no plaid_user linked')

                if not serializer.validated_data.get('account_id', False):
                    logger.error(
                        'No plaid account_id sent with deposit request')
                    raise ValidationError(
                        'No plaid account_id sent with deposit request')

            transaction = serializer.save()
            transaction.save()

            # TODO: Check whether other event log type is required for deposit update
            Event.GOAL_DEPOSIT.log('{} {}'.format(request.method,
                                                  request.path),
                                   request.data,
                                   user=request.user,
                                   obj=goal,
                                   support_request_id=sr_id)

            headers = self.get_success_headers(serializer.data)
            return Response(serializer.data,
                            status=status.HTTP_200_OK,
                            headers=headers)
Esempio n. 13
0
 def post(self, request, _id):
     user = request.yoo["user"]
     
     ticket = LotteryTicket.objects.get(pk=_id)
     
     if ticket.user != user:
         raise exceptions.WebServiceAuthorizationFailed()
     
     try:
         data = json.loads(request.body)
     except:
         data = {}
     
     type = data.get("type", None)
     if type not in ["facebook", "twitter"]:
         raise exceptions.WebServiceException("Unsupported Share Type")
     
     if not ticket.coin_share_transaction.filter(type=type).exists():
         parent = CoinTransaction(wallet=user.get_wallet())
         parent.save()
         
         transaction = CoinShareTransaction(ticket=ticket, type=type, transaction=parent)
         transaction.save()
         
         parent.amount = transaction.amount
         parent.save()
         
     return self.get(request, _id)
 def _handle_error(cls, transaction, message):
     transaction.status_message = message
     transaction.status = Transaction.STATUS.error
     transaction.pending_execution_attempt = False
     transaction.save()
     logger.error(transaction.status_message)
     maybe_make_callback(transaction)
Esempio n. 15
0
def transaction_detail(request, id):
    transaction = Transactions.objects.filter(id=id).first()
    alert = False
    if request.POST:
        comments = request.POST.get("comments")
        transaction.comments = comments
        transaction.save()
        alert = True
    account = 'GS' if transaction.vendor == GS else 'SSB'
    total = transaction.total
    trader_total = transaction.trader_total
    exception = abs(total - trader_total)
    status = 'matched' if trader_total == total else 'not matched'
    status_class = 'matched-transaction' if trader_total == total else 'unmatched-transaction'
    date = transaction.date
    idx = transaction.id
    comments = transaction.comments or ''
    return render(
        request, "transactiondetail.html", {
            'account': account,
            'total': total,
            'trader_total': trader_total,
            'exception': exception,
            'status': status,
            'date': date,
            'status_class': status_class,
            'idx': idx,
            'comments': comments,
            'alert': alert
        })
Esempio n. 16
0
def initTransaction(request, *args, **kwargs):
    """Init transaction model data, when seller pay the service fee."""
    app = kwargs.get('app')
    if app:
        transactions = models.Transaction.objects.filter(
            app_id=app.id, seller_id=request.user.id, is_active=True)
        if transactions:
            transaction = transactions[0]
            transaction.buyer = None
            transaction.price = None
            transaction.end_time = None
            transaction.buy_type = None
            transaction.seller_price = None
            transaction.appswalk_price = None
            transaction.gateway = None
            transaction.buyer_account = None
            transaction.seller_account = None
            transaction.appswalk_account = None
            transaction.pay_key = None
        else:
            transaction = models.Transaction()
            transaction.app = app
            transaction.seller = request.user
            transaction.is_active = True
        transaction.status = 1
        transaction.save()
    return transaction
Esempio n. 17
0
    def _update_decision(self, order, transaction, update):
        elems = update.xpath("*[local-name()='NewDecision']")
        if len(elems) <= 0:
            return
        new_decision = elems[0].text

        elems = update.xpath("*[local-name()='Reviewer']")
        reviewer = elems[0].text if len(elems) else ''

        elems = update.xpath("*[local-name()='ReviewerComments']")
        comments = elems[0].text if len(elems) else ''

        note = OrderNote()
        note.order = order
        note.note_type = OrderNote.SYSTEM
        note.message = '[Decision Manager] %s changed decision from %s to %s.\n\nComments: %s' % (
            reviewer, transaction.status, new_decision, comments)
        note.save()

        if new_decision != DECISION_ACCEPT:
            order.status = ORDER_STATUS_PAYMENT_DECLINED
            order.save()

        transaction.status = new_decision
        transaction.save()
Esempio n. 18
0
 def Create(user, fromAccountNumber, toAccountNumber, amount):
     print("create")
     try:
         amount = int(amount.strip())
         fromAccountNumber = int(fromAccountNumber.strip())
         toAccountNumber = int(toAccountNumber.strip())
     except:
         raise SecureBankException(
             'Error in format of account number/amount')
     if (amount <= 0):
         raise SecureBankException('Negative Ammount')
     fromAccount = Account.objects.filter(AccountNumber=fromAccountNumber)
     if len(fromAccount) == 0:
         raise SecureBankException("Account belongs to someone else")
     fromAccount = fromAccount[0]
     if fromAccount.AccountHolder.user.username != user.username:
         raise SecureBankException("Trying to access someones else account")
     if fromAccount.Balance < amount:
         raise SecureBankException("Insufficient Funds")
     toAccount = Account.objects.filter(AccountNumber=toAccountNumber)
     if len(toAccount) == 0:
         raise SecureBankException('Cannot send to this account')
     toAccount = toAccount[0]
     if fromAccount.AccountNumber == toAccount.AccountNumber:
         raise SecureBankException("Cannot transfer to same account")
     transaction = Transaction(FromAccount=fromAccount,
                               ToAccount=toAccount,
                               Amount=amount,
                               Status='O',
                               Type='T')
     print("Done")
     transaction.save()
     return transaction
    def _record_payment(self, order, token, request, reply_log_entry):
        source_type, created = SourceType.objects.get_or_create(name=settings.SOURCE_TYPE)
        source, created = Source.objects.get_or_create(order=order, source_type=source_type)
        source.currency = request.data.get('req_currency')
        source.amount_allocated += Decimal(request.data.get('auth_amount', '0'))
        source.save()

        transaction = Transaction()
        transaction.log = reply_log_entry
        transaction.source = source
        transaction.token = token
        transaction.txn_type = Transaction.AUTHORISE
        transaction.amount = request.data.get('req_amount', 0)
        transaction.reference = request.data.get('transaction_id')
        transaction.status = request.data.get('decision')
        transaction.request_token = request.data.get('request_token')
        transaction.processed_datetime = datetime.strptime(request.data.get('signed_date_time'), settings.DATE_FORMAT)
        transaction.save()

        event = PaymentEvent()
        event.order = order
        event.amount = request.data.get('auth_amount', 0)
        event.reference = request.data.get('transaction_id')
        event.event_type = PaymentEventType.objects.get_or_create(name=Transaction.AUTHORISE)[0]
        event.save()

        for line in order.lines.all():
            line_event = PaymentEventQuantity()
            line_event.event = event
            line_event.line = line
            line_event.quantity = line.quantity
            line_event.save()

        return transaction
Esempio n. 20
0
def edit_transaction(request, id=None):
    """
    Create or edit a transaction.
    """
    transaction = id and get_object_or_404(
        Transaction, pk=id, user=request.user)
    if request.method == 'POST':
        form = EditTransactionForm(request.user,
                                   instance=transaction,
                                   data=request.POST)
        if form.is_valid():
            transaction = form.save(commit=False)
            transaction.user = request.user
            transaction.save()
            form.save_m2m()
            return redirect(transaction)
    else:
        initial = {}
        if not transaction:
            initial['account'] = request.GET.get('account', None)
            initial['date'] = now()
        form = EditTransactionForm(request.user,
                                   instance=transaction,
                                   initial=initial)
    return render(
        request, 'pages/form.html', {
            'title':
            "{} Transaction".format("Edit" if transaction else "New"),
            'breadcrumbs':
            [transaction.account, transaction] if transaction else [],
            'form':
            form,
        })
Esempio n. 21
0
    def correct_transaction(self, transaction, update) -> None:
        FIELDS_ALLOWED_FOR_UPDATE = set([
            "executed_at",
            "quantity",
            "price",
            "local_value",
            "transaction_costs",
            "value_in_account_currency",
            "total_in_account_currency",
        ])
        for field in update.keys():
            if field not in FIELDS_ALLOWED_FOR_UPDATE:
                raise ValueError(
                    f"Correcting transaction with incorrect arguments,"
                    f"field: '{field}' not allowed ")
        position = transaction.position
        account = position.account

        position.quantity -= transaction.quantity
        account.balance -= transaction.total_in_account_currency

        for attr, value in update.items():
            setattr(transaction, attr, value)

        position.quantity += transaction.quantity
        account.balance += transaction.total_in_account_currency
        position.save()
        account.save()
        transaction.save()
        gains.update_lots(position)
        position.quantity_history.cache_clear()
        position.value_history.cache_clear()
Esempio n. 22
0
def unlink(request, id, id2):
    """
    Unlink a transaction
    """
    transaction = get_object_or_404(Transaction, pk=id, user=request.user)
    transaction2 = get_object_or_404(Transaction, pk=id2, user=request.user)
    if request.method == 'POST':
        form = DeleteForm(data=request.POST)
        if form.is_valid():
            transaction.links.remove(transaction2)
            transaction.save()
            return redirect(transaction)
    else:
        form = DeleteForm()
    return render(
        request, 'pages/delete.html', {
            'title':
            "Unlink Transaction",
            'description':
            "You are about to unlink {}. Links will be removed in both directions."
            .format(transaction2),
            'breadcrumbs': [transaction.account, transaction],
            'form':
            form,
        })
Esempio n. 23
0
def execBuy(request, context=None):
    #obj=stocks.objects.get(name=request.POST['choice'])

    buyer_user = User.objects.get(username=request.user)
    stockname,owner_username=request.POST['choice'].split()

    owner_user = getProfile2(owner_username).user
    startup_Profile=StartupProfile.objects.get(stockName=stockname)

    qtypurchase=float(request.POST['qty'+request.POST.get('choice')])

    if not isInvestor(buyer_user):
        raise Exception('You must be Investor')
    owner_onsale = onsale.objects.get(owner__username=owner_username, startup__stockName=stockname)
    try:
        owner_onsale=onsale.objects.get(owner__username=owner_username,startup__stockName=stockname)
        qtyonsale=owner_onsale.stockpercentage
        print 'raman'
        if qtyonsale is None:
            raise Exception('yo')
        typeOwner=isInvestor(owner_username)
    except:
        raise Exception("Not on sale")
    print(qtyonsale)
    print(qtypurchase)
    if qtyonsale<qtypurchase:
        raise Exception
    if qtypurchase<0:

        raise Exception
    ownerProfile=getProfile(owner_user)
    buyerProfile=getProfile(buyer_user)
    if ownerProfile is None:
        raise Exception
    if buyerProfile is None:
        raise Exception
    try:
        buyer_ownership=ownership.objects.get(owner=buyer_user,startup=startup_Profile)
    except:
        buyer_ownership=ownership()
        buyer_ownership.owner=buyer_user
        buyer_ownership.startup=startup_Profile
        buyer_ownership.sharepercentage=0
    owner_ownership=ownership.objects.get(owner=owner_user,startup=startup_Profile)
    buyer_ownership.sharepercentage=buyer_ownership.sharepercentage+qtypurchase
    owner_onsale.stockpercentage=owner_onsale.stockpercentage-qtypurchase
    owner_ownership.sharepercentage = owner_ownership.sharepercentage - qtypurchase

    buyer_ownership.save()
    print(buyer_ownership.sharepercentage)
    owner_ownership.save()
    owner_onsale.save()
    if(owner_onsale.stockpercentage==0):
        owner_onsale.delete()
    if (owner_ownership.sharepercentage == 0):
        owner_ownership.delete()
    transaction=transactions(owner=owner_user,buyer=buyer_user,stockpercentage=qtypurchase,stockprice=owner_onsale.stockprice,timestamp=datetime.now(),startup=startup_Profile)
    transaction.save()
    return redirect('/investor/')#render(request,'market/index.html',context)
Esempio n. 24
0
def unlink(request, id):
    """
    Unlink a transaction
    """
    transaction = get_object_or_404(Transaction, pk=id, user=request.user)
    transaction.linked = None
    transaction.save()
    return redirect(transaction)
Esempio n. 25
0
def unlink(request, id):
    """
    Unlink a transaction
    """
    transaction = get_object_or_404(Transaction, pk=id, user=request.user)
    transaction.linked = None
    transaction.save()
    return redirect(transaction)
Esempio n. 26
0
    def form_valid(self, form):
        transaction = self.get_transaction()
        transaction.save()
        self.object = form.save(commit=False)
        self.object.update_type = UpdateType.CREATE
        self.object.transaction = transaction
        self.object.save()

        return super().form_valid(form)
    def execute_deposits(cls):
        module = sys.modules[__name__]
        try:
            ready_transactions = PendingDeposits.get_ready_deposits()
        except Exception:
            logger.exception(
                "poll_pending_deposits() threw an unexpected exception")
            return
        for i, transaction in enumerate(ready_transactions):
            if module.TERMINATE:
                still_processing_transactions = ready_transactions[i:]
                Transaction.objects.filter(
                    id__in=[t.id
                            for t in still_processing_transactions]).update(
                                pending_execution_attempt=False)
                break
            cls.execute_deposit(transaction)

        with django.db.transaction.atomic():
            multisig_transactions = list(
                Transaction.objects.filter(
                    kind=Transaction.KIND.deposit,
                    status=Transaction.STATUS.pending_anchor,
                    pending_signatures=False,
                    pending_execution_attempt=False,
                ).select_for_update())
            Transaction.objects.filter(
                id__in=[t.id for t in multisig_transactions]).update(
                    pending_execution_attempt=True)

        for i, transaction in enumerate(multisig_transactions):
            if module.TERMINATE:
                still_processing_transactions = ready_transactions[i:]
                Transaction.objects.filter(
                    id__in=[t.id
                            for t in still_processing_transactions]).update(
                                pending_execution_attempt=False)
                break

            try:
                success = PendingDeposits.submit(transaction)
            except Exception as e:
                logger.exception("submit() threw an unexpected exception")
                transaction.status_message = str(e)
                transaction.status = Transaction.STATUS.error
                transaction.pending_execution_attempt = False
                transaction.save()
                maybe_make_callback(transaction)
                continue

            if success:
                transaction.refresh_from_db()
                try:
                    rdi.after_deposit(transaction)
                except Exception:
                    logger.exception(
                        "after_deposit() threw an unexpected exception")
Esempio n. 28
0
def executeOnePriceBuy(*args, **kwargs):
    """The operation of one price buy, after buyer payed successfully."""
    initParam = kwargs.get('initParam')
    transaction = initParam.get('transaction')
    if transaction:
        transaction.status = 3
        transaction.is_active = True
        txn_expiry_date = string.atoi(
            common.getSystemParam(key='txn_expiry_date', default=15))
        transaction.end_time = datetime.datetime.now() + datetime.timedelta(
            days=txn_expiry_date)
        transaction.buyer_account = initParam.get('buyer_account')
        acceptGateways = paymentModels.AcceptGateway.objects.filter(
            user_id=transaction.seller.id,
            type_id=transaction.gateway.id,
            is_active=True)
        transaction.seller_account = acceptGateways[0].value
        transaction.appswalk_account = settings.APPSWALK_ACCOUNT
        txn_fee_pct = string.atof(
            common.getSystemParam(key='txn_fee_pct', default=0.01))
        transaction.appswalk_price = transaction.price * txn_fee_pct
        transaction.seller_price = transaction.price * (1 - txn_fee_pct)
        transaction.save()
        #Log transaction
        transactionsLog = models.TransactionLog()
        transactionsLog.transaction = transaction
        transactionsLog.app = transaction.app
        transactionsLog.status = transaction.status
        transactionsLog.buyer = transaction.buyer
        transactionsLog.price = transaction.price
        transactionsLog.buyer_account = transaction.buyer_account
        transactionsLog.seller_account = transaction.seller_account
        transactionsLog.appswalk_account = transaction.appswalk_account
        transactionsLog.gateway = transaction.gateway
        transactionsLog.appswalk_price = transaction.appswalk_price
        transactionsLog.seller_price = transaction.seller_price
        transactionsLog.pay_key = transaction.pay_key
        transactionsLog.save()
        #Update app status and end_date.
        app = transaction.app
        if app.status == 2:
            app.status = 3
            app.end_date = datetime.datetime.now()
            app.save()

        #Send email to seller
        notificationViews.onePriceBuyInformSellerEmail(transaction=transaction)

        log.info(
            _('The transaction of one price buy with id %(param1)s is payed by %(param2)s.'
              ) % {
                  'param1': transaction.id,
                  'param2': transaction.buyer.username
              })
        return transaction
    return None
Esempio n. 29
0
 def _log_failed_mop_payment(self,message,token,communication_successful):
     transaction = Transaction(
         communication_successful = communication_successful,
         payment_successful = False,
         meal = self,
         gateway = 's',
         token = token,
         json_result = message
     )
     transaction.save()
Esempio n. 30
0
    def post(self, request):
        transaction = UnconfirmedTransactionSerializer(data=request.data)
        transaction.is_valid(raise_exception=True)
        transaction.save()

        # Mine a block if we have at least 10 transaction waiting
        if UnconfirmedTransaction.objects.count() >= 10:
            logger.info('At least 10 transactions waiting, mining new block.')
            mine_block()

        return Response()
Esempio n. 31
0
 def make_transaction(self,from_user, to_user, amount, reason):
     status = False
     if from_user.amount >= amount:
         from_user.amount -= amount
         to_user.amount += amount
         from_user.save()
         to_user.save()
         status = True
     transaction = Transaction(from_user=from_user.user, to_user=to_user.user, amount=amount, success=status, reason=reason)
     transaction.save()
     return transaction, status
Esempio n. 32
0
def make_transaction(request, amount):
    customer = Customer.objects.get(pk=request.user.id)
    customer.credit += amount
    transaction = Transaction()
    transaction.value = amount
    transaction.state = "D"
    transaction.transactions_type = "RCH"
    transaction.creator = customer
    customer.save()
    transaction.save()
    return transaction
Esempio n. 33
0
 def make_transaction(self,from_user, to_hotel, amount, reason):
     status = False
     if from_user.wallet >= amount:
         from_user.wallet -= amount
         to_hotel.wallet += amount
         from_user.save()
         to_hotel.save()
         status = True
     transaction = Transaction(from_user=from_user.user, to_hotel=to_hotel, amount=amount, success=status, reason=reason)
     transaction.save()
     self.send_email(transaction)
     return transaction, status
Esempio n. 34
0
 def  _log_successful_mop_payment(self,token,charge):
     transaction = Transaction(
         communication_successful = True,
         payment_successful = charge.paid,
         meal = self,
         amount = charge.amount,
         currency = charge.currency,
         gateway = 's',
         token = token,
         json_result = json.dumps(charge)
     )
     transaction.save()
Esempio n. 35
0
def transaction_view(request):
    user = request.user
    profile = Profile.objects.get(user=user)
    accounts = Account.objects.filter(account_user_fk=profile)
    # @transaction.atomic
    # Logic to get the balance from the current usery
    context = {
        "accounts": accounts,
    }

    if request.method == 'POST':
        account_sender = request.POST['account_number_sender']

        account_selected = Account.objects.get(account_number=account_sender)
        print(account_selected)
        receiver = request.POST['receiver']
        amount = request.POST['amount']
        if amount.isdigit():
            amount = int(amount)
            if account_selected.account_balance >= amount:
                transaction = Transaction()
                unique_id = get_random_string(length=20)
                # Getting the account data from the receiver
                transaction.transaction_account_number_sender = account_selected.account_number
                #should be autogenerate, check UUID
                transaction.transaction_user_account_fk = account_selected
                transaction.transaction_id = unique_id
                transaction.transaction_account_number_receiver = receiver
                try:
                    receiver_ = Account.objects.get(account_number=receiver)
                    transaction.transaction_amount = amount
                    transaction.transaction_currency = 'DKK'
                    balance_sender = account_selected.account_balance - amount
                    account_selected.account_balance = balance_sender
                    receiver_.account_balance = receiver_.account_balance + amount

                    receiver_.save()
                    account_selected.save()
                    transaction.save()
                    print('the balance of the sender is: ', balance_sender)
                    return HttpResponseRedirect('/transaction/confirmation/')

                except Account.DoesNotExist:
                    context = {'error': 'error', "accounts": accounts}
                    return render(request, 'transaction_app/transaction.html',
                                  context)

            else:
                #Should print some error message in the frontend, maybe with the if operator
                print("you don't have enough money")
        else:
            print('please enter a valid amount')
    return render(request, 'transaction_app/transaction.html', context)
Esempio n. 36
0
    def init_transaction(self, wallet_id_from, wallet_id_to, amount, message):
        # TODO: There are should be currency conversion (ignored for now)
        #  or restricted transactions between wallets in different curencies
        try:
            sender_wallet = self.wallet_set.get(wallet_id=wallet_id_from)
        except Wallet.DoesNotExist:
            logger.log(f'Wallet {wallet_id_from} is not your wallet!')
            raise
        else:
            system_wallet = Wallet.objects.get(
                account__user__is_superuser=True,
                currency=sender_wallet.currency)
            try:
                reciever_wallet = Wallet.objects.get(wallet_id=wallet_id_to)
            except Wallet.DoesNotExist:
                logger.log(f'Wallet {wallet_id_to} or '
                           f'{wallet_id_from} doesn`t exist!')
                raise
            else:
                transaction = fee = None
                if self == reciever_wallet.account:  # no fee
                    fee_amount = 0.0
                else:
                    fee_amount = amount * settings.SYSTEM_FEE
                    if sender_wallet.money >= amount + fee_amount:
                        fee = Transaction(from_wallet=sender_wallet,
                                          to_wallet=system_wallet,
                                          message=f'fee for '
                                          f'{sender_wallet.account}',
                                          amount=fee_amount)
                        fee.save()

                if sender_wallet.money >= amount + fee_amount:
                    transaction = Transaction(from_wallet=sender_wallet,
                                              to_wallet=reciever_wallet,
                                              fee=fee,
                                              message=message,
                                              amount=amount)
                    transaction.save()
                else:
                    error_message = f'You have not enough money in ' \
                                    f'{wallet_id_from}.'
                    logger.error(error_message)
                    raise NotEnoughMoneyError(error_message)

            sender_wallet.money -= amount + fee_amount
            reciever_wallet.money += amount
            system_wallet.money += fee_amount
            Wallet.objects.bulk_update(
                [sender_wallet, reciever_wallet, system_wallet],
                fields=['money'])
            return transaction
Esempio n. 37
0
 def request(self, source, destination, with_taxes, amount):
     transaction = self.model(
         source=source,
         destination=destination,
         status=constants.PaymentTransactionStatus.SCHEDULED,
         amount=amount,
         currency=destination.currency,
         with_taxes=with_taxes,
     )
     if settings.IMMEDIATELY_RATE:
         transaction.set_rate_and_taxes()
     transaction.save()
     return transaction
Esempio n. 38
0
 def get_ready_deposits(cls) -> List[Transaction]:
     pending_deposits = Transaction.objects.filter(
         status__in=[
             Transaction.STATUS.pending_user_transfer_start,
             Transaction.STATUS.pending_external,
         ],
         kind=Transaction.KIND.deposit,
         pending_execution_attempt=False,
     ).select_for_update()
     with django.db.transaction.atomic():
         ready_transactions = rri.poll_pending_deposits(pending_deposits)
         Transaction.objects.filter(
             id__in=[t.id for t in ready_transactions]).update(
                 pending_execution_attempt=True)
     verified_ready_transactions = []
     for transaction in ready_transactions:
         # refresh from DB to pull pending_execution_attempt value and to ensure invalid
         # values were not assigned to the transaction in rri.poll_pending_deposits()
         transaction.refresh_from_db()
         if transaction.kind != transaction.KIND.deposit:
             cls.handle_error(
                 transaction,
                 "poll_pending_deposits() returned a non-deposit transaction",
             )
             continue
         if transaction.amount_in is None:
             cls.handle_error(
                 transaction,
                 "poll_pending_deposits() did not assign a value to the "
                 "amount_in field of a Transaction object returned",
             )
             continue
         elif transaction.amount_fee is None:
             if registered_fee_func is calculate_fee:
                 try:
                     transaction.amount_fee = calculate_fee({
                         "amount":
                         transaction.amount_in,
                         "operation":
                         settings.OPERATION_DEPOSIT,
                         "asset_code":
                         transaction.asset.code,
                     })
                 except ValueError as e:
                     cls.handle_error(transaction, str(e))
                     continue
             else:
                 transaction.amount_fee = Decimal(0)
             transaction.save()
         verified_ready_transactions.append(transaction)
     return verified_ready_transactions
Esempio n. 39
0
def do_transactions(request, amount, type):
    manager = Manager.objects.get(pk=10)
    customer = Customer.objects.get(pk=request.user)
    customer.credit -= amount
    manager.credit += amount
    customer.save()
    manager.save()
    transaction = Transaction()
    transaction. value = amount
    transaction.creator = customer
    transaction.state ='W'
    transaction.transactions_type=type
    transaction.save()
    request.session['trans_id']= transaction.id
Esempio n. 40
0
def executeOnePriceBuy(*args, **kwargs):
    """The operation of one price buy, after buyer payed successfully."""
    initParam = kwargs.get('initParam')
    transaction = initParam.get('transaction')
    if transaction:
        transaction.status = 3
        transaction.is_active = True
        txn_expiry_date = string.atoi(common.getSystemParam(key='txn_expiry_date', default=15))
        transaction.end_time = datetime.datetime.now() + datetime.timedelta(days=txn_expiry_date)
        transaction.buyer_account = initParam.get('buyer_account')
        acceptGateways = paymentModels.AcceptGateway.objects.filter(user_id=transaction.seller.id, type_id=transaction.gateway.id, is_active=True)
        transaction.seller_account = acceptGateways[0].value
        transaction.appswalk_account = settings.APPSWALK_ACCOUNT
        txn_fee_pct = string.atof(common.getSystemParam(key='txn_fee_pct', default=0.01))
        transaction.appswalk_price = transaction.price * txn_fee_pct
        transaction.seller_price = transaction.price * (1 - txn_fee_pct)
        transaction.save()
        #Log transaction
        transactionsLog = models.TransactionLog()
        transactionsLog.transaction = transaction
        transactionsLog.app = transaction.app
        transactionsLog.status = transaction.status
        transactionsLog.buyer = transaction.buyer
        transactionsLog.price = transaction.price
        transactionsLog.buyer_account = transaction.buyer_account
        transactionsLog.seller_account = transaction.seller_account
        transactionsLog.appswalk_account = transaction.appswalk_account
        transactionsLog.gateway = transaction.gateway
        transactionsLog.appswalk_price = transaction.appswalk_price
        transactionsLog.seller_price = transaction.seller_price
        transactionsLog.pay_key = transaction.pay_key
        transactionsLog.save()
        #Update app status and end_date.
        app = transaction.app
        if app.status == 2:
            app.status = 3
            app.end_date = datetime.datetime.now()
            app.save()

        #Send email to seller
        notificationViews.onePriceBuyInformSellerEmail(transaction=transaction)

        log.info(_('The transaction of one price buy with id %(param1)s is payed by %(param2)s.')
                 % {'param1': transaction.id, 'param2': transaction.buyer.username})
        return transaction
    return None
Esempio n. 41
0
def person_merge(person_from, person_to):
    """
    Merge two people into one
    Move all related items from person_from to person_to
    Then delete person_to and their address record
    """
    person_reassign_records(person_from, person_to)
    for sub in person_from.subscription_set.all():
        sub.person_member = person_to
        sub.save()
    # if person_from.sub and not person_to.sub:
    #     person_to.sub = person_from.sub
    # if person_from.auth and not person_to.auth:
    #     person_to.auth = person_from.auth
    # if person_from.cardless_id and not person_to.cardless_id:
    #     person_to.cardless_id = person_from.cardless_id
    for invitem in person_from.invoiceitem_set.all():
        invitem.person = person_to
        invitem.save()
    for application in person_from.adultapplication_set.all():
        application.person = person_to
        application.save()

    for group in person_from.groups.all():
        person_from.groups.remove(group)
        person_to.groups.add(group)
        person_from.save()
        person_to.save()
    for transaction in person_from.transaction_set.all():
        transaction.person = person_to
        transaction.save()
    for entry in person_from.visitorbook_set.all():
        entry.person = person_to
        entry.save()
    for entry in person_from.participant_set.all():
        entry.person = person_to
        entry.save()
    for entry in person_from.waitinglist_set.all():
        entry.person = person_to
        entry.save()

    for field in ('sub', 'auth', 'cardless_id'):
        _move_field(field, person_from, person_to)
    person_from.save()
    person_to.save()
Esempio n. 42
0
def duplicate_exchange(request, exchange_id):
    exchange = get_object_or_404(ledger.Exchange, pk=exchange_id, editor=request.user)
    transactions = exchange.transactions.filter(editor=request.user)

    exchange.id = None
    exchange.memo = "Copy of %s" % (exchange.memo)
    exchange.delivered = False
    exchange.save(force_insert=True)
    for transaction in transactions:
        transaction.id = None
        transaction.memo = "Copy of %s" % (transaction.memo)
        transaction.exchange = exchange
        transaction.debit_reconciled = False
        transaction.credit_reconciled = False
        transaction.save(force_insert=True)

    if request.GET["next"]:
        return HttpResponseRedirect(request.GET["next"])
    else:
        return HttpResponseRedirect(reverse("list_exchanges"))
Esempio n. 43
0
def new_transaction(request, transaction_key):
    if request.method == 'POST':
        form = TransactionForm(request.POST, auto_id='transaction-%s')
        if form.is_valid():
            transaction = form.save(commit=False)
            transaction.staff_member = request.user
            transaction.save()
            now = transaction.timestamp
            periods = transaction.catalog.periods.all()

            assets_in_ids = request.POST.getlist('asset_in')
            assets_in = Asset.objects.in_bulk(assets_in_ids)
            for asset_id, asset in assets_in.iteritems():
                reservation = asset.get_current_reservation()
                if reservation:
                    reservation.transaction_in = transaction
                    reservation.save()
                else:
                    print 'No current reservation'

            renew_ids = request.POST.getlist('renew')
            assets_out_ids = renew_ids + request.POST.getlist('asset_out')
            assets_out = Asset.objects.in_bulk(assets_out_ids)
            custom_due_date = form.cleaned_data['due_date']
            for asset_id, asset in assets_out.iteritems():
                if custom_due_date:
                    due_date = custom_due_date
                else:
                    duration = asset.get_reservation_duration()
                    due_date = duration and duration.get_due_date(now, periods)
                try:
                    transaction.reservations_out.create(asset=asset, due_date=due_date)
                except Exception:
                    raise

            print 'Redirecting...'
            return redirect('reservations:receipt', transaction.pk)
        else:
            print 'Transaction failed'

    return redirect('reservations:scan')
Esempio n. 44
0
def reconcile_transaction(request):
    value = False
    reconciled_balance = "0.0"
    errors = []

    if request.POST:
        form = ledger_forms.ReconcileTransactionForm(request.POST)
        if form.is_valid():
            try:
                transaction = form.cleaned_data["transaction"]
                account = form.cleaned_data["account"]
                value = not getattr(transaction, "%s_reconciled" % account)
                setattr(transaction, "%s_reconciled" % account, value)
                transaction.save()
                account_id = getattr(transaction, "%s_id" % account)
                account = ledger.Account.objects.get(pk=account_id, editor=request.user)
                to_date = form.cleaned_data["to_date"]
                reconciled_balance = "%.2f" % account.reconciled_balance(to_date=to_date)
            except Exception, e:
                errors.append("%s: %s" % (type(e).__name__, e.message))
        else:
            for k, v in form.errors.iteritems():
                errors.append("%s: %s" % (k, v))
Esempio n. 45
0
def closedTrade(request, *args, **kwargs):
    """Need update end_time to now."""
    initParam = {}
    transaction = get_object_or_404(models.Transaction, pk=kwargs.get('txn_id'), buyer_id=kwargs.get('buyer_id'), is_active=True)
    transaction.status = 4
    transaction.end_date = datetime.datetime.now()
    transaction.save()
    #Log transaction
    transactionsLog = models.TransactionLog()
    transactionsLog.transaction = transaction
    transactionsLog.app = transaction.app
    transactionsLog.status = transaction.status
    transactionsLog.buyer = transaction.buyer
    transactionsLog.save()
    #Increase seller and buyer credit point
    point = common.getSystemParam(key='cp_closed_trade', default=50)
    creditViews.increaseCreditPoint(user=transaction.buyer, point=point)
    creditViews.increaseCreditPoint(user=transaction.seller, point=point)
    #Send email to seller and buyer
    notificationViews.closedTradeInform(transaction=transaction)

    initParam['transaction'] = transaction
    return render_to_response('transaction/trade_action.html', initParam, context_instance=RequestContext(request))
Esempio n. 46
0
def edit_transaction(request, id=None):
    """
    Create or edit a transaction.
    """
    transaction = id and get_object_or_404(Transaction, pk=id, user=request.user)
    if request.method == 'POST':
        form = EditTransactionForm(request.user, instance=transaction, data=request.POST)
        if form.is_valid():
            transaction = form.save(commit=False)
            transaction.user = request.user
            transaction.save()
            form.save_m2m()
            return redirect(transaction)
    else:
        initial = {}
        if not transaction:
            initial['account'] = request.GET.get('account', None)
            initial['date'] = now()
        form = EditTransactionForm(request.user, instance=transaction, initial=initial)
    return render(request, 'pages/form.html', {
        'title': "{} Transaction".format("Edit" if transaction else "New"),
        'breadcrumbs': [transaction.account, transaction] if transaction else [],
        'form': form,
    })
Esempio n. 47
0
def confirm_trans_record(trans_record):
	"""Confirm a transaction record."""
	# Build and save matching record
	confirm_record = models.TransactionRecord(
		creator_person=trans_record.target_person,
		target_person=trans_record.creator_person,
		from_receiver=not trans_record.from_receiver,
		currency=trans_record.currency,
		transaction_time=trans_record.transaction_time,
		value=trans_record.value
	)
	transaction = models.Transaction()
	transaction.save()

	confirm_record.transaction_id = trans_record.transaction_id = transaction.id
	confirm_record.save()
	trans_record.save()

	# Update the balance, or create a new one
	update_balance(
		trans_record, 
		trans_record.provider,
		trans_record.receiver
	)
Esempio n. 48
0
def onePriceBuy(request, *args, **kwargs):
    """
        Buyer pay by clicking button 'Buy It Now with 10 USD' in app detail page.
        Note: url include app_id, and publisher_id, because of preventing user to cheat.
    """
    initParam = {}
    app_id = kwargs.get('app_id')
    publisher_id = kwargs.get('publisher_id')
    app = get_object_or_404(appModels.App, pk=app_id, publisher_id=publisher_id, status=2)

    transactions = models.Transaction.objects.filter(app_id=app.id, seller_id=publisher_id, buyer_id=request.user.id, status=1)
    if transactions:
        transaction = transactions[0]
    else:
        transaction = models.Transaction()
        transaction.app = app
        transaction.seller = app.publisher
        transaction.status = 1
        transaction.is_active = False
        transaction.buyer = request.user
        transaction.price = app.one_price
        transaction.buy_type = 1
        paid_expiry_date = string.atoi(common.getSystemParam(key='paid_expiry_date', default=7))
        transaction.end_time = datetime.datetime.now() + datetime.timedelta(days=paid_expiry_date)
        transaction.save()

        #Log transaction
        transactionsLog = models.TransactionLog()
        transactionsLog.transaction = transaction
        transactionsLog.app = transaction.app
        transactionsLog.status = transaction.status
        transactionsLog.buyer = transaction.buyer
        transactionsLog.price = transaction.price
        transactionsLog.buy_type = transaction.buy_type
        transactionsLog.save()

    initParam['transaction'] = transaction
    initParam['page_source'] = 'one-price'
    if transaction.end_time > datetime.datetime.now():
        initParam['time_remaining'] = time.mktime(time.strptime(transaction.end_time.strftime('%Y-%m-%d %H:%M:%S'), '%Y-%m-%d %H:%M:%S'))
    else:
        initParam['time_remaining'] = "Deal Closed"
        initParam['paid_expiry'] = True

    if request.method == 'POST':
        #Buyer credit point judge for bidding.
        min_cp = common.getSystemParam(key='min_cp_for_bid', default=50)
        cp = creditViews.getUserCreditPoint(user=request.user)
        if cp == -1 or cp < string.atoi(min_cp):
            initParam['error_msg'] = _('You are not allowed to buy, because your credit points is too low.')
        else:
            #Buyser pay for app.
            txn_fee_pct = string.atof(common.getSystemParam(key='txn_fee_pct', default=0.01))
            initParam['currency'] = app.currency.currency
            initParam['appsWalk_account'] = settings.APPSWALK_ACCOUNT
            initParam['gateway'] = 'paypal'
            gateways = paymentModels.Gateway.objects.filter(name__iexact=initParam.get('gateway'))
            acceptGateways = paymentModels.AcceptGateway.objects.filter(user_id=transaction.seller.id, type_id=gateways[0].id, is_active=True)
            initParam['seller_account'] = acceptGateways[0].value
            initParam['appsWalk_amount'] = app.one_price * txn_fee_pct
            initParam['seller_amount'] = app.one_price * (1 - txn_fee_pct)
            initParam['txn_id'] = transaction.id
            #The needed operation method in pay.
            initParam['executeMethod'] = updateTransaction
            #The back page, when pay has error.
            if request.session.get('back_page', None):
                del request.session['back_page']
            if request.session.get('back_page_msg', None):
                del request.session['back_page_msg']
            request.session['back_page'] = '/'.join([common.getHttpHeader(request), 'query/app-detail', str(app.id)])
            request.session['back_page_msg'] = 'App Detail'
            #The success return page, when pay finish.
            if request.session.get('success_page', None):
                del request.session['success_page']
            if request.session.get('success_page_msg', None):
                del request.session['success_page_msg']
            request.session['success_page'] = '/'.join([common.getHttpHeader(request), 'transaction/trade-action/buy', str(app.id), str(request.user.id)])
            request.session['success_page_msg'] = 'Trade Action'
            return paymentViews.pay(request, initParam=initParam)
    return render_to_response('transaction/one_price_buy.html', initParam, context_instance=RequestContext(request))
    def insert_new_fpds(self, to_insert, total_rows):
        place_of_performance_field_map = {
            "location_country_code": "place_of_perform_country_c",
            "country_name": "place_of_perf_country_desc",
            "state_code": "place_of_performance_state",
            "state_name": "place_of_perfor_state_desc",
            "city_name": "place_of_perform_city_name",
            "county_name": "place_of_perform_county_na",
            "county_code": "place_of_perform_county_co",
            "zip_4a": "place_of_performance_zip4a",
            "congressional_code": "place_of_performance_congr",
            "zip_last4": "place_of_perform_zip_last4",
            "zip5": "place_of_performance_zip5",
        }

        legal_entity_location_field_map = {
            "location_country_code": "legal_entity_country_code",
            "country_name": "legal_entity_country_name",
            "state_code": "legal_entity_state_code",
            "state_name": "legal_entity_state_descrip",
            "city_name": "legal_entity_city_name",
            "county_name": "legal_entity_county_name",
            "county_code": "legal_entity_county_code",
            "address_line1": "legal_entity_address_line1",
            "address_line2": "legal_entity_address_line2",
            "address_line3": "legal_entity_address_line3",
            "zip4": "legal_entity_zip4",
            "congressional_code": "legal_entity_congressional",
            "zip_last4": "legal_entity_zip_last4",
            "zip5": "legal_entity_zip5",
        }

        for index, row in enumerate(to_insert, 1):
            upper_case_dict_values(row)

            # Create new LegalEntityLocation and LegalEntity from the row data
            legal_entity_location = create_location(
                legal_entity_location_field_map, row, {"recipient_flag": True, "is_fpds": True}
            )
            recipient_name = row["awardee_or_recipient_legal"]
            legal_entity = LegalEntity.objects.create(
                recipient_unique_id=row["awardee_or_recipient_uniqu"],
                recipient_name=recipient_name if recipient_name is not None else "",
            )
            legal_entity_value_map = {
                "location": legal_entity_location,
                "business_categories": get_business_categories(row=row, data_type="fpds"),
                "is_fpds": True,
            }
            set_legal_entity_boolean_fields(row)
            legal_entity = load_data_into_model(legal_entity, row, value_map=legal_entity_value_map, save=True)

            # Create the place of performance location
            pop_location = create_location(place_of_performance_field_map, row, {"place_of_performance_flag": True})

            # Find the toptier awards from the subtier awards
            awarding_agency = Agency.get_by_subtier_only(row["awarding_sub_tier_agency_c"])
            funding_agency = Agency.get_by_subtier_only(row["funding_sub_tier_agency_co"])

            # Generate the unique Award ID
            # "CONT_AW_" + agency_id + referenced_idv_agency_iden + piid + parent_award_id
            generated_unique_id = (
                "CONT_AW_"
                + (row["agency_id"] if row["agency_id"] else "-NONE-")
                + "_"
                + (row["referenced_idv_agency_iden"] if row["referenced_idv_agency_iden"] else "-NONE-")
                + "_"
                + (row["piid"] if row["piid"] else "-NONE-")
                + "_"
                + (row["parent_award_id"] if row["parent_award_id"] else "-NONE-")
            )

            # Create the summary Award
            (created, award) = Award.get_or_create_summary_award(
                generated_unique_award_id=generated_unique_id, piid=row["piid"]
            )
            award.parent_award_piid = row.get("parent_award_id")
            award.save()

            # Append row to list of Awards updated
            AWARD_UPDATE_ID_LIST.append(award.id)

            if row["last_modified"] and len(str(row["last_modified"])) == len("YYYY-MM-DD HH:MM:SS"):  # 19 characters
                dt_fmt = "%Y-%m-%d %H:%M:%S"
            else:
                dt_fmt = "%Y-%m-%d %H:%M:%S.%f"  # try using this even if last_modified isn't a valid string

            try:
                last_mod_date = datetime.strptime(str(row["last_modified"]), dt_fmt).date()
            except ValueError:  # handle odd-string formats and NULLs from the upstream FPDS-NG system
                info_message = "Invalid value '{}' does not match: '{}'".format(row["last_modified"], dt_fmt)
                logger.info(info_message)
                last_mod_date = None

            award_type, award_type_desc = award_types(row)

            parent_txn_value_map = {
                "award": award,
                "awarding_agency": awarding_agency,
                "funding_agency": funding_agency,
                "recipient": legal_entity,
                "place_of_performance": pop_location,
                "period_of_performance_start_date": format_date(row["period_of_performance_star"]),
                "period_of_performance_current_end_date": format_date(row["period_of_performance_curr"]),
                "action_date": format_date(row["action_date"]),
                "last_modified_date": last_mod_date,
                "transaction_unique_id": row["detached_award_proc_unique"],
                "generated_unique_award_id": generated_unique_id,
                "is_fpds": True,
                "type": award_type,
                "type_description": award_type_desc,
            }

            contract_field_map = {"description": "award_description"}

            transaction_normalized_dict = load_data_into_model(
                TransactionNormalized(),  # thrown away
                row,
                field_map=contract_field_map,
                value_map=parent_txn_value_map,
                as_dict=True,
            )

            contract_instance = load_data_into_model(TransactionFPDS(), row, as_dict=True)  # thrown away

            detached_award_proc_unique = contract_instance["detached_award_proc_unique"]
            unique_fpds = TransactionFPDS.objects.filter(detached_award_proc_unique=detached_award_proc_unique)

            if unique_fpds.first():
                transaction_normalized_dict["update_date"] = datetime.now(timezone.utc)
                transaction_normalized_dict["fiscal_year"] = fy(transaction_normalized_dict["action_date"])

                # update TransactionNormalized
                TransactionNormalized.objects.filter(id=unique_fpds.first().transaction.id).update(
                    **transaction_normalized_dict
                )

                # update TransactionFPDS
                unique_fpds.update(**contract_instance)
            else:
                # create TransactionNormalized
                transaction = TransactionNormalized(**transaction_normalized_dict)
                transaction.save()

                # create TransactionFPDS
                transaction_fpds = TransactionFPDS(transaction=transaction, **contract_instance)
                transaction_fpds.save()

            # Update legal entity to map back to transaction
            legal_entity.transaction_unique_id = detached_award_proc_unique
            legal_entity.save()
Esempio n. 50
0
def crud_pledge_need(request, project_key, need_id, action=None):
    if not request.user.is_authenticated() :
        if request.is_ajax() :
            return HttpResponseBadRequest()
        else :
            return redirect('bitfund.core.login')

    project = get_object_or_404(Project, key=project_key)
    need = get_object_or_404(ProjectNeed, id=need_id)

    template_data = {'project': project,
                     'request': request,
                     'today': datetime.utcnow().replace(tzinfo=utc).today(),
                     'site_currency_sign': SITE_CURRENCY_SIGN,
                     }

    if request.method == 'POST' :
        if action == 'pledge' :
            pledge_need_form = PledgeProjectNeedForm(request.POST, prefix='need-'+str(need.id))
            if pledge_need_form.is_valid() :
                with transaction.commit_on_success():
                    cleaned_pledge_type = pledge_need_form.cleaned_data['pledge_type']
                    cleaned_pledge_amount = pledge_need_form.cleaned_data['pledge_amount']

                    if cleaned_pledge_type == DONATION_TYPES_CHOICES.onetime :
                        transaction = DonationTransaction()
                        transaction.populatePledgeTransaction(project=project, user=request.user, need=need,
                                                              pledge_amount=cleaned_pledge_amount)
                        transaction.save()
                        transaction.createRedonationTransactions()
                    else :
                        pledge_subscription = (DonationSubscription.objects
                                               .filter(user=request.user)
                                               .filter(project=project)
                                               .select_related())

                        if pledge_subscription.count() == 1 :
                            pledge_subscription = pledge_subscription[0]
                            pledge_subscription_need = (DonationSubscriptionNeeds.objects
                                                        .filter(donation_subscription=pledge_subscription)
                                                        .filter(need=need))
                            if pledge_subscription_need.count() == 1 :
                                pledge_subscription_need = pledge_subscription_need[0]

                                pledge_subscription.cancelPendingTransactions(pledge_subscription_need)

                                pledge_subscription_need.amount = cleaned_pledge_amount
                                pledge_subscription_need.save()
                            else :
                                pledge_subscription_need = DonationSubscriptionNeeds()
                                pledge_subscription_need.donation_subscription = pledge_subscription
                                pledge_subscription_need.need = need
                                pledge_subscription_need.amount = cleaned_pledge_amount
                                pledge_subscription_need.save()

                        else :
                            pledge_subscription = DonationSubscription()
                            pledge_subscription.user = request.user
                            pledge_subscription.project = project
                            pledge_subscription.save()

                            pledge_subscription_need = DonationSubscriptionNeeds()
                            pledge_subscription_need.donation_subscription = pledge_subscription
                            pledge_subscription_need.need = need
                            pledge_subscription_need.amount = cleaned_pledge_amount
                            pledge_subscription_need.save()

                        transaction = DonationTransaction()
                        transaction.populatePledgeTransaction(project=project, user=request.user, need=need,
                                                              pledge_amount=cleaned_pledge_amount,
                                                              donation_subscription=pledge_subscription)
                        transaction.transaction_status = DONATION_TRANSACTION_STATUSES_CHOICES.pending
                        transaction.save()
                        transaction.createRedonationTransactions()

                        return redirect('bitfund.project.views.crud_pledge_need', project_key=project.key, need_id=need.id)
            else :
                template_data['need'] = _prepare_need_item_template_data(request, project, need, pledge_need_form)

            if not request.is_ajax() :
                if not request.user_has_bank_card_attached :
                    request.session[SESSION_PARAM_RETURN_TO_PROJECT] = project.key
                    return redirect('bitfund.pledger.attach_card')
                else :
                    return redirect('bitfund.project.budget', project_key=project.key)

        elif action == 'switch_monthly' :
            pledge_need_form = PledgeProjectNeedForm(request.POST, prefix='need-'+str(need.id))
            if pledge_need_form.is_valid() :
                with transaction.commit_on_success():
                    pledge_subscription = (DonationSubscription.objects
                                           .filter(user=request.user)
                                           .filter(project=project)
                                           .select_related())
                    if pledge_subscription.count() == 1 :
                        pledge_subscription = pledge_subscription[0]
                    else :
                        pledge_subscription = DonationSubscription()
                        pledge_subscription.user = request.user
                        pledge_subscription.project = project
                        pledge_subscription.save()


                    pledge_subscription_need = (DonationSubscriptionNeeds.objects
                                                .filter(donation_subscription=pledge_subscription)
                                                .filter(need=need))
                    if pledge_subscription_need.count() == 0 :
                        cleaned_pledge_amount = pledge_need_form.cleaned_data['pledge_amount']
                        pledge_subscription_need = DonationSubscriptionNeeds()
                        pledge_subscription_need.donation_subscription = pledge_subscription
                        pledge_subscription_need.need = need
                        pledge_subscription_need.amount = cleaned_pledge_amount
                        pledge_subscription_need.save()

                return redirect('bitfund.project.views.crud_pledge_need', project_key=project.key, need_id=need.id)

            else :
                template_data['need'] = _prepare_need_item_template_data(request, project, need, pledge_need_form)

        elif action == 'drop_subscription' :
            existing_subscription = (DonationSubscription.objects
                                     .filter(user=request.user, project=project)
                                     .select_related())

            if existing_subscription.count() == 1 :
                with transaction.commit_on_success():
                    existing_subscription = existing_subscription[0]
                    existing_subscription_need = (DonationSubscriptionNeeds.objects
                                                  .filter(donation_subscription=existing_subscription,
                                                          need=need))
                    if existing_subscription_need.count() == 1 :
                        existing_subscription_need = existing_subscription_need[0]
                        existing_subscription.cancelPendingTransactions(existing_subscription_need)

                        existing_subscription_need.delete()

                    other_subscriptions_count = (DonationSubscriptionNeeds.objects
                                                 .filter(donation_subscription_id=existing_subscription.id)
                                                 .count())
                    if other_subscriptions_count == 0 :
                        existing_subscription.delete()

            return redirect('bitfund.project.views.crud_pledge_need', project_key=project.key, need_id=need.id)

    if 'need' not in template_data:
        template_data['need'] = _prepare_need_item_template_data(request, project, need)

    template_data['budget'] = _prepare_project_budget_template_data(request, project)

    return render_to_response('project/budget/ajax-pledge_need_form.djhtm', template_data, context_instance=RequestContext(request))
Esempio n. 51
0
	def register_transaction(self, giftcard, charge, comment = '', id = ''):
		transaction = Transaction(merchant = self, comment = comment, purchase_item_id = id, amount = charge, giftcard= giftcard)
		transaction.save()
		#TODO	SEND E_MAIL TO MERCHANT ADMIN
		return transaction
Esempio n. 52
0
def tradeNow(request, *args, **kwargs):
    """Trade app."""
    initParam = {}
    app = get_object_or_404(appModels.App, pk=kwargs.get('app_id'), publisher_id=request.user.id)
    user = get_object_or_404(User, pk=kwargs.get('buyer_id'))
    bid = get_object_or_404(bidModels.Bidding, pk=kwargs.get('bid_id'), buyer_id=user.id, app_id=app.id, status=1)
    initParam['app'] = app
    initParam['user'] = user
    initParam['bid'] = bid
    transactions = models.Transaction.objects.filter(app_id=app.id, seller_id=request.user.id, is_active=True)
    if transactions:
        transaction = transactions[0]
    else:
        transaction = models.Transaction()
        transaction.app = app
        transaction.status = 1
        transaction.seller = request.user
        transaction.is_active = True
        transaction.save()
    #Remind that seller has 7 days to trade now, if bid price is more than reserve price.
    cur_time = datetime.datetime.now()
    if transaction.status == 1 and app.status != 1 and app.end_date <= cur_time and bid.price >= app.reserve_price:
        if transaction.end_time is None:
            paid_expiry_date = string.atoi(common.getSystemParam(key='sell_expiry_date', default=7))
            transaction.end_time = app.end_date + datetime.timedelta(days=paid_expiry_date)
            transaction.save()
        if transaction.end_time > cur_time:
            initParam['time_remaining'] = time.mktime(time.strptime(str(transaction.end_time), '%Y-%m-%d %H:%M:%S'))
            initParam['is_expiry_date'] = False
        else:
            initParam['is_expiry_date'] = True
    initParam['transaction'] = transaction

    if request.method == 'POST':
        if transaction and transaction.status != 1:
            initParam['error_msg'] = _('You have traded with buyer %(param)s, can not trade again.') % {'param': user.username}
        else:
            if transaction is None:
                transaction = models.Transaction()
                transaction.app = app
                transaction.seller = request.user
                transaction.is_active = True
            transaction.status = 2
            transaction.buyer = user
            transaction.price = bid.price
            paid_expiry_date = string.atoi(common.getSystemParam(key='paid_expiry_date', default=7))
            transaction.end_time = cur_time + datetime.timedelta(days=paid_expiry_date)
            transaction.buy_type = 2
            transaction.save()
            #Log transaction
            transactionsLog = models.TransactionLog()
            transactionsLog.transaction = transaction
            transactionsLog.app = transaction.app
            transactionsLog.status = transaction.status
            transactionsLog.seller = transaction.seller
            transactionsLog.buyer = transaction.buyer
            transactionsLog.price = transaction.price
            transactionsLog.buy_type = transaction.buy_type
            transactionsLog.save()
            #Update app status and end_date
            if app.status == 2:
                app.status = 3
                app.end_date = cur_time
                app.save()
            #Send the email of pay to buyer
            notificationViews.tradeNowInformBuyerPayEmail(request, app=app, user=user)

            return redirect(reverse('transaction:trade_action',
                                    kwargs={'action': 'sell', 'app_id': app.id, 'user_id': request.user.id}))

    return render_to_response('transaction/trade_now.html', initParam, context_instance=RequestContext(request))
def success(request):    
    from payments.gateways.paypal import PayPalGateway
    from payments.models import PayPalShopSettings, PayPalToken, PayPalTransaction
    from preferences.models import Preference
    from sell.templatetags.sell_tags import money_format

    cart = request.cart
    
    #### Verify Products Availability
    if not cart.is_available():
        request.flash['message'] = 'Items not longer available: '
        for item in cart.items_not_availables():
            request.flash['message'] += item.product.title
        cart.remove_not_available_items()
        
        return HttpResponseRedirect(reverse('my_shopping'))
    
    if request.method == 'GET':
        payerid = request.GET.get('PayerID', None)
        token = request.GET.get('token', None)
    else:
        payerid = request.POST.get('PayerID', None)
        token = request.POST.get('token', None)
    
    if None in (token, payerid):
        request.flash['message'] = unicode(_("Payment failed, try other method."))
        request.flash['severity'] = "error"
        return HttpResponseRedirect(reverse('my_shopping'))
    
    shop = request.shop   
    paypal_settings = PayPalShopSettings.objects.filter(shop = shop).get()
    
    try:
        paypaltoken = PayPalToken.objects.filter(token=token).get()
    except PayPalToken.DoesNotExist:
        request.flash['message'] = unicode(_("Payment failed, try other method."))
        request.flash['severity'] = "error"
        return HttpResponseRedirect(reverse('my_shopping'))

    if paypaltoken.confirmed == True:
        request.flash['message'] = unicode(_("Payment is already confirmed!"))
        request.flash['severity'] = "notice"
        return HttpResponseRedirect(reverse('my_shopping'))

    cart = paypaltoken.cart
    #currency = Preference.get_preference(shop).checkout_currency
    total_amount = "%0.2f" % cart.total_with_taxes()
    
    
    if request.method != 'POST':
        
        t = loader.get_template('payments/payment_paypal_confirm.html')
        c = RequestContext(request, {
                                     'payerid': payerid,
                                     'token': token,
                                     #'api_signature': settings.PAYPAL_SIGNATURE,                                                                   
                                     #'api_user': settings.PAYPAL_USERNAME,
                                     #'api_password': settings.PAYPAL_PASSWORD
                                    })
        block = (t.render(c))
        
        param = {'total_amount': money_format(total_amount, shop),
                 'paypaltoken': paypaltoken,
                 'cart': cart,
                 'cancel_url': reverse('payments_cancel'),
                 'form_paypal_confirm': block,
                }
        
        return HttpResponse(my_render(request, param, 'payment_paypal_confirm'))        
    
    
    action = request.POST.get('action', 'cancel').lower()
    
    if action == 'confirm':
        
        paypal_gw = PayPalGateway(username=settings.PAYPAL_USERNAME,
                                  password=settings.PAYPAL_PASSWORD,
                                  sign=settings.PAYPAL_SIGNATURE,
                                  debug=settings.PAYPAL_DEBUG)
       
        #return_url = request.build_absolute_uri(reverse("paypal_success"))
        #cancel_url = request.build_absolute_uri(reverse("paypal_cancel"))
        is_token_data = paypal_gw.GetExpressCheckoutDetails(paypaltoken.token, subject=paypal_settings.email)
        
        if not is_token_data:
            logging.critical("Error found when trying to do a GetExpressCheckoutDetails api call on Paypal. RESPONSE: %s" % paypal_gw.api_response)
            request.flash['message'] = unicode(_("Could not get transaction data from PayPal. Please contact admin to complete your purchase!"))
            request.flash['severity'] = "error"
            return HttpResponseRedirect(reverse('my_shopping'))
        
        
        ack = paypal_gw.api_response['ACK'][0]            
        
        if ack != "Success":
            logging.critical("Paypal Api Response Failure. RESPONSE: %s" % paypal_gw.api_response)
            request.flash['message'] = unicode(_("There was an error when trying to get data from PayPal. Please contact admin to complete your purchase!"))
            request.flash['severity'] = "error"
            return HttpResponseRedirect(reverse('my_shopping'))
        
        try:
            amount = decimal.Decimal(paypal_gw.api_response['PAYMENTREQUEST_0_AMT'][0])
        except KeyError:
            logging.critical("Fail when trying to read the payment amount. The API response don't have an AMT key. RESPONSE: %s" % paypal_gw.api_response)    
            request.flash['message'] = unicode(_("We have found an error when trying to validate your purchase!"))
            request.flash['severity'] = "error"
            return HttpResponseRedirect(reverse('my_shopping'))
        
        if amount != cart.total_with_taxes():
            request.flash['message'] = unicode(_("You have authorized us to charge you just $%s, but you want buy $%s! Please contact admin if you think this is a mistake!" % (amount, cart.total_with_taxes())))
            request.flash['severity'] = "error"
            return HttpResponseRedirect(reverse('my_shopping'))
        
    
        payment_request = {
            'PAYMENTREQUEST_0_PAYMENTACTION': 'Sale',
            'PAYMENTREQUEST_0_AMT': "%0.2f" % cart.total_with_taxes(), 
            #'PAYMENTREQUEST_0_TAXAMT': "%0.2f" % cart.taxes(),
            #'PAYMENTREQUEST_n_SHIPPINGAMT': "%0.2f" % cart.shipping_charge(),
            #'PAYMENTREQUEST_0_ITEMAMT': "%0.2f" % cart.total(),
            'PAYMENTREQUEST_0_CURRENCYCODE': Preference.get_preference(shop).checkout_currency,
            'PAYMENTREQUEST_0_NOTIFYURL': request.build_absolute_uri(reverse("payments_paypal_ipn")),
            'SUBJECT': paypal_settings.email
        }
        success = paypal_gw.DoExpressCheckoutPayment(payment_request, paypaltoken.token, payerid)
        
        
        if success:
            #Close and clean the cart
            sell = cart.close("PayPal")
            #Set the sell payments as paid
            sell.payment.pay()
            paypaltoken.confirmed = True
            paypaltoken.save()
            
            # {'PAYMENTINFO_0_TRANSACTIONTYPE': 'expresscheckout', 'ACK': 'Success', 'PAYMENTINFO_0_PAYMENTTYPE': 'instant', 'PAYMENTINFO_0_REASONCODE': 'None', 'SHIPPINGOPTIONISDEFAULT': 'false', 'INSURANCEOPTIONSELECTED': 'false', 'CORRELATIONID': '8d20dfd3e3575', 'PAYMENTINFO_0_TAXAMT': '0.00', 'PAYMENTINFO_0_TRANSACTIONID': '6MH53467HE876651A', 'PAYMENTINFO_0_PENDINGREASON': 'None', 'PAYMENTINFO_0_AMT': '57.00', 'PAYMENTINFO_0_PROTECTIONELIGIBILITY': 'Ineligible', 'PAYMENTINFO_0_ERRORCODE': '0', 'TOKEN': 'EC-7MR99474WD5992801', 'VERSION': '63.0', 'SUCCESSPAGEREDIRECTREQUESTED': 'false', 'BUILD': '1482946', 'PAYMENTINFO_0_CURRENCYCODE': 'USD', 'PAYMENTINFO_0_FEEAMT': '1.95', 'TIMESTAMP': '2010-09-08T18:03:24Z', 'PAYMENTINFO_0_ACK': 'Success', 'PAYMENTINFO_0_ORDERTIME': '2010-09-08T18:03:23Z', 'PAYMENTINFO_0_PAYMENTSTATUS': 'Completed'}
            txn_id = paypal_gw.api_response['PAYMENTINFO_0_TRANSACTIONID']
            
            transaction = PayPalTransaction()
            transaction.transaction_id = txn_id
            transaction.sell = sell
            transaction.save()
            
            return HttpResponseRedirect(reverse('payments_success'))
        else:
            request.flash['message'] = unicode(_("Payment Failed!"))
            request.flash['severity'] = "error"
            return HttpResponseRedirect(reverse('my_shopping'))
    else:
        paypaltoken.delete()
        request.flash['message'] = unicode(_("Payment cancel!"))
        request.flash['severity'] = "notice"
        return HttpResponseRedirect(reverse('my_shopping'))
Esempio n. 54
0
def contract_uploader_view(request):
    csv_file = request.FILES.get('file', None)
    contract_id = request.data.get('contract_id', None)
    data = {
        'errors' : {
            'user_exists' : [],
            'class_not_found' : [],
        },
        'stats'  : {
            'inserted' : 0,
            'num_errors': 0,
            'new_groups':0,
        }
    }
    if not contract_id:
        data['errors']['form'] = "Contract must be specified"
        return Response(data, status.HTTP_400_BAD_REQUEST)

    contract = Contract.objects.get(pk=contract_id)
    if csv_file:
        import unicodecsv as csv
        transactions = {
            'create' : [],
            'group_users' : {},
            'class_users' : {},
            'contract' : {
                'group' : [],
                'class' : [],
                'unities' : []
            }
        }
        try:
            cf = csv_file.read().splitlines()
            csv_reader = csv.DictReader(cf)
            csv_reader = [c for c in csv_reader]

            groups = set([c for u in csv_reader for c in u['Grupos']
                         .split(';')])
            for group in groups:
                if not Group.objects.filter(name=group).exists():
                    g = Group(name=group)
                    transactions['create'].append(g)
                    data['stats']['new_groups']+=1

            for user in csv_reader:
                transactions['contract']['unities'] += user[u'Município']\
                    .split(';')
                if not TimtecUser.objects.filter(email=user['Email']).exists():
                    username = slugify((user['Nome'] + user['Sobrenome'])[0:30])
                    tries = 0
                    while TimtecUser.objects.filter(username=username)\
                        .exists() and tries < 10:
                        tries+=1
                        username = username[0:-1] + str(tries)

                    u = TimtecUser(email=user['Email'], cpf=user['CPF'],
                                   username=username,
                                   first_name=user['Nome'][0:30],
                                   last_name=user['Sobrenome'][0:30])
                    transactions['create'].append(u)
                    data['stats']['inserted']+=1
                else:
                    data['errors']['user_exists'].append(user['Nome'] +
                                                         user['Sobrenome'])
                    data['stats']['num_errors']+=1
                    u = None

                groups = user['Grupos'].split(';')
                for group in groups:
                    if not transactions['group_users'].has_key(group):
                        transactions['group_users'][group] = []

                    transactions['contract']['group'].append(group)
                    if u:
                        transactions['group_users'][group].append(u)

                classes = user['Turmas'].split(';')
                for class_course in classes:
                    (cclass, course) = class_course.split(' @ ')
                    if Class.objects.filter(name=cclass, course__slug=course)\
                        .exists():
                        if not transactions['class_users']\
                            .has_key(class_course):
                            transactions['class_users'][class_course] = []
                        if u:
                            transactions['class_users'][class_course].append(u)
                        transactions['contract']['class']\
                            .append(Class.objects
                                    .get(name=cclass, course__slug=course))
                    else:
                        data['errors']['class_not_found'].append(class_course)
                        data['stats']['num_errors']+=1

            if data['stats']['num_errors'] == 0:
                from django.db import transaction
                with transaction.atomic():
                    # create entities
                    for transaction in transactions['create']:
                        transaction.save()

                    # add to groups
                    for group_transaction in transactions['group_users']:
                        group = Group.objects.get(name=group_transaction)
                        for u in transactions['group_users'][group_transaction]:
                            group.user_set.add(u)
                        group.save()

                    # add to classes
                    for class_transaction in transactions['class_users']:
                        (cclass, course) = class_transaction.split(' @ ')
                        cclass = Class.objects\
                            .get(name=cclass, course__slug=course)
                        for u in transactions['class_users'][class_transaction]:
                            cclass.students.add(u)
                            cclass.save()
                            if not CourseStudent.objects\
                                .filter(user=u, course=cclass.course).exists():
                                cs = CourseStudent(user=u, course=cclass.course)
                                cs.save()

                    # add groups and classes to contract
                    groups = Group.objects\
                        .filter(name__in=transactions['contract']['group'])
                    for group in groups:
                        contract.groups.add(group)

                    # add classes to contract
                    classes = transactions['contract']['class']
                    for cclass in classes:
                        contract.classes.add(cclass)

                    unities = contract.unities + \
                              list(set(transactions['contract']['unities']))
                    contract.unities = unities
                    contract.save()
                    serializer = ContractSerializer(instance=contract)
                    data['instance'] = serializer.data
            else:
                serializer = ContractSerializer(instance=contract)
                data['instance'] = serializer.data
                return Response(data, status.HTTP_400_BAD_REQUEST)
        except KeyError:
            data['errors']['form'] = "Not valid CSV file"
            return Response(data, status.HTTP_400_BAD_REQUEST)
    else:
        data['errors']['form'] = "Not valid CSV file"
        return Response(data, status.HTTP_400_BAD_REQUEST)

    return Response(data, status.HTTP_200_OK)
Esempio n. 55
0
def crud_pledge_empty_project(request, project_key, action=None):

    if not request.user.is_authenticated() :
        if request.is_ajax() :
            return HttpResponseBadRequest()
        else :
            return redirect('bitfund.core.login')

    project = get_object_or_404(Project, key=project_key)

    template_data = {'project': project,
                     'request': request,
                     'today': datetime.utcnow().replace(tzinfo=utc).today(),
                     'site_currency_sign': SITE_CURRENCY_SIGN,
                     }

    template_data['project_edit_access'] = False
    if request.user.id == project.maintainer_id :
        template_data['project_edit_access'] = True


    if request.method == 'POST' :
        if action == 'pledge' :
            pledge_empty_project_form = PledgeNoBudgetProjectForm(request.POST)
            if pledge_empty_project_form.is_valid() :
                with transaction.commit_on_success():
                    cleaned_pledge_type = pledge_empty_project_form.cleaned_data['pledge_type']
                    cleaned_pledge_amount = pledge_empty_project_form.cleaned_data['pledge_amount']

                    if cleaned_pledge_type == DONATION_TYPES_CHOICES.onetime:
                        transaction = DonationTransaction()
                        transaction.populatePledgeTransaction(project=project, user=request.user,
                                                              pledge_amount=cleaned_pledge_amount)
                        transaction.save()
                        transaction.createRedonationTransactions()
                    else:
                        pledge_subscription = (DonationSubscription.objects
                                               .filter(user=request.user)
                                               .filter(project=project)
                                               .select_related())

                        if pledge_subscription.count() == 1:
                            pledge_subscription = pledge_subscription[0]
                            pledge_subscription.cancelPendingTransactions()
                            pledge_subscription.amount = cleaned_pledge_amount
                            pledge_subscription.save()
                        else:
                            pledge_subscription = DonationSubscription()
                            pledge_subscription.user = request.user
                            pledge_subscription.project = project
                            pledge_subscription.amount = cleaned_pledge_amount
                            pledge_subscription.save()

                        transaction = DonationTransaction()
                        transaction.populatePledgeTransaction(project=project, user=request.user,
                                                              pledge_amount=cleaned_pledge_amount,
                                                              donation_subscription=pledge_subscription)
                        transaction.transaction_status = DONATION_TRANSACTION_STATUSES_CHOICES.pending
                        transaction.save()
                        transaction.createRedonationTransactions()

                        return redirect('bitfund.project.views.crud_pledge_empty_project', project_key=project.key)
            else :
                template_data['empty_project'] = _prepare_empty_project_template_data(request, project, pledge_empty_project_form)

            if not request.is_ajax() :
                #@TODO card presence check (along with the payment integration itself)
                if not request.user.is_card_attached :
                    request.session[SESSION_PARAM_RETURN_TO_PROJECT] = project.key
                    return redirect('bitfund.pledger.attach_card')
                else :
                    return redirect('bitfund.project.budget', project_key=project.key)

        elif action == 'switch_monthly' :
            pledge_empty_project_form = PledgeNoBudgetProjectForm(request.POST)
            if pledge_empty_project_form.is_valid() :
                with transaction.commit_on_success():
                    cleaned_pledge_amount = pledge_empty_project_form.cleaned_data['pledge_amount']

                    pledge_subscription = (DonationSubscription.objects
                                           .filter(user=request.user)
                                           .filter(project=project)
                                           .select_related())
                    if pledge_subscription.count() == 1 :
                        pledge_subscription = pledge_subscription[0]
                    else :
                        pledge_subscription = DonationSubscription()
                        pledge_subscription.user = request.user
                        pledge_subscription.project = project


                    pledge_subscription.amount = cleaned_pledge_amount
                    pledge_subscription.save()

                    return redirect('bitfund.project.views.crud_pledge_empty_project', project_key=project.key)
            else :
                template_data['empty_project'] = _prepare_empty_project_template_data(request, project, pledge_empty_project_form)

        elif action == 'drop_subscription' :
            existing_subscription = (DonationSubscription.objects
                                     .filter(user=request.user, project=project)
                                     .select_related())

            if existing_subscription.count() == 1 :
                with transaction.commit_on_success():
                    existing_subscription = existing_subscription[0]
                    existing_subscription.cancelPendingTransactions()

                    subscription_needs_count = (DonationSubscriptionNeeds.objects
                                                .filter(donation_subscription_id=existing_subscription.id)
                                                .count())
                    if subscription_needs_count == 0 :
                        existing_subscription.delete()
                    else :
                        existing_subscription.amount = 0
                        existing_subscription.save()

            return redirect('bitfund.project.views.crud_pledge_empty_project', project_key=project.key)

    template_data['empty_project'] = _prepare_empty_project_template_data(request, project)
    template_data['budget'] = _prepare_project_budget_template_data(request, project)

    return render_to_response('project/budget/ajax-pledge_empty_project_form.djhtm', template_data, context_instance=RequestContext(request))
Esempio n. 56
0
 def save_transaction(transaction):
     transaction.exchange = exchange
     transaction.editor = request.user
     debit_or_credit = exchange_type.debit_or_credit()
     setattr(transaction, debit_or_credit, exchange_form.cleaned_data[debit_or_credit])
     transaction.save()