Html 如何在django中将响应从视图保存到数据库 models.py forms.py views.py 来自django.contrib.auth.models导入用户 从django.shortcuts导入渲染到响应 从django.template导入请

如何在django中将响应从视图保存到数据库 models.py forms.py views.py

来自django.contrib.auth.models导入用户
从django.shortcuts导入渲染到响应
从django.template导入请求上下文
从django.http导入HttpResponseRedirect，HttpResponse
从django.contrib.auth.decorators导入所需的登录名
从表格导入Carloan_表格表格
@需要登录
def索引（请求）：
form=Carloan_formformform（）
如有要求，请发送：
form=Carloan\u formformform（request.POST）
如果form.is_有效（）：
form.save（）
#收集和分配用户输入
车辆的数量=浮动（表.清洁的车辆数据['车辆的成本]）
租期=浮动（表格.清理的租期数据['loan\u Returnation\u租期\u Months']）
利率=浮动（表格.数据['利率百分比]）
权益=浮动（格式.已清理数据['equity\u contrib\u rate\u Percentage']）
折旧率=浮动（格式.已清理的折旧率数据['折旧率\百分比]）
carloan=form.save（commit=False）
carloan.user=request.user
carloan.save（）
#类定义
类贷款信用证：
定义初始（自身、车辆数量、使用期限、利率、权益、折旧率）：
self.amount\u of \u vehicle=amount\u of \u vehicle
任期
自身利率=利率
自我公平=公平
自折旧率=折旧率
def利益（自我）：
报税表（（自付利率/100）*自付金额\车辆*（自付保有权/12））
def管理费（自付）：
返回0.01*（自车金额+自利（）
def处理费（自付）：
返回0.0025*（自车金额+自利（）
def法律费用（自付）：
返回0.0075*（自车金额+自利（）
def残留量（自身）：
返回0.01*（自车金额-（（自折旧率/100）*自车金额*（自保有权/12）））
def股权供款（自付）：
收益（自有权益/100）*自有金额
def总量（自身）：
返还车辆自付金额+自付利息（）+自付管理费（）+自付处理费（）+自付法律费（）+自付剩余金额（）
def预付款（自付）：
返回自我管理费（）+自我处理费（）+自我法律费（）+自我股权出资费（）+自我剩余金额（）
def开启_平衡（自）：
返回self.total_amount（）-self.upfront_payment（）
def每月分期付款（自付）：
返回self.opening\u balance（）/self.permission
def贷款支付计划（自助）：
月=1
总金额=自有车辆金额+自有利息（）+自有管理费（）+自有处理费（）+自有法律费（）+自有剩余金额（）
预付款=自我管理费（）+自我处理费（）+自我法律费（）+自我股权出资费（）+自我剩余金额（）
期初余额=总金额-预付款
余额=期初余额
而第0个月：
每月分期付款=（期初余额/自住期）
月利息=（（自利利率/100）*余额）/12）
贷款付款=每月分期付款-每月利息
期末余额=余额-每月分期付款
打印“”，月份“”，四舍五入（余额，2），“”，四舍五入（每月分期付款，2），“”，四舍五入（每月利息，2）\
四舍五入（贷款支付，2），“四舍五入（期末余额，2）
余额=期末余额
月份+=1
返回“感谢您使用贷款计算应用程序”
#创建名为“calc”的实例
计算=贷款信用证（车辆金额、使用期限、利率、权益、折旧率）
amountofVehicle=车辆数量
利息=计算利息（）
管理费=计算管理费（）
处理费=计算处理费（）
legalFee=计算法律费用（）
剩余金额=计算剩余金额（）
权益贡献=计算权益贡献（）
合计金额=计算总金额（）
预付款=计算预付款（）
期初余额=计算期初余额（）
贷款支付计划=计算贷款支付计划（）
#将与结果一起显示的空表单
forms=Carloan_FormFormForm（）
#呈现显示结果的模板
返回render_to_response（'carloan/result.html'，{'form'：forms，'result'：amountofVehicle，'result1'：interest，'result2'：managementFee，'result3'：processingFee，
“结果4”：法律依据，“结果5”：剩余金额，“结果6”：权益分配，“结果7”：总金额，
“结果8”：预付款，“结果9”：期初余额，“结果10”：贷款支付计划}，
上下文\实例=请求上下文（请求））
#如果用户不提交表单，它将显示一个空表单
其他：
form=Carloan_formformform（）
#呈现显示空表单的模板
返回render_to_响应（'carloan/index.html'，{'form'：form}，
上下文\实例=请求上下文（请求））

我的问题是,；

有什么方法可以保存我传递给的结果吗

from django.db import models
from django.contrib.auth.models import User

from registeredmember.models import Registeredmember


# Create your models here.

class Carloan_form(models.Model):
    cost_of_vehicle_Naira               = models.DecimalField(max_digits=10, decimal_places=2)
    loan_repayment_tenure_Months        = models.DecimalField(max_digits=10, decimal_places=2)
    interest_rate_Percentage            = models.DecimalField(max_digits=10, decimal_places=2)
    equity_contrib_rate_Percentage      = models.DecimalField(max_digits=10, decimal_places=2)
    depreciation_rate_Percentage        = models.DecimalField(max_digits=10, decimal_places=2)
    user                                = models.ForeignKey(User, null=True)
    time                                = models.DateTimeField(auto_now_add=True)

    def __unicode__(self):
            return unicode(self.user)    

from django import forms
from django.forms import ModelForm

from models import Carloan_form

class Carloan_formForm(ModelForm):
    cost_of_vehicle_Naira           = forms.DecimalField(label=(u'Cost of vehicle (in Naira)'))
    loan_repayment_tenure_Months    = forms.DecimalField(label=(u'Loan tenure (in Months)'))
    interest_rate_Percentage        = forms.DecimalField(label=(u'Interest rate (in %)'))
    equity_contrib_rate_Percentage  = forms.DecimalField(label=(u'Equity contribution rate (in %)'))
    depreciation_rate_Percentage    = forms.DecimalField(label=(u'Depreciation rate (in %)'))
    class Meta:
        model = Carloan_form
        exclude = ('user',)

from django.contrib.auth.models import User
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.http import HttpResponseRedirect, HttpResponse
from django.contrib.auth.decorators import login_required


from forms import Carloan_formForm
@login_required
def index(request):
    form = Carloan_formForm()
    if request.POST:
        form = Carloan_formForm(request.POST)
        if form.is_valid():
            form.save()

            #Collection and Assignment of User input
            amount_of_vehicle = float(form.cleaned_data['cost_of_vehicle_Naira'])
            tenure = float(form.cleaned_data['loan_repayment_tenure_Months'])
            interest_rate = float(form.cleaned_data['interest_rate_Percentage'])
            equity = float(form.cleaned_data['equity_contrib_rate_Percentage'])
            depreciation_rate = float(form.cleaned_data['depreciation_rate_Percentage'])
            carloan = form.save(commit=False)
            carloan.user = request.user
            carloan.save()

            #Class Definition
            class LoanCalc:
                def __init__(self,amount_of_vehicle,tenure,interest_rate,equity,depreciation_rate):
                    self.amount_of_vehicle = amount_of_vehicle
                    self.tenure = tenure
                    self.interest_rate = interest_rate
                    self.equity = equity
                    self.depreciation_rate = depreciation_rate
                def interest(self):
                      return((self.interest_rate/100) * self.amount_of_vehicle *(self.tenure/12))
                def management_fee(self):
                    return 0.01 * (self.amount_of_vehicle + self.interest())
                def processing_fee(self):
                    return 0.0025 *(self.amount_of_vehicle + self.interest())
                def legal_fee(self):
                    return 0.0075 *(self.amount_of_vehicle + self.interest())
                def residual_amount(self):
                    return 0.01 * (self.amount_of_vehicle - ((self.depreciation_rate/100) * self.amount_of_vehicle *(self.tenure/12)))
                def equity_contribution(self):
                    return (self.equity/100) * self.amount_of_vehicle
                def total_amount(self):
                    return self.amount_of_vehicle+self.interest()+self.management_fee()+self.processing_fee()+self.legal_fee()+self.residual_amount() 
                def upfront_payment(self):
                    return self.management_fee() + self.processing_fee() + self.legal_fee() + self.equity_contribution() + self.residual_amount()
                def opening_balance(self):
                    return self.total_amount() - self.upfront_payment()
                def monthly_instalment(self):
                    return self.opening_balance()/self.tenure
                def LoanPaymentPlan(self):
                    months = 1
                    total_amount = self.amount_of_vehicle+self.interest()+self.management_fee()+self.processing_fee()+self.legal_fee()+self.residual_amount()
                    upfront_payment = self.management_fee()+self.processing_fee()+self.legal_fee()+self.equity_contribution()+self.residual_amount()
                    opening_balance = total_amount - upfront_payment
                    balance = opening_balance
                    while months <= self.tenure:
                        if balance > 0:
                            monthly_instalment =(opening_balance/self.tenure)
                            monthly_interest = (((self.interest_rate/100) * balance)/ 12)
                            loan_payment = monthly_instalment - monthly_interest
                            closing_balance = balance - monthly_instalment
                            print '  ',months,'  ',round(balance,2),'   ', round(monthly_instalment,2),'        ',round(monthly_interest,2) \
                            , '       ',' ',round(loan_payment,2),'     ',round(closing_balance,2)
                            balance = closing_balance
                            months += 1
                    return 'Thank you for using the Loan Calc App'

            #Creation of an instance with the name 'calc'
            calc = LoanCalc(amount_of_vehicle,tenure,interest_rate,equity,depreciation_rate)
            amountofVehicle = amount_of_vehicle
            interest = calc.interest()
            managementFee = calc.management_fee()
            processingFee = calc.processing_fee()
            legalFee = calc.legal_fee()
            residualAmount = calc.residual_amount()
            equityContribution = calc.equity_contribution()
            totalAmount = calc.total_amount()
            upfrontPayment = calc.upfront_payment()
            openingBalance = calc.opening_balance()
            loanpaymentplan =calc.LoanPaymentPlan()



            #An empty form to be displayed alongside the result
            forms = Carloan_formForm()

            #Renders a template that displays the result
            return render_to_response('carloan/result.html', {'form': forms, 'result':amountofVehicle , 'result1': interest, 'result2': managementFee, 'result3': processingFee,
                                                              'result4': legalFee, 'result5': residualAmount, 'result6': equityContribution, 'result7': totalAmount,
                                                              'result8': upfrontPayment, 'result9':openingBalance, 'result10': loanpaymentplan},
                          context_instance=RequestContext(request))
    #If the user doesn't submit the form, it displays an empty form
    else:
        form = Carloan_formForm()
    #Rendering a that template that displays an empty form
    return render_to_response('carloan/index.html', {'form': form},
                          context_instance=RequestContext(request))

from django.db import models
class LoanCalc(models.Model):
    amount_of_vehicle = models.DecimalField()
    tenure = models.DecimalField()
    interest_rate = models.DecimalField()
    equity = models.DecimalField()
    depreciation_rate = models.DecimalField()

    def interest(self):
        return((self.interest_rate/100) * self.amount_of_vehicle *(self.tenure/12))
    def management_fee(self):
        return 0.01 * (self.amount_of_vehicle + self.interest())

# views.py
from django.core.mail import send_mail
from django.template.loader import get_template
from django.template import Context

from .models import LoanCalc

def loan_calc(request, **kwargs):
    calc = LoanCalc.objects.create(**kwargs)

    # Render your calc model in a template and use send_mail to email it
    send_mail(
        'This is your loan calculation!',
        get_template('carloan/email.txt').render(
            Context({
                'calc': calc,
            })
        ),
        'you@example.com',
        ['receiver@gexample.com']
    )

    return render_to_response('carloan/result.html',
                              {'form': forms, 'calc': calc}
                              context_instance=RequestContext(request))

# result.html
<table>
    <tr>
       <td>Interest</td>
       <td>{{ calc.interest }}</td>
    </tr>
    <tr>
       <td>Management fee</td>
       <td>{{ calc.management_fee }}</td>
    </tr>
</table>

# email.txt
Hi, this is your loan calculation overview:

Interest: {{ calc.interest }}
Management fee: {{ calc.management_fee }}