apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pension Funds,养老基金
DocType: Supplier Quotation,Rounding Adjustment (Company Currency,舍入调整（公司货币
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Course is mandatory in row {0},第{0}行必修课程
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Credit Account,信用账户
DocType: Employee Tax Exemption Proof Submission,Submission Date,提交日期
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Template Code,更改模板代码
DocType: Expense Claim,Total Sanctioned Amount,总受制裁金额
DocType: Email Digest,New Expenses,新费用
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Healthcare Practitioner not available on {0},医疗从业者在{0}上不可用
DocType: Delivery Note,Transport Receipt No,运输收据编号
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Administrative Officer,行政官员
DocType: Opportunity,Probability (%),概率（％）
DocType: Soil Texture,Silty Clay Loam,粉质粘土壤土
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,WooCommerce Products,WooCommerce产品
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Account Pay Only,仅限帐户付款
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Cess,塞斯
apps/erpnext/erpnext/config/settings.py,"Set Default Values like Company, Currency, Current Fiscal Year, etc.",设置公司，货币，当前会计年度等的默认值。
apps/erpnext/erpnext/config/projects.py,Time Tracking,时间跟踪
DocType: Employee Education,Under Graduate,大学本科
DocType: Request for Quotation Item,Supplier Part No,供应商零件号
DocType: Journal Entry Account,Party Balance,党的平衡
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Source of Funds (Liabilities),资金来源（负债）
DocType: Payroll Period,Taxable Salary Slabs,应税工资板
DocType: Quality Action,Quality Feedback,质量反馈
DocType: Support Settings,Support Settings,支持设置
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please enter Production Item first,请先输入生产项目
DocType: Quiz,Grading Basis,评分基础
DocType: Stock Entry Detail,Basic Amount,基本金额
DocType: Journal Entry,Pay To / Recd From,付款/退款
DocType: BOM,Scrap Material Cost,废料成本
DocType: Material Request Item,Received Quantity,收到的数量
,Sales Person-wise Transaction Summary,销售人员交易摘要
DocType: Work Order,Actual Operating Cost,实际运营成本
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Mode of Payments,付款方式
DocType: Stock Entry,Send to Subcontractor,发送给分包商
DocType: Purchase Invoice,Select Shipping Address,选择送货地址
DocType: Student,AB-,AB-
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Summary for {0},{0}的项目摘要
apps/erpnext/erpnext/regional/india/bank_remittance.py,"{0} is mandatory for generating remittance payments, set the field and try again",{0}是生成汇款付款的必填项，请设置该字段并重试
apps/erpnext/erpnext/public/js/hub/marketplace.js,Some emails are invalid,有些电子邮件无效
DocType: Asset,Calculate Depreciation,计算折旧
DocType: Academic Term,Term Name,术语名称
DocType: Question,Question,题
DocType: Employee Tax Exemption Declaration Category,Exemption Sub Category,豁免子类别
apps/erpnext/erpnext/www/all-products/item_row.html,More Details,更多细节
DocType: Salary Component,Earning,收益
DocType: Restaurant Order Entry,Click Enter To Add,单击Enter To Add
DocType: Employee Group,Employee Group,员工组
DocType: Quality Procedure,Processes,流程
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,指定汇率以将一种货币转换为另一种货币
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 4,老化范围4
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Warehouse required for stock Item {0},库存项目{0}所需的仓库
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve criteria score function for {0}. Make sure the formula is valid.,无法解决{0}的条件评分函数。确保公式有效。
DocType: Bank Reconciliation,Include Reconciled Entries,包括已对帐条目
DocType: Purchase Invoice Item,Allow Zero Valuation Rate,允许零估值率
apps/erpnext/erpnext/templates/includes/product_list.js,Nothing more to show.,没有更多要显示。
apps/erpnext/erpnext/controllers/buying_controller.py,"Tax Category has been changed to ""Total"" because all the Items are non-stock items",税收类别已更改为“总计”，因为所有项目都是非库存项目
DocType: Salary Detail,Tax on flexible benefit,对灵活福利征税
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,This is based on the Time Sheets created against this project,这基于针对此项目创建的时间表
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Rate,购买率
DocType: Water Analysis,Type of Sample,样品类型
DocType: Budget,Budget Accounts,预算帐户
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} quantity {1} cannot be a fraction,序列号{0}数量{1}不能是分数
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock In Hand,股票在手
DocType: Workstation,Wages,工资
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,No leave record found for employee {0} for {1},找不到{1}的员工{0}的休假记录
DocType: Invoice Discounting,Accounts Receivable Unpaid Account,应收帐款未付帐户
DocType: GST Account,SGST Account,SGST账户
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date should be in between Work From Date and Work End Date,半日期应在工作日期和工作结束日期之间
DocType: Employee Boarding Activity,Applicable in the case of Employee Onboarding,适用于员工入职的情况
apps/erpnext/erpnext/controllers/buying_controller.py,Specified BOM {0} does not exist for Item {1},第{1}项不存在指定的BOM {0}
apps/erpnext/erpnext/config/accounting.py,Company (not Customer or Supplier) master.,公司（非客户或供应商）主人。
DocType: Shopify Settings,Sales Invoice Series,销售发票系列
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Asset Movement record {0} created,已创建资产移动记录{0}
DocType: Lab Prescription,Test Created,测试创建
DocType: Academic Term,Term Start Date,学期开始日期
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment {0} and Sales Invoice {1} cancelled,约会{0}和销售发票{1}已取消
DocType: Purchase Receipt,Vehicle Number,车号
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Your email address...,您的电子邮件地址...
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Include Default Book Entries,包括默认工作簿条目
DocType: Activity Cost,Activity Type,活动类型
DocType: Purchase Invoice,Get Advances Paid,获得进展支付
DocType: Company,Gain/Loss Account on Asset Disposal,资产处置的损益账户
DocType: GL Entry,Voucher No,凭证号码
DocType: Item,Reorder level based on Warehouse,根据仓库重新订购级别
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,"Stopped Work Order cannot be cancelled, Unstop it first to cancel",已停止的工作订单无法取消，请先停止取消
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,{0} Serial Numbers required for Item {1}. You have provided {2}.,项目{1}需要{0}序列号。您提供了{2}。
DocType: Customer,Customer Primary Contact,客户主要联系人
DocType: Purchase Order Item Supplied,BOM Detail No,BOM详细信息
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Cash In Hand,手头现金
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,The holiday on {0} is not between From Date and To Date,{0}上的假日不在“起始日期”和“结束日期”之间
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Lead must be set if Opportunity is made from Lead,如果机会由Lead制作，则必须设置潜在客户
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be converted to group.,具有现有事务的帐户无法转换为组。
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Timesheet {0} is already completed or cancelled,时间表{0}已完成或取消
DocType: Terms and Conditions,"Standard Terms and Conditions that can be added to Sales and Purchases.

Examples:

1. Validity of the offer.
1. Payment Terms (In Advance, On Credit, part advance etc).
1. What is extra (or payable by the Customer).
1. Safety / usage warning.
1. Warranty if any.
1. Returns Policy.
1. Terms of shipping, if applicable.
1. Ways of addressing disputes, indemnity, liability, etc.
1. Address and Contact of your Company.",可添加到销售和采购的标准条款和条件。示例：1。要约的有效性。 1.付款条款（提前，贷方，部分预付等）。 1.什么是额外的（或由客户支付）。 1.安全/使用警告。 1.保修，如果有的话。 1.退货政策。 1.运输条款（如适用）。 1.解决纠纷，赔偿，责任等的方式1.贵公司的地址和联系方式。
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Status Notification,离开状态通知
DocType: Designation Skill,Designation Skill,指定技巧
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity required for Item {0} in row {1},行{1}中的项{0}所需的数量
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"To filter based on Party, select Party Type first",要根据派对进行过滤，请先选择派对类型
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,No Salary Structure assigned for Employee {0} on given date {1},在给定日期{1}没有为员工{0}分配薪资结构
DocType: Prescription Duration,Number,数
DocType: Student Group Creation Tool,Separate course based Group for every Batch,每个批次单独的基于课程的组
DocType: Healthcare Settings,Require Lab Test Approval,需要实验室测试批准
DocType: Bank Reconciliation,Update Clearance Date,更新清关日期
DocType: Chart of Accounts Importer,Import Chart of Accounts from a csv file,从csv文件导入科目表
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Support for public app is deprecated. Please setup private app, for more details refer user manual",不推荐使用对公共应用的支持。请设置私人应用，有关详细信息，请参阅用户手册
DocType: Contract,Signed,签
DocType: Purchase Invoice,Terms and Conditions1,条款和条件1
apps/erpnext/erpnext/hr/doctype/department_approver/department_approver.py,Please select Employee Record first.,请先选择员工记录。
apps/erpnext/erpnext/hr/doctype/hr_settings/hr_settings.py,Password policy for Salary Slips is not set,未设置Salary Slips的密码策略
DocType: Assessment Result Tool,Result HTML,结果HTML
DocType: Agriculture Task,Ignore holidays,忽略假期
DocType: Linked Soil Texture,Linked Soil Texture,连接的土壤纹理
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle_dashboard.py,This is based on logs against this Vehicle. See timeline below for details,这是基于针对此Vehicle的日志。请参阅下面的时间表了解详情
DocType: Payment Entry,ACC-PAY-.YYYY.-,ACC-PAY-.YYYY.-
DocType: Employee,Emergency Contact,紧急联系人
DocType: QuickBooks Migrator,Authorization URL,授权URL
DocType: Attendance,On Leave,休假
DocType: Item,Show a slideshow at the top of the page,在页面顶部显示幻灯片
DocType: Cheque Print Template,Payer Settings,付款人设置
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Set Tax Rule for shopping cart,为购物车设置税收规则
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,In Production,在生产中
DocType: Payment Entry,Payment References,付款参考
DocType: Fee Validity,Valid Till,有效期至
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0}: From {0} of type {1},{0}：来自{1}类型的{0}
DocType: Request for Quotation Item,Project Name,项目名
DocType: Purchase Invoice Item,Stock Qty,库存数量
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Child Item should not be a Product Bundle. Please remove item `{0}` and save,子项不应该是产品包。请删除项目“{0}”并保存
DocType: Support Search Source,Response Result Key Path,响应结果密钥路径
DocType: Travel Request,Fully Sponsored,完全赞助
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,Not permitted. Please disable the Service Unit Type,不允许。请禁用服务单位类型
DocType: POS Profile,Offline POS Settings,离线POS设置
DocType: Supplier Scorecard Period,Calculations,计算
DocType: Production Plan,Material Requested,要求的材料
DocType: Payment Reconciliation Payment,Reference Row,参考行
DocType: Leave Policy Detail,Annual Allocation,年度分配
DocType: Buying Settings,Subcontract,分包
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Valuation type charges can not marked as Inclusive,估价类型的费用不能标记为包含
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not belong to company: {2},帐户{0}：父帐户{1}不属于公司：{2}
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to login,登录失败
apps/erpnext/erpnext/config/buying.py,Items and Pricing,物品和定价
DocType: Payment Terms Template,Payment Terms Template,付款条款模板
DocType: Employee,Previous Work Experience,以前的工作经验
DocType: Assessment Plan,Program,程序
DocType: Antibiotic,Healthcare,卫生保健
DocType: Complaint,Complaint,抱怨
DocType: Shipping Rule,Restrict to Countries,限制国家
DocType: Hub Tracked Item,Item Manager,项目经理
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Currency of the Closing Account must be {0},结算账户的货币必须为{0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Budgets,预算
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Opening Invoice Item,打开发票项目
DocType: Work Order,Plan material for sub-assemblies,规划子组件的材料
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Hardware,硬件
DocType: Budget,Action if Annual Budget Exceeded on MR,如果年度预算超过MR，则采取行动
DocType: Sales Invoice Advance,Advance Amount,提前金额
DocType: Accounting Dimension,Dimension Name,尺寸名称
DocType: Delivery Note Item,Against Sales Invoice Item,针对销售发票项目
DocType: Expense Claim,HR-EXP-.YYYY.-,HR-EXP-.YYYY.-
DocType: BOM Explosion Item,Include Item In Manufacturing,包括制造业中的项目
DocType: Item Reorder,Check in (group),入住（团体）
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,不要在货币旁边显示任何符号，如$ etc。
DocType: Additional Salary,Salary Component Type,薪资组件类型
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shareholder does not belong to this company,股东不属于该公司
DocType: Payment Term,Day(s) after the end of the invoice month,发票月结束后的一天
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Vehicle Type,车辆类型
DocType: Antibiotic,Healthcare Administrator,医疗管理员
DocType: Tax Withholding Rate,Single Transaction Threshold,单一交易阈值
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Broadcasting,广播
DocType: Support Search Source,Post Title Key,帖子标题键
DocType: Customer,Customer Primary Address,客户主要地址
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select batches for batched item ,请选择批次项目的批次
DocType: Pricing Rule,Min Qty,最小数量
DocType: Payment Entry,Payment Deductions or Loss,付款扣除或损失
DocType: Purchase Taxes and Charges,On Item Quantity,关于物品数量
apps/erpnext/erpnext/config/manufacturing.py,Replace BOM and update latest price in all BOMs,替换BOM并更新所有BOM中的最新价格
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Both Trial Period Start Date and Trial Period End Date must be set,必须设置试用期开始日期和试用期结束日期
apps/erpnext/erpnext/templates/pages/projects.html,No time sheets,没有时间表
DocType: Bank Statement Settings,Statement Header Mapping,语句标题映射
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Half Day,马克半日
DocType: Stock Entry,Material Transfer for Manufacture,制造材料转移
DocType: Supplier,Block Supplier,阻止供应商
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter Woocommerce Server URL,请输入Woocommerce Server URL
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Place,从地方
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,No contacts with email IDs found.,找不到与电子邮件ID的联系人。
DocType: Clinical Procedure,Consumption Invoiced,消费已开票
DocType: Bin,Requested Quantity,请求的数量
DocType: Student,Exit,出口
DocType: Delivery Stop,Dispatch Information,发货信息
DocType: BOM Scrap Item,Basic Amount (Company Currency),基本金额（公司货币）
DocType: Selling Settings,Selling Settings,销售设置
apps/erpnext/erpnext/education/doctype/question/question.py,A question must have more than one options,一个问题必须有多个选项
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Please set the Date Of Joining for employee {0},请为员工{0}设置加入日期
apps/erpnext/erpnext/public/js/hub/components/profile_dialog.js,About your company,关于你的公司
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} does not exist,会计年度{0}不存在
DocType: Attendance,Leave Application,离开应用程序
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Maintenance Log,维护日志
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid Posting Time,发布时间无效
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount,折扣
DocType: Sales Invoice,Redeem Loyalty Points,兑换忠诚度积分
DocType: Shopping Cart Settings,Quotation Series,报价系列
DocType: Guardian,Occupation,占用
DocType: Item,Opening Stock,上市股票
DocType: Supplier Scorecard,Supplier Score,供应商分数
DocType: POS Profile,Only show Items from these Item Groups,仅显示这些项目组中的项目
DocType: Job Card Time Log,Time In Mins,分钟时间
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item {0} does not exist in the system or has expired,项目{0}在系统中不存在或已过期
DocType: Pricing Rule,Price Discount Scheme,价格折扣计划
DocType: Vital Signs,Hyper,超
apps/erpnext/erpnext/public/js/setup_wizard.js,What does it do?,它有什么作用？
,Sales Invoice Trends,销售发票趋势
DocType: Bank Reconciliation,Payment Entries,付款条目
DocType: Employee Education,Class / Percentage,等级/百分比
,Electronic Invoice Register,电子发票登记
DocType: Shift Type,The number of occurrence after which the consequence is executed.,执行结果的发生次数。
DocType: Sales Invoice,Is Return (Credit Note),是回报（信用证）
DocType: Price List,Price Not UOM Dependent,价格不是UOM依赖
DocType: Lab Test Sample,Lab Test Sample,实验室测试样品
DocType: Shopify Settings,status html,状态html
DocType: Fiscal Year,"For e.g. 2012, 2012-13",例如，2012年，2012年13月
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,disabled user,禁用用户
DocType: Amazon MWS Settings,ES,ES
DocType: Warehouse,Warehouse Type,仓库类型
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Quick Journal Entry,快速入学
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Consumed Amount,消费金额
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Already completed,已经完成
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Pending Amount,待定金额
DocType: Supplier,Warn RFQs,警告RFQ
DocType: Lab Prescription,Lab Prescription,实验室处方
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Available-for-use Date,折旧行{0}：下一个折旧日期不能在可用日期之前
DocType: Certification Application,USD,美元
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,"Asset {0} cannot be scrapped, as it is already {1}",资产{0}无法废弃，因为它已经{1}
DocType: Delivery Trip,Departure Time,出发时间
DocType: Donor,Donor Type,捐助者类型
DocType: Company,Monthly Sales Target,每月销售目标
DocType: Loyalty Point Entry Redemption,Redemption Date,赎回日期
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving User cannot be same as user the rule is Applicable To,批准用户不能与规则适用的用户相同
DocType: Fee Schedule Student Group,Fee Schedule Student Group,收费表学生组
apps/erpnext/erpnext/projects/report/billing_summary.py, From Date can not be greater than To Date,从日期不能大于到日期
apps/erpnext/erpnext/public/js/queries.js,Please specify a {0},请指定{0}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To GSTIN,到GSTIN
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be earlier than the Term Start Date. Please correct the dates and try again.,期限结束日期不能早于期限开始日期。请更正日期，然后重试。
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,No Employee Found,找不到员工
DocType: Employee Tax Exemption Declaration Category,Exemption Category,豁免类别
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Disbursement Entry,创建支付条目
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Purpose must be one of {0},目的必须是{0}之一
DocType: Content Activity,Last Activity ,上次活动
DocType: Crop Cycle,A link to all the Locations in which the Crop is growing,指向作物生长的所有位置的链接
apps/erpnext/erpnext/education/doctype/course_activity/course_activity.py,Course Enrollment {0} does not exists,课程注册{0}不存在
apps/erpnext/erpnext/hr/doctype/leave_policy/leave_policy.py,Maximum leave allowed in the leave type {0} is {1},休假类型{0}允许的最大休假为{1}
,Qty to Transfer,转移数量
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Group) for type - {0},请为类型{0}标识/创建帐户（组）
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Please set default customer group and territory in Selling Settings,请在“销售设置”中设置默认客户组和区域
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,There isn't any item variant for the selected item,所选项目没有任何项目变体
DocType: Contract,Contract Details,合同细节
DocType: Customer,"Select, to make the customer searchable with these fields",选择，使客户可以使用这些字段进行搜索
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Actual,实际总数
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Code,改变代码
DocType: Crop,Planting Area,种植面积
DocType: Leave Control Panel,Employee Grade (optional),员工等级（可选）
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Cost Center For Item with Item Code ',包含物料代码的物料的成本中心
DocType: Stock Settings,Default Stock UOM,默认股票UOM
DocType: Workstation,Rent Cost,租金成本
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Result,培训结果
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order not created,工作订单未创建
apps/erpnext/erpnext/utilities/user_progress.py,Meter,仪表
DocType: Course,Hero Image,英雄形象
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,No Items to pack,没有要打包的物品
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery warehouse required for stock item {0},库存商品{0}需要交货仓库
apps/erpnext/erpnext/controllers/buying_controller.py,Reserved Warehouse is mandatory for Item {0} in Raw Materials supplied,预留仓库对于提供的原材料中的项目{0}是必需的
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Target Location is required for the asset {0},资产{0}需要目标位置
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,SGST Amount,SGST金额
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'",帐户余额已在Credit中，您不能将&#39;Balance Must Be&#39;设置为&#39;借记&#39;
DocType: GSTR 3B Report,GSTR 3B Report,GSTR 3B报告
DocType: BOM Item,Rate & Amount,费率和金额
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To is required,借记付款是必需的
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Item Name,项目名称
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of New Purchase,新购买成本
DocType: Customer,Additional information regarding the customer.,有关客户的其他信息。
DocType: Quiz Result,Wrong,错误
apps/erpnext/erpnext/config/help.py,Batch Inventory,批量库存
DocType: HR Settings,"The salary slip emailed to the employee will be password protected, the password will be generated based on the password policy.",通过电子邮件发送给员工的工资单将受密码保护，密码将根据密码策略生成。
DocType: Payment Entry,Received Amount,收到金额
DocType: Item,Is Sales Item,是销售项目
apps/erpnext/erpnext/accounts/doctype/payment_order/regional/india.js,Generate Text File,生成文本文件
DocType: Item,Variants,变种
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,"Charges will be distributed proportionately based on item qty or amount, as per your selection",根据您的选择，费用将根据项目数量或金额按比例分配
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Pending activities for today,今天有待开展的活动
DocType: Quality Procedure Process,Quality Procedure Process,质量程序流程
DocType: Fee Schedule Program,Student Batch,学生批量
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Valuation Rate required for Item in row {0},第{0}行中项目所需的估价率
DocType: BOM Operation,Base Hour Rate(Company Currency),基本小时费率（公司货币）
DocType: Job Offer,Printing Details,印刷细节
DocType: Asset Repair,Manufacturing Manager,制造经理
DocType: BOM,Job Card,工作卡
DocType: Subscription Settings,Prorate,按比例分配
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.",系统用户（登录）ID。如果设置，它将成为所有HR表单的默认值。
apps/erpnext/erpnext/public/js/pos/pos.html,All Item Groups,所有项目组
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Status,选择状态
DocType: Subscription Plan,Fixed rate,固定利率
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Airline,航空公司
DocType: Quotation,Term Details,期限细节
DocType: Vehicle,Acquisition Date,购买日期
DocType: SMS Center,Send To,发送至
apps/erpnext/erpnext/accounts/report/share_balance/share_balance.py,Average Rate,平均率
DocType: Stock Settings,Set Qty in Transactions based on Serial No Input,根据Serial No Input在Transactions中设置Qty
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Advance account currency should be same as company currency {0},预付账户货币应与公司货币{0}相同
apps/erpnext/erpnext/portal/doctype/homepage/homepage.js,Customize Homepage Sections,自定义主页部分
DocType: GSTR 3B Report,October,十月
DocType: Selling Settings,Hide Customer's Tax Id from Sales Transactions,从销售交易中隐藏客户的税务ID
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! A GSTIN must have 15 characters.,GSTIN无效！ GSTIN必须有15个字符。
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Pricing Rule {0} is updated,定价规则{0}已更新
DocType: Contract Fulfilment Checklist,Contract Fulfilment Checklist,合同履行清单
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,All Products,所有产品
apps/erpnext/erpnext/www/all-products/index.html,Product Search,产品搜索
DocType: Salary Slip,Net Pay,净薪酬
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Invoiced Amt,总发票金额
DocType: Clinical Procedure,Consumables Invoice Separately,耗材单独发票
DocType: Shift Type,Working Hours Threshold for Absent,缺勤的工作时间门槛
DocType: Appraisal,HR-APR-.YY.-.MM.,HR-APR-.YY.-.MM。
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Budget cannot be assigned against Group Account {0},无法针对组帐户{0}分配预算
DocType: Purchase Receipt Item,Rate and Amount,费率和金额
DocType: Patient Appointment,Check availability,检查可用性
apps/erpnext/erpnext/public/js/controllers/transaction.js,Cannot find Item with this barcode,找不到包含此条形码的物品
DocType: Hotel Settings,Default Invoice Naming Series,默认发票命名系列
DocType: Student Siblings,Student Siblings,学生兄弟姐妹
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Journal Entry {0} does not have account {1} or already matched against other voucher,日记帐分录{0}没有帐户{1}或已与其他凭证匹配
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Legal Expenses,法律费用
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Checkout,查看
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Membership Details,会员详情
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Customer Address,请设置客户地址
apps/erpnext/erpnext/utilities/user_progress.py,List your products or services that you buy or sell.,列出您购买或出售的产品或服务。
DocType: Account,Income,收入
DocType: Account,Rate at which this tax is applied,适用此税的税率
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Payment Receipt Note,付款收据
DocType: Asset Finance Book,In Percentage,百分比
apps/erpnext/erpnext/config/buying.py,Quotations received from Suppliers.,从供应商处收到的报价。
DocType: Journal Entry Account,Reference Due Date,参考截止日期
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Lead Time Days,提前期
DocType: Quality Goal,Revision and Revised On,修订和修订
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Purchase Order {1},{0}针对采购订单{1}
apps/erpnext/erpnext/education/doctype/program_enrollment/program_enrollment.py,Fee Records Created - {0},已创建费用记录 -  {0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Note: {0},注意：{0}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} has already been received,已收到序列号{0}
DocType: HR Settings,Leave Settings,离开设置
DocType: Delivery Note,Issue Credit Note,发行信用票据
,Batch Item Expiry Status,批次项目到期状态
apps/erpnext/erpnext/config/stock.py,Stock Transactions,股票交易
apps/erpnext/erpnext/hr/notification/training_scheduled/training_scheduled.html,Event Location,活动地点
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Motion Picture & Video,电影和视频
DocType: Crop,Row Spacing,行间距
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Account number for account {0} is not available.<br> Please setup your Chart of Accounts correctly.,帐户{0}的帐号不可用。 <br>请正确设置您的会计科目表。
DocType: Cheque Print Template,Starting location from left edge,从左边缘开始的位置
DocType: HR Settings,HR Settings,HR设置
DocType: Healthcare Practitioner,Appointments,约会
apps/erpnext/erpnext/controllers/buying_controller.py,Asset {0} created,已创建资产{0}
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch,选择批处理
DocType: BOM,Item Description,商品描述
DocType: Account,Account Name,用户名
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Key,请输入API Consumer Key
DocType: Products Settings,Products per Page,每页产品
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Duplicate {0} found in the table,表中找到重复的{0}
DocType: Global Defaults,Default Distance Unit,默认距离单位
DocType: Clinical Procedure,Consume Stock,消费股票
DocType: Appraisal Template Goal,Key Performance Area,关键绩效领域
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,S.O. No.,所以不行。
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,{0} not found for item {1},项目{1}找不到{0}
DocType: Sales Invoice,Set Source Warehouse,设置源仓库
DocType: Healthcare Settings,Out Patient Settings,出患者设置
DocType: Asset,Insurance End Date,保险结束日期
DocType: Bank Account,Branch Code,分行代码
apps/erpnext/erpnext/public/js/conf.js,User Forum,用户论坛
DocType: Landed Cost Item,Landed Cost Item,登陆成本项目
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The seller and the buyer cannot be the same,卖方和买方不能相同
DocType: Project,Copied From,复制自
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Available,可得到
DocType: Sales Person,Sales Person Targets,销售人员目标
DocType: BOM Operation,BOM Operation,BOM操作
DocType: Student,O-,O-
DocType: Repayment Schedule,Interest Amount,利息金额
DocType: Water Analysis,Origin,起源
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Add a new address,添加新地址
DocType: POS Profile,Write Off Account,注销账户
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal/Price Quote,提案/报价
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Associate,关联
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please input all required Result Value(s),请输入所有必需的结果值
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,提供的采购订单项目
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Item {0} is not a serialized Item,项{0}不是序列化项
DocType: GoCardless Mandate,GoCardless Customer,GoCardless客户
DocType: Leave Encashment,Leave Balance,保持平衡
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule {0} exists against {1},对{1}存在维护计划{0}
DocType: Assessment Plan,Supervisor Name,主管姓名
DocType: Selling Settings,Campaign Naming By,广告系列命名
DocType: Student Group Creation Tool Course,Course Code,科目编号
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Aerospace,航天
DocType: Landed Cost Voucher,Distribute Charges Based On,基于的分配费用
DocType: Supplier Scorecard Scoring Criteria,Supplier Scorecard Scoring Criteria,供应商记分卡评分标准
DocType: Account,Stock,股票
DocType: Landed Cost Item,Receipt Document Type,收据凭证类型
DocType: Territory,Classification of Customers by region,按地区划分的客户分类
DocType: Hotel Room Amenity,Billable,计费
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Government,政府
apps/erpnext/erpnext/utilities/activation.py,"Create Employee records to manage leaves, expense claims and payroll",创建员工记录以管理假期，费用索赔和工资单
apps/erpnext/erpnext/config/help.py,Point-of-Sale,销售点
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner.py,User {0} is already assigned to Healthcare Practitioner {1},用户{0}已分配给Healthcare Practitioner {1}
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Buying,标准购买
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Apprentice,学徒
apps/erpnext/erpnext/utilities/activation.py,Add Timesheets,添加Timesheets
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Number of new Account, it will be included in the account name as a prefix",新帐户的数量，它将作为前缀包含在帐户名称中
apps/erpnext/erpnext/controllers/buying_controller.py,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,分包合同采购收据的强制性供应商仓库
apps/erpnext/erpnext/hr/doctype/employee/employee.js,Please enter Preferred Contact Email,请输入首选联系电子邮件
DocType: Vital Signs,Normal,正常
DocType: Customer,Customer POS Id,客户POS ID
DocType: Purchase Invoice Item,Weight Per Unit,每单位重量
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,Child nodes can be only created under 'Group' type nodes,子节点只能在“组”类型节点下创建
DocType: Share Transfer,(including),（包含）
,Requested,要求
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is not a stock Item,料品{0}不是库存料品
DocType: Journal Entry,Multi Currency,多币种
DocType: Payment Entry,Write Off Difference Amount,注销差额金额
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is disabled,项目{0}已禁用
DocType: Asset Maintenance Task,Last Completion Date,上次完成日期
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order_dashboard.py,Fulfillment,履行
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"The task has been enqueued as a background job. In case there is any issue on processing in background, the system will add a comment about the error on this Stock Reconciliation and revert to the Draft stage",该任务已被列入后台工作。如果在后台处理有任何问题，系统将在此库存对帐中添加有关错误的注释，并恢复到草稿阶段
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Considered,考虑总订单
DocType: Delivery Trip,Optimize Route,优化路线
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Discount Percentage can be applied either against a Price List or for all Price List.,折扣百分比可以应用于价格清单或所有价格清单。
DocType: Training Event,Trainer Email,培训师电子邮件
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Get from Patient Encounter,来自患者遭遇
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Software Developer,软件开发师
DocType: Clinical Procedure Template,Sample Collection,样品采集
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Please share your feedback to the training by clicking on 'Training Feedback' and then 'New',请点击“培训反馈”然后点击“新建”，分享您对培训的反馈意见
DocType: QuickBooks Migrator,Connecting to QuickBooks,连接到QuickBooks
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enrolling student,注册学生
DocType: Employee Advance,Claimed,声称
apps/erpnext/erpnext/config/hr.py,Leaves,树叶
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,基于盈余和扣减的薪资分手。
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Structure Missing,薪资结构缺失
DocType: Setup Progress Action,Action Field,行动领域
,Quotation Trends,报价趋势
apps/erpnext/erpnext/config/integrations.py,Connect Amazon with ERPNext,将Amazon与ERPNext连接起来
DocType: Service Level Agreement,Response and Resolution Time,响应和解决时间
DocType: Loyalty Program,Collection Tier,收集层
DocType: Guardian,Guardian Of ,守护者
DocType: Payment Request,Payment Gateway Details,支付网关详情
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Staffing Plan {0} already exist for designation {1},指定{1}的人员配备计划{0}已存在
DocType: Item,Website Warehouse,网站仓库
DocType: Sales Invoice Item,Rate With Margin,保证金率
apps/erpnext/erpnext/regional/india/utils.py,Salary Structure must be submitted before submission of Tax Ememption Declaration,薪酬结构必须在提交税务征收声明之前提交
apps/erpnext/erpnext/public/js/event.js,Add Leads,添加潜在客户
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reserve Warehouse,储备仓库
DocType: Payment Term,Payment Term Name,付款条款名称
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,No Permission,没有许可
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Company...,选择公司......
DocType: Stock Settings,Use Naming Series,使用命名系列
DocType: Salary Component,Formula,式
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on Actual,如果累计每月预算超过实际数量，则采取措施
DocType: Leave Type,Allow Encashment,允许兑现
apps/erpnext/erpnext/config/projects.py,Project activity / task.,项目活动/任务。
DocType: Bank Statement Transaction Invoice Item,Bank Statement Transaction Invoice Item,银行对账单交易发票项目
DocType: Work Order,Total Operating Cost,总运营成本
DocType: Employee Onboarding,Employee Onboarding Template,员工入职模板
DocType: Pricing Rule,Same Item,相同的项目
apps/erpnext/erpnext/regional/india/bank_remittance.py,"Amount for a single transaction exceeds maximum allowed amount, create a separate payment order by splitting the transactions",单笔交易的金额超过最大允许金额，通过拆分交易创建单独的付款订单
DocType: Payroll Entry,Salary Slips Created,工资单创建
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,Lab Test(s) ,实验室测试
DocType: Payment Request,Party Details,派对细节
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Purchased Items,购买物品的成本
apps/erpnext/erpnext/support/doctype/issue/issue.js,All communications including and above this shall be moved into the new Issue,包括及以上的所有通信都应移入新的期刊
DocType: Stock Entry,Material Consumption for Manufacture,制造材料消耗
DocType: Item Website Specification,Table for Item that will be shown in Web Site,将在网站中显示的项目表
DocType: Restaurant Menu,Restaurant Menu,餐厅菜单
DocType: Asset Movement,Purpose,目的
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,Salary Structure Assignment for Employee already exists,员工的薪酬结构分配已经存在
DocType: Clinical Procedure,Service Unit,服务单位
DocType: Travel Request,Identification Document Number,身份证明文件号码
DocType: Stock Entry,Additional Costs,额外费用
DocType: Employee Education,Employee Education,员工教育
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.js,Number of positions cannot be less then current count of employees,职位数量不能少于当前的员工数量
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Customer Groups,所有客户群
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Buying Price List,购买价格表
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Finished Good Item Code,成品商品代码
apps/erpnext/erpnext/controllers/accounts_controller.py,Multiple fiscal years exist for the date {0}. Please set company in Fiscal Year,日期{0}存在多个会计年度。请在财年设置公司
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available for use date is required,需要使用日期
DocType: Employee Training,Training Date,培训日期
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Reading Uploaded File,阅读上传的文件
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material Request,材料要求
DocType: Payment Entry,Total Allocated Amount (Company Currency),总分配金额（公司货币）
DocType: Restaurant Order Entry Item,Restaurant Order Entry Item,餐厅订单输入项目
DocType: Delivery Stop,Distance,距离
DocType: Amazon MWS Settings,Get financial breakup of Taxes and charges data by Amazon ,亚马逊获得税收和收费数据的财务分解
DocType: Vehicle Service,Mileage,里程
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be positive number",对于项目{0}，数量必须为正数
apps/erpnext/erpnext/public/js/pos/pos.html,Item Cart,物品车
apps/erpnext/erpnext/accounts/utils.py,Payment Entries {0} are un-linked,付款条目{0}未链接
DocType: Email Digest,Open Notifications,打开通知
apps/erpnext/erpnext/accounts/doctype/bank_statement_transaction_entry/bank_statement_transaction_entry.py,Successfully created payment entries,已成功创建付款条目
DocType: Soil Analysis,Mg/K,镁/ K
DocType: Item,Has Serial No,有序列号
DocType: Asset Maintenance,Manufacturing User,制造用户
apps/erpnext/erpnext/accounts/doctype/account/account.js,Ledger,莱杰
DocType: Journal Entry Account,Loan,贷款
DocType: Vehicle,Fuel UOM,燃料UOM
DocType: Issue,Support,支持
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid Company for Inter Company Transaction.,公司间交易的公司无效。
DocType: Company,Fixed Asset Depreciation Settings,固定资产折旧设置
DocType: Employee,Department and Grade,部门和年级
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Cheques Required,检查必需
DocType: Lead,Do Not Contact,不要联系
DocType: Sales Invoice,Update Billed Amount in Sales Order,更新销售订单中的结算金额
DocType: Travel Itinerary,Meal Preference,饮食偏好
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:",即使有多个具有最高优先级的定价规则，也会应用以下内部优先级：
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is not active or does not exist,员工{0}未处于活动状态或不存在
apps/erpnext/erpnext/config/accounting.py,List of all share transactions,所有股票交易清单
DocType: Item Default,Sales Defaults,销售默认值
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Overlap in scoring between {0} and {1},{0}和{1}之间的评分重叠
DocType: Course Assessment Criteria,Weightage,权重
DocType: Bank Statement Transaction Entry,Create New Payment/Journal Entry,创建新的付款/日记帐分录
DocType: Attendance,HR-ATT-.YYYY.-,HR-ATT-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If two or more Pricing Rules are found based on the above conditions, Priority is applied. Priority is a number between 0 to 20 while default value is zero (blank). Higher number means it will take precedence if there are multiple Pricing Rules with same conditions.",如果根据上述条件找到两个或更多定价规则，则应用优先级。优先级是介于0到20之间的数字，而默认值为零（空白）。数字越大意味着如果有多个具有相同条件的定价规则，它将优先。
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Qty is mandatory,行{0}：数量是强制性的
DocType: Sales Invoice,Against Income Account,反对收入账户
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Purchase Invoice cannot be made against an existing asset {1},行＃{0}：无法对现有资产{1}进行采购发票
apps/erpnext/erpnext/config/buying.py,Rules for applying different promotional schemes.,适用不同促销计划的规则。
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,UOM coversion factor required for UOM: {0} in Item: {1},UOM所需的UOM转换因子：项目中的{0}：{1}
apps/erpnext/erpnext/buying/utils.py,Please enter quantity for Item {0},请输入项目{0}的数量
DocType: Workstation,Electricity Cost,电费
DocType: Vehicle Service,Vehicle Service,车辆服务
apps/erpnext/erpnext/config/help.py,Making Stock Entries,制作股票
DocType: Bank Guarantee,Fixed Deposit Number,定期存款编号
DocType: Vital Signs,Very Coated,非常涂层
DocType: Delivery Trip,Initial Email Notification Sent,已发送初始电子邮件通知
DocType: Production Plan,For Warehouse,对于仓库
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"{0}: Employee email not found, hence email not sent",{0}：找不到员工电子邮件，因此未发送电子邮件
DocType: Currency Exchange,From Currency,来自货币
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Return / Debit Note,退货/借记通知单
DocType: Homepage Section,"Order in which sections should appear. 0 is first, 1 is second and so on.",应该出现哪些部分的顺序。 0是第一个，1是第二个，依此类推。
apps/erpnext/erpnext/utilities/activation.py,Create Sales Orders to help you plan your work and deliver on-time,创建销售订单以帮助您规划工作并按时交付
apps/erpnext/erpnext/templates/includes/cart.js,Something went wrong!,有些不对劲！
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Healthcare Service,请选择医疗保健服务
DocType: Leave Application,Apply / Approve Leaves,申请/批准离开
DocType: Leave Block List,Applies to Company,适用于公司
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Row {0}: Bill of Materials not found for the Item {1},行{0}：找不到项目的物料清单{1}
DocType: Loan,Account Info,帐户信息
DocType: Item Attribute Value,Abbreviation,缩写
DocType: Email Digest,Purchase Orders to Bill,向比尔购买订单
DocType: Purchase Invoice,Total Net Weight,总净重
DocType: Authorization Rule,Approving Role (above authorized value),批准角色（高于授权价值）
DocType: Employee Advance,HR-EAD-.YYYY.-,HR-EAD-.YYYY.-
DocType: Job Applicant,Resume Attachment,恢复附件
DocType: Agriculture Analysis Criteria,Agriculture Manager,农业经理
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batch Entries,批量条目
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Purchase Order and Applicable on Booking Actual Expenses,请启用适用于采购订单并适用于预订实际费用
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Gain/Loss on Asset Disposal,资产处置的收益/损失
DocType: Loan,Total Payment,付款总额
DocType: Asset,Total Number of Depreciations,折旧总数
DocType: Asset,Fully Depreciated,完全贬值
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Creating Accounts,创建帐户
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant Settings,项目变体设置
DocType: Supplier Group,Supplier Group Name,供应商组名称
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Sales Price List,销售价格表
DocType: Email Digest,How frequently?,多久一次？
DocType: Purchase Invoice,Supplier Warehouse,供应商仓库
DocType: Salary Component,Only Tax Impact (Cannot Claim But Part of Taxable Income),只有税收影响（不能申请部分应纳税所得额）
DocType: Item Default,Purchase Defaults,购买默认值
DocType: Contract,Contract Template,合同模板
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Batch {1},序列号{0}不属于批处理{1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Pending Leaves,等待叶子
DocType: Student Applicant,Applied,应用的
DocType: Clinical Procedure,Consumption Details,消费细节
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.html,Loading Payment System,加载付款系统
DocType: Assessment Plan,Maximum Assessment Score,最高评估分数
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Status Notification in HR Settings.,请在HR设置中为“保留状态通知”设置默认模板。
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Report Card,学生报告卡
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Nature Of Supplies,供应的性质
DocType: Shopify Settings,Last Sync Datetime,上次同步日期时间
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Code {0} already exist,代码{0}已存在
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Based On Payment Terms,根据付款条款
DocType: Lab Test Template,This value is updated in the Default Sales Price List.,此值在“默认销售价格清单”中更新。
DocType: Special Test Template,Special Test Template,特殊测试模板
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variants,创建变体
DocType: Item Default,Default Expense Account,默认费用帐户
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Please setup Students under Student Groups,请在学生组下设置学生
apps/erpnext/erpnext/regional/india/utils.py,Taxable Amount,应税金额
DocType: Lead,Lead Owner,主人
DocType: Share Transfer,Transfer,传递
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Search Item (Ctrl + i),搜索项目（Ctrl + i）
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,{0} Result submittted,{0}结果已提交
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,From date can not be greater than than To date,从日期开始不能大于To date
DocType: Supplier,Supplier of Goods or Services.,商品或服务供应商。
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Name of new Account. Note: Please don't create accounts for Customers and Suppliers,新帐户的名称。注意：请不要为客户和供应商创建帐户
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Student Group or Course Schedule is mandatory,学生组或课程表是强制性的
DocType: Tax Rule,Sales Tax Template,销售税模板
DocType: BOM,Routing,路由
DocType: Payment Reconciliation,Payment Reconciliation,付款对帐
apps/erpnext/erpnext/config/accounting.py,Match non-linked Invoices and Payments.,匹配未链接的发票和付款。
apps/erpnext/erpnext/utilities/user_progress.py,Opening Balances,期初余额
DocType: Supplier,PAN,泛
DocType: Work Order,Operation Cost,运营成本
DocType: Bank Guarantee,Name of Beneficiary,受益人姓名
apps/erpnext/erpnext/public/js/templates/address_list.html,New Address,新地址
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"Subsidiary companies have already planned for {1} vacancies at a budget of {2}. \
				Staffing Plan for {0} should allocate more vacancies and budget for {3} than planned for its subsidiary companies",子公司已计划{1}的预算为{1}空缺。 \ {0}的人员配置计划应为{3}分配比其子公司更多的空缺和预算
DocType: Stock Entry,From BOM,来自BOM
DocType: Program Enrollment Tool,Student Applicant,学生申请人
DocType: Leave Application,Leave Balance Before Application,申请前请保持平衡
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Expiry date is mandatory for selected item,所选项目必须有效期限
DocType: Stock Entry,Default Target Warehouse,默认目标仓库
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Show Salary Slip,显示薪资单
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py,Percentage Allocation should be equal to 100%,百分比分配应等于100％
DocType: Purchase Invoice Item,UOM Conversion Factor,UOM转换因子
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Stock cannot be updated against Purchase Receipt {0},无法根据采购收据{0}更新库存
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item Row {0}: {1} {2} does not exist in above '{1}' table,项目行{0}：{1} {2}在上面的“{1}”表格中不存在
DocType: Asset Maintenance Task,2 Yearly,每年2
DocType: Guardian Student,Guardian Student,卫报学生
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please add a Temporary Opening account in Chart of Accounts,请在“会计科目表”中添加临时开户帐户
DocType: Account,Include in gross,包括毛
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Serial Numbers,选择序列号
DocType: Tally Migration,UOMs,计量单位
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party / Account does not match with {1} / {2} in {3} {4},第{0}行：聚会/帐户与{3} {4}中的{1} / {2}不符
apps/erpnext/erpnext/utilities/transaction_base.py,Invalid reference {0} {1},无效的参考{0} {1}
DocType: Quality Action,Corrective/Preventive,纠正/预防
DocType: Work Order Operation,Work In Progress,工作正在进行中
DocType: Bank Reconciliation,Account Currency,账户币种
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,credit_note_amt,credit_note_amt
DocType: Setup Progress Action,Action Name,行动名称
DocType: Employee,Health Insurance,健康保险
DocType: Student Group,Max Strength,最大强度
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate customer group found in the cutomer group table,在cutomer组表中找到重复的客户组
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Leave cannot be applied/cancelled before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}",在{0}之前不能应用/取消休假，因为休假余额已在未来的休假分配记录{1}中转发
DocType: Promotional Scheme Price Discount,Min Amount,最低金额
DocType: Sales Invoice Item,Rate With Margin (Company Currency),保证金率（公司货币）
DocType: Lead,Follow Up,跟进
DocType: Tax Rule,Shipping Country,运输国家
DocType: Delivery Note,Track this Delivery Note against any Project,跟踪任何项目的交货单
DocType: Company,Default Payroll Payable Account,默认工资支付帐户
DocType: Drug Prescription,Update Schedule,更新时间表
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Updating estimated arrival times.,更新预计到达时间。
DocType: Asset Category,Finance Book Detail,财务书详细信息
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No {0} does not belong to Delivery Note {1},序列号{0}不属于交货单{1}
apps/erpnext/erpnext/regional/italy/utils.py,Please set Tax ID for the customer '%s',请为客户&#39;％s&#39;设置税号
DocType: Sales Partner,Logo,商标
DocType: Leave Type,Include holidays within leaves as leaves,在叶子中包括假期作为叶子
DocType: Shift Assignment,Shift Request,轮班请求
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.py,"Can not mark Inpatient Record Discharged, there are Unbilled Invoices {0}",无法标记已出院的住院病历，有未开单的发票{0}
DocType: QuickBooks Migrator,Scope,范围
DocType: Purchase Invoice Item,Service Stop Date,服务停止日期
DocType: Article,Publish Date,发布日期
DocType: Student,O+,O +
DocType: BOM,Work Order,工作指示
DocType: Bank Statement Transaction Settings Item,Transaction,交易
DocType: Workstation,per hour,每小时
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,This action will stop future billing. Are you sure you want to cancel this subscription?,此操作将停止将来结算。您确定要取消此订阅吗？
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,State/UT Tax,州/ UT税
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,Scorecards,记分卡
,Projected Quantity as Source,预计数量为来源
DocType: Supplier Group,Parent Supplier Group,母供应商组
apps/erpnext/erpnext/controllers/accounts_controller.py,Rows with duplicate due dates in other rows were found: {0},找到其他行中具有重复截止日期的行：{0}
DocType: Fees,EDU-FEE-.YYYY.-,EDU-收费.YYYY.-
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Chart Of Accounts Template,会计科目表模板
DocType: Lead,Lead,铅
DocType: Appraisal Template Goal,KRA,KRA
apps/erpnext/erpnext/utilities/user_progress.py,Setup Institution,设置机构
,Salary Register,薪资登记册
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"In the case of multi-tier program, Customers will be auto assigned to the concerned tier as per their spent",在多层程序的情况下，客户将根据其花费自动分配到相关层
DocType: Bank Reconciliation Detail,Posting Date,发布日期
DocType: Upload Attendance,Attendance From Date,出席日期
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.py,Program in the Fee Structure and Student Group {0} are different.,费用结构和学生组{0}中的程序是不同的。
DocType: GST Settings,GST Summary,消费税总结
DocType: Education Settings,Make Academic Term Mandatory,使学术期限强制执行
DocType: Vehicle,Odometer Value (Last),里程表值（最后）
apps/erpnext/erpnext/config/assets.py,Transfer an asset from one warehouse to another,将资产从一个仓库转移到另一个仓库
DocType: Room,Seating Capacity,座位容量
DocType: Employee Benefit Application Detail,Employee Benefit Application Detail,员工福利申请明细
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Employee {0} has already applied for {1} between {2} and {3} : ,员工{0}已在{2}和{3}之间申请{1}：
DocType: Asset Category Account,Capital Work In Progress Account,资本工作进行中帐户
DocType: Employee Benefit Claim,Benefit Type and Amount,福利类型和金额
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default payable account for the company {0},请为公司{0}设置默认的应付帐户
DocType: Daily Work Summary Group,Holiday List,假期清单
DocType: Job Card,Total Time in Mins,分钟总时间
DocType: Shipping Rule,Shipping Amount,运费金额
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Absent,完全缺席
DocType: Fee Validity,Reference Inv,参考Inv
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Row {0}: {1} is required to create the Opening {2} Invoices,行{0}：{1}是创建Opening {2}发票所必需的
DocType: Bank Account,Is Company Account,是公司帐户
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Do you want to notify all the customers by email?,您想通过电子邮件通知所有客户吗？
DocType: Opening Invoice Creation Tool,Sales,销售
DocType: Vital Signs,Tongue,舌
DocType: Journal Entry,Excise Entry,消费税入境
apps/erpnext/erpnext/www/all-products/index.html,Clear filters,清除过滤器
DocType: Delivery Trip,In Transit,在途中
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} is not a valid {1} code,条形码{0}不是有效的{1}代码
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Balance for Account {0} must always be {1},帐户{0}的余额必须始终为{1}
apps/erpnext/erpnext/public/js/controllers/transaction.js,Invalid Blanket Order for the selected Customer and Item,所选客户和项目的空白订单无效
DocType: Production Plan Item,"If enabled, system will create the work order for the exploded items against which BOM is available.",如果启用，系统将为BOM可用的爆炸项目创建工作订单。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Product Bundle,产品包
DocType: Exchange Rate Revaluation Account,New Exchange Rate,新汇率
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open To Do,开放做
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Receiver List is empty. Please create Receiver List,接收者列表为空。请创建接收者列表
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Liabilities,流动负债
apps/erpnext/erpnext/templates/pages/demo.html,ERPNext Demo,ERPNext演示
DocType: Patient,Other Risk Factors,其他风险因素
DocType: Item Attribute,To Range,估计
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} applicable after {1} working days,{0}在{1}个工作日后适用
DocType: Task,Task Description,任务描述
DocType: Bank Account,SWIFT Number,SWIFT号码
DocType: Accounts Settings,Show Payment Schedule in Print,在打印中显示付款时间表
DocType: Purchase Invoice,Apply Tax Withholding Amount,申请预扣税金额
DocType: Supplier Scorecard Standing,Supplier Scorecard Standing,供应商记分卡站
DocType: Quality Inspection Reading,Quality Inspection Reading,质量检验阅读
DocType: Healthcare Settings,Valid number of days,有效天数
DocType: Production Plan Item,material_request_item,material_request_item
DocType: Installation Note,MAT-INS-.YYYY.-,MAT-INS-.YYYY.-
DocType: Healthcare Settings,Custom Signature in Print,打印中的自定义签名
DocType: Patient Encounter,Procedures,程序
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Issues,开放式问题
DocType: Company,Series for Asset Depreciation Entry (Journal Entry),资产折旧系列（期刊录入）
DocType: Healthcare Service Unit,Occupancy Status,占用状况
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Privilege Leave,特权假
DocType: Subscription,Current Invoice End Date,当前发票结束日期
DocType: Sample Collection,Collected Time,收集时间
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please select BOM for Item in Row {0},请为行{0}中的项目选择物料清单
DocType: Department,Expense Approver,费用审批人
DocType: Bank Statement Transaction Entry,New Transactions,新交易
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,Payable Amount,应付金额
DocType: SMS Center,All Supplier Contact,所有供应商联系
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} not of type {1},报价{0}不是{1}类型
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,Leave Type {0} is not encashable,保留类型{0}不可保留
DocType: Contract,Fulfilment Status,履行状况
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Unsubscribe from this Email Digest,取消订阅此电子邮件摘要
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.py,{0} {1} created,已创建{0} {1}
DocType: Water Analysis,Person Responsible,负责人
DocType: Asset,Asset Category,资产类别
DocType: Stock Settings,Limit Percent,限制百分比
DocType: Cash Flow Mapping Accounts,Cash Flow Mapping Accounts,现金流量映射帐户
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Select Serial No,选择序列号
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Sales Return,销售回报
apps/erpnext/erpnext/hr/report/employee_advance_summary/employee_advance_summary.py,No record found,没有找到记录
DocType: Department,Expense Approvers,费用审批人
DocType: Purchase Invoice,Group same items,分组相同的项目
DocType: Company,Parent Company,母公司
DocType: Daily Work Summary Group,Reminder,提醒
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Overdraft Account,银行透支账户
DocType: Journal Entry,Difference (Dr - Cr),差异（Dr  -  Cr）
apps/erpnext/erpnext/stock/doctype/item/item.py,"An Item Group exists with same name, please change the item name or rename the item group",存在具有相同名称的项目组，请更改项目名称或重命名项目组
DocType: Student,B+,B +
apps/erpnext/erpnext/controllers/buying_controller.py,Following item {0} is not marked as {1} item. You can enable them as {1} item from its Item master,项目{0}之后未标记为{1}项目。您可以从项目主文件中将它们作为{1}项启用
DocType: Healthcare Service Unit,Allow Overlap,允许重叠
apps/erpnext/erpnext/controllers/item_variant.py,Value for Attribute {0} must be within the range of {1} to {2} in the increments of {3} for Item {4},对于项{4}，属性{0}的值必须在{1}到{2}的范围内，增量为{3}
DocType: Timesheet,Billing Details,结算明细
DocType: Quality Procedure Table,Quality Procedure Table,质量程序表
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} created,已创建序列号{0}
DocType: Warehouse,Warehouse Detail,仓库细节
DocType: Sales Order,To Deliver and Bill,交付和比尔
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Added to details,添加到细节
apps/erpnext/erpnext/public/js/hub/marketplace.js,Add Users to Marketplace,将用户添加到市场
DocType: Healthcare Settings,Remind Before,提醒之前
DocType: Healthcare Settings,Manage Customer,管理客户
DocType: Loyalty Program Collection,Tier Name,等级名称
DocType: Manufacturing Settings,Manufacturing Settings,制造设置
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Taken,采取
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Start Date and End Date for Item {0},请为项目{0}选择开始日期和结束日期
DocType: Education Settings,Education Settings,教育设置
DocType: Student Admission,Admission End Date,入学结束日期
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"If you {0} {1} worth item <b>{2}</b>, the scheme <b>{3}</b> will be applied on the item.
				",如果{0} {1}值得项目<b>{2}</b> ，则方案<b>{3}</b>将应用于该项目。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please specify Company to proceed,请指定公司继续
DocType: Asset Maintenance Team,Asset Maintenance Team,资产维护团队
DocType: Production Plan Material Request,Material Request Date,材料申请日期
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Responsibilities,责任
DocType: Project,Total Costing Amount (via Timesheets),总成本金额（通过时间表）
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Items and UOMs,导入项目和UOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Leaves per Year,每年的叶子
DocType: Student,Date of Leaving,离职日期
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,Export E-Invoices,出口电子发票
DocType: Healthcare Settings,Laboratory SMS Alerts,实验室短信提醒
DocType: Program,Is Published,已发布
DocType: Clinical Procedure,Healthcare Practitioner,医疗从业者
apps/erpnext/erpnext/stock/get_item_details.py,Item Price updated for {0} in Price List {1},价格清单{1}中的商品价格已更新为{0}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Batched Item {0} cannot be updated using Stock Reconciliation, instead use Stock Entry",无法使用库存对帐更新批处理项目{0}，而是使用库存输入
DocType: Employee External Work History,Total Experience,所有经验
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Material to Supplier,供应商的材料
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Customer is required against Receivable account {2},{0} {1}：应收帐户{2}需要客户
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Healthcare Services,医疗服务
DocType: Grading Scale Interval,Grade Code,等级代码
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,Appointments and Patient Encounters,约会和患者遭遇
,TDS Computation Summary,TDS计算摘要
DocType: Shipping Rule,Shipping Rule Label,运输规则标签
DocType: Buying Settings,Supplier Naming By,供应商命名
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Admissions for {0},{0}的入学
DocType: Loan,Loan Details,贷款详情
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} on Half day on {1},员工{0}在{1}的半天
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_sub_category/employee_tax_exemption_sub_category.py,Max Exemption Amount cannot be greater than maximum exemption amount {0} of Tax Exemption Category {1},最高豁免金额不得超过免税类别{1}的最高豁免金额{0}
apps/erpnext/erpnext/hr/utils.py,Please set leave policy for employee {0} in Employee / Grade record,请在员工/成绩记录中为员工{0}设置休假政策
DocType: Bank Reconciliation Detail,Cheque Number,支票号码
,Prospects Engaged But Not Converted,前景参与但未转换
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Liabilities,股票负债
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,-Above,-以上
DocType: Item Website Specification,Item Website Specification,商品网站规格
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Item {0} (Serial No: {1}) cannot be consumed as is reserverd\
						 to fullfill Sales Order {2}.",项目{0}（序列号：{1}）不能像reserverd \那样使用，以完成销售订单{2}。
DocType: Vehicle,Electric,电动
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,"Item Price appears multiple times based on Price List, Supplier/Customer, Currency, Item, UOM, Qty and Dates.",物料价格根据价格清单，供应商/客户，货币，物料，UOM，数量和日期多次出现。
DocType: Stock Ledger Entry,Stock Ledger Entry,股票分类账
DocType: HR Settings,Email Salary Slip to Employee,向工作人员发送工资单
DocType: Stock Entry,Delivery Note No,送货单号
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Timeslots,添加Timeslots
DocType: Packing Slip Item,Packing Slip Item,包装单项目
DocType: Payroll Period,Standard Tax Exemption Amount,标准免税额
apps/erpnext/erpnext/config/help.py,Serialized Inventory,序列化库存
DocType: Contract,Requires Fulfilment,需要履行
DocType: Quality Inspection,MAT-QA-.YYYY.-,MAT-QA-.YYYY.-
DocType: Bank Statement Transaction Entry,Receivable Account,应收账款
DocType: Website Attribute,Website Attribute,网站属性
apps/erpnext/erpnext/public/js/templates/address_list.html,No address added yet.,尚未添加地址。
DocType: Sales Order,Partly Billed,部分收费
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,Customer isn't enrolled in any Loyalty Program,客户未加入任何忠诚度计划
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Jobs,工作
DocType: Expense Claim,Approval Status,批准状态
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Opening Qty,开放数量
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,"Skipping Salary Structure Assignment for the following employees, as Salary Structure Assignment records already exists against them. {0}",跳过下列员工的薪资结构分配，因为已存在针对他们的薪资结构分配记录。 {0}
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term End Date cannot be later than the Year End Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,期限结束日期不得晚于该学期的学年结束日期（学年{}）。请更正日期，然后重试。
DocType: Purchase Order,% Billed,已开帐单
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Variance,总差异
apps/erpnext/erpnext/support/doctype/issue/issue.js,Split Issue,拆分问题
DocType: Item Default,Default Supplier,默认供应商
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Base,基础
apps/erpnext/erpnext/config/accounting.py,Share Management,分享管理
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Sales Order {0} is not valid,销售订单{0}无效
DocType: Leave Control Panel,Branch (optional),分支（可选）
DocType: Bank Reconciliation Detail,Clearance Date,清关日期
DocType: Supplier Scorecard Period,Criteria,标准
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,当库存达到重新订购水平时，提高物料请求
,Campaign Efficiency,运动效率
apps/erpnext/erpnext/utilities/activation.py,Create Timesheet,创建时间表
DocType: Employee,Internal Work History,内部工作历史
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Select Target Warehouse,选择目标仓库
DocType: Subscription Settings,Grace Period,宽限期
DocType: Patient,Married,已婚
DocType: Work Order Item,Available Qty at Source Warehouse,源仓库的可用数量
DocType: Shipping Rule Country,Shipping Rule Country,运输规则国家
DocType: Delivery Stop,Email Sent To,电子邮件发送至
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Material Consumption,材料消耗
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Nothing to change,没什么可改变的
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.py,No Lab Test created,没有创建实验室测试
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} have already been retained for Batch {1} and Item {2} in Batch {3}.,最大样本 - 批次{1}中的批次{1}和项目{2}已保留{0}。
apps/erpnext/erpnext/setup/doctype/company/company.py,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.",无法更改公司的默认货币，因为存在现有交易。必须取消交易才能更改默认货币。
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Maintenance Expenses,办公室维护费用
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more days than maximum allocation of {0} leave type for employee {1} in the period,分配的总分钟数比该期间员工{1}的最大分配{0}分类类型的天数多
DocType: Stock Entry,Update Rate and Availability,更新率和可用性
DocType: Item Variant Attribute,Item Variant Attribute,项目变体属性
DocType: Delivery Note Item,Available Batch Qty at From Warehouse,From Warehouse的可用批次数量
DocType: Sales Invoice Item,Discount (%) on Price List Rate with Margin,有保证金的价格表费率折扣（％）
DocType: Asset,Check if Asset requires Preventive Maintenance or Calibration,检查资产是否需要预防性维护或校准
DocType: Lab Test,Technician Name,技术员姓名
DocType: Lab Test Groups,Normal Range,普通范围
DocType: Item,Total Projected Qty,预计总数量
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Boms,物料清单
DocType: Work Order,Actual Start Date,实际开始日期
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,You are not present all day(s) between compensatory leave request days,在补休请假日之间，您不会全天在场
apps/erpnext/erpnext/config/accounting.py,Tree of financial accounts.,财务帐户树。
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Income,间接收入
DocType: Hotel Room Reservation Item,Hotel Room Reservation Item,酒店客房预订项目
DocType: Course Scheduling Tool,Course Start Date,课程开始日期
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Sell,卖
DocType: Support Search Source,Post Route String,邮政路线后
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Electrical,电动
DocType: Journal Entry,Total Debit,总借记
DocType: Guardian,Guardian,监护人
DocType: Share Transfer,Transfer Type,转移类型
apps/erpnext/erpnext/config/crm.py,Database of potential customers.,潜在客户数据库。
DocType: Skill,Skill Name,技能名称
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.js,Print Report Card,打印报告卡
DocType: Soil Texture,Ternary Plot,三元情节
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Support Tickets,支持门票
DocType: Asset Category Account,Fixed Asset Account,固定资产账户
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Latest,最新
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Submit Salary Slip,提交工资单
DocType: Vital Signs,Adults' pulse rate is anywhere between 50 and 80 beats per minute.,成人的脉搏频率在每分钟50到80次之间。
DocType: Program Enrollment Course,Program Enrollment Course,课程注册课程
,IRS 1099,IRS 1099
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set the series to be used.,请设置要使用的系列。
DocType: Delivery Trip,Distance UOM,距离UOM
DocType: Accounting Dimension,Mandatory For Balance Sheet,资产负债表必备
DocType: Payment Entry,Total Allocated Amount,总分配金额
DocType: Sales Invoice,Get Advances Received,收到进展
DocType: Shift Type,Last Sync of Checkin,Checkin的上次同步
DocType: Student,B-,B-
DocType: Purchase Invoice Item,Item Tax Amount Included in Value,物品税金额包含在价值中
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,"Row {0}: Invoice {1} is invalid, it might be cancelled / does not exist. \
						Please enter a valid Invoice",行{0}：发票{1}无效，可能取消/不存在。 \请输入有效的发票
DocType: Subscription Plan,Subscription Plan,订阅计划
DocType: Student,Blood Group,血型
apps/erpnext/erpnext/config/healthcare.py,Masters,大师
DocType: Crop,Crop Spacing UOM,裁剪间距UOM
DocType: Shift Type,The time after the shift start time when check-in is considered as late (in minutes).,在办理登机手续的班次开始时间之后的时间被视为迟到（以分钟为单位）。
apps/erpnext/erpnext/templates/pages/home.html,Explore,探索
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices found,没有找到未完成的发票
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"{0} vacancies and {1} budget for {2} already planned for subsidiary companies of {3}. \
				You can only plan for upto {4} vacancies and and budget {5} as per staffing plan {6} for parent company {3}.",已为{3}的子公司计划的{0}空缺和{1} {2}预算。 \根据母公司{3}的人员编制计划{6}，您只能计划最多{4}个职位空缺和预算{5}。
DocType: Promotional Scheme,Product Discount Slabs,产品折扣板
DocType: Hotel Room Package,Amenities,设施
DocType: Lab Test Groups,Add Test,添加测试
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Cannot return more than {1} for Item {2},行＃{0}：对于项{2}，返回的值不能超过{1}
DocType: Student Leave Application,Student Leave Application,学生请假申请
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py,Repayment amount {} should be greater than monthly interest amount {},还款金额{}应大于每月利息金额{}
DocType: Maintenance Schedule Item,Maintenance Schedule Item,维护计划项目
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,POS Profile required to make POS Entry,进行POS输入所需的POS配置文件
DocType: Education Settings,Enable LMS,启用LMS
DocType: POS Closing Voucher,Sales Invoices Summary,销售发票摘要
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Benefit,效益
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Balance Sheet account,Credit To帐户必须是资产负债表帐户
DocType: Video,Duration,持续时间
DocType: Lab Test Template,Descriptive,描述的
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select Price List,请选择价目表
DocType: Payment Reconciliation,From Invoice Date,从发票日期开始
DocType: Education Settings,Validate Batch for Students in Student Group,为学生组中的学生验证批次
DocType: Leave Policy,Leave Allocations,离开分配
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Score cannot be greater than Maximum Score,分数不能大于最高分数
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,BOM is not specified for subcontracting item {0} at row {1},没有为第{1}行的转包项目{0}指定物料清单
DocType: Item,Automatically Create New Batch,自动创建新批次
DocType: Restaurant Menu,Price List (Auto created),价目表（自动创建）
DocType: Customer,Credit Limit and Payment Terms,信用额度和付款条款
apps/erpnext/erpnext/stock/doctype/item/item.js,Show Variants,显示变体
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Gain/Loss Account on Asset Disposal' in Company {0},请在公司{0}设置&#39;资产处置的收益/损失账户&#39;
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for time sheet {1},已为时间表{1}创建的员工{0}的工资单
apps/erpnext/erpnext/config/projects.py,Timesheet for tasks.,任务的时间表。
DocType: Purchase Invoice,Rounded Total (Company Currency),圆形总计（公司货币）
apps/erpnext/erpnext/config/website.py,Settings for website product listing,网站产品列表的设置
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Successfully Set Supplier,成功设置供应商
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Start Date of Agreement can't be greater than or equal to End Date.,协议的开始日期不得大于或等于结束日期。
,Item Prices,商品价格
DocType: Products Settings,Product Page,产品页面
DocType: Amazon MWS Settings,Market Place ID,市场ID
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order has been {0},生产订单已为{0}
DocType: Employee Benefit Application,Employee Benefit Application,员工福利申请
DocType: BOM Item,Item operation,物品操作
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Received,部分收到
DocType: Landed Cost Voucher,MAT-LCV-.YYYY.-,MAT-LCV-.YYYY.-
DocType: Employee Advance,Due Advance Amount,到期预付金额
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves {0} cannot be less than already approved leaves {1} for the period,已分配的总分配{0}不能少于该期间已批准的分段{1}
DocType: Email Digest,New Purchase Orders,新的采购订单
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Item: {0} does not exist in the system,项目：{0}在系统中不存在
DocType: Loan Application,Loan Info,贷款信息
DocType: Manufacturing Settings,Try planning operations for X days in advance.,请提前X天尝试计划操作。
DocType: Serial No,Is Cancelled,取消
DocType: Request for Quotation,For individual supplier,对于个别供应商
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Qty can not be greater than Max Qty,最小数量不能大于最大数量
DocType: Soil Texture,Loamy Sand,Loamy Sand
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,行{0}：对销售/采购订单的付款应始终标记为提前
DocType: Item,"Example: ABCD.#####. If series is set and Batch No is not mentioned in transactions, then automatic batch number will be created based on this series. If you always want to explicitly mention Batch No for this item, leave this blank. Note: this setting will take priority over the Naming Series Prefix in Stock Settings.",示例：ABCD。#####。如果设置了系列并且事务中未提及批次编号，则将基于此系列创建自动批次编号。如果您始终要明确提及此项目的批次号，请将此处留空。注意：此设置将优先于“库存设置”中的“命名序列前缀”。
apps/erpnext/erpnext/config/healthcare.py,Consultation,会诊
DocType: Item,Item Defaults,项目默认值
DocType: Sales Invoice,Total Commission,总佣金
DocType: Hotel Room,Hotel Room,旅馆房间
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,{0} hours,{0}小时
apps/erpnext/erpnext/controllers/buying_controller.py,Serial no is mandatory for the item {0},项目{0}必须是序列号
DocType: Company,Standard Template,标准模板
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The number of shares and the share numbers are inconsistent,股票数量和股票数量不一致
DocType: Project,Start and End Dates,开始和结束日期
DocType: Supplier Scorecard,Notify Employee,通知员工
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Software,软件
DocType: Program,Allow Self Enroll,允许自我注册
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Expenses,库存费用
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No is mandatory if you entered Reference Date,如果您输入参考日期，则参考号为必填项
DocType: Training Event,Workshop,作坊
DocType: Stock Settings,Auto insert Price List rate if missing,如果缺少，则自动插入价格清单率
DocType: Course Content,Course Content,课程内容
DocType: Purchase Order Item,Material Request Item,材料申请项目
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,维护访问目的
DocType: Designation,Skills,技能
DocType: Asset,Out of Order,故障
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Available {0},可用{0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.js,Select Customer,选择客户
DocType: Projects Settings,Ignore Workstation Time Overlap,忽略工作站时间重叠
DocType: Shareholder,Hidden list maintaining the list of contacts linked to Shareholder,隐藏列表，维护链接到股东的联系人列表
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Same item has been entered multiple times,已多次输入相同的项目
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under maintenance contract upto {1},序列号{0}的维护合同最高为{1}
DocType: Bin,FCFS Rate,FCFS费率
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Quantity is not allowed,不允许负数
DocType: Quotation Item,Planning,规划
DocType: Marketplace Settings,Marketplace URL (to hide and update label),市场URL（隐藏和更新标签）
DocType: Item Group,Parent Item Group,父项目组
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Buying Price List Rate,平均。购买价格表费率
,Fichier des Ecritures Comptables [FEC],Fichier des Ecritures Comptables [FEC]
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Row #{0}: Timings conflicts with row {1},行＃{0}：时间与行{1}冲突
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customers,重复客户
DocType: Fee Schedule,Fee Schedule,收费表
DocType: Quality Inspection Reading,Reading 10,读10
apps/erpnext/erpnext/config/hr.py,Setting up Employees,设置员工
DocType: Selling Settings,Settings for Selling Module,销售模块的设置
DocType: Payment Reconciliation,Reconcile,调和
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Difference Account must be a Asset/Liability type account, since this Stock Entry is an Opening Entry",差异账户必须是资产/负债类型账户，因为此股票分录是开仓分录
apps/erpnext/erpnext/accounts/report/financial_statements.py,End Year cannot be before Start Year,结束年份不能在开始年份之前
DocType: Task,Parent Task,父任务
DocType: Attendance,Attendance Request,出勤请求
DocType: Item,Moving Average,移动平均线
DocType: Employee Attendance Tool,Unmarked Attendance,没有标记的出席
DocType: Homepage Section,Number of Columns,列数
DocType: Issue Priority,Issue Priority,问题优先
DocType: Holiday List,Add Weekly Holidays,添加每周假期
DocType: Shopify Log,Shopify Log,Shopify日志
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Salary Slip,创建工资单
DocType: Customs Tariff Number,Customs Tariff Number,关税税号
DocType: Job Offer Term,Value / Description,价值/描述
DocType: Warranty Claim,Issue Date,发行日期
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Please select a Batch for Item {0}. Unable to find a single batch that fulfills this requirement,请为项目{0}选择批处理。无法找到满足此要求的单个批次
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Cannot create Retention Bonus for left Employees,无法为左员工创建保留奖金
DocType: Employee Checkin,Location / Device ID,位置/设备ID
DocType: Purchase Order,To Receive,受到
apps/erpnext/erpnext/accounts/page/pos/pos.js,You are in offline mode. You will not be able to reload until you have network.,您处于离线模式。在拥有网络之前，您将无法重新加载。
DocType: Course Activity,Enrollment,注册
DocType: Lab Test Template,Lab Test Template,实验室测试模板
,Employee Birthday,员工生日
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Max: {0},最大值：{0}
apps/erpnext/erpnext/regional/italy/utils.py,E-Invoicing Information Missing,电子发票信息丢失
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No material request created,未创建任何材料请求
DocType: Loan,Total Amount Paid,支付总金额
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,All these items have already been invoiced,所有这些物品都已开具发票
DocType: Training Event,Trainer Name,培训师姓名
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Project Manager,专案经理
DocType: Travel Itinerary,Non Diary,非日记
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares don't exist with the {0},{0}不存在共享
DocType: Lab Test,Test Group,测试组
DocType: Subscription,Number of days that the subscriber has to pay invoices generated by this subscription,订户必须支付此订阅生成的发票的天数
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Please set Unrealized Exchange Gain/Loss Account in Company {0},请在公司{0}中设置未实现的交易所增/亏损账户
DocType: Payroll Entry,Select Payment Account to make Bank Entry,选择付款帐户进行银行输入
DocType: Supplier Scorecard,Scoring Setup,评分设置
DocType: Salary Slip,Total Interest Amount,利息总额
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},会计年度开始日期和会计年度结束日期已在会计年度{0}中设置
apps/erpnext/erpnext/projects/report/billing_summary.py,Billable Hours,可开票时间
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge with Existing Account,与现有帐户合并
DocType: Lead,Lost Quotation,丢失报价
DocType: Email Digest,Note: Email will not be sent to disabled users,注意：电子邮件不会发送给已禁用的用户
apps/erpnext/erpnext/config/settings.py,"Create and manage daily, weekly and monthly email digests.",创建和管理每日，每周和每月电子邮件摘要。
DocType: Academic Term,Academic Year,学年
DocType: Sales Stage,Stage Name,艺名
DocType: SMS Center,All Employee (Active),所有员工（主动）
DocType: Accounting Dimension,Accounting Dimension,会计维度
DocType: Project,Customer Details,顾客信息
DocType: Buying Settings,Default Supplier Group,默认供应商组
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Receipt {0} first,请先取消购买收据{0}
apps/erpnext/erpnext/controllers/accounts_controller.py,Charge of type 'Actual' in row {0} cannot be included in Item Rate,第{0}行中“实际”类型的费用不能包含在项目费率中
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Business Development Manager,业务发展经理
DocType: Agriculture Task,Urgent,紧急
DocType: Shipping Rule Condition,From Value,从价值
DocType: Asset Maintenance Task,Next Due Date,下一个截止日期
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Buy,购买
apps/erpnext/erpnext/projects/doctype/task/task.py,Progress % for a task cannot be more than 100.,任务的进度％不能超过100。
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Number of root accounts cannot be less than 4,root帐户数不能少于4
DocType: Item,Website Item Groups,网站项目组
DocType: Certified Consultant,Certified Consultant,认证顾问
DocType: Driving License Category,Class,类
DocType: Asset,Sold,出售
apps/erpnext/erpnext/accounts/party.py,There can only be 1 Account per Company in {0} {1},{0} {1}每个公司只能有一个帐户
DocType: GL Entry,Against,反对
DocType: Company,Default Deferred Expense Account,默认递延费用帐户
DocType: Stock Settings,Auto Material Request,自动材料申请
DocType: Marketplace Settings,Sync in Progress,同步进行中
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No salary slip found to submit for the above selected criteria OR salary slip already submitted,找不到上述选定标准提交的工资单或已提交的工资单
apps/erpnext/erpnext/config/settings.py,Create rules to restrict transactions based on values.,创建规则以基于值限制事务。
DocType: Products Settings,Enable Field Filters,启用字段过滤器
DocType: Loan,Loan Amount,贷款额度
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Miscellaneous Expenses,杂项开支
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the public administration '%s',请为公共管理&#39;％s&#39;设置财政代码
apps/erpnext/erpnext/config/retail.py,Setup mode of POS (Online / Offline),POS的设置模式（在线/离线）
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,User {0} doesn't have any default POS Profile. Check Default at Row {1} for this User.,用户{0}没有任何默认POS配置文件。检查此用户的行{1}处的默认值。
DocType: Department,Leave Block List,离开阻止列表
apps/erpnext/erpnext/healthcare/page/medical_record/patient_select.html,Select Patient,选择患者
DocType: Attendance,Leave Type,离开类型
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Creating student groups,创建学生组
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Plants and Machineries,植物和机械
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Not Marked,没有标记
DocType: Bank Statement Transaction Invoice Item,Purchase Invoice,购买发票
DocType: GL Entry,Is Opening,正在开放
DocType: Accounts Settings,Accounts Settings,帐户设置
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Actual Qty: Quantity available in the warehouse.,实际数量：仓库中可用的数量。
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expires On,到期
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Accounting Entry for Asset,资产会计分录
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Schedule Course,安排课程
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to ledger,具有现有交易的成本中心无法转换为分类帐
,Bank Clearance Summary,银行清关摘要
DocType: SMS Center,SMS Center,短信中心
DocType: Pricing Rule,Threshold for Suggestion,建议的门槛
DocType: Stock Entry,Sales Invoice No,销售发票号
DocType: Project Update,Project Update,项目更新
DocType: Student Sibling,Student ID,学生卡
,Pending SO Items For Purchase Request,待购买请求的SO项目
DocType: Task,Timeline,时间线
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,The Loyalty Program isn't valid for the selected company,忠诚度计划对所选公司无效
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure {0},配置{0}
DocType: Employee,Contact Details,联系方式
apps/erpnext/erpnext/utilities/user_progress.py,Classrooms/ Laboratories etc where lectures can be scheduled.,可以安排讲座的教室/实验室等。
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot cancel because submitted Stock Entry {0} exists,无法取消，因为提交的库存条目{0}已存在
DocType: Exchange Rate Revaluation Account,Balance In Account Currency,账户货币余额
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Close the POS,关闭POS
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only credit accounts can be linked against another debit entry",对于{0}，只有信用帐户可以与另一个借记条目链接
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Pharmaceutical,制药
DocType: Program Enrollment,Boarding Student,寄宿学生
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,Total Contribution Amount: {0},总贡献金额：{0}
DocType: Item Alternative,Two-way,双向
DocType: Appraisal,Appraisal,评价
apps/erpnext/erpnext/controllers/trends.py,Fiscal Year: {0} does not exists,会计年度：{0}不存在
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Create Employee,创建员工
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Structures have been assigned successfully,已成功分配结构
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Expenses,直接费用
DocType: Support Search Source,Result Route Field,结果路线字段
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,There is not enough leave balance for Leave Type {0},请假类型{0}没有足够的休假余额
DocType: Material Request Plan Item,Actual Qty,实际数量
DocType: Purchase Invoice,Supplier Invoice Date,供应商发票日期
DocType: Depreciation Schedule,Finance Book Id,财务书ID
DocType: Exchange Rate Revaluation Account,Current Exchange Rate,当前汇率
DocType: Account,Equity,公平
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Sales Order, Sales Invoice or Journal Entry",行＃{0}：参考凭证类型必须是销售订单，销售发票或日记帐分录之一
apps/erpnext/erpnext/utilities/user_progress.py,Explore Sales Cycle,探索销售周期
DocType: Shopify Log,Request Data,请求数据
DocType: Quality Procedure,Quality Procedure,质量程序
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Email sent to supplier {0},电子邮件已发送至供应商{0}
,Course wise Assessment Report,课程明智的评估报告
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Automotive,汽车
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},行{0}：分配的金额{1}必须小于或等于发票金额{2}
DocType: Student Report Generation Tool,Total Parents Teacher Meeting,家长教师会议总数
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0} : Operation is required against the raw material item {1},行{0}：对原材料项{1}需要操作
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Posting timestamp must be after {0},发布时间戳必须在{0}之后
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please mention the Lead Name in Lead {0},请提及潜在客户{0}中的潜在客户名称
DocType: Employee,You can enter any date manually,您可以手动输入任何日期
DocType: Stock Reconciliation Item,Stock Reconciliation Item,股票调节项目
DocType: Shift Type,Early Exit Consequence,提前退出后果
DocType: Item Group,General Settings,常规设置
apps/erpnext/erpnext/accounts/party.py,Due Date cannot be before Posting / Supplier Invoice Date,截止日期不能在过帐/供应商发票日期之前
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the Beneficiary before submittting.,在提交之前输入受益人的姓名。
apps/erpnext/erpnext/config/healthcare.py,Record Patient Vitals,记录患者的生命
DocType: Shopping Cart Settings,Show Configure Button,显示配置按钮
DocType: Industry Type,Industry Type,行业类型
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,无法选择第一行的“在上一行金额”或“在前一行总计”上的费用类型
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The shares already exist,股票已经存在
DocType: Work Order Item,Available Qty at WIP Warehouse,WIP仓库中的可用数量
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Resolve error and upload again.,解决错误并再次上传。
DocType: Travel Request,Copy of Invitation/Announcement,邀请/公告的副本
DocType: Healthcare Service Unit,Healthcare Service Unit,医疗服务单位
apps/erpnext/erpnext/controllers/trends.py,Total(Qty),总（数量）
DocType: Employee,Health Insurance No,健康保险号码
DocType: Supplier Scorecard Scoring Standing,Max Grade,最高等级
DocType: Department Approver,Approver,赞同者
,Sales Order Trends,销售订单趋势
DocType: Asset Repair,Repair Cost,修缮成本
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Account in Company,请提及公司的四舍五入账
DocType: Payroll Entry,Select Payroll Period,选择工资核算期
DocType: Price List,Price List Name,价目表名称
apps/erpnext/erpnext/hr/doctype/leave_encashment/leave_encashment.py,You can only submit Leave Encashment for a valid encashment amount,您只能提交有效兑现金额的Leave Encashment
DocType: Pricing Rule,"Higher the number, higher the priority",数字越大，优先级越高
DocType: Designation,Required Skills,所需技能
DocType: Marketplace Settings,Disable Marketplace,禁用市场
DocType: Budget,Action if Annual Budget Exceeded on Actual,年度预算超过实际的行动
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as {1} on leave.,休假时，{1}的出勤率未作为{1}提交。
DocType: Pricing Rule,Promotional Scheme Id,促销计划ID
apps/erpnext/erpnext/projects/doctype/project/project.py,End date of task <b>{0}</b> cannot be greater than <b>{1}</b> expected end date <b>{2}</b>,任务<b>{0}的</b>结束日期不能超过<b>{1}</b>预期结束日期<b>{2}</b>
DocType: Driver,License Details,许可细节
DocType: Cash Flow Mapper,e.g Adjustments for:,例如：调整：
DocType: Selling Settings,Default Quotation Validity Days,默认报价有效期
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,"Bank Account, From Date and To Date are Mandatory",银行账户，从日期和迄今为止是强制性的
DocType: Travel Request Costing,Expense Type,费用类型
DocType: Account,Auditor,审计
apps/erpnext/erpnext/templates/pages/integrations/gocardless_confirmation.html,Payment Confirmation,付款确认
,Available Stock for Packing Items,包装物品的可用库存
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please remove this Invoice {0} from C-Form {1},请从C表单{1}中删除此发票{0}
DocType: Shift Type,Every Valid Check-in and Check-out,每次有效入住和退房
DocType: Support Search Source,Query Route String,查询路由字符串
DocType: Customer Feedback Template,Customer Feedback Template,客户反馈模板
apps/erpnext/erpnext/config/selling.py,Quotes to Leads or Customers.,对潜在客户或客户的报价。
DocType: Driver,Transporter,运输车
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Salary Slip of employee {0} already created for this period,已为此期间创建的员工{0}的工资单
apps/erpnext/erpnext/controllers/selling_controller.py,To {0} | {1} {2},至{0} | {1} {2}
DocType: Leave Block List Date,Block Date,阻止日期
DocType: Sales Team,Contact No.,联系方式。
DocType: Manufacturing Settings,Overproduction Percentage For Work Order,工作订单的生产过剩百分比
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Enroll,注册
DocType: Quotation Lost Reason,Quotation Lost Reason,报价丢失的原因
,Employee Billing Summary,员工账单摘要
apps/erpnext/erpnext/config/settings.py,Country wise default Address Templates,国家明智的默认地址模板
DocType: Cost Center,Parent Cost Center,家长成本中心
DocType: Pricing Rule,Apply Rule On Item Group,在项目组上应用规则
apps/erpnext/erpnext/utilities/user_progress.py,Example: Basic Mathematics,示例：基础数学
DocType: Expense Claim,Total Amount Reimbursed,报销总金额
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Validity period of this quotation has ended.,该报价的有效期已经结束。
,Item-wise Sales History,逐项销售历史
DocType: Employee,Personal Email,个人电邮
DocType: Bank Reconciliation Detail,Cheque Date,检查日期
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Previous Financial Year is not closed,上一财政年度尚未结束
DocType: Lead,Next Contact Date,下一个联系日期
DocType: Membership,Membership,籍
DocType: Buying Settings,Default Buying Price List,默认购买价格表
DocType: Asset,Depreciation Method,折旧方法
DocType: Travel Request,Travel Request,旅行要求
apps/erpnext/erpnext/stock/doctype/item/item.js,{0} variants created.,已创建{0}个变体。
DocType: Healthcare Settings,Avoid Confirmation,避免确认
DocType: Serial No,Under AMC,在AMC下
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"Warehouse required at Row No {0}, please set default warehouse for the item {1} for the company {2}",在行号{0}需要仓库，请为公司{2}的项目{1}设置默认仓库
DocType: Authorization Control,Authorization Control,授权控制
,Daily Work Summary Replies,每日工作摘要回复
apps/erpnext/erpnext/projects/doctype/project/project.py,You have been invited to collaborate on the project: {0},您已被邀请参与该项目的合作：{0}
DocType: Issue,Response By Variance,按方差回应
DocType: Item,Sales Details,销售细节
apps/erpnext/erpnext/config/settings.py,Letter Heads for print templates.,打印模板的信头。
DocType: Salary Detail,Tax on additional salary,额外工资税
apps/erpnext/erpnext/public/js/setup_wizard.js,Attach Logo,附上徽标
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,For row {0}: Enter Planned Qty,对于行{0}：输入计划数量
DocType: Asset Settings,Calculate Prorated Depreciation Schedule Based on Fiscal Year,根据财政年度计算按比例折旧的计划
apps/erpnext/erpnext/config/crm.py,Logs for maintaining sms delivery status,用于维护短信传递状态的日志
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,Current Job Openings,目前的职位空缺
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.",定价规则首先根据“申请时”字段选择，该字段可以是项目，项目组或品牌。
DocType: Purchase Receipt,Add / Edit Taxes and Charges,添加/编辑税费
DocType: Item,Supply Raw Materials for Purchase,供应采购原料
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Proposal Writing,提案写作
DocType: Landed Cost Item,Purchase Receipt Item,购买收据项目
DocType: Production Plan,Get Sales Orders,获取销售订单
DocType: Pricing Rule,Selling,销售
DocType: Supplier Scorecard Scoring Standing,Prevent Purchase Orders,防止采购订单
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Print and Stationery,印刷品和文具
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Buying,运输规则仅适用于购买
apps/erpnext/erpnext/templates/includes/product_list.js,No products found.,没有找到产品。
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set at Tax Exemption Reason in Sales Taxes and Charges,行{0}：请设置销售税和费用中的免税原因
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Group: ,评估组：
DocType: Tally Migration,Parties,派对
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Show exploded view,显示爆炸视图
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,No Delivery Note selected for Customer {},没有为客户{}选择交货单
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,End on,结束
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You can't redeem Loyalty Points having more value than the Grand Total.,您无法兑换价值超过总计的忠诚度积分。
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Designer,设计师
DocType: QuickBooks Migrator,Default Warehouse,默认仓库
DocType: Company,Default Cash Account,默认现金帐户
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please enter Reference date,请输入参考日期
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Item {0} must be a stock Item,项目{0}必须是库存项目
DocType: POS Profile,Print Format for Online,在线打印格式
,Employee Leave Balance,员工休假余额
DocType: Projects Settings,Ignore User Time Overlap,忽略用户时间重叠
DocType: Stock Entry,As per Stock UOM,按照库存UOM
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cost Center with existing transactions can not be converted to group,具有现有事务的成本中心无法转换为组
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,cannot be greater than 100,不能大于100
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Please Delivery Note first,请先发货
DocType: Leave Type,Leave Type Name,保留类型名称
DocType: Homepage Featured Product,Homepage Featured Product,主页特色产品
DocType: Assessment Plan,Examiner Name,考官姓名
,Hotel Room Occupancy,酒店房间占用
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Telecommunications,电信
DocType: Certification Application,Certification Application,认证申请
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image should be a public file or website URL,网站图片应为公共文件或网站网址
apps/erpnext/erpnext/utilities/user_progress.py,Your Suppliers,您的供应商
DocType: Appraisal Goal,Weightage (%),重量（％）
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inter-State Supplies,国家间供应
DocType: Fees,Send Payment Request,发送付款申请
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} is not added in the table,表中未添加{0}
apps/erpnext/erpnext/utilities/activation.py,Create Student,创建学生
apps/erpnext/erpnext/config/projects.py,Gantt chart of all tasks.,甘特图所有任务。
DocType: Department,Leave Approvers,离开审批人
DocType: BOM,Materials Required (Exploded),所需材料（爆炸）
DocType: Loan,Repay Over Number of Periods,偿还期数
DocType: Account,Receivable,应收账款
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py,Price List must be applicable for Buying or Selling,价目表必须适用于购买或销售
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Resend Payment Email,重新发送付款电邮
apps/erpnext/erpnext/regional/italy/utils.py,Please set {0} for address {1},请为地址{1}设置{0}
DocType: Stock Entry,Default Source Warehouse,默认源仓库
DocType: Timesheet Detail,Bill,法案
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Duplicate roll number for student {0},学生{0}的卷号重复
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} has expired.,项{1}的批{0}已过期。
DocType: Lab Test,Approved Date,批准日期
DocType: Item Group,Item Tax,物品税
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Cannot transfer Employee with status Left,无法转移状态为Left的员工
DocType: BOM,Total Cost,总成本
DocType: Request for Quotation Supplier,Quote Status,报价状态
DocType: Employee Education,Qualification,合格
DocType: Complaint,Complaints,投诉
DocType: Item,Is Purchase Item,是购买物品
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Purchase Receipt,购买收据
DocType: Subscription,Trial Period Start Date,试用期开始日期
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Credit Balance,信用额度
DocType: Employee Benefit Application,Payroll Period,工资期
apps/erpnext/erpnext/config/buying.py,Supplier database.,供应商数据库
DocType: Tax Rule,Tax Type,税种
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Move Item,移动项目
DocType: Job Opening,Description of a Job Opening,职位空缺说明
apps/erpnext/erpnext/utilities/activation.py,Create Users,创建用户
DocType: Global Defaults,Current Fiscal Year,本财政年度
DocType: Item,Hub Warehouse,枢纽仓库
DocType: Purchase Invoice,Tax Breakup,税收分手
DocType: Job Card,Material Transferred,转移的材料
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,You are not authorized to add or update entries before {0},您无权在{0}之前添加或更新条目
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Birth cannot be greater than today.,出生日期不能超过今天。
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Number of serial nos and quantity must be the same,序列号和数量必须相同
DocType: Company,Exception Budget Approver Role,例外预算审批人角色
DocType: Fee Schedule,In Process,正在处理中
DocType: Daily Work Summary Group,Send Emails At,发送电子邮件至
apps/erpnext/erpnext/public/js/hub/hub_call.js,Marketplace Error,市场错误
DocType: Salary Slip,Working Days,工作日
DocType: Bank Guarantee,Margin Money,保证金
DocType: Chapter,Chapter,章节
DocType: Purchase Receipt Item Supplied,Current Stock,现有股票
DocType: Employee,History In Company,公司历史
DocType: Purchase Invoice Item,Manufacturer,生产厂家
apps/erpnext/erpnext/healthcare/setup.py,Moderate Sensitivity,中等灵敏度
DocType: Compensatory Leave Request,Leave Allocation,离开分配
DocType: Timesheet,Timesheet,时间表
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation already used for another company,已经用于其他公司的缩写
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Please select Patient to get Lab Tests,请选择患者进行实验室测试
DocType: Purchase Order,Advance Paid,提前支付
DocType: Supplier Scorecard,Load All Criteria,加载所有标准
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Numbers in row {0} does not match with Delivery Note,行{0}中的序列号与交货单不匹配
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Creditors,债权人
DocType: Warranty Claim,Raised By,提出来
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference No and Reference Date is mandatory for Bank transaction,银行交易必须提供参考号和参考日期
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,There can be multiple tiered collection factor based on the total spent. But the conversion factor for redemption will always be same for all the tier.,根据总花费可以有多个分层收集因子。但兑换的兑换系数对于所有等级总是相同的。
DocType: Purchase Invoice Item,Batch No,批号
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Executive Search,高管人才搜寻
DocType: Company,Stock Adjustment Account,股票调整账户
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Gross Profit %,毛利 ％
DocType: Lead,Request Type,请求类型
DocType: Patient Appointment,Reminded,提醒
DocType: Accounts Settings,Billing Address,帐单地址
DocType: Student Leave Application,Mark as Present,标记为现在
DocType: Landed Cost Voucher,Landed Cost Voucher,登陆成本凭证
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Total working hours should not be greater than max working hours {0},总工作时间不得超过最长工作时间{0}
apps/erpnext/erpnext/config/selling.py,Customer Addresses And Contacts,客户地址和联系人
DocType: Project,Task Progress,任务进度
DocType: Journal Entry,Opening Entry,开场报名
DocType: Bank Guarantee,Charges Incurred,发生的费用
DocType: Shift Type,Working Hours Calculation Based On,基于的工时计算
DocType: Work Order,Material Transferred for Manufacturing,为制造业转移的材料
DocType: Products Settings,Hide Variants,隐藏变体
DocType: Manufacturing Settings,Disable Capacity Planning and Time Tracking,禁用容量规划和时间跟踪
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,*将在交易中计算。
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Balance Sheet' account {1}.,“资产负债表”帐户{1}需要{0}。
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} not allowed to transact with {1}. Please change the Company.,{0}不允许与{1}进行交易。请更改公司。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Reciept Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Receipt first for item {0}",根据采购设置，如果需要采购收货==&#39;是&#39;，那么为了创建采购发票，用户需要首先为项目{0}创建采购收据
DocType: Delivery Trip,Delivery Details,交货细节
DocType: Inpatient Record,Discharge Scheduled,出院预定
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Reference: {0}, Item Code: {1} and Customer: {2}",参考：{0}，物料代码：{1}和客户：{2}
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Caution,警告
DocType: Project User,View attachments,查看附件
DocType: Manufacturing Settings,Allow Production on Holidays,允许节假日生产
apps/erpnext/erpnext/config/accounting.py,Update Bank Transaction Dates,更新银行交易日期
DocType: Quality Inspection Reading,Reading 4,阅读4
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Item {0} has no Serial No. Only serilialized items \
						can have delivery based on Serial No",项目{0}没有序列号只有serilialized items \可以根据序列号进行交付
DocType: Program Course,Program Course,课程
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Telephone Expenses,电话费
DocType: Patient,Widow,寡妇
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Number of Interaction,交互次数
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,"Multiple Price Rules exists with same criteria, please resolve conflict by assigning priority. Price Rules: {0}",多个价格规则存在相同的标准，请通过分配优先级来解决冲突。价格规则：{0}
apps/erpnext/erpnext/config/accounting.py,Cost Center and Budgeting,成本中心和预算编制
,Ordered Items To Be Delivered,有序物品将被交付
DocType: Homepage Section Card,Homepage Section Card,主页卡片
DocType: Account,Depreciation,折旧
DocType: Guardian,Interests,兴趣
DocType: Purchase Receipt Item Supplied,Consumed Qty,消耗量
DocType: Education Settings,Education Manager,教育经理
DocType: Employee Checkin,Shift Actual Start,切换实际开始
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,计划工作站工作时间以外的时间日志。
apps/erpnext/erpnext/public/js/utils.js,Loyalty Points: {0},忠诚度积分：{0}
DocType: Healthcare Settings,Registration Message,注册消息
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Select an account to print in account currency,选择要以帐户货币打印的帐户
apps/erpnext/erpnext/accounts/page/pos/pos.js,Serial no item cannot be a fraction,序列号没有项目不能分数
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,无法删除仓库，因为此仓库存在股票分类帐条目。
apps/erpnext/erpnext/templates/pages/cart.html,See past quotations,查看过去的报价
apps/erpnext/erpnext/www/all-products/index.html,Prev,上一页
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Unit of Measure,测量单位
DocType: Lab Test,Test Template,测试模板
DocType: Fertilizer,Fertilizer Contents,肥料含量
DocType: Quality Meeting Minutes,Minute,分钟
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Asset {1} cannot be submitted, it is already {2}",行＃{0}：无法提交资产{1}，它已经是{2}
DocType: Task,Actual Time (in Hours),实际时间（小时）
DocType: Period Closing Voucher,Closing Account Head,结账户主管
DocType: Purchase Invoice,Shipping Rule,运输规则
DocType: Shipping Rule,Net Weight,净重
apps/erpnext/erpnext/public/js/setup_wizard.js,Please enter valid Financial Year Start and End Dates,请输入有效的财政年度开始和结束日期
DocType: POS Closing Voucher Invoices,Quantity of Items,物品数量
DocType: Warehouse,PIN,销
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab testing datetime cannot be before collection datetime,实验室测试日期时间不能在收集日期时间之前
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice already created for all billing hours,已为所有结算时间创建的发票
DocType: Sales Partner,Contact Desc,联系Desc
DocType: Purchase Invoice,Pricing Rules,定价规则
apps/erpnext/erpnext/stock/doctype/item/item.py,"As there are existing transactions against item {0}, you can not change the value of {1}",由于存在针对项{0}的现有事务，因此无法更改{1}的值
DocType: Hub Tracked Item,Image List,图像列表
DocType: Item Variant Settings,Allow Rename Attribute Value,允许重命名属性值
apps/erpnext/erpnext/templates/generators/bom.html,Time(in mins),时间（分钟）
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Basic,基本
DocType: Loan,Interest Income Account,利息收入账户
DocType: Shipping Rule Condition,A condition for a Shipping Rule,运输规则的条件
DocType: Payroll Period Date,Payroll Period Date,工资期限日期
DocType: Employee,Employment Type,雇佣类型
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Select POS Profile,选择POS配置文件
DocType: Support Settings,Get Latest Query,获取最新查询
DocType: Employee Incentive,Employee Incentive,员工激励
DocType: Service Level,Priorities,优先级
apps/erpnext/erpnext/config/website.py,Add cards or custom sections on homepage,在主页上添加卡片或自定义栏目
DocType: Homepage,Hero Section Based On,基于英雄的英雄部分
DocType: Project,Total Purchase Cost (via Purchase Invoice),总购买成本（通过采购发票）
DocType: Staffing Plan Detail,Total Estimated Cost,总估算成本
DocType: Item,"Sales, Purchase, Accounting Defaults",销售，采购，会计违约
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Requesting payment against {0} {1} for amount {2},申请金额为{0}的{0} {1}付款
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Please set the Item Code first,请先设置项目代码
DocType: Payment Term,Due Date Based On,截止日期基于
DocType: Quality Inspection,Incoming,来
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Partially Ordered,部分订购
DocType: Delivery Note,Customer's Purchase Order No,客户的采购订单号
apps/erpnext/erpnext/public/js/utils.js,Select Alternate Item,选择替代项目
DocType: Employee,Applicable Holiday List,适用的假期清单
DocType: Hub Tracked Item,Hub Tracked Item,Hub Tracked Item
DocType: Vehicle Log,Service Details,服务细节
DocType: Program,Is Featured,精选
DocType: HR Settings,Don't send Employee Birthday Reminders,不要发送员工生日提醒
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,在整个销售周期内保持相同的利率
DocType: Program Enrollment,Transportation,运输
DocType: Patient Appointment,Date TIme,约会时间
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select quantity on row ,请在行上选择数量
DocType: Employee Benefit Application Detail,Earning Component,赚取组件
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company first,请先选择公司
DocType: Item,Publish Item to hub.erpnext.com,将项目发布到hub.erpnext.com
apps/erpnext/erpnext/projects/doctype/project/project.py,Join,加入
DocType: BOM,Set rate of sub-assembly item based on BOM,基于BOM设置子装配项的比率
DocType: Vehicle,Wheels,车轮
DocType: Product Bundle,"Aggregate group of **Items** into another **Item**. This is useful if you are bundling a certain **Items** into a package and you maintain stock of the packed **Items** and not the aggregate **Item**. 

The package **Item** will have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes"".

For Example: If you are selling Laptops and Backpacks separately and have a special price if the customer buys both, then the Laptop + Backpack will be a new Product Bundle Item.

Note: BOM = Bill of Materials",将**项目**聚合成另一个**项目**。如果您将某个**项目**捆绑到一个包中并保持包装的**项目**而不是聚合**项目**的库存，这将非常有用。包**项目**将“库存项目”设为“否”，“销售项目”为“是”。例如：如果您单独销售笔记本电脑和背包，并且如果客户购买两者都有特价，那么笔记本电脑+背包将是一个新的产品包项目。注意：BOM =物料清单
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Another Budget record '{0}' already exists against {1} '{2}' and account '{3}' for fiscal year {4},对于财务年度{4}，{1}&#39;{2}&#39;和帐户“{3}”已存在另一个预算记录“{0}”
DocType: Asset,Purchase Receipt Amount,购买收据金额
DocType: Issue,Ongoing,不断的
DocType: Service Level Agreement,Agreement Details,协议细节
DocType: Purchase Invoice,Posting Time,发布时间
DocType: Loyalty Program,Loyalty Program Name,忠诚度计划名称
DocType: Patient,Dormant,休眠
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,{0}: From {1},{0}：来自{1}
DocType: Chart of Accounts Importer,Attach custom Chart of Accounts file,附加自定义会计科目表文件
apps/erpnext/erpnext/config/help.py,Item Variants,项目变体
DocType: Maintenance Visit,Fully Completed,完全完成
DocType: Bank Statement Transaction Invoice Item,Transaction Date,交易日期
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,No data for this period,此期间没有数据
DocType: Mode of Payment Account,Default account will be automatically updated in POS Invoice when this mode is selected.,选择此模式后，默认帐户将在POS发票中自动更新。
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation cannot have more than 5 characters,公司缩写不能超过5个字符
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting_list.js,Canceled,取消
apps/erpnext/erpnext/utilities/user_progress.py,Customers and Suppliers,客户和供应商
,To Produce,生产
DocType: Location,Is Container,是容器
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research & Development,研究和发展
DocType: QuickBooks Migrator,Application Settings,应用程序设置
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Production Order cannot be raised against a Item Template,无法针对项目模板提出生产订单
DocType: Work Order,Manufacture against Material Request,根据材料要求制造
DocType: Blanket Order Item,Ordered Quantity,订购数量
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Warehouse is mandatory against rejected Item {1},行＃{0}：拒绝仓库对被拒绝的项目{1}是强制性的
,Received Items To Be Billed,收到的物品需要收费
DocType: Attendance,Working Hours,工作时间
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Payment Mode,付款方式
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Purchase Order Items not received on time,未按时收到采购订单项目
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,Duration in Days,持续时间天数
DocType: Customer,Sales Team Details,销售团队详情
DocType: BOM Update Tool,Replace,更换
DocType: Training Event,Event Name,活动名称
DocType: SMS Center,Receiver List,接收人名单
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Cr,铬
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Are you sure you want to cancel this appointment?,您确定要取消此预约吗？
DocType: Invoice Discounting,Accounts Receivable Credit Account,应收帐款信用帐户
DocType: Naming Series,Prefix,字首
DocType: Work Order Operation,Actual Operation Time,实际运行时间
DocType: Purchase Invoice Item,Net Rate,净费率
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Cash,现金净变动
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.py,Set warehouse for Procedure {0} ,为过程{0}设置仓库
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Block Invoice,阻止发票
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} does not exist,帐户{0}：父帐户{1}不存在
DocType: HR Settings,Encrypt Salary Slips in Emails,加密电子邮件中的工资单
DocType: Supplier Scorecard Scoring Criteria,Score,得分了
DocType: Delivery Note,Driver Name,司机名
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select Incharge Person's name,请选择Incharge Person的名字
DocType: Employee Training,Training,训练
apps/erpnext/erpnext/config/stock.py,Stock Reports,股票报告
apps/erpnext/erpnext/stock/doctype/item/item.py,Conversion factor for default Unit of Measure must be 1 in row {0},默认计量单位的转换因子必须为行{0}中的1
DocType: Course Scheduling Tool,Course Scheduling Tool,课程安排工具
,Finished Goods,完成品
DocType: Sales Invoice Item,Customer Warehouse (Optional),客户仓库（可选）
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Master Data,同步主数据
DocType: Lead,Address & Contact,地址和联系方式
DocType: Bank Reconciliation,To Date,至今
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Error in some rows,某些行出错
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Lab Tests and Vital Signs,实验室测试和生命体征
apps/erpnext/erpnext/config/accounting.py,Tax Rule for transactions.,交易的税收规则。
DocType: Stock Settings,Show Barcode Field,显示条形码字段
DocType: Packing Slip Item,DN Detail,DN细节
DocType: Vital Signs,Fluid,流体
DocType: GST Settings,B2C Limit,B2C限制
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Electronic Equipments,电子设备
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Cannot find active Leave Period,找不到有效的休假期
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Create Maintenance Visit,创建维护访问
DocType: Healthcare Service Unit Type,Change In Item,改变项目
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,{0} Students have been enrolled,{0}学生已注册
DocType: Vehicle Service,Inspection,检查
DocType: Location,Area,区域
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this week and pending activities,本周和未决活动的摘要
DocType: Asset Maintenance Task,Maintenance Task,维护任务
DocType: Subscription,Current Invoice Start Date,当前发票开始日期
DocType: Purchase Invoice Item,Item,项目
DocType: Program Enrollment Tool,Get Students From,让学生来
DocType: Amazon MWS Settings,Always synch your products from Amazon MWS before synching the Orders details,在同步订单详细信息之前，始终从亚马逊MWS同步您的产品
DocType: Leave Block List,Leave Block List Name,保留阻止列表名称
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,"Could not update stock, invoice contains drop shipping item.",无法更新库存，发票包含下降运输项目。
DocType: Asset Maintenance Log,Completion Date,完成日期
DocType: Purchase Receipt,Rate at which supplier's currency is converted to company's base currency,供应商货币转换为公司基础货币的汇率
DocType: Leave Control Panel,Leave Control Panel,离开控制面板
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Total Applicable Charges in Purchase Receipt Items table must be same as Total Taxes and Charges,“采购收据项目”中的总适用费用表必须与“总税收和费用”相同
DocType: Delivery Note,In Words will be visible once you save the Delivery Note.,保存交货单后，将显示单词。
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Suppliies made to Composition Taxable Persons,对合成纳税人的补贴
DocType: Bin,Reserved Qty for Production,保留的生产数量
DocType: Asset,Quality Manager,质量经理
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit_type/healthcare_service_unit_type.py,"Configure Item Fields like UOM, Item Group, Description and No of Hours.",配置项目字段，如UOM，项目组，描述和小时数。
apps/erpnext/erpnext/hr/doctype/department/department_tree.js,New Department,新部门
DocType: Employee,Job Applicant,求职者
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Create Invoices,创建发票
DocType: Purchase Invoice Item,Purchase Order Item,采购订单项目
apps/erpnext/erpnext/config/settings.py,Data Import and Export,数据导入和导出
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Please contact to the user who have Sales Master Manager {0} role,请联系具有Sales Master Manager {0}角色的用户
apps/erpnext/erpnext/projects/doctype/project_type/project_type.py,You cannot delete Project Type 'External',您无法删除项目类型“外部”
DocType: Account,Temporary,临时
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Column Labels : ,列标签：
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Employee A/C Number,员工账号
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date should be before Closing Date,开放日期应在截止日期之前
DocType: Packed Item,Parent Detail docname,父详细信息docname
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,银行对帐明细
DocType: Tax Withholding Rate,Cumulative Transaction Threshold,累积交易阈值
DocType: Subscription Plan,"Number of intervals for the interval field e.g if Interval is 'Days' and Billing Interval Count is 3, invoices will be generated every 3 days",间隔字段的间隔数例如，如果Interval为&#39;Days&#39;且Billing Interval Count为3，则每3天生成一次发票
apps/erpnext/erpnext/projects/doctype/task/task.py,'Actual Start Date' can not be greater than 'Actual End Date',“实际开始日期”不能超过“实际结束日期”
DocType: Payment Entry Reference,Payment Entry Reference,付款条目参考
DocType: Salary Component Account,Salary Component Account,薪酬组件账户
DocType: Supplier,Default Payable Accounts,默认应付账款
DocType: Purchase Invoice,In Words,用言语
DocType: Journal Entry Account,Purchase Order,采购订单
DocType: Journal Entry,Entry Type,进入类型
apps/erpnext/erpnext/config/healthcare.py,Laboratory,实验室
DocType: Purchase Order,To Bill,开单
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Utility Expenses,公用事业费用
DocType: Manufacturing Settings,Time Between Operations (in mins),运营间隔时间（分钟）
DocType: GSTR 3B Report,May,可以
apps/erpnext/erpnext/accounts/utils.py,"Payment Gateway Account not created, please create one manually.",付款网关帐户未创建，请手动创建一个。
DocType: Opening Invoice Creation Tool,Purchase,采购
DocType: Program Enrollment,School House,学校的房子
apps/erpnext/erpnext/public/js/setup_wizard.js,Please select at least one domain.,请至少选择一个域名。
apps/erpnext/erpnext/projects/doctype/project/project.py,Daily Project Summary for {0},{0}的每日项目摘要
apps/erpnext/erpnext/accounts/doctype/sales_invoice/pos.py,All Territories,所有领土
DocType: Asset Repair,Failure Date,失败日期
DocType: Training Event,Attendees,与会者
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Total Outstanding,总突出
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Amount of TDS Deducted,扣除TDS的金额
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cash or Bank Account is mandatory for making payment entry,付款时必须使用现金或银行账户
DocType: Company,Registration Details,注册细节
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Calculated Bank Statement balance,计算银行对账单余额
apps/erpnext/erpnext/hub_node/api.py,Only users with {0} role can register on Marketplace,只有{0}角色的用户才能在Marketplace上注册
apps/erpnext/erpnext/controllers/stock_controller.py,"Warehouse {0} is not linked to any account, please mention the account in  the warehouse record or set default inventory account in company {1}.",仓库{0}未链接到任何帐户，请在仓库记录中提及该帐户或在公司{1}中设置默认库存帐户。
DocType: Inpatient Record,Admission,入场
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,This is based on the attendance of this Student,这是基于该学生的出席情况
DocType: SMS Center,Create Receiver List,创建接收者列表
DocType: Leave Type,Max Leaves Allowed,最大叶子允许
DocType: Salary Detail,Component,零件
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Leave and Attendance,离开和出勤
DocType: Sales Invoice Timesheet,Billing Amount,结算金额
DocType: BOM Website Item,BOM Website Item,BOM网站项目
DocType: Purchase Invoice,Rounded Total,圆形总计
DocType: Production Plan,Production Plan,生产计划
DocType: Asset Maintenance Log,Actions performed,已执行的操作
DocType: Purchase Invoice,Set Accepted Warehouse,设置接受的仓库
apps/erpnext/erpnext/config/buying.py,Rules for applying pricing and discount.,申请定价和折扣的规则。
DocType: Supplier,Statutory info and other general information about your Supplier,有关您的供应商的法定信息和其他一般信息
DocType: Item Default,Default Selling Cost Center,默认销售成本中心
DocType: Sales Partner,Address & Contacts,地址和联系方式
DocType: Subscriber,Subscriber,订户
apps/erpnext/erpnext/utilities/bot.py,[{0}](#Form/Item/{0}) is out of stock,[{0}]（＃Form / Item / {0}）缺货
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Posting Date first,请先选择发布日期
DocType: Supplier,Mention if non-standard payable account,如果是非标准的应付帐户，请提及
DocType: Training Event,Advance,预先
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,"Root Type for ""{0}"" must be one of the Asset, Liability, Income, Expense and Equity",“{0}”的根类型必须是资产，责任，收入，费用和权益之一
DocType: Project,% Complete Method,完成方法％
DocType: Detected Disease,Tasks Created,创建的任务
apps/erpnext/erpnext/stock/doctype/item/item.py,Default BOM ({0}) must be active for this item or its template,默认物料清单（{0}）必须对此料品或其模板有效
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Commission Rate %,佣金率％
DocType: Service Level Priority,Response Time,响应时间
DocType: Woocommerce Settings,Woocommerce Settings,Woocommerce设置
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Quantity must be positive,数量必须是正数
DocType: Contract,CRM,CRM
DocType: Purchase Taxes and Charges,Parenttype,ParentType的
DocType: Tax Rule,Billing State,账单状态
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Quantity for Item {0} must be less than {1},第{0}项的数量必须小于{1}
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Transfer Material,转移材料
DocType: Shipping Rule,Shipping Account,运输帐户
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Please set default template for Leave Approval Notification in HR Settings.,请在HR设置中为Leave Approval Notification设置默认模板。
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Television,电视
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection required for Item {0},项目{0}需要进行质量检验
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Debit ({0}),借记（{0}）
DocType: Healthcare Practitioner,Inpatient Visit Charge,住院访问费用
DocType: Bank Statement Settings,Transaction Data Mapping,交易数据映射
apps/erpnext/erpnext/crm/doctype/lead/lead.py,A Lead requires either a person's name or an organization's name,领导者需要一个人的姓名或组织的名称
DocType: Student,Guardians,守护者
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Brand...,选择品牌......
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Middle Income,中等收入
DocType: Shipping Rule,Calculate Based On,基于计算
apps/erpnext/erpnext/stock/doctype/item/item.py,Barcode {0} already used in Item {1},条款{0}已在项目{1}中使用
DocType: Lead,Campaign Name,广告系列名称
DocType: Purchase Invoice,Rejected Warehouse,拒绝仓库
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} must be submitted,必须提交{0} {1}
DocType: Expense Claim Advance,Expense Claim Advance,费用索赔预付款
DocType: Purchase Invoice,Rounding Adjustment (Company Currency),四舍五入调整（公司货币）
DocType: Item,Publish in Hub,在Hub中发布
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTIN,GSTIN
DocType: GSTR 3B Report,August,八月
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter Purchase Receipt first,请先输入购买收据
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Start Year,开始一年
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Target ({}),目标（{}）
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set Default Payroll Payable Account in Company {0},请在公司{0}中设置默认工资支付帐户
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/closing_voucher_details.html,Sales Summary,销售摘要
DocType: Purchase Invoice,In Words (Company Currency),用词（公司货币）
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Please specify currency in Company,请在公司中指定货币
DocType: Pricing Rule,Price,价钱
DocType: Material Request Item,Min Order Qty,最小订单数量
DocType: Agriculture Task,Holiday Management,假期管理
apps/erpnext/erpnext/hr/doctype/daily_work_summary_group/daily_work_summary_group.py,Please enable default incoming account before creating Daily Work Summary Group,请在创建每日工作摘要组之前启用默认传入帐户
apps/erpnext/erpnext/accounts/doctype/cash_flow_mapping/cash_flow_mapping.py,You can only select a maximum of one option from the list of check boxes.,您只能从复选框列表中选择最多一个选项。
DocType: Program Enrollment,Public Transport,公共交通
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Maximum Samples - {0} can be retained for Batch {1} and Item {2}.,最大样本 -  {0}可以保留为批{1}和项{2}。
DocType: Item,Max Sample Quantity,最大样品数量
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Source and target warehouse must be different,源仓库和目标仓库必须不同
DocType: Employee Benefit Application,Benefits Applied,应用的好处
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Against Journal Entry {0} does not have any unmatched {1} entry,针对日记帐分录{0}没有任何不匹配的{1}条目
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,"Special Characters except ""-"", ""#"", ""."", ""/"", ""{"" and ""}"" not allowed in naming series",命名系列中不允许使用除“ - ”，“＃”，“。”，“/”，“{”和“}”之外的特殊字符
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,Price or product discount slabs are required,价格或产品折扣板是必需的
apps/erpnext/erpnext/utilities/user_progress.py,Set a Target,设定目标
apps/erpnext/erpnext/education/doctype/student_attendance/student_attendance.py,Attendance Record {0} exists against Student {1},针对学生{1}的出勤记录{0}
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Date of Transaction,交易日期
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Cancel Subscription,取消订阅
apps/erpnext/erpnext/support/doctype/issue/issue.py,Couldn't Set Service Level Agreement {0}.,无法设置服务水平协议{0}。
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Net Salary Amount,净工资金额
DocType: Account,Liability,责任
DocType: Employee,Bank A/C No.,银行A / C号
DocType: Inpatient Record,Discharge Note,出院备注
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on MR,如果累计月度预算超过MR，则采取行动
DocType: Asset Movement,Asset Movement,资产流动
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,"Could not create Credit Note automatically, please uncheck 'Issue Credit Note' and submit again",无法自动创建信用票据，请取消选中“发行信用票据”并再次提交
DocType: Supplier Scorecard,Per Month,每月
DocType: Routing,Routing Name,路由名称
DocType: Disease,Common Name,通用名称
DocType: Education Settings,LMS Title,LMS标题
apps/erpnext/erpnext/config/non_profit.py,Loan Management,贷款管理
DocType: Clinical Procedure,Consumable Total Amount,消耗总量
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Enable Template,启用模板
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Customer LPO,客户LPO
apps/erpnext/erpnext/stock/doctype/item/item.py,Website Image {0} attached to Item {1} cannot be found,无法找到附加到项目{1}的网站图像{0}
DocType: Asset Maintenance Log,Planned,计划
DocType: Asset,Custodian,保管人
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Filter based on Cost Center is only applicable if Budget Against is selected as Cost Center,仅当“预算违规”选为“成本中心”时，基于“成本中心”的过滤才适用
,Quoted Item Comparison,引用项目比较
DocType: Journal Entry Account,Employee Advance,员工进步
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies liable to reverse charge (other than 1 & 2 above),内向物品可能反向充电（上述1和2除外）
DocType: Quotation,Shopping Cart,购物车
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} does not exist,用户{0}不存在
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans and Advances (Assets),贷款和垫款（资产）
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,行{0}：如果这是提前输入，请检查帐户{1}的“提前”。
DocType: Leave Control Panel,Designation (optional),指定（可选）
DocType: Salary Slip,Total Principal Amount,总本金额
DocType: Opportunity,Customer / Lead Address,客户/主要地址
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Soap & Detergent,肥皂和洗涤剂
,Purchase Analytics,购买分析
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Opportunity,机会
DocType: Employee,Prefered Contact Email,首选联系电子邮件
apps/erpnext/erpnext/config/help.py,Opening Accounting Balance,开立会计余额
DocType: POS Profile,[Select],[选择]
DocType: Stock Reconciliation,MAT-RECO-.YYYY.-,MAT-RECO-.YYYY.-
DocType: Tally Migration,Master Data,主要的数据
DocType: Certification Application,Yet to appear,然而出现
apps/erpnext/erpnext/public/js/pos/pos.html,Customers in Queue,队列中的客户
DocType: Supplier,Supplier Details,供应商详情
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,No gain or loss in the exchange rate,汇率没有收益或损失
,GSTR-1,GSTR-1
DocType: Timesheet,Total Billable Hours,总可结算时数
DocType: Supplier,Represents Company,代表公司
DocType: POS Profile,Company Address,公司地址
,Lead Name,主要名称
apps/erpnext/erpnext/config/agriculture.py,Diseases & Fertilizers,疾病与肥料
apps/erpnext/erpnext/stock/get_item_details.py,Item {0} must be a Sub-contracted Item,项目{0}必须是子签约项目
DocType: Landed Cost Voucher,Purchase Receipt Items,购买收据项目
DocType: Production Plan,Ignore Existing Projected Quantity,忽略现有的预计数量
DocType: Assessment Plan,Supervisor,监
DocType: Salary Detail,Salary Detail,薪资明细
DocType: Budget,Budget Against,预算反对
DocType: Student Report Generation Tool,Add Letterhead,添加信头
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard criteria.,供应商记分卡标准模板。
DocType: Asset,Default Finance Book,默认财务手册
apps/erpnext/erpnext/stock/get_item_details.py,Please specify Company,请注明公司
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Total contribution percentage should be equal to 100,总贡献百分比应等于100
DocType: GoCardless Settings,Webhooks Secret,Webhooks秘密
,Asset Depreciations and Balances,资产折旧和余额
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch Qty,新批量数量
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of goods,进口货物
DocType: Purchase Order Item Supplied,Raw Material Item Code,原材料项目代码
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Invoice {0} is already submitted,已提交采购发票{0}
DocType: Fees,Student Email,学生电邮
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Healthcare Services,从医疗保健服务获取项目
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Stock Entry {0} is not submitted,库存条目{0}未提交
DocType: Item Attribute Value,Item Attribute Value,物品属性值
DocType: Volunteer,Volunteer Skills,志愿者技能
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Cannot enroll more than {0} students for this student group.,此学生组不能为{0}名学生注册。
DocType: Travel Request,Costing Details,成本计算细节
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Invoice {0} has already been submitted,销售发票{0}已提交
DocType: Journal Entry,Accounting Entries,会计分录
DocType: Payment Entry,Internal Transfer,内部转移
DocType: Sales Invoice Item,Stock Details,股票详情
DocType: Leave Type,Is Carry Forward,继续前进
DocType: Lead,Product Enquiry,产品查询
DocType: Purchase Order,PUR-ORD-.YYYY.-,PUR-ORD-.YYYY.-
DocType: Supplier Scorecard,Evaluation Period,评估期
DocType: Volunteer Skill,Volunteer Skill,志愿者技能
DocType: Purchase Order,Order Confirmation No,订单确认号
,POS,POS
DocType: Training Event,Self-Study,自习
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Above,以上
DocType: Setup Progress Action,Action Doctype,动作Doctype
DocType: POS Profile,Allow Print Before Pay,付款前允许打印
DocType: Production Plan,Select Items to Manufacture,选择要制造的项目
DocType: Leave Application,Leave Approver Name,留下审批人姓名
DocType: Shareholder,Shareholder,股东
apps/erpnext/erpnext/config/selling.py,Default settings for selling transactions.,销售交易的默认设置。
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Please select Student Admission which is mandatory for the paid student applicant,请选择学生入学，这是付费学生申请人必须的
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM,选择BOM
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Schedules for {0} overlaps, do you want to proceed after skiping overlaped slots ?",{0}的时间表重叠，是否要在滑动重叠的插槽后继续？
DocType: Stock Entry,Customer or Supplier Details,客户或供应商详情
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Debit Account,借方账户
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Trial Period End Date Cannot be before Trial Period Start Date,试用期结束日期不能在试用期开始日期之前
DocType: Employee,Rented,租用
DocType: Employee Group Table,Employee Group Table,员工组表
DocType: Contract,HR Manager,人力资源经理
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Details of Outward Supplies and inward supplies liable to reverse charge,向外供应和向内供应的详细信息可能被撤销费用
DocType: Payment Entry,Cheque/Reference No,检查/参考编号
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.js,Assessment Result,评估结果
apps/erpnext/erpnext/public/js/templates/contact_list.html,New Contact,新联系人
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Opportunities,机会
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Operations,运营现金净额
DocType: Leave Encashment,Leave Encashment,离开兑现
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source warehouse is mandatory for row {0},行仓库对于行{0}是必需的
DocType: Amazon MWS Settings,After Date,日期之后
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Available (whether in full op part),ITC可用（无论是全部操作部分）
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Activity Type is mandatory.,行{0}：活动类型是必需的。
DocType: Lead,Consultant,顾问
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Select an employee to get the employee advance.,选择一名员工以提升员工。
apps/erpnext/erpnext/assets/doctype/asset/asset.py,"Asset cannot be cancelled, as it is already {0}",资产无法取消，因为它已经是{0}
apps/erpnext/erpnext/setup/doctype/company/company.js,Wrong Password,密码错误
DocType: Item,STO-ITEM-.YYYY.-,STO-ITEM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Number / Name,更新帐号/名称
DocType: Accounts Settings,Use Custom Cash Flow Format,使用自定义现金流量格式
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices,开立发票
DocType: Stock Entry,Send to Warehouse,发送到仓库
DocType: Training Event,Event Status,活动状态
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty must be greater than zero,完成的总数量必须大于零
DocType: Account,Chargeable,收费
DocType: Volunteer,Anytime,随时
,Student Batch-Wise Attendance,学生批量出席
DocType: Normal Test Template,Normal Test Template,正常测试模板
apps/erpnext/erpnext/config/accounting.py,Tree of financial Cost Centers.,金融成本中心树。
DocType: Work Order Operation,"in Minutes
Updated via 'Time Log'",在几分钟内通过&#39;时间日志&#39;更新
DocType: Bin,Bin,箱子
DocType: Payment Reconciliation Invoice,Invoice Number,发票编号
DocType: Delivery Trip,Fulfillment User,履行用户
DocType: Work Order Operation,Planned End Time,计划结束时间
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Section Code,部分代码
DocType: Project,Monitor Progress,监控进度
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select Batch No,选择批号
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Payroll Number,工资号码
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Include UOM,包括UOM
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,库存分类帐分录和总帐分录将重新过帐所选的采购收据
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Update Print Format,更新打印格式
DocType: Student,Siblings,兄弟姐妹
DocType: Purchase Invoice,Hold Invoice,持有发票
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Invalid reference {1},行{0}：无效的引用{1}
,Profitability Analysis,盈利能力分析
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,New Account Name,新帐户名称
DocType: Employee Benefit Claim,Expense Proof,费用证明
DocType: Restaurant Order Entry Item,Served,曾任
DocType: Loan,Member,会员
DocType: Practitioner Service Unit Schedule,Practitioner Service Unit Schedule,从业者服务单位时间表
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Wire Transfer,电汇
DocType: Quality Review Objective,Quality Review Objective,质量审查目标
DocType: Bank Reconciliation Detail,Against Account,反对帐户
DocType: Projects Settings,Projects Settings,项目设置
apps/erpnext/erpnext/stock/dashboard/item_dashboard_list.html,Actual Qty {0} / Waiting Qty {1},实际数量{0} /等待数量{1}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} cannot be a Group,{0} {1}：帐户{2}不能是群组
DocType: Prescription Duration,Prescription Duration,处方持续时间
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Debit entry can not be linked with a {1},行{0}：借记条目无法与{1}链接
DocType: Program,Intro Video,介绍视频
DocType: Purchase Invoice,Is Paid,已经付清
DocType: Account,Debit,借方
,Item Balance (Simple),物品平衡（简单）
apps/erpnext/erpnext/utilities/activation.py,Purchase orders help you plan and follow up on your purchases,采购订单可帮助您计划和跟进购买
DocType: Project,Project Type,项目类型
DocType: Program Enrollment Tool Student,Student Batch Name,学生批名称
,Qty to Receive,收到的数量
DocType: Agriculture Task,Previous Business Day,上一工作日
DocType: Travel Request Costing,Sponsored Amount,赞助金额
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Please wait 3 days before resending the reminder.,请等待3天再重新发送提醒。
DocType: Sales Invoice Item,Qty as per Stock UOM,按库存UOM数量
DocType: Opening Invoice Creation Tool Item,Quantity,数量
DocType: Delivery Stop,Estimated Arrival,预计抵达时间
,Trial Balance for Party,党的审判平衡
DocType: Employee Separation,Employee Separation Template,员工分离模板
DocType: Quality Objective,Unit,单元
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Maximum benefit amount of component {0} exceeds {1},组件{0}的最大收益金额超过{1}
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Venture Capital,风险投资
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year End Date should be one year after Fiscal Year Start Date,会计年度结束日期应为会计年度开始日期后一年
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Daily Reminders,每日提醒
DocType: Item,Default Sales Unit of Measure,默认销售计量单位
apps/erpnext/erpnext/regional/report/gst_itemised_sales_register/gst_itemised_sales_register.js,Company GSTIN,公司GSTIN
DocType: Asset Finance Book,Rate of Depreciation,折旧率
DocType: Support Search Source,Post Description Key,帖子描述键
DocType: Loyalty Program Collection,Minimum Total Spent,最低总支出
DocType: Supplier Scorecard Period,Period Score,期间分数
apps/erpnext/erpnext/education/doctype/assessment_criteria/assessment_criteria.py,Can't create standard criteria. Please rename the criteria,无法创建标准条件。请重命名标准
DocType: Travel Itinerary,Arrival Datetime,到达日期时间
apps/erpnext/erpnext/education/doctype/student/student_dashboard.py,Student LMS Activity,学生LMS活动
DocType: Stock Reconciliation Item,Quantity Difference,数量差异
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Allocated Amount cannot be greater than outstanding amount.,行＃{0}：分配的金额不能大于未付金额。
DocType: Sales Invoice Timesheet,Timesheet Detail,时间表细节
DocType: Employee Skill,Proficiency,能力
DocType: SMS Log,Sent To,寄去
DocType: Item,Hub Publishing Details,Hub Publishing详细信息
apps/erpnext/erpnext/utilities/activation.py,"Student Batches help you track attendance, assessments and fees for students",学生批次可以帮助您跟踪学生的出勤率，评估和费用
DocType: Employee Tax Exemption Declaration Category,Declared Amount,申报金额
DocType: Selling Settings,Auto close Opportunity after 15 days,15天后自动关闭机会
DocType: Share Transfer,Issue,问题
DocType: Volunteer,Availability Timeslot,可用性时间段
DocType: Program,Program Abbreviation,程序缩写
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Start Date,项目开始日期
DocType: Purchase Invoice,Additional DIscount Amount,额外的DIscount金额
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} not found in 'Raw Materials Supplied' table in Purchase Order {1},采购订单{1}中的“原材料提供”表中未找到料品{0}
DocType: BOM,Manage cost of operations,管理运营成本
apps/erpnext/erpnext/accounts/doctype/account/account.py,You are not authorized to set Frozen value,您无权设置“冻结”值
DocType: Contract,Lapsed,失效
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Investments,投资
DocType: Inpatient Record,Date of Birth,出生日期
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的用户才能在Marketplace上注册。
DocType: Item Attribute,Item Attribute Values,项目属性值
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please save the patient first,请先保存患者
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Half Day Date should be between From Date and To Date,半日期应在起始日期和到期日之间
DocType: Inpatient Record,Expected Discharge,预期解雇
DocType: Travel Request,Travel Type,旅行类型
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Customer is required,客户是必需的
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Invalid quantity specified for item {0}. Quantity should be greater than 0.,为项目{0}指定的数量无效。数量应大于0。
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Supervisor,作为主管
DocType: Payroll Entry,Employees,雇员
DocType: Sales Order,Billing Status,结算状态
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Please select Category first,请先选择类别
apps/erpnext/erpnext/config/manufacturing.py,BOM Browser,BOM浏览器
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.js,Create Student Groups,创建学生组
DocType: Work Order Operation,In Minutes,在几分钟内
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Net Pay cannot be less than 0,净薪酬不能低于0
DocType: Maintenance Schedule,Schedules,时间表
DocType: Employee Training,Employee Training,员工培训
DocType: Loan,Rate of Interest (%) / Year,利率（％）/年
DocType: Normal Test Items,Require Result Value,需要结果值
DocType: Loan,Loan Type,贷款类型
DocType: Packing Slip,Identification of the package for the delivery (for print),识别包裹（用于打印）
DocType: Assessment Plan,Assessment Name,评估名称
DocType: Travel Itinerary,Departure Datetime,出发日期时间
DocType: Delivery Note Item,From Warehouse,从仓库
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} against {2} {3},对{2} {3}的金额{0} {1}
apps/erpnext/erpnext/stock/doctype/item/item.js,Create Variant,创建变体
DocType: Contract Template,Fulfilment Terms and Conditions,履行条款和条件
apps/erpnext/erpnext/setup/doctype/company/company.js,Date of Commencement should be greater than Date of Incorporation,开始日期应大于公司注册日期
DocType: Pricing Rule,Price or Product Discount,价格或产品折扣
DocType: Quality Inspection Reading,Reading 1,阅读1
DocType: Student Admission Program,Maximum Age,最大年龄
DocType: Payroll Period,Payroll Periods,工资期
apps/erpnext/erpnext/buying/report/subcontracted_raw_materials_to_be_transferred/subcontracted_raw_materials_to_be_transferred.py,Transferred Quantity,转移数量
DocType: Marketplace Settings,Marketplace Settings,市场设置
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Purchase Orders are not allowed for {0} due to a scorecard standing of {1}.,由于记分卡为{1}，因此{0}不允许购买订单。
apps/erpnext/erpnext/stock/get_item_details.py,Price List not selected,未选择价目表
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,Workstation is closed on the following dates as per Holiday List: {0},根据假期列表，工作站将在以下日期关闭：{0}
DocType: Customer,"Reselect, if the chosen address is edited after save",如果在保存后编辑了所选地址，请重新选择
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Item {0} cannot be changed directly because you have already made some transaction(s) with another UOM. You will need to create a new Item to use a different Default UOM.,项目{0}的默认度量单位无法直接更改，因为您已经与另一个UOM进行了一些事务。您需要创建一个新项目以使用不同的默认UOM。
apps/erpnext/erpnext/stock/doctype/item/item.js,Changing Customer Group for the selected Customer is not allowed.,不允许更改所选客户的客户组。
DocType: Serial No,Creation Document Type,创建文档类型
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,仓库的可用批次数量
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Invoice Grand Total,发票总计
apps/erpnext/erpnext/setup/doctype/territory/territory.js,This is a root territory and cannot be edited.,这是根域，无法编辑。
DocType: Patient,Surgical History,外科史
apps/erpnext/erpnext/config/quality_management.py,Tree of Quality Procedures.,质量树程序。
DocType: Bank Account,Contact HTML,联系HTML
,Employee Information,员工信息
DocType: Assessment Plan,Examiner,检查员
DocType: Employee Tax Exemption Proof Submission Detail,Actual Amount,实际金额
DocType: Contract,Fulfilled,达到
apps/erpnext/erpnext/controllers/buying_controller.py,Row {0}: Enter location for the asset item {1},行{0}：输入资产项{1}的位置
DocType: Project Task,View Timesheet,查看时间表
DocType: Purchase Invoice,Taxes and Charges Calculation,税收和收费计算
DocType: Setup Progress Action,Action Document,行动文件
DocType: Clinical Procedure,Procedure Prescription,程序处方
DocType: Guardian,Guardian Name,卫报的名字
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Successfully Reconciled,成功调和
DocType: Accounting Period,Period Name,期间名称
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Please pull items from Delivery Note,请从交货单中提取物品
DocType: Content Question,Content Question,内容问题
apps/erpnext/erpnext/public/js/pos/pos_bill_item.html,In Stock: ,有现货：
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.js,Please save before assigning task.,请在分配任务前保存。
apps/erpnext/erpnext/accounts/doctype/bank_account/bank_account.py,Company is manadatory for company account,公司是公司账户的管理者
DocType: Sales Order Item,Delivery Warehouse,交货仓库
DocType: Shopify Settings,Enable Shopify,启用Shopify
DocType: Patient,Additional information regarding the patient,有关患者的其他信息
DocType: Landed Cost Voucher,Purchase Receipts,购买收据
apps/erpnext/erpnext/hr/doctype/employee/employee_tree.js,New Employee,新员工
DocType: Purchase Invoice,Update Auto Repeat Reference,更新自动重复参考
DocType: Fees,Fees,费用
DocType: Student Group,Student Group Name,学生团体名称
DocType: Supplier Scorecard Scoring Standing,Employee,雇员
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Available-for-use Date should be after purchase date,可供使用的日期应在购买日期之后
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Please define grade for Threshold 0%,请为门槛0％定义等级
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,"Apps using current key won't be able to access, are you sure?",使用当前密钥的应用无法访问，您确定吗？
DocType: Quality Meeting,Minutes,分钟
DocType: Quiz Result,Correct,正确
DocType: Employee Tax Exemption Declaration,Total Declared Amount,申报总金额
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.py,Material,材料
DocType: Appointment Type,Is Inpatient,是住院病人
DocType: Leave Encashment,Encashment Amount,兑现金额
DocType: BOM,Conversion Rate,兑换率
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,CEO,CEO
apps/erpnext/erpnext/projects/doctype/project/project.js,Set tasks in this project as cancelled?,将此项目中的任务设置为已取消？
DocType: Bin,Reserved Qty for sub contract,子合同的保留数量
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Create Payment Entry,创建付款条目
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Submit Proof,提交证明
DocType: Payment Term,Credit Months,信用月份
DocType: Bank Guarantee,Providing,提供
DocType: Sales Invoice,Total Billing Amount,总计费金额
DocType: Maintenance Visit,Maintenance Visit,维护访问
DocType: Item,Country of Origin,出生国家
DocType: Agriculture Analysis Criteria,Agriculture Analysis Criteria,农业分析标准
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Additional Salary Component Exists.,额外的薪资组件存在。
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Grocery,杂货
DocType: Restaurant Table,Minimum Seating,最低座位
DocType: Vital Signs,Furry,毛茸茸
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Account, if grouped by Account",如果按帐户分组，则无法根据帐户进行过滤
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Bank Entries,银行参赛作品
DocType: Soil Texture,Sandy Clay Loam,桑迪粘土壤土
DocType: Crop Cycle,LInked Analysis,LInked分析
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Valid From Date must be lesser than Valid Upto Date.,有效起始日期必须小于有效起始日期。
DocType: Additional Salary,Salary Component,薪酬部分
DocType: Asset Maintenance Team,Maintenance Team Members,维护团队成员
DocType: Student Admission Program,Minimum Age,最低年龄
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Available Selling,可售
DocType: Purchase Invoice,Taxes and Charges Deducted,税收和收费扣除
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Lab Test,创建实验室测试
DocType: Hotel Settings,Hotel Settings,酒店设置
DocType: Naming Series,Select Transaction,选择交易
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Declare Lost,宣布失去
DocType: Warranty Claim,If different than customer address,如果与客户地址不同
DocType: Chart of Accounts Importer,Chart Tree,图表树
DocType: Contract,Contract,合同
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,Please select the Multiple Tier Program type for more than one collection rules.,请为多个收集规则选择多层程序类型。
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,{0} for {1},{1}为{1}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For Quantity (Manufactured Qty) is mandatory,对于数量（制造数量）是强制性的
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Primary School"" or ""University""",例如“小学”或“大学”
DocType: Pricing Rule,Apply Multiple Pricing Rules,应用多个定价规则
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.py,Review Invitation Sent,查看邀请已发送
DocType: Item,No of Months,没有几个月
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial Nos Required for Serialized Item {0},序列化项目{0}所需的序列号
apps/erpnext/erpnext/config/manufacturing.py,Bill of Materials (BOM),物料清单（BOM）
DocType: Accounts Settings,Allow Stale Exchange Rates,允许过时的汇率
DocType: BOM,Website Description,网站描述
DocType: POS Closing Voucher,Expense Details,费用详情
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,From Range has to be less than To Range,范围必须小于范围
DocType: Homepage,Products to be shown on website homepage,产品将在网站主页上显示
DocType: Tally Migration,Is Master Data Processed,主数据是否已处理
DocType: Item Price,Quantity  that must be bought or sold per UOM,每个UOM必须购买或出售的数量
DocType: Project,Total Sales Amount (via Sales Order),总销售额（通过销售订单）
apps/erpnext/erpnext/utilities/user_progress.py,Box,框
DocType: QuickBooks Migrator,Default Cost Center,默认成本中心
DocType: Purchase Order Item,Billed Amt,收费金额
apps/erpnext/erpnext/accounts/utils.py,Please set default {0} in Company {1},请在公司{1}中设置默认{0}
DocType: Cheque Print Template,Distance from left edge,距左边缘的距离
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 4,第4项
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"Advance paid against {0} {1} cannot be greater \
						than Grand Total {2}",对{0} {1}支付的预付款不能超过总计{2}
DocType: Account,Income Account,收入账户
apps/erpnext/erpnext/patches/v7_0/create_warehouse_nestedset.py,All Warehouses,所有仓库
DocType: Contract,Signee Details,Signee详细信息
DocType: Shift Type,Allow check-out after shift end time (in minutes),允许在班次结束后退房（以分钟为单位）
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,Procurement,采购
DocType: Item Group,Check this if you want to show in website,如果要在网站上显示，请选中此项
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Fiscal Year {0} not found,找不到会计年度{0}
DocType: Bank Statement Settings,Bank Statement Settings,银行对账单设置
DocType: Quality Procedure Process,Link existing Quality Procedure.,链接现有的质量程序。
apps/erpnext/erpnext/config/getting_started.py,Import Chart Of Accounts from CSV / Excel files,从CSV / Excel文件导入科目表
DocType: Appraisal Goal,Score (0-5),分数（0-5）
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute {0} selected multiple times in Attributes Table,在“属性表”中多次选择了属性{0}
DocType: Purchase Invoice,Debit Note Issued,发行借方通知单
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.js,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Product Bundle",请选择项目，其中“是库存项目”是“否”，“是销售项目”是“是”，没有其他产品包
apps/erpnext/erpnext/hr/utils.py,Employee {0} of grade {1} have no default leave policy,成绩{1}的员工{0}没有默认休假政策
DocType: Leave Policy Detail,Leave Policy Detail,请留下政策明细
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Warehouse not found in the system,仓库在系统中找不到
DocType: Healthcare Practitioner,OP Consulting Charge,OP咨询费
DocType: Bank Statement Transaction Payment Item,Invoices,发票
DocType: Currency Exchange,Currency Exchange,货币兑换
DocType: Payroll Entry,Fortnightly,半月刊
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} not in stock,序列号{0}没有库存
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Material Request not created, as quantity for Raw Materials already available.",材料请求未创建，因为原材料的数量已经可用。
DocType: Woocommerce Settings,Creation User,创作用户
apps/erpnext/erpnext/config/crm.py,"Record of all communications of type email, phone, chat, visit, etc.",电子邮件，电话，聊天，访问等所有通信记录
DocType: Asset Settings,Asset Settings,资产设置
DocType: Compensatory Leave Request,Worked On Holiday,在度假工作
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Either location or employee must be required,必须要求地点或员工
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} is cancelled,项目{0}已取消
DocType: Course Scheduling Tool,Course End Date,课程结束日期
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Opportunity From field is mandatory,来自现场的机会是强制性的
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Warning: Leave application contains following block dates,警告：请假应用程序包含以下阻止日期
DocType: Asset Maintenance Task,Preventive Maintenance,预防性的维护
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Abbreviation,学院缩写
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Difference Account must be a Asset/Liability type account, since this Stock Reconciliation is an Opening Entry",差异账户必须是资产/负债类型账户，因为此股票对账是开仓条目
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Contract End Date must be greater than Date of Joining,合同结束日期必须大于加入日期
DocType: Employee Grade,Default Leave Policy,默认离开政策
DocType: Daily Work Summary Group,Select Users,选择用户
DocType: Workstation,Net Hour Rate,净小时费率
DocType: Clinical Procedure,Age,年龄
DocType: Travel Request,Event Details,活动详情
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Accumulated Monthly,每月累计
apps/erpnext/erpnext/projects/doctype/project/project.js,Save the document first.,首先保存文档。
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Update Cost,更新成本
DocType: Sales Order,Fully Delivered,完全交付
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Please enter company first,请先进入公司
apps/erpnext/erpnext/config/selling.py,Confirmed orders from Customers.,来自客户的确认订单。
DocType: Dosage Strength,Dosage Strength,剂量强度
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Fill the form and save it,填写表格并保存
DocType: Program Enrollment Tool,Enrollment Details,报名详情
DocType: Subscription Invoice,Subscription Invoice,订阅发票
DocType: Leave Allocation,Total Leaves Encashed,总叶子数量增加
DocType: Quality Inspection,Verified By,经核实
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices,获取发票
DocType: Invoice Discounting,Settled,安定
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Re-open,重新打开
DocType: Period Closing Voucher,Closing Fiscal Year,关闭财政年度
DocType: Purchase Invoice,Release Date,发布日期
DocType: Purchase Invoice,Advances,进展
DocType: Shipping Rule,Specify conditions to calculate shipping amount,指定计算运费的条件
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Technology,技术
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',仅当收费类型为“在上一行金额上”或“上一行总计”时才能引用行
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",如果选中，则总计编号。工作日将包括假期，这将减少每日工资的价值
DocType: Location,Location Name,地点名称
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} does not belong to Company {3},{0} {1}：帐户{2}不属于公司{3}
DocType: Employee Benefit Application,Remaining Benefits (Yearly),剩余福利（每年）
DocType: Asset Finance Book,Depreciation Start Date,折旧开始日期
DocType: Activity Cost,Billing Rate,账单价格
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Warning: Another {0} # {1} exists against stock entry {2},警告：对于库存条目{2}存在另一个{0}＃{1}
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Please enable Google Maps Settings to estimate and optimize routes,请启用Google地图设置来估算和优化路线
DocType: Purchase Invoice Item,Page Break,分页符
DocType: Supplier Scorecard Criteria,Max Score,最高分数
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Repayment Start Date cannot be before Disbursement Date.,还款开始日期不能在支付日期之前。
DocType: Support Search Source,Support Search Source,支持搜索源
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Financial Services,金融服务
DocType: Volunteer,Availability,可用性
apps/erpnext/erpnext/config/quality_management.py,Tree of Procedures,程序树
DocType: Buying Settings,Allow Item to be added multiple times in a transaction,允许在事务中多次添加项目
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is not submitted,{0} {1}未提交
DocType: Work Order,Backflush raw materials from work-in-progress warehouse,从在制品库中反冲原料
DocType: Maintenance Team Member,Maintenance Team Member,维护团队成员
apps/erpnext/erpnext/config/accounting.py,Setup custom dimensions for accounting,为会计设置自定义维度
DocType: Crop Cycle,The minimum distance between rows of plants for optimum growth,植物行之间的最小距离，以实现最佳生长
DocType: Employee Health Insurance,Health Insurance Name,健康保险名称
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Stock Assets,股票资产
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Further cost centers can be made under Groups but entries can be made against non-Groups,可以在组下进行更多成本中心，但可以针对非组进行输入
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Upper Income,高收入
DocType: Company,Discount Allowed Account,折扣允许的帐户
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Restart Subscription,重新启动订阅
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,You can not change rate if BOM mentioned agianst any item,如果BOM提到任何项目，则无法更改费率
apps/erpnext/erpnext/hub_node/api.py,Please login as another user to register on Marketplace,请以另一个用户身份登录以在Marketplace上注册
DocType: Asset,Insurance Details,保险详情
DocType: Subscription,Past Due Date,截止日期
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,"You can only plan for upto {0} vacancies and budget {1} \
				for {2} as per staffing plan {3} for parent company {4}.",根据母公司{4}的人员配备计划{3}，您只能计划最多{0}个职位空缺和预算{1} \ {2}。
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,No GST No. found for the Company.,没有找到公司的GST编号。
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Pin Code,来自Pin Code
DocType: Contract,Signed On,签名
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Accounting Entry for {2} can only be made in currency: {3},{0} {1}：{2}的会计分录只能以货币进行：{3}
DocType: Assessment Criteria,Assessment Criteria,评估标准
DocType: Lab Test Template,Is Billable,是可以收费的
DocType: Naming Series,User must always select,用户必须始终选择
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Compensatory leave request days not in valid holidays,补偿假请求天数不在有效假期
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py,Sum of points for all goals should be 100. It is {0},所有目标的积分总和应为100.它是{0}
DocType: BOM,Scrap Items,废品
DocType: Special Test Template,Result Component,结果组件
apps/erpnext/erpnext/regional/india/utils.py,Please mention Basic and HRA component in Company,请在公司中提及基本和HRA组件
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,{0} does not belong to Company {1},{0}不属于公司{1}
DocType: Attendance Request,Half Day Date,半天日期
DocType: Delivery Note,Billing Address Name,帐单地址名称
,GST Itemised Purchase Register,GST分项购买登记册
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Alternate Item,替代项目
DocType: Certification Application,Name of Applicant,申请人名称
DocType: Leave Type,Earned Leave,获得休假
DocType: GSTR 3B Report,June,六月
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Row {0}: Cost center is required for an item {1},行{0}：项目{1}需要成本中心
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Can be approved by {0},可以通过{0}批准
apps/erpnext/erpnext/stock/doctype/item/item.py,Unit of Measure {0} has been entered more than once in Conversion Factor Table,在转换因子表中多次输入了计量单位{0}
DocType: Purchase Invoice Item,Net Rate (Company Currency),净费率（公司货币）
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,All BOMs,所有物料清单
DocType: Department,Days for which Holidays are blocked for this department.,截止该部门假期的天数。
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,"Cannot Submit, Employees left to mark attendance",无法提交，员工留下来标记出勤
DocType: BOM,Quality Inspection Template,质量检验模板
DocType: Plant Analysis,Result Datetime,结果日期时间
DocType: Purchase Taxes and Charges,Valuation,计价
,Student Monthly Attendance Sheet,学生每月出勤表
DocType: Academic Term,Term End Date,期限结束日期
DocType: Pricing Rule Detail,Child Docname,儿童医生名称
apps/erpnext/erpnext/public/js/setup_wizard.js,Services,服务
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than received quantity,无法设置小于收货数量的数量
DocType: Purchase Order Item,Supplier Part Number,供应商部件号
DocType: Lab Test Template,Standard Selling Rate,标准销售率
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set an active menu for Restaurant {0},请为餐厅{0}设置有效菜单
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user with System Manager and Item Manager roles to add users to Marketplace.,您需要是具有System Manager和Item Manager角色的用户才能将用户添加到Marketplace。
DocType: Asset Finance Book,Asset Finance Book,资产融资书
DocType: Quality Goal Objective,Quality Goal Objective,质量目标
DocType: Employee Transfer,Employee Transfer,员工转移
,Sales Funnel,销售漏斗
DocType: Agriculture Analysis Criteria,Water Analysis,水分析
DocType: Shift Type,Begin check-in before shift start time (in minutes),在班次开始时间（以分钟为单位）开始办理登机手续
DocType: Accounts Settings,Accounts Frozen Upto,帐户冻结了
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,There is nothing to edit.,没有什么可以编辑的。
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations",操作{0}比工作站{1}中的任何可用工作时间长，将操作分解为多个操作
DocType: Item Variant Settings,Do not update variants on save,不要在保存时更新变体
DocType: Grading Scale Interval,Threshold,阈
DocType: Timesheet,% Amount Billed,已结算金额
DocType: Warranty Claim,Resolved By,解决了
apps/erpnext/erpnext/utilities/user_progress.py,"Add users to your organization, other than yourself.",将用户添加到您的组织，而不是您自己。
DocType: Global Defaults,Default Company,默认公司
DocType: Shopify Settings,Cash Account will used for Sales Invoice creation,现金帐户将用于创建销售发票
apps/erpnext/erpnext/controllers/selling_controller.py,Sales Order {0} is {1},销售订单{0}为{1}
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Delay in payment (Days),延迟付款（天）
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Enter depreciation details,输入折旧详细信息
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Customer PO,客户PO
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Expected Delivery Date should be after Sales Order Date,预计交货日期应在销售订单日期之后
apps/erpnext/erpnext/controllers/accounts_controller.py,Item quantity can not be zero,物品数量不能为零
apps/erpnext/erpnext/controllers/item_variant.py,Invalid Attribute,无效的属性
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select BOM against item {0},请根据项目{0}选择物料清单
DocType: Bank Statement Transaction Invoice Item,Invoice Type,发票类型
DocType: Price List,Price List Master,价格表大师
,Lost Opportunity,失去的机会
DocType: Maintenance Visit,Maintenance Date,维护日期
DocType: Volunteer,Afternoon,下午
DocType: Vital Signs,Nutrition Values,营养价值观
DocType: Vital Signs,Presence of a fever (temp &gt; 38.5 °C/101.3 °F or sustained temp &gt; 38 °C/100.4 °F),发热（温度&gt; 38.5°C / 101.3°F或持续温度&gt; 38°C / 100.4°F）
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please setup Employee Naming System in Human Resource &gt; HR Settings,请在人力资源&gt;人力资源设置中设置员工命名系统
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,ITC Reversed,ITC逆转
DocType: Project,Collect Progress,收集进展
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Energy,能源
,Items To Be Requested,要求的项目
DocType: Soil Analysis,Ca/K,钙/ K
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Order already created for all items with BOM,已为包含BOM的所有项目创建工作订单
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Billed Amount,账单金额
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Current Odometer reading entered should be greater than initial Vehicle Odometer {0},输入的当前里程表读数应大于初始车辆里程表{0}
DocType: Employee Transfer Property,Employee Transfer Property,员工转移财产
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Pending Activities,待定活动
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your customers. They could be organizations or individuals.,列出一些客户。他们可以是组织或个人。
DocType: Bank Guarantee,Bank Account Info,银行账户信息
DocType: Quality Goal,Weekday,平日
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Name,Guardian1名称
DocType: Salary Component,Variable Based On Taxable Salary,基于应税薪酬的变量
DocType: Accounting Period,Accounting Period,会计期间
DocType: Company,Standard Working Hours,标准工作时间
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,In Stock,有现货
DocType: Amazon MWS Settings,Market Place Account Group,市场账户组
DocType: Stock Reconciliation Item,Before reconciliation,在和解之前
DocType: Fee Component,Fees Category,费用类别
DocType: Sales Order,%  Delivered,已交付％
DocType: Sales Invoice,Redemption Cost Center,赎回成本中心
DocType: Vital Signs,Respiratory rate,呼吸频率
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Get Students From,必修课 - 让学生来自
DocType: Item Group,Item Classification,物品分类
DocType: Asset,Is Existing Asset,是现有资产
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Cancel Material Visits {0} before cancelling this Maintenance Visit,在取消此维护访问之前取消材料访问{0}
DocType: Workstation,Workstation Name,工作站名称
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row #{0}: Status must be {1} for Invoice Discounting {2},行＃{0}：发票贴现的状态必须为{1} {2}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Material Transfer,物料转移
DocType: Delivery Note,% Installed,％已安装
DocType: Agriculture Task,Agriculture Task,农业任务
DocType: Dosage Form,Dosage Form,剂型
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Select the program first,首先选择程序
DocType: Project,Expected Start Date,预计开始日期
DocType: Share Transfer,Share Transfer,分享转移
apps/erpnext/erpnext/config/hr.py,Leave Management,离开管理层
DocType: Loan Application,Total Payable Interest,应付利息总额
DocType: Employee,Current Address,目前的地址
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot {0} {1} {2} without any negative outstanding invoice,没有任何负面未结发票，{0} {1} {2}不能
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Transaction not allowed against stopped Work Order {0},不允许交易停止工作订单{0}
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to ledger.,具有现有交易的仓库无法转换为分类帐。
DocType: Payroll Entry,Deduct Tax For Unsubmitted Tax Exemption Proof,未提交免税证明的退税
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date updated,清关日期已更新
DocType: Delivery Trip,Delivery Stops,交货停止
DocType: Setup Progress,Setup Progress,设置进度
,Ordered Items To Be Billed,有序项目需要付费
DocType: Taxable Salary Slab,To Amount,到金额
DocType: Purchase Invoice,Is Return (Debit Note),是退货（借记通知单）
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Customer &gt; Customer Group &gt; Territory,客户&gt;客户组&gt;地区
apps/erpnext/erpnext/config/desktop.py,Getting Started,入门
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge,合并
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,保存会计年度后，无法更改会计年度开始日期和会计年度结束日期。
DocType: Production Plan,Get Material Request,获取物料申请
DocType: C-Form Invoice Detail,Invoice No,发票号码
DocType: Pricing Rule,Max Qty,最大数量
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,Row {0}: Allocated amount {1} must be less than or equals to Payment Entry amount {2},行{0}：分配的金额{1}必须小于或等于付款条目金额{2}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Piecework,计件工作
DocType: Sales Invoice Item,Drop Ship,掉落船
DocType: Hub User,Hub User,中心用户
DocType: Lab Test Template,No Result,没有结果
DocType: Bank Statement Transaction Entry,Match Transaction to Invoices,将交易与发票进行匹配
DocType: Sales Invoice,Commission,佣金
DocType: Sales Invoice Item,Sales Order Item,销售订单项目
DocType: Maintenance Schedule Detail,Actual Date,实际日期
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance start date can not be before delivery date for Serial No {0},维护开始日期不能在序列号{0}的交货日期之前
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Exchange Rate is mandatory,行{0}：汇率是强制性的
DocType: Purchase Invoice,Select Supplier Address,选择供应商地址
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Available quantity is {0}, you need {1}",可用数量为{0}，您需要{1}
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.py,Please enter API Consumer Secret,请输入API Consumer Secret
DocType: Program Enrollment Fee,Program Enrollment Fee,计划注册费
DocType: Employee Checkin,Shift Actual End,转移实际结束
DocType: Serial No,Warranty Expiry Date,保修到期日
DocType: Hotel Room Pricing,Hotel Room Pricing,酒店房间定价
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Outward taxable supplies(other than zero rated, nil rated and exempted",外向应税供应品（零税率，零税率和豁免除外）
DocType: Issue,Resolution By,分辨率
DocType: Loyalty Program,Customer Territory,客户地区
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication,最后的沟通
DocType: Timesheet,Total Billed Hours,总开工时间
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Current invoice {0} is missing,缺少当前发票{0}
DocType: Healthcare Settings,Patient Registration,患者登记
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice No exists in Purchase Invoice {0},采购发票{0}中不存在供应商发票
DocType: Service Day,Workday,劳动日
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,No Items added to cart,没有商品添加到购物车
DocType: Target Detail,Target Qty,目标数量
apps/erpnext/erpnext/stock/doctype/item/item.py,"To merge, following properties must be same for both items",要合并，两个项的以下属性必须相同
DocType: Drug Prescription,Drug Prescription,药物处方
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Buildings,房屋
DocType: Student Applicant,Application Date,申请日期
DocType: Assessment Result,Result,结果
DocType: Leave Block List,Leave Block List Allowed,保留阻止列表允许
DocType: Purchase Order Item,Blanket Order,总订单
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance for employee {0} is already marked,已标记员工{0}的出勤率
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.py,Assessment Result record {0} already exists.,评估结果记录{0}已存在。
DocType: Purchase Invoice,Rounding Adjustment,舍入调整
DocType: Quality Review Table,Quality Review Table,质量审查表
DocType: Member,Membership Expiry Date,会员到期日
DocType: Asset Finance Book,Expected Value After Useful Life,实用生活后的预期价值
DocType: GSTR 3B Report,November,十一月
DocType: Loan Application,Rate of Interest,利率
DocType: Bank Statement Transaction Payment Item,Bank Statement Transaction Payment Item,银行对账单交易付款项目
DocType: Restaurant Reservation,Waitlisted,轮候
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,You need to enable Shopping Cart,您需要启用购物车
DocType: HR Settings,Leave Status Notification Template,离开状态通知模板
DocType: Salary Slip,Leave Without Pay,停薪留职
DocType: Clinical Procedure Item,Actual Qty (at source/target),实际数量（来源/目标）
DocType: Purchase Invoice,Tax ID,税号
apps/erpnext/erpnext/templates/pages/cart.html,See past orders,查看过去的订单
DocType: Stock Reconciliation Item,Current Qty,目前的数量
apps/erpnext/erpnext/buying/utils.py,UOM Conversion factor is required in row {0},行{0}中需要UOM转换因子
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges",税务明细表从项目主数据中获取为字符串并存储在此字段中。用于税收和收费
DocType: Appraisal Goal,Key Responsibility Area,主要责任区
DocType: Purchase Receipt Item,Sample Quantity,样品数量
DocType: Journal Entry Account,Expense Claim,费用索赔
apps/erpnext/erpnext/public/js/account_tree_grid.js,Opening Date and Closing Date should be within same Fiscal Year,开业日期和结算日期应在同一会计年度内
DocType: Soil Texture,Silt Composition (%),淤泥成分（％）
DocType: Tax Withholding Rate,Tax Withholding Rate,税收预扣税率
DocType: Restaurant,Default Tax Template,默认税模板
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Transfer Asset,转移资产
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp/Lead %,Opp / Lead％
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please cancel Purchase Invoice {0} first,请先取消购买发票{0}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Complete Job,完成工作
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Select Possible Supplier,选择可能的供应商
DocType: POS Profile,Customer Groups,客户群
DocType: Hub Tracked Item,Hub Category,枢纽类别
apps/erpnext/erpnext/utilities/activation.py,"Quotations are proposals, bids you have sent to your customers",报价是提案，您已发送给客户的出价
DocType: Quality Inspection Reading,Reading 5,阅读5
DocType: Shopping Cart Settings,Display Settings,显示设置
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please set Number of Depreciations Booked,请设置预订的折旧数
DocType: Shift Type,Consequence after,之后的后果
apps/erpnext/erpnext/templates/pages/help.html,What do you need help with?,你有什么需要帮助的？
DocType: Journal Entry,Printing Settings,打印设置
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Banking,银行业
DocType: Purchase Invoice Advance,Purchase Invoice Advance,购买发票预付款
DocType: Student Applicant,EDU-APP-.YYYY.-,EDU-APP-.YYYY.-
DocType: Purchase Invoice Item,PR Detail,公关细节
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Billing Address is same as Shipping Address,帐单地址与送货地址相同
DocType: Account,Cash,现金
DocType: Employee,Leave Policy,离开政策
DocType: Shift Type,Consequence,后果
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Address,学生地址
DocType: GST Account,CESS Account,CESS帐户
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center is required for 'Profit and Loss' account {2}. Please set up a default Cost Center for the Company.,{0} {1}：“损益”帐户{2}需要成本中心。请为公司设置默认成本中心。
apps/erpnext/erpnext/accounts/doctype/account/account.py,"While creating account for child Company {0}, parent account {1} not found. Please create the parent account in corresponding COA",在为子公司{0}创建帐户时，找不到父帐户{1}。请在相应的COA中创建父帐户
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.js,General Ledger,总帐
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Reminder to update GSTIN Sent,提醒更新GSTIN已发送
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Select Days,选择天数
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact By cannot be same as the Lead Email Address,下一个联系方式不能与潜在客户电子邮件地址相同
DocType: Packing Slip,To Package No.,到包装号
DocType: Course,Course Name,课程名
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial no is required for the asset {0},资产{0}需要序列号
DocType: Asset,Maintenance,保养
DocType: Selling Settings,Validate Selling Price for Item against Purchase Rate or Valuation Rate,根据购买率或估价率验证物品的销售价格
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,The following Work Orders were created:,创建了以下工作订单：
DocType: Delivery Trip,MAT-DT-.YYYY.-,MAT-DT-.YYYY.-
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,IFSC Code,IFSC准则
DocType: Bank Statement Transaction Payment Item,Mode of Payment,付款方式
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,折扣金额后的税额
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Get Suppliers By,获得供应商
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}",行{0}：要设置{1}周期性，from和date之间的差异必须大于或等于{2}
DocType: Purchase Invoice Item,Valuation Rate,估价率
DocType: Shopping Cart Settings,Default settings for Shopping Cart,购物车的默认设置
DocType: Quiz,Score out of 100,得分100分
DocType: Manufacturing Settings,Capacity Planning,容量规划
apps/erpnext/erpnext/utilities/user_progress.py,Go to Instructors,去教练
DocType: Activity Cost,Projects,项目
DocType: Item Barcode,Barcode Type,条形码类型
DocType: Employee Incentive,Incentive Amount,奖励金额
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js,"To set this Fiscal Year as Default, click on 'Set as Default'",要将此会计年度设置为默认值，请单击“设为默认值”
DocType: C-Form,II,II
DocType: Cashier Closing,From Time,从时间
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant Details Report,变体详细信息报告
,BOM Explorer,BOM Explorer
DocType: Currency Exchange,For Buying,购买
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Slots for {0} are not added to the schedule,{0}的插槽未添加到计划中
DocType: Target Detail,Target Distribution,目标分布
DocType: Staffing Plan,Staffing Plan Details,人员配置计划详情
apps/erpnext/erpnext/controllers/accounts_controller.py,Account {0} is invalid. Account Currency must be {1},帐户{0}无效。帐户货币必须为{1}
DocType: Pricing Rule,Rule Description,规则说明
DocType: Delivery Trip,Total Estimated Distance,总估计距离
DocType: Opportunity Lost Reason,Lost Reason,失去理智
DocType: Depreciation Schedule,Make Depreciation Entry,进行折旧输入
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Serial nos {0} does not belongs to the location {1},序列号{0}不属于{1}位置
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,允许设置冻结帐户和编辑冻结条目的角色
DocType: Employee,Health Concerns,健康问题
DocType: Company,Company Info,公司信息
DocType: Activity Cost,Activity Cost,活动成本
DocType: Journal Entry,Payment Order,付款单
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Pricing,价钱
,Item Delivery Date,物品交货日期
DocType: Quality Goal,January-April-July-October,1至4月，7- 10月
DocType: Purchase Order Item,Warehouse and Reference,仓库和参考
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be converted to ledger,具有子节点的帐户无法转换为分类帐
DocType: Soil Texture,Clay Composition (%),粘土成分（％）
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,成品物料的BOM编号
DocType: Journal Entry,User Remark,用户备注
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Your order is out for delivery!,您的订单已发货！
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"Payment Type must be one of Receive, Pay and Internal Transfer",付款类型必须是收款，付款和内部转账之一
DocType: HR Settings,Payroll Settings,工资核算设置
DocType: GST HSN Code,GST HSN Code,GST HSN代码
DocType: Period Closing Voucher,Period Closing Voucher,期间结算凭证
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Name,Guardian2名字
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Expense Account,请输入费用帐户
DocType: Issue,Resolution By Variance,按方差分辨率
DocType: Employee,Resignation Letter Date,辞职信日期
DocType: Soil Texture,Sandy Clay,桑迪克莱
DocType: Upload Attendance,Attendance To Date,出席日期
DocType: Invoice Discounting,Loan Start Date,贷款开始日期
DocType: Workstation,Consumable Cost,消耗性成本
DocType: Leave Type,Encashment,兑现
DocType: Employee Tax Exemption Declaration,Income From Other Sources,其他来源的收入
DocType: Crop,Produced Items,生产的物品
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Approval Status must be 'Approved' or 'Rejected',审批状态必须为“已批准”或“已拒绝”
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,View Now,现在查看
DocType: Item Price,Valid Upto,有效期至
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Reference Doctype must be one of {0},参考文档类型必须是{0}之一
DocType: Employee Checkin,Skip Auto Attendance,跳过自动出勤
DocType: Payment Request,Transaction Currency,交易货币
DocType: Loan,Repayment Schedule,还款时间表
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Sample Retention Stock Entry,创建样本保留库存条目
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Open,设为开放
DocType: Job Card,Requested Qty,请求数量
DocType: POS Profile,Apply Discount On,申请折扣
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sub contracting,保留用于分包合同
apps/erpnext/erpnext/stock/doctype/item/item.py,Item variant {0} exists with same attributes,项变体{0}具有相同的属性
DocType: Member,Membership Type,会员类型
DocType: Student Leave Application,Will show the student as Present in Student Monthly Attendance Report,将在学生每月出勤报告中显示该学生
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.js,Minimum Lead Age (Days),最短领导年龄（天）
DocType: Shopify Settings,Delivery Note Series,送货单系列
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Academic Year,必修课 - 学年
DocType: Vehicle Log,Fuel Price,燃料价格
DocType: Travel Itinerary,Mode of Travel,旅行方式
DocType: Special Test Items,Special Test Items,特殊测试项目
DocType: Purchase Invoice,Edit Posting Date and Time,编辑过帐日期和时间
DocType: Sales Order,Not Billed,没有收费
DocType: Employee Transfer,Employee Transfer Detail,员工转移明细
DocType: Project,Task Completion,任务完成
DocType: Shopify Webhook Detail,Webhook ID,Webhook ID
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Travel Expenses,旅行费用
apps/erpnext/erpnext/hr/utils.py,Future dates not allowed,未来的日期不允许
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Varaiance ,Varaiance
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the Mode of Payment in Payment Schedule,行{0}：请在付款时间表中设置付款方式
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Term: ,学术期限：
DocType: Quality Feedback Parameter,Quality Feedback Parameter,质量反馈参数
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select Apply Discount On,请选择应用折扣
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Row # {0}: ,行＃{0}：
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.py,Total Payments,总付款
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please enter Account for Change Amount,请输入更改金额的帐户
DocType: Tax Withholding Account,Tax Withholding Account,预扣税账户
DocType: Account,Stock Received But Not Billed,收到但没有收费的股票
apps/erpnext/erpnext/accounts/doctype/account/account.py,Please add the account to root level Company - %s,请将帐户添加到根级别公司 - ％s
DocType: Sample Collection,Collected By,收集
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,在创建自动材料申请时通过电子邮件通知
DocType: Asset Repair,Downtime,停机
DocType: Cost Center,Cost Center Number,成本中心编号
DocType: Driver,Applicable for external driver,适用于外部驱动器
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Start on,开始
DocType: Sales Invoice,Payment Due Date,付款截止日期
DocType: Item,"If this item has variants, then it cannot be selected in sales orders etc.",如果此项目有变体，则无法在销售订单等中选择。
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,Following course schedules were created,以下课程安排已创建
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Timesheet created:,时间表创建：
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open BOM {0},打开BOM {0}
apps/erpnext/erpnext/stock/doctype/material_request/material_request_list.js,Transfered,转移
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Credit To account must be a Payable account,Credit To帐户必须是应付帐款
DocType: Item,Item Attribute,物品属性
apps/erpnext/erpnext/config/quality_management.py,Goal and Procedure,目标和程序
DocType: Asset,Frequency of Depreciation (Months),折旧频率（月）
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Real Estate,房地产
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Parents Teacher Meeting Attendance,家长老师会议出席
DocType: Employee Grade,Employee Grade,员工等级
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,"Total {0} for all items is zero, may be you should change 'Distribute Charges Based On'",所有项目的总{0}为零，可能您应该更改&#39;基于分配费用&#39;
DocType: Sales Invoice Timesheet,Time Sheet,时间表
DocType: Hotel Room Reservation,Late Checkin,延迟入住
DocType: Project,Costing and Billing,成本计算和计费
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Total Outgoing,总出局人数
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,A Default Service Level Agreement already exists.,已存在默认服务级别协议。
DocType: Packing Slip,If more than one package of the same type (for print),如果有多个相同类型的包装（用于打印）
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Please select Company and Posting Date to getting entries,请选择公司和过账日期以获取条目
DocType: Healthcare Practitioner,Default Currency,默认货币
DocType: Sales Invoice,Packing List,打包清单
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Secretary,秘书
DocType: Travel Itinerary,Gluten Free,不含麸质
DocType: Hub Tracked Item,Hub Node,集线器节点
apps/erpnext/erpnext/projects/report/billing_summary.py,Employee ID,员工ID
DocType: Salary Structure Assignment,Salary Structure Assignment,薪酬结构分配
DocType: POS Closing Voucher Taxes,POS Closing Voucher Taxes,POS结算凭证税
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,Action Initialised,行动初始化
DocType: POS Profile,Applicable for Users,适用于用户
,Delayed Order Report,延迟订单报告
DocType: Training Event,Exam,考试
apps/erpnext/erpnext/accounts/general_ledger.py,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,找到的总帐分录数不正确。您可能在交易中选择了错误的帐户。
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Sales Pipeline,销售渠道
,Leaderboard,排行榜
DocType: Account,Inter Company Account,公司间账户
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Closed order cannot be cancelled. Unclose to cancel.,已关闭的订单无法取消。无法取消。
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} does not exist,{0} {1}不存在
DocType: Job Opening,Planned number of Positions,计划的职位数量
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Maintenance Status has to be Cancelled or Completed to Submit,维护状态必须取消或完成才能提交
apps/erpnext/erpnext/accounts/page/pos/pos.js,Please select customer,请选择客户
DocType: Account,Round Off,四舍五入
DocType: Pricing Rule,Conditions will be applied on all the selected items combined. ,条件将适用于所有选定项目的组合。
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Configure,配置
DocType: Hotel Room,Capacity,容量
DocType: Employee Checkin,Shift End,转移结束
DocType: Installation Note Item,Installed Qty,已安装数量
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Batch {0} of Item {1} is disabled.,项目{1}的批处理{0}已禁用。
DocType: Hotel Room Reservation,Hotel Reservation User,酒店预订用户
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,Service Level Agreement with Entity Type {0} and Entity {1} already exists.,与实体类型{0}和实体{1}的服务水平协议已存在。
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Item Group not mentioned in item master for item {0},项目主文件中未提及项目组{0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Name error: {0},名称错误：{0}
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Territory is Required in POS Profile,POS配置文件中需要区域
DocType: Purchase Invoice Item,Service End Date,服务结束日期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Quotation,行情
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Exchange Rate must be same as {0} {1} ({2}),汇率必须与{0} {1}（{2}）相同
DocType: Service Level,Holiday List (ignored during SLA calculation),假期列表（在SLA计算期间被忽略）
DocType: Student Admission Program,Student Admission Program,学生入学计划
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: Parent account {1} can not be a ledger,帐户{0}：父帐户{1}不能是分类帐
DocType: Sales Order,% of materials billed against this Sales Order,根据此销售订单收取的材料百分比
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The payment gateway account in plan {0} is different from the payment gateway account in this payment request,计划{0}中的支付网关帐户与此付款请求中的支付网关帐户不同
DocType: Stock Entry Detail,Subcontracted Item,分包物品
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.py,Loan Start Date and Loan Period are mandatory to save the Invoice Discounting,贷款开始日期和贷款期限是保存发票折扣的必要条件
DocType: Healthcare Settings,Default receivable accounts to be used if not set in Patient to book Appointment charges.,如果未在患者中设置预约费用，则使用默认应收帐户。
DocType: Student Attendance Tool,Students HTML,学生HTML
DocType: Student Guardian,Student Guardian,学生卫士
DocType: GoCardless Settings,GoCardless Settings,GoCardless设置
DocType: Delivery Note,Transport Receipt Date,运输收货日期
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Show Opening Entries,显示开场条目
DocType: Vital Signs,Heart Rate / Pulse,心率/脉搏
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,All Assessment Groups,所有评估小组
DocType: Asset,Asset Name,资产名称
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",“To Value”只能有一个出货规则条件为0或空白值
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Optimizing routes.,优化路线。
DocType: Shopify Tax Account,Shopify Tax/Shipping Title,Shopify税/运输标题
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,To date can not be equal or less than from date,迄今为止不能等于或小于日期
apps/erpnext/erpnext/utilities/user_progress.py,You added ,你补充说
DocType: Assessment Result,Total Score,总得分
DocType: Delivery Note,"If you have created a standard template in Sales Taxes and Charges Template, select one and click on the button below.",如果您在销售税和费用模板中创建了标准模板，请选择一个并单击下面的按钮。
DocType: Budget,Cost Center,成本中心
apps/erpnext/erpnext/controllers/selling_controller.py,Total allocated percentage for sales team should be 100,销售团队的总分配百分比应为100
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved \
											to fullfill Sales Order {2}",无法交付项目{1}的序列号{0}，因为它已保留\以满足销售订单{2}
apps/erpnext/erpnext/accounts/utils.py,Payment Entry has been modified after you pulled it. Please pull it again.,付款后，您已经修改了付款条目。请再拉一下。
DocType: Employee,Bio / Cover Letter,生物/求职信
DocType: Stock Ledger Entry,Stock Value Difference,股票价值差异
DocType: Academic Year,Academic Year Name,学年名称
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Bank Accounts,银行账户
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,The Payment Term at row {0} is possibly a duplicate.,第{0}行的付款期限可能是重复的。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Unblock Invoice,取消阻止发票
DocType: Pricing Rule,Percentage,百分比
DocType: Sensitivity Test Items,Sensitivity Test Items,灵敏度测试项目
apps/erpnext/erpnext/config/retail.py,To make Customer based incentive schemes.,制定基于客户的激励计划。
,Purchase Register,购买注册
DocType: Depreciation Schedule,Schedule Date,安排日期
DocType: Packing Slip,Package Weight Details,包装重量详情
DocType: Job Applicant,Job Opening,职位空缺
DocType: Shift Type,Last Known Successful Sync of Employee Checkin. Reset this only if you are sure that all Logs are synced from all the locations. Please don't modify this if you are unsure.,员工签到的最后一次成功同步。仅当您确定从所有位置同步所有日志时才重置此项。如果您不确定，请不要修改此项。
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Actual Cost,实际成本
apps/erpnext/erpnext/controllers/accounts_controller.py,Total advance ({0}) against Order {1} cannot be greater than the Grand Total ({2}),针对订单{1}的总提前量（{0}）不能大于总计（{2}）
apps/erpnext/erpnext/stock/doctype/item/item.py,Item Variants updated,项目变体已更新
DocType: Item,Batch Number Series,批号系列
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Open Projects,打开项目
DocType: Shopify Settings,Import Delivery Notes from Shopify on Shipment,从Shopify出口交货
DocType: QuickBooks Migrator,Token Endpoint,令牌端点
apps/erpnext/erpnext/utilities/user_progress.py,List a few of your suppliers. They could be organizations or individuals.,列出一些供应商。他们可以是组织或个人。
DocType: Amazon MWS Settings,MWS Credentials,MWS凭证
DocType: Shopping Cart Settings,Shopping Cart Settings,购物车设置
DocType: Sales Invoice Item,Enable Deferred Revenue,启用递延收入
apps/erpnext/erpnext/config/help.py,Managing Projects,管理项目
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.js,Message Sent,消息已发送
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Same item has been entered multiple times. {0},已多次输入相同的项目。 {0}
DocType: Pricing Rule,Margin,余量
apps/erpnext/erpnext/accounts/utils.py,{0} '{1}' not in Fiscal Year {2},{0}&#39;{1}&#39;未在会计年度{2}
DocType: Fee Schedule,Fee Structure,费用结构
apps/erpnext/erpnext/public/js/templates/item_quick_entry.html,Variant Attributes,变体属性
DocType: Employee,Confirmation Date,确认日期
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set a default Holiday List for Employee {0} or Company {1},请为员工{0}或公司{1}设置默认假期列表
DocType: Job Applicant Source,Job Applicant Source,求职者来源
DocType: Opening Invoice Creation Tool,Opening Invoice Creation Tool,打开发票创建工具
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} does not exist,帐户{0}不存在
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Ignore Existing Ordered Qty,忽略现有的订购数量
DocType: Material Request Item,Lead Time Date,提前期日期
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Accounts Receivable Summary,应收帐款摘要
DocType: Asset,Available-for-use Date,可供使用的日期
DocType: HR Settings,Employee record is created using selected field. ,使用所选字段创建员工记录。
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"Row #{0}: Reference Document Type must be one of Purchase Order, Purchase Invoice or Journal Entry",行＃{0}：参考凭证类型必须是采购订单，采购发票或日记帐分录之一
DocType: Payment Entry,Type of Payment,付款方式
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Leave the field empty to make purchase orders for all suppliers,将该字段留空以为所有供应商下达采购订单
apps/erpnext/erpnext/stock/utils.py,Item {0} ignored since it is not a stock item,项目{0}被忽略，因为它不是库存项目
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot have Valuation Rate",“客户提供的项目”不具有估价率
DocType: Soil Texture,Clay,粘土
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,"{0} currently has a {1} Supplier Scorecard standing, and Purchase Orders to this supplier should be issued with caution.",{0}目前有{1}供应商记分卡，并且应谨慎发出此供应商的采购订单。
DocType: Item,"If item is a variant of another item then description, image, pricing, taxes etc will be set from the template unless explicitly specified",如果item是另一个项目的变体，则除非明确指定，否则将从模板设置描述，图像，定价，税收等
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Target,总目标
DocType: Location,Longitude,经度
DocType: Accounts Settings,Determine Address Tax Category From,确定地址税类别
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Identifying Decision Makers,确定决策者
DocType: Stock Entry Detail,Reference Purchase Receipt,参考购买收据
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invocies,获取Invocies
DocType: Tally Migration,Is Day Book Data Imported,是否导入了日记簿数据
,Sales Partners Commission,销售伙伴委员会
DocType: Shift Type,Enable Different Consequence for Early Exit,为早期退出启用不同的后果
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Legal,法律
DocType: Loan Application,Required by Date,按日期要求
DocType: Quiz Result,Quiz Result,测验结果
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Close Loan,关闭贷款
DocType: Lead,From Customer,来自客户
DocType: Payment Reconciliation,Minimum Invoice Amount,最低发票金额
apps/erpnext/erpnext/stock/doctype/material_request/material_request_dashboard.py,Related,有关
DocType: Drug Prescription,Description/Strength,说明/力量
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order cannot be raised against a Item Template,无法针对项目模板提出工作订单
DocType: Employee External Work History,Salary,薪水
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Status,设置状态
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward supplies from ISD,ISD的内向供应
,Vehicle Expenses,车辆费用
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set 'Apply Additional Discount On',请设置&#39;应用额外折扣&#39;
DocType: Closed Document,Closed Document,封闭文件
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py,Please select weekly off day,请选择每周休息日
DocType: Leave Type,Applicable After (Working Days),适用后（工作日）
DocType: Timesheet Detail,Hrs,小时
DocType: Supplier Scorecard Criteria,Supplier Scorecard Criteria,供应商记分卡标准
DocType: Amazon MWS Settings,FR,FR
DocType: Quality Feedback Template Parameter,Quality Feedback Template Parameter,质量反馈模板参数
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date of Joining must be greater than Date of Birth,加入日期必须大于出生日期
DocType: Bank Statement Transaction Invoice Item,Invoice Date,发票日期
DocType: Healthcare Settings,Create Lab Test(s) on Sales Invoice Submit,在销售发票上创建实验室测试提交
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"No active BOM found for item {0}. Delivery by \
						Serial No cannot be ensured",未找到项{0}的有效BOM。交货\串口号无法确保
DocType: Employee Education,Post Graduate,研究生
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} has been entered multiple times,帐户{0}已多次输入
DocType: Employee Benefit Application Detail,Pay Against Benefit Claim,支付福利索赔
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Principal Amount,本金
apps/erpnext/erpnext/setup/doctype/company/company.py,Main,主要
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,Serial No {0} does not exist,序列号{0}不存在
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Program,请选择程序
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Discharge,附表卸货
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Set items shelf life in days, to set expiry based on manufacturing_date plus self life",设置物品保质期（以天为单位），根据manufacturing_date加上自我生命设置到期日
DocType: Bank Reconciliation,Get Payment Entries,获取付款条目
DocType: Amazon MWS Settings,Max Retry Limit,最大重试限制
DocType: Woocommerce Settings,Endpoint,端点
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Cost Center is required in row {0} in Taxes table for type {1},对于类型{1}，Taxes表中的行{0}中需要成本中心
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,Currency Exchange must be applicable for Buying or for Selling.,货币兑换必须适用于购买或出售。
DocType: Cheque Print Template,Cheque Width,检查宽度
DocType: Woocommerce Settings,Secret,秘密
DocType: Restaurant Order Entry,Current Order,当前订单
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Item must be added using 'Get Items from Purchase Receipts' button,必须使用“从采购收据中获取项目”按钮添加项目
,Delay Days,延迟天数
DocType: Company,Default Income Account,默认收入帐户
DocType: Patient Appointment,Get prescribed procedures,获得规定的程序
DocType: Lead,Market Segment,细分市场
apps/erpnext/erpnext/projects/doctype/task/task_list.js,Set as Completed,设为已完成
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Completed Qty can not be greater than 'Qty to Manufacture',完成数量不能超过&#39;制造数量&#39;
apps/erpnext/erpnext/config/support.py,Service Level.,服务水平。
DocType: Stock Entry,MAT-STE-.YYYY.-,MAT-STE-.YYYY.-
DocType: Fiscal Year,Year Start Date,年份开始日期
DocType: Work Order Operation,(Hour Rate / 60) * Actual Operation Time,（小时率/ 60）*实际操作时间
DocType: C-Form,Received Date,收到的日期
apps/erpnext/erpnext/config/accounting.py,Financial / accounting year.,财务/会计年度。
DocType: Pricing Rule,Pricing Rule,定价规则
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Optional Holiday List not set for leave period {0},假期列表未设置为休假期{0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please set User ID field in an Employee record to set Employee Role,请在员工记录中设置用户ID字段以设置员工角色
DocType: Training Event,Training Event,培训活动
DocType: Vital Signs,"Normal resting blood pressure in an adult is approximately 120 mmHg systolic, and 80 mmHg diastolic, abbreviated ""120/80 mmHg""",成人的正常静息血压约为120 mmHg收缩压，80 mmHg舒张压缩，缩写为“120/80 mmHg”
DocType: Payment Reconciliation,System will fetch all the entries if limit value is zero.,如果限制值为零，系统将获取所有条目。
DocType: Item,Copy From Item Group,从项目组复制
,Bank Remittance,银行汇款
apps/erpnext/erpnext/stock/stock_ledger.py,"Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry",未找到项{0}的评估率，这是执行{1} {2}的会计分录所必需的。如果该项目在{1}中作为零估价费率项进行交易，请在{1}项目表中提及。否则，请在项目记录中为项目创建进货库存交易或提及估价率，然后尝试提交/取消此条目
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Half day date should be in between from date and to date,半日期应该在日期和日期之间
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Accrual Journal Entry for salaries from {0} to {1},从{0}到{1}的工资的应计日记帐分录
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Material Receipt,材料收据
DocType: Employee Transfer,Re-allocate Leaves,重新分配叶子
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,To Date should be within the Fiscal Year. Assuming To Date = {0},到目前为止应该在财政年度内。假设到日期= {0}
DocType: Employee Promotion,Employee Promotion Details,员工晋升详情
DocType: Project User,Project Status,项目状态
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction can not be deleted,无法删除现有交易的帐户
apps/erpnext/erpnext/setup/doctype/supplier_group/supplier_group.js,This is a root supplier group and cannot be edited.,这是根供应商组，无法进行编辑。
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_variable/supplier_scorecard_variable.py,Could not find path for ,无法找到路径
DocType: Item Customer Detail,Item Customer Detail,项目客户明细
DocType: Grant Application,Assessment  Mark (Out of 10),评估标记（满分10分）
DocType: Shareholder,ACC-SH-.YYYY.-,ACC-SH-.YYYY.-
DocType: Lab Test,LabTest Approver,LabTest审批人
DocType: Task,Is Milestone,是里程碑
DocType: Program Enrollment Tool,Get Students,得到学生
DocType: Program Enrollment,Self-Driving Vehicle,自动驾驶汽车
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a Fixed Asset Item,项{0}必须是固定资产项
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Rent,办公室租金
DocType: Asset,In Maintenance,在维护中
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Variant properties after stock transaction. You will have to make a new Item to do this.,股票交易后无法更改Variant属性。你必须制作一个新的物品才能做到这一点。
DocType: Purchase Invoice,Unpaid,未付
apps/erpnext/erpnext/accounts/doctype/account/account.js,Update Account Name / Number,更新帐户名称/号码
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Intern,实习生
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show only POS,仅显示POS
DocType: Cashier Closing,Custody,保管
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,From Date cannot be greater than To Date,从日期不能大于到日期
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,As per your assigned Salary Structure you cannot apply for benefits,根据您指定的薪资结构，您无法申请福利
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup defaults,无法设置默认值
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account Number {0} already used in account {1},帐户{1}中已使用的帐号{0}
DocType: HR Settings,Emails salary slip to employee based on preferred email selected in Employee,根据员工中选择的首选电子邮件，将员工的工资发放给员工
DocType: Company,Asset Depreciation Cost Center,资产折旧成本中心
DocType: Lead,Address Desc,地址描述
DocType: Woocommerce Settings,Enable Sync,启用同步
DocType: Student Applicant,Approved,批准
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,From Date should be within the Fiscal Year. Assuming From Date = {0},从日期起应在财政年度内。假设从日期= {0}
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please Set Supplier Group in Buying Settings.,请在购买设置中设置供应商组。
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,{} is an invalid Attendance Status.,{}是无效的出勤状态。
DocType: Opening Invoice Creation Tool Item,Temporary Opening Account,临时开户
DocType: Purchase Invoice,Cash/Bank Account,现金/银行账户
DocType: Quality Meeting Table,Quality Meeting Table,质量会议桌
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,The Term Start Date cannot be earlier than the Year Start Date of the Academic Year to which the term is linked (Academic Year {}). Please correct the dates and try again.,学期开始日期不能早于该学期的学年开始日期（学年{}）。请更正日期，然后重试。
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 1,老化范围1
DocType: Employee Tax Exemption Proof Submission,Tax Exemption Proofs,免税证明
DocType: Purchase Invoice,Price List Currency,价格表货币
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Batch: ,批量：
DocType: Purchase Invoice,Total Advance,总进展
DocType: Employee,Emergency Phone,紧急电话
DocType: Inpatient Occupancy,Check Out,查看
DocType: Invoice Discounting,Loan Period,贷款期限
DocType: Loyalty Program,Conversion Factor,转换因子
DocType: BOM Operation,Operating Cost(Company Currency),营业成本（公司货币）
apps/erpnext/erpnext/config/website.py,"Settings for online shopping cart such as shipping rules, price list etc.",在线购物车的设置，如运输规则，价目表等。
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Edit Publishing Details,编辑发布细节
DocType: Soil Texture,Soil Texture Criteria,土壤质地标准
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Department...,选择部门......
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Currency should be same as Price List Currency: {0},货币应与价格表货币相同：{0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Please specify Serial No for Item {1},行＃{0}：请为项目{1}指定序列号
DocType: Plant Analysis Criteria,Minimum Permissible Value,最低允许值
DocType: Stock Entry,Source Warehouse Address,源仓库地址
DocType: Compensatory Leave Request,Compensatory Leave Request,补偿请假
DocType: Lead,Mobile No.,手机号码。
DocType: GSTR 3B Report,July,七月
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Eligible ITC,符合条件的ITC
DocType: Fertilizer,Density (if liquid),密度（如果是液体）
DocType: Employee,External Work History,外部工作经历
DocType: Quality Inspection,Outgoing,传出
DocType: Email Digest,Add Quote,添加报价
DocType: Inpatient Record,Discharge,排出
DocType: Amazon MWS Settings,MWS Auth Token,MWS Auth Token
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,"Food, Beverage & Tobacco",食品，饮料与烟草
apps/erpnext/erpnext/education/doctype/course/course.js,Course Schedule,课程表
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,项目明智的税收细节
DocType: Shift Type,Attendance will be marked automatically only after this date.,只有在此日期之后才会自动标记出勤率。
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to UIN holders,供应给UIN持有人的供应品
apps/erpnext/erpnext/hooks.py,Request for Quotations,要求报价
apps/erpnext/erpnext/accounts/doctype/account/account.py,Currency can not be changed after making entries using some other currency,使用其他货币进行输入后，货币无法更改
apps/erpnext/erpnext/controllers/accounts_controller.py,Cannot set quantity less than delivered quantity,无法设定数量小于交货数量
apps/erpnext/erpnext/config/accounting.py,Bank/Cash transactions against party or for internal transfer,针对当事人或内部转账的银行/现金交易
apps/erpnext/erpnext/accounts/doctype/sales_taxes_and_charges_template/sales_taxes_and_charges_template.py,Disabled template must not be default template,禁用的模板不能是默认模板
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Absent,马克缺席
DocType: Salary Component,Statistical Component,统计部分
DocType: Bin,Reserved Quantity,预留数量
DocType: Vehicle,Insurance Company,保险公司
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Note: Item {0} entered multiple times,注意：项目{0}已多次输入
DocType: Plant Analysis,Collection Datetime,收集日期时间
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Total Achieved,达到总计
DocType: Course Topic,Topic,话题
DocType: Employee Promotion,Promotion Date,促销日期
DocType: Tax Withholding Category,Account Details,帐户详细资料
DocType: POS Profile,Allow user to edit Rate,允许用户编辑评分
DocType: Healthcare Settings,Result Emailed,结果通过电子邮件发送
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js,View Leads,查看潜在客户
DocType: Fee Validity,Visited yet,访问了
DocType: Purchase Invoice,Terms,条款
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Disbursed Amount cannot be greater than Loan Amount {0},已支付金额不能大于贷款金额{0}
DocType: Share Balance,Issued,发行
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter.js,Schedule Admission,入学时间表
apps/erpnext/erpnext/public/js/templates/contact_list.html,No contacts added yet.,尚未添加任何联系人。
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Create Print Format,创建打印格式
DocType: Asset,Policy number,保单号码
DocType: GL Entry,Against Voucher,反对凭证
DocType: Bank Statement Transaction Payment Item,Payment Reference,付款凭据
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Student Mobile No.,学生手机号码
DocType: Cheque Print Template,Cheque Print Template,检查打印模板
DocType: Loyalty Program Collection,For how much spent = 1 Loyalty Point,花费多少= 1忠诚点
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js,Email Digest: ,电子邮件摘要：
DocType: Accounts Settings,Show Inclusive Tax In Print,在印刷品中显示包含税
DocType: Student Report Generation Tool,Include All Assessment Group,包括所有评估小组
DocType: Employee Benefit Application,Employee Benefits,员工福利
apps/erpnext/erpnext/controllers/status_updater.py,This document is over limit by {0} {1} for item {4}. Are you making another {3} against the same {2}?,对于项目{4}，此文档超出{0} {1}。你是否正在针对同一个{2}制作另一个{3}？
DocType: Leave Type,Is Optional Leave,是可选假
DocType: Cash Flow Mapping,Is Finance Cost,是财务成本
DocType: Vehicle,Doors,门
DocType: Shopify Settings,Customer Settings,客户设置
DocType: Purchase Invoice Item,Include Exploded Items,包括爆炸物品
DocType: Assessment Plan,Evaluate,评估
DocType: Purchase Invoice Item,Is Free Item,是免费物品
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Present,总现在
DocType: Item,Is Item from Hub,来自Hub的物品
apps/erpnext/erpnext/config/quality_management.py,Quality Procedure.,质量程序。
DocType: Share Balance,No of Shares,股份数量
DocType: Quality Action,Preventive,预防
DocType: Support Settings,Forum URL,论坛网址
apps/erpnext/erpnext/config/hr.py,Employee and Attendance,员工和出勤
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Vital Signs,生命体征
DocType: Academic Term,Academics User,学者用户
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Get Items from BOM,从BOM中获取物品
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Serial No is mandatory for Item {0},项目{0}必须使用序列号
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Get Items from Prescriptions,从Prescriptions获取物品
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Cannot cancel {0} {1} because Serial No {2} does not belong to the warehouse {3},无法取消{0} {1}，因为序列号{2}不属于仓库{3}
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,View Orders,查看订单
DocType: Staffing Plan Detail,Number Of Positions,职位数量
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Walk In,步入
DocType: Shopify Settings,Import Sales Invoice from Shopify if Payment is marked,如果付款已标记，则从Shopify导入销售发票
DocType: Certification Application,Certification Status,认证状态
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source Location is required for the asset {0},资产{0}需要源位置
DocType: Employee,Encashment Date,兑现日期
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Completion Date for Completed Asset Maintenance Log,请选择已完成资产维护日志的完成日期
DocType: Quiz,Latest Attempt,最新尝试
DocType: Leave Block List,Allow Users,允许用户
apps/erpnext/erpnext/accounts/doctype/account/account.js,Chart Of Accounts,会计科目表
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,Customer is mandatory if 'Opportunity From' is selected as Customer,如果选择“Opportunity From”作为客户，则客户是强制性的
DocType: Customer,Primary Address,主要地址
DocType: Room,Room Name,房间名称
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Tax Id: ,税号：
DocType: Serial No,Creation Document No,创作文件号
apps/erpnext/erpnext/stock/doctype/item/item.js,Projected,预计
DocType: Purchase Invoice Item,Rejected Qty,被拒绝的数量
DocType: Pricing Rule,Free Item,免费物品
DocType: Salary Component,Is Payable,应付款
DocType: Clinical Procedure Template,Allow Stock Consumption,允许库存消耗
apps/erpnext/erpnext/education/doctype/academic_term/academic_term.py,An academic term with this 'Academic Year' {0} and 'Term Name' {1} already exists. Please modify these entries and try again.,这个“学年”{0}和“学期名称”{1}的学术术语已经存在。请修改这些条目，然后重试。
DocType: Payment Entry,Initiated,启动
apps/erpnext/erpnext/config/selling.py,Blanket Orders from Costumers.,来自客户的毯子订单。
DocType: Sales Order Item,Used for Production Plan,用于生产计划
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 2,老化范围2
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Time logs are required for job card {0},作业卡{0}需要时间日志
DocType: Expense Claim,Vehicle Log,车辆日志
DocType: Grading Scale,Grading Scale Intervals,评分等级间隔
DocType: Accounts Settings,Report Settings,报告设置
apps/erpnext/erpnext/config/retail.py,Point-of-Sale Profile,销售点简介
DocType: Lab Test Groups,Lab Test Groups,实验室测试组
DocType: Stock Settings,Default Valuation Method,默认估值方法
DocType: Item,Safety Stock,安全库存
apps/erpnext/erpnext/accounts/doctype/cheque_print_template/cheque_print_template.js,Print settings updated in respective print format,打印设置以相应的打印格式更新
DocType: Support Settings,Issues,问题
apps/erpnext/erpnext/utilities/user_progress.py,Student Application,学生申请
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Large,特大号
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Remaining Balance,保持平衡
DocType: Lead,Industry,行业
DocType: Payment Entry,Cheque/Reference Date,检查/参考日期
DocType: Asset Movement,Stock Manager,股票经理
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,No items to be received are overdue,没有收到的物品已逾期
apps/erpnext/erpnext/config/non_profit.py,Grant information.,授予信息。
apps/erpnext/erpnext/stock/report/total_stock_summary/total_stock_summary.py,Please set Company filter blank if Group By is 'Company',如果Group By是&#39;Company&#39;，请将Company过滤器设置为空白
apps/erpnext/erpnext/erpnext_integrations/doctype/amazon_mws_settings/amazon_methods.py,Sync has been temporarily disabled because maximum retries have been exceeded,暂时禁用了同步，因为已超出最大重试次数
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled or stopped,{0} {1}被取消或停止
DocType: Asset Maintenance Log,Has Certificate,有证书
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,"Search by item code, serial number, batch no or barcode",按商品代码，序列号，批号或条形码搜索
DocType: Item Price,Multiple Item prices.,多件商品价格。
DocType: Request for Quotation,Request for Quotation,要求报价
DocType: Stock Reconciliation Item,Current Valuation Rate,目前的估值率
DocType: Tax Rule,Shipping County,航运县
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Perception Analysis,感知分析
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item {0} is not active or end of life has been reached,项目{0}未激活或已达到使用寿命
apps/erpnext/erpnext/stock/doctype/item/item.js,Single Variant,单一变体
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Row #{0}: Reference Document Type must be one of Expense Claim or Journal Entry,行＃{0}：参考文档类型必须是费用索赔或日记帐分录之一
DocType: Purchase Invoice,Print Language,打印语言
DocType: Pricing Rule,Pricing Rule Help,定价规则帮助
DocType: Shareholder,Contact List,联系人列表
DocType: Employee,Better Prospects,更好的前景
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',不会为所有项目生成维护计划。请点击“生成时间表”
DocType: Authorization Rule,Itemwise Discount,逐项折扣
DocType: Inpatient Record,Patient Encounter,患者遭遇
apps/erpnext/erpnext/config/non_profit.py,Define various loan types,定义各种贷款类型
DocType: Supplier,Supplier Type,供应商类型
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Collected: {0},收集总数：{0}
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Credit Card,信用卡
DocType: Warranty Claim,SER-WRN-.YYYY.-,SER-WRN-.YYYY.-
DocType: Supplier Scorecard Period,Supplier Scorecard Setup,供应商记分卡设置
DocType: Amazon MWS Settings,Amazon MWS Settings,亚马逊MWS设置
DocType: Program Enrollment,Walking,步行
DocType: SMS Log,Requested Numbers,请求的号码
DocType: Woocommerce Settings,Freight and Forwarding Account,货运和货运账户
apps/erpnext/erpnext/accounts/party.py,Please select a Company,请选择一家公司
apps/erpnext/erpnext/assets/doctype/asset_category/asset_category.py,Row {0}: {1} must be greater than 0,行{0}：{1}必须大于0
apps/erpnext/erpnext/public/js/setup_wizard.js,Upload your letter head and logo. (you can edit them later).,上传你的信头和徽标。 （您可以稍后编辑）。
DocType: Salary Component,Create Separate Payment Entry Against Benefit Claim,针对福利索赔创建单独的付款条目
apps/erpnext/erpnext/utilities/bot.py,Did not find any item called {0},没有找到任何名为{0}的项目
DocType: Student,Nationality,国籍
DocType: BOM Item,Scrap %,废料％
DocType: Item,Inspection Criteria,检验标准
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup company,无法设置公司
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Balance Sheet account,借方到帐户必须是资产负债表帐户
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Number of Order,订单数量
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,"{0} {1} is associated with {2}, but Party Account is {3}",{0} {1}与{2}相关联，但是Party帐户为{3}
DocType: Purchase Invoice,Items,项目
DocType: C-Form,I,一世
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Work-in-Progress Warehouse is required before Submit,提交前需要在制品仓库
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sales Order {0} has reservation for item {1}, you can
		only deliver reserved {1} against {0}. Serial No {2} cannot
		be delivered",销售订单{0}对项目{1}有预留，您只能针对{0}提供保留的{1}。序列号{2}无法发送
DocType: Quality Goal,Monitoring Frequency,监测频率
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Closing Balance,结算余额
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Sold Asset,已售资产成本
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Rejected Qty can not be entered in Purchase Return,行＃{0}：拒绝数量无法输入到采购退货中
DocType: Asset Maintenance Log,ACC-AML-.YYYY.-,ACC-AML-.YYYY.-
DocType: GSTR 3B Report,JSON Output,JSON输出
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Increment cannot be 0,增量不能为0
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be submitted,必须提交BOM {0}
DocType: Amazon MWS Settings,Synch Orders,同步订单
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Disburse Loan,支付贷款
DocType: Item,Delivered by Supplier (Drop Ship),由供应商提供（Drop Ship）
apps/erpnext/erpnext/templates/pages/cart.html,Place Order,下订单
DocType: Employee,Place of Issue,签发地点
DocType: Purchase Receipt,Transporter Details,运输者详情
,Gross and Net Profit Report,毛利润和净利润报告
DocType: Appraisal Template,Appraisal Template Title,评估模板标题
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Work Orders Created: {0},创建的工作订单：{0}
DocType: Packed Item,To Warehouse (Optional),仓库（可选）
DocType: Appointment Type,Physician,医师
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Until,直到
DocType: Leave Policy,Leave Policy Details,请留下政策详情
DocType: HR Settings,<b>Example:</b> SAL-{first_name}-{date_of_birth.year} <br>This will generate a password like SAL-Jane-1972,<b>示例：</b> SAL- {first_name}  -  {date_of_birth.year} <br>这将生成一个像SAL-Jane-1972的密码
apps/erpnext/erpnext/config/accounting.py,To make recurring documents,制作经常性文件
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Ref,PDC / LC参考
DocType: Naming Series,Update Series Number,更新系列号
DocType: Student Group Creation Tool,Leave unchecked if you don't want to consider batch while making course based groups. ,如果您在制作基于课程的小组时不想考虑批处理，请不要选中。
DocType: Assessment Plan Criteria,Maximum Score,最高分数
DocType: Website Filter Field,Website Filter Field,网站过滤字段
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probationary Period,试用期
DocType: Travel Request,Require Full Funding,需要全额资助
DocType: Batch,Manufacturing Date,生产日期
apps/erpnext/erpnext/utilities/activation.py,Group your students in batches,将您的学生分批分组
DocType: Payroll Entry,Bimonthly,半月刊
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Eliminated due to disposal of assets,折旧因资产处置而消失
DocType: Maintenance Visit,Purposes,目的
apps/erpnext/erpnext/hooks.py,Shipments,出货量
DocType: Program Enrollment Tool,New Academic Term,新学期
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Nothing is included in gross,毛不包含任何内容
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse_tree.js,New Warehouse Name,新仓库名称
apps/erpnext/erpnext/selling/report/sales_partner_transaction_summary/sales_partner_transaction_summary.js,Show Return Entries,显示返回条目
DocType: Soil Texture,Soil Type,土壤类型
DocType: Loyalty Program,Multiple Tier Program,多层计划
DocType: BOM Update Tool,The BOM which will be replaced,将被替换的BOM
DocType: Patient,Risk Factors,风险因素
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for sale,保留待售
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Prescriptions,处方
apps/erpnext/erpnext/config/accounting.py,Bills raised to Customers.,提单给客户。
DocType: Training Event,Seminar,研讨会
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Credit ({0}),信用（{0}）
DocType: Payment Request,Subscription Plans,订阅计划
DocType: GSTR 3B Report,March,游行
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split Batch,拆分批次
DocType: School House,House Name,房名
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Outstanding for {0} cannot be less than zero ({1}),{0}的突出不能小于零（{1}）
DocType: Vehicle,Petrol,汽油
DocType: Customer,Bypass credit limit check at Sales Order,绕过销售订单的信用额度检查
DocType: Employee External Work History,Employee External Work History,员工外部工作历史
DocType: HR Settings,Expense Approver Mandatory In Expense Claim,费用审批人必须在费用索赔中
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Optional. Sets company's default currency, if not specified.",可选的。设置公司的默认货币（如果未指定）。
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Monthly Repayment Amount cannot be greater than Loan Amount,每月还款金额不能大于贷款金额
DocType: Leave Allocation,Allocation,分配
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid attachment {0},警告：附件{0}无效
DocType: Vehicle,License Plate,牌照
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Paid Amount cannot be greater than total negative outstanding amount {0},付费金额不能大于总欠款金额{0}
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Stock quantity to start procedure is not available in the warehouse. Do you want to record a Stock Transfer,仓库中没有库存数量启动程序。您想记录股票转让吗？
DocType: Bank Guarantee,Clauses and Conditions,条款和条件
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please select correct account,请选择正确的帐户
DocType: Content Activity,Content Activity,内容活动
DocType: Pricing Rule Detail,Pricing Rule Detail,定价规则细节
DocType: Loan,Monthly Repayment Amount,每月还款金额
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,提供的购买收据项目
DocType: Leave Control Panel,Employment Type (optional),就业类型（可选）
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Invalid {0} for Inter Company Transaction.,Inter Company Transaction无效{0}。
DocType: Asset Movement,From Employee,来自员工
DocType: Attendance,Attendance Date,出勤日期
apps/erpnext/erpnext/setup/doctype/company/company.js,There were errors.,有错误。
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consumer Products,消费产品
DocType: Email Digest,Add/Remove Recipients,添加/删除收件人
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),折扣金额后的税额（公司货币）
DocType: Account,Capital Work in Progress,资本工作正在进行中
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js,Browse BOM,浏览BOM
DocType: Cash Flow Mapping,Select Maximum Of 1,选择最大值为1
DocType: Stock Settings,Batch Identification,批次识别
DocType: Pricing Rule Brand,Pricing Rule Brand,定价规则品牌
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js,This is a root sales person and cannot be edited.,这是root销售人员，无法进行编辑。
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Payroll date can not be less than employee's joining date,工资日期不能低于员工的加入日期
DocType: Fee Validity,Max number of visit,最大访问次数
DocType: Item,Serial Nos and Batches,序列号和批次
DocType: HR Settings,Password Policy,密码政策
apps/erpnext/erpnext/education/doctype/course_scheduling_tool/course_scheduling_tool.js,There were errors creating Course Schedule,创建课程表时出错
DocType: Student Attendance Tool,Batch,批量
DocType: Amazon MWS Settings,ERPNext Integrations,ERPNext集成
DocType: Batch,Source Document Name,来源文件名称
DocType: Restaurant,Invoice Series Prefix,发票系列前缀
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,90-Above,90以上
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Currency for {0} must be {1},{0}的货币必须为{1}
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,From Date must be before To Date,从日期必须在到目前为止
DocType: Delivery Settings,Dispatch Notification Attachment,发货通知附件
apps/erpnext/erpnext/controllers/accounts_controller.py,Total Payment Amount in Payment Schedule must be equal to Grand / Rounded Total,付款时间表中的付款总额必须等于Grand / Rounded Total
,Itemwise Recommended Reorder Level,逐项推荐的重新订购等级
DocType: Course Activity,Video,视频
DocType: Salary Slip Loan,Salary Slip Loan,工资贷款贷款
DocType: Account,Balance Sheet,资产负债表
DocType: Email Digest,Payables,应付帐款
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Created,费用已创建
,Customer Acquisition and Loyalty,客户获取和忠诚度
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Student Group Name is mandatory in row {0},学生组名称在行{0}中是必填项
apps/erpnext/erpnext/config/accounting.py,Exchange Rate Revaluation master.,汇率重估主数据。
apps/erpnext/erpnext/controllers/status_updater.py,Status must be one of {0},状态必须是{0}之一
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"For job card {0}, you can only make the 'Material Transfer for Manufacture' type stock entry",对于作业卡{0}，您只能进行“制造材料转移”类型库存条目
DocType: Asset,Insurance Start Date,保险开始日期
DocType: Target Detail,Target Detail,目标细节
DocType: Packing Slip,Net Weight UOM,净重UOM
DocType: Purchase Invoice Item,Net Amount (Company Currency),净金额（公司货币）
DocType: Bank Statement Transaction Settings Item,Mapped Data,映射数据
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Securities and Deposits,证券和存款
DocType: Promotional Scheme Price Discount,Discount Type,折扣类型
DocType: Hotel Settings,Default Taxes and Charges,默认税和费用
apps/erpnext/erpnext/buying/doctype/supplier/supplier_dashboard.py,This is based on transactions against this Supplier. See timeline below for details,这是基于针对此供应商的交易。请参阅下面的时间表了解详情
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum benefit amount of employee {0} exceeds {1},员工{0}的最高福利金额超过{1}
DocType: Delivery Note Item,Against Sales Invoice,反对销售发票
DocType: Loyalty Point Entry,Purchase Amount,采购量
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Cannot set as Lost as Sales Order is made.,无法将“销售订单”设置为“丢失”。
DocType: Salary Structure,Salary Component for timesheet based payroll.,基于工作表的工资单的薪资组件。
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Suplier Name,上帝的名字
DocType: Manufacturing Settings,Allow multiple Material Consumption against a Work Order,允许针对工作订单的多种物料消耗
apps/erpnext/erpnext/templates/pages/help.html,Open a new ticket,打开一张新票
apps/erpnext/erpnext/public/js/conf.js,Report an Issue,报告问题
DocType: Support Search Source,Link Options,链接选项
DocType: Selling Settings,Sales Update Frequency,销售更新频率
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Pin Code,密码
apps/erpnext/erpnext/config/crm.py,Newsletters,简讯
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,License,执照
DocType: Employee Tax Exemption Declaration,Other Incomes,其他收入
DocType: Job Card,Job Started,工作开始了
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please set recurring after saving,保存后请设置重复
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Atleast one item should be entered with negative quantity in return document,应该在返回文档中输入至少一个带有负数量的项目
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for Hold,保留原因
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.js,HSN/SAC,HSN / SAC
DocType: Homepage,"URL for ""All Products""",“所有产品”的网址
DocType: Lead,Organization Name,机构名称
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from and valid upto fields are mandatory for the cumulative,有效且有效的最多字段对于累积是必需的
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Batch No must be same as {1} {2},行＃{0}：批次号必须与{1} {2}相同
DocType: Employee Checkin,Shift Start,转移开始
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock transactions before {0} are frozen,冻结{0}之前的库存交易
DocType: Driver,Issuing Date,发行日期
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requestor,请求者
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Cost Center {2} does not belong to Company {3},{0} {1}：成本中心{2}不属于公司{3}
DocType: Certification Application,Not Certified,未经认证
DocType: Work Order,Check if material transfer entry is not required,检查是否不需要物料转移条目
DocType: BOM,Raw Material Cost,原材料成本
DocType: Project,Second Email,第二封电邮
DocType: Vehicle Log,Service Detail,服务细节
DocType: Manufacturing Settings,Default 10 mins,默认10分钟
DocType: Subscription Plan,Billing Interval,结算间隔
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Debit must be equal to Total Credit. The difference is {0},总借记必须等于总积分。差异是{0}
DocType: Supplier,Name and Type,名称和类型
DocType: Cheque Print Template,Cheque Height,检查高度
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter relieving date.,请输入解除日期。
DocType: Loyalty Program,Loyalty Program Help,忠诚度计划帮助
DocType: Journal Entry,Inter Company Journal Entry Reference,Inter Company Journal Entry Reference
DocType: Quality Meeting,Agenda,议程
DocType: Quality Action,Corrective,纠正的
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js,Group By,通过...分组
DocType: Bank Account,Address and Contact,地址和联系方式
DocType: Payment Term,Day(s) after invoice date,发票日期之后的日期
DocType: Woocommerce Settings,API consumer secret,API消费者秘密
DocType: Shift Assignment,Shift Assignment,班次分配
DocType: Maintenance Visit,MAT-MVS-.YYYY.-,MAT-MVS-.YYYY.-
DocType: Issue,First Responded On,首先回应
DocType: Work Order Operation,Estimated Time and Cost,估计的时间和成本
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Return / Credit Note,退货/信用票据
apps/erpnext/erpnext/buying/report/quoted_item_comparison/quoted_item_comparison.js,Select Default Supplier,选择默认供应商
DocType: Water Analysis,Appearance,出现
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Voucher #,凭证＃
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,设置帐户类型有助于在事务中选择此帐户。
apps/erpnext/erpnext/config/projects.py,Define Project type.,定义项目类型。
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to install presets,无法安装预设
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Root Company,根公司
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Default Activity Cost exists for Activity Type - {0},活动类型存在默认活动成本 -  {0}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Target Location,目标位置
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Count,订单数量
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Invoice Patient Registration,发票患者登记
DocType: Training Event Employee,Training Event Employee,培训活动员工
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,You will lose records of previously generated invoices. Are you sure you want to restart this subscription?,您将丢失先前生成的发票的记录。您确定要重新启动此订阅吗？
DocType: Cash Flow Mapping Template Details,Cash Flow Mapping Template Details,现金流量映射模板详细信息
apps/erpnext/erpnext/config/hr.py,Recruitment and Training,招聘和培训
DocType: Drug Prescription,Interval UOM,间隔UOM
DocType: Shift Type,Grace Period Settings For Auto Attendance,自动出勤的宽限期设置
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py,From Currency and To Currency cannot be same,从货币到货币不能相同
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Pharmaceuticals,制药
DocType: Employee,HR-EMP-,HR-EMP-
DocType: Service Level,Support Hours,支持时间
apps/erpnext/erpnext/controllers/selling_controller.py,{0} {1} is cancelled or closed,{0} {1}已取消或已关闭
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Customer must be credit,行{0}：对客户的预付必须是信用
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher (Consolidated),按凭证分组（合并）
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Please set default account in Expense Claim Type {0},请在费用索赔类型{0}中设置默认帐户
,BOM Search,BOM搜索
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Dispatch State,派遣国
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Continue Configuration,继续配置
DocType: Item Alternative,Item Alternative,项目替代
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Healthcare Practitioner...,选择医疗从业者......
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Employee {0} already submited an apllication {1} for the payroll period {2},员工{0}已为工资核算期{2}提交了应用程序{1}
apps/erpnext/erpnext/controllers/accounts_controller.py,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,注意：由于未指定“现金或银行账户”，因此不会创建付款输入
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non GST Inward Supplies,非消费税进口供应
DocType: Detected Disease,Disease,疾病
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'To Date' is required,&#39;到日期&#39;是必需的
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Equipments,资本设备
DocType: Bank Statement Settings,Statement Headers,声明标题
DocType: Packing Slip,Gross Weight UOM,毛重UOM
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Please check Multi Currency option to allow accounts with other currency,请选中多币种选项以允许使用其他货币的帐户
DocType: Loan,Repay Fixed Amount per Period,每期偿还固定金额
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.js,Show Variant Attributes,显示变体属性
DocType: GL Entry,Credit Amount,信贷金额
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,Total Amount Credited,总金额
DocType: Support Search Source,Post Route Key List,邮政路线钥匙清单
apps/erpnext/erpnext/accounts/utils.py,{0} {1} not in any active Fiscal Year.,{0} {1}没有任何有效的会计年度。
DocType: Quality Action Resolution,Problem,问题
DocType: Training Event,Conference,会议
DocType: Mode of Payment Account,Mode of Payment Account,付款方式帐户
DocType: Leave Encashment,Encashable days,可以忍受的日子
DocType: Healthcare Settings,Collect Fee for Patient Registration,收集患者登记费
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Disable Template,禁用模板
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Filter Employees By (Optional),过滤员工（可选）
apps/erpnext/erpnext/setup/default_success_action.py,{0} has been submitted successfully,{0}已成功提交
DocType: Workstation,Wages per hour,每小时工资
DocType: Item,Max Discount (%),最大折扣（％）
DocType: Employee,Salary Mode,薪资模式
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,The amount of {0} set in this payment request is different from the calculated amount of all payment plans: {1}. Make sure this is correct before submitting the document.,此付款申请中设置的{0}金额与所有付款计划的计算金额不同：{1}。在提交文档之前，请确保这是正确的。
DocType: Opportunity,Contact Info,联系信息
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Transaction reference no {0} dated {1},交易参考号{0}的日期为{1}
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Currency is required for Price List {0},价格表{0}需要货币
DocType: Program,Program Name,程序名称
apps/erpnext/erpnext/accounts/doctype/account/account.js,This is a root account and cannot be edited.,这是root帐户，无法编辑。
apps/erpnext/erpnext/projects/doctype/task/task.py,'Expected Start Date' can not be greater than 'Expected End Date',“预期开始日期”不能超过“预期结束日期”
DocType: Employee Tax Exemption Declaration Category,Employee Tax Exemption Declaration Category,员工免税声明类别
DocType: Work Order,Item To Manufacture,物品制造
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,In Qty,在数量上
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Is Fixed Asset"" cannot be unchecked, as Asset record exists against the item",无法取消选中“固定资产”，因为资产记录存在于项目中
DocType: Salary Component,Flexible Benefits,灵活的好处
apps/erpnext/erpnext/patches/v11_0/add_default_email_template_for_leave.py,Leave Approval Notification,离开审批通知
DocType: Employee Tax Exemption Proof Submission,Total Actual Amount,实际总金额
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party is mandatory,派对是强制性的
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Check all,选择所有
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If unlimited expiry for the Loyalty Points, keep the Expiry Duration empty or 0.",如果忠诚度积分无限期到期，请将到期时间保持为空或0。
DocType: Attendance Request,Explanation,说明
DocType: Journal Entry Account,Exchange Rate,汇率
DocType: Task,Total Costing Amount (via Time Sheet),总成本金额（通过时间表）
DocType: Tax Rule,Billing County,比林县
DocType: Lead Source,Lead Source,主要来源
DocType: Email Digest,Next email will be sent on:,下一封电子邮件将发送至：
DocType: Batch,Source Document Type,来源文件类型
DocType: Project,Frequency To Collect Progress,频率收集进展
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Head of Marketing and Sales,市场营销主管
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Supplier Quotation {0} created,已创建供应商报价{0}
apps/erpnext/erpnext/setup/doctype/company/company.js,Successfully deleted all transactions related to this company!,成功删除了与该公司相关的所有交易！
DocType: Purchase Taxes and Charges,On Net Total,净总额
DocType: Soil Analysis,Ca/(K+Ca+Mg),的Ca /（K +钙+镁）
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Hold,保持
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You can not enter current voucher in 'Against Journal Entry' column,您无法在“反对日记帐分录”列中输入当前凭证
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js,Please select Company and Party Type first,请先选择公司和派对类型
apps/erpnext/erpnext/utilities/user_progress.py,Go to ,去
,Work Orders in Progress,工作订单正在进行中
DocType: Payment Reconciliation,To Invoice Date,发票日期
DocType: Staffing Plan Detail,Vacancies,职位空缺
DocType: Purchase Order Item,Last Purchase Rate,上次购买率
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Sales Expenses,销售费用
DocType: Healthcare Settings,Default income accounts to be used if not set in Healthcare Practitioner to book Appointment charges.,如果未在医疗从业者中设置预约费用，则使用默认收入帐户。
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Student Group is already updated.,学生组已经更新。
DocType: Driver,Fleet Manager,车队经理
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,You are not authorized to approve leaves on Block Dates,您无权在Block Dates批准离开
,Purchase Invoice Trends,购买发票趋势
DocType: Purchase Taxes and Charges,On Previous Row Amount,在上一行金额
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,No Tax Withholding data found for the current Fiscal Year.,未找到当前财年的预扣税数据。
DocType: Travel Itinerary,Taxi,出租车
DocType: Contract,Inactive,待用
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Actual qty in stock,库存实际数量
DocType: Student Sibling,Student Sibling,学生兄弟姐妹
apps/erpnext/erpnext/utilities/user_progress.py,Go to Rooms,去房间
apps/erpnext/erpnext/utilities/activation.py,Create Employee Records,创建员工记录
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Ordered Qty: Quantity ordered for purchase, but not received.",订购数量：订购但未收到的数量。
DocType: Patient,Patient ID,患者ID
DocType: Employee,Permanent Address Is,永久地址是
DocType: Hotel Room Reservation,Guest Name,客人姓名
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,Accumulated Values in Group Company,集团公司的累计价值
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Resume,恢复
,BOM Stock Calculated,BOM库存计算
DocType: Employee Transfer,New Employee ID,新员工ID
apps/erpnext/erpnext/config/accounting.py,Tax template for selling transactions.,销售交易的税务模板。
DocType: Currency Exchange,To Currency,货币
DocType: Course Schedule,Instructor Name,教练姓名
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Research,研究
DocType: Additional Salary,Employee Name,员工姓名
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance can not be marked for future dates,未来日期的出勤率无法标记
DocType: Supplier Scorecard Scoring Standing,Min Grade,最低等级
DocType: Work Order,Manufactured Qty,制造数量
DocType: Patient,Alcohol Current Use,酒精当前使用
DocType: Leave Application,Total Leave Days,总休假天数
DocType: Asset Repair,Repair Status,维修状态
DocType: Territory,Territory Manager,区域经理
DocType: Lab Test,Sample ID,样品ID
apps/erpnext/erpnext/templates/includes/cart/cart_dropdown.html,Cart is Empty,购物车是空的
apps/erpnext/erpnext/hr/doctype/shift_type/shift_type.js,Attendance has been marked as per employee check-ins,出勤已标记为每个员工签到
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset {0} must be submitted,必须提交资产{0}
,Absent Student Report,缺席学生报告
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Included in Gross Profit,包含在毛利润中
apps/erpnext/erpnext/accounts/page/pos/pos.js,Price List not found or disabled,未找到或禁用价目表
DocType: Travel Request Costing,Funded Amount,资助金额
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has not been submitted so the action cannot be completed,尚未提交{0} {1}，因此无法完成操作
DocType: Subscription,Trial Period End Date,试用期结束日期
DocType: Shift Type,Alternating entries as IN and OUT during the same shift,在同一班次期间交替输入IN和OUT
DocType: BOM Update Tool,The new BOM after replacement,更换后的新BOM
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Supplier &gt; Supplier Type,供应商&gt;供应商类型
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 5,第5项
DocType: Employee,Passport Number,护照号
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Opening,临时开放
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Pricing Rules are further filtered based on quantity.,定价规则将根据数量进一步过滤。
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Appraisal {0} created for Employee {1} in the given date range,在给定日期范围内为员工{1}创建了评估{0}
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Variance,方差
DocType: Sales Order,Partly Delivered,部分交付
DocType: Item,Maintain Stock,维持股票
DocType: Job Card,Started Time,开始时间
apps/erpnext/erpnext/config/hr.py,Shifts and Fleet Management,班次和车队管理
DocType: Item,Average time taken by the supplier to deliver,供应商交付的平均时间
DocType: Stock Entry,Per Transferred,每次转移
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),表示包是此交付的一部分（仅草稿）
DocType: Upload Attendance,Get Template,获取模板
DocType: Agriculture Task,Next Business Day,下一工作日
DocType: Payment Reconciliation,Receivable / Payable Account,应收/应付账款
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,You cannot credit and debit same account at the same time,您无法同时对同一帐户进行贷记和借记
DocType: Agriculture Analysis Criteria,Weather,天气
,Welcome to ERPNext,欢迎来到ERPNext
DocType: Payment Reconciliation,Maximum Invoice Amount,最高发票金额
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim for Vehicle Log {0},车辆日志{0}的费用索赔
DocType: Healthcare Settings,Patient Encounters in valid days,患者在有效日期遇到
,Student Fee Collection,学生费收取
DocType: Selling Settings,Sales Order Required,需要销售订单
DocType: Stock Entry Detail,Serial No / Batch,序列号/批处理
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Statement of Account,账户报表
DocType: Job Offer Term,Offer Term,优惠期限
apps/erpnext/erpnext/setup/doctype/company/company.py,Account {0} does not belong to company: {1},帐户{0}不属于公司：{1}
DocType: Tally Migration,Tally Migration,理货迁移
DocType: Item,"Purchase, Replenishment Details",购买，补货细节
DocType: Purchase Invoice,"Once set, this invoice will be on hold till the set date",设置完成后，此发票将一直保留到设定日期
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock cannot exist for Item {0} since has variants,由于具有变体，因此项目{0}不能存在
DocType: Lab Test Template,Grouped,分组
DocType: GSTR 3B Report,January,一月
DocType: Course Assessment Criteria,Course Assessment Criteria,课程评估标准
DocType: Certification Application,INR,INR
DocType: Job Card Time Log,Completed Qty,完成数量
DocType: Agriculture Task,Start Day,开始日
apps/erpnext/erpnext/config/integrations.py,GoCardless payment gateway settings,GoCardless支付网关设置
DocType: Asset Category Account,Depreciation Expense Account,折旧费用帐户
DocType: Production Plan Sales Order,Production Plan Sales Order,生产计划销售订单
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished product quantity <b>{0}</b> and For Quantity <b>{1}</b> cannot be different,成品数量<b>{0}</b>和数量<b>{1}</b>不能不同
apps/erpnext/erpnext/healthcare/doctype/sample_collection/sample_collection.js,View Lab Tests,查看实验室测试
DocType: Article,Instructor,讲师
DocType: Shopping Cart Settings,Show Public Attachments,显示公共附件
DocType: Item Variant Settings,Fields will be copied over only at time of creation.,字段将仅在创建时复制。
DocType: Delivery Note,Vehicle No,车号
DocType: Lead,CRM-LEAD-.YYYY.-,CRM-LEAD-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry is already created,付款条目已创建
apps/erpnext/erpnext/stock/doctype/item/item.js,Multiple Variants,多个变种
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please select a csv file,请选择一个csv文件
DocType: Serial No,Serial No Details,序列号没有细节
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Source and Target Location cannot be same,来源和目标位置不能相同
apps/erpnext/erpnext/hr/doctype/job_offer/job_offer.js,Show Employee,显示员工
DocType: Payment Entry,Writeoff,注销
DocType: Issue,ISS-.YYYY.-,ISS-.YYYY.-
DocType: Payment Order,Payment Request,付钱请求
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Selected Price List should have buying and selling fields checked.,选定的价格表应该检查买卖场。
apps/erpnext/erpnext/accounts/doctype/account/account.py,Cannot covert to Group because Account Type is selected.,由于选择了帐户类型，因此无法转换为组。
DocType: Company,Exchange Gain / Loss Account,交换收益/损失账户
DocType: Project Template,Project Template,项目模板
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Reorder Qty,重新订购数量
apps/erpnext/erpnext/accounts/report/financial_statements.html,Too many columns. Export the report and print it using a spreadsheet application.,列太多了。导出报告并使用电子表格应用程序进行打印。
DocType: Payroll Entry,Salary Slips Submitted,提交工资单
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,For Supplier,供应商
apps/erpnext/erpnext/accounts/party.py,Accounting entries have already been made in currency {0} for company {1}. Please select a receivable or payable account with currency {0}.,会计分录已经以公司{1}的货币{0}进行。请选择货币为{0}的应收账款或应付账款。
DocType: Asset Value Adjustment,New Asset Value,新资产价值
DocType: Volunteer,Volunteer Type,志愿者类型
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Printed On,打印
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant Leaves,格兰特叶子
DocType: Vehicle,Vehicle Value,车辆价值
,Project Billing Summary,项目开票摘要
DocType: Asset,Receipt,收据
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to get schedule,请单击“生成计划”以获取计划
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,TDS Rate %,TDS率％
DocType: Training Event,Contact Number,联系电话
DocType: POS Closing Voucher,POS Closing Voucher,POS结账凭证
DocType: Quality Inspection Template,Quality Inspection Template Name,质量检验模板名称
apps/erpnext/erpnext/public/js/hub/marketplace.js,Added {0} users,添加了{0}个用户
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Non-Group,转换为非组
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Set as Lost,设为迷失
DocType: Journal Entry Account,Payroll Entry,工资单输入
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0}是强制性的。可能不会为{1}到{2}创建货币兑换记录。
DocType: Delivery Note,Transporter Name,运输商名称
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Planned Qty: Quantity, for which, Work Order has been raised, but is pending to be manufactured.",计划数量：数量，已为此工作订单提出，但尚待制造。
DocType: Item,Has Variants,有变种
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Securities & Commodity Exchanges,证券与商品交易所
DocType: Purchase Invoice Item,Deferred Expense,递延费用
apps/erpnext/erpnext/hr/report/salary_register/salary_register.py,Salary Slip ID,工资单ID
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Membership ID,会员ID
,Sales Register,销售登记
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Please specify a valid 'From Case No.',请指定有效的“案件编号”
DocType: Customer,Primary Address and Contact Detail,主要地址和联系方式
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,This is based on transactions against this Customer. See timeline below for details,这是基于针对该客户的交易。请参阅下面的时间表了解详情
DocType: Hotel Room,Hotels,酒店
DocType: Shipping Rule,Valid for Countries,适用于国家
,Territory Target Variance Based On Item Group,基于项目组的地域目标差异
DocType: Rename Tool,Rename Tool,重命名工具
DocType: Loan Application,Total Payable Amount,应付金额总额
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Add All Suppliers,添加所有供应商
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Row {0}: Currency of the BOM #{1} should be equal to the selected currency {2},行{0}：BOM＃{1}的货币应等于所选货币{2}
DocType: Pricing Rule,Product,产品
apps/erpnext/erpnext/controllers/item_variant.py,Value {0} for Attribute {1} does not exist in the list of valid Item Attribute Values for Item {2},项{2}的有效项属性值列表中不存在属性{1}的值{0}
apps/erpnext/erpnext/utilities/bot.py,{0} units of [{1}](#Form/Item/{1}) found in [{2}](#Form/Warehouse/{2}),在{{2}]（＃Form / Warehouse / {2}）中找到的{0}单位[{1}]（＃表/项/ {1}）
DocType: Vital Signs,Weight (In Kilogram),重量（公斤）
DocType: Department,Leave Approver,离开审批人
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period_dashboard.py,Transactions,交易
DocType: Issue,Resolution Details,分辨率细节
DocType: Sales Invoice Item,Delivery Note Item,送货单项目
DocType: QuickBooks Migrator,Connected to QuickBooks,连接到QuickBooks
DocType: Item,Shelf Life In Days,几天的保质期
apps/erpnext/erpnext/config/buying.py,Key Reports,主要报告
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Possible Supplier,可能的供应商
,Issued Items Against Work Order,发出违反工作订单的物品
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Creating {0} Invoice,创建{0}发票
apps/erpnext/erpnext/education/doctype/instructor/instructor.py,Please setup Instructor Naming System in Education &gt; Education Settings,请在教育&gt;教育设置中设置教师命名系统
DocType: Student,Joining Date,加盟日期
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Requesting Site,请求网站
DocType: Purchase Invoice,Against Expense Account,反对费用账户
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Cannot create a Delivery Trip from Draft documents.,无法从草稿文档创建交货旅行。
apps/erpnext/erpnext/config/crm.py,Lead to Quotation,导致报价
DocType: Program Enrollment,Check this if the Student is residing at the Institute's Hostel.,如果学生居住在学院宿舍，请检查此项。
apps/erpnext/erpnext/education/utils.py,Student {0} - {1} appears Multiple times in row {2} & {3},学生{0}  -  {1}在行{2}和{3}中多次出现
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Creating Payment Entries......,创建付款条目......
DocType: Production Plan,Total Planned Qty,总计划数量
DocType: Subscription Plan,Cost,成本
DocType: Healthcare Service Unit Type,Healthcare Service Unit Type,医疗服务单位类型
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,Please enter atleast 1 invoice in the table,请在表格中输入至少1张发票
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Sales Order {0} is not submitted,未提交销售订单{0}
apps/erpnext/erpnext/education/api.py,Attendance has been marked successfully.,出勤率已成功标记。
apps/erpnext/erpnext/accounts/doctype/tax_category/tax_category_dashboard.py,Pre Sales,售前
apps/erpnext/erpnext/config/projects.py,Project master.,项目大师。
DocType: Daily Work Summary,Daily Work Summary,每日工作总结
DocType: Asset,Partially Depreciated,部分贬值
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,'Days Since Last Order' must be greater than or equal to zero,“自最后订单以来的天数”必须大于或等于零
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,For Default Supplier (optional),对于默认供应商（可选）
DocType: Employee,Leave Encashed?,离开？
DocType: Certified Consultant,Discuss ID,讨论身份证
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set GST Accounts in GST Settings,请在GST设置中设置GST帐户
DocType: Quiz,Latest Highest Score,最新的最高分
DocType: Supplier,Billing Currency,结算货币
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Student Activity,学生活动
apps/erpnext/erpnext/setup/doctype/territory/territory.py,Either target qty or target amount is mandatory,目标数量或目标金额是强制性的
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0}现在是默认的会计年度。请刷新浏览器以使更改生效。
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 2,来自地址2
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Of the supplies shown in 3.1 (a) above, details of inter-State supplies made to unregisterd
	persons, composition taxable persons and UIN holders",上文3.1（a）所示供应品中，向未注册人，构成应税人和UIN持有人提供的国家间供应详情
DocType: Company,Default Inventory Account,默认库存帐户
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.py,The Year End Date cannot be earlier than the Year Start Date. Please correct the dates and try again.,年终日期不能早于年份开始日期。请更正日期，然后重试。
DocType: Target Detail,Target  Amount,目标金额
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Hotel Rooms of type {0} are unavailable on {1},{1}类型的酒店客房不可用{1}
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customer Revenue,新客户收入
DocType: Landed Cost Item,Applicable Charges,适用费用
,Point of Sale,销售点
DocType: Authorization Rule,Approving User  (above authorized value),批准用户（高于授权价值）
DocType: Service Level Agreement,Entity,实体
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} transferred from {2} to {3},从{2}转移到{3}的金额{0} {1}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Customer {0} does not belong to project {1},客户{0}不属于项目{1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Party Name,来自党名
DocType: Asset Maintenance Log,Maintenance Status,维护状态
DocType: Production Plan Item,Pending Qty,等待数量
apps/erpnext/erpnext/controllers/accounts_controller.py, or ,要么
DocType: Sales Order,Not Delivered,没送到
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be allocated since it is leave without pay,保留类型{0}无法分配，因为它是无薪休假
DocType: GL Entry,Debit Amount,借方金额
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Already record exists for the item {0},已经存在项{0}的记录
DocType: Video,Vimeo,Vimeo的
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sub Assemblies,子组件
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.",如果继续存在多个定价规则，则会要求用户手动设置优先级以解决冲突。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',当类别为“估值”或“估值与总计”时，无法扣除
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,BOM and Manufacturing Quantity are required,BOM和制造数量是必需的
apps/erpnext/erpnext/stock/doctype/item/item.py,Item {0} has reached its end of life on {1},项目{0}已达到{1}的生命周期
DocType: Quality Inspection Reading,Reading 6,阅读6
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Company field is required,公司字段是必填项
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Material Consumption is not set in Manufacturing Settings.,“制造设置”中未设置“材料消耗”。
DocType: Assessment Group,Assessment Group Name,评估组名称
DocType: Purchase Invoice Item,Manufacturer Part Number,制造商零件编号
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Payroll Payable,应付薪资
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Row #{0}: {1} can not be negative for item {2},对于项目{2}，行＃{0}：{1}不能为负数
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Balance Qty,平衡数量
DocType: Question,Multiple Correct Answer,多个正确的答案
DocType: Loyalty Program,1 Loyalty Points = How much base currency?,1忠诚度积分=基础货币多少钱？
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Note: There is not enough leave balance for Leave Type {0},注意：休假类型{0}没有足够的休假余额
DocType: Clinical Procedure,Inpatient Record,住院病历
DocType: Sales Invoice Item,Customer's Item Code,客户的物品代码
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure_template/clinical_procedure_template.js,Change Item Code,更改项目代码
DocType: Student Group Instructor,Student Group Instructor,学生组讲师
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Transaction Type,交易类型
apps/erpnext/erpnext/regional/india/utils.py,House rented dates should be atleast 15 days apart,房屋租用日期应至少相隔15天
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,View Form,查看表格
apps/erpnext/erpnext/stock/doctype/item/item.py,Valuation Rate is mandatory if Opening Stock entered,如果输入开盘股，则必须使用估值率
DocType: Employee,Exit Interview Details,退出面试详细信息
DocType: Sales Invoice,Accounting Details,会计细节
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,在取消此销售订单之前，必须取消维护计划{0}
DocType: Driver,HR-DRI-.YYYY.-,HR-DRI-.YYYY.-
DocType: Customer,Mention if non-standard receivable account,提到非标准应收账款
DocType: Lab Test,Prescription,处方
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js,Set as Closed,设为已关闭
DocType: Asset,Opening Accumulated Depreciation,开放累计折旧
DocType: Soil Texture,Sand Composition (%),砂组成（％）
DocType: Production Plan,MFG-PP-.YYYY.-,MFG-PP-.YYYY.-
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Day Book Data,导入日记簿数据
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please set Naming Series for {0} via Setup &gt; Settings &gt; Naming Series,请通过设置&gt;设置&gt;命名系列为{0}设置命名系列
DocType: Asset,Asset Owner Company,资产所有者公司
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Cost center is required to book an expense claim,成本中心需要预订费用索赔
apps/erpnext/erpnext/stock/utils.py,{0} valid serial nos for Item {1},{0}项{1}的有效序列号
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Cannot promote Employee with status Left,无法提升状态为Left的员工
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,Expiry (In Days),到期时间（天）
DocType: Supplier Scorecard Standing,Notify Other,通知其他
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Please select Company,请选择公司
,Item-wise Purchase Register,按项目购买登记册
DocType: Employee,Reason For Leaving,离开的原因
DocType: Salary Slip,Earning & Deduction,收入和扣除
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Employee Referral,员工推荐
,Qty to Order,订购数量
apps/erpnext/erpnext/config/buying.py,Request for purchase.,要求购买。
DocType: Bin,Moving Average Rate,移动平均费率
apps/erpnext/erpnext/config/buying.py,Tax template for buying transactions.,购买交易的税收模板。
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Send SMS,发送短信
apps/erpnext/erpnext/erpnext_integrations/utils.py,Unverified Webhook Data,未经验证的Webhook数据
apps/erpnext/erpnext/config/help.py,Human Resource,人力资源
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} has been modified. Please refresh.,{0} {1}已被修改。请刷新。
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},批次{0}中的库存余额对于仓库{3}处的料品{2}将变为负值{1}
,Asset Depreciation Ledger,资产折旧分类帐
DocType: Location,Tree Details,树细节
DocType: Opening Invoice Creation Tool,Create missing customer or supplier.,创建缺少的客户或供应商。
DocType: Vital Signs,Blood Pressure (diastolic),血压（舒张压）
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per rules 42 & 43 of CGST Rules,根据CGST规则第42和43条
DocType: Item,Show in Website (Variant),在网站上显示（Variant）
apps/erpnext/erpnext/education/doctype/fees/fees.js,Please set the Email ID for the Student to send the Payment Request,请设置学生的电子邮件ID以发送付款申请
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.",为要交付的包裹生成装箱单。用于通知包裹号，包裹内容及其重量。
DocType: SMS Log,No of Requested SMS,没有请求的短信
apps/erpnext/erpnext/config/accounting.py,Banking and Payments,银行和支付
DocType: Instructor,Instructor Log,讲师日志
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Please enter valid email address,请输入有效的电子邮件地址
apps/erpnext/erpnext/config/retail.py,Retail Operations,零售业务
DocType: Company,Phone No,电话号码
,Reqd By Date,按日期要求
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Uncheck all,取消所有
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Place,放置
DocType: Manufacturing Settings,Default Work In Progress Warehouse,默认工作进度仓库
DocType: Fees,Include Payment,包括付款
DocType: Crop,Byproducts,副产品
DocType: Assessment Result,Student,学生
apps/erpnext/erpnext/config/crm.py,Manage Customer Group Tree.,管理客户组树。
DocType: Payment Entry,Payment From / To,付款自/至
apps/erpnext/erpnext/stock/utils.py,Serial number {0} entered more than once,序列号{0}不止一次输入
DocType: Website Item Group,Website Item Group,网站项目组
DocType: Amazon MWS Settings,CA,CA
DocType: Serial No,Under Warranty,在保修期内
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,Invoice Posting Date,发票过帐日期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery Note,送货单
DocType: Education Settings,Attendance Freeze Date,出席冻结日期
DocType: Warranty Claim,Item and Warranty Details,物品和保修详情
DocType: Job Card,Time Logs,时间日志
DocType: Hotel Room,Extra Bed Capacity,加床容量
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,保存工资单后，净支付（单词）将可见。
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Could not solve weighted score function. Make sure the formula is valid.,无法解决加权分数函数。确保公式有效。
DocType: Asset,Asset Owner,资产所有者
apps/erpnext/erpnext/buying/utils.py,Warehouse is mandatory for stock Item {0} in row {1},仓库对于行{1}中的库存料品{0}是强制性的
DocType: Stock Entry,Total Additional Costs,总额外费用
apps/erpnext/erpnext/regional/italy/utils.py,Please set at least one row in the Taxes and Charges Table,请在“税费和收费表”中至少设置一行
DocType: Asset Maintenance Team,Maintenance Team Name,维护团队名称
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Chart of Cost Centers,成本中心图
apps/erpnext/erpnext/utilities/user_progress.py,Go to Users,转到用户
DocType: Pricing Rule,Item Code,项目代码
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,'Opening',“开放”
DocType: Payment Entry,Set Exchange Gain / Loss,设置交换增益/损失
DocType: Accounts Settings,Make Payment via Journal Entry,通过日记帐分录付款
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,User has not applied rule on the invoice {0},用户未在发票{0}上应用规则
apps/erpnext/erpnext/config/accounting.py,Payment Terms based on conditions,付款条款基于条件
DocType: Purchase Order,% Received,已收到％
DocType: Sales Order Item,Work Order Qty,工单数量
DocType: Job Card,WIP Warehouse,WIP仓库
DocType: Payment Request,ACC-PRQ-.YYYY.-,ACC-PRQ-.YYYY.-
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,User ID not set for Employee {0},未为员工{0}设置的用户ID
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} created,用户{0}已创建
DocType: Stock Settings,Item Naming By,项目命名方式
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Ordered,有序
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js,This is a root customer group and cannot be edited.,这是根客户组，无法进行编辑。
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Material Request {0} is cancelled or stopped,材料请求{0}已取消或停止
DocType: Shift Type,Strictly based on Log Type in Employee Checkin,严格基于员工签入中的日志类型
DocType: Purchase Order Item Supplied,Supplied Qty,提供数量
DocType: Cash Flow Mapper,Cash Flow Mapper,现金流量映射器
DocType: Soil Texture,Sand,砂
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee cannot report to himself.,员工无法向自己报告。
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_log/shopify_log.js,Order rescheduled for sync,订单已重新安排同步
apps/erpnext/erpnext/stock/doctype/item/item.py,Default Unit of Measure for Variant '{0}' must be same as in Template '{1}',变体“{0}”的默认度量单位必须与模板“{1}”中的相同
DocType: Blanket Order,Purchasing,购买
DocType: Driver,Cellphone Number,手机号码
DocType: Salary Slip,Gross Pay,总薪酬
DocType: Hotel Room Pricing Package,Hotel Room Pricing Package,酒店客房定价套餐
DocType: Pricing Rule,Is Cumulative,是累积的
apps/erpnext/erpnext/templates/pages/cart.html,Your cart is Empty,您的购物车是空的
,Daily Timesheet Summary,每日时间表摘要
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure_tree.js,New Quality Procedure,新的质量程序
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_dashboard.py,Sub-contracting,分包
DocType: Fee Schedule Program,Total Students,学生总数
apps/erpnext/erpnext/utilities/user_progress_utils.py,Local,本地
DocType: Chapter Member,Leave Reason,离开原因
DocType: Salary Component,Condition and Formula,条件和公式
DocType: Quality Goal,Objectives,目标
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,"Salary already processed for period between {0} and {1}, Leave application period cannot be between this date range.",工资已在{0}和{1}之间处理，请假申请期限不能在此日期范围之间。
DocType: BOM Item,Basic Rate (Company Currency),基本费率（公司货币）
DocType: BOM Scrap Item,BOM Scrap Item,BOM报废项目
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py,Serial #,序列号＃
DocType: Activity Type,Default Billing Rate,默认结算率
DocType: Vital Signs,Coated,涂
DocType: Patient Appointment,More Info,更多信息
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Bill of Materials,材料清单
DocType: Purchase Invoice,Inter Company Invoice Reference,公司间发票参考
DocType: Crop Cycle,Cycle Type,循环类型
DocType: Employee Separation,Exit Interview Summary,退出面试摘要
,Item Variant Details,项目变体详细信息
DocType: Contract,Partially Fulfilled,部分实现
DocType: Journal Entry,ACC-JV-.YYYY.-,ACC-JV-.YYYY.-
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.py,To {0},至{0}
DocType: GST Settings,GST Accounts,GST账户
DocType: C-Form,Total Invoiced Amount,总发票金额
DocType: Manufacturing Settings,Disables creation of time logs against Work Orders. Operations shall not be tracked against Work Order,禁用针对工作订单创建时间日志。不得根据工作订单跟踪操作
apps/erpnext/erpnext/stock/utils.py,Group node warehouse is not allowed to select for transactions,不允许组节点仓库选择事务
DocType: Subscriber,Subscriber Name,订户名称
DocType: Purchase Order,Customer Mobile No,客户手机号
DocType: Bank Guarantee,Receiving,接收
DocType: Account,Is Group,是集团
DocType: Healthcare Practitioner,Contacts and Address,联系方式和地址
DocType: Warehouse,Warehouse Name,仓库名称
apps/erpnext/erpnext/hr/doctype/attendance_request/attendance_request.py,Attendance not submitted for {0} as it is a Holiday.,由于是假日，因此未提交{0}的出席。
DocType: Leave Type,Rounding,四舍五入
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Ineligible ITC,不合格的ITC
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,{0} created,{0}已创建
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,选择存入支票的银行的帐户主管。
DocType: Service Level,Support and Resolution,支持和解决
DocType: Account,Bank,银行
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Receive at Warehouse Entry,在仓库入口处接收
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Send Supplier Emails,发送供应商电子邮件
DocType: Lab Test Groups,Add new line,添加新行
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Duplicate item group found in the item group table,在项目组表中找到重复的项目组
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Annual Salary,年薪
DocType: Supplier Scorecard,Weighting Function,加权函数
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,UOM Conversion factor ({0} -&gt; {1}) not found for item: {2},未找到项目的UOM转换因子（{0}  - &gt; {1}）：{2}
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Error evaluating the criteria formula,评估标准公式时出错
,Lab Test Report,实验室测试报告
DocType: BOM,With Operations,随着运营
apps/erpnext/erpnext/utilities/user_progress.py,People who teach at your organisation,在您的组织任教的人
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Account {0} does not belongs to company {1},帐户{0}不属于公司{1}
DocType: Item,Has Expiry Date,有到期日
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,Sum of Scores of Assessment Criteria needs to be {0}.,评分标准的得分总和必须为{0}。
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Property already added,物业已添加
DocType: Supplier,SUP-.YYYY.-,SUP-.YYYY.-
DocType: Expense Claim Account,Expense Claim Account,费用索赔账户
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments available for Journal Entry,没有可用于日记帐分录的还款
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is inactive student,{0}  -  {1}是非活动学生
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Make Stock Entry,进入股票
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM recursion: {0} cannot be parent or child of {1},BOM递归：{0}不能是{1}的父级或子级
DocType: Employee Onboarding,Activities,活动
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Atleast one warehouse is mandatory,至少有一个仓库是强制性的
,Customer Credit Balance,客户信用余额
DocType: BOM,Operations,操作
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Create Salary Slips,创建工资单
,Monthly Attendance Sheet,每月出勤表
DocType: Vital Signs,Reflexes,反射
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,"Service Item,Type,frequency and expense amount are required",需要服务项目，类型，频率和费用金额
DocType: Supplier Scorecard Period,Variables,变量
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Multiple Loyalty Program found for the Customer. Please select manually.,为客户找到多个忠诚度计划。请手动选择。
DocType: Patient,Medication,药物治疗
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Select Loyalty Program,选择忠诚度计划
DocType: Employee Checkin,Attendance Marked,出勤率明显
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Materials,原料
DocType: Sales Order,Fully Billed,完全开帐单
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.py,Please set Hotel Room Rate on {},请在{}上设置酒店房价
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select only one Priority as Default.,仅选择一个优先级作为默认值。
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please identify/create Account (Ledger) for type - {0},请为类型{0}标识/创建帐户（分类帐）
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Total Credit/ Debit Amount should be same as linked Journal Entry,总信用额/借方金额应与链接的日记帐分录相同
DocType: Purchase Invoice Item,Is Fixed Asset,是固定资产
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Party Name,到党名
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Variant of {0} (Template).,此项目是{0}（模板）的变体。
DocType: Stock Reconciliation,This tool helps you to update or fix the quantity and valuation of stock in the system. It is typically used to synchronise the system values and what actually exists in your warehouses.,此工具可帮助您更新或修复系统中库存的数量和估价。它通常用于同步系统值和仓库中实际存在的值。
DocType: Cashier Closing,Net Amount,净额
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Price List,销售价格表
DocType: Amazon MWS Settings,IT,它
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,{0} must be negative in return document,返回文档中{0}必须为负数
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Please select a valid Date,请选择有效的日期
DocType: Agriculture Task,End Day,结束日
apps/erpnext/erpnext/templates/emails/training_event.html,Please confirm once you have completed your training,完成培训后请确认
apps/erpnext/erpnext/utilities/user_progress.py,Go to Letterheads,去信笺
DocType: Leave Block List Allow,Allow User,允许用户
DocType: Sales Order,% of materials delivered against this Sales Order,根据此销售订单交付的材料百分比
DocType: Purpose of Travel,Purpose of Travel,旅行的目的
DocType: Healthcare Settings,Appointment Confirmation,预约确认
DocType: Shopping Cart Settings,Orders,命令
DocType: HR Settings,Retirement Age,退休年龄
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py,Please setup numbering series for Attendance via Setup &gt; Numbering Series,请通过设置&gt;编号系列设置出勤编号系列
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Projected Qty,预计数量
apps/erpnext/erpnext/regional/__init__.py,Deletion is not permitted for country {0},国家/地区{0}不允许删除
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} is already {2},行＃{0}：资产{1}已经是{2}
DocType: Delivery Note,Installation Status,安装状态
DocType: Item Attribute Value,Attribute Value,属性值
DocType: Sales Invoice,Base Change Amount (Company Currency),基础变动金额（公司货币）
DocType: Leave Allocation,Unused leaves,未使用的叶子
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Finished Item {0} must be entered for Manufacture type entry,必须为制造类型输入输入完成的项目{0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,'Entries' cannot be empty,&#39;参赛作品&#39;不能为空
apps/erpnext/erpnext/utilities/user_progress.py,Go to Courses,去课程
DocType: Fee Schedule,Fee Breakup for each student,每个学生的费用分手
DocType: Item,Will also apply for variants,也适用于变种
DocType: Shopify Settings,Shared secret,共享秘密
DocType: POS Profile,Write Off Cost Center,注销成本中心
DocType: Soil Texture,Silty Clay,粉质粘土
DocType: Loyalty Point Entry Redemption,Redeemed Points,兑换积分
DocType: GoCardless Mandate,Mandate,要求
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test_list.js,Create Multiple,创建多个
DocType: Supplier Scorecard,Scoring Standings,得分榜
DocType: Support Search Source,Result Title Field,结果标题字段
DocType: Leave Allocation,New Leaves Allocated,新叶子分配
DocType: Homepage,Homepage,主页
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Compensatory Off,补偿性的
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool_dashboard.html,Opening Invoices Summary,打开发票摘要
DocType: Vehicle Service,Engine Oil,机油
DocType: Job Applicant,Applicant Name,申请人姓名
DocType: Serial No,Delivery Document No,交货文件号
DocType: Hub Users,Hub Users,中心用户
DocType: Bin,Actual Quantity,实际数量
DocType: Payment Term,Credit Days,信用日
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Id,项目ID
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Electronics,电子产品
apps/erpnext/erpnext/controllers/accounts_controller.py,Due Date is mandatory,到期日是强制性的
DocType: BOM Explosion Item,Qty Consumed Per Unit,每单位消耗的数量
,Completed Work Orders,已完成的工作订单
DocType: Loyalty Program,Help Section,帮助科
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Attendance date can not be less than employee's joining date,出勤日期不能低于员工的加入日期
DocType: BOM,Total Cost(Company Currency),总成本（公司货币）
DocType: Subscription,Net Total,净总值
DocType: Procedure Prescription,Referral,推荐
DocType: Vehicle,Model,模型
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,Please specify from/to range,请指定从/到范围
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Quantity to Manufacture must be greater than 0.,制造数量必须大于0。
DocType: Maintenance Visit,Maintenance Time,维护时间
DocType: Asset,Naming Series,命名系列
DocType: Contract,Contract Terms,合同条款
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Either target qty or target amount is mandatory.,目标数量或目标金额是强制性的。
apps/erpnext/erpnext/accounts/doctype/pricing_rule/utils.py,Invalid {0},无效{0}
DocType: Item,FIFO,FIFO
DocType: Inpatient Record,HLC-INP-.YYYY.-,HLC-INP-.YYYY.-
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation cannot have more than 5 characters,缩写不能超过5个字符
DocType: Employee Benefit Application,Max Benefits (Yearly),最高福利（每年）
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Create Material Request,创建物料申请
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Address Details,主要地址详细信息
DocType: Project Template Task,Duration (Days),持续时间（天）
DocType: Customer Feedback Template Table,Customer Feedback Template Table,客户反馈模板表
DocType: Purchase Invoice Item,Price List Rate,价格清单率
DocType: Budget,Action if Annual Budget Exceeded on PO,如果年度预算超过采购订单的行动
DocType: POS Profile,Campaign,运动
DocType: POS Profile,Accounting,会计
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,在此区域上设置项目分组预算。您还可以通过设置分布来包括季节性。
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Insurance Start date should be less than Insurance End date,保险开始日期应小于保险结束日期
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items in progress,{0}正在进行的项目
DocType: Item,Foreign Trade Details,外贸详情
DocType: Quality Review Table,Yes/No,是/否
DocType: Tally Migration,Is Master Data Imported,是否导入主数据
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,项目税行{0}必须具有税收或收入或费用或可收费类型的帐户
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,{0} is not a valid Batch Number for Item {1},{0}不是项{1}的有效批次编号
apps/erpnext/erpnext/utilities/user_progress.py,Learn More,学到更多
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Credit Note {0} has been created automatically,已自动创建信用票据{0}
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for replacing the BOM. It may take a few minutes.,排队等待更换BOM。可能需要几分钟时间。
DocType: Lab Test,Result Date,结果日期
apps/erpnext/erpnext/config/accounting.py,Currency exchange rate master.,货币汇率高手。
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.js,Latest price updated in all BOMs,所有BOM中的最新价格均已更新
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated Successfully,系列更新成功
DocType: Soil Texture,Clay Loam,粘土壤土
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please select item code,请选择商品代码
apps/erpnext/erpnext/accounts/page/pos/pos.js,Default warehouse is required for selected item,所选项目需要默认仓库
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Serial No {0},没有序列号为{0}的项目
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,Party Type and Party is mandatory for {0} account,对于{0}帐户，必须使用派对类型和派对
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Accountant,会计
apps/erpnext/erpnext/selling/doctype/pos_closing_voucher/pos_closing_voucher.py,POS Closing Voucher alreday exists for {0} between date {1} and {2},在日期{1}和{2}之间存在POS结算凭证alreday {0}
apps/erpnext/erpnext/config/help.py,Navigating,导航
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.py,No outstanding invoices require exchange rate revaluation,没有未结清的发票需要汇率重估
DocType: Authorization Rule,Customer / Item Name,客户/项目名称
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,新序列号不能有仓库。仓库必须通过库存输入或采购收据设置
DocType: Issue,Via Customer Portal,通过客户门户
DocType: Work Order Operation,Planned Start Time,计划开始时间
apps/erpnext/erpnext/controllers/buying_controller.py,{0} {1} is {2},{0} {1}是{2}
DocType: Service Level Priority,Service Level Priority,服务水平优先
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Number of Depreciations Booked cannot be greater than Total Number of Depreciations,预订的折旧数不能大于折旧总数
apps/erpnext/erpnext/accounts/doctype/shareholder/shareholder.js,Share Ledger,分享Ledger
DocType: Journal Entry,Accounts Payable,应付账款
DocType: Job Offer,Select Terms and Conditions,选择条款和条件
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Ends On date cannot be before Next Contact Date.,结束日期不能在下一个联系日期之前。
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Goods are already received against the outward entry {0},已收到针对外向条目{0}的货物
DocType: Employee Tax Exemption Sub Category,Tax Exemption Category,免税类别
DocType: Sales Invoice,Debit To,借记到
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Selling must be checked, if Applicable For is selected as {0}",如果选择适用于{0}，则必须检查销售情况
DocType: Company,Date of Establishment,成立时间
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Leave Type is madatory,离开类型是疯狂的
DocType: Sales Invoice,Sales Taxes and Charges Template,销售税和费用模板
DocType: Purchase Receipt,Return Against Purchase Receipt,退货购买收据
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Student Group: ,学生团体：
DocType: Cheque Print Template,Cheque Size,检查尺寸
,Consolidated Financial Statement,合并财务报表
DocType: Cheque Print Template,Scanned Cheque,扫描检查
DocType: Restaurant Reservation,Reservation End Time,预订结束时间
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,In Value,在价值
DocType: Job Opening,Staffing Plan,人员配备计划
DocType: Manufacturing Settings,Material Transferred for Manufacture,为制造转移的材料
apps/erpnext/erpnext/stock/page/stock_balance/stock_balance.js,Reserved for manufacturing,保留用于制造
DocType: QuickBooks Migrator,Undeposited Funds Account,未存入资金账户
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Material Request No,材料申请号
DocType: Payment Reconciliation,Unreconciled Payment Details,未付款的付款细节
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,RFQs are not allowed for {0} due to a scorecard standing of {1},由于记分卡为{1}，因此{0}不允许RFQ
DocType: Bank Guarantee,Validity in Days,天数有效期
DocType: Price List,Applicable for Countries,适用于国家
DocType: Supplier,Individual,个人
DocType: Clinical Procedure Template,Clinical Procedure Template,临床程序模板
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Net Asset value as on,净资产值如下
DocType: Sales Invoice,Redemption Account,赎回账户
apps/erpnext/erpnext/config/buying.py,Tree of Item Groups.,项目组树。
DocType: BOM,Show Items,显示项目
DocType: Journal Entry,Paid Loan,付款贷款
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to scrap this asset?,你真的想要废弃这笔资产吗？
DocType: Production Plan Sales Order,Sales Order Date,销售订单日期
DocType: Workstation,Operating Costs,运营成本
DocType: Supplier Quotation Item,Lead Time in days,交货时间以天为单位
DocType: Loan,Repay from Salary,从工资中偿还
DocType: Discounted Invoice,Discounted Invoice,特价发票
DocType: Leave Block List Allow,Leave Block List Allow,保留阻止列表允许
DocType: Serial No,AMC Expiry Date,AMC到期日
DocType: Asset,Number of Depreciations Booked,预订的折旧数量
DocType: Student Group Creation Tool,Student Group Creation Tool,学生组创建工具
,Purchase Order Items To Be Billed,要开票的采购订单项目
DocType: Leave Period,Holiday List for Optional Leave,可选假期假期清单
apps/erpnext/erpnext/config/accounting.py,Default settings for accounting transactions.,会计事务的默认设置。
DocType: Purchase Invoice,Scan Barcode,扫描条形码
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Update Cost Center Number,更新成本中心编号
DocType: Purchase Invoice Item,Service Start Date,服务开始日期
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Furnitures and Fixtures,家具和固定装置
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_period/supplier_scorecard_period.py,Criteria weights must add up to 100%,标准权重必须加起来100％
DocType: Authorization Rule,Average Discount,平均折扣
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Discount must be less than 100,折扣必须小于100
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Accumulated Depreciation as on,累计折旧如下
DocType: Supplier Scorecard Scoring Variable,Supplier Scorecard Scoring Variable,供应商记分卡评分变量
DocType: Cheque Print Template,Message to show,要显示的消息
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,No Students in,没有学生
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Temporary Accounts,临时账户
DocType: Invoice Discounting,Bank Charges,银行收费
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods Transferred,货物转移
apps/erpnext/erpnext/public/js/utils/customer_quick_entry.js,Primary Contact Details,主要联系方式
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.",如果未选中，则必须将列表添加到必须应用它的每个部门。
DocType: Item Group,Show this slideshow at the top of the page,在页面顶部显示此幻灯片
apps/erpnext/erpnext/support/doctype/issue/issue.py,{0} parameter is invalid,{0}参数无效
apps/erpnext/erpnext/templates/generators/bom.html,No description given,没有给出描述
DocType: Accounting Period,Closed Documents,封闭文件
DocType: Project,Gross Margin,毛利率
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation Account,汇率重估账户
DocType: Quotation,Quotation To,报价到
DocType: Bank Statement Settings Item,Bank Statement Settings Item,银行对帐单设置项
DocType: Naming Series,Setup Series,设置系列
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.js,Reload Linked Analysis,重新加载链接分析
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Quantity must be less than or equal to {0},数量必须小于或等于{0}
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py,Out Qty,出数量
DocType: Payment Request,Outward,向外
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Sales Orders in the above table,请在上表中输入销售订单
DocType: Invoice Discounting,Bank Charges Account,银行手续费账户
DocType: Journal Entry,Get Outstanding Invoices,获得优秀发票
DocType: Opportunity,Opportunity From,来自的机会
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year_dashboard.py,Target Details,目标细节
DocType: Item,Customer Code,客户代码
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Please enter Item first,请先输入项目
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Website Listing,网站列表
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the format of GSTIN.,GSTIN无效！您输入的输入与GSTIN的格式不匹配。
DocType: Item Reorder,Re-order Qty,重新订购数量
DocType: Asset,Maintenance Required,需要维护
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Name,文件名
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Lead Owner cannot be same as the Lead,潜在客户不能与潜在客户相同
apps/erpnext/erpnext/config/accounting.py,"e.g. Bank, Cash, Credit Card",例如银行，现金，信用卡
DocType: Item,Serial Number Series,序列号系列
apps/erpnext/erpnext/config/accounting.py,Bank Statement Transaction Entry List,银行对账单交易条目清单
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Postal Expenses,邮政费用
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Management,管理
apps/erpnext/erpnext/config/retail.py,To view logs of Loyalty Points assigned to a Customer.,查看分配给客户的忠诚度积分的日志。
DocType: Item,If subcontracted to a vendor,如果转包给供应商
apps/erpnext/erpnext/templates/pages/help.html,Visit the forums,访问论坛
DocType: C-Form,C-Form,C-表
DocType: Asset Maintenance,Maintenance Team,维护团队
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Half day Leave on {1},半天{0}离开{1}
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Combined invoice portion must equal 100%,合并发票部分必须等于100％
DocType: Patient,Occupational Hazards and Environmental Factors,职业危害和环境因素
DocType: Volunteer,Volunteer,志愿者
DocType: Lab Test,Custom Result,自定义结果
DocType: Issue,Opening Date,开幕日期
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,The selected BOMs are not for the same item,所选物料清单不适用于同一物料
DocType: Delivery Note,Delivery To,送货到
DocType: Bank Statement Transaction Settings Item,Bank Data,银行数据
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.js,Scheduled Upto,预定Upto
apps/erpnext/erpnext/config/crm.py,Track Leads by Lead Source.,追踪潜在客户来源。
DocType: Clinical Procedure,Nursing User,护理用户
DocType: Support Settings,Response Key List,响应密钥列表
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Based On,基于的老龄化
apps/erpnext/erpnext/stock/doctype/item/item.js,Balance,平衡
DocType: Purchase Invoice,Warehouse where you are maintaining stock of rejected items,在仓库中维护被拒物品的库存
apps/erpnext/erpnext/public/js/setup_wizard.js,Retail,零售
,Maintenance Schedules,维护计划
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Cannot convert Cost Center to ledger as it has child nodes,无法将成本中心转换为分类帐，因为它具有子节点
apps/erpnext/erpnext/controllers/item_variant.py,Please specify at least one attribute in the Attributes table,请在“属性”表中指定至少一个属性
DocType: Company,Create Chart Of Accounts Based On,创建基于的会计科目表
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Sales Invoice {0} must be cancelled before cancelling this Sales Order,取消此销售订单之前，必须取消销售发票{0}
DocType: Item,Default Purchase Unit of Measure,默认购买计量单位
DocType: Location,Location Details,位置详情
DocType: Stock Entry Detail,Basic Rate (as per Stock UOM),基本费率（按照库存UOM）
DocType: Travel Request Costing,Travel Request Costing,旅行要求成本核算
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Create Sales Invoice,创建销售发票
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.py,From Time cannot be greater than To Time.,从时间不能大于到时间。
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js,To Date cannot be less than From Date,到日期不能小于从日期
apps/erpnext/erpnext/config/crm.py,Manage Territory Tree.,管理区域树。
DocType: GL Entry,Voucher Type,凭证类型
,Serial No Service Contract Expiry,序列号服务合同到期
DocType: Certification Application,Certified,认证
DocType: Purchase Invoice Item,Manufacture,制造
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,{0} items produced,生成{0}个项目
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request for {0},{0}的付款申请
apps/erpnext/erpnext/accounts/report/inactive_sales_items/inactive_sales_items.js,Days Since Last Order,最后订单以来的天数
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Please set default Cash or Bank account in Mode of Payment {0},请在付款方式{0}中设置默认现金或银行帐户
DocType: Student Group,Instructors,教师
apps/erpnext/erpnext/hr/doctype/employee_attendance_tool/employee_attendance_tool.js,Mark Present,马克当前
DocType: Item Customer Detail,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes",为方便客户，这些代码可用于发票和交货单等打印格式
DocType: Amazon MWS Settings,Enable Amazon,启用亚马逊
DocType: Loan,Total Interest Payable,应付利息总额
DocType: Topic,Topic Content,主题内容
DocType: Sales Invoice,Company Address Name,公司地址名称
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry_list.js,Goods In Transit,货物正在运送中
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,You can only redeem max {0} points in this order.,您只能按此顺序兑换最多{0}个积分。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please set account in Warehouse {0},请在仓库{0}中设置帐户
DocType: Quality Action,Resolution,解析度
DocType: Sales Invoice,Loyalty Points Redemption,忠诚积分兑换
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Total Taxable Value,应税总额
DocType: Patient Appointment,Scheduled,计划
DocType: Sales Partner,Partner Type,伙伴类型
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Import of services,进口服务
DocType: Employee Education,School/University,学院/大学
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}: UOM Conversion Factor is mandatory,行{0}：UOM转换因子是必需的
apps/erpnext/erpnext/accounts/report/tds_payable_monthly/tds_payable_monthly.py,Reference No.,参考编号。
DocType: Work Order,Additional Operating Cost,额外运营成本
DocType: Loyalty Program Collection,Collection Factor (=1 LP),收集因子（= 1 LP）
DocType: Serial No,Delivery Document Type,交货凭证类型
DocType: Products Settings,Attributes,属性
DocType: Bank Guarantee,Bank Guarantee,银行担保
DocType: Territory,Territory Name,地区名称
DocType: Item Price,Minimum Qty ,最低数量
DocType: Supplier Scorecard,Per Week,每个星期
DocType: Supplier Scorecard,Warn for new Request for Quotations,警告新的报价请求
DocType: Account,Tax,税
DocType: Delivery Stop,Visited,访问
DocType: Loyalty Program,Auto Opt In (For all customers),自动选择（适用于所有客户）
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,客户货币转换为客户基础货币的比率
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is an Individual or a Proprietorship,适用于公司是个人或独资企业的情况
DocType: Restaurant,Restaurant,餐厅
DocType: Delivery Stop,Address Name,地址名称
DocType: Employee Promotion,Employee Promotion,员工晋升
apps/erpnext/erpnext/hr/doctype/loan/loan.py,No repayments selected for Journal Entry,没有为日记帐分录选择还款
DocType: GST Settings,Set Invoice Value for B2C. B2CL and B2CS calculated based on this invoice value.,为B2C设置发票金额。 B2CL和B2CS根据此发票金额计算。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Cannot deduct when category is for 'Valuation' or 'Vaulation and Total',当类别为“估价”或“Vaulation and Total”时，无法扣除
DocType: Quality Goal,Revised On,修订版
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Please enter Root Type for - {0},请输入 -  {0}的根类型
apps/erpnext/erpnext/healthcare/utils.py,The item referenced by {0} - {1} is already invoiced,{0}  -  {1}引用的项目已开具发票
DocType: Driver,Suspended,暂停
DocType: Asset Category Account,Accumulated Depreciation Account,累计折旧账户
DocType: Journal Entry Account,Credit in Company Currency,公司货币信贷
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Entertainment & Leisure,娱乐休闲
DocType: Email Digest,New Sales Invoice,新销售发票
apps/erpnext/erpnext/accounts/report/gross_and_net_profit_report/gross_and_net_profit_report.py,Net Profit,净利
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py,Another Sales Person {0} exists with the same Employee id,另一个销售人员{0}存在相同的员工ID
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Dr),结束（博士）
DocType: Loyalty Point Entry,Loyalty Program Tier,忠诚度计划层
DocType: Purchase Invoice,Total Taxes and Charges,总税收和收费
DocType: Amazon MWS Settings,JP,J.P
DocType: Work Order Operation,Operation Description,操作说明
DocType: Bank Statement Transaction Entry,Bank Transaction Entries,银行交易条目
DocType: HR Settings,Leave Approval Notification Template,离开审批通知模板
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Type,文档类型
DocType: Email Digest,New Purchase Invoice,新购买发票
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Requested Qty: Quantity requested for purchase, but not ordered.",请求数量：要求购买的数量，但未订购。
DocType: Purchase Invoice,Supplier Name,供应商名称
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},请点击“生成计划”以获取为项目{0}添加的序列号
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Delivered Items,交付物品的成本
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Consumed,消费
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,法律实体/子公司，其中包含属于本组织的单独会计科目表。
DocType: BOM,Show In Website,在网站上显示
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.",然后根据客户，客户组，地区，供应商，供应商类型，活动，销售合作伙伴等过滤掉定价规则。
DocType: Payment Request,Payment Request Type,付款申请类型
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field To Shareholder cannot be blank,字段To Shareholder不能为空
DocType: QuickBooks Migrator,QuickBooks Migrator,QuickBooks Migrator
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,POS Profile is required to use Point-of-Sale,需要POS配置文件才能使用销售点
DocType: Purchase Order,Purchase Order Pricing Rule,采购订单定价规则
DocType: Expense Claim,Expenses,花费
DocType: Employee,Cheque,校验
DocType: Purchase Invoice,Currency and Price List,货币和价格表
DocType: Shopify Settings,Shop URL,商店网址
DocType: Asset Movement,Source Location,来源地点
apps/erpnext/erpnext/accounts/page/pos/pos.js,Enter value must be positive,输入值必须为正数
DocType: Accounts Settings,Allow Cost Center In Entry of Balance Sheet Account,允许成本中心输入资产负债表科目
apps/erpnext/erpnext/education/doctype/course_schedule/course_schedule.js,Attendance,勤
DocType: Training Event,Internet,互联网
DocType: Monthly Distribution,Monthly Distribution Percentages,每月分配百分比
DocType: Delivery Settings,Dispatch Notification Template,派遣通知模板
apps/erpnext/erpnext/templates/print_formats/includes/total.html,Total (Without Tax),总计（不含税）
DocType: Cash Flow Mapping,Cash Flow Mapping,现金流量映射
DocType: Patient Encounter,HLC-ENC-.YYYY.-,HLC-ENC-.YYYY.-
DocType: Cash Flow Mapper,Section Leader,科长
,Budget Variance Report,预算差异报告
DocType: Asset,Gross Purchase Amount,总购买金额
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,Half Day Date is mandatory,半天日是强制性的
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Removed items with no change in quantity or value.,删除了没有数量或价值变化的项目。
DocType: Loan,Applicant Type,申请人类型
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 2,致地址2
DocType: Purchase Receipt,Range,范围
DocType: Budget,BUDGET,预算
DocType: Journal Entry,Depreciation Entry,折旧条目
DocType: Purchase Invoice Item,Price List Rate (Company Currency),价格表价格（公司货币）
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Not Paid and Not Delivered,未支付和未交付
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Sales Invoice {0} created,已创建销售发票{0}
DocType: Quality Review Table,Objective,目的
DocType: Inpatient Record,Admission Scheduled,入学时间表
DocType: Purchase Order Item,To be delivered to customer,交付给客户
DocType: Attendance Request,On Duty,当班
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Variable,变量
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Depreciation Start Date is required,行{0}：需要折旧开始日期
DocType: Options,Option,选项
DocType: Healthcare Settings,Out Patient SMS Alerts,输出患者短信提醒
apps/erpnext/erpnext/setup/doctype/company/company.py,Sales Account,销售帐户
DocType: Weather,Weather Parameter,天气参数
DocType: Leave Control Panel,Allocate,分配
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,维护计划明细
DocType: BOM Update Tool,BOM Update Tool,BOM更新工具
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Notice Period,通知期
,Lead Owner Efficiency,领导所有者效率
DocType: SMS Center,Total Characters,总字符数
DocType: Patient,Alcohol Past Use,酒精过去使用
DocType: Patient,Divorced,离婚
DocType: Sales Invoice,Allocate Advances Automatically (FIFO),自动分配进度（FIFO）
DocType: Leave Type,Is Compensatory,是补偿性的
,Employees working on a holiday,员工在度假
DocType: Healthcare Practitioner,Mobile,移动
apps/erpnext/erpnext/utilities/activation.py,"Timesheets help keep track of time, cost and billing for activites done by your team",时间表有助于跟踪团队完成的活动的时间，成本和计费
DocType: Delivery Stop,Order Information,订单信息
apps/erpnext/erpnext/templates/pages/cart.html,Subtotal,小计
DocType: Invoice Discounting,Invoice Discounting,发票贴现
apps/erpnext/erpnext/regional/italy/utils.py,Nos,号
DocType: Stock Settings,Freeze Stock Entries,冻结库存条目
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py,Item {0} not found,找不到项{0}
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,You have entered duplicate items. Please rectify and try again.,您输入了重复的项目。请纠正并再试一次。
DocType: Purchase Invoice Item,Rate,率
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.py,Saving {0},保存{0}
DocType: SMS Center,Total Message(s),总消息
DocType: Purchase Invoice,Accounting Dimensions,会计维度
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Account,按帐户分组
DocType: Quotation,In Words will be visible once you save the Quotation.,保存报价后，单词将显示。
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.js,Quantity to Produce,生产数量
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Cannot set Rate if amount is greater than billed amount for Item {1}.,行＃{0}：如果金额大于项目{1}的开帐单金额，则无法设置费率。
DocType: Work Order Operation,Actual Start Time,实际开始时间
DocType: Antibiotic,Laboratory User,实验室用户
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Online Auctions,在线拍卖
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Priority {0} has been repeated.,优先级{0}已重复。
DocType: Fee Schedule,Fee Creation Status,费用创建状态
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Softwares,软件
apps/erpnext/erpnext/config/help.py,Sales Order to Payment,销售订单到付款
apps/erpnext/erpnext/healthcare/doctype/healthcare_practitioner/healthcare_practitioner_dashboard.py,This is based on transactions against this Healthcare Practitioner.,这是基于针对此医疗保健从业者的交易。
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Assigning Structures...,分配结构......
apps/erpnext/erpnext/config/manufacturing.py,Details of the operations carried out.,所进行的操作细节。
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Operation Time must be greater than 0 for Operation {0},操作{0}的操作时间必须大于0
apps/erpnext/erpnext/education/doctype/question/question.py,A qustion must have at least one correct options,Qustion必须至少有一个正确的选项
DocType: Shareholder,Folio no.,Folio没有。
DocType: Inpatient Record,A Negative,否定的
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,{0} is mandatory for Item {1},项{1}必须为{0}
,Production Analytics,生产分析
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Set Supplier for item {1},行＃{0}：为项目{1}设置供应商
apps/erpnext/erpnext/healthcare/doctype/patient_encounter/patient_encounter_dashboard.py,Records,记录
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Case No(s) already in use. Try from Case No {0},案例编号已在使用中。从Case No {0}开始尝试
DocType: Chapter Member,Website URL,网址
apps/erpnext/erpnext/accounts/doctype/account/account.py,Report Type is mandatory,报告类型是强制性的
DocType: Vehicle,Policy No,政策号
apps/erpnext/erpnext/hr/report/daily_work_summary_replies/daily_work_summary_replies.py,Replies,回复
DocType: Supplier Scorecard Scoring Variable,Variable Name,变量名
DocType: Rename Tool,Utilities,公用事业
DocType: Job Card,Total Completed Qty,完成总数量
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials to Manufacture,没有带有物料清单的物品
DocType: Purchase Order Item,Blanket Order Rate,一揽子订单率
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,跟踪产品垂直或部门的单独收入和支出。
apps/erpnext/erpnext/stock/doctype/item/item.py,Warning: Invalid SSL certificate on attachment {0},警告：附件{0}上的SSL证书无效
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Opp Count,Opp Count
apps/erpnext/erpnext/education/doctype/instructor/instructor.js,As Examiner,作为考官
DocType: Company,Default Expense Claim Payable Account,默认费用索赔应付帐款
DocType: Additional Salary,HR-ADS-.YY.-.MM.-,HR-ADS-.YY .-。MM.-
apps/erpnext/erpnext/templates/pages/search_help.py,Docs Search,文档搜索
apps/erpnext/erpnext/hr/doctype/payroll_period/payroll_period.py,End Date can not be less than Start Date,结束日期不能小于开始日期
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,No Items with Bill of Materials.,没有物料清单的物品。
apps/erpnext/erpnext/config/support.py,Single unit of an Item.,单个单元的项目。
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Quotations,语录
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Could not generate Secret,无法生成秘密
DocType: Purchase Taxes and Charges,Valuation and Total,估值和总计
apps/erpnext/erpnext/non_profit/doctype/member/member_dashboard.py,Member Activity,会员活动
DocType: Upload Attendance,Import Attendance,导入出勤
DocType: POS Profile,Account for Change Amount,账户变更金额
,Item Price Stock,商品价格股票
DocType: Asset,ACC-ASS-.YYYY.-,ACC-ASS-.YYYY.-
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"Request for Quotation is disabled to access from portal, for more check portal settings.",禁用报价请求以从门户网站访问，以获取更多检查门户网站设置。
DocType: Bank Statement Settings Item,Mapped Header,映射标题
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,"Item Code, warehouse, quantity are required on row",行上需要物品代码，仓库，数量
DocType: Payment Order Reference,Bank Account Details,银行账户明细
DocType: Homepage,Homepage Slideshow,主页幻灯片
DocType: Travel Request,"Partially Sponsored, Require Partial Funding",部分赞助，需要部分资助
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Payment of {0} from {1} to {2},从{1}到{2}的{0}付款
,Serial No Status,序列号无状态
DocType: Donor,Donor,捐赠者
DocType: BOM,Item UOM,物品UOM
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Row {0}: select the workstation against the operation {1},行{0}：根据操作{1}选择工作站
DocType: Stock Settings,Default Return Warehouse,默认退货仓库
apps/erpnext/erpnext/hr/doctype/training_result/training_result.py,{0} must be submitted,必须提交{0}
DocType: Project,Estimated Cost,估计费用
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot/Lead %,报价/领先％
apps/erpnext/erpnext/config/non_profit.py,Member information.,会员信息
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Reverse Journal Entry,反向日记帐分录
apps/erpnext/erpnext/utilities/user_progress.py,Set a sales goal you'd like to achieve for your company.,设定您希望为公司实现的销售目标。
DocType: Lab Test Template,Special,特别
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Subcontract: Raw materials quantity to make subcotracted items.,分包合同的保留数量：制作分项目的原材料数量。
DocType: Patient Encounter,In print,在印刷品中
apps/erpnext/erpnext/accounts/report/financial_statements.py,Could not retrieve information for {0}.,无法检索{0}的信息。
apps/erpnext/erpnext/accounts/party.py,Billing currency must be equal to either default company's currency or party account currency,结算货币必须等于默认公司的货币或方帐户货币
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,Please enter Employee Id of this sales person,请输入此销售人员的员工ID
DocType: Shift Type,Early Exit Consequence after,提前退出后果
apps/erpnext/erpnext/config/accounting.py,Create Opening Sales and Purchase Invoices,创建开仓销售和采购发票
DocType: Disease,Treatment Period,治疗期
apps/erpnext/erpnext/config/settings.py,Setting up Email,设置电子邮件
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Debit Note Amount,借记单金额
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,价格表货币转换为客户基础货币的比率
apps/erpnext/erpnext/hooks.py,Certification,证明
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc",在这里，您可以保持身高，体重，过敏，医疗问题等
DocType: Journal Entry,Print Heading,打印标题
DocType: Grant Application,Withdrawn,撤回
apps/erpnext/erpnext/public/js/utils/party.js,Select company first,首先选择公司
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be across two allocation records,申请期限不能跨越两个分配记录
apps/erpnext/erpnext/templates/pages/order.html,Rate:,率：
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Employee {0} has no maximum benefit amount,员工{0}没有最高福利金额
DocType: Employee Skill Map,Employee Skills,员工技能
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student Name: ,学生姓名：
DocType: SMS Log,Sent On,在发送
DocType: Bank Statement Transaction Invoice Item,Sales Invoice,销售发票
DocType: Education Settings,"For Course based Student Group, the Course will be validated for every Student from the enrolled Courses in Program Enrollment.",对于基于课程的学生组，课程将针对计划注册中注册课程的每位学生进行验证。
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Intra-State Supplies,国内供应
DocType: Employee,Create User Permission,创建用户权限
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Please save the report again to rebuild or update,请再次保存报告以重建或更新
DocType: C-Form Invoice Detail,Territory,领土
DocType: C-Form,Quarter,25美分硬币
DocType: Purchase Invoice,Grand Total (Company Currency),总计（公司货币）
DocType: Prescription Dosage,Prescription Dosage,处方剂量
DocType: Salary Slip,Hour Rate,小时费率
DocType: Location,Latitude,纬度
DocType: Expense Claim Detail,Expense Date,费用日期
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.js,Show Payment Details,显示付款细节
DocType: Company,Default Payable Account,默认应付账款
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to any Warehouse,序列号{0}不属于任何仓库
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Party,按党分组
DocType: Volunteer,Evening,晚间
DocType: Campaign,SAL-CAM-.YYYY.-,SAL-CAM-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Exchange Gain/Loss,交换增益/损失
DocType: Payment Request,Make Sales Invoice,制作销售发票
DocType: Opening Invoice Creation Tool,Create Missing Party,创造失踪党
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,For quantity {0} should not be grater than work order quantity {1},数量{0}不应大于工单数量{1}
DocType: Landed Cost Voucher,Additional Charges,额外费用
DocType: Assessment Result Tool,Assessment Result Tool,评估结果工具
DocType: Journal Entry,Contra Entry,Contra Entry
DocType: Student Applicant,Application Status,申请状态
DocType: Journal Entry,Total Amount in Words,单词总量
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment. ",跟踪销售活动。跟踪活动中的潜在客户，报价单，销售订单等，以衡量投资回报率。
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py,Missing Currency Exchange Rates for {0},缺少{0}的货币汇率
DocType: Pricing Rule Item Group,Pricing Rule Item Group,定价规则项目组
DocType: Quality Inspection Reading,Reading 8,阅读8
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,From Fiscal Year,从财政年度开始
DocType: Tally Migration,Tally Creditors Account,理货债权人账户
DocType: Student Report Generation Tool,Print Section,打印部分
apps/erpnext/erpnext/hr/doctype/department/department.js,This is a root department and cannot be edited.,这是根部门，无法编辑。
,Project Quantity,项目数量
apps/erpnext/erpnext/config/settings.py,Standard contract terms for Sales or Purchase.,销售或购买的标准合同条款。
DocType: Sales Invoice,Customer PO Details,客户PO详细信息
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Patient not found,找不到病人
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Select a Default Priority.,选择默认优先级。
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Remove item if charges is not applicable to that item,如果费用不适用于该项目，请删除项目
apps/erpnext/erpnext/selling/doctype/customer/customer.py,A Customer Group exists with same name please change the Customer name or rename the Customer Group,存在具有相同名称的客户组请更改客户名称或重命名客户组
DocType: Sales Taxes and Charges Template,"Standard tax template that can be applied to all Sales Transactions. This template can contain list of tax heads and also other expense / income heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Is this Tax included in Basic Rate?: If you check this, it means that this tax will not be shown below the item table, but will be included in the Basic Rate in your main item table. This is useful where you want give a flat price (inclusive of all taxes) price to customers.",标准税模板，可应用于所有销售交易。此模板可以包含税务负责人列表以及其他费用/收入负责人，如“运费”，“保险”，“处理”等。####注意您在此定义的税率将是所有**的标准税率项目**。如果**项目**具有不同的费率，则必须将它们添加到**项目**主文件的**项目税**表中。 ####列说明1.计算类型： - 可以是**净总计**（即基本金额的总和）。 -  **上一行总额/金额**（累计税金或费用）。如果选择此选项，则税额将应用为上一行（税表中）金额或总金额的百分比。 -  **实际**（如上所述）。 2.账户负责人：将在其中预订此税的账户分类账3.成本中心：如果税/费是收入（如运费）或费用，则需要根据成本中心进行预订。 4.描述：税收描述（将在发票/报价中打印）。 5.费率：税率。 6.金额：税额。 7.总计：累计到此为止。 8.输入行：如果基于“上一行总计”，您可以选择将作为此计算基础的行号（默认为上一行）。 9.此税是否包含在基本费率中？：如果您选中此项，则表示该税项不会显示在项目表下方，但会包含在主项目表的基本费率中。如果您希望向客户提供固定价格（包括所有税费），这将非常有用。
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,To Date must be greater than From Date,到日期必须大于从日期
DocType: Customer Group,Parent Customer Group,家长客户组
DocType: Shopping Cart Settings,Prices will not be shown if Price List is not set,如果未设置价格清单，价格将不会显示
apps/erpnext/erpnext/config/settings.py,ERPNext Settings,ERP下载设置
apps/erpnext/erpnext/config/manufacturing.py,Time Sheet for manufacturing.,制造时间表。
DocType: Student Language,Student Language,学生语言
apps/erpnext/erpnext/regional/italy/utils.py,Please set the Payment Schedule,请设置付款时间表
DocType: Travel Request,Name of Organizer,组织者姓名
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set Depreciation related Accounts in Asset Category {0} or Company {1},请在资产类别{0}或公司{1}中设置与折旧相关的帐户
apps/erpnext/erpnext/config/accounting.py,Setup cheque dimensions for printing,设置检查打印尺寸
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,"If you have any questions, please get back to us.",如果您有任何疑问，请回复我们。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Receipt {0} is not submitted,未提交采购收据{0}
DocType: Task,Total Expense Claim (via Expense Claim),总费用索赔（通过费用索赔）
DocType: Quality Goal,Quality Goal,质量目标
DocType: Support Settings,Support Portal,支持门户
apps/erpnext/erpnext/projects/doctype/project/project.py,End date of task <b>{0}</b> cannot be less than <b>{1}</b> expected start date <b>{2}</b>,任务<b>{0}的</b>结束日期不能少于<b>{1}</b>预期开始日期<b>{2}</b>
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py,Employee {0} is on Leave on {1},员工{0}正在{1}上休假
apps/erpnext/erpnext/support/doctype/issue/issue.py,This Service Level Agreement is specific to Customer {0},此服务级别协议特定于客户{0}
DocType: Employee,Held On,坚持住
DocType: Healthcare Practitioner,Practitioner Schedules,从业者时间表
DocType: Project Template Task,Begin On (Days),开始（天）
DocType: Production Plan,"If enabled, then system will create the material even if the raw materials are available",如果启用，则即使原材料可用，系统也会创建材料
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Work Order has been {0},工单已{0}
DocType: Inpatient Record,Admission Schedule Date,入学时间表日期
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Value Adjustment,资产价值调整
DocType: Shift Type,Mark attendance based on 'Employee Checkin' for Employees assigned to this shift.,根据分配给此班次的员工的“员工签到”标记出勤率。
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Supplies made to Unregistered Persons,向未登记人员提供的物资
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,All Jobs,所有工作
DocType: Appointment Type,Appointment Type,预约类型
DocType: Manufacturing Settings,Allow Overtime,允许加班
DocType: Sales Invoice Item,Available Qty at Warehouse,仓库的可用数量
DocType: Sales Invoice Item,Sales Invoice Item,销售发票项目
DocType: Additional Salary,HR,HR
DocType: Student Report Generation Tool,Assessment Terms,评估条款
apps/erpnext/erpnext/controllers/item_variant.py,Increment for Attribute {0} cannot be 0,属性{0}的增量不能为0
DocType: Leave Control Panel,Carry Forward,带着向前
DocType: Dependent Task,Dependent Task,依赖任务
DocType: Allowed To Transact With,Allowed To Transact With,允许与之交易
apps/erpnext/erpnext/public/js/hub/marketplace.js,Become a Seller,成为卖家
DocType: Bank Reconciliation,Bank Reconciliation,银行对账
apps/erpnext/erpnext/config/projects.py,Types of activities for Time Logs,时间日志的活动类型
DocType: POS Closing Voucher Invoices,POS Closing Voucher Invoices,POS结账凭证发票
DocType: Inpatient Record,AB Negative,AB否定
DocType: Company,Budget Detail,预算明细
DocType: Vital Signs,Normal reference range for an adult is 16–20 breaths/minute (RCP 2012),成人的正常参考范围是16-20次呼吸/分钟（RCP 2012）
DocType: Production Plan,Sales Orders,销售订单
apps/erpnext/erpnext/accounts/doctype/exchange_rate_revaluation/exchange_rate_revaluation.js,Create Journal Entry,创建日记帐分录
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Secured Loans,抵押贷款
DocType: Share Transfer,To Shareholder,对股东
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Maintenance Schedule,维护计划
DocType: Chapter,"chapters/chapter_name
leave blank automatically set after saving chapter.",保存章节后，章节/ chapter_name会自动设置为空白。
DocType: Shopping Cart Settings,Payment Success Url,付款成功网址
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Delivered Amount,交付金额
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Min Amt can not be greater than Max Amt,Min Amt不能大于Max Amt
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Salary Structure not found for employee {0} and date {1},未找到员工{0}和日期{1}的薪资结构
DocType: Healthcare Settings,Invoice Appointments Automatically,自动发票约会
apps/erpnext/erpnext/education/doctype/assessment_result/assessment_result.js,Please fill in all the details to generate Assessment Result.,请填写所有详细信息以生成评估结果。
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Variance ({}),差异（{}）
DocType: Healthcare Settings,Patient Name,患者姓名
apps/erpnext/erpnext/public/js/setup_wizard.js,Your Organization,你的组织
DocType: Contract,Fulfilment Details,履行细节
DocType: Project,Total Billed Amount (via Sales Invoices),总开帐单金额（通过销售发票）
apps/erpnext/erpnext/utilities/user_progress.py,Kg,公斤
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Appointment cancelled,预约已取消
DocType: Healthcare Settings,Reminder Message,提醒信息
DocType: Repayment Schedule,Balance Loan Amount,余额贷款金额
apps/erpnext/erpnext/config/crm.py,Manage Sales Person Tree.,管理销售人员树。
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,There are more holidays than working days this month.,本月假期多于工作日。
DocType: Item,Default BOM,默认BOM
DocType: BOM,Operating Cost (Company Currency),营业成本（公司货币）
DocType: Item Price,Item Price,商品价格
DocType: Payment Entry,Party Name,党名
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a customer,请选择一位客户
DocType: Program Enrollment Tool,New Program,新计划
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,"Number of new Cost Center, it will be included in the cost center name as a prefix",新成本中心的数量，它将作为前缀包含在成本中心名称中
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Select the customer or supplier.,选择客户或供应商。
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Valid till date cannot be before transaction date,有效日期不能在交易日期之前
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cannot deactivate or cancel BOM as it is linked with other BOMs,无法停用或取消BOM，因为它与其他物料清单链接
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Place Of Supply (State/UT),供应地点（州/ UT）
DocType: Job Opening,Job Title,职称
DocType: Fee Component,Fee Component,费用组件
apps/erpnext/erpnext/config/accounting.py,C-Form records,C-Form记录
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Cancelled. Please check your GoCardless Account for more details,付款已取消。请查看您的GoCardless帐户以获取更多详细信息
DocType: Crop Cycle,Less than a year,不到一年
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Work Order {0} must be submitted,必须提交工单{0}
apps/erpnext/erpnext/stock/report/warehouse_wise_item_balance_age_and_value/warehouse_wise_item_balance_age_and_value.js,Filter Total Zero Qty,过滤总零数量
DocType: Job Applicant,Applicant for a Job,申请工作
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Invoice table,“发票”表中未找到任何记录
DocType: Chart of Accounts Importer,Chart of Accounts Importer,会计科目表进口商
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Item or Warehouse for row {0} does not match Material Request,行{0}的项目或仓库与物料请求不匹配
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,IGST Amount,IGST金额
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,Delivery Notes {0} updated,已更新交货单{0}
DocType: Travel Itinerary,Lodging Required,需要住宿
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Total Revenue,总收入
DocType: Student Group Student,Student Group Student,学生团体学生
DocType: Customer,Buyer of Goods and Services.,商品和服务的买方。
DocType: Vehicle,Vehicle,车辆
apps/erpnext/erpnext/utilities/transaction_base.py,Quantity ({0}) cannot be a fraction in row {1},数量（{0}）不能是行{1}中的分数
DocType: Retention Bonus,Bonus Amount,奖金额
DocType: Stock Reconciliation Item,Amount Difference,金额差异
DocType: Asset Maintenance,Maintenance Tasks,维护任务
DocType: HR Settings,Stop Birthday Reminders,停止生日提醒
DocType: Payment Gateway Account,Payment Account,支付帐户
DocType: Stock Settings,Stock Frozen Upto,股票冻结Upto
DocType: Item,Default Material Request Type,默认物料申请类型
DocType: Clinical Procedure Item,Clinical Procedure Item,临床程序项目
DocType: Finance Book,Finance Book,财务书
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,From Datetime,从日期时间
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Currency of the price list {0} must be {1} or {2},价格表{0}的货币必须为{1}或{2}
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Open Orders,未结订单
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record.js,Admit,承认
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,Total {0} ({1}),总计{0}（{1}）
DocType: Certified Consultant,GitHub ID,GitHub ID
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From Address 1,从地址1
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Total hours: {0},总小时数：{0}
DocType: Employee Transfer,Transfer Date,转移日期
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,如果查询来源是活动，请输入活动名称
apps/erpnext/erpnext/stock/doctype/item/item.js,This Item is a Template and cannot be used in transactions. Item attributes will be copied over into the variants unless 'No Copy' is set,此项目是模板，不能在事务中使用。除非设置了“无复制”，否则项目属性将被复制到变体中
DocType: Cheque Print Template,Regular,定期
apps/erpnext/erpnext/controllers/selling_controller.py,Maximum discount for Item {0} is {1}%,第{0}项的最大折扣为{1}％
DocType: Production Plan,Not Started,没有开始
DocType: Disease,Treatment Task,治疗任务
DocType: Landed Cost Voucher,Landed Cost Help,降落成本帮助
DocType: Supplier Scorecard,Scoring Criteria,评分标准
DocType: Bank Statement Transaction Entry,Matching Invoices,匹配发票
DocType: Donor,Donor Name,捐助者姓名
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Select Property,选择房产
DocType: Homepage,Homepage Section,主页部分
DocType: Assessment Result,Grade,年级
DocType: Production Plan Material Request,Production Plan Material Request,生产计划材料申请
DocType: Request for Quotation Supplier,Send Email,发送电子邮件
DocType: Item,Retain Sample,保留样本
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be negative,行＃{0}（付款表）：金额必须为负数
,Warehouse wise Item Balance Age and Value,仓库明智的物品平衡年龄和价值
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),包裹的总重量。通常净重+包装材料重量。 （用于打印）
DocType: Plant Analysis,Laboratory Testing Datetime,实验室测试日期时间
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,The Item {0} cannot have Batch,项{0}不能具有批处理
apps/erpnext/erpnext/education/report/student_batch_wise_attendance/student_batch_wise_attendance.py,Student Group Strength,学生团体实力
DocType: Bank Statement Transaction Entry,Bank Statement Transaction Entry,银行对账单交易录入
DocType: Purchase Order,Get Items from Open Material Requests,从Open Material Requests获取项目
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**财年**代表财政年度。所有会计分录和其他主要交易均针对**财年**进行跟踪。
DocType: Procedure Prescription,Procedure Name,程序名称
apps/erpnext/erpnext/public/js/event.js,Add Sales Partners,添加销售伙伴
apps/erpnext/erpnext/public/js/pos/pos.html,Qty Total,数量总计
DocType: Payment Entry Reference,Outstanding,优秀
DocType: Employee Tax Exemption Proof Submission,Employee Tax Exemption Proof Submission,员工免税证明提交
DocType: Contract Fulfilment Checklist,Requirement,需求
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,No active or default Salary Structure found for employee {0} for the given dates,在给定日期找不到员工{0}的有效或默认薪资结构
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Quantity should be greater than 0,数量应大于0
DocType: Purchase Order Item,Supplier Quotation Item,供应商报价项目
DocType: Appraisal,Appraisal Template,评估模板
DocType: Item,Hub Category to Publish,要发布的集线器类别
DocType: Staffing Plan Detail,Current Openings,目前的开局
apps/erpnext/erpnext/config/crm.py,Customer Database.,客户数据库。
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,As On Date,作为日期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Delivery Note {0} is not submitted,未提交交货单{0}
DocType: Appraisal Template Goal,Appraisal Template Goal,评估模板目标
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Closing (Cr),收盘价（Cr）
DocType: Restaurant Reservation,Restaurant Reservation,餐厅预订
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Amount,最后订单金额
apps/erpnext/erpnext/config/desktop.py,Learn,学习
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Multiple default mode of payment is not allowed,不允许多种默认付款方式
DocType: Crop Cycle,This will be day 1 of the crop cycle,这将是作物周期的第1天
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} {1} is not associated with {2} {3},{0} {1}与{2} {3}无关
apps/erpnext/erpnext/controllers/stock_controller.py,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,项目{0}必须使用费用或差额帐户，因为它会影响整体库存值
DocType: Purchase Invoice,Price List Exchange Rate,价格表汇率
DocType: Purchase Invoice Item,Amount (Company Currency),金额（公司货币）
DocType: Driver,Driver,司机
DocType: GST Account,CGST Account,CGST账户
DocType: Loan,Disbursement Date,支付日期
apps/erpnext/erpnext/templates/pages/projects.html,New task,新任务
DocType: Customer Feedback Table,Customer Feedback Table,客户反馈表
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Course {2},{0}  -  {1}未在课程{2}中注册
DocType: Asset Value Adjustment,Difference Amount,差额金额
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Cheques and Deposits incorrectly cleared,检查和存款未正确清除
DocType: Journal Entry,Cash Entry,现金入境
DocType: GST Settings,GST Settings,消费税设置
,Item-wise Sales Register,逐项销售登记
apps/erpnext/erpnext/stock/doctype/item/item.py,Item has variants.,物品有变种。
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Difference Amount must be zero,差额金额必须为零
DocType: Fee Schedule,Institution,机构
DocType: Patient,Tobacco Current Use,烟草当前使用
apps/erpnext/erpnext/utilities/user_progress.py,Setup your ,设置你的
DocType: Payment Entry Deduction,Payment Entry Deduction,付款条目扣除
apps/erpnext/erpnext/stock/doctype/batch/batch.py,"Row #{0}: The batch {1} has only {2} qty. Please select another batch which has {3} qty available or split the row into multiple rows, to deliver/issue from multiple batches",行＃{0}：批处理{1}仅有{2}个数量。请选择另一个具有{3}数量可用的批次或将该行拆分为多行，以便从多个批次交付/发放
DocType: Patient Appointment,Procedure,程序
,Total Stock Summary,总库存总结
DocType: Purchase Invoice,Additional Discount,额外折扣
DocType: Healthcare Settings,Patient Name By,患者姓名
DocType: Healthcare Service Unit Type,Rate / UOM,费率/ UOM
DocType: Job Offer,Job Offer Terms,招聘条款
DocType: GL Entry,Debit Amount in Account Currency,账户货币的借方金额
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py,{0} must appear only once,{0}必须只出现一次
apps/erpnext/erpnext/controllers/stock_controller.py,Expense / Difference account ({0}) must be a 'Profit or Loss' account,费用/差额帐户（{0}）必须是“损益”帐户
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. Pending Amount is {2},行号{0}：金额不能大于费用索赔{1}的待定金额。待定金额为{2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Earnest Money,保证金
apps/erpnext/erpnext/config/buying.py,All Supplier scorecards.,所有供应商记分卡。
DocType: Sales Invoice,Terms and Conditions Details,条款和条件细节
DocType: Exchange Rate Revaluation,Get Entries,获取参赛作品
DocType: Vehicle Service,Service Item,服务项目
DocType: Sales Invoice,Customer's Purchase Order,客户的采购订单
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in formula or condition: {0},公式或条件中的语法错误：{0}
DocType: Agriculture Analysis Criteria,Agriculture User,农业用户
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter Reqd by Date,请按日期输入Reqd
DocType: Company,Total Monthly Sales,每月总销售额
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,每月分配百分比
DocType: Stock Reconciliation,Reconciliation JSON,对帐JSON
apps/erpnext/erpnext/stock/get_item_details.py,No Item with Barcode {0},没有条形码{0}的物品
DocType: Asset,Scrapped,报废
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Delivery Trip,送货之旅
DocType: Student Admission Program,Application Fee,报名费
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Sales orders are not available for production,销售订单不可用于生产
DocType: Website Attribute,Attribute,属性
DocType: Rename Tool,Rename Log,重命名日志
apps/erpnext/erpnext/controllers/trends.py,'Based On' and 'Group By' can not be same,&#39;基于&#39;和&#39;分组&#39;不能相同
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.js,Show Ageing Warehouse-wise,显示老龄化仓库
DocType: Sales Invoice,Write Off Outstanding Amount,注销未付金额
DocType: Payroll Entry,Employee Details,员工详细信息
DocType: Pricing Rule,Discount Amount,折扣金额
DocType: Healthcare Service Unit Type,Item Details,项目细节
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.py,Duplicate Tax Declaration of {0} for period {1},期间{1}的重复税务申报{0}
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.js,From Delivery Note,来自送货单
DocType: Holiday,Holiday,假日
DocType: Cheque Print Template,Line spacing for amount in words,单词行数
DocType: Item Group,Item Group Defaults,项目组默认值
DocType: Salary Component,Abbr,缩写
apps/erpnext/erpnext/config/support.py,Warranty Claim against Serial No.,针对序列号的保修索赔
apps/erpnext/erpnext/config/desktop.py,Quality,质量
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,{0} is not a stock Item,{0}不是库存物料
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,原材料供应成本
DocType: Employee,Permanent Address,永久地址
DocType: Asset,Booked Fixed Asset,预订固定资产
apps/erpnext/erpnext/templates/pages/help.html,Your tickets,你的门票
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Create Supplier Quotation,创建供应商报价
DocType: Item,Inspection Required before Purchase,购买前需要检查
DocType: Payment Entry,Payment Ordered,付款订购
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,"There seems to be an issue with the server's GoCardless configuration. Don't worry, in case of failure, the amount will get refunded to your account.",服务器的GoCardless配置似乎存在问题。不要担心，如果失败，金额将退还到您的帐户。
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Payment Mode is not configured. Please check, whether account has been set on Mode of Payments or on POS Profile.",付款方式未配置。请检查帐户是否已在付款方式或POS个人资料中设置。
DocType: Email Digest,Purchase Orders Items Overdue,采购订单项目逾期
DocType: BOM,Inspection Required,需要检查
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} {1} is cancelled so the action cannot be completed,{0} {1}已取消，因此无法完成操作
DocType: Project Template Task,Project Template Task,项目模板任务
apps/erpnext/erpnext/projects/doctype/task/task.py,Circular Reference Error,循环参考错误
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: 'Profit and Loss' type account {2} not allowed in Opening Entry,{0} {1}：在营业条目中不允许使用“盈亏”类型帐户{2}
DocType: Website Item Group,Cross Listing of Item in multiple groups,在多个组中交叉列出项目
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with existing transaction cannot be converted to ledger,具有现有交易的帐户无法转换为分类帐
DocType: POS Profile,Display Items In Stock,显示库存商品
DocType: Issue,Service Level,服务水平
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Other outward supplies(Nil rated,Exempted)",其他外向供应（未评级，豁免）
,TDS Payable Monthly,TDS应付月度
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Posting Date before selecting Party,请在选择Party之前选择发布日期
,GST Purchase Register,消费税购买登记
DocType: Accounts Settings,Automatically Add Taxes and Charges from Item Tax Template,从项目税模板自动添加税费
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Stock Options,股票期权
DocType: Healthcare Schedule Time Slot,Healthcare Schedule Time Slot,医疗保健计划时间槽
apps/erpnext/erpnext/public/js/pos/pos.html,Tap items to add them here,点按项目即可在此处添加
DocType: Payment Schedule,Invoice Portion,发票部分
apps/erpnext/erpnext/config/accounting.py,Tax Category for overriding tax rates.,最高税率的税收类别。
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Retained Earnings,留存收益
DocType: Grant Application,Requested Amount,请求金额
DocType: Salary Detail,Additional Amount,额外金额
DocType: Quiz,Quiz Configuration,测验配置
DocType: Mode of Payment,General,一般
DocType: Email Digest,Annual Expenses,年度费用
apps/erpnext/erpnext/projects/doctype/project/project.py,Expected End Date can not be less than Expected Start Date,预期结束日期不能低于预期开始日期
DocType: Global Defaults,Disable In Words,禁用单词
DocType: Customer,CUST-.YYYY.-,CUST-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Net pay cannot be negative,净工资不能为负
apps/erpnext/erpnext/crm/report/lead_conversion_time/lead_conversion_time.py,No of Interactions,没有相互作用
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row {0}# Item {1} cannot be transferred more than {2} against Purchase Order {3},行{0}＃Item {1}对于采购订单{3}的转移不能超过{2}
DocType: Attendance,Shift,转移
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Chart of Accounts and Parties,处理会计科目和缔约方
DocType: Stock Settings,Convert Item Description to Clean HTML,将项目描述转换为清除HTML
apps/erpnext/erpnext/patches/v11_0/rename_supplier_type_to_supplier_group.py,All Supplier Groups,所有供应商组
,Final Assessment Grades,最终评估等级
apps/erpnext/erpnext/projects/doctype/task/task.py,Cannot close task {0} as its dependant task {1} is not closed.,无法关闭任务{0}，因为其依赖任务{1}未关闭。
DocType: Promotional Scheme,Promotional Scheme Price Discount,促销计划价格折扣
DocType: Installation Note,Installation Note,安装说明
DocType: Student Admission,Application Form Route,申请表格路线
DocType: Work Order,Planned Operating Cost,计划运营成本
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Colour,颜色
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,{0} is not in Optional Holiday List,{0}不在可选假日列表中
DocType: Student Report Generation Tool,Show Marks,显示标记
DocType: Salary Component,Max Benefit Amount (Yearly),最高福利金额（每年）
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Next Depreciation Date cannot be before Purchase Date,折旧行{0}：下一个折旧日期不能在购买日期之前
DocType: Loyalty Program,Customer Group,客户群
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Fiscal Year Start Date should be one year earlier than Fiscal Year End Date,会计年度开始日期应比会计年度结束日期提前一年
,BOM Items and Scraps,物料清单物料和废料
apps/erpnext/erpnext/healthcare/setup.py,High Sensitivity,高灵敏度
DocType: Pricing Rule,Apply Discount on Rate,应用折扣率
DocType: Manufacturing Settings,"Update BOM cost automatically via Scheduler, based on latest valuation rate / price list rate / last purchase rate of raw materials.",根据最新的估值率/价格表率/原材料的最后购买率，通过Scheduler自动更新BOM成本。
DocType: Tally Migration,Tally Company,理货公司
DocType: Quiz Question,Quiz Question,测验问题
DocType: Task Depends On,Task Depends On,任务取决于
,Lead Id,潜在客户
DocType: Subscription Plan Detail,Subscription Plan Detail,订阅计划详细信息
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Week's Summary,本周摘要
DocType: Pricing Rule Item Code,Pricing Rule Item Code,定价规则项目代码
DocType: Water Analysis,Storage Temperature,贮存温度
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Direct Income,直接收入
apps/erpnext/erpnext/controllers/trends.py,Amt,AMT
,Sales Analytics,销售分析
DocType: Project,Total Billable Amount (via Timesheets),总可结算金额（通过时间表）
DocType: Setup Progress Action,Domains,域
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,"Not permitted, configure Lab Test Template as required",不允许，根据需要配置实验室测试模板
DocType: Item,Default Unit of Measure,默认计量单位
DocType: Serial No,Distinct unit of an Item,物品的不同单位
DocType: Amazon MWS Settings,Synch Products,同步产品
DocType: Supplier Scorecard Scoring Variable,Path,路径
DocType: Project Task,Task ID,任务ID
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Dr),开幕（博士）
DocType: Project,% Completed,％已完成
DocType: Customer,Commission Rate,佣金率
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Central Tax,中央税
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Outstanding Amount,总未付金额
DocType: Employee Tax Exemption Proof Submission Detail,Maximum Exemption Amount,最高免税额
DocType: Subscription Plan,Based on price list,根据价格表
DocType: Stock Entry Detail,Additional Cost,附加费用
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Closing Account {0} must be of type Liability / Equity,结算帐户{0}必须是Liability / Equity类型
apps/erpnext/erpnext/utilities/user_progress.py,Setup Company,设置公司
DocType: Inpatient Occupancy,Check In,报到
apps/erpnext/erpnext/config/buying.py,Customer and Supplier,客户和供应商
DocType: Issue,Support Team,支持团队
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0}: You can not assign itself as parent account,帐户{0}：您不能将自己指定为父帐户
apps/erpnext/erpnext/stock/doctype/item/item.py,Fixed Asset Item must be a non-stock item.,固定资产项目必须是非库存项目。
apps/erpnext/erpnext/stock/doctype/batch/batch.js,New Batch ID (Optional),新批次ID（可选）
apps/erpnext/erpnext/projects/doctype/project/project.js,Gantt Chart,甘特图
DocType: Employee Benefit Application Detail,Max Benefit Amount,最高福利金额
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} on Leave on {1},{0}离开{1}
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Do you really want to restore this scrapped asset?,你真的想恢复这个报废的资产吗？
apps/erpnext/erpnext/healthcare/doctype/healthcare_settings/healthcare_settings.py,Registration fee can not be Zero,注册费不能为零
DocType: Item Tax Template,Item Tax Template,物品税模板
DocType: Fiscal Year,Auto Created,自动创建
DocType: Quality Objective,Quality Objective,质量目标
DocType: Period Closing Voucher,"The account head under Liability or Equity, in which Profit/Loss will be booked",负债或权益项下的账户负责人，其中将记入损益
DocType: GL Entry,Credit Amount in Account Currency,账户货币的信贷金额
DocType: Employee Onboarding Activity,Employee Onboarding Activity,员工入职活动
DocType: Healthcare Service Unit,Parent Service Unit,家长服务单位
DocType: Sales Invoice,Include Payment (POS),包括付款（POS）
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Private Equity,私人产权
DocType: Shift Type,First Check-in and Last Check-out,首次入住和最后退房
DocType: Landed Cost Item,Receipt Document,收据文件
DocType: Supplier Scorecard Period,Supplier Scorecard Period,供应商记分卡期间
DocType: Employee Grade,Default Salary Structure,默认薪资结构
DocType: Exchange Rate Revaluation,Total Gain/Loss,总收益/损失
apps/erpnext/erpnext/education/doctype/course_enrollment/course_enrollment.py,Student is already enrolled.,学生已经注册。
DocType: Product Bundle,Parent Item,父项
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Brokerage,佣金
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Please create purchase receipt or purchase invoice for the item {0},请为商品{0}创建采购收据或购买发票
,Product Bundle Balance,产品包余额
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Name cannot be Company,公司名称不能是公司
DocType: Maintenance Visit,Breakdown,分解
DocType: Inpatient Record,B Negative,B否定
DocType: Issue,Response By,回应
DocType: Purchase Invoice,Credit To,归功于
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Submit this Work Order for further processing.,提交此工作订单以进行进一步处理。
DocType: Bank Guarantee,Bank Guarantee Number,银行担保号码
apps/erpnext/erpnext/templates/pages/material_request_info.html,Delivered: {0},已交付：{0}
DocType: Quality Meeting Table,Under Review,正在审查中
apps/erpnext/erpnext/public/js/setup_wizard.js,Agriculture (beta),农业（测试版）
,Average Commission Rate,平均佣金率
DocType: Sales Invoice,Customer's Purchase Order Date,客户的采购订单日期
apps/erpnext/erpnext/config/buying.py,All Contacts.,所有联系人。
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Used Leaves,二手叶子
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The field From Shareholder cannot be blank,来自股东的字段不能为空
DocType: Brand,Brand Defaults,品牌默认值
DocType: Task,Depends on Tasks,取决于任务
DocType: Healthcare Settings,Healthcare Settings,医疗保健设置
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,{0} Student Groups created.,{0}已创建学生组。
apps/erpnext/erpnext/public/js/hub/marketplace.js,Register,寄存器
DocType: Woocommerce Settings,"This warehouse will be used to create Sale Orders. The fallback warehouse is ""Stores"".",该仓库将用于创建销售订单。后备仓库是“商店”。
DocType: Vehicle Service,Oil Change,换油
DocType: Project User,Project User,项目用户
DocType: Course,Assessment,评定
DocType: Promotional Scheme,Price Discount Slabs,价格折扣板
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,New Customers,新客户
DocType: Project,Total Expense Claim (via Expense Claims),总费用索赔（通过费用索赔）
DocType: Instructor Log,Other Details,其他详情
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot change Attributes after stock transaction. Make a new Item and transfer stock to the new Item,股票交易后无法更改属性。创建一个新项目并将库存转移到新项目
DocType: Employee Attendance Tool,Employees HTML,员工HTML
DocType: Leave Block List,Stop users from making Leave Applications on following days.,阻止用户在接下来的几天内离开应用程序。
DocType: Budget,Ignore,忽视
,Sales Person Target Variance Based On Item Group,基于项目组的销售人员目标差异
DocType: Education Settings,Current Academic Year,本学年
DocType: Bank Statement Transaction Entry,Submit/Reconcile Payments,提交/核对付款
DocType: Purchase Invoice,Set Advances and Allocate (FIFO),设置进度和分配（FIFO）
DocType: BOM,Item to be manufactured or repacked,要制造或重新包装的物品
apps/erpnext/erpnext/accounts/page/pos/pos.js,New Cart,新推车
DocType: Purchase Receipt,MAT-PRE-.YYYY.-,MAT-PRE-.YYYY.-
apps/erpnext/erpnext/stock/doctype/item/item.py,Please select Sample Retention Warehouse in Stock Settings first,请先在库存设置中选择样品保留仓库
DocType: Lab Test Template,Result Format,结果格式
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,会计分录所针对的负责人（或团体）和余额得以维持。
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,材料请求用于进行此股票输入
DocType: Request for Quotation,Link to material requests,链接到物料请求
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Unsecured Loans,无抵押贷款
apps/erpnext/erpnext/public/js/event.js,Add Customers,添加客户
DocType: Manufacturing Settings,Default Finished Goods Warehouse,默认成品仓库
DocType: Grant Application,Grant Description,拨款说明
apps/erpnext/erpnext/stock/doctype/item/item.js,"Weight is mentioned,\nPlease mention ""Weight UOM"" too",提到重量，\ n请注意“重量UOM”
apps/erpnext/erpnext/accounts/party.py,{0} {1} is disabled,{0} {1}已停用
DocType: Contract,Contract Period,合同期
apps/erpnext/erpnext/healthcare/doctype/clinical_procedure/clinical_procedure.js,Please enter Item Code to get Batch Number,请输入物料代码以获取批号
DocType: Cash Flow Mapping,Is Working Capital,营运资金
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Missing email template for dispatch. Please set one in Delivery Settings.,缺少发送的电子邮件模板。请在“传递设置”中设置一个。
DocType: Packing Slip,MAT-PAC-.YYYY.-,MAT-PAC-.YYYY.-
DocType: Supplier Scorecard,"Scorecard variables can be used, as well as:
{total_score} (the total score from that period),
{period_number} (the number of periods to present day)
",可以使用记分卡变量，以及：{total_score}（该期间的总分），{period_number}（到期日的期间数）
apps/erpnext/erpnext/public/js/stock_analytics.js,Value Or Qty,价值或数量
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].js,Please register the SIREN number in the company information file,请在公司信息文件中注册SIREN号码
DocType: Amazon MWS Settings,Check this to enable a scheduled Daily synchronization routine via scheduler,选中此选项可通过调度程序启用计划的每日同步例程
DocType: Employee Tax Exemption Declaration,Declarations,声明
DocType: Manufacturing Settings,Backflush Raw Materials Based On,反吹原料基于
DocType: Cheque Print Template,Distance from top edge,距离上边缘的距离
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Job Description,职位描述
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,"Can not filter based on Voucher No, if grouped by Voucher",如果按凭证分组，则无法根据凭证号进行过滤
DocType: Purchase Receipt Item,Received and Accepted,收到并接受
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Negative Valuation Rate is not allowed,不允许负估值率
DocType: Woocommerce Settings,"The user that will be used to create Customers, Items and Sales Orders. This user should have the relevant permissions.",将用于创建客户，项目和销售订单的用户。该用户应具有相关权限。
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Purchase Order,创建采购订单
apps/erpnext/erpnext/config/accounting.py,Define budget for a financial year.,定义财政年度的预算。
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Accounts table cannot be blank.,帐户表不能为空。
DocType: Employee Checkin,Entry Grace Period Consequence,进入宽限期后果
,Payment Period Based On Invoice Date,基于发票日期的付款期
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py,Installation date cannot be before delivery date for Item {0},项目{0}的交货日期之前的安装日期不能
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Link to Material Request,链接到材料请求
DocType: Warranty Claim,From Company,来自公司
DocType: Bank Statement Transaction Settings Item,Mapped Data Type,映射数据类型
apps/erpnext/erpnext/stock/doctype/item/item.py,Row {0}: An Reorder entry already exists for this warehouse {1},行{0}：此仓库{1}已存在重新订购条目
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Doc Date,文件日期
DocType: Monthly Distribution,Distribution Name,分配名称
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Workday {0} has been repeated.,工作日{0}已重复。
apps/erpnext/erpnext/accounts/doctype/account/account.js,Group to Non-Group,集团到非集团
apps/erpnext/erpnext/setup/doctype/company/company.js,Update in progress. It might take a while.,正在更新。这可能需要一段时间。
DocType: Item,"Example: ABCD.#####
If series is set and Serial No is not mentioned in transactions, then automatic serial number will be created based on this series. If you always want to explicitly mention Serial Nos for this item. leave this blank.",示例：ABCD。#####如果设置了系列并且事务中未提及序列号，则将基于此系列创建自动序列号。如果您总是希望明确提及此项目的序列号。留空。
DocType: Stock Entry,Stock Entry (Outward GIT),股票进入（外向GIT）
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Party Addresses,处理方地址
DocType: Selling Settings,Delivery Note Required,需要交货单
DocType: Pricing Rule,Sales Partner,销售合作伙伴
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",截至此日期冻结的会计分录，除下面指定的角色外，没有人可以进行/修改分录。
DocType: Vehicle Log,Fuel Qty,燃料数量
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Mobile No,Guardian1手机号码
DocType: Invoice Discounting,Disbursed,支付
DocType: Shift Type,Time after the end of shift during which check-out is considered for attendance.,轮班结束后的时间，在此期间考虑退房。
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Payable,应付账款净变动
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Not Available,无法使用
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Part-time,兼职
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Delivery,交货
DocType: Student Group Creation Tool Course,Student Group Creation Tool Course,学生组创建工具课程
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be greater than unadjusted amount,分配的金额不能大于未调整的金额
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,第三方经销商/经销商/佣金代理商/关联公司/经销商，销售公司产品以获得佣金。
DocType: BOM Item,Original Item,原始物品
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py,Series is mandatory,系列是强制性的
apps/erpnext/erpnext/config/crm.py,Potential opportunities for selling.,潜在的销售机会。
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show PDC in Print,在Print中显示PDC
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/sync_product.py,Shopify Supplier,Shopify供应商
DocType: POS Profile User,POS Profile User,POS档案用户
DocType: Sales Person,Sales Person Name,销售人员姓名
DocType: Packing Slip,Gross Weight,总重量
DocType: Journal Entry,Bill No,比尔号
apps/erpnext/erpnext/assets/doctype/location/location_tree.js,New Location,新位置
,Project wise Stock Tracking,项目明智的股票追踪
DocType: Vehicle Log,HR-VLOG-.YYYY.-,HR-VLOG，.YYYY.-
DocType: Student,A+,A +
DocType: Issue,Service Level Agreement,服务水平协议
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Item valuation rate is recalculated considering landed cost voucher amount,考虑到岸成本凭证金额，重新计算项目估价率
DocType: Timesheet,Employee Detail,员工细节
DocType: Tally Migration,Vouchers,优惠券
DocType: Student,Guardian Details,卫报详情
DocType: Shopify Settings,eg: frappe.myshopify.com,例如：frappe.myshopify.com
apps/erpnext/erpnext/crm/doctype/lead/lead.py,"Email Address must be unique, already exists for {0}",电子邮件地址必须唯一，{0}已存在
apps/erpnext/erpnext/config/accounting.py,Match Payments with Invoices,将付款与发票匹配
DocType: Holiday List,Weekly Off,每周休息
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Not allow to set alternative item for the item {0},不允许为项目{0}设置备用项目
apps/erpnext/erpnext/www/lms/program.py,Program {0} does not exist.,程序{0}不存在。
apps/erpnext/erpnext/hr/doctype/department/department.js,You cannot edit root node.,您无法编辑根节点。
DocType: Fee Schedule,Student Category,学生类别
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Item {0}: {1} qty produced, ",项目{0}：生成{1}数量，
DocType: Identification Document Type,Identification Document Type,识别文件类型
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Insufficient Stock,库存不足
apps/erpnext/erpnext/controllers/selling_controller.py,Row {0}: Conversion Factor is mandatory,行{0}：转换因子是必需的
DocType: Buying Settings,Purchase Receipt Required,需要购买收据
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,BOM Rate,BOM率
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The check digit validation has failed. ,GSTIN无效！校验位验证失败。
DocType: HR Settings,Max working hours against Timesheet,针对Timesheet的最长工作时间
DocType: HR Settings,Include holidays in Total no. of Working Days,在总数中包括假期。工作日
DocType: Quality Meeting,Quality Meeting,质量会议
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Consulting,咨询
DocType: Payment Gateway Account,Default Payment Request Message,默认付款请求消息
DocType: GST Settings,GSTIN Email Sent On,GSTIN电子邮件已发送
DocType: Amazon MWS Settings,Enable Scheduled Synch,启用预定同步
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Please select Employee,请选择员工
DocType: Healthcare Settings,"If checked, a customer will be created, mapped to Patient.
Patient Invoices will be created against this Customer. You can also select existing Customer while creating Patient.",如果选中，将创建一个客户，映射到患者。将针对该客户创建患者发票。您还可以在创建患者时选择现有客户。
DocType: Fiscal Year,Stock User,股票用户
apps/erpnext/erpnext/config/support.py,Service Level Agreement.,服务水平协议。
DocType: Additional Salary,Date on which this component is applied,应用此组件的日期
apps/erpnext/erpnext/config/accounting.py,List of available Shareholders with folio numbers,具有作品集编号的可用股东名单
apps/erpnext/erpnext/config/accounting.py,Setup Gateway accounts.,设置网关帐户。
DocType: Service Level Priority,Response Time Period,响应时间段
DocType: Purchase Invoice,Purchase Taxes and Charges,购买税和费用
DocType: Course Activity,Activity Date,活动日期
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select or add new customer,选择或添加新客户
DocType: Contract,Unfulfilled,秕
apps/erpnext/erpnext/templates/pages/home.html,Read blog,阅读博客
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Project Value,项目价值
DocType: Task,Expected Time (in hours),预计时间（小时）
apps/erpnext/erpnext/stock/doctype/item/item.py,Updating Variants...,更新变体......
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Show Sales Person in Print,在Print中显示销售人员
DocType: Supplier Scorecard,Per Year,每年
DocType: Inpatient Record,Admitted Datetime,承认日期时间
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Template is mandatory.,税模板是强制性的。
DocType: Clinical Procedure,Patient,患者
DocType: Timesheet Detail,Costing Amount,成本金额
apps/erpnext/erpnext/stock/doctype/item/item.js,Add / Edit Prices,添加/编辑价格
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Non-GST outward supplies,非商品及服务税外向供应
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From time must be less than to time,行{0}：从时间开始必须小于时间
apps/erpnext/erpnext/hr/doctype/employee/employee.py,User {0} is already assigned to Employee {1},用户{0}已分配给员工{1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Form View,表单视图
DocType: Supplier Quotation,Auto Repeat Section,自动重复部分
DocType: Sales Person,Select company name first.,首先选择公司名称。
apps/erpnext/erpnext/public/js/setup_wizard.js,Financial Year,财政年度
DocType: Sales Invoice Item,Deferred Revenue,递延收入
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Atleast one of the Selling or Buying must be selected,必须选择至少一个销售或购买
DocType: Shift Type,Working Hours Threshold for Half Day,半天的工作时间门槛
,Item-wise Purchase History,项目购买历史
apps/erpnext/erpnext/accounts/deferred_revenue.py,Cannot change Service Stop Date for item in row {0},无法更改行{0}中项目的服务停止日期
DocType: Production Plan,Include Subcontracted Items,包括转包商品
DocType: Salary Structure,Max Benefits (Amount),最高福利（金额）
DocType: Homepage,Hero Section,英雄科
apps/erpnext/erpnext/config/manufacturing.py,Where manufacturing operations are carried.,在哪里进行制造业务。
apps/erpnext/erpnext/patches/v11_0/add_default_dispatch_notification_template.py,Dispatch Notification,发货通知
DocType: Projects Settings,Timesheets,时间表
DocType: Purchase Receipt,Get current stock,获取当前库存
DocType: Account,Expense,费用
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,{0} asset cannot be transferred,{0}资产无法转移
,Unpaid Expense Claim,未付费用索赔
DocType: Employee,Family Background,家庭背景
apps/erpnext/erpnext/hr/doctype/retention_bonus/retention_bonus.py,Bonus Payment Date cannot be a past date,奖金支付日期不能是过去的日期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,No {0} found for Inter Company Transactions.,在Inter Company Transactions中找不到{0}。
DocType: Bank Account,Party Type,派对类型
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Finish,完
DocType: Sales Invoice,C-Form Applicable,C形式适用
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",账户余额已经在借方，您不能将&#39;余额必须&#39;设置为&#39;信用&#39;
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Qty increased by 1,行＃{0}：数量增加1
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,为此销售人员分组设置目标项目。
DocType: Asset Repair,ACC-ASR-.YYYY.-,ACC-ASR-.YYYY.-
DocType: Student,Student Mobile Number,学生手机号码
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Academic Year: ,学年：
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,"As per the Buying Settings if Purchase Order Required == 'YES', then for creating Purchase Invoice, user need to create Purchase Order first for item {0}",根据购买订单要求的购买设置==&#39;是&#39;，然后用于创建采购发票，用户需要首先为项目{0}创建采购订单
DocType: Shipping Rule Condition,To Value,为了价值
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Please add the account to root level Company - ,请将帐户添加到根级公司 -
DocType: Asset Settings,Number of Days in Fiscal Year,财政年度的天数
DocType: Journal Entry,Total Amount Currency,总金额货币
DocType: BOM,Allow Same Item Multiple Times,多次允许相同的项目
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create BOM,创建BOM
DocType: Healthcare Practitioner,Charges,收费
DocType: Employee,Attendance and Leave Details,出勤和离职详情
DocType: Student,Personal Details,个人资料
DocType: Sales Order,Billing and Delivery Status,结算和交付状态
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Row {0}: For supplier {0} Email Address is required to send email,行{0}：对于供应商{0}，需要电子邮件地址来发送电子邮件
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Investing,投资现金流量
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Approving Role cannot be same as role the rule is Applicable To,批准角色不能与规则适用的角色相同
DocType: Crop,Crop Spacing,裁剪间距
DocType: Selling Settings,How often should project and company be updated based on Sales Transactions.,项目和公司应根据销售交易多久更新一次。
DocType: Pricing Rule,Period Settings,期间设置
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Accounts Receivable,应收账款净变动
DocType: Quality Feedback Template,Quality Feedback Template,质量反馈模板
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be greater than zero,对于数量必须大于零
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,"There are inconsistencies between the rate, no of shares and the amount calculated",费率，股份数和计算金额之间存在不一致
DocType: Student Group Creation Tool,Leave blank if you make students groups per year,如果您每年组建学生团体，请留空
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Loans (Liabilities),贷款（负债）
apps/erpnext/erpnext/non_profit/doctype/grant_application/grant_application.js,Send Grant Review Email,发送Grant Review Email
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,GSTR3B-Form,GSTR3B表格
DocType: Production Plan Item,Produced Qty,制作数量
DocType: Bank Statement Transaction Invoice Item,Journal Entry,期刊录入
DocType: Stock Entry,Purchase Receipt No,购买收据编号
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be before employee's joining Date {1},从日期{0}开始，不能在员工加入日期{1}之前
DocType: Journal Entry,Debit Note,借记通知单
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,此税是否包含在基本税率中？
DocType: Share Balance,Purchased,购买
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,价格表货币转换为公司基础货币的比率
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,View Fees Records,查看费用记录
DocType: Training Event,Theory,理论
apps/erpnext/erpnext/utilities/activation.py,Create Quotation,创建报价
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Journal Entry {1} does not have account {2} or already matched against another voucher,行＃{0}：日记帐分录{1}没有帐户{2}或已与另一个凭证匹配
apps/erpnext/erpnext/accounts/page/pos/pos.js,Create a new Customer,创建一个新客户
DocType: BOM Website Operation,BOM Website Operation,BOM网站运营
DocType: Payment Reconciliation,Invoice/Journal Entry Details,发票/日记帐分录详细信息
DocType: Share Balance,Share Balance,分享余额
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Period Closing Entry,期末结算
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py,Purchase Price List,购买价格表
DocType: Contract,Party User,派对用户
DocType: Restaurant Order Entry,Restaurant Order Entry,餐厅订单输入
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,"Serialized Item {0} cannot be updated using Stock Reconciliation, please use Stock Entry",无法使用库存对帐更新序列化物料{0}，请使用库存输入
DocType: Practitioner Schedule,Time Slots,时隙
apps/erpnext/erpnext/stock/doctype/item/item.js,Select at least one value from each of the attributes.,从每个属性中选择至少一个值。
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank Draft,银行汇票
DocType: Email Digest,Send regular summary reports via Email.,通过电子邮件定期发送摘要报告
DocType: Quality Procedure Table,Step,步
DocType: Normal Test Items,Result Value,结果值
DocType: Cash Flow Mapping,Is Income Tax Liability,是所得税责任
DocType: Healthcare Practitioner,Inpatient Visit Charge Item,住院访问费用项目
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,{0} {1} does not exist.,{0} {1}不存在。
apps/erpnext/erpnext/templates/emails/training_event.html,Update Response,更新回复
DocType: Bank Guarantee,Supplier,供应商
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Enter value betweeen {0} and {1},输入{0}和{1}之间的值
DocType: Purchase Order,Order Confirmation Date,订单确认日期
DocType: Delivery Trip,Calculate Estimated Arrival Times,计算预计到达时间
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Consumable,耗材
DocType: Instructor,EDU-INS-.YYYY.-,EDU-INS-.YYYY.-
DocType: Subscription,Subscription Start Date,订阅开始日期
DocType: Woocommerce Settings,Woocommerce Server URL,Woocommerce服务器URL
DocType: Payroll Entry,Number Of Employees,在职员工人数
apps/erpnext/erpnext/regional/india/bank_remittance.py,{0} field is limited to size {1},{0}字段的大小限制为{1}
apps/erpnext/erpnext/education/utils.py,This {0} conflicts with {1} for {2} {3},对于{2} {3}，此{0}与{1}冲突
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Value Proposition,价值主张
DocType: Purchase Invoice,Contact Email,联系电子邮件
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Cannot set authorization on basis of Discount for {0},无法根据{0}的折扣设置授权
DocType: Attendance Request,Work From Home,在家里工作
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: From Time and To Time is mandatory.,行{0}：从时间到时间是必需的。
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Supplier Id,供应商ID
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Invoice can't be made for zero billing hour,零帐单小时不能发票
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,"Leave cannot be allocated before {0}, as leave balance has already been carry-forwarded in the future leave allocation record {1}",在{0}之前不能分配休假，因为休假余额已在未来的休假分配记录{1}中转发
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Last Order Date,最后订购日期
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Course: ,课程：
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Dispatch,调度
DocType: Installation Note Item,Installation Note Item,安装说明项目
DocType: Journal Entry Account,Journal Entry Account,日记帐分录
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant,变种
apps/erpnext/erpnext/templates/pages/help.html,Forum Activity,论坛活动
DocType: Service Level Priority,Resolution Time Period,解决时间段
DocType: Request for Quotation,Supplier Detail,供应商细节
DocType: Project Task,View Task,查看任务
DocType: Serial No,Purchase / Manufacture Details,购买/制造细节
DocType: Accounts Settings,Book Asset Depreciation Entry Automatically,自动预订资产折旧条目
DocType: Work Order Operation,Operation completed for how many finished goods?,操作完成了多少成品？
DocType: Healthcare Settings,Employee name and designation in print,员工姓名和印刷品名称
DocType: Tally Migration,Is Day Book Data Processed,是否处理了日记簿数据
DocType: Program,Courses,课程
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Update stock must be enable for the purchase invoice {0},必须为购买发票{0}启用更新库存
DocType: Employee Boarding Activity,Employee Boarding Activity,员工寄宿活动
apps/erpnext/erpnext/stock/utils.py,Warehouse {0} does not belong to company {1},仓库{0}不属于公司{1}
DocType: Global Defaults,"If disable, 'In Words' field will not be visible in any transaction",如果禁用，则在任何事务中都不会显示“在单词中”字段
DocType: Payment Entry Reference,Allocated,分配
DocType: Project,Time to send,发送时间
DocType: Vital Signs,Bloated,胀
DocType: Blanket Order,Order Type,订单类型
DocType: POS Closing Voucher,Period Start Date,期间开始日期
DocType: Maintenance Schedule,Generate Schedule,生成计划
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Opening Value,开放价值
DocType: Additional Salary,Additional Salary,额外薪水
DocType: Loan,Repayment Method,还款方式
apps/erpnext/erpnext/config/projects.py,Cost of various activities,各种活动的费用
DocType: Opportunity,Mins to First Response,分钟到第一反应
DocType: Patient Appointment,Patient Age,患者年龄
DocType: Patient Encounter,Investigations,调查
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Office Equipments,办公设备
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full , did not save",LocalStorage已满，没有保存
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Items for Raw Material Request,原料要求的项目
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.js,Select Item (optional),选择项目（可选）
apps/erpnext/erpnext/selling/doctype/product_bundle/product_bundle.py,Parent Item {0} must not be a Stock Item,父项{0}不能是库存项目
DocType: Stock Entry Detail,Against Stock Entry,反对股票进入
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Fetch exploded BOM (including sub-assemblies),获取爆炸物料清单（包括子组件）
DocType: Sales Invoice,ACC-SINV-.YYYY.-,ACC-SINV-.YYYY.-
DocType: Loan,Loan Application,申请贷款
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Job Card,对于工作卡
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Master Data,处理主数据
DocType: Cheque Print Template,Is Account Payable,是应付帐款
apps/erpnext/erpnext/selling/report/inactive_customers/inactive_customers.py,Total Order Value,总订单价值
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,Supplier {0} not found in {1},在{1}中找不到供应商{0}
apps/erpnext/erpnext/config/settings.py,Setup SMS gateway settings,设置SMS网关设置
DocType: Salary Component,Round to the Nearest Integer,舍入到最近的整数
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Root cannot have a parent cost center,Root不能拥有父成本中心
DocType: Healthcare Service Unit,Allow Appointments,允许约会
DocType: BOM,Show Operations,显示操作
DocType: Practitioner Schedule,Practitioner Schedule,从业者时间表
DocType: Asset Maintenance Task,Calibration,校准
DocType: Pricing Rule,Apply On,应用于
apps/erpnext/erpnext/config/accounting.py,Close Balance Sheet and book Profit or Loss.,关闭资产负债表并预订盈亏。
DocType: Employee,Provide Email Address registered in company,提供在公司注册的电子邮件地址
DocType: Item Alternative,Alternative Item Name,替代物品名称
DocType: Assessment Plan,Course,课程
DocType: Patient,Patient Details,患者详情
DocType: Employee Separation,Employee Separation,员工分离
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Debtors,债务人
DocType: Bank Statement Settings,Mapped Items,映射的项目
DocType: Leave Control Panel,Department (optional),部门（可选）
DocType: Task Type,Task Type,任务类型
apps/erpnext/erpnext/hr/report/bank_remittance/bank_remittance.py,Debit A/C Number,借记A / C号码
DocType: Timesheet,Total Billed Amount,总账单金额
apps/erpnext/erpnext/accounts/party.py,Due / Reference Date cannot be after {0},到期/参考日期不能在{0}之后
DocType: Leave Allocation,Add unused leaves from previous allocations,添加先前分配中未使用的叶子
DocType: Employee Transfer,New Company,新公司
DocType: Sales Invoice,Commission Rate (%),佣金率（％）
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,仓库只能通过库存输入/交货单/购买收据进行更改
DocType: Support Settings,Close Issue After Days,几天后关闭问题
DocType: Payment Schedule,Payment Schedule,付款时间表
DocType: Shift Type,Enable Entry Grace Period,启用条目宽限期
DocType: Patient Relation,Spouse,伴侣
DocType: Purchase Invoice,Reason For Putting On Hold,搁置的原因
DocType: Item Attribute,Increment,增量
DocType: Vital Signs,Cuts,削减
DocType: Student Applicant,LMS Only,仅限LMS
DocType: Shopping Cart Settings,Show Contact Us Button,显示联系我们按钮
apps/erpnext/erpnext/public/js/event.js,Add Employees,添加员工
DocType: Holiday List,Holidays,假期
DocType: Chapter,Chapter Head,章头
apps/erpnext/erpnext/healthcare/doctype/lab_test_template/lab_test_template.py,Not permitted. Please disable the Test Template,不允许。请禁用测试模板
DocType: Restaurant Reservation,No Show,没有出现
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Selling Amount,卖出金额
DocType: Amazon MWS Settings,AWS Access Key ID,AWS访问密钥ID
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.py,{0} {1} is not present in the parent company,母公司中不存在{0} {1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,To Date cannot be before From Date,到日期不能早于日期
apps/erpnext/erpnext/public/js/event.js,Add Suppliers,添加供应商
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,Summary for this month and pending activities,本月和未决活动的摘要
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Mode of Transport,交通方式
DocType: Salary Slip,Gross Pay - Total Deduction - Loan Repayment,总薪酬 - 扣除总额 - 贷款还款
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Posting Date cannot be future date,过账日期不能是将来的日期
,Work Order Stock Report,工作订单库存报告
apps/erpnext/erpnext/config/accounting.py,Enable / disable currencies.,启用/禁用货币。
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,View in Cart,在购物车中查看
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Fetch based on FIFO,基于FIFO获取
DocType: Timesheet,Total Billable Amount,总可结算金额
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},对于销售订单{2}，可以对项目{1}进行最大{0}的物料请求
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order_calendar.js,Production Item,生产项目
DocType: Share Transfer,Equity/Liability Account,权益/责任账户
apps/erpnext/erpnext/www/all-products/index.html,No values,没有价值
apps/erpnext/erpnext/assets/doctype/asset_value_adjustment/asset_value_adjustment.py,Cancel the journal entry {0} first,首先取消日记帐分录{0}
DocType: GL Entry,Remarks,备注
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Advance against Supplier must be debit,行{0}：针对供应商的预付款必须是借方
DocType: Student Report Generation Tool,Attended by Parents,由家长参加
DocType: POS Profile,Update Stock,更新股票
DocType: Account,Old Parent,老父母
DocType: Production Plan,Download Materials Required,下载所需材料
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py,Another Period Closing Entry {0} has been made after {1},在{1}之后创建了另一个期间结算条目{0}
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,Item Template,项目模板
DocType: Purchase Invoice Item,Discount on Price List Rate (%),价格表折扣率（％）
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbreviation is mandatory,缩写是强制性的
DocType: Travel Request,Domestic,国内
apps/erpnext/erpnext/selling/report/pending_so_items_for_purchase_request/pending_so_items_for_purchase_request.py,SO Qty,这么多
DocType: Program Enrollment,Pick/Drop by Guardian,由卫报选择/删除
DocType: Exchange Rate Revaluation Account,Balance In Base Currency,基础货币余额
apps/erpnext/erpnext/config/buying.py,All Products or Services.,所有产品或服务。
DocType: Vehicle Service,Brake Pad,刹车片
DocType: Pricing Rule,Max Amt,Max Amt
DocType: Shopping Cart Settings,Show Stock Availability,显示库存可用性
DocType: Hotel Room Pricing Item,Hotel Room Pricing Item,酒店客房定价项目
DocType: Project Task,Pending Review,等待审核
DocType: Employee,Date of Joining,加入的日期
DocType: Patient,Patient Relation,患者关系
DocType: Currency Exchange,For Selling,出售
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Financing,融资现金流量
DocType: Blanket Order,Manufacturing,制造业
apps/erpnext/erpnext/templates/pages/home.html,By {0},到{0}
DocType: Restaurant Menu,Restaurant Manager,餐厅经理
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Out Value,出价值
DocType: Volunteer,Availability and Skills,可用性和技能
DocType: Employee Advance,Advance Account,预付账户
DocType: GSTR 3B Report,Invoices with no Place Of Supply,没有供应地的发票
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Ref,参考
DocType: Invoice Discounting,Loan End Date,贷款结束日期
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Quantity in row {0} ({1}) must be same as manufactured quantity {2},行{0}（{1}）中的数量必须与制造数量{2}相同
apps/erpnext/erpnext/utilities/user_progress_utils.py,Commercial,广告
DocType: Salary Slip,Bank Account No.,银行帐号
apps/erpnext/erpnext/controllers/taxes_and_totals.py,Advance amount cannot be greater than {0} {1},提前金额不能超过{0} {1}
DocType: Cheque Print Template,Width of amount in word,单词中的金额宽度
DocType: Delivery Note,MAT-DN-.YYYY.-,MAT-DN-.YYYY.-
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign Salary Structure,分配薪资结构
DocType: Stock Entry,Stock Entry Type,股票进入类型
DocType: Quality Action Table,Responsible,主管
DocType: Room,Room Number,房间号
apps/erpnext/erpnext/public/js/account_tree_grid.js,Select Fiscal Year...,选择财政年度......
,Trial Balance,试算平衡
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,Employee Transfer cannot be submitted before Transfer Date ,在转移日期之前无法提交员工转移
DocType: Grading Scale,Grading Scale Name,评分标度名称
DocType: Location,Area UOM,区域UOM
DocType: Timesheet,Total Costing Amount,总成本金额
DocType: Material Request Plan Item,Material Issue,重大问题
DocType: BOM,Item Image (if not slideshow),项目图片（如果不是幻灯片）
DocType: Share Balance,Is Company,是公司
DocType: BOM Update Tool,Update latest price in all BOMs,更新所有物料清单中的最新价格
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,超过160个字符的邮件将拆分为多个邮件
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Salary Slip submitted for period from {0} to {1},提交期限从{0}到{1}的工资单
apps/erpnext/erpnext/controllers/trends.py,Project-wise data is not available for Quotation,项目明智的数据不适用于报价
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Outstanding Amt,总突出金额
DocType: Purchase Invoice Item,Item Tax Rate,物品税率
DocType: Sales Order Item,Planned Quantity,计划数量
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry,保留库存
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,在保存交货单后，将显示单词（导出）。
DocType: Selling Settings,Each Transaction,每笔交易
DocType: Program Enrollment,Institute's Bus,学院的巴士
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select the Company first,请先选择公司
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Attendance for employee {0} is already marked for this day,员工{0}的出勤已经标记为当天
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py,Opening,开盘
DocType: Crop Cycle,Detected Disease,检出疾病
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0}（{1}）不能大于生产订单{3}中的计划质量（{2}）
DocType: Stock Ledger Entry,Stock Queue (FIFO),股票队列（FIFO）
apps/erpnext/erpnext/controllers/buying_controller.py,Please enter 'Is Subcontracted' as Yes or No,请输入“Is Subttracted”为“是”或“否”
DocType: Company,Default Holiday List,默认假期列表
DocType: Naming Series,Current Value,当前值
apps/erpnext/erpnext/config/accounting.py,"Seasonality for setting budgets, targets etc.",设定预算，目标等的季节性
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Warning: Sales Order {0} already exists against Customer's Purchase Order {1},警告：客户的采购订单{1}已存在销售订单{0}
apps/erpnext/erpnext/utilities/user_progress.py,Monthly Sales Target (,每月销售目标（
DocType: Guardian,Guardian Interests,守护者的利益
apps/erpnext/erpnext/stock/doctype/batch/batch.py,Batch ID is mandatory,批次ID是必需的
DocType: Item,Allow over delivery or receipt upto this percent,允许超过交付或收据达到此百分比
DocType: Payment Entry,Paid Amount (Company Currency),已付金额（公司货币）
DocType: Shipping Rule Condition,Shipping Rule Condition,运输规则条件
DocType: Employee Boarding Activity,Required for Employee Creation,员工创建需要
DocType: Loyalty Point Entry Redemption,Loyalty Point Entry Redemption,忠诚度积分兑换
DocType: Job Applicant,Cover Letter,求职信
DocType: Chart of Accounts Importer,Chart Preview,图表预览
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,物品质量检验参数
DocType: Support Settings,Get Started Sections,入门章节
DocType: Delivery Note,% of materials delivered against this Delivery Note,根据本交货单交付的材料百分比
DocType: Warranty Claim,Warranty / AMC Status,保修/ AMC状态
apps/erpnext/erpnext/utilities/user_progress.py,Gram,公克
apps/erpnext/erpnext/accounts/utils.py,Allocated amount cannot be negative,分配数量不能为负数
DocType: POS Profile,Item Groups,物品组
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Customer LPO No.,客户LPO编号
,Company Name,公司名
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To Address 1,致地址1
,Purchase Receipt Trends,购买收据趋势
DocType: Leave Block List,Leave Block List Dates,保留阻止列表日期
apps/erpnext/erpnext/education/doctype/student/student.py,Student {0} exist against student applicant {1},学生{0}针对学生申请人{1}
DocType: Education Settings,LMS Settings,LMS设置
apps/erpnext/erpnext/config/settings.py,Titles for print templates e.g. Proforma Invoice.,打印模板的标题，例如形式发票。
DocType: Serial No,Delivery Time,交货时间
DocType: Loan,Repayment Period in Months,还款期限以月计算
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Transporter ID,运输商ID
apps/erpnext/erpnext/config/buying.py,Price List master.,价目表大师。
DocType: Department,The first Expense Approver in the list will be set as the default Expense Approver.,列表中的第一个费用审批人将被设置为默认的费用审批人。
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Advertising,广告
DocType: Authorization Rule,Customer or Item,客户或物品
DocType: Vehicle Log,Invoice Ref,发票参考
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py,C-form is not applicable for Invoice: {0},C表格不适用于发票：{0}
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Invoice Created,发票已创建
DocType: Shift Type,Early Exit Grace Period,提前退出宽限期
DocType: Patient Encounter,Review Details,查看详情
apps/erpnext/erpnext/projects/doctype/timesheet/timesheet.py,Row {0}: Hours value must be greater than zero.,行{0}：小时值必须大于零。
DocType: Account,Account Number,帐号
DocType: Assessment Result Detail,Assessment Result Detail,评估结果细节
apps/erpnext/erpnext/controllers/status_updater.py,"To allow over-billing or over-ordering, update ""Allowance"" in Stock Settings or the Item.",要允许超额结算或过度订购，请在库存设置或项目中更新“限额”。
DocType: Support Settings,Auto close Issue after 7 days,7天后自动关闭问题
DocType: Supplier,Is Frozen,被冻结
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total weightage assigned should be 100%. It is {0},指定的总重量应为100％。它是{0}
apps/erpnext/erpnext/regional/italy/setup.py,"Applicable if the company is SpA, SApA or SRL",如果公司是SpA，SApA或SRL，则适用
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Overlapping conditions found between:,发现重叠条件：
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Paid and Not Delivered,付费和未付款
DocType: GST HSN Code,HSN Code,HSN代码
DocType: GSTR 3B Report,September,九月
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Administrative Expenses,行政费用
DocType: C-Form,C-Form No,C表格编号
DocType: Purchase Invoice,End date of current invoice's period,当前发票期限的结束日期
DocType: Item,Manufacturers,制造商
DocType: Crop Cycle,Crop Cycle,作物周期
DocType: Serial No,Creation Time,创作时间
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Please enter Approving Role or Approving User,请输入批准角色或批准用户
DocType: Inpatient Record,Discharged,出院
DocType: BOM,Raw Material Cost(Company Currency),原材料成本（公司货币）
apps/erpnext/erpnext/accounts/party.py,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),注意：到期/参考日期超过允许的客户信用天数{0}天
DocType: Email Digest,New Sales Orders,新的销售订单
apps/erpnext/erpnext/buying/report/purchase_analytics/purchase_analytics.js,based_on,基于
DocType: Employee,Owned,国有
DocType: Item Default,Item Default,项目默认
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Party can only be one of ,派对只能是其中之一
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Entertainment Expenses,业务招待费
DocType: Item,Inspection Required before Delivery,交货前需要检查
apps/erpnext/erpnext/regional/report/fichier_des_ecritures_comptables_[fec]/fichier_des_ecritures_comptables_[fec].py,Opening Entry Journal,开放日记
DocType: Purchase Taxes and Charges,Add or Deduct,添加或减少
DocType: POS Closing Voucher Details,Collected Amount,收集金额
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Commission on Sales,销售委员会
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.py,Start entering data from here : ,从这里开始输入数据：
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Rest Of The World,世界其他地区
apps/erpnext/erpnext/templates/pages/home.html,Publications,出版物
DocType: Salary Component Account,Default Bank / Cash account will be automatically updated in Salary Journal Entry when this mode is selected.,选择此模式后，默认银行/现金帐户将在薪资日记帐分录中自动更新。
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Total Budget,预算总额
DocType: Upload Attendance,Upload HTML,上传HTML
DocType: Bank Reconciliation Detail,Payment Document,付款文件
DocType: Opportunity Item,Opportunity Item,机会项目
DocType: Travel Itinerary,Travel From,旅行
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,CWIP Account,CWIP帐户
DocType: SMS Log,Sender Name,发件者姓名
DocType: Pricing Rule,Supplier Group,供应商组
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Set Start Time and End Time for  \
					Support Day {0} at index {1}.",在索引{1}处为\支持日{0}设置开始时间和结束时间。
DocType: Employee,Date of Issue,发行日期
,Requested Items To Be Transferred,要求转移的物品
DocType: Employee,Contract End Date,合同结束日期
DocType: Purchase Order Item,Returned Qty,退货数量
DocType: Sales Order,SAL-ORD-.YYYY.-,SAL-ORD-.YYYY.-
DocType: Delivery Note,Required only for sample item.,仅对样品项目是必需的。
DocType: Healthcare Service Unit,Vacant,空的
DocType: Opportunity,Sales Stage,销售阶段
DocType: Sales Order,In Words will be visible once you save the Sales Order.,保存销售订单后，将显示单词。
DocType: Item Reorder,Re-order Level,重新订购等级
DocType: Shift Type,Enable Auto Attendance,启用自动出勤
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Preference,偏爱
,Department Analytics,部门分析
DocType: Crop,Scientific Name,科学名称
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Discount amount cannot be greater than 100%,折扣金额不能超过100％
DocType: Student Guardian,Relation,关系
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py,Name or Email is mandatory,姓名或电子邮件是强制性的
DocType: Tax Rule,Billing Zipcode,计费邮编
apps/erpnext/erpnext/public/js/hub/marketplace.js,Marketplace,市井
apps/erpnext/erpnext/buying/utils.py,{0} {1} status is {2},{0} {1}状态为{2}
DocType: Quiz Activity,Quiz Activity,测验活动
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,{0} is not in a valid Payroll Period,{0}不在有效的工资核算期内
DocType: Timesheet,Billed,帐单
apps/erpnext/erpnext/config/support.py,Issue Type.,问题类型。
DocType: Restaurant Order Entry,Last Sales Invoice,上次销售发票
DocType: Payment Terms Template,Payment Terms,付款条件
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,"Reserved Qty: Quantity ordered for sale, but not delivered.",保留数量：订购销售但未交付的数量。
apps/erpnext/erpnext/accounts/page/pos/pos.js,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2},{0}是强制性的。可能没有为{1}到{2}创建货币兑换记录
DocType: Task,Actual End Date (via Time Sheet),实际结束日期（通过时间表）
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js,Score must be less than or equal to 5,分数必须小于或等于5
apps/erpnext/erpnext/controllers/buying_controller.py,Please select BOM in BOM field for Item {0},请在项目{0}的物料清单字段中选择物料清单
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} is under warranty upto {1},序列号{0}的保修期不超过{1}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Split,分裂
DocType: Bank Account,Bank Account No,银行账号
DocType: Payroll Entry,Salary Slip Based on Timesheet,基于时间表的工资单
DocType: Program Enrollment,Mode of Transportation,运输方式
DocType: Budget,Control Action,控制行动
DocType: Employee Tax Exemption Declaration,Total Exemption Amount,总豁免金额
DocType: Medical Code,Medical Code Standard,医疗守则标准
apps/erpnext/erpnext/controllers/buying_controller.py,Row #{0}: Reqd by Date cannot be before Transaction Date,行＃{0}：按日期要求不能在交易日期之前
DocType: Education Settings,Current Academic Term,目前的学期
DocType: Employee,Short biography for website and other publications.,网站和其他出版物的简短传记。
DocType: Purchase Invoice Item,Received Qty,收到了数量
DocType: Purchase Invoice Item,Rate (Company Currency),费率（公司货币）
DocType: Item Reorder,Request for,要求
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Installing presets,安装预设
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter Repayment Periods,请输入还款期限
DocType: Pricing Rule,Advanced Settings,高级设置
DocType: Payment Entry,Paid Amount,支付的金额
DocType: Setup Progress Action,Setup Progress Action,设置进度操作
DocType: Subscription Plan,Billing Interval Count,结算间隔计数
apps/erpnext/erpnext/public/js/financial_statements.js,Financial Statements,财务报表
DocType: Project,Message will sent to users to get their status on the project,将向用户发送消息以获取其在项目上的状态
DocType: Employee Tax Exemption Proof Submission Detail,Employee Tax Exemption Proof Submission Detail,员工免税证明提交细则
DocType: Purchase Order,Delivered,交付
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Delivered,已交付{0}％
DocType: Lead,Request for Information,索取资料
apps/erpnext/erpnext/accounts/report/consolidated_financial_statement/consolidated_financial_statement.js,End Year,结束一年
DocType: Vehicle,Diesel,柴油机
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,受制裁金额不能大于行{0}中的索赔金额。
apps/erpnext/erpnext/controllers/buying_controller.py,From {0} | {1} {2},从{0} | {1} {2}
apps/erpnext/erpnext/education/api.py,Result already Submitted,结果已提交
DocType: Pricing Rule Detail,Rule Applied,适用规则
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Actual Qty is mandatory,实际数量是强制性的
DocType: Purchase Order Item,Expected Delivery Date,预计交货日期
DocType: Issue,Resolution Date,解决日期
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave of type {0} cannot be longer than {1},{0}类型的保留时间不能超过{1}
DocType: Shopping Cart Settings,Enable Shopping Cart,启用购物车
DocType: Pricing Rule,Apply Rule On Other,在其他方面适用规则
DocType: Vehicle,Last Carbon Check,最后的碳检查
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Make,使
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,Sales Invoice {0} created as paid,销售发票{0}已创建为已付款
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,To create a Payment Request reference document is required,要创建付款申请参考文档是必需的
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Income Tax,所得税
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Computer,电脑
DocType: Material Request,% Ordered,％订购
apps/erpnext/erpnext/controllers/buying_controller.py,Following items {0} are not marked as {1} item. You can enable them as {1} item from its Item master,以下项{0}未标记为{1}项。您可以从项目主文件中将它们作为{1}项启用
DocType: Quiz,Passing Score,合格分数
apps/erpnext/erpnext/config/website.py,Settings for website homepage,网站主页的设置
DocType: Work Order,Qty To Manufacture,制造数量
apps/erpnext/erpnext/public/js/setup_wizard.js,Non Profit (beta),非盈利（测试版）
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Outstanding Amt,杰出的Amt
apps/erpnext/erpnext/templates/includes/cart/cart_address.html,Pin Code,PIN码
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,允许以下用户批准离开应用程序以用于阻止日期。
apps/erpnext/erpnext/assets/doctype/asset_maintenance_log/asset_maintenance_log.py,Please select Maintenance Status as Completed or remove Completion Date,请选择维护状态为已完成或删除完成日期
DocType: Production Plan,Get Items For Work Order,获取工作订单项目
apps/erpnext/erpnext/projects/doctype/project/project.js,Set Project and all Tasks to status {0}?,将项目和所有任务设置为状态{0}？
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",根据此仓库中的库存显示“有库存”或“无库存”。
apps/erpnext/erpnext/accounts/page/pos/pos.js,Delete permanently?,永久删除？
DocType: Blanket Order,MFG-BLR-.YYYY.-,MFG-BLR-.YYYY.-
DocType: Leave Type,Is Leave Without Pay,离开没有工资
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} must be submitted,行＃{0}：必须提交资产{1}
DocType: Purchase Invoice,Additional Discount Amount (Company Currency),额外折扣金额（公司货币）
DocType: Patient,Tobacco Past Use,烟草过去使用
DocType: Crop,Materials Required,所需材料
DocType: POS Profile,POS Profile,POS档案
DocType: Journal Entry,Write Off Entry,注销
apps/erpnext/erpnext/public/js/hub/marketplace.js,You need to be a user other than Administrator with System Manager and Item Manager roles to register on Marketplace.,您需要是具有System Manager和Item Manager角色的Administrator以外的用户才能在Marketplace上注册。
DocType: Asset,Insured value,保险价值
DocType: Quotation Item,Against Docname,反对Docname
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,"As raw materials projected quantity is more than required quantity, there is no need to create material request.
			Still if you want to make material request, kindly enable <b>Ignore Existing Projected Quantity</b> checkbox",由于原材料预计数量超过所需数量，因此无需创建物料申请。如果您想要提出物料请求，请启用<b>忽略现有预计数量</b>复选框
DocType: Packed Item,Prevdoc DocType,Prevdoc DocType
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py,{0} payment entries can not be filtered by {1},{0}付款条目无法按{1}过滤
DocType: Variant Field,Variant Field,变体字段
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,Access token or Shopify URL missing,访问令牌或Shopify URL丢失
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Bank account cannot be named as {0},银行帐户不能命名为{0}
DocType: Terms and Conditions,Terms and Conditions Help,条款和条件帮助
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,From and To dates required,从需要的日期和到期日
DocType: Production Plan Item,Product Bundle Item,产品捆绑项目
DocType: Student Group,Group Based On,基于的群体
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Mobile No,Guardian2手机号码
DocType: Manufacturing Settings,Allow Multiple Material Consumption,允许多种材料消耗
DocType: Item Quality Inspection Parameter,Acceptance Criteria,验收标准
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule only applicable for Selling,运输规则仅适用于销售
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Selling Rate,销售率
DocType: Account,Asset,财富
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} does not have a Healthcare Practitioner Schedule. Add it in Healthcare Practitioner master,{0}没有医疗从业者计划。将其添加到Healthcare Practitioner master中
DocType: Vehicle,Chassis No,底盘号
DocType: Employee,Default Shift,默认Shift
apps/erpnext/erpnext/public/js/setup_wizard.js,Company Abbreviation,公司缩写
apps/erpnext/erpnext/config/manufacturing.py,Tree of Bill of Materials,物料清单树
DocType: Article,LMS User,LMS用户
DocType: BOM,Allow Alternative Item,允许替代项目
apps/erpnext/erpnext/projects/doctype/activity_type/activity_type.js,Activity Cost per Employee,每位员工的活动成本
DocType: Email Digest,Open Quotations,打开报价单
DocType: Cash Flow Mapper,Section Footer,部分页脚
DocType: Lead,Next Contact By,下一个联系方式
apps/erpnext/erpnext/buying/report/subcontracted_item_to_be_received/subcontracted_item_to_be_received.py,Pending Quantity,待定数量
DocType: Quotation,SAL-QTN-.YYYY.-,SAL-QTN-.YYYY.-
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select to add Serial Number.,选择添加序列号。
apps/erpnext/erpnext/templates/includes/projects/project_tasks.html,modified,改性
DocType: Pricing Rule,Qty,数量
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Net ITC Available(A) - (B),净ITC可用（A） - （B）
,Material Requests for which Supplier Quotations are not created,未创建供应商报价的物料请求
DocType: GST Account,GST Account,GST账户
DocType: Pricing Rule,For Price List,价目表
DocType: GoCardless Mandate,GoCardless Mandate,GoCardless授权
DocType: Work Order,Skip Material Transfer to WIP Warehouse,跳过物料转移到WIP仓库
DocType: Cheque Print Template,Primary Settings,主要设置
DocType: Amazon MWS Settings,Customer Type,客户类型
DocType: Supplier Scorecard Period,PU-SSP-.YYYY.-,PU-SSP-.YYYY.-
DocType: POS Settings,Use POS in Offline Mode,在离线模式下使用POS
DocType: Territory,Parent Territory,家长地区
DocType: Vehicle Log,Odometer Reading,里程表阅读
DocType: Additional Salary,Salary Slip,工资单
DocType: Payroll Entry,Payroll Frequency,工资单频率
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}",开始和结束日期不在有效的工资核算期内，无法计算{0}
DocType: Products Settings,Home Page is Products,主页是产品
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Calls,呼叫
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference #{0} dated {1},参考编号{{0}的日期为{1}
DocType: Guardian Interest,Guardian Interest,守护者的兴趣
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,PO already created for all sales order items,已为所有销售订单项创建采购订单
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Subscription,订阅
DocType: Stock Entry Detail,Stock Entry Detail,股票详情
DocType: Email Digest,Sales Orders to Bill,比尔的销售订单
DocType: Company,For reference only.,仅供参考。
DocType: GL Entry,GL Entry,GL Entry
DocType: Employee Tax Exemption Category,Employee Tax Exemption Category,员工免税类别
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Row {0}: asset is required for item {1},行{0}：项{1}需要资产
DocType: Expense Claim Detail,Sanctioned Amount,制裁金额
DocType: Taxable Salary Slab,Taxable Salary Slab,应税薪资平板
DocType: Grant Application,Grant Application,拨款申请
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard.py,Unable to find score starting at {0}. You need to have standing scores covering 0 to 100,无法从{0}开始找到分数。你需要有0到100的常设分数
DocType: Fee Structure,EDU-FST-.YYYY.-,EDU-FST-.YYYY.-
DocType: Sales Person,Parent Sales Person,家长销售人员
DocType: Student Group Creation Tool,Get Courses,获得课程
apps/erpnext/erpnext/controllers/accounts_controller.py,"Row #{0}: Qty must be 1, as item is a fixed asset. Please use separate row for multiple qty.",行＃{0}：数量必须为1，因为项目是固定资产。请为多个数量使用单独的行。
DocType: Shift Type,Working hours below which Absent is marked. (Zero to disable),缺席的工作时间标记为缺席。 （零禁用）
DocType: Customer Group,Only leaf nodes are allowed in transaction,事务中只允许叶节点
DocType: Grant Application,Organization,组织
DocType: Fee Category,Fee Category,费用类别
DocType: Batch,Batch ID,批次ID
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot be a fixed asset item as Stock Ledger is created.,由于创建了Stock Ledger，因此无法成为固定资产项目。
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,This Month's Summary,本月总结
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: {1} {2} does not match with {3},行{0}：{1} {2}与{3}不匹配
apps/erpnext/erpnext/utilities/user_progress.py,Go to Suppliers,转到供应商
DocType: Payment Order,PMO-,PMO-
apps/erpnext/erpnext/templates/emails/training_event.html,Please update your status for this training event,请更新您的培训活动状态
DocType: Volunteer,Morning,早上
DocType: Quotation Item,Quotation Item,报价项目
apps/erpnext/erpnext/config/support.py,Issue Priority.,问题优先。
DocType: Journal Entry,Credit Card Entry,信用卡输入
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,"Time slot skiped, the slot {0} to {1} overlap exisiting slot {2} to {3}",时间段滑落，插槽{0}到{1}与现有插槽{2}重叠到{3}
DocType: Journal Entry Account,If Income or Expense,如果收入或费用
DocType: Work Order Operation,Work Order Operation,工作单操作
DocType: Accounts Settings,Address used to determine Tax Category in transactions.,用于确定交易中的税收类别的地址。
apps/erpnext/erpnext/utilities/user_progress.py,Go to Customers,转到客户
DocType: Student Group,Set 0 for no limit,设置0表示无限制
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Account {2} is inactive,{0} {1}：帐户{2}无效
DocType: Repayment Schedule,Payment Date,付款日期
DocType: Asset Maintenance Task,Assign To Name,分配给名称
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Warning: Material Requested Qty is less than Minimum Order Qty,警告：物料请求数量小于最小订单数量
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Current BOM and New BOM can not be same,当前BOM和新BOM不能相同
apps/erpnext/erpnext/config/agriculture.py,Crops & Lands,农作物和土地
apps/erpnext/erpnext/setup/doctype/company/company.py,Abbr can not be blank or space,Abbr不能为空或空格
DocType: Material Request,MAT-MR-.YYYY.-,MAT-MR-.YYYY.-
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot deliver Serial No {0} of item {1} as it is reserved to \
												fullfill Sales Order {2}",无法提供项目{1}的序列号{0}，因为它保留给\ fullfill销售订单{2}
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Fetching records......,获取记录......
DocType: Delivery Stop,Contact Information,联系信息
DocType: Sales Order Item,For Production,用于生产
DocType: Serial No,Asset Details,资产明细
DocType: Restaurant Reservation,Reservation Time,预订时间
DocType: Selling Settings,Default Territory,默认地区
DocType: Employee Benefit Application,Dispensed Amount (Pro-rated),分配金额（按比例分配）
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Max discount allowed for item: {0} is {1}%,项目允许的最大折扣：{0}为{1}％
DocType: Product Bundle,List items that form the package.,列出构成包的项目。
DocType: Payment Request,Amount in customer's currency,客户货币金额
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,从购买收据中获取商品
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row #{0} (Payment Table): Amount must be positive,行＃{0}（付款表）：金额必须为正数
DocType: Employee Tax Exemption Declaration,Employee Tax Exemption Declaration,员工免税声明
DocType: Project,Expected End Date,预计结束日期
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Conversion rate cannot be 0 or 1,转换率不能为0或1
DocType: Opportunity,CRM-OPP-.YYYY.-,CRM-OPP-.YYYY.-
apps/erpnext/erpnext/public/js/setup_wizard.js,Institute Name,学院名称
DocType: Serial No,Asset Status,资产状况
DocType: Salary Slip,Earnings,收益
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Total Paid Amount,总付费金额
apps/erpnext/erpnext/stock/doctype/batch/batch.js,To Warehouse,到仓库
DocType: Appraisal,Total Score (Out of 5),总分（满分5分）
DocType: Journal Entry,Accounts Receivable,应收账款
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting defaults,设置默认值
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
					Item {0} is added with and without Ensure Delivery by \
					Serial No.",无法通过序列号确保交货，因为\项目{0}是否添加了确保交货\序号。
,Invoiced Amount (Exclusive Tax),发票金额（独家税）
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Cannot change status as student {0} is linked with student application {1},由于学生{0}与学生申请{1}相关联，因此无法更改状态
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total leaves allocated is mandatory for Leave Type {0},保留类型{0}必须分配总叶数
apps/erpnext/erpnext/config/getting_started.py,Data Import and Settings,数据导入和设置
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"If Auto Opt In is checked, then the customers will be automatically linked with the concerned Loyalty Program (on save)",如果选中自动选择，则客户将自动与相关的忠诚度计划链接（保存时）
DocType: Account,Expense Account,费用帐户
DocType: Shift Type,The time before the shift start time during which Employee Check-in is considered for attendance.,在考虑员工入住的班次开始时间之前的时间。
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian1,与Guardian1的关系
apps/erpnext/erpnext/hotels/doctype/hotel_room_reservation/hotel_room_reservation.js,Create Invoice,创建发票
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Request already exists {0},付款申请已存在{0}
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Employee relieved on {0} must be set as 'Left',在{0}上解雇的员工必须设置为“离开”
apps/erpnext/erpnext/templates/pages/integrations/gocardless_checkout.py,Pay {0} {1},支付{0} {1}
DocType: Company,Sales Settings,销售设置
DocType: Sales Order Item,Produced Quantity,生产数量
apps/erpnext/erpnext/templates/emails/request_for_quotation.html,The request for quotation can be accessed by clicking on the following link,点击以下链接即可访问报价请求
DocType: Monthly Distribution,Name of the Monthly Distribution,每月分配的名称
DocType: Production Plan,Get Raw Materials For Production,获取生产原料
DocType: Employee,New Workplace,新工作场所
DocType: Support Search Source,API,API
apps/erpnext/erpnext/erpnext_integrations/doctype/shopify_settings/shopify_settings.py,"Missing value for Password, API Key or Shopify URL",缺少密码，API密钥或Shopify URL的值
DocType: Supplier Scorecard Scoring Variable,Parameter Name,参数名称
DocType: Request for Quotation,PUR-RFQ-.YYYY.-,PUR-RFQ-.YYYY.-
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Account {0} does not match with Company {1},帐户{0}与公司{1}不匹配
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select an item in the cart,请在购物车中选择一个项目
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Create Payment Entries,创建付款条目
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Select Company,选择公司
DocType: Material Request Plan Item,Material Request Type,材料申请类型
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Member ID,会员ID
DocType: Issue,Raised By (Email),提出者（电子邮件）
DocType: Employee Health Insurance,Employee Health Insurance,员工健康保险
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Application period cannot be outside leave allocation period,申请期限不能在假期分配期限内
DocType: Lab Test Template,"If unchecked, the item wont be appear in Sales Invoice, but can be used in group test creation. ",如果未选中，则该项目不会显示在“销售发票”中，但可以用于创建组测试。
DocType: Healthcare Settings,Registration Fee,注册费用
,Produced,生成
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,White,白色
DocType: Clinical Procedure,Procedure Template,程序模板
DocType: Account,Frozen,冻结的
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Price not found for item {0} in price list {1},价格表{1}中的商品{0}找不到价格
DocType: Student Admission,Publish on website,在网站上发布
apps/erpnext/erpnext/portal/doctype/homepage/homepage.py,This is an example website auto-generated from ERPNext,这是从ERPNext自动生成的示例网站
DocType: Accounts Settings,Unlink Payment on Cancellation of Invoice,取消发票时取消关联付款
apps/erpnext/erpnext/templates/pages/projects.html,No tasks,没有任务
DocType: Delivery Note,Print Without Amount,打印无金额
apps/erpnext/erpnext/config/buying.py,Purchase Orders given to Suppliers.,向供应商下达采购订单。
,Reserved,保留的
DocType: Employee,Notice (days),通知（天）
apps/erpnext/erpnext/config/help.py,Setting up Email Account,设置电子邮件帐户
DocType: Course Schedule,EDU-CSH-.YYYY.-,EDU-CSH-.YYYY.-
DocType: Contract,Unsigned,无符号
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,The day(s) on which you are applying for leave are holidays. You need not apply for leave.,您申请休假的日期是假期。你不需要申请休假。
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Could not submit some Salary Slips,无法提交一些薪资单
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} can not be deleted as quantity exists for Item {1},无法删除仓库{0}，因为项目{1}的数量存在
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,登陆成本购买收据
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Approve,批准
apps/erpnext/erpnext/hr/page/team_updates/team_updates.js,No more updates,没有更多的更新
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py,Leaves Allocated Successfully for {0},已成功为{0}分配了叶子
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Assessment Report,评估报告
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.",要在特定交易中不应用定价规则，应禁用所有适用的定价规则。
DocType: Company,Default Deferred Revenue Account,默认递延收入帐户
apps/erpnext/erpnext/config/non_profit.py,Donor information.,捐助者信息。
DocType: Authorization Rule,Customerwise Discount,客户折扣
DocType: Stock Ledger Entry,Outgoing Rate,外出率
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row",请至少在一行中选择分配金额，发票类型和发票编号
DocType: Asset Category,Asset Category Name,资产类别名称
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Receipt document must be submitted,必须提交收据文件
,Employee Advance Summary,员工进展摘要
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Detailed Reason,详细原因
apps/erpnext/erpnext/healthcare/setup.py,Low Sensitivity,灵敏度低
DocType: Authorization Rule,Applicable To (Designation),适用于（指定）
DocType: Tax Rule,Billing City,计费城市
DocType: Item,Is Customer Provided Item,是客户提供的项目
DocType: Purchase Invoice,Purchase Taxes and Charges Template,购买税和费用模板
DocType: Sales Invoice Item,Brand Name,品牌
DocType: Fee Schedule,Total Amount per Student,每位学生的总金额
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Apparel & Accessories,服饰与配饰
DocType: Compensatory Leave Request,Work From Date,从日期开始工作
apps/erpnext/erpnext/projects/doctype/project/project.py,Project Collaboration Invitation,项目合作邀请
DocType: Student Attendance Tool,Student Attendance Tool,学生出勤工具
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Prescribed Procedures,订明程序
apps/erpnext/erpnext/buying/doctype/supplier_scorecard_criteria/supplier_scorecard_criteria.py,Unable to find variable: ,无法找到变量：
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,PDC/LC Amount,PDC / LC金额
apps/erpnext/erpnext/public/js/hub/components/item_publish_dialog.js,Set Details,设置细节
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total claimed amount,预付总金额不得超过索赔总额
DocType: POS Item Group,Item Group,物品组
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js, Currently no stock available in any warehouse,目前在任何仓库中都没有库存
apps/erpnext/erpnext/utilities/user_progress.py,Upload your letter head (Keep it web friendly as 900px by 100px),上传你的信头（保持网络友好为900px 100px）
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Column must be blank,项目{0}未设置为序列号。列必须为空
DocType: Company,Default Values,默认值
apps/erpnext/erpnext/setup/doctype/company/company.js,Default tax templates for sales and purchase are created.,创建销售和采购的默认税收模板。
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leave Type {0} cannot be carry-forwarded,保留类型{0}不能转发
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Debit To account must be a Receivable account,借方到帐户必须是应收帐款
apps/erpnext/erpnext/support/doctype/service_level_agreement/service_level_agreement.py,End Date of Agreement can't be less than today.,协议的结束日期不能低于今天。
apps/erpnext/erpnext/stock/__init__.py,Please set Account in Warehouse {0} or Default Inventory Account in Company {1},请在仓库{0}中设置帐户或在公司{1}中设置默认库存帐户
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Set as Default,设为默认
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),这个包的净重。 （自动计算为物品净重的总和）
apps/erpnext/erpnext/stock/doctype/item_variant_settings/item_variant_settings.py,Cannot set the field <b>{0}</b> for copying in variants,无法将字段<b>{0}设置</b>为在变体中进行复制
DocType: Payment Term,Month(s) after the end of the invoice month,发票月结束后的月份
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,Get Employees,获得员工
DocType: Student,Leaving Certificate Number,离开证书编号
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js,Not Expired,没过期
DocType: Company,Unrealized Exchange Gain/Loss Account,未实现的交易所收益/亏损账户
DocType: Employee,Relieving Date,缓解日期
DocType: Plant Analysis,Plant Analysis Criterias,植物分析标准
DocType: Leave Block List Date,Leave Block List Date,保留阻止列表日期
DocType: Payment Entry,Receive,接收
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Relieving Date must be greater than Date of Joining,缓解日期必须大于加入日期
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Error: Not a valid id?,错误：不是有效的ID？
DocType: BOM Update Tool,"Replace a particular BOM in all other BOMs where it is used. It will replace the old BOM link, update cost and regenerate ""BOM Explosion Item"" table as per new BOM.
It also updates latest price in all the BOMs.",替换使用它的所有其他BOM中的特定BOM。它将替换旧的BOM链接，更新成本并根据新BOM重新生成“BOM Explosion Item”表。它还会更新所有物料清单中的最新价格。
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,"Company, Payment Account, From Date and To Date is mandatory",公司，付款帐户，从日期和到日期是强制性的
DocType: Sales Invoice Payment,Base Amount (Company Currency),基本金额（公司货币）
DocType: Sales Invoice Advance,Sales Invoice Advance,销售发票预付款
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Notify Customers via Email,通过电子邮件通知客户
DocType: Production Plan Item,Make Work Order for Sub Assembly Items,制作子装配件的工作订单
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Manager,经理
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Expired Batches,已过期批次
DocType: Shipping Rule,Shipping Rule Type,送货规则类型
DocType: Job Offer,Accepted,公认
apps/erpnext/erpnext/education/doctype/assessment_plan/assessment_plan.py,You have already assessed for the assessment criteria {}.,您已经评估了评估标准{}。
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Select Batch Numbers,选择批号
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py,Age (Days),年龄（天）
DocType: Student Batch Name,Batch Name,批名称
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Large,大
apps/erpnext/erpnext/controllers/accounts_controller.py,Accounting Entry for {0}: {1} can only be made in currency: {2},{0}的会计分录：{1}只能以货币进行：{2}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Reason for hold: ,暂停原因：
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Failed,费用创建失败
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Reorder Level,重新订购等级
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} '{1}' is disabled,{0}“{1}”已停用
DocType: Stock Ledger Entry,Actual Qty After Transaction,交易后的实际数量
DocType: Subscription,Cancel At End Of Period,在期末取消
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,Healthcare Service Unit Tree,医疗服务单位树
apps/erpnext/erpnext/config/buying.py,Bundle items at time of sale.,在销售时捆绑物品。
DocType: Payment Reconciliation Payment,Allocated Amount,分配金额
apps/erpnext/erpnext/hr/doctype/staffing_plan/staffing_plan.py,Please select Company and Designation,请选择公司和指定
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,'Date' is required,&#39;日期&#39;是必需的
DocType: Email Digest,Bank Credit Balance,银行信贷余额
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,Show Cumulative Amount,显示累计金额
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.py,You don't have enought Loyalty Points to redeem,您没有获得忠诚度积分兑换
DocType: Purchase Invoice,Additional DIscount Percentage,额外的DIscount百分比
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the name of the bank or lending institution before submittting.,在提交之前输入银行或贷款机构的名称。
apps/erpnext/erpnext/controllers/accounts_controller.py,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,警告：系统不会检查超额计费，因为{1}中的项目{0}的金额为零
apps/erpnext/erpnext/public/js/setup_wizard.js,Select your Domains,选择您的域名
DocType: Agriculture Task,Task Name,任务名称
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Stock Entries already created for Work Order ,已为工作订单创建的库存条目
apps/erpnext/erpnext/hr/doctype/employee_transfer/employee_transfer.py,"Please delete the Employee <a href=""#Form/Employee/{0}"">{0}</a>\
					to cancel this document","请删除员工<a href=""#Form/Employee/{0}"">{0}</a> \以取消此文档"
,Amount to Deliver,交付金额
apps/erpnext/erpnext/accounts/doctype/account/account.py,Company {0} does not exist,公司{0}不存在
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,No pending Material Requests found to link for the given items.,找不到要为给定项目链接的待处理物料请求。
apps/erpnext/erpnext/utilities/activation.py,"Students are at the heart of the system, add all your students",学生是系统的核心，添加所有学生
DocType: Company,Company Logo,公司标志
DocType: Content Question,Question Link,问题链接
DocType: HR Settings,Leave Approver Mandatory In Leave Application,请假申请人必须在休假申请中
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Add notes,添加备注
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} items found.,找到{0}个项目。
DocType: Patient,Personal and Social History,个人和社会历史
DocType: Maintenance Visit Purpose,Work Done,完成工作
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,"Setting Events to {0}, since the Employee attached to the below Sales Persons does not have a User ID{1}",将事件设置为{0}，因为附加到以下销售人员的员工没有用户ID {1}
DocType: Student Guardian,Father,父亲
,Purchase Order Items To Be Received,要收货的采购订单项目
apps/erpnext/erpnext/accounts/general_ledger.py,Debit and Credit not equal for {0} #{1}. Difference is {2}.,借方和贷方不等于{0}＃{1}。差异是{2}。
DocType: Marketplace Settings,Custom Data,自定义数据
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,保存采购订单后，将显示单词。
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Actual type tax cannot be included in Item rate in row {0},实际类型税不能包含在行{0}中的项目费率中
DocType: Lab Test Template,Compound,复合
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,客户货币转换为公司基础货币的比率
DocType: Lead,Converted,转换
DocType: Email Digest,New Income,新收入
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js,Retention Stock Entry already created or Sample Quantity not provided,已创建保留库存条目或未提供样品数量
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Vouchers,处理优惠券
apps/erpnext/erpnext/public/js/controllers/transaction.js,Please enter Item Code to get batch no,请输入物料代码以获得批号
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be before Service Start Date,服务停止日期不能早于服务开始日期
DocType: Employee Property History,Employee Property History,员工财产历史
,Requested Items To Be Ordered,要求的要求物品
DocType: Vital Signs,Blood Pressure (systolic),血压（收缩压）
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Leave Without Pay does not match with approved Leave Application records,离职无薪与批准的离职申请记录不符
DocType: Purchase Invoice Item,Expense Head,费用头
DocType: Employee,Reason for Resignation,辞职原因
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.js,Fetch Subscription Updates,获取订阅更新
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Paid amount + Write Off Amount can not be greater than Grand Total,已付金额+核销金额不能超过总金额
DocType: Asset Repair,Error Description,错误说明
DocType: Healthcare Practitioner,Out Patient Consulting Charge Item,出患者咨询费用项目
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,No replies from,没有回复
DocType: Shopify Settings,Sales Order Series,销售订单系列
DocType: Accounts Settings,Automatically Fetch Payment Terms,自动获取付款条款
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Cannot refer row number greater than or equal to current row number for this Charge type,对于此Charge类型，不能引用大于或等于当前行号的行号
apps/erpnext/erpnext/public/js/hub/components/reviews.js,Anonymous,匿名
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please select the Company,请选择公司
apps/erpnext/erpnext/accounts/page/pos/pos.js,"Master data syncing, it might take some time",主数据同步，可能需要一些时间
DocType: Leave Application,HR-LAP-.YYYY.-,HR-LAP-.YYYY.-
DocType: Item,Customer Items,客户项目
DocType: Program Enrollment,Enrolled courses,注册课程
DocType: Lab Prescription,Test Code,测试代码
DocType: Purchase Taxes and Charges,On Previous Row Total,在上一行总计
DocType: Student,Student Email Address,学生电邮地址
,Delayed Item Report,延迟物品报告
DocType: Academic Term,Education,教育
DocType: Supplier Quotation,Supplier Address,供应商地址
DocType: Salary Detail,Do not include in total,不包括总数
apps/erpnext/erpnext/stock/doctype/item/item.py,Cannot set multiple Item Defaults for a company.,无法为公司设置多个项目默认值。
apps/erpnext/erpnext/accounts/party.py,{0}: {1} does not exists,{0}：{1}不存在
DocType: Purchase Receipt Item,Rejected Quantity,拒绝数量
DocType: Cashier Closing,To TIme,到时间
DocType: Daily Work Summary Group User,Daily Work Summary Group User,每日工作摘要组用户
DocType: Fiscal Year Company,Fiscal Year Company,财年公司
apps/erpnext/erpnext/stock/doctype/item_alternative/item_alternative.py,Alternative item must not be same as item code,替代项目不得与项目代码相同
DocType: Payment Schedule,Payment Term,付款期限
DocType: Quality Action,Quality Review,质量审查
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,In Stock Qty,库存数量
DocType: Material Request Plan Item,Customer Provided,客户提供
apps/erpnext/erpnext/projects/doctype/task/task.py,Child Task exists for this Task. You can not delete this Task.,此任务存在子任务。您无法删除此任务。
DocType: Item,Inventory,库存
DocType: Supplier Scorecard Criteria,Criteria Name,标准名称
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Total Allocated Leaves,分配的总叶数
DocType: Chapter,Members,会员
DocType: Fees,Student Details,学生详情
DocType: Account,Fixed Asset,固定资产
DocType: Cheque Print Template,Has Print Format,有打印格式
DocType: Training Result Employee,Training Result Employee,培训结果员工
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account with child nodes cannot be set as ledger,具有子节点的帐户不能设置为分类帐
apps/erpnext/erpnext/config/buying.py,Purchase Order to Payment,采购订单付款
apps/erpnext/erpnext/agriculture/doctype/disease/disease.py,Start day is greater than end day in task '{0}',任务“{0}”中的开始日期大于结束日期
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Financing,融资净现金
DocType: Quiz,Enter 0 to waive limit,输入0以放弃限制
apps/erpnext/erpnext/accounts/doctype/cashier_closing/cashier_closing.py,From Time Should Be Less Than To Time,从时间应该少于时间
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Newspaper Publishers,报纸出版社
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Supplier is required against Payable account {2},{0} {1}：应付帐户{2}需要供应商
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Outstanding Cheques and Deposits to clear,优秀的支票和存款清理
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You can only have Plans with the same billing cycle in a Subscription,您只能在订阅中拥有具有相同结算周期的计划
DocType: Vehicle,Natural Gas,天然气
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Serial No {0} not found,未找到序列号{0}
DocType: Hub User,Hub Password,集线器密码
,Bank Reconciliation Statement,银行对账单
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Fixed Asset,固定资产净变动
DocType: Payment Request,Paid,付费
DocType: Maintenance Visit,Completion Status,完成状态
DocType: Job Card,Transferred Qty,转移数量
DocType: Healthcare Service Unit,Occupied,占据
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.js,Opening {0} Invoice created,打开{0}创建的发票
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to create website,无法创建网站
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.js,Opportunities by lead source,铅来源的机会
DocType: Grading Scale Interval,Grading Scale Interval,评分量表间隔
DocType: Education Settings,Instructor Records to be created by,要创建的教师记录
DocType: Student Report Generation Tool,Student Report Generation Tool,学生报告生成工具
apps/erpnext/erpnext/stock/doctype/batch/batch.js,View Ledger,查看Ledger
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",任何其他评论，值得注意的努力应该记录在案。
DocType: Travel Request,"Details of Sponsor (Name, Location)",赞助商详情（姓名，地点）
DocType: Project Task,Weight,重量
DocType: Staffing Plan Detail,Current Count,当前计数
DocType: Sales Team,Incentives,激励
DocType: Program Fee,Program Fee,课程费用
DocType: Delivery Settings,Delay between Delivery Stops,交货停止之间的延迟
DocType: Stock Settings,Freeze Stocks Older Than [Days],冷冻库存早于[天]
DocType: Promotional Scheme,Promotional Scheme Product Discount,促销计划产品折扣
apps/erpnext/erpnext/support/doctype/issue_priority/issue_priority.py,Issue Priority Already Exists,问题优先级已经存在
DocType: Account,Asset Received But Not Billed,已收到资产但尚未收费
DocType: POS Closing Voucher,Total Collected Amount,总收款金额
DocType: Course,Default Grading Scale,默认评分量表
DocType: POS Profile,Allow user to edit Discount,允许用户编辑折扣
DocType: POS Closing Voucher,Linked Invoices,关联的发票
DocType: Volunteer,Weekends,周末
DocType: Employee,Health Details,健康详情
DocType: Employee Education,Graduate,毕业
DocType: Asset Maintenance Task,Asset Maintenance Task,资产维护任务
DocType: Restaurant Order Entry,Restaurant Table,餐厅桌
DocType: Amazon MWS Settings,CN,CN
apps/erpnext/erpnext/restaurant/doctype/restaurant/restaurant.js,Order Entry,订单输入
DocType: Request for Quotation Supplier,Download PDF,下载PDF
DocType: Payment Entry,Unallocated Amount,未分配金额
DocType: Travel Itinerary,Rented Car,租来的车
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,On Hold,等候接听
DocType: Sales Invoice Timesheet,Sales Invoice Timesheet,销售发票时间表
DocType: Subscription,Plans,计划
DocType: Purchase Invoice Item,Landed Cost Voucher Amount,登陆成本凭证金额
DocType: Student Log,Medical,医
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Account {0} is frozen,帐户{0}已冻结
DocType: Project,First Email,第一封电邮
DocType: Supplier Scorecard,Criteria Setup,标准设置
DocType: Crop,Yield UOM,产量UOM
apps/erpnext/erpnext/healthcare/doctype/lab_test/lab_test.js,Lab Test Prescriptions,实验室测试处方
apps/erpnext/erpnext/hr/report/vehicle_expenses/vehicle_expenses.py,Service Expense,服务费用
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Reference No & Reference Date is required for {0},{0}需要参考号和参考日期
DocType: Salary Structure,Leave Encashment Amount Per Day,每天留下兑现金额
DocType: Student Admission Program,Naming Series (for Student Applicant),命名系列（适用于学生申请者）
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,As per section 17(5),根据第17（5）条
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} on {3} {4} for {5} to complete this transaction.,对于{5}，{3} {4} {2}需要{0}单位{1}才能完成此交易。
apps/erpnext/erpnext/accounts/doctype/payment_terms_template/payment_terms_template.py,Credit Days cannot be a negative number,信用日不能是负数
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,Same supplier has been entered multiple times,已多次输入相同的供应商
DocType: Customs Tariff Number,Tariff Number,关税号码
DocType: Plant Analysis Criteria,Maximum Permissible Value,最大允许值
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Received Stock Entries,收到的股票条目
DocType: Opportunity,Opportunity Amount,机会金额
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount,采购订单金额
DocType: C-Form,III,III
DocType: Contract,Fulfilment Terms,履行条款
apps/erpnext/erpnext/accounts/doctype/account/account.js,Non-Group to Group,非集团到集团
DocType: Student Guardian,Mother,母亲
DocType: Issue,Service Level Agreement Fulfilled,达成服务水平协议
DocType: Payroll Entry,Deduct Tax For Unclaimed Employee Benefits,为无人认领的员工福利扣除税款
DocType: Travel Request,Travel Funding,旅游资金
DocType: Shipping Rule,Fixed,固定
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,{0} ({1}) cannot be greater than planned quantity ({2}) in Work Order {3},{0}（{1}）不能大于工单{3}中的计划数量（{2}）
DocType: Quality Review,Additional Information,附加信息
DocType: Course Scheduling Tool,Reschedule,改期
apps/erpnext/erpnext/setup/doctype/company/company.py,Please select Existing Company for creating Chart of Accounts,请选择现有公司以创建会计科目表
apps/erpnext/erpnext/selling/page/sales_funnel/sales_funnel.py,Active Leads / Customers,活跃的潜在客户/客户
apps/erpnext/erpnext/templates/generators/item/item_configure.js,1 exact match.,1完全匹配。
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Sports,体育
DocType: Employee Advance,Claimed Amount,声明金额
DocType: Plant Analysis Criteria,Plant Analysis Criteria,植物分析标准
DocType: Fee Schedule,Send Payment Request Email,发送付款请求电子邮件
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,保存销售发票后，将显示单词。
DocType: Sales Invoice,Sales Team1,销售团队1
DocType: Work Order,Required Items,必填项目
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Read the ERPNext Manual,阅读ERPNext手册
DocType: Accounts Settings,Check Supplier Invoice Number Uniqueness,检查供应商发票编号唯一性
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Search Sub Assemblies,搜索子装配
DocType: Rename Tool,Type of document to rename.,要重命名的文档类型。
apps/erpnext/erpnext/utilities/activation.py,"Leads help you get business, add all your contacts and more as your leads",潜在客户可帮助您开展业务，添加所有联系人以及更多潜在客户
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Indirect Expenses,间接费用
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Internet Publishing,互联网出版
DocType: Customer,Account Manager,客户经理
DocType: Amazon MWS Settings,BR,BR
DocType: Item,Warranty Period (in days),保修期（天）
apps/erpnext/erpnext/utilities/page/leaderboard/leaderboard.js,No items found.,未找到任何项目。
DocType: Item Attribute,From Range,从范围
DocType: Clinical Procedure,Consumables,耗材
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,'employee_field_value' and 'timestamp' are required.,&#39;employee_field_value&#39;和&#39;timestamp&#39;是必需的。
DocType: Purchase Taxes and Charges,Reference Row #,参考行＃
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Please set 'Asset Depreciation Cost Center' in Company {0},请在公司{0}中设置“资产折旧成本中心”
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Payment document is required to complete the trasaction,行＃{0}：完成交易需要付款文件
DocType: Amazon MWS Settings,Click this button to pull your Sales Order data from Amazon MWS.,单击此按钮可从亚马逊MWS中提取销售订单数据。
DocType: Shift Type,Working hours below which Half Day is marked. (Zero to disable),工作时间低于标记的半天。 （零禁用）
,Assessment Plan Status,评估计划状态
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select {0} first,请先选择{0}
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,Submit this to create the Employee record,提交此内容以创建Employee记录
DocType: Item Attribute Value,"This will be appended to the Item Code of the variant. For example, if your abbreviation is ""SM"", and the item code is ""T-SHIRT"", the item code of the variant will be ""T-SHIRT-SM""",这将附加到变体的项目代码中。例如，如果您的缩写是“SM”，并且商品代码是“T-SHIRT”，则变体的商品代码将为“T-SHIRT-SM”
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please enter Delivery Date,请输入交货日期
DocType: Purchase Invoice Item,Quality Inspection,质量检验
DocType: Account,Root Type,根类型
DocType: Journal Entry,Write Off Based On,基于的注销
DocType: Lab Test,Report Preference,报告偏好
DocType: Products Settings,Products Settings,产品设置
DocType: Amazon MWS Settings,Synch Taxes and Charges,同步税和费用
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Total cannot be zero,总数不能为零
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Opening (Cr),开盘价（Cr）
DocType: Employee,Company Email,公司邮箱
DocType: Shopping Cart Settings,Show Stock Quantity,显示库存数量
DocType: Student,A-,一个-
apps/erpnext/erpnext/accounts/doctype/account/account.py,Account {0} is added in the child company {1},子公司{1}中添加了帐户{0}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Date Of Retirement must be greater than Date of Joining,退休日期必须大于加入日期
DocType: Restaurant Order Entry,Add Item,新增项目
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Sick Leave,病假
DocType: Lab Test,Lab Test,试验
DocType: Account,Accumulated Depreciation,累计折旧
DocType: Support Search Source,Source Type,来源类型
DocType: Department Approver,Department Approver,部门批准人
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Qty per BOM Line,每个BOM行数量
apps/erpnext/erpnext/controllers/buying_controller.py,Accepted + Rejected Qty must be equal to Received quantity for Item {0},接受+拒绝的数量必须等于项目{0}的已接收数量
apps/erpnext/erpnext/config/hr.py,Expense Claims,费用索赔
DocType: Bank Account,Address HTML,地址HTML
,Stock Projected Qty,股票预测数量
DocType: Employee Onboarding,Job Offer,工作机会
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,No Remarks,没有备注
DocType: Sales Invoice,Change Amount,变更金额
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Write Off Amount,注销金额
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items available for transfer,没有可供转让的物品
DocType: Work Order,Actual End Date,实际结束日期
DocType: Loyalty Point Entry,Loyalty Point Entry,忠诚度积分
DocType: Travel Itinerary,Train,培养
DocType: BOM Explosion Item,BOM Explosion Item,BOM爆炸物品
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Inward Supplies(liable to reverse charge,内向供应（可能反向充电
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,{0}: {1} not found in Invoice Details table,{0}：在“发票明细表”表中找不到{1}
DocType: Stock Entry,Total Incoming Value,总入会价值
apps/erpnext/erpnext/public/js/stock_analytics.js,Select Warehouse...,选择仓库......
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Type of Business,业务类型
apps/erpnext/erpnext/config/buying.py,All Addresses.,所有地址。
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,"Enabling 'Use for Shopping Cart', as Shopping Cart is enabled and there should be at least one Tax Rule for Shopping Cart",启用“用于购物车”，因为购物车已启用且购物车应至少有一个税收规则
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,Please select Course,请选择课程
DocType: Taxable Salary Slab,Percent Deduction,扣除百分比
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Quantity to Produce can not be less than Zero,生产数量不能少于零
DocType: Share Balance,To No,致不
DocType: Leave Control Panel,Allocate Leaves,分配叶子
DocType: Assessment Result,Student Name,学生姓名
apps/erpnext/erpnext/config/crm.py,Plan for maintenance visits.,计划维护访问。
apps/erpnext/erpnext/templates/emails/reorder_item.html,Following Material Requests have been raised automatically based on Item's re-order level,物料请求已根据物料的重新订购级别自动提出
DocType: Budget,Action if Accumulated Monthly Budget Exceeded on PO,PO的累计月度预算超过的行动
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Full-time,全职
DocType: Program Enrollment,Vehicle/Bus Number,车辆/巴士号码
DocType: Tax Rule,Purchase Tax Template,购买税模板
DocType: Production Plan,Material Request Planning,物料请求计划
DocType: UOM,Check this to disallow fractions. (for Nos),选中此选项可禁用分数。 （对于Nos）
DocType: Retention Bonus,Bonus Payment Date,奖金支付日期
DocType: BOM,Operating Cost,运营成本
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select Items based on Delivery Date,根据交货日期选择项目
DocType: Homepage,Tag Line,标语
DocType: Customer,From Lead,来自Lead
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Unclosed Fiscal Years Profit / Loss (Credit),未披露的财政年度盈亏（信贷）
DocType: Agriculture Analysis Criteria,Agriculture,农业
DocType: Quality Procedure,Parent Procedure,父程序
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Set Open,设置打开
apps/erpnext/erpnext/www/all-products/index.html,Toggle Filters,切换过滤器
DocType: Production Plan,Material Request Detail,材料要求详情
DocType: Shift Type,Process Attendance After,过程出勤
DocType: Material Request Item,Quantity and Warehouse,数量和仓库
apps/erpnext/erpnext/utilities/user_progress.py,Go to Programs,转到程序
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Row #{0}: Duplicate entry in References {1} {2},行＃{0}：引用{1}中的重复条目{2}
DocType: Loyalty Point Entry,Loyalty Program,忠诚计划
DocType: Lost Reason Detail,Opportunity Lost Reason,机会失去理智
apps/erpnext/erpnext/regional/italy/setup.py,Applicable if the company is a limited liability company,适用于公司是有限责任公司的情况
DocType: Patient,"Allergies, Medical and Surgical History",过敏，医学和外科史
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Capital Stock,股本
DocType: Share Transfer,From Folio No,来自Folio No.
apps/erpnext/erpnext/templates/pages/order.js,Pay Remaining,支付剩余
apps/erpnext/erpnext/accounts/page/pos/pos.js,Search Item,搜索项目
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Total Leaves,总叶数
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update rate as per last purchase,根据上次购买更新率
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please select a table,请选择一张桌子
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} is blocked so this transaction cannot proceed,{0}被阻止，因此无法继续执行此事务
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items From,从中获取物品
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,"Loyalty Points will be calculated from the spent done (via the Sales Invoice), based on collection factor mentioned.",忠诚度积分将根据所花费的完成量（通过销售发票）计算得出。
DocType: Setup Progress Action,Min Doc Count,Min Doc Count
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} must be a non-stock item,项目{0}必须是非库存项目
apps/erpnext/erpnext/accounts/doctype/account/account.js,Merge Account,合并帐户
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Convert to Group,转换为组
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,"Already set default in pos profile {0} for user {1}, kindly disabled default",已经为用户{1}的pos个人资料{0}设置了默认值，默认情况下已禁用
DocType: Fiscal Year,Companies,公司
,Minutes to First Response for Opportunity,第一次机会响应的会议纪要
DocType: Hotel Room Amenity,Hotel Room Amenity,酒店房间设施
apps/erpnext/erpnext/config/selling.py,Invoices for Costumers.,客户发票。
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.js,No Staffing Plans found for this Designation,没有为此指定找到人员配置计划
DocType: BOM Update Tool,Current BOM,当前BOM
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Casual Leave,休假
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Cost Updated,成本更新
apps/erpnext/erpnext/accounts/doctype/loyalty_program/loyalty_program.js,One customer can be part of only single Loyalty Program.,一个客户只能参与一个忠诚度计划。
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Cannot cancel transaction for Completed Work Order.,无法取消已完成工单的交易。
DocType: Grant Application,Grant Application Details ,授予申请详情
DocType: Purchase Invoice,Apply Additional Discount On,应用额外折扣
,Sales Partner Commission Summary,销售合作伙伴佣金摘要
apps/erpnext/erpnext/controllers/selling_controller.py,Order Type must be one of {0},订单类型必须是{0}之一
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Payment Entry already exists,付款条目已存在
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,No Work Orders created,没有创建工作订单
DocType: Assessment Plan,Grading Scale,分级量表
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Marketing Expenses,营销费用
apps/erpnext/erpnext/crm/doctype/lead/lead.py,Next Contact Date cannot be in the past,下一个联系日期不能过去
DocType: Shopify Settings,Webhooks Details,Webhooks详细信息
DocType: Authorization Rule,Authorization Rule,授权规则
apps/erpnext/erpnext/config/non_profit.py,Volunteer Type information.,志愿者类型信息。
DocType: Naming Series,This is the number of the last created transaction with this prefix,这是具有此前缀的上次创建的事务的编号
DocType: Supplier Scorecard,Indicator Color,指示灯颜色
DocType: Item Variant Settings,Copy Fields to Variant,将字段复制到Variant
DocType: Soil Texture,Sandy Loam,桑迪壤土
DocType: Question,Single Correct Answer,单一正确答案
apps/erpnext/erpnext/hr/utils.py,From date can not be less than employee's joining date,从日期开始不能少于员工的加入日期
DocType: Selling Settings,Allow multiple Sales Orders against a Customer's Purchase Order,允许针对客户的采购订单的多个销售订单
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,PDC/LC,PDC / LC
DocType: Purchase Taxes and Charges,"If checked, the tax amount will be considered as already included in the Print Rate / Print Amount",如果选中，则税额将被视为已包含在打印率/打印金额中
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py,Date is repeated,日期重复
DocType: Pricing Rule,Party Information,党的信息
apps/erpnext/erpnext/shopping_cart/cart.py,Debtors ({0}),债务人（{0}）
apps/erpnext/erpnext/hr/utils.py,To date can not greater than employee's relieving date,迄今为止不能超过员工的解除日期
DocType: Shift Type,Enable Exit Grace Period,启用退出宽限期
DocType: Expense Claim,Employees Email Id,员工电子邮件ID
DocType: Shopify Settings,Update Price from Shopify To ERPNext Price List,更新价格从Shopify到ERPNext价目表
DocType: Healthcare Settings,Default Medical Code Standard,默认医疗法规标准
DocType: Woocommerce Settings,Tax Account,税务帐户
apps/erpnext/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.py,Total Paid Amt,总付费金额
DocType: BOM,Website Specifications,网站规格
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"From a supplier under composition scheme, Exempt and Nil rated",来自组成计划下的供应商，免税和零评级
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,"Do you want to update attendance?<br>Present: {0}\
					<br>Absent: {1}",你想更新出勤率吗？ <br>现在：{0} \ <br>缺席：{1}
DocType: Leave Control Panel,Employee (optional),员工（可选）
DocType: Purchase Invoice,Supplier Invoice Details,供应商发票明细
apps/erpnext/erpnext/healthcare/doctype/patient/patient.py,Customer {0} is created.,客户{0}已创建。
DocType: Company,Default Cost of Goods Sold Account,商品销售帐户的默认成本
apps/erpnext/erpnext/accounts/utils.py,{0} Number {1} already used in account {2},{0}帐户{2}中已使用的号码{1}
DocType: Mode of Payment Account,Default Account,默认帐户
DocType: Purchase Invoice,Disable Rounded Total,禁用圆形总计
DocType: Contract,Signee,签署人
apps/erpnext/erpnext/crm/doctype/contract/contract.py,End Date cannot be before Start Date.,结束日期不能早于开始日期。
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with existing transaction can not be converted to group.,具有现有交易的仓库无法转换为组。
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Both Warehouse must belong to same Company,两个仓库必须属于同一公司
DocType: Maintenance Visit Purpose,Against Document Detail No,反对文件细节
apps/erpnext/erpnext/public/js/queries.js,Please set {0},请设置{0}
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Please select prefix first,请先选择前缀
apps/erpnext/erpnext/config/buying.py,Managing Subcontracting,管理转包
DocType: Activity Cost,Projects User,项目用户
DocType: Supplier Scorecard Variable,Supplier Scorecard Variable,供应商记分卡变量
DocType: Item Group,Item Group Name,物料组名称
DocType: Budget,Applicable on Material Request,适用于材料申请
DocType: Support Settings,Search APIs,搜索API
DocType: Manufacturing Settings,Overproduction Percentage For Sales Order,销售订单的生产过剩百分比
DocType: Purchase Invoice,Supplied Items,提供的物品
DocType: Leave Control Panel,Select Employees,选择员工
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Select interest income account in loan {0},贷款中选择利息收入账户{0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,All items have already been transferred for this Work Order.,已为此工作订单转移所有项目。
DocType: Certification Application,Payment Details,付款详情
apps/erpnext/erpnext/config/settings.py,Printing and Branding,印刷和品牌
DocType: Item Group,HTML / Banner that will show on the top of product list.,将显示在产品列表顶部的HTML /横幅。
,Sales Payment Summary,销售付款摘要
DocType: Salary Component,Is Flexible Benefit,灵活的好处
DocType: GST Account,IGST Account,IGST账户
DocType: Shopping Cart Settings,Checkout Settings,结帐设置
apps/erpnext/erpnext/regional/italy/utils.py,Please set Fiscal Code for the customer '%s',请为客户&#39;％s&#39;设置财务代码
DocType: Monthly Distribution,**Monthly Distribution** helps you distribute the Budget/Target across months if you have seasonality in your business.,**如果您的业务有季节性，每月分发**可帮助您在几个月内分配预算/目标。
DocType: Guardian,Students,学生们
apps/erpnext/erpnext/hr/doctype/vehicle_log/vehicle_log.py,Expense Claim {0} already exists for the Vehicle Log,车辆日志已存在费用索赔{0}
DocType: Salary Component,"If selected, the value specified or calculated in this component will not contribute to the earnings or deductions. However, it's value can be referenced by other components that can be added or deducted. ",如果选中，则此组件中指定或计算的值将不会对收入或扣减产生影响。但是，它的值可以由可以添加或扣除的其他组件引用。
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Please enter repayment Amount,请输入还款金额
DocType: Sales Invoice,Is Opening Entry,正在开放
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Set New Release Date,设置新发布日期
DocType: Account,Expenses Included In Valuation,估值中包含的费用
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Serial Numbers,序列号
DocType: Salary Slip,Deductions,扣除
,Supplier-Wise Sales Analytics,供应商智慧销售分析
DocType: GSTR 3B Report,February,二月
DocType: Appraisal,For Employee,对于员工
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Actual Delivery Date,实际交货日期
DocType: Sales Partner,Sales Partner Name,销售伙伴名称
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Depreciation Start Date is entered as past date,折旧行{0}：折旧开始日期作为过去日期输入
DocType: GST HSN Code,Regional,区域性
DocType: Lead,Lead is an Organization,领导是一个组织
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please select Charge Type first,请先选择费用类型
DocType: Purchase Receipt Item,Accepted Quantity,接受数量
DocType: Amazon MWS Settings,DE,DE
apps/erpnext/erpnext/templates/pages/product_search.html,Search Results,搜索结果
DocType: Item Default,Default Buying Cost Center,默认购买成本中心
DocType: Production Plan,Include Non Stock Items,包括非库存商品
DocType: Student,AB+,AB +
DocType: Upload Attendance,Upload Attendance,上传出勤
DocType: Drug Prescription,Drug Code,药品代码
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,Please enable Applicable on Booking Actual Expenses,请启用适用于预订实际费用
apps/erpnext/erpnext/accounts/report/account_balance/account_balance.js,Chargeble,Chargeble
DocType: Purchase Order,Supply Raw Materials,供应原料
,Item-wise Price List Rate,按项目定价的价格表
DocType: Purchase Invoice Item,BOM,BOM
DocType: Quality Inspection,Readings,阅读
apps/erpnext/erpnext/accounts/deferred_revenue.py,Error while processing deferred accounting for {0},处理{0}的延迟记帐时出错
apps/erpnext/erpnext/regional/italy/utils.py,Please set either the Tax ID or Fiscal Code on Company '%s',请在公司&#39;％s&#39;上设置税号或财务代码
apps/erpnext/erpnext/public/js/utils.js,Add Serial No,添加序列号
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Selling Rate,平均。销售率
DocType: Payment Request,payment_url,payment_url
DocType: Delivery Note,Excise Page Number,消费税页码
,Sales Partner Target Variance based on Item Group,销售合作伙伴基于项目组的目标差异
DocType: Stock Settings,Naming Series Prefix,命名系列前缀
DocType: BOM Operation,Workstation,工作站
DocType: Employee Boarding Activity,Task Weight,任务重量
apps/erpnext/erpnext/public/js/utils.js,Annual Billing: {0},年度结算：{0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,You cannot delete Fiscal Year {0}. Fiscal Year {0} is set as default in Global Settings,您无法删除会计年度{0}。在“全局设置”中将会计年度{0}设置为默认值
apps/erpnext/erpnext/public/js/pos/pos.html,No Customers yet!,还没有顾客！
DocType: Company,Enable Perpetual Inventory,启用永久库存
DocType: Opportunity,Potential Sales Deal,潜在的销售交易
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js,Excise Invoice,消费税发票
DocType: Supplier Scorecard,Supplier Scorecard,供应商记分卡
DocType: Travel Itinerary,Travel To,前往
apps/erpnext/erpnext/education/doctype/student_attendance_tool/student_attendance_tool.js,Mark Attendance,马克出勤
DocType: Shift Type,Determine Check-in and Check-out,确定登记入住和退房
DocType: POS Closing Voucher,Difference,区别
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Small,小
DocType: Work Order Item,Work Order Item,工单项目
apps/erpnext/erpnext/accounts/report/sales_payment_summary/sales_payment_summary.py,Sales and Returns,销售和退货
DocType: Budget,Monthly Distribution,每月分配
DocType: Quality Action,Quality Action,质量行动
DocType: Work Order,Work-in-Progress Warehouse,在制品仓库
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Dividends Paid,支付的股息
DocType: Program Enrollment Tool,New Academic Year,新学年
DocType: Sales Person,Name and Employee ID,姓名和员工ID
DocType: Subscription,Generate Invoice At Beginning Of Period,在期初生成发票
DocType: Item,Minimum Order Qty,最低订单数量
DocType: Leave Block List,Block Holidays on important days.,在重要日子节假日。
apps/erpnext/erpnext/public/js/conf.js,Documentation,文档
DocType: Item Alternative,Alternative Item Code,替代物品代码
DocType: Sales Partner,Partner website,伙伴网站
DocType: Loan,Applicant,申请人
DocType: Lab Test Template,"Single for results which require only a single input, result UOM and normal value 
<br>
Compound for results which require multiple input fields with corresponding event names, result UOMs and normal values
<br>
Descriptive for tests which have multiple result components and corresponding result entry fields. 
<br>
Grouped for test templates which are a group of other test templates.
<br>
No Result for tests with no results. Also, no Lab Test is created. e.g.. Sub Tests for Grouped results.",单个结果只需要一个输入，结果是UOM和正常值<br>复合结果需要多个输入字段和相应的事件名称，结果UOM和正常值<br>描述具有多个结果组件和相应结果输入字段的测试。 <br>为测试模板分组，测试模板是一组其他测试模板。 <br>没有结果的测试没有结果。此外，没有创建实验室测试。例如。子测试分组结果。
apps/erpnext/erpnext/accounts/general_ledger.py,Please mention Round Off Cost Center in Company,请提及公司的Round Off Cost Center
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Delivery Notes {0} must be cancelled before cancelling this Sales Order,在取消此销售订单之前，必须取消交货单{0}
DocType: Grant Application,Show on Website,在网站上显示
DocType: Sales Invoice,Shipping Address Name,送货地址名称
apps/erpnext/erpnext/healthcare/setup.py,Drug,药物
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is closed,{0} {1}已关闭
DocType: Patient,Medical History,医学史
DocType: Expense Claim,Expense Taxes and Charges,费用税和费用
DocType: Subscription Settings,Number of days after invoice date has elapsed before canceling subscription or marking subscription as unpaid,取消订阅或将订阅标记为未付款之前已过去发票日期的天数
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Installation Note {0} has already been submitted,安装说明{0}已提交
DocType: Patient Relation,Family,家庭
DocType: Work Order Operation,Updated via 'Time Log',通过&#39;时间日志&#39;更新
DocType: Quality Inspection,Sample Size,样本量
DocType: Journal Entry,Reference Number,参考编号
DocType: UOM Conversion Detail,UOM Conversion Detail,UOM转换细节
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Opening Accumulated Depreciation must be less than equal to {0},开仓累计折旧必须小于等于{0}
DocType: Antibiotic,Antibiotic Name,抗生素名称
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,"Only the Student Applicant with the status ""Approved"" will be selected in the table below.",只有在下表中选择状态为“已批准”的学生申请人。
DocType: Task,% Progress,％进展
DocType: UOM Category,UOM Category,UOM类别
apps/erpnext/erpnext/config/help.py,Publish Items on Website,在网站上发布项目
DocType: Chapter,Meetup Embed HTML,Meetup嵌入HTML
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js,Please select Party Type first,请先选择派对类型
DocType: Loan,Repayment Start Date,还款开始日期
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py,Not authroized since {0} exceeds limits,由于{0}超出限制，因此未经过授权
DocType: Procedure Prescription,Procedure Created,程序已创建
,Serial No Warranty Expiry,序列号无保修期限
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Against Supplier Invoice {0} dated {1},针对{1}的供应商发票{0}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Change POS Profile,更改POS档案
apps/erpnext/erpnext/utilities/activation.py,Create Lead,创造领导力
DocType: Shopify Settings,Default Customer,默认客户
DocType: Payment Entry Reference,Supplier Invoice No,供应商发票号
DocType: Pricing Rule,Mixed Conditions,混合条件
DocType: Woocommerce Settings,"This is the default UOM used for items and Sales orders. The fallback UOM is ""Nos"".",这是用于商品和销售订单的默认UOM。后备UOM是“不”。
DocType: Payment Request,Mute Email,静音电子邮件
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 2,第2项
apps/erpnext/erpnext/config/accounting.py,Tax Withholding rates to be applied on transactions.,税收预扣税率适用于交易。
DocType: Dosage Strength,Strength,强度
apps/erpnext/erpnext/stock/stock_ledger.py,{0} units of {1} needed in {2} to complete this transaction.,{2}中需要{0}单位{1}才能完成此交易。
DocType: Buying Settings,Backflush Raw Materials of Subcontract Based On,基于PLC的转包反冲原料
DocType: Education Settings,"If enabled, field Academic Term will be Mandatory in Program Enrollment Tool.",如果启用，则在学期注册工具中，字段学术期限将是强制性的。
DocType: Education Settings,"For Batch based Student Group, the Student Batch will be validated for every Student from the Program Enrollment.",对于基于批处理的学生组，将从计划注册中为每个学生验证学生批处理。
DocType: Course,Topics,话题
apps/erpnext/erpnext/stock/doctype/item/item.py,Row #{0}: Please set reorder quantity,行＃{0}：请设置重新订购数量
DocType: Crop Cycle,Linked Location,链接的位置
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Batch number is mandatory for Item {0},项目{0}必须有批号
apps/erpnext/erpnext/accounts/party.py,Not permitted for {0},{0}不允许
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} {1} is fully billed,{0} {1}已完全结算
DocType: Payment Request,Inward,向内的
apps/erpnext/erpnext/templates/pages/help.html,See All Articles,查看所有文章
DocType: Bank Reconciliation Detail,Payment Entry,付款条目
DocType: Payment Request,Recipient Message And Payment Details,收件人消息和付款细节
DocType: Payment Terms Template Detail,Payment Terms Template Detail,付款方式模板细节
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Select Quantity,选择数量
DocType: Student Attendance,Student Attendance,学生出勤
DocType: Stock Settings,Automatically Set Serial Nos based on FIFO,根据FIFO自动设置序列号
,Available Qty,可用数量
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Get Invoices based on Filters,根据过滤器获取发票
DocType: Operation,Default Workstation,默认工作站
DocType: Salary Slip,Salary Structure,薪酬结构
DocType: Products Settings,Enable Attribute Filters,启用属性过滤器
DocType: Member,Non Profit Member,非营利成员
DocType: Material Request Plan Item,Material Request Plan Item,物料申请计划项目
DocType: Holiday List,Add to Holidays,加入假期
apps/erpnext/erpnext/controllers/status_updater.py,Limit Crossed,限制交叉
DocType: Company,Transactions Annual History,交易年历
DocType: Company,Delete Company Transactions,删除公司交易
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,To State,国家
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Department Stores,百货商店
DocType: Healthcare Service Unit,Inpatient Occupancy,住院病人入住率
apps/erpnext/erpnext/controllers/accounts_controller.py,Row {0}: Due Date cannot be before posting date,行{0}：截止日期不能在截止日期之前
apps/erpnext/erpnext/restaurant/doctype/restaurant_order_entry/restaurant_order_entry.py,Please set default customer in Restaurant Settings,请在“餐厅设置”中设置默认客户
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py, Group Roll No,集团卷号
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,Please specify a valid Row ID for row {0} in table {1},请为表{1}中的行{0}指定有效的行ID
DocType: Asset Movement,To Employee,对员工
DocType: Item,End of Life,生命尽头
DocType: Lab Test Template,Sensitivity,灵敏度
DocType: Territory,Territory Targets,领土目标
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,"Skipping Leave Allocation for the following employees, as Leave Allocation records already exists against them. {0}",跳过以下员工的休假分配，因为已经存在针对他们的休假分配记录。 {0}
DocType: Quality Action Resolution,Quality Action Resolution,质量行动决议
DocType: Sales Invoice Item,Delivered By Supplier,由供应商提供
DocType: Agriculture Analysis Criteria,Plant Analysis,植物分析
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Expense account is mandatory for item {0},项目{0}必须有费用帐户
,Subcontracted Raw Materials To Be Transferred,分包原材料将被转让
DocType: Cashier Closing,Cashier Closing,收银员关闭
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Item {0} has already been returned,已返回项{0}
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! The input you've entered doesn't match the GSTIN format for UIN Holders or Non-Resident OIDAR Service Providers,GSTIN无效！您输入的输入与UIN持有人或非居民OIDAR服务提供商的GSTIN格式不符
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Child warehouse exists for this warehouse. You can not delete this warehouse.,这个仓库存在子仓库。您无法删除此仓库。
DocType: Diagnosis,Diagnosis,诊断
apps/erpnext/erpnext/hr/doctype/compensatory_leave_request/compensatory_leave_request.py,There is no leave period in between {0} and {1},{0}和{1}之间没有休假期
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,{0} Budget for Account {1} against {2} {3} is {4}. It will exceed by {5},{0}针对{2} {3}的帐户{1}的预算为{4}。它将超过{5}
DocType: Purchase Invoice Item,Asset Location,资产位置
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Please enter Difference Account,请输入差异账户
DocType: Journal Entry,Total Credit,总学分
DocType: Certified Consultant,Name of Consultant,顾问姓名
DocType: Driver,License Number,许可证号码
DocType: Program Enrollment Tool,Program Enrollment Tool,计划注册工具
DocType: Amazon MWS Settings,US,我们
DocType: Sales Order,Track this Sales Order against any Project,跟踪任何项目的销售订单
DocType: QuickBooks Migrator,Authorization Settings,授权设置
DocType: Homepage,Products,制品
,Profit and Loss Statement,损益表
apps/erpnext/erpnext/hotels/report/hotel_room_occupancy/hotel_room_occupancy.py,Rooms Booked,预订客房
apps/erpnext/erpnext/stock/doctype/item_manufacturer/item_manufacturer.py,Duplicate entry against the item code {0} and manufacturer {1},项目代码{0}和制造商{1}的重复输入
DocType: Item Barcode,EAN,EAN
DocType: Purchase Invoice Item,Total Weight,总重量
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Travel,旅行
,Stock Ledger,股票分类账
DocType: Volunteer,Volunteer Name,志愿者姓名
apps/erpnext/erpnext/regional/india/utils.py,Invalid GSTIN! First 2 digits of GSTIN should match with State number {0}.,GSTIN无效！ GSTIN的前2位数字应与州号{0}匹配。
DocType: Quality Inspection,Report Date,报告日期
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js,Create Inter Company Journal Entry,创建国际公司日记帐分录
apps/erpnext/erpnext/manufacturing/report/bom_stock_report/bom_stock_report.py,Enough Parts to Build,足够的零件来建造
DocType: Member,NPO-MEM-.YYYY.-,NPO-MEM-.YYYY.-
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py,Cost of Issued Items,已发行物品的成本
apps/erpnext/erpnext/education/doctype/grading_scale/grading_scale.py,Treshold {0}% appears more than once,阈值{0}％出现多次
DocType: Chapter,Chapter Members,章节成员
DocType: Warranty Claim,Service Address,服务地址
DocType: Journal Entry,Remark,备注
DocType: Patient Encounter,Encounter Time,遇到时间
DocType: Serial No,Invoice Details,发票明细
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,"Further accounts can be made under Groups, but entries can be made against non-Groups",可以在“组”下进行进一步的帐户，但可以针对非组进行输入
apps/erpnext/erpnext/public/js/pos/pos.html,Stock Items,库存物品
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Row {0}# Allocated amount {1} cannot be greater than unclaimed amount {2},行{0}＃分配的金额{1}不能大于无人认领的金额{2}
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Reqd Qty,需要数量
DocType: Vital Signs,Body Temperature,体温
DocType: Customer Group,Customer Group Name,客户组名称
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Total allocated leaves are more than days in the period,在此期间，已分配的总分钟数超过天数
DocType: Homepage Section,Section Cards,部分卡片
apps/erpnext/erpnext/config/selling.py,Rules for adding shipping costs.,添加运费的规则。
DocType: Item Price,Valid From,有效来自
DocType: Travel Itinerary,Preferred Area for Lodging,住宿的首选区域
DocType: Student Attendance,Absent,缺席
DocType: Global Defaults,Hide Currency Symbol,隐藏货币符号
DocType: Additional Salary,Overwrite Salary Structure Amount,覆盖薪资结构金额
DocType: Supplier Quotation,Is Subcontracted,是分包合同
apps/erpnext/erpnext/hr/doctype/employee_loan_application/employee_loan_application.py,Loan Amount cannot exceed Maximum Loan Amount of {0},贷款金额不能超过{0}的最大贷款金额
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,BOM does not contain any stock item,BOM不包含任何库存项目
DocType: Employee Skill Map,Employee Skill Map,员工技能图
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Marketing,营销
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Not allowed to change Supplier as Purchase Order already exists,行＃{0}：不允许更改供应商，因为采购订单已存在
DocType: Item,Maximum sample quantity that can be retained,可保留的最大样品数量
DocType: Staffing Plan,Total Estimated Budget,预算总预算
DocType: Supplier Scorecard Scoring Standing,Standing Name,常备名称
DocType: Education Settings,Validate Enrolled Course for Students in Student Group,为学生组中的学生验证注册课程
apps/erpnext/erpnext/hr/doctype/salary_structure_assignment/salary_structure_assignment.py,From Date {0} cannot be after employee's relieving Date {1},从员工的解除日期{1}起，日期{0}不能生效
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,"The total Issue / Transfer quantity {0} in Material Request {1}  \
							cannot be greater than requested quantity {2} for Item {3}",物料请求{1} \中的总发货/转移数量{0}不能大于物料{3}的请求数量{2}
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_declaration/employee_tax_exemption_declaration.js,Please select {0},请选择{0}
DocType: Selling Settings,Default Customer Group,默认客户组
DocType: Journal Entry Account,Debit in Company Currency,借记公司货币
DocType: Woocommerce Settings,"The fallback series is ""SO-WOO-"".",后备系列是“SO-WOO-”。
DocType: Quality Meeting Agenda,Quality Meeting Agenda,质量会议议程
DocType: Cash Flow Mapper,Section Header,部分标题
apps/erpnext/erpnext/utilities/user_progress.py,Your Products or Services,您的产品或服务
DocType: Crop,Perennial,多年生
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Freight and Forwarding Charges,运费和货运费
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Last Purchase Price,上次购买价格
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Tax Assets,税收资产
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"If selected Pricing Rule is made for 'Rate', it will overwrite Price List. Pricing Rule rate is the final rate, so no further discount should be applied. Hence, in transactions like Sales Order, Purchase Order etc, it will be fetched in 'Rate' field, rather than 'Price List Rate' field.",如果为“费率”选择了定价规则，它将覆盖价格表。定价规则费率是最终费率，因此不应再适用折扣。因此，在销售订单，采购订单等交易中，它将在“费率”字段中提取，而不是“价格列表费率”字段。
DocType: Share Balance,Share Type,分享类型
DocType: Agriculture Analysis Criteria,Soil Analysis,土壤分析
DocType: Water Analysis,Water Analysis Criteria,水分析标准
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Note: Total allocated leaves {0} shouldn't be less than already approved leaves {1} for the period,注意：分配的总分配{0}不应小于该期间已批准的叶{1}
DocType: Salary Component,Deduction,扣除
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,You cannot restart a Subscription that is not cancelled.,您无法重新启动未取消的订阅。
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Employee Advances,员工进步
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Provisional Profit / Loss (Credit),临时损益（信贷）
DocType: Employee Tax Exemption Category,Max Exemption Amount,最高免税额
DocType: Timesheet,TS-.YYYY.-,TS-.YYYY.-
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,Different UOM for items will lead to incorrect (Total) Net Weight value. Make sure that Net Weight of each item is in the same UOM.,项目的不同UOM将导致不正确的（总计）净重值。确保每个项目的净重在同一个UOM中。
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Supplier Quotation,供应商报价
DocType: Item,Auto re-order,自动重新订购
DocType: Expense Claim,Total Advance Amount,总预付金额
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Row #{0}: Clearance date {1} cannot be before Cheque Date {2},行＃{0}：清除日期{1}不能在检查日期{2}之前
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Can only make payment against unbilled {0},只能对未开单的{0}付款
DocType: BOM,Thumbnail,缩略图
DocType: Production Plan Item,Planned Qty,计划数量
DocType: Tax Withholding Category,Rates,价格
DocType: Asset,Journal Entry for Scrap,期刊报道废料
DocType: GL Entry,Voucher Detail No,优惠券详细信息
apps/erpnext/erpnext/stock/doctype/item/item.py,Variant Based On cannot be changed,Variant Based On无法更改
DocType: Task,Review Date,审核日期
DocType: Crop,Biennial,双年展
DocType: Woocommerce Settings,Endpoints,端点
DocType: Subscription Plan Detail,Plan,计划
DocType: Employee Education,Year of Passing,传递的年份
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py,Total Tax,总税
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter default currency in Company Master,请在公司主文件中输入默认货币
DocType: Tally Migration,Processed Files,已处理的文件
DocType: Leave Type,Is Earned Leave,获得休假
DocType: Support Search Source,Search Term Param Name,搜索术语参数名称
DocType: Sales Invoice,Time Sheets,时间表
DocType: Installation Note,Installation Time,安装时间
apps/erpnext/erpnext/config/buying.py,Templates of supplier scorecard variables.,供应商记分卡变量的模板。
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.",购买，出售或库存的产品或服务。
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Closing (Opening + Total),结束（开盘+总计）
DocType: Supplier Scorecard Criteria,Criteria Formula,标准公式
apps/erpnext/erpnext/config/support.py,Support Analytics,支持分析
DocType: Employee,Attendance Device ID (Biometric/RF tag ID),考勤设备ID（生物识别/ RF标签ID）
apps/erpnext/erpnext/config/quality_management.py,Review and Action,审查和行动
DocType: Account,"If the account is frozen, entries are allowed to restricted users.",如果帐户被冻结，则允许条目限制用户。
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Amount After Depreciation,折旧后的金额
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Import Master Data,导入主数据
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} must be active,BOM {0}必须处于活动状态
,GST Sales Register,GST销售登记
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Supplier Invoice Date cannot be greater than Posting Date,供应商发票日期不能大于过账日期
apps/erpnext/erpnext/utilities/activation.py,Manage your orders,管理您的订单
DocType: Supplier Scorecard,Notify Supplier,通知供应商
,GSTR-2,GSTR-2
DocType: Sales Invoice,Credit Note Issued,发行信用票据
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_dashboard.py,This covers all scorecards tied to this Setup,这涵盖了与此安装程序相关的所有记分卡
DocType: Payment Order,Payment Order Type,付款订单类型
DocType: Account,Parent Account,家长帐户
DocType: Maintenance Visit,Unscheduled,未计划
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js,Issue Material,发行材料
DocType: Work Order,Use Multi-Level BOM,使用多级BOM
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Qty for {0},{0}的数量
DocType: Salary Slip,Loan Repayment,偿还借款
DocType: Employee Education,Major/Optional Subjects,主要/选修科目
DocType: Soil Texture,Silt,淤泥
apps/erpnext/erpnext/config/buying.py,Supplier Addresses And Contacts,供应商地址和联系方式
DocType: Bank Guarantee,Bank Guarantee Type,银行担保类型
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction",如果禁用，则在任何事务中都不会显示“Rounded Total”字段
DocType: Pricing Rule,Min Amt,Min Amt
apps/erpnext/erpnext/healthcare/doctype/healthcare_service_unit/healthcare_service_unit.js,This is a root healthcare service unit and cannot be edited.,这是根医疗服务单位，无法编辑。
apps/erpnext/erpnext/regional/italy/setup.py,Set this if the customer is a Public Administration company.,如果客户是公共管理公司，请设置此项。
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Max benefits should be greater than zero to dispense benefits,最大利益应大于零以分配利益
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Work Order # {3}. Please update operation status via Job Card # {4},行＃{0}：对于工作订单＃{3}中的{2}数量的成品，操作{1}未完成。请通过工作卡＃{4}更新运营状态
DocType: Production Plan Item,Planned Start Date,计划开始日期
apps/erpnext/erpnext/assets/doctype/asset/asset.js,Asset Maintenance,资产维护
DocType: Lead,Interested,有兴趣
DocType: Purchase Invoice,Net Total (Company Currency),净总额（公司货币）
DocType: Salary Component,Depends on Payment Days,取决于付款日
DocType: Subscription,Taxes,税
DocType: Bank Account,Bank Account,银行账户
DocType: Homepage Section,Section HTML,部分HTML
DocType: Sales Invoice,Packed Items,打包物品
apps/erpnext/erpnext/accounts/doctype/promotional_scheme/promotional_scheme.py,New {0} pricing rules are created,创建新的{0}定价规则
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/item_group_wise_sales_target_variance.py,Achieved ({}),达到（{}）
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Investment Banking,投资银行
DocType: Contract Template,Contract Terms and Conditions,合同条款和条件
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Fetch Data,获取数据
DocType: Stock Settings,Default Item Group,默认项目组
DocType: Sales Invoice Timesheet,Billing Hours,结算时间
apps/erpnext/erpnext/education/doctype/student_leave_application/student_leave_application.py,Leave application {0} already exists against the student {1},针对学生{1}已经存在申请{0}
DocType: Pricing Rule,Margin Type,保证金类型
DocType: Purchase Invoice Item,Rejected Serial No,拒绝序列号
DocType: Stock Reconciliation Item,Current Amount,当前金额
apps/erpnext/erpnext/config/retail.py,Setup default values for POS Invoices,设置POS发票的默认值
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost as on,成本一样
apps/erpnext/erpnext/config/projects.py,Project Update.,项目更新。
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Type is mandatory,根类型是必需的
apps/erpnext/erpnext/setup/utils.py,Unable to find exchange rate for {0} to {1} for key date {2}. Please create a Currency Exchange record manually,关键日期{2}无法找到{0}到{1}的汇率。请手动创建货币兑换记录
apps/erpnext/erpnext/controllers/website_list_for_contact.py,{0}% Billed,已结算{0}％
DocType: Purchase Invoice,Overdue,过期的
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,从给定数量的原材料制造/重新包装后获得的项目数量
DocType: Opening Invoice Creation Tool Item,Opening Invoice Creation Tool Item,打开发票创建工具项
DocType: Soil Analysis,(Ca+Mg)/K,（钙+镁）/ K
DocType: Bank Reconciliation,Include POS Transactions,包括POS交易
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,No Employee found for the given employee field value. '{}': {},找不到给定员工字段值的员工。 &#39;{}&#39;：{}
DocType: Payment Entry,Received Amount (Company Currency),收到金额（公司货币）
apps/erpnext/erpnext/accounts/page/pos/pos.js,"LocalStorage is full, did not save",LocalStorage已满，没有保存
DocType: Chapter Member,Chapter Member,章成员
DocType: Certified Consultant,Certification Validity,认证有效性
DocType: Share Transfer,Asset Account,资产帐户
apps/erpnext/erpnext/accounts/report/delivered_items_to_be_billed/delivered_items_to_be_billed.py,Suplier,Suplier
DocType: POS Closing Voucher Details,POS Closing Voucher Details,POS结算凭证详情
DocType: Patient Medical Record,HLC-PMR-.YYYY.-,HLC-PMR-.YYYY.-
DocType: Delivery Settings,Delivery Settings,交货设置
DocType: Email Digest,Receivables,应收账款
DocType: Crop,Annual,全年
DocType: Item Tax Template Detail,Tax Rate,税率
DocType: Patient Encounter,Medical Coding,医疗编码
DocType: Purchase Invoice,Total Quantity,总数（量
DocType: Asset,Comprehensive Insurance,综合保险
DocType: Purchase Invoice Item,Quantity and Rate,数量和费率
DocType: Employee Benefit Claim,Max Amount Eligible,最高金额符合条件
DocType: Salary Slip,Employee Loan,员工贷款
DocType: Payment Entry,Account Paid To,帐户支付给
DocType: Lab Test Template,Single,单
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Customer required for 'Customerwise Discount',客户要求“客户折扣”
DocType: Purchase Invoice,Advance Payments,预付款
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,"Cannot ensure delivery by Serial No as \
				Item {0} is added with and without Ensure Delivery by \
				Serial No.",无法通过序列号确保交货，因为\项目{0}是否添加了确保交货\序号。
DocType: Inpatient Record,Discharge Date,出院日期
,Open Work Orders,打开工作订单
DocType: Crop Cycle,List of diseases detected on the field. When selected it'll automatically add a list of tasks to deal with the disease ,在田间检测到的疾病清单。选择后，它会自动添加一个任务列表来处理疾病
DocType: SMS Center,All Lead (Open),全铅（开放）
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,No Student Groups created.,没有创建学生组。
apps/erpnext/erpnext/utilities/transaction_base.py,Duplicate row {0} with same {1},具有相同{1}的重复行{0}
DocType: Employee,Salary Details,薪资明细
DocType: Employee Checkin,Exit Grace Period Consequence,退出宽限期后果
DocType: Bank Statement Transaction Invoice Item,Invoice,发票
DocType: Special Test Items,Particulars,细节
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Please set filter based on Item or Warehouse,请根据项目或仓库设置过滤器
DocType: Bank Statement Transaction Invoice Item,Outstanding Amount,优秀金额
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py,Transactions can only be deleted by the creator of the Company,交易只能由公司的创建者删除
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,"For 'Product Bundle' items, Warehouse, Serial No and Batch No will be considered from the 'Packing List' table. If Warehouse and Batch No are same for all packing items for any 'Product Bundle' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.",对于“产品包”项目，将从“装箱单”表中考虑仓库，序列号和批号。如果任何“产品包”项目的所有包装项目的仓库和批次编号相同，则可以在主项目表中输入这些值，将值复制到“装箱单”表。
DocType: Lab Test,Submitted Date,提交日期
DocType: Delivery Settings,Send with Attachment,发送附件
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Account {0} does not exists,帐户{0}不存在
DocType: BOM Item,BOM No,物料清单编号
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,Avg Daily Outgoing,平均每日外出
DocType: Patient,Allergies,过敏
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order/Quot %,订单/报价％
DocType: Delivery Note,Transporter Info,运输者信息
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.py,Please select the assessment group other than 'All Assessment Groups',请选择“所有评估组”以外的评估组
DocType: Leave Encashment,Payroll,工资表
DocType: POS Closing Voucher,Expense Amount,费用金额
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Received On,收到了
DocType: Travel Itinerary,Flight,飞行
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,降落成本税和费用
apps/erpnext/erpnext/hr/utils.py,More than one selection for {0} not allowed,不允许对{0}进行多次选择
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Equity,股权净变动
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Leaves has been granted sucessfully,叶子已经成功获得
DocType: Loyalty Point Entry,Expiry Date,到期日
DocType: Project Task,Working,工作
apps/erpnext/erpnext/quality_management/doctype/quality_procedure/quality_procedure.py,{0} already has a Parent Procedure {1}.,{0}已有父程序{1}。
apps/erpnext/erpnext/healthcare/doctype/patient/patient_dashboard.py,This is based on transactions against this Patient. See timeline below for details,这是基于针对该患者的交易。请参阅下面的时间表了解详情
DocType: Material Request,Requested For,请求
DocType: SMS Center,All Sales Person,所有销售人员
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Please set default account in Salary Component {0},请在薪酬组件{0}中设置默认帐户
apps/erpnext/erpnext/www/all-products/not_found.html,No products found,没有找到产品
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Reserved Qty for Production: Raw materials quantity to make manufacturing items.,生产保留数量：生产制造项目的原材料数量。
apps/erpnext/erpnext/accounts/doctype/account/account_tree.js,Optional. This setting will be used to filter in various transactions.,可选的。此设置将用于过滤各种交易。
DocType: Stock Entry,Target Warehouse Address,目标仓库地址
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Outward taxable supplies(zero rated),外向应税物资（零评级）
DocType: Sales Invoice,Customer Address,客户地址
DocType: Leave Allocation,HR-LAL-.YYYY.-,HR-LAL-.YYYY.-
apps/erpnext/erpnext/assets/doctype/asset_movement/asset_movement.py,Asset {0} does not belong to company {1},资产{0}不属于公司{1}
apps/erpnext/erpnext/utilities/user_progress.py,Room Capacity,房间容量
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a batch,请选择批次
apps/erpnext/erpnext/stock/doctype/item/item.js,Select Attribute Values,选择属性值
DocType: Cheque Print Template,Signatory Position,签署职位
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Party Type and Party is required for Receivable / Payable account {1},行{0}：应收帐款/应付帐款{1}需要派对类型和派对
apps/erpnext/erpnext/config/manufacturing.py,Production,生产
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Failed to setup post company fixtures,无法设置公司后装置
apps/erpnext/erpnext/config/support.py,Communication log.,通讯日志。
DocType: Purchase Invoice Item,Enable Deferred Expense,启用延期费用
DocType: Purchase Order,Customer Contact Email,客户联系电邮
DocType: Clinical Procedure Template,Collection Details,收集细节
DocType: Stock Entry Detail,Stock Entry Child,股票入境儿童
DocType: Request for Quotation Supplier,No Quote,没有报价
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Sorry, Serial Nos cannot be merged",对不起，序列号不能合并
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_dashboard.py,This is based on transactions against this Sales Person. See timeline below for details,这是基于针对此销售人员的交易。请参阅下面的时间表了解详情
DocType: Course Content,Quiz,测验
DocType: Sales Invoice Item,Delivered Qty,交付数量
DocType: Material Request Plan Item,Minimum Order Quantity,最小起订量
DocType: Supplier Scorecard Scoring Standing,Warn Purchase Orders,警告采购订单
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,允许提交超过信用额度设置的交易的角色。
DocType: Employee Boarding Activity,Activity Name,活动名称
DocType: Item Barcode,UPC-A,UPC-A
DocType: Shopify Webhook Detail,Shopify Webhook Detail,Shopify Webhook详细信息
apps/erpnext/erpnext/templates/includes/cart/cart_items.html,Variant Of,变种
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse is mandatory for row {0},第{0}行必须使用目标仓库
apps/erpnext/erpnext/config/support.py,Warranty,保证
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian2 Email ID,Guardian2电子邮件ID
DocType: Expense Claim Detail,Expense Claim Type,费用索赔类型
DocType: Email Digest,Bank Balance,银行存款余额
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",定价规则基于某些标准覆盖价格清单/定义折扣百分比。
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Customer Group is Required in POS Profile,POS配置文件中需要客户组
DocType: Authorization Rule,Applicable To (Employee),适用于（员工）
DocType: Tally Migration,Day Book Data,日簿数据
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.py,Gross Profit / Loss,毛利润/亏损
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Credit Note Amount,信用票据金额
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Payment,付款
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Capacity Planning Error,容量规划错误
DocType: Supplier,Prevent POs,防止PO
DocType: QuickBooks Migrator,Authorization Endpoint,授权端点
DocType: Payment Gateway Account,Payment Gateway Account,支付网关帐户
,BOM Variance Report,BOM差异报告
apps/erpnext/erpnext/utilities/activation.py,Add the rest of your organization as your users. You can also add invite Customers to your portal by adding them from Contacts,将您组织的其余部分添加为您的用户。您还可以通过从“联系人”添加邀请客户来将其添加到门户中
DocType: Training Event,Employee Emails,员工电子邮件
DocType: Travel Request,Any other details,任何其他细节
DocType: Patient,Inpatient Status,住院状况
apps/erpnext/erpnext/hr/doctype/loan/loan.js,Create Repayment Entry,创建还款条目
apps/erpnext/erpnext/hr/utils.py,A {0} exists between {1} and {2} (,{1}和{2}之间存在{0}（
DocType: BOM,Scrap,废料
DocType: Clinical Procedure,Clinical Procedure,临床程序
DocType: Supplier,Hold Type,保持类型
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.js,Process Day Book Data,处理日书数据
DocType: Fee Validity,Fee Validity,费用有效期
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Create Fees,创造费用
DocType: Cheque Print Template,Date Settings,日期设置
DocType: BOM Operation,Operation Time,操作时间
DocType: Asset,Value After Depreciation,折旧后的价值
apps/erpnext/erpnext/projects/doctype/project/project.py,Start date of task <b>{0}</b> cannot be less than <b>{1}</b> expected start date <b>{2}</b>,任务<b>{0}的</b>开始日期不能小于<b>{1}</b>预期开始日期<b>{2}</b>
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Remaining,剩余
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Lead Count,铅计数
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of your company for which you are setting up this system.,您要为其设置此系统的公司名称。
DocType: Serial No,Out of AMC,走出AMC
DocType: Job Opening,"Job profile, qualifications required etc.",工作简介，要求的资格等
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Ship To State,送到州
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Do you want to submit the material request,您要提交材料申请吗？
DocType: Opportunity Item,Basic Rate,基本费率
DocType: Compensatory Leave Request,Work End Date,工作结束日期
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Request for Raw Materials,原材料申请
apps/erpnext/erpnext/config/quality_management.py,Quality Goal.,质量目标。
apps/erpnext/erpnext/templates/pages/projects.js,Show Open,显示打开
DocType: Item Attribute,Attribute Name,属性名称
apps/erpnext/erpnext/config/non_profit.py,Donor Type information.,捐赠者类型信息。
DocType: Supplier,Is Transporter,是运输车
DocType: Loan Type,Maximum Loan Amount,最高贷款金额
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email not found in default contact,默认联系人中找不到电子邮件
DocType: Hotel Room Reservation,Booked,预订
DocType: Maintenance Visit,Partially Completed,部分完成
DocType: Quality Procedure Process,Process Description,进度解析
DocType: Company,Default Employee Advance Account,默认员工预付帐户
DocType: Leave Type,Allow Negative Balance,允许负余额
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Assessment Plan Name,评估计划名称
DocType: Supplier,Default Payment Terms Template,默认付款条款模板
apps/erpnext/erpnext/stock/dashboard/item_dashboard.js,Add more items or open full form,添加更多项目或打开完整表格
apps/erpnext/erpnext/hr/doctype/daily_work_summary/daily_work_summary.py,Work Summary for {0},{0}的工作摘要
DocType: Academic Term,Academic Term,学术期限
DocType: Pricing Rule,Quantity and Amount,数量和金额
DocType: Stock Entry,Target Warehouse Name,目标仓库名称
DocType: Employee Tax Exemption Declaration Category,Maximum Exempted Amount,最高豁免金额
DocType: Stock Settings,Sample Retention Warehouse,样本保留仓库
DocType: Pricing Rule,Discount Percentage,折扣百分比
DocType: Company,Company Description,公司介绍
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Item {1},序列号{0}不属于项{1}
DocType: Work Order,Scrap Warehouse,废料仓库
apps/erpnext/erpnext/config/non_profit.py,Chapter information.,章节信息。
apps/erpnext/erpnext/hr/utils.py,) for {0},）{0}
DocType: Sales Invoice Item,References,参考
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Reserved Qty,保留数量
DocType: Shift Assignment,Shift Type,班次类型
DocType: Delivery Stop,Delivery Stop,交货停止
apps/erpnext/erpnext/education/doctype/assessment_result_tool/assessment_result_tool.js,No Result to submit,没有结果要提交
DocType: Loyalty Program,Redemption,赎回
DocType: Material Request,Transferred,转移
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} has fee validity till {1},{0}的费用有效期至{1}
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,All Student Admissions,所有学生入学
DocType: Travel Request,Address of Organizer,主办单位地址
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,"Values of exempt, nil rated and non-GST inward supplies",豁免，零税率和非商品及服务税内向供应的价值
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,在取消此销售订单之前，必须取消维护访问{0}
DocType: Quotation Item,Stock Balance,库存余额
DocType: Delivery Note Item,Available Qty at From Warehouse,From Warehouse的可用数量
DocType: Stock Entry,Repack,改装
DocType: UOM,Must be Whole Number,必须是整数
apps/erpnext/erpnext/selling/doctype/customer/customer.py,Credit limit has been crossed for customer {0} ({1}/{2}),客户{0}已超过信用额度（{1} / {2}）
apps/erpnext/erpnext/accounts/page/pos/pos.js,Submitted orders can not be deleted,提交的订单无法删除
apps/erpnext/erpnext/hr/notification/training_feedback/training_feedback.html,Hello,你好
DocType: Vehicle Service,Change,更改
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py,Activity Cost exists for Employee {0} against Activity Type - {1},员工{0}对活动类型的活动成本 -  {1}
DocType: Request for Quotation Item,Request for Quotation Item,要求报价项目
apps/erpnext/erpnext/accounts/doctype/item_tax_template/item_tax_template.py,{0} entered twice in Item Tax,{0}在项目税中输入两次
DocType: Additional Salary,Deduct Full Tax on Selected Payroll Date,在选定的工资日期扣除全额税
apps/erpnext/erpnext/hr/doctype/vehicle/vehicle.py,Last carbon check date cannot be a future date,最后的碳检查日期不能是未来的日期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Select change amount account,选择更改金额帐户
DocType: Support Settings,Forum Posts,论坛帖子
DocType: Timesheet Detail,Expected Hrs,预期的Hrs
DocType: Subscription Plan,Payment Plan,付款计划
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Earliest,最早
DocType: Program Enrollment Tool,Enroll Students,注册学生
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py,Repeat Customer Revenue,重复客户收入
DocType: Company,Date of Commencement,毕业日期
DocType: Bank,Bank Name,银行名
DocType: GSTR 3B Report,December,十二月
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Valid from date must be less than valid upto date,从日期开始有效必须低于最新有效期
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,This is based on the attendance of this Employee,这是基于该员工的出席情况
DocType: Products Settings,"If checked, the Home page will be the default Item Group for the website",如果选中，则主页将成为网站的默认项目组
DocType: Crop,Row Spacing UOM,行间距UOM
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Only Leave Applications with status 'Approved' and 'Rejected' can be submitted,只能提交状态为“已批准”和“已拒绝”的应用程序
apps/erpnext/erpnext/stock/doctype/item_price/item_price.js,Import in Bulk,批量导入
DocType: Material Request,Terms and Conditions Content,条款和条件内容
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Amount(Company Currency),采购订单金额（公司货币）
DocType: Healthcare Practitioner,Hospital,医院
,Stock Analytics,股票分析
apps/erpnext/erpnext/controllers/selling_controller.py,Selling rate for item {0} is lower than its {1}. Selling rate should be atleast {2},商品{0}的销售价格低于其{1}。销售率至少应为{2}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Application of Funds (Assets),资金（资产）的应用
apps/erpnext/erpnext/config/buying.py,Templates of supplier standings.,供应商排名模板。
DocType: Patient,HLC-PAT-.YYYY.-,HLC-PAT-.YYYY.-
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.js,Grant,格兰特
apps/erpnext/erpnext/stock/get_item_details.py,Price List Currency not selected,价格表货币未选中
DocType: Salary Slip,Total in words,单词总数
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.",如果启用，系统将自动过帐库存的会计分录。
DocType: BOM Item,BOM Item,BOM项目
DocType: Maintenance Schedule Detail,Scheduled Date,约定的日期
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please enter Maintaince Details first,请先输入Maintaince Details
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.js,Projected Quantity Formula,预计数量公式
DocType: Supplier Scorecard Scoring Standing,Supplier Scorecard Scoring Standing,供应商记分卡评分站
apps/erpnext/erpnext/regional/italy/utils.py,Row {0}: Please set the correct code on Mode of Payment {1},行{0}：请在付款方式{1}上设置正确的代码
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,"Maximum benefit of employee {0} exceeds {1} by the sum {2} of previous claimed\
			amount",员工{0}的最高福利金额超过{1}以前申请的金额的金额{2}
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Employee status cannot be set to 'Left' as following employees are currently reporting to this employee:&nbsp;,员工状态不能设置为“左”，因为以下员工当前正在向此员工报告：
DocType: BOM Explosion Item,Source Warehouse,源仓库
apps/erpnext/erpnext/utilities/user_progress.py,Add Users,添加用户
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.js,Payment Tems,付款方式
DocType: SMS Center,All Sales Partner Contact,所有销售伙伴联系人
apps/erpnext/erpnext/controllers/trends.py,Total(Amt),总（AMT）
DocType: Bank Statement Transaction Invoice Item,Payment Description,付款说明
apps/erpnext/erpnext/accounts/page/pos/pos.js,ZIP Code,邮政编码
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.js,Accumulated Values,累计值
DocType: Grading Scale,Intervals,间隔
apps/erpnext/erpnext/hr/doctype/training_program/training_program_dashboard.py,Training Events,培训活动
DocType: Production Plan Item,Quantity and Description,数量和描述
DocType: Payment Entry,Payment Type,支付方式
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The folio numbers are not matching,对开的数字不匹配
DocType: C-Form,ACC-CF-.YYYY.-,ACC-CF-.YYYY.-
apps/erpnext/erpnext/controllers/stock_controller.py,Quality Inspection: {0} is not submitted for the item: {1} in row {2},质量检验：项目未提交{0}：行{2}中的{1}
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.js,Show {0},显示{0}
apps/erpnext/erpnext/templates/generators/item/item_configure.js,{0} item found.,找到{0}项。
,Stock Ageing,股票老龄化
DocType: Customer Group,Mention if non-standard receivable account applicable,如果非标准应收账款适用，请提及
,Subcontracted Item To Be Received,要转包的分包物品
DocType: Item,Synced With Hub,与Hub同步
apps/erpnext/erpnext/hr/utils.py,To date can not be less than from date,迄今为止不能少于约会
DocType: Guardian,Work Address,工作地址
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Total completed qty can not be greater than for quantity,完成的总数量不能大于数量
DocType: POS Item Group,POS Item Group,POS物品组
DocType: Homepage,Company Description for website homepage,网站主页的公司描述
,Delivery Note Trends,交货单趋势
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,"Stopped Production Order cannot be cancelled, Unstop it first to cancel",已停止的生产订单无法取消，请先停止取消
DocType: Share Balance,Current State,当前状态
apps/erpnext/erpnext/manufacturing/doctype/bom/bom_item_preview.html,Open Item {0},打开项目{0}
,Batch-Wise Balance History,批量智能平衡历史记录
DocType: Monthly Distribution Percentage,Percentage Allocation,百分比分配
DocType: Vital Signs,One Sided,单面
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Relation with Guardian2,与Guardian2的关系
DocType: Asset,Disposal Date,处置日期
DocType: Opportunity,Opportunity Type,机会类型
DocType: Cash Flow Mapping Template,Cash Flow Mapping Template,现金流量映射模板
DocType: Asset Settings,Depreciation Options,折旧选项
DocType: Student Admission,Admission Start Date,入学开始日期
DocType: Manufacturing Settings,Update BOM Cost Automatically,自动更新BOM成本
DocType: Subscription Settings,Subscription Settings,订阅设置
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CGST Amount,CGST金额
DocType: Amazon MWS Settings,Seller ID,卖家ID
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,'To Case No.' cannot be less than 'From Case No.',&#39;到案号&#39;不能少于&#39;从案件编号&#39;
DocType: Fee Schedule,EDU-FSH-.YYYY.-,EDU-FSH-.YYYY.-
apps/erpnext/erpnext/accounts/doctype/account/account.py,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company",只有当两个记录中的后续属性相同时，才可以进行合并。是集团，根类型，公司
DocType: SMS Log,SMS Log,短信日志
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please specify either Quantity or Valuation Rate or both,请指定数量或估价率或两者
DocType: Salary Component,Amount based on formula,金额基于公式
DocType: Clinical Procedure Item,Transfer Qty,转移数量
apps/erpnext/erpnext/setup/doctype/company/company.js,Cost Centers,成本中心
apps/erpnext/erpnext/education/doctype/student_group_creation_tool/student_group_creation_tool.py,Batch is mandatory in row {0},行{0}中必须批处理
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Error in formula or condition: {0},公式或条件出错：{0}
apps/erpnext/erpnext/controllers/accounts_controller.py,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",要在项目费率中的行{0}中包含税，还必须包含行{1}中的税
,Trial Balance (Simple),试算平衡（简单）
DocType: Purchase Order,Customer Contact,客户联系
DocType: Marketplace Settings,Registered,注册
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Gross Purchase Amount is mandatory,总购买金额是强制性的
DocType: Fee Structure,Components,组件
DocType: Pricing Rule,Promotional Scheme,促销计划
DocType: Quotation Item,Against Doctype,反对Doctype
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Total flexible benefit component amount {0} should not be less than max benefits {1},总灵活福利金额{0}不应低于最高福利金额{1}
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From GSTIN,来自GSTIN
DocType: Sales Invoice,Return Against Sales Invoice,退货销售发票
DocType: Item Variant Settings,Rename Attribute Value in Item Attribute.,在项属性中重命名属性值。
apps/erpnext/erpnext/manufacturing/doctype/bom_update_tool/bom_update_tool.py,Queued for updating latest price in all Bill of Materials. It may take a few minutes.,排队更新所有物料清单中的最新价格。可能需要几分钟时间。
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please select a warehouse,请选择一个仓库
DocType: Purchase Invoice Item,Weight UOM,重量UOM
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Accounts Payable Summary,应付帐款摘要
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Order {1},{0}针对销售订单{1}
DocType: Payroll Employee Detail,Payroll Employee Detail,工资单员工详细信息
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Admission and Enrollment,入学和入学
DocType: Budget Account,Budget Amount,预算额
apps/erpnext/erpnext/accounts/doctype/mode_of_payment/mode_of_payment.py,Account {0} does not match with Company {1} in Mode of Account: {2},帐户{0}与帐户模式中的公司{1}不匹配：{2}
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py,Please enter Receipt Document,请输入收据凭证
DocType: Naming Series,Change the starting / current sequence number of an existing series.,更改现有系列的开始/当前序列号。
apps/erpnext/erpnext/config/hr.py,Employee Lifecycle,员工生命周期
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,For Quantity must be less than quantity {0},对于数量必须小于数量{0}
DocType: Assessment Plan,Assessment Plan,评估计划
apps/erpnext/erpnext/maintenance/doctype/maintenance_visit/maintenance_visit.js,Warranty Claim,保修索赔
DocType: Company,Date of Incorporation,注册成立日期
DocType: Asset,Double Declining Balance,双倍下降的平衡
DocType: Payroll Entry,Validate Attendance,验证出勤
DocType: Lab Test,LP-,LP-
DocType: POS Customer Group,POS Customer Group,POS客户组
,Qty to Deliver,交付数量
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py,Fiscal Year {0} is required,会计年度{0}是必需的
DocType: HR Settings,Employee Records to be created by,要创建的员工记录
DocType: Depreciation Schedule,Depreciation Amount,折旧金额
DocType: Sales Order Item,Gross Profit,毛利
DocType: Quality Inspection,Item Serial No,商品序列号
DocType: Asset,Insurer,保险公司
DocType: Employee Checkin,OUT,OUT
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Buying Amount,购买金额
DocType: Asset Maintenance Task,Certificate Required,证书要求
DocType: Retention Bonus,Retention Bonus,保留奖金
DocType: Item,Asset Naming Series,资产命名系列
DocType: Healthcare Settings,Laboratory Settings,实验室设置
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Amount of Integrated Tax,综合税额
DocType: Branch,Branch,科
DocType: Request for Quotation Item,Required Date,要求日期
DocType: Cashier Closing,Returns,返回
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Negotiation/Review,谈判/评论
,Stock Summary,股票摘要
DocType: Bank Reconciliation,From Date,从日期
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"You can claim only an amount of {0}, the rest amount {1} should be in the application \
				as pro-rata component",您只能申请{0}金额，其余金额{1}应作为按比例分配在应用程序中
DocType: Warehouse,A logical Warehouse against which stock entries are made.,用于创建库存条目的逻辑仓库。
DocType: Stock Entry Detail,Difference Account,差异账户
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.js,This will submit Salary Slips and create accrual Journal Entry. Do you want to proceed?,这将提交Salary Slips并创建应计日记帐分录。你想继续吗？
DocType: Manufacturer,Manufacturers used in Items,物品中使用的制造商
apps/erpnext/erpnext/education/__init__.py,Student {0} does not belong to group {1},学生{0}不属于组{1}
DocType: Buying Settings,Maintain same rate throughout purchase cycle,在整个购买周期内保持相同的费率
apps/erpnext/erpnext/setup/doctype/company/company.py,Set default inventory account for perpetual inventory,为永久库存设置默认库存帐户
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Fee Creation Pending,费用创建待定
DocType: Accounts Settings,Unlink Advance Payment on Cancelation of Order,取消订单取消预付款
apps/erpnext/erpnext/config/crm.py,Visit report for maintenance call.,访问维护呼叫报告。
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,"To get the best out of ERPNext, we recommend that you take some time and watch these help videos.",为了充分利用ERPNext，我们建议您花一些时间观看这些帮助视频。
DocType: Fertilizer Content,Fertilizer Content,肥料含量
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,"Cannot delete Serial No {0}, as it is used in stock transactions",无法删除序列号{0}，因为它在股票交易中使用
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js,Charges are updated in Purchase Receipt against each item,在每个项目的采购收据中更新费用
DocType: Account,Credit,信用
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.js,Download JSON,下载JSON
DocType: Sales Invoice,Loyalty Amount,忠诚度金额
DocType: Account,Accounts,帐号
DocType: Loyalty Program,Expiry Duration (in days),到期时间（天）
DocType: Pricing Rule,Product Discount Scheme,产品折扣计划
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Creating Company and Importing Chart of Accounts,创建公司并导入会计科目表
apps/erpnext/erpnext/stock/report/item_price_stock/item_price_stock.py,Stock Available,现货供应
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Assign to Employees,分配给员工
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,No employees for the mentioned criteria,没有员工提到上述标准
apps/erpnext/erpnext/accounts/page/pos/pos.js,Not items found,找不到物品
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.py,Job card {0} created,已创建作业卡{0}
DocType: Delivery Note,Is Return,是回归
DocType: Soil Analysis Criteria,Soil Analysis Criteria,土壤分析标准
DocType: Quiz Result,Selected Option,选择的选项
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js,Preview Salary Slip,预览工资单
DocType: Asset,Assets,资产
DocType: Pricing Rule,Rate or Discount,价格或折扣
DocType: Travel Itinerary,Non-Vegetarian,非素食者
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule.js,Total Outstanding: {0},总突出：{0}
DocType: Appraisal,For Employee Name,对于员工姓名
apps/erpnext/erpnext/buying/doctype/supplier_scorecard/supplier_scorecard_list.js,Unknown,未知
apps/erpnext/erpnext/accounts/page/pos/pos.js,Sync Offline Invoices,同步离线发票
DocType: Practitioner Schedule,Schedule Name,附表名称
DocType: Shopify Settings,Shopify Settings,Shopify设置
DocType: Company,Sales Monthly History,销售月历
apps/erpnext/erpnext/stock/doctype/item/item.py,'Has Serial No' can not be 'Yes' for non-stock item,对于非库存商品，“具有序列号”不能为“是”
apps/erpnext/erpnext/regional/report/hsn_wise_summary_of_outward_supplies/hsn_wise_summary_of_outward_supplies.py,Total Taxable Amount,应税总额
apps/erpnext/erpnext/controllers/item_variant.py,Invalid attribute {0} {1},无效的属性{0} {1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial no {0} has been already returned,已返回序列号{0}
DocType: Maintenance Schedule,MAT-MSH-.YYYY.-,MAT-MSH-.YYYY.-
DocType: Student Group Student,Group Roll Number,组卷数
DocType: QuickBooks Migrator,Default Shipping Account,默认装运帐户
DocType: Work Order,MFG-WO-.YYYY.-,MFG-WO-.YYYY.-
DocType: Subscription,Trialling,试用
DocType: Loyalty Program,Single Tier Program,单层计划
apps/erpnext/erpnext/hr/doctype/loan/loan.py,Against Loan: {0},反对贷款：{0}
DocType: Tax Withholding Category,Tax Withholding Rates,预扣税率
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Community Forum,社区论坛
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Account Type for {0} must be {1},{0}的帐户类型必须为{1}
DocType: Purchase Receipt Item Supplied,Required Qty,要求的数量
apps/erpnext/erpnext/assets/doctype/asset_repair/asset_repair.py,Please select Completion Date for Completed Repair,请选择完成修复的完成日期
DocType: Clinical Procedure,Medical Department,医疗部门
DocType: Share Transfer,From Shareholder,来自股东
DocType: Company,Default Terms,默认条款
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Add Time Slots,添加时间槽
DocType: Sales Order Item,Ensure Delivery Based on Produced Serial No,确保基于生产的序列号的交货
,Eway Bill,Eway Bill
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Stock cannot be updated against Delivery Note {0},无法根据交货单{0}更新库存
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Sub Type,子类型
DocType: Task,Closing Date,截止日期
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Go to the Desktop and start using ERPNext,转到桌面并开始使用ERPNext
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Duplicate Serial No entered for Item {0},为项目{0}输入重复序列号
DocType: Item Price,Packing Unit,包装单位
DocType: Travel Request,International,国际
DocType: Item Tax Template Detail,Item Tax Template Detail,项目税模板详细信息
DocType: BOM Update Tool,New BOM,新BOM
DocType: Supplier,Is Internal Supplier,是内部供应商
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.js,Reject,拒绝
DocType: Salary Slip,net pay info,净工资信息
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Duties and Taxes,职责和税收
DocType: Appraisal Goal,Score Earned,获得分数
DocType: Task,Dependent Tasks,相关任务
DocType: Tax Rule,Shipping Zipcode,运输邮编
DocType: Naming Series,Update Series,更新系列
apps/erpnext/erpnext/public/js/setup_wizard.js,"e.g. ""Build tools for builders""",例如“为建造者建造工具”
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Prospecting,勘探
DocType: Bank Statement Transaction Entry,Bank Statement,银行对帐单
DocType: Appointment Type,Default Duration,默认持续时间
apps/erpnext/erpnext/config/buying.py,Default settings for buying transactions.,购买交易的默认设置。
DocType: Work Order Operation,Actual Time and Cost,实际时间和成本
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Evaluation,评估
apps/erpnext/erpnext/controllers/accounts_controller.py,Account: {0} with currency: {1} can not be selected,帐户：{0}货币：{1}无法选择
apps/erpnext/erpnext/hr/doctype/employee/employee_dashboard.py,Lifecycle,生命周期
DocType: Student Sibling,Studying in Same Institute,在同一所学院学习
apps/erpnext/erpnext/education/report/course_wise_assessment_report/course_wise_assessment_report.html,Course Code: ,科目编号：
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution %,贡献％
DocType: Journal Entry,Credit Note,信用票据
DocType: Batch,Parent Batch,父批
DocType: Payment Reconciliation,Get Unreconciled Entries,获取未经调整的条目
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js,Please set the Company,请设置公司
DocType: Lead,Lead Type,引线类型
DocType: Payment Entry,Difference Amount (Company Currency),差额（公司货币）
DocType: Invoice Discounting,Sanctioned,制裁
DocType: Course Enrollment,Course Enrollment,课程报名
DocType: Item,Supplier Items,供应商项目
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,"Start Time can't be greater than or equal to End Time \
					for {0}.",对于{0}，开始时间不能大于或等于结束时间\。
DocType: Sales Order,Not Applicable,不适用
DocType: Support Search Source,Response Options,响应选项
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,{0} should be a value between 0 and 100,{0}应该是0到100之间的值
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Sales Person,销售人员
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js,Packing Slip,包装单
apps/erpnext/erpnext/config/manufacturing.py,Global settings for all manufacturing processes.,所有制造流程的全局设置。
DocType: Shopify Settings,Customer Group will set to selected group while syncing customers from Shopify,客户组将在同步Shopify客户时设置为选定组
apps/erpnext/erpnext/education/doctype/student_admission/templates/student_admission.html,Apply Now,现在申请
DocType: Accounts Settings,Credit Controller,信贷控制
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Done,完成
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Manufacturing Quantity is mandatory,制造数量是强制性的
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py,Bypass credit check at Sales Order ,绕过销售订单的信用检查
DocType: Bin,Stock Value,股票价值
apps/erpnext/erpnext/config/accounting.py,Tax template for item tax rates.,项目税率的税收模板。
apps/erpnext/erpnext/accounts/party.py,{0} {1} is not active,{0} {1}未激活
DocType: Inpatient Record,O Positive,O积极
DocType: Training Event,Training Program,培训计划
DocType: Cashier Closing Payments,Cashier Closing Payments,收银员结算付款
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js,The 'From Package No.' field must neither be empty nor it's value less than 1.,&#39;来自套餐号&#39;字段既不能为空，也不能小于1。
,Purchase Order Trends,采购订单趋势
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py,Please enter parent cost center,请输入父成本中心
DocType: Purchase Receipt,Supplier Delivery Note,供应商交货单
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Please select Drug,请选择药物
DocType: Support Settings,Post Route Key,邮政路线钥匙
apps/erpnext/erpnext/education/doctype/student_admission/student_admission.py,Student Admissions,学生入学
apps/erpnext/erpnext/config/non_profit.py,Memebership Details,Memebership详细信息
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Probation,缓刑
,Inactive Sales Items,非活动销售项目
DocType: Amazon MWS Settings,AU,AU
DocType: Vital Signs,Abdomen,腹部
DocType: HR Settings,Employee Settings,员工设置
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Arrear,拖欠
apps/erpnext/erpnext/config/buying.py,Supplier Group master.,供应商组主。
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py,A customer with the same name already exists,已存在具有相同名称的客户
DocType: Course Enrollment,Program Enrollment,计划注册
apps/erpnext/erpnext/hr/doctype/job_opening/job_opening.py,"Job Openings for designation {0} already open \
					or hiring completed as per Staffing Plan {1}",指定{0}的职位空缺已根据人员配置计划{1}打开\或已完成招聘
apps/erpnext/erpnext/accounts/print_format/payment_receipt_voucher/payment_receipt_voucher.html,Authorized Signatory,授权签字人
DocType: Pricing Rule,Discount on Other Item,其他物品的折扣
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Quot Count,报数
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,No students Found,找不到学生
DocType: Journal Entry,Bank Entry,银行入境
DocType: Antibiotic,Antibiotic,抗生素
DocType: Stock Settings,Percentage you are allowed to receive or deliver more against the quantity ordered. For example: If you have ordered 100 units. and your Allowance is 10% then you are allowed to receive 110 units.,允许您根据订购数量接收或交付更多的百分比。例如：如果您订购了100个单位。你的津贴是10％，那么你可以获得110个单位。
apps/erpnext/erpnext/config/support.py,Support queries from customers.,支持客户的查询。
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py,Actual,实际
apps/erpnext/erpnext/manufacturing/doctype/production_plan/production_plan.py,Please enter Material Requests in the above table,请在上表中输入材料请求
DocType: Item Reorder,Item Reorder,物品重新订购
DocType: Company,Stock Settings,库存设置
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No is mandatory,行＃{0}：序列号是必需的
DocType: Homepage Section,Number of columns for this section. 3 cards will be shown per row if you select 3 columns.,此部分的列数。如果选择3列，每行将显示3张卡片。
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment_dashboard.py,Consultations,磋商
DocType: Employee Benefit Claim,Claim Benefit For,索赔利益
DocType: Fiscal Year,Year Name,年名
DocType: Bank Statement Transaction Entry,Reconciled Transactions,对帐交易
apps/erpnext/erpnext/controllers/status_updater.py,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,注意：系统不会检查物料{0}的超额交货和超额预订，因为数量或金额为0
apps/erpnext/erpnext/accounts/report/customer_ledger_summary/customer_ledger_summary.py,Opening Balance,期初余额
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py,'From Date' must be after 'To Date',&#39;From Date&#39;必须在&#39;To Date&#39;之后
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Total Amount {0},总金额{0}
DocType: Employee Skill,Evaluation Date,评估日期
apps/erpnext/erpnext/stock/doctype/item/item.py,"""Customer Provided Item"" cannot be Purchase Item also",“客户提供的项目”也不能是购买项目
DocType: C-Form Invoice Detail,Grand Total,累计
apps/erpnext/erpnext/selling/doctype/customer/customer.py,New credit limit is less than current outstanding amount for the customer. Credit limit has to be atleast {0},新的信用额度低于客户的当前未结清金额。信用额度必须至少为{0}
apps/erpnext/erpnext/shopping_cart/cart.py,Only {0} in stock for item {1},商品{1}的库存仅为{0}
DocType: Payment Reconciliation,Bank / Cash Account,银行/现金账户
apps/erpnext/erpnext/projects/doctype/project/project.py,Task weight cannot be negative,任务权重不能为负
DocType: Serial No,Creation Date,创立日期
apps/erpnext/erpnext/manufacturing/report/bom_variance_report/bom_variance_report.py,Finished Good,成品
DocType: Healthcare Settings,Manage Sample Collection,管理样品采集
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Unable to find DocType {0},无法找到DocType {0}
DocType: Purchase Invoice Item,Item Weight Details,物品重量详情
DocType: POS Closing Voucher,Modes of Payment,付款方式
DocType: Naming Series,Series List for this Transaction,此交易的系列列表
DocType: Crop,Produce,生产
DocType: Woocommerce Settings,API consumer key,API使用者密钥
DocType: Quality Inspection Reading,Reading 2,阅读2
DocType: Driver,Driving License Categories,驾驶执照类别
DocType: Asset Repair,Asset Repair,资产修复
DocType: Exchange Rate Revaluation,Exchange Rate Revaluation,汇率重估
DocType: Warehouse,Warehouse Contact Info,仓库联系信息
DocType: Request for Quotation Supplier,Request for Quotation Supplier,要求报价供应商
DocType: Travel Request,Costing,成本核算
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Fixed Assets,固定资产
DocType: Purchase Order,Ref SQ,参考SQ
DocType: Salary Structure,Total Earning,总收入
DocType: Share Balance,From No,从没有
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,付款对帐发票
DocType: Purchase Invoice,Taxes and Charges Added,税和费用已添加
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,考虑税收或收费
DocType: Authorization Rule,Authorized Value,授权价值
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Received From,从......收到
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouse {0} does not exist,仓库{0}不存在
DocType: Item Manufacturer,Item Manufacturer,商品制造商
DocType: Sales Invoice,Sales Team,销售团队
apps/erpnext/erpnext/stock/report/product_bundle_balance/product_bundle_balance.py,Bundle Qty,捆绑数量
DocType: Purchase Order Item Supplied,Stock UOM,股票UOM
DocType: Installation Note,Installation Date,安装日期
DocType: Email Digest,New Quotations,新报价
DocType: Production Plan Item,Ordered Qty,订购数量
,Minutes to First Response for Issues,问题的第一个响应的分钟
DocType: Vehicle Log,Refuelling Details,加油细节
DocType: Sales Partner,Targets,目标
DocType: Buying Settings,Settings for Buying Module,购买模块的设置
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Purchase Order {0} is not submitted,未提交采购订单{0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Material Request {0} submitted.,材料申请{0}已提交。
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Posting date and posting time is mandatory,发布日期和发布时间是强制性的
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,{} of {},{} {}
DocType: Lab Test Template,Lab Routine,实验室常规
apps/erpnext/erpnext/erpnext_integrations/doctype/gocardless_settings/gocardless_settings.py,Payment Failed. Please check your GoCardless Account for more details,支付失败。请查看您的GoCardless帐户以获取更多详细信息
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Row {0}:Start Date must be before End Date,行{0}：开始日期必须早于结束日期
apps/erpnext/erpnext/config/education.py,LMS Activity,LMS活动
DocType: Asset,Next Depreciation Date,下一个折旧日期
DocType: Healthcare Settings,Appointment Reminder,预约提醒
DocType: Cost Center,Cost Center Name,成本中心名称
DocType: Pricing Rule,Margin Rate or Amount,保证金率或金额
DocType: Healthcare Settings,Clinical Procedure Consumable Item,临床程序消耗品
DocType: Asset,Manual,手册
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Raw Materials cannot be blank.,原材料不能为空白。
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Please enter Cost Center,请输入成本中心
DocType: Support Search Source,Source DocType,源DocType
DocType: Assessment Group,Parent Assessment Group,家长评估小组
DocType: Purchase Invoice Item,Accepted Warehouse,接受的仓库
DocType: Sales Invoice Item,Discount and Margin,折扣和保证金
,Student and Guardian Contact Details,学生和监护人联系方式
DocType: Pricing Rule,Buying,购买
DocType: Student Attendance,Present,当下
DocType: Membership,Member Since,会员自
DocType: Tax Rule,Use for Shopping Cart,用于购物车
DocType: Loan,Loan Account,贷款账户
apps/erpnext/erpnext/hr/doctype/employee_onboarding/employee_onboarding.py,All the mandatory Task for employee creation hasn't been done yet.,所有员工创建的强制性任务尚未完成。
DocType: Crop Cycle,The minimum length between each plant in the field for optimum growth,田间每株植物之间的最小长度，以实现最佳生长
DocType: Budget,Applicable on Purchase Order,适用于采购订单
DocType: Stock Entry,Receive at Warehouse,在仓库接收
DocType: Cash Flow Mapping,Is Income Tax Expense,是所得税费用
DocType: Journal Entry,Make Difference Entry,做出差异
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py,Total (Credit),总计（学分）
apps/erpnext/erpnext/public/js/setup_wizard.js,The Brand,品牌
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 3,第3项
DocType: Purchase Invoice Item,Deferred Expense Account,递延费用帐户
DocType: Depreciation Schedule,Accumulated Depreciation Amount,累计折旧金额
apps/erpnext/erpnext/controllers/stock_controller.py,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}：商品{2}必须使用成本中心
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,No accounting entries for the following warehouses,没有以下仓库的会计分录
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.js,Please save first,请先保存
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Extra Small,超小
DocType: Assessment Group,Assessment Group,评估小组
DocType: Pricing Rule,UOM,UOM
apps/erpnext/erpnext/config/accounting.py,Bills raised by Suppliers.,供应商提出的法案。
DocType: Additional Salary,HR User,HR用户
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py,Profit for the year,今年的利润
DocType: Codification Table,Medical Code,医疗法典
apps/erpnext/erpnext/config/accounting.py,Update bank payment dates with journals.,使用期刊更新银行付款日期。
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Current Assets,当前资产
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not belong to company {2},行＃{0}：资产{1}不属于公司{2}
DocType: Purchase Invoice,Contact Person,联系人
apps/erpnext/erpnext/education/doctype/student_group/student_group.py,{0} - {1} is not enrolled in the Batch {2},{0}  -  {1}未在批处理{2}中注册
DocType: Holiday List,Holiday List Name,假期列表名称
DocType: Water Analysis,Collection Temperature ,收集温度
DocType: Healthcare Settings,Manage Appointment Invoice submit and cancel automatically for Patient Encounter,管理约会发票提交并自动取消患者遭遇
DocType: Employee Benefit Claim,Claim Date,索赔日期
DocType: Supplier,Leave blank if the Supplier is blocked indefinitely,如果供应商被无限期阻止，请留空
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Attendance From Date and Attendance To Date is mandatory,出席日期和出勤日期是强制性的
DocType: Serial No,Out of Warranty,超出保修期
apps/erpnext/erpnext/buying/utils.py,Same item cannot be entered multiple times.,同一项目不能多次输入。
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Select students manually for the Activity based Group,为基于活动的组手动选择学生
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py,Series Updated,系列更新
DocType: Employee,Date Of Retirement,退休日期
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Please select Patient,请选择患者
DocType: Asset,Straight Line,直线
DocType: Quality Action,Resolutions,决议
DocType: SMS Log,No of Sent SMS,没有发送短信
,GST Itemised Sales Register,商品及服务税明细销售登记册
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Total advance amount cannot be greater than total sanctioned amount,总预付金额不得超过总制裁金额
DocType: Lab Test,Test Name,测试名称
DocType: Task,Total Billing Amount (via Time Sheet),总账单金额（通过时间表）
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Quotation {0} is cancelled,报价{0}已取消
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Clear values,清晰的价值观
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Traceability,可追溯性
apps/erpnext/erpnext/hr/doctype/expense_claim_type/expense_claim_type.py,Same Company is entered more than once,同一公司不止一次进入
DocType: Delivery Stop,Contact Name,联系人姓名
DocType: Customer,Is Internal Customer,是内部客户
DocType: Purchase Taxes and Charges,Account Head,帐户主管
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Lower Income,低收入
apps/erpnext/erpnext/assets/doctype/asset_maintenance/asset_maintenance.py,Start date should be less than end date for task {0},开始日期应小于任务{0}的结束日期
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Customer Service,客户服务
apps/erpnext/erpnext/education/doctype/program/program_dashboard.py,Fee,费用
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM {0} does not belong to Item {1},BOM {0}不属于项目{1}
DocType: Daily Work Summary,Daily Work Summary Group,每日工作总结小组
apps/erpnext/erpnext/config/help.py,Customizing Forms,自定义表单
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py,Cancel Material Visit {0} before cancelling this Warranty Claim,取消物料在取消此保修索赔之前访问{0}
DocType: POS Profile,Ignore Pricing Rule,忽略定价规则
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Food,餐饮
DocType: Lost Reason Detail,Lost Reason Detail,丢失的原因细节
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,The following serial numbers were created: <br> {0},创建了以下序列号： <br> {0}
DocType: Maintenance Visit,Customer Feedback,客户的反馈意见
DocType: Serial No,Warranty / AMC Details,保修/ AMC详细信息
DocType: Issue,Opening Time,营业时间
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,View a list of all the help videos,查看所有帮助视频的列表
DocType: Purchase Invoice,Party Account Currency,党账户货币
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Please select a field to edit from numpad,请从numpad中选择要编辑的字段
DocType: Assessment Plan Criteria,Assessment Plan Criteria,评估计划标准
DocType: Products Settings,Item Fields,项目字段
apps/erpnext/erpnext/config/selling.py,Manage Sales Partners.,管理销售合作伙伴
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py,"Cannot declare as lost, because Quotation has been made.",不能声明丢失，因为报价已经完成。
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children",在这里，您可以维护家庭详细信息，如父母，配偶和子女的姓名和职业
DocType: Tax Rule,Shipping City,航运城
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Update Items,更新项目
,Customer Ledger Summary,客户分类帐摘要
DocType: Inpatient Record,B Positive,B肯定
apps/erpnext/erpnext/config/accounting.py,Accounting journal entries.,会计日记帐分录。
DocType: Buying Settings,Purchase Order Required,需要采购订单
DocType: Program Enrollment Tool,New Student Batch,新学生批次
DocType: Account,Account Type,帐户类型
DocType: Vehicle,Fuel Type,汽油种类
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Email sent to {0},电子邮件已发送至{0}
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Change Release Date,更改发布日期
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM for {0} not found,找不到{0}的默认BOM
,HSN-wise-summary of outward supplies,HSN-wise-外向供应总结
apps/erpnext/erpnext/healthcare/doctype/inpatient_record/inpatient_record_dashboard.py,Appointments and Encounters,约会和遭遇
DocType: Tax Withholding Category,Tax Withholding Category,预扣税类别
DocType: Agriculture Analysis Criteria,Linked Doctype,链接的Doctype
DocType: Account,Cost of Goods Sold,销售成本
DocType: Quality Inspection Reading,Reading 3,阅读3
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Group by Voucher,由优惠券分组
,Delivered Items To Be Billed,交付的物品需要付费
DocType: Employee Transfer,Employee Transfer Details,员工转移详细信息
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,公司注册号供您参考。税号等
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Serial No {0} does not belong to Warehouse {1},序列号{0}不属于仓库{1}
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Del,德尔
apps/erpnext/erpnext/templates/pages/task_info.html,on,上
DocType: Crop,"You can define all the tasks which need to carried out for this crop here. The day field is used to mention the day on which the task needs to be carried out, 1 being the 1st day, etc.. ",您可以在此处定义需要为此作物执行的所有任务。日期字段用于提示需要执行任务的日期，1表示第1天等。
DocType: Asset Maintenance Log,Task,任务
DocType: Naming Series,Help HTML,帮助HTML
DocType: Drug Prescription,Dosage by time interval,剂量按时间间隔计算
DocType: Batch,Batch Description,批次描述
apps/erpnext/erpnext/accounts/doctype/tax_withholding_category/tax_withholding_category.py,Please set associated account in Tax Withholding Category {0} against Company {1},请在针对公司{1}的预扣税分类{0}中设置关联帐户
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Needs Analysis,需求分析
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Allocated Leaves,分配叶子
DocType: Payment Request,Transaction Details,交易明细
DocType: Item,"Publish ""In Stock"" or ""Not in Stock"" on Hub based on stock available in this warehouse.",根据此仓库中可用的库存在Hub上发布“有库存”或“无库存”。
apps/erpnext/erpnext/setup/doctype/company/company.js,Company name not same,公司名称不一样
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.py,Employee Promotion cannot be submitted before Promotion Date ,在促销日期之前无法提交员工晋升
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py,Not allowed to update stock transactions older than {0},不允许更新早于{0}的股票交易
DocType: Employee Checkin,Employee Checkin,员工签到
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Start date should be less than end date for Item {0},开始日期应小于项目{0}的结束日期
apps/erpnext/erpnext/utilities/activation.py,Create customer quotes,创建客户报价
DocType: Buying Settings,Buying Settings,购买设置
DocType: Restaurant Menu Item,Restaurant Menu Item,餐厅菜单项目
DocType: Appraisal,Calculate Total Score,计算总分
DocType: Issue,Issue Type,问题类型
apps/erpnext/erpnext/projects/doctype/project/project.py,Start date of task <b>{0}</b> cannot be greater than <b>{1}</b> expected end date <b>{2}</b>,任务<b>{0}的</b>开始日期不能超过<b>{1}</b>预期结束日期<b>{2}</b>
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py,Balance Value,平衡价值
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,Groups,组
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Target warehouse in row {0} must be same as Work Order,行{0}中的目标仓库必须与工作订单相同
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Serial Number: {0} is already referenced in Sales Invoice: {1},序列号：销售发票中已引用{0}：{1}
DocType: Shopify Settings,"If Shopify not contains a customer in Order, then while syncing Orders, the system will consider default customer for order",如果Shopify不包含订单中的客户，则在同步订单时，系统将考虑订购的默认客户
DocType: Shopify Settings,Shopify Tax Account,Shopify税务帐户
apps/erpnext/erpnext/setup/doctype/company/company.js,Please make sure you really want to delete all the transactions for this company. Your master data will remain as it is. This action cannot be undone.,请确保您确实要删除该公司的所有交易。您的主数据将保持原样。此操作无法撤消。
DocType: Purchase Receipt,Auto Repeat Detail,自动重复细节
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Please supply the specified items at the best possible rates,请以最优惠的价格提供指定的物品
apps/erpnext/erpnext/controllers/accounts_controller.py,{0} in row {1},第{1}行中的{0}
DocType: Job Card Time Log,Job Card Time Log,工作卡时间日志
DocType: Patient,Patient Demographics,患者人口统计学
DocType: Share Transfer,To Folio No,对于Folio No
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Cash Flow from Operations,运营现金流量
DocType: Employee Checkin,Log Type,日志类型
DocType: Stock Settings,Allow Negative Stock,允许负面股票
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,None of the items have any change in quantity or value.,没有任何项目的数量或价值有任何变化。
DocType: Asset,Purchase Date,购买日期
DocType: Bank Statement Transaction Settings Item,Bank Statement Transaction Settings Item,银行对帐单交易设置项
,BOM Stock Report,BOM库存报告
apps/erpnext/erpnext/public/js/payment/pos_payment.html,Write Off,注销
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Row {0}: Expected Value After Useful Life must be less than Gross Purchase Amount,行{0}：使用寿命后的预期值必须小于总购买金额
DocType: Employee,Personal Bio,个人生物
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py,Duplicate Entry. Please check Authorization Rule {0},双重输入。请检查授权规则{0}
apps/erpnext/erpnext/hr/doctype/shift_assignment/shift_assignment.py,Employee {0} has already applied for {1} on {2} : ,员工{0}已在{2}申请{1}：
apps/erpnext/erpnext/patches/v4_0/create_price_list_if_missing.py,Standard Selling,标准销售
DocType: Clinical Procedure,Invoiced,已开发票
apps/erpnext/erpnext/education/doctype/guardian/guardian.py,User {0} already exists,用户{0}已存在
DocType: Account,Profit and Loss,收益与损失
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.py,Diff Qty,差异数量
DocType: Asset Finance Book,Written Down Value,写下来的价值
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts_with_account_number.py,Opening Balance Equity,期初余额权益
DocType: GSTR 3B Report,April,四月
DocType: Supplier,Credit Limit,信用额度
apps/erpnext/erpnext/public/js/setup_wizard.js,Distribution,分配
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,debit_note_amt,debit_note_amt
DocType: Quality Inspection,Inspected By,通过检查
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Get Items from Product Bundle,从Product Bundle获取物品
DocType: Employee Benefit Claim,Employee Benefit Claim,员工福利索赔
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py,Clearance Date not mentioned,没有提到清关日期
DocType: Company,Default Receivable Account,默认应收帐款
DocType: Location,Check if it is a hydroponic unit,检查它是否是水培单元
DocType: Student Guardian,Others,其他
DocType: Patient Appointment,Patient Appointment,患者预约
DocType: Inpatient Record,AB Positive,AB阳性
apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py,Depreciation Date,折旧日期
apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html,Upcoming Calendar Events,即将到来的日历活动
apps/erpnext/erpnext/config/hr.py,"Appraisals, Expense Claims and Loans",评估，费用索赔和贷款
apps/erpnext/erpnext/utilities/activation.py,Create Student Batch,创建学生批处理
DocType: Travel Itinerary,Travel Advance Required,需要提前旅行
apps/erpnext/erpnext/config/manufacturing.py,Orders released for production.,发布生产订单。
DocType: Loyalty Program,Collection Rules,收集规则
DocType: Asset Settings,Disable CWIP Accounting,禁用CWIP会计
DocType: Homepage Section,Section Based On,基于的部分
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,{0} already allocated for Employee {1} for period {2} to {3},已为员工{1}分配{0}期{2}到{3}
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.py,Row {0}: From Time and To Time of {1} is overlapping with {2},行{0}：从{1}的时间到时间与{2}重叠
DocType: Vital Signs,Very Hyper,非常超
apps/erpnext/erpnext/public/js/setup_wizard.js,Select the nature of your business.,选择您的业务性质。
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py,Please select month and year,请选择月份和年份
DocType: Service Level,Default Priority,默认优先级
DocType: Student Log,Student Log,学生日志
DocType: Shopping Cart Settings,Enable Checkout,启用结帐
apps/erpnext/erpnext/config/settings.py,Human Resources,人力资源
DocType: Stock Entry,Total Value Difference (Out - In),总价值差异（Out-In）
DocType: Work Order Operation,Actual End Time,实际结束时间
apps/erpnext/erpnext/config/help.py,Setting up Taxes,设置税收
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Cash from Investing,投资净现金
apps/erpnext/erpnext/accounts/doctype/invoice_discounting/invoice_discounting.js,Accounting Ledger,会计分类帐
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,Item Group Tree,项目组树
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,'Total',&#39;总&#39;
apps/erpnext/erpnext/stock/report/bom_search/bom_search.js,Item 1,第1项
apps/erpnext/erpnext/utilities/user_progress.py,Student Batches,学生批次
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name",附加带有两列的.csv文件，一列用于旧名称，另一列用于新名称
DocType: Bank Statement Transaction Payment Item,outstanding_amount,outstanding_amount
apps/erpnext/erpnext/healthcare/setup.py,Susceptible,易感
DocType: Purchase Invoice,Total (Company Currency),总计（公司货币）
DocType: Item,Website Content,网站内容
DocType: Driver,Driving License Category,驾驶执照类别
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Row #{0}: Expected Delivery Date cannot be before Purchase Order Date,行＃{0}：预计交货日期不能在采购订单日期之前
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Make Payment,付款
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Party Type is mandatory,派对类型是强制性的
apps/erpnext/erpnext/accounts/doctype/share_transfer/share_transfer.py,The fields From Shareholder and To Shareholder cannot be blank,来自股东和股东的字段不能为空
DocType: Customer Feedback,Quality Management,质量管理
DocType: BOM,Transfer Material Against,转移材料
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js,Temporarily on Hold,暂时搁置
apps/erpnext/erpnext/config/integrations.py,Connect Shopify with ERPNext,将Shopify与ERPNext连接
DocType: Homepage Section Card,Subtitle,字幕
DocType: Soil Texture,Loam,壤土
DocType: BOM,Scrap Material Cost(Company Currency),废料成本（公司货币）
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py,Delivery Note {0} must not be submitted,不得提交交货单{0}
DocType: Task,Actual Start Date (via Time Sheet),实际开始日期（通过时间表）
DocType: Sales Order,Delivery Date,邮寄日期
,Item Shortage Report,物品短缺报告
DocType: Subscription Plan,Price Determination,价格确定
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Retail & Wholesale,零售批发
DocType: Project,Twice Daily,每天两次
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,Integrated Tax,综合税
DocType: Payment Entry,Deductions or Loss,扣除或损失
apps/erpnext/erpnext/regional/italy/utils.py,"Fiscal Regime is mandatory, kindly set the fiscal regime in the company {0}",财政制度是强制性的，请在公司{0}设定财政制度
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Time slots added,时隙已添加
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py,Leaves must be allocated in multiples of 0.5,叶子必须以0.5的倍数分配
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} deducted against {2},针对{2}扣除的金额{0} {1}
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,付款对帐付款
apps/erpnext/erpnext/config/buying.py,Template of terms or contract.,条款或合同的模板。
DocType: Item,Barcodes,条形码
DocType: Course Enrollment,Enrollment Date,注册日期
DocType: Holiday List,Clear Table,清除表
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Setting up company,建立公司
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,Free item code is not selected,未选择免费商品代码
apps/erpnext/erpnext/public/js/utils.js,Total Unpaid: {0},未付款总额：{0}
DocType: Account,Balance must be,平衡必须
DocType: Supplier,Default Bank Account,默认银行帐户
apps/erpnext/erpnext/education/doctype/fee_schedule/fee_schedule_list.js,Creating Fees,创造费用
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Please select Qty against item {0},请根据项目{0}选择数量
DocType: Healthcare Settings,Do not confirm if appointment is created for the same day,不确认是否在同一天创建了约会
DocType: Loan,Repaid/Closed,偿还/关闭
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Row {0}: {1} Serial numbers required for Item {2}. You have provided {3}.,行{0}：{1}项{2}所需的序列号。您提供了{3}。
DocType: Exchange Rate Revaluation Account,Gain/Loss,收益/损失
DocType: POS Profile,Sales Invoice Payment,销售发票付款
DocType: Timesheet,Payslip,工资单
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,HSN,HSN
apps/erpnext/erpnext/config/buying.py,Request for quotation.,要求报价。
,Procurement Tracker,采购跟踪器
DocType: Employee Tax Exemption Proof Submission Detail,Type of Proof,证明类型
DocType: Purchase Receipt,Vehicle Date,车辆日期
DocType: Delivery Settings,Dispatch Settings,发货设置
DocType: Task,Dependencies,依赖
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js,Lost,丢失
DocType: BOM Update Tool,Replace BOM,替换BOM
DocType: Patient,Marital Status,婚姻状况
DocType: HR Settings,Enter retirement age in years,输入退休年龄
apps/erpnext/erpnext/templates/generators/item_group.html,No items listed,没有列出项目
apps/erpnext/erpnext/regional/report/electronic_invoice_register/electronic_invoice_register.js,No data to export,没有要导出的数据
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,如果您还想将上一会计年度的余额保留到本财政年度，请选择继续
apps/erpnext/erpnext/config/help.py,Opening Stock Balance,开仓存量
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py,Leave Blocked,离开被阻止
apps/erpnext/erpnext/stock/doctype/item/item.py,Asset Category is mandatory for Fixed Asset item,固定资产项目必须具有资产类别
DocType: Purchase Receipt Item,Required By,要求的
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Add to Details,添加到详细信息
,Inactive Customers,不活跃的客户
DocType: Drug Prescription,Dosage,剂量
DocType: Cheque Print Template,Starting position from top edge,从上边缘开始的位置
apps/erpnext/erpnext/healthcare/doctype/practitioner_schedule/practitioner_schedule.js,Appointment Duration (mins),预约时间（分钟）
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,This employee already has a log with the same timestamp.{0},此员工已有一个具有相同时间戳的日志。{0}
DocType: Accounting Dimension,Disable,禁用
DocType: Email Digest,Purchase Orders to Receive,要接收的采购订单
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,Productions Orders cannot be raised for:,制作订单不能用于：
DocType: Projects Settings,Ignore Employee Time Overlap,忽略员工时间重叠
DocType: Employee Skill Map,Trainings,培训
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,Lost Reasons,失去的原因
DocType: Inpatient Record,A Positive,积极的
DocType: Quality Inspection Reading,Reading 7,阅读7
DocType: Purchase Invoice Item,Serial No,序列号
DocType: Material Request Plan Item,Required Quantity,所需数量
DocType: Location,Parent Location,家长位置
DocType: Production Plan,Material Requests,材料请求
DocType: Buying Settings,Material Transferred for Subcontract,转包的材料转包
DocType: Job Card,Timing Detail,时间细节
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html,Required On,必填
DocType: Job Offer Term,Job Offer Term,工作机会
DocType: SMS Center,All Contact,全部联系
DocType: Project Task,Project Task,项目任务
DocType: Item Barcode,Item Barcode,物品条形码
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Levels,股票水平
DocType: Vital Signs,Height (In Meter),高度（米）
apps/erpnext/erpnext/crm/report/campaign_efficiency/campaign_efficiency.py,Order Value,订单价值
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,所有销售交易都可以针对多个**销售人员**进行标记，以便您可以设置和监控目标。
apps/erpnext/erpnext/public/js/utils.js,You have already selected items from {0} {1},您已经从{0} {1}中选择了项目
DocType: Request for Quotation,Get Suppliers,获得供应商
DocType: Sales Team,Contribution (%),贡献（％）
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.js,Cannot set a received RFQ to No Quote,无法将收到的RFQ设置为无报价
apps/erpnext/erpnext/manufacturing/doctype/blanket_order/blanket_order.js,Create Sales Order,创建销售订单
apps/erpnext/erpnext/accounts/general_ledger.py,Account: {0} can only be updated via Stock Transactions,帐户：{0}只能通过库存交易进行更新
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py,{0} Request for {1},{0}申请{1}
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js,Please select a value for {0} quotation_to {1},请为{0} quotation_to {1}选择一个值
DocType: Opportunity,Opportunity Date,机会日期
apps/erpnext/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html,Next Steps,下一步
apps/erpnext/erpnext/hr/doctype/training_event/training_event.js,Training Feedback,培训反馈
DocType: Purchase Invoice,ACC-PINV-.YYYY.-,ACC-PINV-.YYYY.-
DocType: Holiday List,Total Holidays,总假期
DocType: Fertilizer,Fertilizer Name,肥料名称
apps/erpnext/erpnext/regional/india/utils.py,House rented dates required for exemption calculation,众议院租用了豁免计算所需的日期
,Expiring Memberships,即将到期的会员资格
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py,Supplier(s),供应商（S）
DocType: GL Entry,To Rename,要重命名
apps/erpnext/erpnext/templates/generators/item/item_configure.html,Contact Us,联系我们
DocType: POS Closing Voucher,Cashier,出纳员
DocType: Drug Prescription,Hour,小时
DocType: Support Settings,Show Latest Forum Posts,显示最新论坛帖子
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Distributor,分销商
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"Please add the remaining benefits {0} to the application as \
				pro-rata component",请将剩余的好处{0}作为\ pro-rata组件添加到应用程序中
DocType: Invoice Discounting,Short Term Loan Account,短期贷款账户
DocType: Cash Flow Mapper,Section Subtotal,部分小计
apps/erpnext/erpnext/config/buying.py,Material Request to Purchase Order,物料采购订单
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,CESS Amount,CESS金额
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Not authorized to edit frozen Account {0},无权编辑冻结帐户{0}
DocType: POS Closing Voucher Details,Expected Amount,预期金额
DocType: Customer,Default Price List,默认价格表
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,No Items selected for transfer,没有选择要转移的项目
DocType: Payment Schedule,Payment Amount,支付金额
DocType: Grant Application,Assessment  Manager,评估经理
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Chemical,化学
apps/erpnext/erpnext/config/education.py,Assessment Reports,评估报告
DocType: C-Form,IV,IV
DocType: Student Log,Academic,学术的
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item {0} is not setup for Serial Nos. Check Item master,没有为序列号设置项目{0}。检查项目主文件
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,From State,来自州
DocType: Leave Type,Maximum Continuous Days Applicable,最大连续天数适用
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Please enter company name first,请先输入公司名称
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js,Import Successful,导入成功
DocType: Guardian,Alternate Number,替代号码
apps/erpnext/erpnext/patches/v11_0/create_department_records_for_each_company.py,All Departments,所有部门
apps/erpnext/erpnext/config/projects.py,Make project from a template.,从模板创建项目。
DocType: Purchase Order,Inter Company Order Reference,公司间订单参考
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py,Work Order {0} must be cancelled before cancelling this Sales Order,取消此销售订单之前，必须取消工单{0}
DocType: Education Settings,Employee Number,员工编号
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py,Avg. Buying Rate,平均。购买率
DocType: Manufacturing Settings,Capacity Planning For (Days),容量规划（天）
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,From value must be less than to value in row {0},从值必须小于行{0}中的值
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,Select BOM and Qty for Production,选择BOM和生产数量
DocType: Price List Country,Price List Country,价格表国家
apps/erpnext/erpnext/setup/doctype/company/company.js,Create Tax Template,创建税务模板
DocType: Item Attribute,Numeric Values,数字值
DocType: Delivery Note,Instructions,说明
DocType: Blanket Order Item,Blanket Order Item,一揽子订单项目
DocType: Accounting Dimension,Mandatory For Profit and Loss Account,对于损益账户必须提供
apps/erpnext/erpnext/controllers/selling_controller.py,Commission rate cannot be greater than 100,佣金率不能超过100
DocType: Course Topic,Course Topic,课程主题
DocType: Employee,This will restrict user access to other employee records,这将限制用户访问其他员工记录
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py,Please create Customer from Lead {0},请从潜在客户{0}创建客户
DocType: QuickBooks Migrator,Company Settings,公司设置
DocType: Travel Itinerary,Vegetarian,素
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py,"An item exists with same name ({0}), please change the item group name or rename the item",存在具有相同名称（{0}）的项目，请更改项目组名称或重命名该项目
DocType: Hotel Room,Hotel Room Type,酒店房间类型
,Cash Flow,现金周转
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Payment against {0} {1} cannot be greater than Outstanding Amount {2},针对{0} {1}的付款不能超过未付金额{2}
DocType: Student Log,Achievement,成就
apps/erpnext/erpnext/projects/doctype/task/task_tree.js,Add Multiple Tasks,添加多个任务
apps/erpnext/erpnext/stock/doctype/item/item.js,Item Variant {0} already exists with same attributes,项目变体{0}已存在，具有相同的属性
apps/erpnext/erpnext/accounts/doctype/subscription/subscription.py,Invoice {0} no longer exists,发票{0}不再存在
DocType: Item,Will also apply for variants unless overrridden,除非被覆盖，否则也将适用于变体
DocType: Cash Flow Mapping Accounts,Account,帐户
DocType: Sales Order,To Deliver,交付
,Customers Without Any Sales Transactions,没有任何销售交易的客户
DocType: Maintenance Visit Purpose,Against Document No,反对文件号
apps/erpnext/erpnext/config/education.py,Content Masters,内容大师
apps/erpnext/erpnext/config/accounting.py,Subscription Management,订阅管理
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.js,Get customers from,从中获取客户
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py,{0} Digest,{0}摘要
DocType: Employee,Reports to,向...报告
DocType: Video,YouTube,YouTube的
DocType: Party Account,Party Account,党的帐户
DocType: Assessment Plan,Schedule,时间表
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Please enter ,请输入
DocType: Lead,Channel Partner,渠道合作伙伴
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html,Invoiced Amount,发票金额
DocType: Project,From Template,来自模板
,DATEV,DATEV
apps/erpnext/erpnext/selling/doctype/customer/customer_dashboard.py,Subscriptions,订阅
apps/erpnext/erpnext/manufacturing/report/bom_stock_calculated/bom_stock_calculated.js,Quantity to Make,制作数量
DocType: Quality Review Table,Achieved,实现
apps/erpnext/erpnext/selling/report/sales_person_commission_summary/sales_person_commission_summary.py,Contribution Amount,贡献金额
DocType: Budget,Fiscal Year,财政年度
DocType: Supplier,Prevent RFQs,防止RFQ
DocType: Company,Discount Received Account,折扣收到的帐户
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py, (Half Day),（半天）
DocType: Email Digest,Email Digest,电子邮件摘要
DocType: Crop,Crop,作物
DocType: Email Digest,Profit & Loss,利润损失
DocType: Homepage Section,Section Order,部分顺序
DocType: Healthcare Settings,Result Printed,打印结果
apps/erpnext/erpnext/education/doctype/academic_year/academic_year.js,Student Group,学生团体
DocType: Purchase Taxes and Charges Template,"Standard tax template that can be applied to all Purchase Transactions. This template can contain list of tax heads and also other expense heads like ""Shipping"", ""Insurance"", ""Handling"" etc.

#### Note

The tax rate you define here will be the standard tax rate for all **Items**. If there are **Items** that have different rates, they must be added in the **Item Tax** table in the **Item** master.

#### Description of Columns

1. Calculation Type: 
    - This can be on **Net Total** (that is the sum of basic amount).
    - **On Previous Row Total / Amount** (for cumulative taxes or charges). If you select this option, the tax will be applied as a percentage of the previous row (in the tax table) amount or total.
    - **Actual** (as mentioned).
2. Account Head: The Account ledger under which this tax will be booked
3. Cost Center: If the tax / charge is an income (like shipping) or expense it needs to be booked against a Cost Center.
4. Description: Description of the tax (that will be printed in invoices / quotes).
5. Rate: Tax rate.
6. Amount: Tax amount.
7. Total: Cumulative total to this point.
8. Enter Row: If based on ""Previous Row Total"" you can select the row number which will be taken as a base for this calculation (default is the previous row).
9. Consider Tax or Charge for: In this section you can specify if the tax / charge is only for valuation (not a part of total) or only for total (does not add value to the item) or for both.
10. Add or Deduct: Whether you want to add or deduct the tax.",可应用于所有采购交易的标准税收模板。此模板可以包含税务负责人列表以及其他费用负责人，例如“运费”，“保险”，“处理”等。####注意您在此定义的税率将是所有**项目的标准税率* *。如果**项目**具有不同的费率，则必须将它们添加到**项目**主文件的**项目税**表中。 ####列说明1.计算类型： - 可以是**净总计**（即基本金额的总和）。 -  **上一行总额/金额**（累计税金或费用）。如果选择此选项，则税额将应用为上一行（税表中）金额或总金额的百分比。 -  **实际**（如上所述）。 2.账户负责人：将在其中预订此税的账户分类账3.成本中心：如果税/费是收入（如运费）或费用，则需要根据成本中心进行预订。 4.描述：税收描述（将在发票/报价中打印）。 5.费率：税率。 6.金额：税额。 7.总计：累计到此为止。 8.输入行：如果基于“上一行总计”，您可以选择将作为此计算基础的行号（默认为上一行）。 9.考虑税收或收费：在本节中，您可以指定税收/费用是仅用于估价（不是总额的一部分）还是仅用于总额（不为项目增加价值）或两者。 10.添加或减免：是否要添加或扣除税金。
apps/erpnext/erpnext/erpnext_integrations/doctype/quickbooks_migrator/quickbooks_migrator.js,Connect to Quickbooks,连接到Quickbooks
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root cannot be edited.,Root无法编辑。
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Engineer,工程师
apps/erpnext/erpnext/public/js/controllers/transaction.js,Row #{0}: Item added,行＃{0}：已添加项目
DocType: Student Admission,Eligibility and Details,资格和细节
DocType: Staffing Plan,Staffing Plan Detail,人员配备计划细节
DocType: Shift Type,Late Entry Grace Period,延迟入境宽限期
DocType: Email Digest,Annual Income,年收入
DocType: Journal Entry,Subscription Section,订阅部分
DocType: Salary Slip,Payment Days,付款日
apps/erpnext/erpnext/config/non_profit.py,Volunteer information.,志愿者信息。
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,`Freeze Stocks Older Than` should be smaller than %d days.,`冻结股票比&#39;低于&#39;应该小于％d天。
DocType: Bank Reconciliation,Total Amount,总金额
DocType: Certification Application,Non Profit,非盈利
DocType: Subscription Settings,Cancel Invoice After Grace Period,宽限期后取消发票
DocType: Loyalty Point Entry,Loyalty Points,忠诚度积分
DocType: Purchase Order,Set Target Warehouse,设置目标仓库
apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py,"{0} currently has a {1} Supplier Scorecard standing, and RFQs to this supplier should be issued with caution.",{0}目前有{1}供应商记分卡，应谨慎发放给该供应商的RFQ。
DocType: Travel Itinerary,Check-in Date,入住日期
DocType: Tally Migration,Round Off Account,四舍五入账
DocType: Serial No,Warranty Period (Days),保修期（天）
DocType: Expense Claim Detail,Expense Claim Detail,费用索赔明细
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Program: ,程序：
DocType: Patient Medical Record,Patient Medical Record,病历医疗记录
DocType: Item,Variant Based On,变体基于
DocType: Vehicle Service,Brake Oil,制动油
DocType: Employee,Create User,创建用户
DocType: Codification Table,Codification Table,编纂表
DocType: Training Event Employee,Optional,可选的
DocType: HR Settings,Show Leaves Of All Department Members In Calendar,在日历中显示所有部门成员的叶子
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,"Did not found transfered item {0} in Work Order {1}, the item not added in Stock Entry",未在工作订单{1}中找到转移的项目{0}，该项目未在库存条目中添加
apps/erpnext/erpnext/templates/pages/help.html,See all open tickets,查看所有打开的门票
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Operations cannot be left blank,操作不能留空
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,At least one mode of payment is required for POS invoice.,POS发票至少需要一种付款方式。
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Guardian1 Email ID,Guardian1电子邮件ID
DocType: Sales Order Item,Supplier delivers to Customer,供应商交付给客户
DocType: Procedure Prescription,Appointment Booked,预约预约
DocType: Crop,Target Warehouse,目标仓库
DocType: Accounts Settings,Stale Days,陈旧的日子
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,Row {0}: Credit entry can not be linked with a {1},行{0}：信用条目无法与{1}链接
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Healthcare Practitioner {0} not available on {1},医疗从业者{0}在{1}上不可用
DocType: SMS Center,All Customer Contact,所有客户联系
apps/erpnext/erpnext/stock/doctype/item/item.py," {0} Retain Sample is based on batch, please check Has Batch No to retain sample of item",{0}保留样品基于批次，请选中具有批次否以保留项目样品
apps/erpnext/erpnext/selling/page/point_of_sale/point_of_sale.js,Disc,圆盘
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,为每个股票运动进行会计分录
DocType: Travel Itinerary,Check-out Date,离开日期
DocType: Agriculture Analysis Criteria,Fertilizer,肥料
DocType: Supplier,Default Tax Withholding Config,默认税收预扣配置
DocType: Production Plan,Total Produced Qty,总产量数量
DocType: Leave Allocation,Leave Period,离开期间
apps/erpnext/erpnext/education/doctype/fees/fees.py,Payment request {0} created,已创建付款请求{0}
DocType: Healthcare Service Unit Type,UOM Conversion in Hours,UOM按小时转换
apps/erpnext/erpnext/stock/report/item_variant_details/item_variant_details.py,Avg. Selling Price List Rate,平均。卖出价格表
apps/erpnext/erpnext/config/manufacturing.py,Generate Material Requests (MRP) and Work Orders.,生成物料请求（MRP）和工作订单。
DocType: Journal Entry Account,Account Balance,账户余额
DocType: Asset Maintenance Log,Periodicity,周期性
apps/erpnext/erpnext/healthcare/doctype/patient/patient.js,Medical Record,医疗记录
apps/erpnext/erpnext/hr/doctype/employee_checkin/employee_checkin.py,Log Type is required for check-ins falling in the shift: {0}.,签到班次中需要登录类型：{0}。
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Execution,执行
DocType: Item,Valuation Method,估价方法
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Sales Invoice {1},{0}针对销售发票{1}
DocType: Quiz Activity,Pass,通过
DocType: Sales Partner,Sales Partner Target,销售伙伴目标
DocType: Patient Appointment,Referring Practitioner,转介医生
DocType: Account,Expenses Included In Asset Valuation,资产评估中包含的费用
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Publishing,出版
DocType: Production Plan,Sales Orders Detail,销售订单明细
DocType: Salary Slip,Total Deduction,总扣除额
apps/erpnext/erpnext/hr/report/loan_repayment/loan_repayment.py,EMI,EMI
DocType: Naming Series,Set prefix for numbering series on your transactions,为您的交易设置编号序列的前缀
apps/erpnext/erpnext/accounts/utils.py,Journal Entries {0} are un-linked,日记帐分录{0}未链接
apps/erpnext/erpnext/config/buying.py,Other Reports,其他报道
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,All items have already been invoiced,所有商品均已开具发票
apps/erpnext/erpnext/assets/doctype/asset/depreciation.py,Asset scrapped via Journal Entry {0},通过日记帐分录{0}报废资产
DocType: Employee,Prefered Email,首选电子邮件
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py,"Can't change valuation method, as there are transactions against some items which does not have it's own valuation method",无法更改估价方法，因为某些项目的交易没有自己的估值方法
DocType: Cash Flow Mapper,Section Name,部分名称
DocType: Packed Item,Packed Item,打包物品
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} {1}: Either debit or credit amount is required for {2},{0} {1}：{2}需要借记或贷记金额
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Submitting Salary Slips...,提交工资单......
apps/erpnext/erpnext/quality_management/doctype/quality_review/quality_review_list.js,No Action,没有行动
apps/erpnext/erpnext/accounts/doctype/budget/budget.py,"Budget cannot be assigned against {0}, as it's not an Income or Expense account",无法针对{0}分配预算，因为它不是收入或费用帐户
apps/erpnext/erpnext/config/accounting.py,Masters and Accounts,硕士和帐户
DocType: Quality Procedure Table,Responsible Individual,负责任的个人
apps/erpnext/erpnext/education/doctype/course/course.py,Total Weightage of all Assessment Criteria must be 100%,所有评估标准的总权重必须为100％
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,An error occurred during the update process,更新过程中发生错误
DocType: Sales Invoice,Customer Name,顾客姓名
apps/erpnext/erpnext/hr/doctype/additional_salary/additional_salary.py,Amount should not be less than zero.,金额不应小于零。
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py,Average Age,平均年龄
DocType: Shopping Cart Settings,Show Price,显示价格
DocType: Program Enrollment Tool Student,Program Enrollment Tool Student,计划注册工具学生
DocType: Tax Rule,Shipping State,运输状态
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.js,Please set Company,请设置公司
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html,Balance (Dr - Cr),平衡（Dr  -  Cr）
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Supply Type,供应类型
DocType: Healthcare Settings,Create documents for sample collection,为样品采集创建文档
DocType: Selling Settings,Close Opportunity After Days,几天后关闭机会
DocType: Item Customer Detail,Ref Code,参考代码
DocType: Employee,Widowed,寡
DocType: Tally Migration,ERPNext Company,ERPNext公司
DocType: Delivery Settings,Leave blank to use the standard Delivery Note format,留空以使用标准的交货单格式
DocType: Purchase Invoice Item,Accepted Qty,接受数量
DocType: Pricing Rule,Apply Rule On Brand,在品牌上应用规则
DocType: Products Settings,Show Availability Status,显示可用性状态
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Import Successfull,导入成功
DocType: Agriculture Analysis Criteria,Soil Texture,土壤质地
DocType: Maintenance Schedule Item,No of Visits,没有访问
DocType: Customer Feedback Table,Qualitative Feedback,定性反馈
DocType: Service Level,Response and Resoution Time,响应和资源时间
apps/erpnext/erpnext/non_profit/report/expiring_memberships/expiring_memberships.py,Expiring On,即将到期
DocType: Supplier Scorecard,Scorecard Actions,记分卡操作
DocType: Account,Stock Adjustment,库存调整
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Health Care,卫生保健
DocType: Restaurant Table,No of Seats,没有席位
apps/erpnext/erpnext/setup/doctype/company/company.js,Delete all the Transactions for this Company,删除此公司的所有交易
,Lead Details,细节
DocType: Service Level Agreement,Default Service Level Agreement,默认服务水平协议
apps/erpnext/erpnext/portal/doctype/products_settings/products_settings.py,"Filter Fields Row #{0}: Fieldname <b>{1}</b> must be of type ""Link"" or ""Table MultiSelect""",筛选字段行＃{0}：字段名<b>{1}</b>必须是“链接”或“表格MultiSelect”类型
DocType: Lead,Suggestions,建议
apps/erpnext/erpnext/accounts/doctype/payment_order/payment_order.js,Get from,从获得
DocType: Tax Rule,Tax Rule,税收规则
DocType: Payment Entry,Payment Order Status,付款订单状态
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py,Duplicate entry,双重输入
apps/erpnext/erpnext/utilities/user_progress.py,Example: Masters in Computer Science,示例：计算机科学硕士
DocType: Purchase Invoice Item,Purchase Invoice Item,购买发票项目
DocType: Certified Consultant,Non Profit Manager,非盈利经理
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,For Warehouse is required before Submit,在提交之前需要仓库
DocType: Authorization Rule,Applicable To (User),适用于（用户）
DocType: Appraisal Goal,Appraisal Goal,评估目标
DocType: Supplier Scorecard,Warn for new Purchase Orders,警告新的采购订单
apps/erpnext/erpnext/public/js/setup_wizard.js,View Chart of Accounts,查看会计科目表
apps/erpnext/erpnext/templates/pages/rfq.html,Quotations: ,语录：
DocType: Opportunity,To Discuss,讨论
DocType: Quality Inspection Reading,Reading 9,阅读9
DocType: Authorization Rule,Applicable To (Role),适用于（角色）
DocType: Quotation Item,Additional Notes,补充说明
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,{0} can not be negative,{0}不能是否定的
apps/erpnext/erpnext/utilities/activation.py,Create Purchase Orders,创建采购订单
DocType: Staffing Plan Detail,Estimated Cost Per Position,每个位置的估计成本
DocType: Loan Type,Loan Name,贷款名称
apps/erpnext/erpnext/accounts/doctype/pos_profile/pos_profile.py,Set default mode of payment,设置默认付款方式
DocType: Quality Goal,Revision,调整
DocType: Shift Type,The time before the shift end time when check-out is considered as early (in minutes).,退房结束时间之前的时间被视为提前（以分钟为单位）。
DocType: Healthcare Service Unit,Service Unit Type,服务单位类型
DocType: Purchase Invoice,Return Against Purchase Invoice,退货购买发票
apps/erpnext/erpnext/erpnext_integrations/doctype/woocommerce_settings/woocommerce_settings.js,Generate Secret,生成秘密
DocType: Loyalty Program Collection,Loyalty Program Collection,忠诚度计划集
apps/erpnext/erpnext/config/crm.py,Send mass SMS to your contacts,向您的联系人发送群发短信
apps/erpnext/erpnext/education/doctype/fee_structure/fee_structure.js,Create Fee Schedule,创建收费表
DocType: Rename Tool,File to Rename,要重命名的文件
apps/erpnext/erpnext/public/js/projects/timer.js,Timer exceeded the given hours.,计时器超过给定的小时数。
DocType: Shopify Tax Account,ERPNext Account,ERPNext账户
DocType: Item Supplier,Item Supplier,物品供应商
apps/erpnext/erpnext/stock/get_item_details.py,Price List {0} is disabled or does not exist,价格表{0}已禁用或不存在
DocType: Sales Invoice Item,Deferred Revenue Account,递延收入帐户
apps/erpnext/erpnext/agriculture/doctype/soil_texture/soil_texture.py,Soil compositions do not add up to 100,土壤成分不超过100
DocType: Salary Slip,Salary Slip Timesheet,工资单时间表
DocType: Budget,Warn,警告
DocType: Grant Application,Email Notification Sent,已发送电子邮件通知
DocType: Work Order,Planned End Date,计划结束日期
DocType: QuickBooks Migrator,Quickbooks Company ID,Quickbooks公司ID
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Warehouse cannot be changed for Serial No.,仓库不能更改序列号
DocType: Loan Type,Rate of Interest (%) Yearly,每年的利率（％）
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Cost of Scrapped Asset,废弃资产成本
apps/erpnext/erpnext/regional/italy/utils.py,Please set an Address on the Company '%s',请在公司&#39;％s&#39;上设置地址
DocType: Patient Encounter,Encounter Date,遇到日期
DocType: Shopify Settings,Webhooks,网络挂接
apps/erpnext/erpnext/config/non_profit.py,Memebership Type Details,Memebership类型详细信息
apps/erpnext/erpnext/healthcare/setup.py,Resistant,耐
DocType: Hotel Room Package,Hotel Room Package,酒店客房套餐
DocType: Sales Team,Contribution to Net Total,对净总额的贡献
DocType: Customer,"Reselect, if the chosen contact is edited after save",如果在保存后编辑了所选联系人，请重新选择
DocType: Employee Tax Exemption Sub Category,Employee Tax Exemption Sub Category,员工免税子类别
apps/erpnext/erpnext/hr/doctype/employee_advance/employee_advance.py,Row {0}# Paid Amount cannot be greater than requested advance amount,行{0} #Pake Amount不能大于请求的预付金额
DocType: Asset Settings,This value is used for pro-rata temporis calculation,该值用于按比例计算
DocType: Company,Change Abbreviation,更改缩写
DocType: Project,Total Consumed Material Cost  (via Stock Entry),消耗材料总成本（通过库存输入）
DocType: Purchase Invoice,Raw Materials Supplied,原料供应
DocType: Salary Detail,Condition and Formula Help,条件和公式帮助
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Balance ({0}),余额（{0}）
apps/erpnext/erpnext/education/doctype/student_report_generation_tool/student_report_generation_tool.html,Student ID: ,学生卡：
DocType: Leave Control Panel,New Leaves Allocated (In Days),新叶分配（天）
apps/erpnext/erpnext/projects/report/daily_timesheet_summary/daily_timesheet_summary.py,To Datetime,到日期时间
apps/erpnext/erpnext/agriculture/doctype/water_analysis/water_analysis.py,Lab result datetime cannot be before testing datetime,实验室结果日期时间不能在测试日期时间之前
apps/erpnext/erpnext/setup/doctype/company/company.js,Please re-type company name to confirm,请重新输入公司名称进行确认
DocType: Subscription,Subscription Period,订阅期
DocType: Cash Flow Mapper,Position,位置
DocType: Student,Sibling Details,兄弟姐妹详情
DocType: Cash Flow Mapping,Is Finance Cost Adjustment,财务成本调整
DocType: Patient Encounter,Encounter Impression,遇到印象
DocType: Contract,N/A,N / A
DocType: Lab Test,Lab Technician,实验室技术员
apps/erpnext/erpnext/stock/get_item_details.py,"Item {0} is a template, please select one of its variants",项目{0}是模板，请选择其中一个变体
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,How Pricing Rule is applied?,如何应用定价规则？
DocType: Email Digest,Email Digest Settings,电子邮件摘要设置
DocType: Journal Entry,Inter Company Journal Entry,Inter Company Journal Entry
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note_list.js,Create Delivery Trip,创建送货之旅
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Serial No {1} does not match with {2} {3},行＃{0}：序列号{1}与{2} {3}不匹配
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Sales Order required for Item {0},第{0}项所需的销售订单
apps/erpnext/erpnext/hr/doctype/employee_tax_exemption_proof_submission/employee_tax_exemption_proof_submission.js,Get Details From Declaration,从宣言中获取细节
,Support Hour Distribution,支持小时分发
DocType: Company,Allow Account Creation Against Child Company,允许针对儿童公司创建帐户
DocType: Payment Entry,Company Bank Account,公司银行账户
DocType: Amazon MWS Settings,UK,联合王国
DocType: Normal Test Items,Normal Test Items,正常测试项目
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,项{0}：有序数量{1}不能小于最小订单数量{2}（在项目中定义）。
apps/erpnext/erpnext/templates/generators/item/item_add_to_cart.html,Not in Stock,没存货
apps/erpnext/erpnext/templates/includes/navbar/navbar_items.html,Cart,大车
DocType: Course Activity,Course Activity,课程活动
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Thank you for your business!,感谢您的业务！
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,Against Journal Entry {0} is already adjusted against some other voucher,针对日记帐条目{0}已针对其他一些凭证进行调整
DocType: Journal Entry,Bill Date,比尔日期
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Please enter Write Off Account,请输入注销账户
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Biotechnology,生物技术
apps/erpnext/erpnext/setup/setup_wizard/operations/sample_data.py,Setup your Institute in ERPNext,在ERPNext中设置您的学院
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} does not exist,项目{0}不存在
DocType: Asset Maintenance Log,Asset Maintenance Log,资产维护日志
DocType: Accounts Settings,Settings for Accounts,帐户设置
DocType: Bank Guarantee,Reference Document Name,参考文件名称
DocType: Warehouse,"If blank, parent Warehouse Account or company default will be considered",如果为空，则将考虑父仓库帐户或公司默认值
DocType: BOM,Rate Of Materials Based On,基于的材料率
DocType: Water Analysis,Container,容器
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.js,Available slots,可用插槽
DocType: Quiz,Max Attempts,Max尝试
apps/erpnext/erpnext/public/js/financial_statements.js,Cash Flow Statement,现金流量表
DocType: Loyalty Point Entry,Redeem Against,兑换
DocType: Sales Invoice,Offline POS Name,离线POS名称
DocType: Crop Cycle,ISO 8601 standard,ISO 8601标准
DocType: Purchase Taxes and Charges,Deduct,扣除
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-Form发票明细
apps/erpnext/erpnext/accounts/report/cash_flow/cash_flow.py,Net Change in Inventory,库存净变化
apps/erpnext/erpnext/accounts/report/asset_depreciations_and_balances/asset_depreciations_and_balances.py,Depreciation Amount during the period,期内的折旧金额
DocType: Shopify Settings,App Type,应用类型
DocType: Lead,Blog Subscriber,博客订阅者
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js,[Error],[错误]
DocType: Restaurant,Active Menu,活动菜单
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,Transactions against the company already exist! ,针对公司的交易已经存在！
DocType: Customer,Sales Partner and Commission,销售合作伙伴和佣金
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py,Goals cannot be empty,目标不能为空
DocType: Work Order,Warehouses,仓库
DocType: Crop Cycle,Detected Diseases,检出疾病
apps/erpnext/erpnext/accounts/doctype/bank_guarantee/bank_guarantee.py,Enter the Bank Guarantee Number before submittting.,在提交之前输入银行担保编号。
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Processing Items and UOMs,处理物品和UOM
DocType: Payment Request,Is a Subscription,是订阅
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.js,Download as Json,下载为Json
,Appointment Analytics,预约分析
DocType: Quality Inspection,Inspection Type,检查类型
DocType: Sales Invoice,Sales Taxes and Charges,销售税和费用
DocType: Employee,Health Insurance Provider,健康保险提供者
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js,This is a root item group and cannot be edited.,这是根项目组，无法编辑。
DocType: Production Plan,Projected Qty Formula,预计数量公式
DocType: Payment Order,Payment Order Reference,付款订单参考
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Tree Type,树型
DocType: Activity Type,Default Costing Rate,默认成本费率
DocType: Vital Signs,Constipated,大便干燥
DocType: Salary Detail,Default Amount,默认金额
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,Budget List,预算清单
DocType: Job Offer,Awaiting Response,等待回应
apps/erpnext/erpnext/stock/doctype/item/item.js,Variant creation has been queued.,变体创建已排队。
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,"An amount of {0} already claimed for the component {1},\
						 set the amount equal or greater than {2}",已为组件{1}声明的{0}金额，\设置金额等于或大于{2}
apps/erpnext/erpnext/hr/doctype/employee_benefit_application/employee_benefit_application.py,Please add the remaining benefits {0} to any of the existing component,请将剩余的好处{0}添加到任何现有组件中
DocType: Vehicle Log,Odometer,里程表
apps/erpnext/erpnext/accounts/doctype/payment_request/payment_request.py,Transaction currency must be same as Payment Gateway currency,交易货币必须与支付网关货币相同
apps/erpnext/erpnext/controllers/status_updater.py,"For an item {0}, quantity must be negative number",对于项目{0}，数量必须为负数
DocType: Additional Salary,Payroll Date,工资日期
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py,Mode of payment is required to make a payment,付款方式需要付款方式
DocType: BOM,Materials,物料
DocType: Delivery Note Item,Against Sales Order,反对销售订单
DocType: Supplier Quotation,PUR-SQTN-.YYYY.-,PUR-SQTN-.YYYY.-
DocType: Delivery Note Item,Against Sales Order Item,针对销售订单项目
DocType: Appraisal,Goals,目标
DocType: Employee,ERPNext User,ERPNext用户
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application_dashboard.html,Available Leaves,可用叶子
apps/erpnext/erpnext/accounts/doctype/account/account.py,Root Account must be a group,Root帐户必须是一个组
apps/erpnext/erpnext/regional/doctype/gst_settings/gst_settings.py,Email Reminders will be sent to all parties with email contacts,电子邮件提醒将通过电子邮件联系人发送给所有各方
apps/erpnext/erpnext/healthcare/page/appointment_analytic/appointment_analytic.js,Select Type...,选择类型...
DocType: Workstation Working Hour,Workstation Working Hour,工作站工作时间
apps/erpnext/erpnext/config/agriculture.py,Analytics,Analytics（分析）
DocType: Maintenance Team Member,Maintenance Role,维护角色
apps/erpnext/erpnext/config/buying.py,Terms and Conditions Template,条款和条件模板
DocType: Fee Schedule Program,Fee Schedule Program,收费计划
DocType: Project Task,Make Timesheet,制作时间表
DocType: Production Plan Item,Production Plan Item,生产计划项目
apps/erpnext/erpnext/education/report/assessment_plan_status/assessment_plan_status.py,Total Student,学生总数
DocType: Packing Slip,From Package No.,从包裹编号
DocType: Accounts Settings,Shipping Address,收件地址
DocType: Vehicle Service,Clutch Plate,离合器板
apps/erpnext/erpnext/controllers/accounts_controller.py,Row #{0}: Asset {1} does not linked to Item {2},行＃{0}：资产{1}未链接到项目{2}
apps/erpnext/erpnext/stock/doctype/batch/batch.js,Stock Entry {0} created,已创建库存条目{0}
apps/erpnext/erpnext/buying/report/procurement_tracker/procurement_tracker.py,Purchase Order Date,采购订单日期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py,Company currencies of both the companies should match for Inter Company Transactions.,两家公司的公司货币应与国际公司交易相匹配。
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py,Shortage Qty,短缺数量
DocType: Employee Attendance Tool,Marked Attendance,标记出勤
DocType: Pricing Rule,System will notify to increase or decrease quantity or amount ,系统将通知增加或减少数量或金额
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Cosmetics,化妆品
DocType: Naming Series,Check this if you want to force the user to select a series before saving. There will be no default if you check this.,如果要在保存之前强制用户选择系列，请选中此项。如果你检查这个，将没有默认值。
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,具有此角色的用户可以设置冻结帐户并根据冻结帐户创建/修改会计分录
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js,Item Code &gt; Item Group &gt; Brand,商品代码&gt;商品分组&gt;品牌
DocType: Expense Claim,Total Claimed Amount,申索金额总额
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Unable to find Time Slot in the next {0} days for Operation {1},操作{1}的下一个{0}天内无法找到时间段
apps/erpnext/erpnext/setup/setup_wizard/setup_wizard.py,Wrapping up,包起来
apps/erpnext/erpnext/non_profit/doctype/membership/membership.py,You can only renew if your membership expires within 30 days,如果您的会员资格在30天内到期，您只能续订
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Value must be between {0} and {1},值必须介于{0}和{1}之间
DocType: Quality Feedback,Parameters,参数
DocType: Shift Type,Auto Attendance Settings,自动出勤设置
,Sales Partner Transaction Summary,销售合作伙伴交易摘要
DocType: Asset Maintenance,Maintenance Manager Name,维护经理姓名
apps/erpnext/erpnext/public/js/controllers/transaction.js,It is needed to fetch Item Details.,需要获取项目详细信息。
apps/erpnext/erpnext/stock/doctype/item/item_dashboard.py,This is based on stock movement. See {0} for details,这是基于库存变动。有关详细信息，请参阅{0}
DocType: Clinical Procedure,Appointment,约定
apps/erpnext/erpnext/public/js/utils/party.js,Please enter {0} first,请先输入{0}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,BOM #{0}: Raw material cannot be same as main Item,BOM＃{0}：原材料不能与主要材料相同
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Following accounts might be selected in GST Settings:,可能会在GST设置中选择以下帐户：
DocType: Item,You can use any valid Bootstrap 4 markup in this field. It will be shown on your Item Page.,您可以在此字段中使用任何有效的Bootstrap 4标记。它将显示在您的项目页面上。
DocType: Serial No,Incoming Rate,收入率
DocType: Cashier Closing,POS-CLO-,POS-CLO-
DocType: Invoice Discounting,Accounts Receivable Discounted Account,应收帐款折扣帐户
DocType: Tally Migration,Tally Debtors Account,理货债务人账户
DocType: Grant Application,Has any past Grant Record,有任何过去的格兰特记录
DocType: POS Closing Voucher,Amount in Custody,监管金额
DocType: Drug Prescription,Interval,间隔
DocType: Warehouse,Parent Warehouse,家长仓库
apps/erpnext/erpnext/stock/reorder_item.py,Auto Material Requests Generated,生成自动材料请求
apps/erpnext/erpnext/controllers/stock_controller.py,Row {0}: Quality Inspection rejected for item {1},行{0}：项目{1}的质量检验被拒绝
DocType: Vehicle,Additional Details,额外细节
DocType: Sales Partner Type,Sales Partner Type,销售伙伴类型
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js,"Select BOM, Qty and For Warehouse",选择BOM，Qty和For Warehouse
DocType: Asset Maintenance Log,Maintenance Type,维护类型
DocType: Homepage Section,Use this field to render any custom HTML in the section.,使用此字段在该部分中呈现任何自定义HTML。
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment cancelled, Please review and cancel the invoice {0}",预约已取消，请查看并取消发票{0}
DocType: Sales Invoice,Time Sheet List,时间表清单
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,{0} against Bill {1} dated {2},{0}对{2}的比尔{1}
DocType: Shopify Settings,For Company,对于公司
DocType: Linked Soil Analysis,Linked Soil Analysis,连锁土壤分析
DocType: Project,Day to Send,发送日
DocType: Salary Component,Is Tax Applicable,税是否适用
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py,Purchase Order number required for Item {0},项目{0}所需的采购订单编号
DocType: Item Tax Template,Tax Rates,税率
apps/erpnext/erpnext/templates/pages/search_help.py,Help Results for,帮助结果
DocType: Student Admission,Student Admission,学生入学
DocType: Designation Skill,Skill,技能
DocType: Budget Account,Budget Account,预算帐户
DocType: Employee Transfer,Create New Employee Id,创建新的员工ID
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py,{0} is required for 'Profit and Loss' account {1}.,“损益”帐户{1}需要{0}。
apps/erpnext/erpnext/config/accounting.py,Goods and Services Tax (GST India),商品和服务税（GST印度）
apps/erpnext/erpnext/hr/doctype/payroll_entry/payroll_entry.py,Creating Salary Slips...,创建工资单......
DocType: Employee Skill,Employee Skill,员工技能
DocType: Pricing Rule,Apply Rule On Item Code,在物品代码上应用规则
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,'Update Stock' can not be checked because items are not delivered via {0},无法检查“更新库存”，因为商品未通过{0}投放
DocType: Journal Entry,Stock Entry,股票进入
apps/erpnext/erpnext/regional/india/utils.py,House rent paid days overlapping with {0},房屋租金支付天数与{0}重叠
DocType: Employee,Current Address Is,目前的地址是
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Analyst,分析人士
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py,No records found in the Payment table,在“付款”表中找不到任何记录
DocType: Email Digest,Sales Orders to Deliver,要交付的销售订单
DocType: Item,Units of Measure,计量单位
DocType: Leave Block List,Block Days,阻止日
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Quantity must not be more than {0},数量不得超过{0}
apps/erpnext/erpnext/public/js/utils/item_selector.js,Add Items,添加项目
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),税和费用增加（公司货币）
DocType: Accounts Settings,Currency Exchange Settings,货币兑换设置
DocType: Taxable Salary Slab,From Amount,从金额
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Warehouse is mandatory,仓库是强制性的
apps/erpnext/erpnext/utilities/user_progress.py,Add Students,添加学生
DocType: Payment Entry,Account Paid From,帐户已付款
DocType: Employee Attendance Tool,Marked Attendance HTML,标记出席HTML
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Item {0} has been disabled,项目{0}已被禁用
DocType: Cheque Print Template,Amount In Figure,数量在图中
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Cannot produce more Item {0} than Sales Order quantity {1},无法生成比销售订单数量{1}更多的料品{0}
DocType: Purchase Invoice,Return,返回
apps/erpnext/erpnext/stock/doctype/batch/batch.py,The selected item cannot have Batch,所选项目不能具有批次
apps/erpnext/erpnext/regional/report/irs_1099/irs_1099.js,Print IRS 1099 Forms,打印IRS 1099表格
apps/erpnext/erpnext/controllers/accounts_controller.py,'Update Stock' cannot be checked for fixed asset sale,无法检查“更新库存”的固定资产销售情况
DocType: Asset,Depreciation Schedule,折旧表
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,Shipping rule not applicable for country {0},送货规则不适用于国家/地区{0}
DocType: Purchase Receipt,Time at which materials were received,收到材料的时间
DocType: Tax Rule,Billing Country,账单国家
DocType: Journal Entry Account,Sales Order,销售订单
apps/erpnext/erpnext/hr/doctype/employee_promotion/employee_promotion.js,Value missing,价值缺失
apps/erpnext/erpnext/stock/doctype/item/item.py,Stores,商店
DocType: Exchange Rate Revaluation Account,New Balance In Base Currency,基础货币的新余额
DocType: POS Profile,Price List,价目单价目表
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py,Invalid {0}: {1},无效{0}：{1}
DocType: Article,Article,文章
apps/erpnext/erpnext/public/js/setup_wizard.js,The name of the institute for which you are setting up this system.,您要为其设置此系统的机构的名称。
apps/erpnext/erpnext/utilities/user_progress.py,A Product,一个产品
DocType: Crop,Crop Name,裁剪名称
apps/erpnext/erpnext/stock/report/batch_item_expiry_status/batch_item_expiry_status.py,'From Date' is required,&#39;从日期&#39;是必需的
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py,Please select a BOM,请选择一个BOM
DocType: Travel Itinerary,Travel Itinerary,行程
apps/erpnext/erpnext/hr/doctype/employee/employee.py,Birthday Reminder,生日提醒
apps/erpnext/erpnext/utilities/user_progress.py,Pair,对
apps/erpnext/erpnext/stock/get_item_details.py,Item Price added for {0} in Price List {1},价格清单{1}中为{0}添加的商品价格
DocType: Pricing Rule,Validate Applied Rule,验证应用规则
DocType: Job Card Item,Job Card Item,工作卡项目
DocType: Homepage,Company Tagline for website homepage,公司标语为网站主页
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Set Response Time and Resolution for Priority {0} at index {1}.,在索引{1}处设置优先级{0}的响应时间和分辨率。
DocType: Company,Round Off Cost Center,圆形成本中心
DocType: Supplier Scorecard Criteria,Criteria Weight,标准重量
DocType: Asset,Depreciation Schedules,折旧表
DocType: Subscription,Discounts,折扣
DocType: Shipping Rule,Shipping Rule Conditions,运输规则条件
DocType: Subscription,Cancelation Date,取消日期
DocType: Payment Entry,Party Bank Account,党银行账户
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center_tree.js,New Cost Center Name,新成本中心名称
DocType: Promotional Scheme Price Discount,Max Amount,最大金额
DocType: Shopping Cart Settings,After payment completion redirect user to selected page.,付款完成后，将用户重定向到所选页面。
DocType: Salary Slip,Total Loan Repayment,贷款还款总额
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js,To Fiscal Year,到财政年度
DocType: Delivery Note,Return Against Delivery Note,退货交货单
apps/erpnext/erpnext/public/js/utils/item_quick_entry.js,"Edit in full page for more options like assets, serial nos, batches etc.",在整页编辑以获取更多选项，如资产，序列号，批次等。
DocType: Payment Entry,Allocate Payment Amount,分配付款金额
apps/erpnext/erpnext/controllers/sales_and_purchase_return.py,Row # {0}: Returned Item {1} does not exists in {2} {3},行＃{0}：{2} {3}中不存在返回的项{1}
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.js,Enrolling students,招收学生
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,允许用户编辑交易中的价格清单率
apps/erpnext/erpnext/selling/report/sales_partner_commission_summary/sales_partner_commission_summary.py,Please select the document type first,请先选择文档类型
DocType: Hotel Room Reservation,Hotel Room Reservation,酒店客房预订
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Researcher,研究员
apps/erpnext/erpnext/accounts/party.py,{0} {1} is frozen,{0} {1}被冻结
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py,Item Code cannot be changed for Serial No.,序列号无法更改项目代码
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),总税金和收费（公司货币）
apps/erpnext/erpnext/accounts/doctype/tax_rule/tax_rule.py,Tax Rule Conflicts with {0},税收规则与{0}冲突
DocType: Fiscal Year,Year End Date,年终日期
apps/erpnext/erpnext/utilities/activation.py,Create Leads,创建潜在客户
apps/erpnext/erpnext/accounts/report/profitability_analysis/profitability_analysis.js,Show zero values,显示零值
DocType: Employee Onboarding,Employee Onboarding,员工入职
DocType: POS Closing Voucher,Period End Date,期末日期
DocType: Department,The first Leave Approver in the list will be set as the default Leave Approver.,列表中的第一个Leave Approver将被设置为默认的Leave Approver。
DocType: POS Settings,POS Settings,POS设置
apps/erpnext/erpnext/accounts/doctype/chart_of_accounts_importer/chart_of_accounts_importer.js,All Accounts,所有账户
DocType: Hotel Room,Hotel Manager,酒店经理
DocType: Opportunity,With Items,有物品
DocType: GL Entry,Is Advance,是先进的
DocType: Membership,Membership Status,会员身份
apps/erpnext/erpnext/config/crm.py,Sales campaigns.,销售活动。
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py,Default BOM not found for Item {0} and Project {1},项目{0}和项目{1}找不到默认BOM
DocType: Leave Type,Encashment Threshold Days,兑现门槛天数
apps/erpnext/erpnext/stock/report/item_prices/item_prices.js,Items Filter,物品过滤
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,{0} is on hold till {1},{0}暂停{1}
DocType: Clinical Procedure Item,Invoice Separately as Consumables,发票单独作为耗材
DocType: Subscription,Days Until Due,截止日期
apps/erpnext/erpnext/templates/pages/projects.js,Show Completed,显示已完成
apps/erpnext/erpnext/config/accounting.py,Bank Statement Transaction Entry Report,银行对账单交易录入报告
apps/erpnext/erpnext/accounts/doctype/bank/bank_dashboard.py,Bank Deatils,银行Deatils
apps/erpnext/erpnext/utilities/transaction_base.py,Row #{0}: Rate must be same as {1}: {2} ({3} / {4}) ,行＃{0}：费率必须与{1}相同：{2}（{3} / {4}）
DocType: Clinical Procedure,HLC-CPR-.YYYY.-,HLC-CPR-.YYYY.-
DocType: Healthcare Settings,Healthcare Service Items,医疗服务项目
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js,Ageing Range 3,老龄化范围3
DocType: Vital Signs,Blood Pressure,血压
apps/erpnext/erpnext/selling/report/sales_partner_target_variance_based_on_item_group/sales_partner_target_variance_based_on_item_group.js,Target On,目标开启
apps/erpnext/erpnext/patches/v11_0/add_healthcare_service_unit_tree_root.py,All Healthcare Service Units,所有医疗服务单位
apps/erpnext/erpnext/education/doctype/program_enrollment_tool/program_enrollment_tool.py,Mandatory field - Program,必填项目 - 计划
apps/erpnext/erpnext/public/js/projects/timer.js,Timer,计时器
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Set {0} in asset category {1} or company {2},在资产类别{1}或公司{2}中设置{0}
DocType: Bank Statement Settings Item,Bank Header,银行标题
apps/erpnext/erpnext/education/doctype/student_applicant/student_applicant.py,Not eligible for the admission in this program as per DOB,根据DOB，不符合参加此计划的资格
DocType: Assessment Criteria,Assessment Criteria Group,评估标准组
DocType: Options,Is Correct,是正确的
apps/erpnext/erpnext/utilities/user_progress.py,user@example.com,user@example.com
DocType: Department,Parent Department,家长部
DocType: Employee Internal Work History,Employee Internal Work History,员工内部工作历史
DocType: Supplier,Warn POs,警告PO
DocType: Employee,Offer Date,优惠日期
DocType: Sales Invoice,Product Bundle Help,产品包帮助
DocType: Stock Reconciliation,Stock Reconciliation,股票和解
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py,Accounting Entry for Stock,股票会计分录
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,"Appointment overlaps with {0}.<br> {1} has appointment scheduled
			with {2} at {3} having {4} minute(s) duration.",约会与{0}重叠。 <br> {1}预约时间为{2}，{3}的时间为{4}分钟。
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py,Warehouses with child nodes cannot be converted to ledger,具有子节点的仓库无法转换为分类帐
DocType: Project,Projects Manager,项目经理
apps/erpnext/erpnext/hr/doctype/training_event/training_event.py,End time cannot be before start time,结束时间不能在开始时间之前
DocType: UOM,UOM Name,UOM名称
DocType: Vital Signs,BMI,BMI
apps/erpnext/erpnext/projects/doctype/project/project_dashboard.html,Hours,小时
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.py,Amount {0} {1} {2} {3},金额{0} {1} {2} {3}
,Supplier Ledger Summary,供应商分类帐摘要
apps/erpnext/erpnext/education/report/student_and_guardian_contact_details/student_and_guardian_contact_details.py,Student Email ID,学生电子邮件ID
apps/erpnext/erpnext/config/integrations.py,GoCardless SEPA Mandate,GoCardless SEPA授权
DocType: Bank Account,IBAN,IBAN
DocType: Restaurant Reservation,No of People,没有人
apps/erpnext/erpnext/accounts/report/tds_computation_summary/tds_computation_summary.py,From Date and To Date lie in different Fiscal Year,从日期和日期到不同的财政年度
apps/erpnext/erpnext/healthcare/utils.py,The Patient {0} do not have customer refrence to invoice,患者{0}没有客户参考发票
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,Syntax error in condition: {0},条件语法错误：{0}
DocType: Payment Entry,Transaction ID,交易ID
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py,Please enter message before sending,请在发送前输入消息
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Ref Date,参考日期
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,注意：此成本中心是一个组。无法对组进行会计分录。
DocType: Soil Analysis,Soil Analysis Criterias,土壤分析标准
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packing Slip(s) cancelled,装箱单已取消
DocType: Company,Existing Company,现有公司
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Batches,批
apps/erpnext/erpnext/setup/setup_wizard/data/industry_type.py,Defense,防御
DocType: Item,Has Batch No,有批号
apps/erpnext/erpnext/stock/report/delayed_item_report/delayed_item_report.py,Delayed Days,延迟天数
DocType: Lead,Person Name,人名
DocType: Item Variant,Item Variant,项目变体
DocType: Training Event Employee,Invited,邀请
apps/erpnext/erpnext/hr/doctype/employee_benefit_claim/employee_benefit_claim.py,Maximum amount eligible for the component {0} exceeds {1},组件{0}的最大合格金额超过{1}
apps/erpnext/erpnext/accounts/report/purchase_order_items_to_be_billed/purchase_order_items_to_be_billed.py,Amount to Bill,账单金额
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py,"For {0}, only debit accounts can be linked against another credit entry",对于{0}，只有借方帐户可以与另一个贷方条目链接
apps/erpnext/erpnext/accounts/doctype/accounting_dimension/accounting_dimension.py,Creating Dimensions...,创建尺寸......
DocType: Bank Statement Transaction Entry,Payable Account,应付账款
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please mention no of visits required,请注明不需要访问
DocType: Accounts Settings,Only select if you have setup Cash Flow Mapper documents,仅在您设置Cash Flow Mapper文档时选择
apps/erpnext/erpnext/healthcare/doctype/patient_appointment/patient_appointment.py,{0} is a company holiday,{0}是公司假期
DocType: Item,Items with higher weightage will be shown higher,重量较高的物品会显得较高
DocType: Project,Project will be accessible on the website to these users,可以在网站上向这些用户访问项目
apps/erpnext/erpnext/stock/doctype/item/item.py,Attribute table is mandatory,属性表是必需的
DocType: Salary Slip,Total Working Hours,总工作时间
DocType: Crop,Planting UOM,种植UOM
DocType: Inpatient Record,O Negative,O否定
DocType: Purchase Order,To Receive and Bill,收到和比尔
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py,"Start and end dates not in a valid Payroll Period, cannot calculate {0}.",不在有效工资核算期内的开始和结束日期无法计算{0}。
DocType: POS Profile,Only show Customer of these Customer Groups,仅显示这些客户组的客户
apps/erpnext/erpnext/accounts/page/pos/pos.js,Select items to save the invoice,选择要保存发票的项目
DocType: Service Level Priority,Resolution Time,解决时间
DocType: Grading Scale Interval,Grade Description,等级描述
DocType: Homepage Section,Cards,牌
DocType: Quality Meeting Minutes,Quality Meeting Minutes,质量会议纪要
DocType: Linked Plant Analysis,Linked Plant Analysis,连接植物分析
apps/erpnext/erpnext/public/js/controllers/transaction.js,Service Stop Date cannot be after Service End Date,服务停止日期不能在服务结束日期之后
apps/erpnext/erpnext/regional/report/gstr_1/gstr_1.py,Please set B2C Limit in GST Settings.,请在GST设置中设置B2C限制。
DocType: Member,Member Name,成员名字
DocType: Account,Payable,应付帐款
DocType: Job Card,For Quantity,数量
DocType: Territory,For reference,以供参考
apps/erpnext/erpnext/templates/generators/item/item_configure.js,Add to Cart,添加到购物车
DocType: Global Defaults,Global Defaults,全局默认值
DocType: Leave Application,Follow via Email,通过电子邮件关注
DocType: Leave Allocation,Total Leaves Allocated,分配的叶子总数
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js,Raw Material,原材料
DocType: Manufacturer,Limited to 12 characters,限12个字符
DocType: Selling Settings,Customer Naming By,客户命名
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py,Packed quantity must equal quantity for Item {0} in row {1},包装数量必须等于第{1}行中第{0}项的数量
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person_tree.js,New Sales Person Name,新的销售人员姓名
DocType: Amazon MWS Settings,Amazon will synch data updated after this date,亚马逊将同步在此日期之后更新的数据
DocType: Service Day,Service Day,服务日
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),扣除税款和收费（公司货币）
DocType: Project,Gross Margin %,毛利率％
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py,Bank Statement balance as per General Ledger,根据总帐的银行对帐单余额
apps/erpnext/erpnext/public/js/setup_wizard.js,Healthcare (beta),医疗保健（测试版
DocType: Shopify Settings,Default Warehouse to to create Sales Order and Delivery Note,默认仓库以创建销售订单和交货单
apps/erpnext/erpnext/support/doctype/service_level/service_level.py,Response Time for {0} at index {1} can't be greater than Resolution Time.,索引{1}处的{0}的响应时间不能大于“解决时间”。
DocType: Opportunity,Customer / Lead Name,客户/主要名称
DocType: Student,EDU-STU-.YYYY.-,EDU-STU-.YYYY.-
DocType: Expense Claim Advance,Unclaimed amount,无人认领的金额
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Source and target warehouse cannot be same for row {0},行{0}的源仓库和目标仓库不能相同
apps/erpnext/erpnext/assets/doctype/asset/asset.py,Depreciation Row {0}: Expected value after useful life must be greater than or equal to {1},折旧行{0}：使用寿命后的预期值必须大于或等于{1}
apps/erpnext/erpnext/education/report/absent_student_report/absent_student_report.py,Please select date,请选择日期
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py,Salary Structure should have flexible benefit component(s) to dispense benefit amount,薪酬结构应具有灵活的福利成分以分配福利金额
DocType: Employee Attendance Tool,Employee Attendance Tool,员工出勤工具
DocType: Employee,Educational Qualification,教育资格
apps/erpnext/erpnext/regional/report/eway_bill/eway_bill.py,Accessable Value,可访问的价值
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py,Sample quantity {0} cannot be more than received quantity {1},样品数量{0}不能超过收货数量{1}
DocType: POS Profile,Taxes and Charges,税和费用
DocType: Opportunity,Contact Mobile No,联系手机号
DocType: Employee,Joining Details,加入细节
apps/erpnext/erpnext/manufacturing/doctype/job_card/job_card.js,Start Job,开始工作
DocType: Quality Action Table,Quality Action Table,质量行动表
DocType: Healthcare Practitioner,Phone (Office),电话（办公室）
DocType: Timesheet Detail,Operation ID,操作ID
DocType: Soil Texture,Silt Loam,淤泥壤土
apps/erpnext/erpnext/accounts/doctype/opening_invoice_creation_tool/opening_invoice_creation_tool.py,Please set the Default Cost Center in {0} company.,请在{0}公司中设置默认成本中心。
apps/erpnext/erpnext/education/doctype/student_group/student_group.js,Update Email Group,更新电子邮件组
DocType: Employee Promotion,Employee Promotion Detail,员工晋升细节
DocType: Loan Application,Repayment Info,还款信息
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js,Show unclosed fiscal year's P&L balances,显示未结算的会计年度损益表余额
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.py,"{0} indicates that {1} will not provide a quotation, but all items \
					have been quoted. Updating the RFQ quote status.",{0}表示{1}不会提供报价，但所有商品都已引用。更新RFQ报价状态。
DocType: Asset,Finance Books,财经书籍
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py,"Buying must be checked, if Applicable For is selected as {0}",必须检查购买，如果选择适用于{0}
DocType: Stock Settings,Role Allowed to edit frozen stock,角色允许编辑冻结库存
apps/erpnext/erpnext/crm/report/prospects_engaged_but_not_converted/prospects_engaged_but_not_converted.py,Last Communication Date,最后通讯日期
DocType: Activity Cost,Costing Rate,成本率
DocType: Shipping Rule,example: Next Day Shipping,例如：次日送货
DocType: Bank Statement Transaction Entry,Payment Invoice Items,付款发票项目
apps/erpnext/erpnext/agriculture/doctype/crop_cycle/crop_cycle.py,Tasks have been created for managing the {0} disease (on row {1}),已经创建了用于管理{0}疾病的任务（在行{1}上）
DocType: Healthcare Settings,Confirmation Message,确认消息
DocType: Lab Test UOM,Lab Test UOM,实验室测试UOM
DocType: Leave Type,Earned Leave Frequency,获得休假频率
DocType: Loyalty Program,Loyalty Program Type,忠诚度计划类型
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py,"Shipping Address does not have country, which is required for this Shipping Rule",送货地址没有国家/地区，这是此送货规则所必需的
DocType: POS Profile,Terms and Conditions,条款和条件
apps/erpnext/erpnext/maintenance/doctype/maintenance_schedule/maintenance_schedule.py,Please click on 'Generate Schedule',请点击“生成时间表”
DocType: Sales Invoice,Total Qty,总数量
apps/erpnext/erpnext/regional/doctype/gstr_3b_report/gstr_3b_report.html,All other ITC,所有其他ITC
apps/erpnext/erpnext/erpnext_integrations/doctype/tally_migration/tally_migration.py,Importing Parties and Addresses,进口缔约方和地址
DocType: Item,List this Item in multiple groups on the website.,在网站上的多个组中列出此项目。
DocType: Request for Quotation,Message for Supplier,供应商消息
DocType: Healthcare Practitioner,Phone (R),电话（R）
DocType: Maintenance Team Member,Team Member,队员
DocType: Asset Category Account,Asset Category Account,资产类别帐户
,Team Updates,团队更新
DocType: Bank Account,Party,派对
DocType: Soil Analysis,Ca/Mg,钙/镁
DocType: Purchase Invoice,Write Off Amount (Company Currency),注销金额（公司货币）
DocType: Stock Entry,Including items for sub assemblies,包括子装配的项目
DocType: Course Topic,Topic Name,主题名称
DocType: Budget,Applicable on booking actual expenses,适用于预订实际费用
DocType: Purchase Invoice,Start date of current invoice's period,当前发票期间的开始日期
apps/erpnext/erpnext/utilities/user_progress.py,Litre,升
DocType: Marketplace Settings,Hub Seller Name,集线器卖家名称
DocType: Stock Entry,Total Outgoing Value,总出局值
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js,Auto repeat document updated,自动重复文档已更新
apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included",对于{1}中的行{0}。要在项目费率中包含{2}，还必须包含行{3}
apps/erpnext/erpnext/config/stock.py,Serial No and Batch,序列号和批处理
DocType: Contract,Fulfilment Deadline,履行截止日期
apps/erpnext/erpnext/manufacturing/doctype/work_order/work_order.js,Create Job Card,创建工作卡
,Sales Person Commission Summary,销售人员委员会摘要
apps/erpnext/erpnext/stock/doctype/delivery_trip/delivery_trip.py,"Cannot process route, since Google Maps Settings is disabled.",由于禁用了Google地图设置，因此无法处理路线。
apps/erpnext/erpnext/utilities/user_progress.py,Go to Items,转到项目
DocType: Asset Value Adjustment,Current Asset Value,当前资产价值
DocType: Support Search Source,Result Preview Field,结果预览字段
apps/erpnext/erpnext/public/js/utils/serial_no_batch_selector.js,Please enter serial numbers for serialized item ,请输入序列化物品的序列号
DocType: GL Entry,Against Voucher Type,凭证类型
DocType: Contract Template Fulfilment Terms,Contract Template Fulfilment Terms,合同模板履行条款
apps/erpnext/erpnext/hr/doctype/leave_period/leave_period.py,Allocating leaves...,分配叶子......
DocType: Student Applicant,Admitted,承认
apps/erpnext/erpnext/templates/includes/footer/footer_extension.html,Get Updates,获取更新
apps/erpnext/erpnext/setup/setup_wizard/operations/install_fixtures.py,Black,黑色
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py,Year start date or end date is overlapping with {0}. To avoid please set company,年份开始日期或结束日期与{0}重叠。为了避免请设置公司
apps/erpnext/erpnext/templates/pages/projects.html,Show closed,显示已关闭
DocType: Sample Collection,No. of print,打印数量
DocType: Sample Collection,HLC-SC-.YYYY.-,HLC-SC-.YYYY.-
