DocType: Employee,Salary Mode,薪酬模式
DocType: Cost Center,"Select Monthly Distribution, if you want to track based on seasonality.",選擇月度分配，如果你想根據季節進行跟踪。
DocType: Employee,Divorced,離婚
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +54,Warning: Same item has been entered multiple times.,警告：相同項目已經輸入多次。
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +96,Items already synced,項目已同步
DocType: Purchase Order,"If you have created a standard template in Purchase Taxes and Charges Template, select one and click on the button below.",如果您已經創建了購置稅和費模板標準模板，選擇一個，然後點擊下面的按鈕。
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +33,Cancel Material Visit {0} before cancelling this Warranty Claim,材質訪問{0}之前取消此保修索賠取消
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +18,Consumer Products,消費類產品
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +72,Please select Party Type first,請選擇黨第一型
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +89,Annealing,退火
DocType: Item,Customer Items,客戶項目
apps/erpnext/erpnext/accounts/doctype/account/account.py +41,Account {0}: Parent account {1} can not be a ledger,帳戶{0}：父帳戶{1}不能是總賬
DocType: Item,Publish Item to hub.erpnext.com,發布項目hub.erpnext.com
apps/erpnext/erpnext/config/setup.py +63,Email Notifications,電子郵件通知
DocType: Item,Default Unit of Measure,缺省的計量單位
DocType: SMS Center,All Sales Partner Contact,所有的銷售合作夥伴聯繫
DocType: Employee,Leave Approvers,休假審批人
DocType: Sales Partner,Dealer,零售商
DocType: Employee,Rented,租
DocType: Stock Entry,Get Stock and Rate,獲取庫存和匯率
DocType: About Us Settings,Website,網站
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +22,Compaction plus sintering,壓實加燒結
DocType: Sales BOM,"The Item that represents the Package. This Item must have ""Is Stock Item"" as ""No"" and ""Is Sales Item"" as ""Yes""",代表包裝的項目。該項目必須有“是股票項目”為“否”和“是銷售項目”為“是”
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +99,Currency is required for Price List {0},貨幣所需的價格表{0}
DocType: Sales Taxes and Charges Template,* Will be calculated in the transaction.,*將被計算在該交易。
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +125,Please enter Employee Id of this sales parson,請輸入本銷售人員的員工ID
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_googledrive.py +120,Please set Google Drive access keys in {0},請設置Google Drive的存取碼{0}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +542,From Material Request,從物料需求
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +39,{0} Tree,{0}樹
DocType: Job Applicant,Job Applicant,求職者
apps/erpnext/erpnext/hub_node/page/hub/hub_body.html +18,No more results.,沒有更多的結果。
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +73,Legal,法律
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +114,Actual type tax cannot be included in Item rate in row {0},實際類型稅不能被包含在商品率排{0}
DocType: C-Form,Customer,客戶
DocType: Purchase Receipt Item,Required By,需求來自
DocType: Department,Department,部門
DocType: Purchase Order,% Billed,％帳單
DocType: Selling Settings,Customer Name,客戶名稱
DocType: Features Setup,"All export related fields like currency, conversion rate, export total, export grand total etc are available in Delivery Note, POS, Quotation, Sales Invoice, Sales Order etc.",在送貨單， POS機，報價單，銷售發票，銷售訂單等可像貨幣，轉換率，進出口總額，出口總計等所有出口相關領域
DocType: Account,Heads (or groups) against which Accounting Entries are made and balances are maintained.,頭（或組）針對其會計分錄是由和平衡得以維持。
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +143,Outstanding for {0} cannot be less than zero ({1}),傑出的{0}不能小於零（ {1} ）
DocType: Manufacturing Settings,Default 10 mins,默認為10分鐘
DocType: Leave Type,Leave Type Name,休假類型名稱
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +143,Series Updated Successfully,系列已成功更新
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +149,Stitching,拼接
DocType: Pricing Rule,Apply On,適用於
DocType: Item Price,Multiple Item prices.,多個項目的價格。
,Purchase Order Items To Be Received,欲收受的採購訂單品項
DocType: SMS Center,All Supplier Contact,所有供應商聯繫
DocType: Quality Inspection Reading,Parameter,參數
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +52,Please specify a Price List which is valid for Territory,請指定價格清單有效期為領地
apps/erpnext/erpnext/projects/doctype/project/project.py +35,Expected End Date can not be less than Expected Start Date,預計結束日期不能小於預期開始日期
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +235,Do really want to unstop production order:,難道真的要unstop生產訂單：
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +190,New Leave Application,新假期申請
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +129,Bank Draft,銀行匯票
DocType: Features Setup,1. To maintain the customer wise item code and to make them searchable based on their code use this option,1。為了保持客戶明智的項目代碼，並使其搜索根據自己的代碼中使用這個選項
DocType: Mode of Payment Account,Mode of Payment Account,支付帳戶模式
apps/erpnext/erpnext/stock/doctype/item/item.js +60,Show Variants,顯示變體
DocType: Sales Invoice Item,Quantity,數量
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +174,Loans (Liabilities),借款（負債）
DocType: Employee Education,Year of Passing,路過的一年
DocType: Designation,Designation,指定
DocType: Production Plan Item,Production Plan Item,生產計劃項目
apps/erpnext/erpnext/hr/doctype/employee/employee.py +137,User {0} is already assigned to Employee {1},用戶{0}已經被分配給員工{1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +30,Health Care,保健
DocType: Purchase Invoice,Monthly,每月一次
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Invoice,發票
DocType: Maintenance Schedule Item,Periodicity,週期性
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +355,Email Address,電子郵件地址
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +20,Defense,防禦
DocType: Company,Abbr,縮寫
DocType: Appraisal Goal,Score (0-5),得分（0-5）
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +205,Row {0}: {1} {2} does not match with {3},行{0}：{1} {2}不相匹配{3}
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +62,Row # {0}:,行＃{0}：
DocType: Delivery Note,Vehicle No,車輛無
sites/assets/js/erpnext.min.js +50,Please select Price List,請選擇價格表
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +161,Woodworking,木工
DocType: Production Order Operation,Work In Progress,工作進行中
DocType: Company,If Monthly Budget Exceeded,如果每月超出預算
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +152,3D printing,3D打印
DocType: Employee,Holiday List,假日列表
DocType: Time Log,Time Log,時間日誌
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +80,Accountant,會計人員
DocType: Company,Phone No,電話號碼
DocType: Time Log,"Log of Activities performed by users against Tasks that can be used for tracking time, billing.",活動日誌由用戶對任務可用於跟踪時間，計費執行。
apps/erpnext/erpnext/controllers/recurring_document.py +125,New {0}: #{1},新{0}：＃{1}
,Sales Partners Commission,銷售合作夥伴佣金
apps/erpnext/erpnext/setup/doctype/company/company.py +31,Abbreviation cannot have more than 5 characters,縮寫不能有超過5個字符
DocType: Backup Manager,Allow Google Drive Access,允許Google Drive訪問
DocType: Email Digest,Projects & System,專案及系統
DocType: Print Settings,Classic,經典
apps/erpnext/erpnext/accounts/doctype/account/account.js +27,This is a root account and cannot be edited.,這是一個root帳戶，不能被編輯。
DocType: Shopping Cart Settings,Shipping Rules,航運規則
DocType: BOM,Operations,操作
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +38,Cannot set authorization on basis of Discount for {0},不能在折扣的基礎上設置授權{0}
DocType: Bin,Quantity Requested for Purchase,需購買的數量
DocType: Rename Tool,"Attach .csv file with two columns, one for the old name and one for the new name",附加.csv文件有兩列，一為舊名稱，一個用於新名稱
DocType: Packed Item,Parent Detail docname,家長可採用DocName細節
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Kg,公斤
apps/erpnext/erpnext/config/hr.py +48,Opening for a Job.,開放的工作。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +5,Advertising,廣告
DocType: Employee,Married,已婚
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +339,Stock cannot be updated against Delivery Note {0},股票不能對送貨單更新的{0}
DocType: Payment Reconciliation,Reconcile,調和
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +29,Grocery,雜貨
DocType: Quality Inspection Reading,Reading 1,閱讀1
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +93,Make Bank Entry,使銀行進入
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +39,Pension Funds,養老基金
apps/erpnext/erpnext/accounts/doctype/account/account.py +116,Warehouse is mandatory if account type is Warehouse,倉庫是強制性的，如果賬戶類型是倉庫
DocType: SMS Center,All Sales Person,所有的銷售人員
DocType: Backup Manager,Credentials,證書
DocType: Purchase Order,"Check if recurring order, uncheck to stop recurring or put proper End Date",檢查經常性秩序，取消，停止經常性或將適當的結束日期
DocType: Sales Invoice Item,Sales Invoice Item,銷售發票項目
DocType: Account,Credit,信用
apps/erpnext/erpnext/hr/doctype/employee/employee.py +25,Please setup Employee Naming System in Human Resource > HR Settings,請在「人力資源＞人力資源設置」設定員工命名系統
DocType: POS Setting,Write Off Cost Center,沖銷成本中心
DocType: Warehouse,Warehouse Detail,倉庫的詳細信息
apps/erpnext/erpnext/selling/doctype/customer/customer.py +159,Credit limit has been crossed for customer {0} {1}/{2},信用額度已經越過了客戶{0} {1} / {2}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +114,You are not authorized to add or update entries before {0},你無權之前添加或更新條目{0}
apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.py +27,Parent Item {0} must be not Stock Item and must be a Sales Item,父項{0}必須不是庫存產品，必須是一個銷售項目
DocType: Item,Item Image (if not slideshow),產品圖片（如果不是幻燈片）
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.py +20,An Customer exists with same name,一個客戶存在具有相同名稱
DocType: Production Order Operation,(Hour Rate / 60) * Actual Operation Time,（小時率/ 60）*實際操作時間
DocType: SMS Log,SMS Log,短信日誌
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Delivered Items,交付項目成本
DocType: Blog Post,Guest,客人
DocType: Quality Inspection,Get Specification Details,獲取詳細規格
DocType: Lead,Interested,有興趣
apps/erpnext/erpnext/config/manufacturing.py +14,Bill of Material,物料清單
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +32,From {0} to {1},從{0} {1}
DocType: Item,Copy From Item Group,複製從項目組
DocType: Journal Entry,Opening Entry,開放報名
apps/erpnext/erpnext/controllers/trends.py +33,{0} is mandatory,{0}是強制性的
apps/erpnext/erpnext/config/setup.py +111,Contact master.,聯繫站長。
apps/erpnext/erpnext/accounts/doctype/account/account.py +87,Account with existing transaction can not be converted to group.,帳戶與現有的交易不能被轉換到群組。
DocType: Lead,Product Enquiry,產品查詢
DocType: Standard Reply,Owner,業主
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +13,Please enter company first,請先輸入公司
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +35,Please select Company first,請首先選擇公司
DocType: Employee Education,Under Graduate,根據研究生
apps/erpnext/erpnext/selling/report/sales_person_target_variance_item_group_wise/sales_person_target_variance_item_group_wise.js +22,Target On,目標在
DocType: BOM,Total Cost,總成本
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +98,Reaming,擴孔
DocType: Email Digest,Stub,存根
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +8,Activity Log:,活動日誌：
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +202,Item {0} does not exist in the system or has expired,項目{0}不存在於系統中或已過期
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +43,Real Estate,房地產
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.html +4,Statement of Account,帳戶狀態
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +40,Pharmaceuticals,製藥
DocType: Expense Claim Detail,Claim Amount,索賠金額
DocType: Employee,Mr,先生
DocType: Custom Script,Client,客戶
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +33,Supplier Type / Supplier,供應商類型/供應商
DocType: Naming Series,Prefix,字首
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,Consumable,耗材
DocType: Upload Attendance,Import Log,導入日誌
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.js +19,Send,發送
DocType: SMS Center,All Contact,所有聯繫
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +159,Annual Salary,年薪
DocType: Period Closing Voucher,Closing Fiscal Year,截止會計年度
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +69,Stock Expenses,庫存費用
DocType: Newsletter,Email Sent?,郵件發送？
DocType: Journal Entry,Contra Entry,魂斗羅進入
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +89,Show Time Logs,顯示的時間記錄
DocType: Email Digest,Bank/Cash Balance,銀行／現金結餘
DocType: Delivery Note,Installation Status,安裝狀態
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +97,Accepted + Rejected Qty must be equal to Received quantity for Item {0},品項{0}的允收＋批退的數量必須等於收到量
DocType: Item,Supply Raw Materials for Purchase,供應原料採購
apps/erpnext/erpnext/stock/get_item_details.py +134,Item {0} must be a Purchase Item,項{0}必須是一個採購項目
DocType: Upload Attendance,"Download the Template, fill appropriate data and attach the modified file.
All dates and employee combination in the selected period will come in the template, with existing attendance records","下載模板，填寫相應的數據，並附加了修改過的文件。
在選定時間段內所有時間和員工的組合會在模板中，與現有的考勤記錄"
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +496,Item {0} is not active or end of life has been reached,項目{0}不活躍或生命的盡頭已經達到
DocType: Time Log Batch,Will be updated after Sales Invoice is Submitted.,之後銷售發票已提交將被更新。
apps/erpnext/erpnext/controllers/accounts_controller.py +385,"To include tax in row {0} in Item rate, taxes in rows {1} must also be included",要包括稅款，行{0}項率，稅收行{1}也必須包括在內
apps/erpnext/erpnext/config/hr.py +90,Settings for HR Module,設定人力資源模塊
DocType: SMS Center,SMS Center,短信中心
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +77,Straightening,直
DocType: BOM Replace Tool,New BOM,新的物料清單
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +132,There were no updates in the items selected for this digest.,還有人入選本月刊的項目沒有更新。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +14,Countergravity casting,反重力鑄造
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +28,Newsletter has already been sent,新聞已發送
DocType: Lead,Request Type,請求類型
DocType: Leave Application,Reason,原因
DocType: Purchase Invoice,The rate at which Bill Currency is converted into company's base currency,在該條例草案的貨幣轉換成公司的基礎貨幣的比率
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +13,Broadcasting,廣播
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +135,Execution,執行
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +362,The first user will become the System Manager (you can change this later).,第一個用戶將成為系統管理器（你可以改變這個版本）。
apps/erpnext/erpnext/config/manufacturing.py +39,Details of the operations carried out.,的操作的細節進行。
DocType: Serial No,Maintenance Status,維修狀態
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +37,From Date should be within the Fiscal Year. Assuming From Date = {0},從日期應該是在財政年度內。假設起始日期＝{0}
DocType: Appraisal,Select the Employee for whom you are creating the Appraisal.,選擇要為其創建的考核員工。
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +90,Cost Center {0} does not belong to Company {1},成本中心{0}不屬於公司{1}
DocType: Customer,Individual,個人
apps/erpnext/erpnext/config/support.py +23,Plan for maintenance visits.,規劃維護訪問。
DocType: SMS Settings,Enter url parameter for message,輸入url參數的消息
apps/erpnext/erpnext/config/selling.py +143,Rules for applying pricing and discount.,規則適用的定價和折扣。
apps/erpnext/erpnext/stock/doctype/price_list/price_list.py +14,Price List must be applicable for Buying or Selling,價格表必須適用於購買或出售
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +90,Installation date cannot be before delivery date for Item {0},品項{0}的安裝日期不能早於交付日期
sites/assets/js/form.min.js +261,Start,開始
DocType: User,First Name,名字
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +602,Your setup is complete. Refreshing.,您的設置就完成了。令人耳目一新。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +11,Full-mold casting,全模鑄造
DocType: Offer Letter,Select Terms and Conditions,選擇條款和條件
DocType: Email Digest,Payments made during the digest period,在消化期間支付的款項
DocType: Production Planning Tool,Sales Orders,銷售訂單
DocType: Purchase Taxes and Charges,Valuation,計價
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +17,Set as Default,設置為默認
,Purchase Order Trends,採購訂單趨勢
apps/erpnext/erpnext/config/hr.py +78,Allocate leaves for the year.,離開一年。
DocType: Earning Type,Earning Type,收入類型
DocType: Email Digest,New Sales Orders,新的銷售訂單
DocType: Bank Reconciliation,Bank Account,銀行帳戶
DocType: Leave Type,Allow Negative Balance,允許負平衡
DocType: Email Digest,Receivable / Payable account will be identified based on the field Master Type,應收/應付帳款的帳戶將基於字段碩士識別
DocType: Selling Settings,Default Territory,默認領地
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +52,Television,電視
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +137,Gashing,Gashing
DocType: Production Order Operation,Updated via 'Time Log',通過“時間日誌”更新
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +76,Account {0} does not belong to Company {1},帳戶{0}不屬於公司{1}
DocType: Naming Series,Series List for this Transaction,本交易系列表
apps/erpnext/erpnext/controllers/selling_controller.py +176,Reserved Warehouse required for stock Item {0} in row {1},需要缺貨登記保留倉庫{0}行{1}
DocType: Sales Invoice,Is Opening Entry,是開放報名
DocType: Supplier,Mention if non-standard receivable account applicable,何況，如果不規範應收賬款適用
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +145,For Warehouse is required before Submit,對於倉庫之前，需要提交
DocType: Sales Partner,Reseller,經銷商
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +49,Please enter Company,請輸入公司名稱
DocType: Delivery Note Item,Against Sales Invoice Item,對銷售發票項目
,Production Orders in Progress,製程中生產訂單
DocType: Item,Auto-raise Material Request if quantity goes below re-order level in default warehouse,自動提高材料如果申請數量低於重新排序級別的默認倉庫
DocType: Journal Entry,Write Off Amount <=,核銷金額&lt;=
DocType: Lead,Address & Contact,地址及聯繫方式
apps/erpnext/erpnext/controllers/recurring_document.py +205,Next Recurring {0} will be created on {1},下一循環{0}將上創建{1}
DocType: POS Setting,Create Stock Ledger Entries when you submit a Sales Invoice,當您提交銷貨發票時新增庫存總帳分錄
DocType: Newsletter List,Total Subscribers,用戶總數
DocType: Lead,Contact Name,聯繫人姓名
DocType: Production Plan Item,SO Pending Qty,SO待定數量
DocType: Salary Manager,Creates salary slip for above mentioned criteria.,建立工資單上面提到的標準。
apps/erpnext/erpnext/templates/generators/item.html +21,No description given,未提供描述
apps/erpnext/erpnext/config/buying.py +18,Request for purchase.,請求您的報價。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +106,Double housing,雙人房
DocType: Item,"Unit of measurement of this item (e.g. Kg, Unit, No, Pair).",這資料（如公斤，單位，不，一對）的測量單位。
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +157,Only the selected Leave Approver can submit this Leave Application,只有選擇的休假審批者可以提交此請假
apps/erpnext/erpnext/hr/doctype/employee/employee.py +110,Relieving Date must be greater than Date of Joining,解除日期必須大於加入的日期
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +167,Leaves per Year,每年葉
DocType: Time Log,Will be updated when batched.,批處理時將被更新。
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +123,Row {0}: Please check 'Is Advance' against Account {1} if this is an advance entry.,行{0}：請檢查'是推進'對帳戶{1}，如果這是一個進步條目。
apps/erpnext/erpnext/stock/utils.py +174,Warehouse {0} does not belong to company {1},倉庫{0}不屬於公司{1}
DocType: Brand,Material Master Manager,物料主數據管理
DocType: Bulk Email,Message,信息
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +663,Pending Items {0} updated,待批項目{0}已更新
DocType: Item Website Specification,Item Website Specification,項目網站規格
DocType: Backup Manager,Dropbox Access Key,Dropbox Access Key
DocType: Payment Tool,Reference No,參考編號
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +342,Leave Blocked,禁假的
apps/erpnext/erpnext/stock/doctype/item/item.py +465,Item {0} has reached its end of life on {1},項{0}已達到其壽命結束於{1}
apps/erpnext/erpnext/accounts/utils.py +306,Annual,全年
DocType: Stock Reconciliation Item,Stock Reconciliation Item,股票和解項目
DocType: Purchase Invoice,In Words will be visible once you save the Purchase Invoice.,在詞將是可見的，一旦你保存購買發票。
DocType: Stock Entry,Sales Invoice No,銷售發票號碼
DocType: Material Request Item,Min Order Qty,最小訂貨量
DocType: Lead,Do Not Contact,不要聯繫
DocType: Sales Invoice,The unique id for tracking all recurring invoices. It is generated on submit.,唯一ID來跟踪所有的經常性發票。它是在提交生成的。
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +88,Software Developer,軟件開發人員
DocType: Item,Minimum Order Qty,最低起訂量
DocType: Pricing Rule,Supplier Type,供應商類型
DocType: Item,Publish in Hub,在發布中心
,Terretory,Terretory
apps/erpnext/erpnext/stock/doctype/item/item.py +482,Item {0} is cancelled,項{0}將被取消
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +620,Material Request,材料要求
DocType: Bank Reconciliation,Update Clearance Date,更新日期間隙
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +128,Wire brushing,鋼絲刷
DocType: Employee,Relation,關係
apps/erpnext/erpnext/config/selling.py +23,Confirmed orders from Customers.,確認客戶的訂單。
DocType: Purchase Receipt Item,Rejected Quantity,拒絕數量
DocType: Features Setup,"Field available in Delivery Note, Quotation, Sales Invoice, Sales Order",在送貨單，報價單，銷售發票，銷售訂單可用欄位
DocType: SMS Settings,SMS Sender Name,短信發送者名稱
DocType: Contact,Is Primary Contact,是主要聯絡人
DocType: Notification Control,Notification Control,通知控制
DocType: Lead,Suggestions,建議
DocType: Territory,Set Item Group-wise budgets on this Territory. You can also include seasonality by setting the Distribution.,設置這個領地項目組間的預算。您還可以包括季節性通過設置分發。
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +72,Please enter parent account group for warehouse {0},請輸入父帳戶組倉庫{0}
DocType: Supplier,Address HTML,地址HTML
DocType: Lead,Mobile No.,手機號碼
DocType: Maintenance Schedule,Generate Schedule,生成時間表
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +80,Hubbing,樞紐
DocType: Purchase Invoice Item,Expense Head,總支出
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +86,Please select Charge Type first,請先選擇付款類別
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Latest,最新
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +393,Max 5 characters,最多5個字符
DocType: Email Digest,New Quotations,新報價
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +194,Select Your Language,選擇您的語言
DocType: Employee,The first Leave Approver in the list will be set as the default Leave Approver,該列表中的第一個休假審批將被設置為默認請假審批
DocType: Accounts Settings,Settings for Accounts,設置帳戶
apps/erpnext/erpnext/config/crm.py +80,Manage Sales Person Tree.,管理銷售人員樹。
DocType: Item,Synced With Hub,同步轂
DocType: Item,Variant Of,變種
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +35,Item {0} must be Service Item,項{0}必須是服務項目
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +297,Completed Qty can not be greater than 'Qty to Manufacture',完成數量不能大於“數量來製造”
DocType: DocType,Administrator,管理員
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +135,Laser drilling,激光打孔
DocType: Stock UOM Replace Utility,New Stock UOM,新的庫存計量單位
DocType: Period Closing Voucher,Closing Account Head,關閉帳戶頭
DocType: Shopping Cart Settings,"<a href=""#Sales Browser/Customer Group"">Add / Edit</a>","<a href=""#Sales Browser/Customer Group"">添加/編輯</a>"
DocType: Employee,External Work History,外部工作經歷
apps/erpnext/erpnext/projects/doctype/task/task.py +86,Circular Reference Error,循環引用錯誤
DocType: ToDo,Closed,關閉
DocType: Delivery Note,In Words (Export) will be visible once you save the Delivery Note.,在字（出口）將是可見的，一旦你保存送貨單。
DocType: Lead,Industry,行業
DocType: Employee,Job Profile,工作簡介
DocType: Newsletter,Newsletter,新聞
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +83,Hydroforming,液壓成形
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +48,Necking,縮頸
DocType: Stock Settings,Notify by Email on creation of automatic Material Request,在創建自動材料需求時已電子郵件通知
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +29,Item is updated,項目更新
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +26,Global POS Setting {0} already created for company {1},全球POS設置{0}已為公司{1}創造了
DocType: Comment,System Manager,系統管理器
DocType: Payment Reconciliation Invoice,Invoice Type,發票類型
DocType: Sales Invoice Item,Delivery Note,送貨單
DocType: Backup Manager,Allow Dropbox Access,讓Dropbox的訪問
DocType: Communication,Support Manager,支持經理
DocType: Sales Order Item,Reserved Warehouse,保留倉庫
apps/erpnext/erpnext/accounts/utils.py +182,Payment Entry has been modified after you pulled it. Please pull it again.,付款項被修改，你把它之後。請重新拉。
apps/erpnext/erpnext/stock/doctype/item/item.py +337,{0} entered twice in Item Tax,{0}輸入兩次項稅
DocType: Workstation,Rent Cost,租金成本
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +73,Please select month and year,請選擇年份和月份
DocType: Purchase Invoice,"Enter email id separated by commas, invoice will be mailed automatically on particular date",輸入電子郵件ID用逗號隔開，發票會自動在特定的日期郵寄
DocType: Employee,Company Email,企業郵箱
DocType: Workflow State,Refresh,刷新
DocType: Features Setup,"All import related fields like currency, conversion rate, import total, import grand total etc are available in Purchase Receipt, Supplier Quotation, Purchase Invoice, Purchase Order etc.",在外購入庫單，供應商報價單，採購發票，採購訂單等所有可像貨幣，轉換率，總進口，進口總計進口等相關領域
apps/erpnext/erpnext/stock/doctype/item/item.js +59,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,這個項目是一個模板，並且可以在交易不能使用。項目的屬性將被複製到變型，除非“不複製”設置
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +59,Total Order Considered,總訂貨考慮
DocType: Sales Invoice Item,Discount (%),折讓（％）
apps/erpnext/erpnext/config/hr.py +110,"Employee designation (e.g. CEO, Director etc.).",員工指定（例如總裁，總監等） 。
apps/erpnext/erpnext/controllers/recurring_document.py +198,Please enter 'Repeat on Day of Month' field value,請輸入「重複月內的一天」欄位值
DocType: Sales Invoice,Rate at which Customer Currency is converted to customer's base currency,公司貨幣被換算成客戶基礎貨幣的匯率
DocType: Features Setup,"Available in BOM, Delivery Note, Purchase Invoice, Production Order, Purchase Order, Purchase Receipt, Sales Invoice, Sales Order, Stock Entry, Timesheet",存在於物料清單，送貨單，採購發票，生產訂單，​​採購訂單，採購入庫單，銷售發票，銷售訂單，股票，時間表
DocType: Item Tax,Tax Rate,稅率
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +510,Select Item,選擇項目
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +208,{0} {1} status is Stopped,{0} {1}狀態為stopped
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +138,"Item: {0} managed batch-wise, can not be reconciled using \
					Stock Reconciliation, instead use Stock Entry","項目：{0}管理分批，不能使用\
股票和解，而是使用股票輸入不甘心"
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +242,Purchase Invoice {0} is already submitted,採購發票{0}已經提交
apps/erpnext/erpnext/accounts/doctype/account/account.js +54,Convert to non-Group,轉換為非集團
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +55,Purchase Receipt must be submitted,購買收據必須提交
DocType: Stock UOM Replace Utility,Current Stock UOM,目前的庫存計量單位
apps/erpnext/erpnext/config/stock.py +53,Batch (lot) of an Item.,一批該產品的（很多）。
DocType: C-Form Invoice Detail,Invoice Date,發票日期
apps/erpnext/erpnext/stock/doctype/item/item.py +358,"As there are existing stock transactions for this item, you can not change the values of 'Has Serial No', 'Has Batch No', 'Is Stock Item' and 'Valuation Method'",由於是現有的存量交易為這個項目，你不能改變'有序列號“的價值觀，'有批號”，“是股票項目”和“評估方法”
apps/erpnext/erpnext/templates/includes/footer_extension.html +6,Your email address,您的電子郵件地址
DocType: Email Digest,Income booked for the digest period,收入入賬的消化期
apps/erpnext/erpnext/config/setup.py +106,Supplier master.,供應商主。
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +191,Please see attachment,請參閱附件
DocType: Purchase Order,% Received,收到％
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +108,Water jet cutting,水射流切割
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +22,Setup Already Complete!!,安裝已經完成！
,Finished Goods,成品
DocType: Delivery Note,Instructions,說明
DocType: Quality Inspection,Inspected By,視察
DocType: Maintenance Visit,Maintenance Type,維護類型
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +69,Serial No {0} does not belong to Delivery Note {1},序列號{0}不屬於送貨單{1}
DocType: Item Quality Inspection Parameter,Item Quality Inspection Parameter,產品質量檢驗參數
DocType: Leave Application,Leave Approver Name,離開批准人姓名
,Schedule Date,排定日期
DocType: Packed Item,Packed Item,盒裝產品
apps/erpnext/erpnext/config/buying.py +54,Default settings for buying transactions.,默認設置為買入交易。
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +23,Activity Cost exists for Employee {0} against Activity Type - {1},存在活動費用為員工{0}對活動類型 -  {1}
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +29,Please do NOT create Accounts for Customers and Suppliers. They are created directly from the Customer / Supplier masters.,請不要創建客戶和供應商帳戶。他們是直接從客戶/供應商的主人創建的。
DocType: Currency Exchange,Currency Exchange,外幣兌換
DocType: Purchase Invoice Item,Item Name,項目名稱
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Credit Balance,貸方餘額
DocType: Employee,Widowed,寡
DocType: Production Planning Tool,"Items to be requested which are ""Out of Stock"" considering all warehouses based on projected qty and minimum order qty",這是“缺貨”的項目被要求考慮根據預計數量和最小起訂量為所有倉庫
DocType: Workstation,Working Hours,工作時間
DocType: Naming Series,Change the starting / current sequence number of an existing series.,更改現有系列的開始/當前的序列號。
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +57,"If multiple Pricing Rules continue to prevail, users are asked to set Priority manually to resolve conflict.",如果有多個定價規則繼續盛行，用戶被要求手動設置優先級來解決衝突。
DocType: Stock Entry,Purchase Return,採購退貨
,Purchase Register,購買註冊
DocType: Item,"Selecting ""Yes"" will allow this item to figure in Sales Order, Delivery Note",選擇“是”將允許這資料圖在銷售訂單，送貨單
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +212,Please enter Purchase Receipt No to proceed,請輸入外購入庫單編號以處理
DocType: Landed Cost Item,Applicable Charges,相關費用
DocType: Workstation,Consumable Cost,耗材成本
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +153,{0} ({1}) must have role 'Leave Approver',{0}（{1}）必須有作用的假期審批“
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +39,Medical,醫療
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +124,Reason for losing,原因丟失
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +35,Tube beading,管釘珠
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +79,Workstation is closed on the following dates as per Holiday List: {0},工作站在以下日期關閉按假日列表：{0}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +638,Make Maint. Schedule,讓MAINT。時間表
DocType: Employee,Single,單
DocType: Account,Cost of Goods Sold,銷貨成本
DocType: Purchase Invoice,Yearly,每年
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +217,Please enter Cost Center,請輸入成本中心
DocType: Sales Invoice Item,Sales Order,銷售訂單
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +63,Avg. Selling Rate,平均。賣出價
DocType: Purchase Order,Start date of current order's period,啟動電流訂單的期限日期
apps/erpnext/erpnext/utilities/transaction_base.py +113,Quantity cannot be a fraction in row {0},於{0}列的數量不能是分數
DocType: Purchase Invoice Item,Quantity and Rate,數量和速率
DocType: Delivery Note,% Installed,％安裝
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +60,Please enter company name first,請先輸入公司名稱
DocType: BOM,Item Desription,項目Desription
DocType: Buying Settings,Supplier Name,供應商名稱
DocType: Account,Is Group,是集團
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +30,Thermoforming,熱成型
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +65,Slitting,縱剪
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +57,'To Case No.' cannot be less than 'From Case No.',“至案件編號”不能少於'從案件編號“
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +99,Non Profit,非營利
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_list.js +7,Not Started,未啟動
DocType: Lead,Channel Partner,渠道合作夥伴
DocType: Account,Old Parent,老家長
DocType: Notification Control,Customize the introductory text that goes as a part of that email. Each transaction has a separate introductory text.,自定義去作為郵件的一部分的介紹文字。每筆交易都有一個單獨的介紹性文字。
DocType: Sales Taxes and Charges Template,Sales Master Manager,銷售主檔經理
apps/erpnext/erpnext/config/manufacturing.py +66,Global settings for all manufacturing processes.,所有製造過程中的全局設置。
DocType: Accounts Settings,Accounts Frozen Upto,帳戶被凍結到
DocType: SMS Log,Sent On,發送於
DocType: Sales Order,Not Applicable,不適用
apps/erpnext/erpnext/config/hr.py +140,Holiday master.,假日高手。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +18,Shell molding,外殼成型
DocType: Material Request Item,Required Date,所需時間
DocType: Delivery Note,Billing Address,帳單地址
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +611,Please enter Item Code.,請輸入產品編號。
DocType: BOM,Costing,成本核算
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/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +48,Total Qty,總數量
DocType: Employee,Health Concerns,健康問題
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +13,Unpaid,未付
DocType: Packing Slip,From Package No.,從包裹編號
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +29,Securities and Deposits,證券及存款
DocType: Features Setup,Imports,進口
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +143,Adhesive bonding,粘接
DocType: Job Opening,Description of a Job Opening,一個空缺職位的說明
apps/erpnext/erpnext/config/hr.py +28,Attendance record.,考勤記錄。
DocType: Bank Reconciliation,Journal Entries,日記帳分錄
DocType: Sales Order Item,Used for Production Plan,用於生產計劃
DocType: System Settings,Loading...,載入中...
DocType: DocField,Password,密碼
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +154,Fused deposition modeling,熔融沉積成型
DocType: Manufacturing Settings,Time Between Operations (in mins),時間操作之間（以分鐘）
DocType: Backup Manager,"Note: Backups and files are not deleted from Google Drive, you will have to delete them manually.",注意：備份和文件不會從Google Drive刪除，你必續手動刪除它們。
DocType: Customer,Buyer of Goods and Services.,買家商品和服務。
DocType: Journal Entry,Accounts Payable,應付帳款
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +24,Add Subscribers,添加訂閱
sites/assets/js/erpnext.min.js +2,""" does not exists",“不存在
DocType: Pricing Rule,Valid Upto,到...為止有效
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +514,List a few of your customers. They could be organizations or individuals.,列出一些你的客戶。他們可以是組織或個人。
DocType: Email Digest,Open Tickets,開放門票
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +143,Direct Income,直接收入
DocType: Email Digest,Total amount of invoices received from suppliers during the digest period,的過程中消化期間向供應商收取的發票總金額
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +29,"Can not filter based on Account, if grouped by Account",7 。總計：累積總數達到了這一點。
DocType: Item,Lead Time days is number of days by which this item is expected in your warehouse. This days is fetched in Material Request when you select this item.,交貨期天是天由該項目預計將在您的倉庫的數量。這天是在申請材料中取出，當你選擇這個項目。
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +83,Administrative Officer,政務主任
DocType: Payment Tool,Received Or Paid,收到或支付
DocType: Item,"Select ""Yes"" if this item is used for some internal purpose in your company.",選擇「是」，如果此項目被用於一些公司內部的目的。
DocType: Stock Entry,Difference Account,差異帳戶
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +307,Please enter Warehouse for which Material Request will be raised,請輸入物料需求欲增加的倉庫
DocType: Production Order,Additional Operating Cost,額外的運營成本
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +19,Cosmetics,化妝品
DocType: DocField,Type,類型
apps/erpnext/erpnext/stock/doctype/item/item.py +413,"To merge, following properties must be same for both items",若要合併，以下屬性必須為這兩個項目是相同的
DocType: Backup Manager,Email ids separated by commas.,電子郵件ID，用逗號分隔。
DocType: Communication,Subject,主題
DocType: Item,"Select ""Yes"" if this item represents some work like training, designing, consulting etc.",選擇「是」，如果此項目表示類似於培訓，設計，諮詢等這類工作。
DocType: Shipping Rule,Net Weight,淨重
DocType: Employee,Emergency Phone,緊急電話
DocType: Backup Manager,Google Drive Access Allowed,允許Google Drive訪問
,Serial No Warranty Expiry,序列號保修到期
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +634,Do you really want to STOP this Material Request?,你真的要停止這種材料要求？
DocType: Purchase Invoice Item,Item,項目
DocType: Journal Entry,Difference (Dr - Cr),差異（Dr - Cr）
DocType: Account,Profit and Loss,損益
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +310,Upcoming Calendar Events (max 10),即將到來的日曆事件（最多10個）
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +101,New UOM must NOT be of type Whole Number,新的計量單位不能是類型整數
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +47,Furniture and Fixture,家具及固定裝置
DocType: Quotation,Rate at which Price list currency is converted to company's base currency,價目表貨幣被換算成公司基礎貨幣的匯率
apps/erpnext/erpnext/setup/doctype/company/company.py +48,Account {0} does not belong to company: {1},帳戶{0}不屬於公司：{1}
DocType: Selling Settings,Default Customer Group,默認用戶組
DocType: Global Defaults,"If disable, 'Rounded Total' field will not be visible in any transaction",如果禁用，“圓角總計”字段將不可見的任何交易
DocType: BOM,Operating Cost,營業成本
,Gross Profit,毛利
DocType: Production Planning Tool,Material Requirement,物料需求
DocType: Company,Delete Company Transactions,刪除公司事務
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +80,Item {0} is not Purchase Item,項目{0}不購買產品
apps/erpnext/erpnext/controllers/recurring_document.py +187,"{0} is an invalid email address in 'Notification \
					Email Address'","{0}在“通知\
電子郵件地址”無效的電子郵件地址"
apps/erpnext/erpnext/buying/doctype/supplier/supplier.js +44,Total Billing This Year:,總計費今年：
DocType: Purchase Receipt,Add / Edit Taxes and Charges,添加／編輯稅金及費用
DocType: Purchase Invoice,Supplier Invoice No,供應商發票號碼
DocType: Territory,For reference,供參考
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +198,Closing (Cr),關閉（Cr）
DocType: Serial No,Warranty Period (Days),保修期限（天數）
DocType: Installation Note Item,Installation Note Item,安裝注意項
DocType: Job Applicant,Thread HTML,主題HTML
DocType: Company,Ignore,忽略
DocType: Backup Manager,Enter Verification Code,輸入驗證碼
apps/erpnext/erpnext/controllers/buying_controller.py +136,Supplier Warehouse mandatory for sub-contracted Purchase Receipt,供應商倉庫強制性分包外購入庫單
DocType: Pricing Rule,Valid From,有效期自
DocType: Sales Invoice,Total Commission,總委員會
DocType: Pricing Rule,Sales Partner,銷售合作夥伴
DocType: Buying Settings,Purchase Receipt Required,需要外購入庫單
DocType: Monthly Distribution,"**Monthly Distribution** helps you distribute your budget across months if you have seasonality in your business.

To distribute a budget using this distribution, set this **Monthly Distribution** in the **Cost Center**","**月**分佈幫助你分配你的預算在整個個月，如果你有季節性的業務。

要使用這種分佈分配預算，設置這個**月**分佈在**成本中心**"
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +172,No records found in the Invoice table,沒有在發票表中找到記錄
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.js +20,Please select Company and Party Type first,請選擇公司和黨的第一型
apps/erpnext/erpnext/config/accounts.py +79,Financial / accounting year.,財務／會計年度。
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +172,"Sorry, Serial Nos cannot be merged",對不起，序列號無法合併
DocType: Email Digest,New Supplier Quotations,新供應商報價
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +616,Make Sales Order,製作銷售訂單
DocType: Project Task,Project Task,項目任務
,Lead Id,鉛標識
DocType: C-Form Invoice Detail,Grand Total,累計
DocType: About Us Settings,Website Manager,網站管理
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +34,Fiscal Year Start Date should not be greater than Fiscal Year End Date,會計年度開始日期應不大於財政年度結束日期
DocType: Warranty Claim,Resolution,決議
DocType: Sales Order,Display all the individual items delivered with the main items,顯示所有交付使用的主要項目的單個項目
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +67,Payable Account,應付帳款
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +58,Repeat Customers,回頭客
DocType: Backup Manager,Sync with Google Drive,同步與谷歌驅動器
DocType: Leave Control Panel,Allocate,分配
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +16,Previous,上一筆
DocType: Stock Entry,Sales Return,銷貨退回
DocType: Production Planning Tool,Select Sales Orders from which you want to create Production Orders.,要從創建生產訂單選擇銷售訂單。
apps/erpnext/erpnext/config/hr.py +120,Salary components.,工資組成部分。
apps/erpnext/erpnext/config/crm.py +12,Database of potential customers.,數據庫的潛在客戶。
apps/erpnext/erpnext/config/crm.py +17,Customer database.,客戶數據庫。
DocType: Quotation,Quotation To,報價到
DocType: Lead,Middle Income,中等收入
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +58,Opening (Cr),開啟（Cr ）
apps/erpnext/erpnext/accounts/utils.py +186,Allocated amount can not be negative,分配金額不能為負
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +122,Tumbling,翻筋斗
DocType: Purchase Order Item,Billed Amt,已結算額
DocType: Warehouse,A logical Warehouse against which stock entries are made.,邏輯倉庫對這些股票的條目進行的。
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +111,Reference No & Reference Date is required for {0},參考號與參考日期須為{0}
DocType: Event,Wednesday,星期三
DocType: Sales Invoice,Customer's Vendor,客戶的供應商
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +197,Production Order is Mandatory,生產訂單是強制性
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +40,{0} {1} has a common territory {2},{0} {1}有一個共同的領土{2}
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +134,Proposal Writing,提案寫作
apps/erpnext/erpnext/config/setup.py +85,Masters,大師
apps/erpnext/erpnext/stock/stock_ledger.py +316,Negative Stock Error ({6}) for Item {0} in Warehouse {1} on {2} {3} in {4} {5},負庫存錯誤（ {6}）的項目{0}在倉庫{1}在{2} {3} {4} {5}
DocType: Fiscal Year Company,Fiscal Year Company,會計年度公司
DocType: Packing Slip Item,DN Detail,DN詳細
DocType: Time Log,Billed,計費
DocType: Batch,Batch Description,一批說明
DocType: Delivery Note,Time at which items were delivered from warehouse,時間在哪個項目是從倉庫運送
DocType: Sales Invoice,Sales Taxes and Charges,銷售稅金及費用
DocType: Employee,Organization Profile,組織簡介
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +90,Please setup numbering series for Attendance via Setup > Numbering Series,通過設置>編號系列請設置編號系列考勤
DocType: Email Digest,New Enquiries,新的查詢
DocType: Employee,Reason for Resignation,辭退原因
apps/erpnext/erpnext/config/hr.py +150,Template for performance appraisals.,模板的績效考核。
DocType: Payment Reconciliation,Invoice/Journal Entry Details,發票/日記帳分錄詳細信息
apps/erpnext/erpnext/accounts/utils.py +50,{0} '{1}' not in Fiscal Year {2},{0}“ {1}”不財政年度{2}
DocType: Buying Settings,Settings for Buying Module,設置購買模塊
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +62,Please enter Purchase Receipt first,請第一次進入購買收據
DocType: Buying Settings,Supplier Naming By,供應商命名
DocType: Maintenance Schedule,Maintenance Schedule,維護計劃
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +34,"Then Pricing Rules are filtered out based on Customer, Customer Group, Territory, Supplier, Supplier Type, Campaign, Sales Partner etc.",然後定價規則將被過濾掉基於客戶，客戶組，領地，供應商，供應商類型，活動，銷售合作夥伴等。
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +126,Please install dropbox python module,請安裝Dropbox的Python模塊
DocType: Employee,Passport Number,護照號碼
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +77,Manager,經理
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +512,From Purchase Receipt,從採購入庫單
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +222,Same item has been entered multiple times.,相同的項目已被輸入多次。
DocType: SMS Settings,Receiver Parameter,收受方參數
apps/erpnext/erpnext/controllers/trends.py +39,'Based On' and 'Group By' can not be same,“根據”和“分組依據”不能相同
DocType: Sales Person,Sales Person Targets,銷售人員目標
sites/assets/js/form.min.js +253,To,到
apps/erpnext/erpnext/templates/includes/footer_extension.html +39,Please enter email address,請輸入您的電子郵件地址
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +34,End tube forming,尾管成型
DocType: Production Order Operation,In minutes,在幾分鐘內
DocType: Issue,Resolution Date,決議日期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +596,Please set default Cash or Bank account in Mode of Payment {0},請設置付款方式{0}默認的現金或銀行賬戶
DocType: Selling Settings,Customer Naming By,客戶命名由
apps/erpnext/erpnext/accounts/doctype/account/account.js +67,Convert to Group,轉換為集團
DocType: Activity Cost,Activity Type,活動類型
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +47,Delivered Amount,交付金額
DocType: Sales Invoice,Packing List,包裝清單
apps/erpnext/erpnext/config/buying.py +28,Purchase Orders given to Suppliers.,購買給供應商的訂單。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +42,Publishing,出版
DocType: Activity Cost,Projects User,項目用戶
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Consumed,消費
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +187,{0}: {1} not found in Invoice Details table,{0}：{1}不是在發票明細表中找到
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +189,Maintenance Visit {0} must be cancelled before cancelling this Sales Order,維護訪問{0}必須取消這個銷售訂單之前被取消
DocType: Material Request,Material Transfer,材料轉讓
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +56,Opening (Dr),開啟（Dr）
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +406,Posting timestamp must be after {0},發布時間戳記必須晚於{0}
apps/frappe/frappe/config/setup.py +59,Settings,設置
DocType: Landed Cost Taxes and Charges,Landed Cost Taxes and Charges,到岸成本稅費
DocType: Production Order Operation,Actual Start Time,實際開始時間
DocType: BOM Operation,Operation Time,操作時間
sites/assets/js/list.min.js +5,More,更多
DocType: Communication,Sales Manager,銷售經理
sites/assets/js/desk.min.js +555,Rename,重命名
DocType: Purchase Invoice,Write Off Amount,核銷金額
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +51,Bending,彎曲
DocType: Leave Block List Allow,Allow User,允許用戶
DocType: Journal Entry,Bill No,帳單號碼
DocType: Purchase Invoice,Quarterly,每季
DocType: Selling Settings,Delivery Note Required,要求送貨單
DocType: Sales Order Item,Basic Rate (Company Currency),基礎匯率（公司貨幣）
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +66,Please enter item details,請輸入項目細節
DocType: Purchase Receipt,Other Details,其他詳細信息
DocType: Account,Accounts,賬戶
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +62,Marketing,市場營銷
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +64,Straight shearing,直剪
DocType: Features Setup,To track item in sales and purchase documents based on their serial nos. This is can also used to track warranty details of the product.,在基於其序列號的銷售和採購文件跟踪的項目。這也可以用來跟踪商品的保修細節。
DocType: Purchase Receipt Item Supplied,Current Stock,當前庫存
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +81,Rejected Warehouse is mandatory against regected item,拒絕倉庫是必須反對regected項目
DocType: Account,Expenses Included In Valuation,支出計入估值
DocType: Employee,Provide email id registered in company,提供的電子郵件ID在公司註冊
DocType: Hub Settings,Seller City,賣家市
DocType: Email Digest,Next email will be sent on:,接下來的電子郵件將被發送：
DocType: Offer Letter Term,Offer Letter Term,報價函期限
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +23,Item {0} not found,項{0}未找到
DocType: Bin,Stock Value,庫存價值
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +88,Tree Type,樹類型
DocType: BOM Explosion Item,Qty Consumed Per Unit,數量消耗每單位
DocType: Serial No,Warranty Expiry Date,保證期到期日
DocType: Material Request Item,Quantity and Warehouse,數量和倉庫
DocType: Sales Invoice,Commission Rate (%),佣金率（％）
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +141,"Against Voucher Type must be one of Sales Order, Sales Invoice or Journal Entry",對憑證類型必須是一個銷售訂單，銷售發票或日記帳分錄
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +138,Biomachining,Biomachining
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +6,Aerospace,航天
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +19,Welcome,歡迎
DocType: Journal Entry,Credit Card Entry,信用卡進入
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +18,Task Subject,任務主題
apps/erpnext/erpnext/config/stock.py +28,Goods received from Suppliers.,從供應商收到貨。
DocType: Communication,Open,開
DocType: Lead,Campaign Name,活動名稱
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +197,Please enter Delivery Note No or Sales Invoice No to proceed,請輸入送貨單號或銷售發票號碼以處理
,Reserved,保留的
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +650,Do you really want to UNSTOP,你真的想UNSTOP
DocType: Purchase Order,Supply Raw Materials,供應原料
DocType: Purchase Invoice,The date on which next invoice will be generated. It is generated on submit.,在這接下來的發票將生成的日期。它在提交生成。
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +10,Current Assets,流動資產
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +108,{0} is not a stock Item,{0}不是一個缺貨登記
DocType: Mode of Payment Account,Default Account,默認帳戶
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +155,Lead must be set if Opportunity is made from Lead,如果機會是由鉛製成鉛必須設置
DocType: Contact Us Settings,Address Title,地址名稱
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +32,Please select weekly off day,請選擇每週休息日
DocType: Production Order Operation,Planned End Time,計劃結束時間
,Sales Person Target Variance Item Group-Wise,銷售人員目標差異項目組，智者
DocType: Backup Manager,Daily,每日
apps/erpnext/erpnext/accounts/doctype/account/account.py +79,Account with existing transaction cannot be converted to ledger,帳戶與現有的交易不能被轉換為總賬
DocType: Delivery Note,Customer's Purchase Order No,客戶的採購訂單號
DocType: Employee,Cell Number,手機號碼
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +7,Lost,丟失
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +139,You can not enter current voucher in 'Against Journal Entry' column,在您不能輸入電流券“對日記帳分錄”專欄
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +24,Energy,能源
DocType: Opportunity,Opportunity From,機會從
apps/erpnext/erpnext/config/hr.py +33,Monthly salary statement.,月薪聲明。
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +434,"Row No {0}: Amount cannot be greater than Pending Amount against Expense Claim {1}. \
						Pending Amount is {2}","行無{0}：金額不能大於待量對報銷{1}。\
待定金額為{2}"
DocType: Item Group,Website Specifications,網站規格
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +198,New Account,新帳號
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +21,{0}: From {0} of type {1},{0}：從{0}類型{1}
apps/erpnext/erpnext/controllers/buying_controller.py +284,Row {0}: Conversion Factor is mandatory,列#{0}：轉換係數是強制性的
apps/erpnext/erpnext/templates/pages/ticket.py +27,Please write something,請寫東西
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +27,Accounting Entries can be made against leaf nodes. Entries against Groups are not allowed.,會計分錄可對葉節點。對組參賽作品是不允許的。
DocType: ToDo,High,高
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +364,Cannot deactivate or cancel BOM as it is linked with other BOMs,無法關閉或取消BOM，因為它是與其他材料明細表鏈接
DocType: Opportunity,Maintenance,維護
DocType: User,Male,男性
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +181,Purchase Receipt number required for Item {0},物品{0}所需交易收據號碼
DocType: Item Attribute Value,Item Attribute Value,項目屬性值
apps/erpnext/erpnext/config/crm.py +54,Sales campaigns.,銷售活動。
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。這是含稅的基本速率？：如果你檢查這一點，就意味著這個稅不會顯示在項目表中，但在你的主項表將被納入基本速率。你想要給一個單位的價格（包括所有稅費）的價格為顧客這是非常有用的。"
DocType: Serial No,Purchase Returned,進貨退出
DocType: Employee,Bank A/C No.,銀行A/C No.
DocType: Email Digest,Scheduler Failed Events,調度失敗事件
DocType: Expense Claim,Project,專案
DocType: Quality Inspection Reading,Reading 7,7閱讀
DocType: Address,Personal,個人
DocType: Expense Claim Detail,Expense Claim Type,費用報銷型
DocType: Shopping Cart Settings,Default settings for Shopping Cart,對購物車的默認設置
apps/erpnext/erpnext/controllers/accounts_controller.py +255,"Journal Entry {0} is linked against Order {1}, check if it should be pulled as advance in this invoice.",日記條目{0}鏈接抗令{1}，檢查它是否應該被拉到作為提前在此發票。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +12,Biotechnology,生物技術
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +108,Office Maintenance Expenses,Office維護費用
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +52,Hemming,海明
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.js +64,Please enter Item first,請先輸入品項
DocType: Account,Liability,責任
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +61,Sanctioned Amount cannot be greater than Claim Amount in Row {0}.,制裁金額不能大於索賠額行{0}。
DocType: Company,Default Cost of Goods Sold Account,銷貨賬戶的默認成本
apps/erpnext/erpnext/stock/get_item_details.py +238,Price List not selected,未選擇價格列表
DocType: Employee,Family Background,家庭背景
DocType: Salary Manager,Send Email,發送電子郵件
apps/erpnext/erpnext/buying/doctype/supplier/supplier.py +85,No Permission,無權限
DocType: Company,Default Bank Account,默認銀行賬戶
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +43,"To filter based on Party, select Party Type first",要根據黨的篩選，選擇黨第一類型
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Nos,NOS
DocType: Bank Reconciliation Detail,Bank Reconciliation Detail,銀行對帳詳細
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +588,My Invoices,我的發票
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +39,No employee found,無發現任何員工
DocType: Purchase Order,Stopped,停止
DocType: SMS Center,All Customer Contact,所有的客戶聯繫
apps/erpnext/erpnext/config/stock.py +64,Upload stock balance via csv.,通過CSV上傳庫存餘額。
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +32,Send Now,立即發送
,Support Analytics,支援分析
DocType: Item,Website Warehouse,網站倉庫
DocType: Sales Invoice,"The day of the month on which auto invoice will be generated e.g. 05, 28 etc",該月的一天，在這汽車的發票將產生如05，28等
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.js +49,Score must be less than or equal to 5,得分必須小於或等於5
apps/erpnext/erpnext/config/accounts.py +159,C-Form records,C-往績紀錄
DocType: Email Digest,Email Digest Settings,電子郵件摘要設置
apps/erpnext/erpnext/config/support.py +13,Support queries from customers.,客戶支持查詢。
DocType: Bin,Moving Average Rate,移動平均房價
DocType: Production Planning Tool,Select Items,選擇項目
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +294,{0} against Bill {1} dated {2},{0}反對比爾{1}日期{2}
DocType: Communication,Reference Name,參考名稱
DocType: Maintenance Visit,Completion Status,完成狀態
DocType: Features Setup,"To track brand name in the following documents Delivery Note, Opportunity, Material Request, Item, Purchase Order, Purchase Voucher, Purchaser Receipt, Quotation, Sales Invoice, Sales BOM, Sales Order, Serial No",在以下文件送貨單，機遇，材質要求，項目，採購訂單，購買憑證，買方收據，報價單，銷售發票，銷售物料，銷售訂單，序列號跟踪品牌
DocType: Production Order,Target Warehouse,目標倉庫
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +23,Expected Delivery Date cannot be before Sales Order Date,預計交貨日期不能早於銷售訂單日期
DocType: Upload Attendance,Import Attendance,進口出席
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +17,All Item Groups,所有項目組
DocType: Salary Manager,Activity Log,活動日誌
apps/erpnext/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.py +30,Net Profit / Loss,淨利／虧損
apps/erpnext/erpnext/config/setup.py +64,Automatically compose message on submission of transactions.,自動編寫郵件在提交交易。
DocType: Production Order,Item To Manufacture,產品製造
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +15,Permanent mold casting,永久模鑄造
DocType: Sales Order Item,Projected Qty,預計數量
DocType: Sales Invoice,Payment Due Date,付款到期日
DocType: Newsletter,Newsletter Manager,通訊經理
DocType: Notification Control,Delivery Note Message,送貨單留言
DocType: Expense Claim,Expenses,開支
,Purchase Receipt Trends,購買收據趨勢
DocType: Appraisal,Select template from which you want to get the Goals,選擇您想要得到的目標模板
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +72,Research & Development,研究與發展
,Amount to Bill,帳單數額
DocType: Company,Registration Details,註冊細節
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +74,Staking,跑馬圈地
DocType: Item Reorder,Re-Order Qty,重新排序數量
DocType: Leave Block List Date,Leave Block List Date,休假區塊清單日期表
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +23,Scheduled to send to {0},要寄送給{0}的排程
DocType: Pricing Rule,Price or Discount,價格或折扣
DocType: Sales Team,Incentives,獎勵
apps/erpnext/erpnext/config/hr.py +38,Performance appraisal.,績效考核。
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +29,Project Value,專案值
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +636,Make Maint. Visit,讓MAINT。訪問
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +68,Cannot carry forward {0},不能發揚{0}
apps/erpnext/erpnext/accounts/doctype/account/account.py +73,"Account balance already in Credit, you are not allowed to set 'Balance Must Be' as 'Debit'",帳戶餘額已歸為信用帳戶，不允許設為Debit帳戶
DocType: Account,Balance must be,餘額必須
DocType: Hub Settings,Publish Pricing,發布定價
DocType: Email Digest,New Purchase Receipts,新的購買收據
DocType: Notification Control,Expense Claim Rejected Message,報銷拒絕消息
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +144,Nailing,釘
,Available Qty,可用數量
DocType: Purchase Taxes and Charges,On Previous Row Total,在上一行共
DocType: Salary Slip,Working Days,工作日
DocType: Serial No,Incoming Rate,傳入速率
DocType: Packing Slip,Gross Weight,毛重
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +409,The name of your company for which you are setting up this system.,您的公司要為其設立這個系統的名稱。
DocType: HR Settings,Include holidays in Total no. of Working Days,包括節假日的總數。工作日
DocType: Job Applicant,Hold,持有
DocType: Employee,Date of Joining,加入日期
DocType: Naming Series,Update Series,更新系列
DocType: Supplier Quotation,Is Subcontracted,轉包
DocType: Item Attribute,Item Attribute Values,項目屬性值
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +3,View Subscribers,查看訂閱
DocType: Purchase Invoice Item,Purchase Receipt,外購入庫單
,Received Items To Be Billed,待付款的收受品項
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +113,Abrasive blasting,噴砂
DocType: Employee,Ms,女士
apps/erpnext/erpnext/config/accounts.py +138,Currency exchange rate master.,貨幣匯率的主人。
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +242,Unable to find Time Slot in the next {0} days for Operation {1},找不到時隙在未來{0}天操作{1}
DocType: Production Order,Plan material for sub-assemblies,計劃材料為子組件
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +423,BOM {0} must be active,BOM {0}必須是積極的
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.js +22,Set Status as Available,設置狀態為可用
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +26,Please select the document type first,請先選擇文檔類型
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +68,Cancel Material Visits {0} before cancelling this Maintenance Visit,取消取消此保養訪問之前，材質訪問{0}
DocType: Salary Slip,Leave Encashment Amount,假期兌現金額
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +223,Serial No {0} does not belong to Item {1},序列號{0}不屬於項目{1}
apps/erpnext/erpnext/accounts/page/pos/pos_page.html +13,Make new POS Setting,使新的POS設置
DocType: Purchase Receipt Item Supplied,Required Qty,所需數量
DocType: Bank Reconciliation,Total Amount,總金額
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +31,Internet Publishing,互聯網出版
DocType: Production Planning Tool,Production Orders,生產訂單
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +30,Balance Value,平衡值
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +38,Sales Price List,銷售價格表
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +69,Publish to sync items,發布同步項目
DocType: Purchase Receipt,Range,範圍
DocType: Supplier,Default Payable Accounts,預設應付帳款
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +40,Employee {0} is not active or does not exist,員工{0}不活躍或不存在
DocType: Features Setup,Item Barcode,商品條碼
apps/erpnext/erpnext/stock/doctype/item/item.py +193,Item Variants {0} updated,項目變種{0}更新
DocType: Quality Inspection Reading,Reading 6,6閱讀
DocType: Purchase Invoice Advance,Purchase Invoice Advance,購買發票提前
DocType: Address,Shop,店
DocType: Hub Settings,Sync Now,立即同步
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +191,Row {0}: Credit entry can not be linked with a {1},行{0}：信用記錄無法被鏈接的{1}
DocType: Mode of Payment Account,Default Bank / Cash account will be automatically updated in POS Invoice when this mode is selected.,默認銀行/現金帳戶將被自動在POS機發票時選擇此模式更新。
DocType: Employee,Permanent Address Is,永久地址
DocType: Production Order Operation,Operation completed for how many finished goods?,操作完成多少成品？
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +471,The Brand,品牌
apps/erpnext/erpnext/controllers/status_updater.py +123,Allowance for over-{0} crossed for Item {1}.,備抵過{0}越過為項目{1}。
DocType: Employee,Exit Interview Details,退出面試細節
DocType: Item,Is Purchase Item,是購買項目
DocType: Payment Reconciliation Payment,Purchase Invoice,採購發票
DocType: Stock Ledger Entry,Voucher Detail No,券詳細說明暫無
DocType: Stock Entry,Total Outgoing Value,即將離任的總價值
DocType: Lead,Request for Information,索取資料
DocType: Payment Tool,Paid,付費
DocType: Salary Slip,Total in words,總字
DocType: Material Request Item,Lead Time Date,交貨時間日期
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +127,Row #{0}: Please specify Serial No for Item {1},列#{0}：請為項目{1}指定序號
apps/erpnext/erpnext/config/stock.py +23,Shipments to customers.,發貨給客戶。
DocType: Purchase Invoice Item,Purchase Order Item,採購訂單項目
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +152,Indirect Income,間接收入
DocType: Contact Us Settings,Address Line 1,地址行1
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Variance,方差
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +390,Company Name,公司名稱
DocType: SMS Center,Total Message(s),總信息（s ）
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +508,Select Item for Transfer,對於轉讓項目選擇
DocType: Bank Reconciliation,Select account head of the bank where cheque was deposited.,選取支票存入該銀行賬戶的頭。
DocType: Selling Settings,Allow user to edit Price List Rate in transactions,允許用戶編輯價目表率的交易
DocType: Pricing Rule,Max Qty,最大數量
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +125,Row {0}: Payment against Sales/Purchase Order should always be marked as advance,行{0}：付款方式對銷售/採購訂單應始終被標記為提前
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +15,Chemical,化學藥品
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +660,All items have already been transferred for this Production Order.,所有項目都已經被轉移為這個生產訂單。
DocType: Salary Manager,Select Payroll Year and Month,選擇薪資年和月
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +32,"Go to the appropriate group (usually Application of Funds > Current Assets > Bank Accounts and create a new Account (by clicking on Add Child) of type ""Bank""",轉到相應的群組（通常資金運用>流動資產>銀行帳戶，並新增一個新帳戶（通過點擊添加類型的兒童），“銀行”
DocType: Workstation,Electricity Cost,電力成本
DocType: HR Settings,Don't send Employee Birthday Reminders,不要送員工生日提醒
DocType: Comment,Unsubscribed,退訂
DocType: Opportunity,Walk In,走在
DocType: Item,Inspection Criteria,檢驗標準
apps/erpnext/erpnext/config/accounts.py +96,Tree of finanial Cost Centers.,樹finanial成本中心。
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +472,Upload your letter head and logo. (you can edit them later).,上傳你的信頭和標誌。 （您可以在以後對其進行編輯）。
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +151,White,白
DocType: SMS Center,All Lead (Open),所有鉛（開放）
DocType: Purchase Invoice,Get Advances Paid,獲取有償進展
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +360,Attach Your Picture,附上你的照片
DocType: Journal Entry,Total Amount in Words,總金額詞
DocType: Workflow State,Stop,停止
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +7,There was an error. One probable reason could be that you haven't saved the form. Please contact support@erpnext.com if the problem persists.,有一個錯誤。一個可能的原因可能是因為您沒有保存的形式。請聯繫support@erpnext.com如果問題仍然存在。
DocType: Purchase Order,% of materials billed against this Purchase Order.,％的材料嘴對這種採購訂單。
apps/erpnext/erpnext/controllers/selling_controller.py +155,Order Type must be one of {0},訂單類型必須是一個{0}
DocType: Lead,Next Contact Date,下次聯絡日期
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +34,Opening Qty,開放數量
DocType: Holiday List,Holiday List Name,假日列表名稱
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +163,Stock Options,股票期權
DocType: Expense Claim,Expense Claim,報銷
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +164,Qty for {0},數量為{0}
DocType: Leave Application,Leave Application,休假申請
apps/erpnext/erpnext/config/hr.py +77,Leave Allocation Tool,排假工具
DocType: Leave Block List,Leave Block List Dates,休假區塊清單日期表
DocType: Email Digest,Buying & Selling,購買與銷售
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +55,Trimming,修剪
DocType: Workstation,Net Hour Rate,淨小時率
DocType: Landed Cost Purchase Receipt,Landed Cost Purchase Receipt,到岸成本外購入庫單
DocType: Packing Slip Item,Packing Slip Item,裝箱單項目
DocType: POS Setting,Cash/Bank Account,現金／銀行賬戶
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +58,Removed items with no change in quantity or value.,刪除的項目在數量或價值沒有變化。
DocType: Delivery Note,Delivery To,交貨給
DocType: Production Planning Tool,Get Sales Orders,獲取銷售訂單
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +64,{0} can not be negative,{0}不能為負
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +198,"Row {0}: Party / Account does not match with \
							Customer / Debit To in {1}","行{0}：黨/賬戶不與\
客戶/借記要在匹配{1}"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +102,Filing,備案
apps/erpnext/erpnext/templates/form_grid/item_grid.html +67,Discount,折扣
DocType: Features Setup,Purchase Discounts,採購折扣
DocType: Stock Entry,This will override Difference Account in Item,這將覆蓋差異帳戶項
DocType: Workstation,Wages,工資
DocType: Time Log,Will be updated only if Time Log is 'Billable',如果時間日誌是“計費”將只更新
DocType: Project,Internal,內部
DocType: Task,Urgent,緊急
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +97,Please specify a valid Row ID for row {0} in table {1},請指定行{0}在表中的有效行ID {1}
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +76,This Time Log conflicts with {0} for {1},這與時間登錄衝突{0} {1}
DocType: Sales BOM,"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 Sales BOM Item.

Note: BOM = Bill of Materials","聚合組** **項目到另一個項目** **的。如果你是捆綁了一定**項目你保持股票的包裝**項目的**，而不是總**項這是一個有用的**成一個包和**。

包** **項目將有“是股票項目”為“否”和“是銷售項目”為“是”。

例如：如果你是銷售筆記本電腦和背包分開，並有一個特殊的價格，如果客戶購買兩者，那麼筆記本電腦+背包將是一個新的銷售BOM項目。

注：物料BOM =比爾"
DocType: Item,Manufacturer,生產廠家
DocType: Landed Cost Item,Purchase Receipt Item,採購入庫項目
DocType: Sales Order,PO Date,訂單日期
DocType: Serial No,Sales Returned,銷貨退回
DocType: Production Plan Item,Reserved Warehouse in Sales Order / Finished Goods Warehouse,在銷售訂單/成品倉庫保留倉庫
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +65,Selling Amount,銷售金額
apps/erpnext/erpnext/projects/doctype/project/project.js +37,Time Logs,時間日誌
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +105,You are the Expense Approver for this record. Please Update the 'Status' and Save,讓項目B是製造< / B>
DocType: Serial No,Creation Document No,文檔創建編號
DocType: Issue,Issue,問題
apps/erpnext/erpnext/config/stock.py +136,"Attributes for Item Variants. e.g Size, Color etc.",屬性的項目變體。如大小，顏色等。
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +30,WIP Warehouse,WIP倉庫
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +204,Serial No {0} is under maintenance contract upto {1},序列號{0}在維護合約期間內直到{1}
DocType: BOM Operation,Operation,手術
DocType: Lead,Organization Name,組織名稱
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +385,POS Setting required to make POS Entry,使POS機輸入所需設置POS機
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +61,Item must be added using 'Get Items from Purchase Receipts' button,項目必須使用'從購買收據項“按鈕進行添加
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +126,Sales Expenses,銷售費用
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +159,Standard Buying,標準採購
DocType: GL Entry,Against,針對
DocType: Item,Default Selling Cost Center,默認情況下銷售成本中心
DocType: Sales Partner,Implementation Partner,實施合作夥伴
DocType: Purchase Invoice,Contact Info,聯繫方式
DocType: Packing Slip,Net Weight UOM,淨重計量單位
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +477,Make Purchase Receipt,券＃
DocType: Item,Default Supplier,默認的供應商
DocType: Shipping Rule Condition,Shipping Rule Condition,送貨規則條件
DocType: Features Setup,Miscelleneous,Miscelleneous
DocType: Holiday List,Get Weekly Off Dates,獲取每週關閉日期
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +30,End Date can not be less than Start Date,結束日期不能小於開始日期
DocType: Sales Person,Select company name first.,先選擇公司名稱。
DocType: Sales BOM Item,Sales BOM Item,銷售BOM項目
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +87,Dr,博士
apps/erpnext/erpnext/stock/doctype/item/item.py +317,"Item must be a purchase item, as it is present in one or many Active BOMs",項目必須是購買項目，因為它存在於一個或多個活躍的BOM
apps/erpnext/erpnext/config/buying.py +23,Quotations received from Suppliers.,從供應商收到的報價。
DocType: Journal Entry Account,Against Purchase Invoice,對採購發票
apps/erpnext/erpnext/controllers/selling_controller.py +21,To {0} | {1} {2},{0} | {1} {2}
DocType: Time Log Batch,updated via Time Logs,通過時間更新日誌
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +40,Average Age,平均年齡
apps/erpnext/erpnext/templates/includes/cart.js +59,Go ahead and add something to your cart.,來吧，講一下你的車。
DocType: Opportunity,Your sales person who will contact the customer in future,你的銷售人員誰將會聯繫客戶在未來
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +537,List a few of your suppliers. They could be organizations or individuals.,列出一些你的供應商。他們可以是組織或個人。
DocType: Supplier,Default Currency,默認貨幣
DocType: Contact,Enter designation of this Contact,輸入該聯繫人指定
DocType: Contact Us Settings,Address,地址
DocType: Expense Claim,From Employee,從員工
apps/erpnext/erpnext/accounts/utils.py +39,{0} {1} not in any Fiscal Year. For more details check {2}.,{0} {1}沒有任何會計年度。欲了解更多詳細信息，請檢查{2}。
apps/erpnext/erpnext/controllers/accounts_controller.py +269,Warning: System will not check overbilling since amount for Item {0} in {1} is zero,警告： {0} {1}為零，系統將不檢查超收因為金額項目
DocType: Journal Entry,Make Difference Entry,使不同入口
DocType: Upload Attendance,Attendance From Date,考勤起始日期
DocType: Appraisal Template Goal,Key Performance Area,關鍵績效區
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +53,Transportation,運輸
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +393,{0} {1} must be submitted,{0} {1}必須提交
DocType: SMS Center,Total Characters,總字符
apps/erpnext/erpnext/controllers/buying_controller.py +140,Please select BOM in BOM field for Item {0},請BOM字段中選擇BOM的項目{0}
DocType: C-Form Invoice Detail,C-Form Invoice Detail,C-表發票詳細信息
DocType: Payment Reconciliation Invoice,Payment Reconciliation Invoice,付款發票對賬
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +32,Contribution %,貢獻％
DocType: Item,website page link,網站頁面的鏈接
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +191,Let's prepare the system for first use.,讓我們準備系統首次使用。
DocType: Company,Company registration numbers for your reference. Tax numbers etc.,公司註冊號碼，供大家參考。稅務號碼等
DocType: Sales Partner,Distributor,經銷商
DocType: Shopping Cart Shipping Rule,Shopping Cart Shipping Rule,購物車運輸規則
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +195,Production Order {0} must be cancelled before cancelling this Sales Order,{0}生產單必須早於售貨單前取消
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +53,Budget cannot be set for Group Cost Centers,預算不能為集團成本中心設置
,Ordered Items To Be Billed,預付款的訂購物品
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +21,Select Time Logs and Submit to create a new Sales Invoice.,選擇時間日誌並提交以創建一個新的銷售發票。
DocType: Global Defaults,Global Defaults,全球默認值
DocType: Salary Slip,Deductions,扣除
DocType: Purchase Invoice,Start date of current invoice's period,當前發票期間內的開始日期
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +23,This Time Log Batch has been billed.,此時日誌批量一直標榜。
apps/erpnext/erpnext/crm/doctype/lead/lead.js +32,Create Opportunity,創造機會
DocType: Salary Slip,Leave Without Pay,無薪假
DocType: Supplier,Communications,通訊
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +275,Capacity Planning Error,容量規劃錯誤
DocType: Lead,Consultant,顧問
DocType: Salary Slip,Earnings,收益
DocType: Sales Invoice Advance,Sales Invoice Advance,銷售發票提前
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +404,Nothing to request,無需求
apps/erpnext/erpnext/projects/doctype/task/task.py +37,'Actual Start Date' can not be greater than 'Actual End Date',“實際開始日期”不能大於“實際結束日期'
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +70,Management,管理
apps/erpnext/erpnext/config/projects.py +33,Types of activities for Time Sheets,活動的考勤表類型
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +13,Investment casting,熔模鑄造
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +45,Either debit or credit amount is required for {0},無論是借方或貸方金額是必需的{0}
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”
DocType: Salary Slip,Net Pay (in words) will be visible once you save the Salary Slip.,淨收費（字）將會看到，一旦你保存工資單。
apps/frappe/frappe/core/doctype/user/user_list.js +12,Active,啟用
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +149,Blue,藍色
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +120,Further nodes can be only created under 'Group' type nodes,此外節點可以在&#39;集團&#39;類型的節點上創建
DocType: Item,UOMs,計量單位
apps/erpnext/erpnext/stock/utils.py +167,{0} valid serial nos for Item {1},{0}有效的序列號的項目{1}
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +58,Item Code cannot be changed for Serial No.,產品編號不能為序列號改變
DocType: Purchase Order Item,UOM Conversion Factor,計量單位換算係數
DocType: Stock Settings,Default Item Group,默認項目組
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +155,Laminated object manufacturing,分層實體製造
apps/erpnext/erpnext/config/buying.py +13,Supplier database.,供應商數據庫。
DocType: Account,Balance Sheet,資產負債表
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +596,Cost Center For Item with Item Code ',成本中心與項目代碼“項目
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +44,Stretch forming,拉伸成型
DocType: Opportunity,Your sales person will get a reminder on this date to contact the customer,您的銷售人員將獲得在此日期提醒聯繫客戶
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +203,"Further accounts can be made under Groups, but entries can be made against non-Groups",進一步帳戶可以根據組進行，但條目可針對非組進行
apps/erpnext/erpnext/config/hr.py +125,Tax and other salary deductions.,稅務及其他薪金中扣除。
DocType: Lead,Lead,鉛
DocType: Email Digest,Payables,應付賬款
DocType: Account,Warehouse,倉庫
,Purchase Order Items To Be Billed,欲付款的採購訂單品項
DocType: Purchase Invoice Item,Net Rate,淨費率
DocType: Backup Manager,Database Folder ID,數據庫文件夾的ID
DocType: Purchase Invoice Item,Purchase Invoice Item,採購發票項目
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +50,Stock Ledger Entries and GL Entries are reposted for the selected Purchase Receipts,股票總帳條目和GL條目轉貼的選擇外購入庫單
DocType: Holiday,Holiday,節日
DocType: Event,Saturday,星期六
DocType: Leave Control Panel,Leave blank if considered for all branches,保持空白如果考慮到全部分支機構
,Daily Time Log Summary,每日時間記錄匯總
DocType: DocField,Label,標籤
DocType: Payment Reconciliation,Unreconciled Payment Details,不甘心付款方式
DocType: Global Defaults,Current Fiscal Year,當前會計年度
DocType: Global Defaults,Disable Rounded Total,禁用圓角總
DocType: Lead,Call,通話
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +356,'Entries' cannot be empty,“分錄”不能是空的
apps/erpnext/erpnext/utilities/transaction_base.py +72,Duplicate row {0} with same {1},重複的行{0}同{1}
,Trial Balance,試算表
sites/assets/js/erpnext.min.js +2,"Grid """,電網“
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +145,Please select prefix first,請先選擇前綴稱號
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +133,Research,研究
DocType: Maintenance Visit Purpose,Work Done,工作完成
DocType: Employee,User ID,使用者 ID
DocType: Communication,Sent,已送出
apps/erpnext/erpnext/accounts/doctype/account/account.js +57,View Ledger,查看總帳
DocType: Cost Center,Lft,LFT
apps/erpnext/erpnext/stock/report/stock_ageing/stock_ageing.py +41,Earliest,最早
apps/erpnext/erpnext/stock/doctype/item/item.py +387,"An Item Group exists with same name, please change the item name or rename the item group",項目組存在具有相同名稱，請更改項目名稱或重命名的項目組
DocType: Sales Order,Delivery Status,交貨狀態
DocType: Production Order,Manufacture against Sales Order,對製造銷售訂單
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +443,Rest Of The World,世界其他地區
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +72,The Item {0} cannot have Batch,該項目{0}不能有批
,Budget Variance Report,預算差異報告
DocType: Salary Slip,Gross Pay,工資總額
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +186,Dividends Paid,股利支付
DocType: Stock Reconciliation,Difference Amount,差額
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +192,Retained Earnings,留存收益
DocType: Purchase Order,Required raw materials issued to the supplier for producing a sub - contracted item.,發給供應商，生產子所需的原材料 - 承包項目。
DocType: BOM Item,Item Description,項目說明
DocType: Payment Tool,Payment Mode,付款方式
DocType: Purchase Invoice,Is Recurring,是經常性
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +153,Direct metal laser sintering,直接金屬激光燒結
DocType: Purchase Order,Supplied Items,提供的物品
DocType: Production Order,Qty To Manufacture,製造數量
DocType: Buying Settings,Maintain same rate throughout purchase cycle,在整個採購週期保持同樣的速度
DocType: Opportunity Item,Opportunity Item,項目的機會
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +61,Temporary Opening,臨時開通
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +40,Cryorolling,Cryorolling
,Employee Leave Balance,員工休假餘額
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +101,Balance for Account {0} must always be {1},帳戶{0}的餘額必須始終為{1}
DocType: Sales Invoice,More Info,更多信息
DocType: Address,Address Type,地址類型
DocType: Purchase Receipt,Rejected Warehouse,拒絕倉庫
DocType: GL Entry,Against Voucher,對傳票
DocType: Item,Default Buying Cost Center,默認情況下購買成本中心
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +42,Item {0} must be Sales Item,項{0}必須是銷售項目
,Accounts Payable Summary,應付帳款摘要
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +159,Not authorized to edit frozen Account {0},無權修改凍結帳戶{0}
DocType: Journal Entry,Get Outstanding Invoices,獲取未付發票
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +55,Sales Order {0} is not valid,銷售訂單{0}無效
DocType: Email Digest,New Stock Entries,新存貨條目
apps/erpnext/erpnext/setup/doctype/company/company.py +161,"Sorry, companies cannot be merged",對不起，企業不能合併
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +140,Small,小
DocType: Employee,Employee Number,員工人數
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +65,Case No(s) already in use. Try from Case No {0},案例編號已在使用中（ S） 。從案例沒有嘗試{0}
DocType: Material Request,% Completed,％已完成
,Invoiced Amount (Exculsive Tax),發票金額（Exculsive稅）
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +59,Account head {0} created,帳戶頭{0}創建
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +148,Green,綠
DocType: Sales Order Item,Discount(%),折讓（％）
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Achieved,總體上實現
DocType: Employee,Place of Issue,簽發地點
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +54,Contract,合同
DocType: Report,Disabled,殘
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +523,UOM coversion factor required for UOM: {0} in Item: {1},所需的計量單位計量單位：丁文因素：{0}項：{1}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +83,Indirect Expenses,間接費用
apps/erpnext/erpnext/controllers/selling_controller.py +171,Row {0}: Qty is mandatory,列#{0}：數量是強制性的
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +7,Agriculture,農業
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +559,Your Products or Services,您的產品或服務
DocType: Mode of Payment,Mode of Payment,付款方式
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +31,This is a root item group and cannot be edited.,請先輸入項目
DocType: Purchase Invoice Item,Purchase Order,採購訂單
DocType: Warehouse,Warehouse Contact Info,倉庫聯繫方式
sites/assets/js/form.min.js +180,Name is required,名稱是必需的
DocType: Purchase Invoice,Recurring Type,經常性類型
DocType: Address,City/Town,市/鎮
DocType: Serial No,Serial No Details,序列號信息
DocType: Purchase Invoice Item,Item Tax Rate,項目稅率
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +132,"For {0}, only credit accounts can be linked against another debit entry",{0}，只有信用賬戶可以對另一個借記鏈接
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +428,Delivery Note {0} is not submitted,送貨單{0}未提交
apps/erpnext/erpnext/stock/get_item_details.py +137,Item {0} must be a Sub-contracted Item,項{0}必須是一個小項目簽約
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +41,Capital Equipments,資本設備
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +31,"Pricing Rule is first selected based on 'Apply On' field, which can be Item, Item Group or Brand.",定價規則是第一選擇是基於“應用在”字段，可以是項目，項目組或品牌。
DocType: Hub Settings,Seller Website,賣家網站
apps/erpnext/erpnext/controllers/selling_controller.py +148,Total allocated percentage for sales team should be 100,對於銷售團隊總分配比例應為100
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +103,Production Order status is {0},生產訂單狀態為{0}
DocType: Appraisal Goal,Goal,目標
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +572,For Supplier,對供應商
DocType: Account,Setting Account Type helps in selecting this Account in transactions.,設置帳戶類型有助於在交易中選擇該帳戶。
DocType: Purchase Invoice,Grand Total (Company Currency),總計（公司貨幣）
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Total Outgoing,即將離任的總
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +42,"There can only be one Shipping Rule Condition with 0 or blank value for ""To Value""",只能有一個運輸規則條件為0或空值“ To值”
DocType: DocType,Transaction,交易
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +46,Note: This Cost Center is a Group. Cannot make accounting entries against groups.,注：該成本中心是一個集團。不能讓反對團體的會計分錄。
apps/erpnext/erpnext/config/projects.py +43,Tools,工具
DocType: Sales Taxes and Charges Template,Valid For Territories,適用於領土
DocType: Item,Website Item Groups,網站項目組
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +190,Production order number is mandatory for stock entry purpose manufacture,生產訂單號碼是強制性的股票入門目的製造
DocType: Purchase Invoice,Total (Company Currency),總（公司貨幣）
DocType: Applicable Territory,Applicable Territory,適用領地
apps/erpnext/erpnext/stock/utils.py +162,Serial number {0} entered more than once,序號{0}多次輸入
DocType: Journal Entry,Journal Entry,日記帳分錄
DocType: Workstation,Workstation Name,工作站名稱
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +19,Email Digest:,電子郵件摘要：
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +429,BOM {0} does not belong to Item {1},BOM {0}不屬於項目{1}
DocType: Sales Partner,Target Distribution,目標分佈
sites/assets/js/desk.min.js +536,Comments,評論
DocType: Salary Slip,Bank Account No.,銀行賬號
DocType: Naming Series,This is the number of the last created transaction with this prefix,這就是以這個前綴的最後一個創建的事務數
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +167,Valuation Rate required for Item {0},所需物品估價速率{0}
DocType: Quality Inspection Reading,Reading 8,閱讀8
DocType: Sales Partner,Agent,代理人
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +74,"Total {0} for all items is zero, may you should change 'Distribute Charges Based On'",共有{0}所有項目為零，可能你應該改變“基於分佈式費”
DocType: Purchase Invoice,Taxes and Charges Calculation,稅費計算
DocType: BOM Operation,Workstation,工作站
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +107,Hardware,硬件
DocType: Attendance,HR Manager,人力資源經理
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +47,Privilege Leave,特權休假
DocType: Purchase Invoice,Supplier Invoice Date,供應商發票日期
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +169,You need to enable Shopping Cart,您需要啟用購物車
sites/assets/js/form.min.js +197,No Data,無數據
DocType: Appraisal Template Goal,Appraisal Template Goal,考核目標模板
DocType: Salary Slip,Earning,盈利
DocType: Purchase Taxes and Charges,Add or Deduct,添加或扣除
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +75,Overlapping conditions found between:,存在重疊的條件：
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +134,Against Journal Entry {0} is already adjusted against some other voucher,對日記條目{0}已經調整一些其他的優惠券
DocType: Backup Manager,Files Folder ID,文件夾的ID
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +58,Total Order Value,總訂單價值
apps/erpnext/erpnext/stock/doctype/item/item.py +196,Item Variants {0} deleted,項目變種{0}刪除
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +38,Food,食物
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +51,Ageing Range 3,老齡範圍3
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +127,You can make a time log only against a submitted production order,您只能對已提交的生產訂單進行時間記錄
DocType: Maintenance Schedule Item,No of Visits,沒有訪問量的
DocType: Cost Center,old_parent,old_parent
apps/erpnext/erpnext/config/support.py +33,"Newsletters to contacts, leads.",通訊，聯繫人，線索。
apps/erpnext/erpnext/hr/doctype/appraisal_template/appraisal_template.py +21,Sum of points for all goals should be 100. It is {0},對所有目標點的總和應該是100。{0}
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +368,Operations cannot be left blank.,操作不能留空。
,Delivered Items To Be Billed,交付項目要被收取
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +61,Warehouse cannot be changed for Serial No.,倉庫不能為序列號改變
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +99,Status updated to {0},狀態更新為{0}
DocType: DocField,Description,描述
DocType: Authorization Rule,Average Discount,平均折扣
DocType: Backup Manager,Backup Manager,備份管理器
DocType: Letter Head,Is Default,是默認
DocType: Address,Utilities,公用事業
DocType: Purchase Invoice Item,Accounting,會計
DocType: Features Setup,Features Setup,功能設置
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +13,View Offer Letter,查看錄取通知書
DocType: Sales BOM,Sales BOM,銷售BOM
DocType: Communication,Communication,通訊
DocType: Item,Is Service Item,是服務項目
DocType: Activity Cost,Projects,專案
apps/erpnext/erpnext/hr/doctype/holiday_list/holiday_list.py +30,Please select Fiscal Year,請選擇會計年度
apps/erpnext/erpnext/controllers/buying_controller.py +23,From {0} | {1} {2},從{0} | {1} {2}
DocType: BOM Operation,Operation Description,操作說明
DocType: Item,Will also apply to variants,也將適用於變種
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +30,Cannot change Fiscal Year Start Date and Fiscal Year End Date once the Fiscal Year is saved.,不能更改財政年度開始日期和財政年度結束日期，一旦會計年度被保存。
DocType: Quotation,Shopping Cart,購物車
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +42,Avg Daily Outgoing,平均每日傳出
DocType: Pricing Rule,Campaign,競賽
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +29,Approval Status must be 'Approved' or 'Rejected',審批狀態必須被“批准”或“拒絕”
DocType: Sales Invoice,Sales BOM Help,銷售BOM幫助
DocType: Purchase Invoice,Contact Person,聯繫人
apps/erpnext/erpnext/projects/doctype/task/task.py +34,'Expected Start Date' can not be greater than 'Expected End Date',“預計開始日期”不能大於“預計結束日期'
DocType: Holiday List,Holidays,假期
DocType: Sales Order Item,Planned Quantity,計劃數量
DocType: Purchase Invoice Item,Item Tax Amount,項目稅額
DocType: Supplier Quotation,Get Terms and Conditions,獲取條款和條件
DocType: Leave Control Panel,Leave blank if considered for all designations,離開，如果考慮所有指定空白
apps/erpnext/erpnext/controllers/accounts_controller.py +391,Charge of type 'Actual' in row {0} cannot be included in Item Rate,類型'實際'行{0}的電荷不能被包含在項目單價
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +165,Max: {0},馬克斯：{0}
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +16,From Datetime,從日期時間
DocType: Email Digest,For Company,對於公司
apps/erpnext/erpnext/config/support.py +38,Communication log.,通信日誌。
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +66,Buying Amount,客戶買入金額
DocType: Sales Invoice,Shipping Address Name,送貨地址名稱
apps/erpnext/erpnext/accounts/doctype/account/account.js +50,Chart of Accounts,科目表
DocType: Material Request,Terms and Conditions Content,條款及細則內容
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +506,cannot be greater than 100,不能大於100
DocType: Purchase Receipt Item,Discount  %,折扣％
apps/erpnext/erpnext/stock/doctype/item/item.py +473,Item {0} is not a stock Item,項{0}不是缺貨登記
DocType: Maintenance Visit,Unscheduled,計劃外
DocType: Employee,Owned,擁有的
DocType: Pricing Rule,"Higher the number, higher the priority",數字越大，優先級越高
,Purchase Invoice Trends,購買發票趨勢
DocType: Employee,Better Prospects,更好的前景
DocType: Appraisal,Goals,目標
DocType: Warranty Claim,Warranty / AMC Status,保修/ AMC狀態
,Accounts Browser,帳戶瀏覽器
DocType: GL Entry,GL Entry,GL報名
DocType: HR Settings,Employee Settings,員工設置
,Batch-Wise Balance History,間歇式平衡歷史
DocType: Email Digest,To Do List,待辦事項列表
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +58,Apprentice,學徒
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +94,Negative Quantity is not allowed,負數量是不允許
DocType: Purchase Invoice Item,"Tax detail table fetched from item master as a string and stored in this field.
Used for Taxes and Charges","稅務詳細信息表從項目主作為一個字符串獲取並存儲在這一領域。
用於稅費"
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +60,Lancing,採血
apps/erpnext/erpnext/hr/doctype/employee/employee.py +147,Employee cannot report to himself.,員工不能報告自己。
DocType: Account,"If the account is frozen, entries are allowed to restricted users.",如果帳戶被凍結，條目被允許受限制的用戶。
DocType: Job Opening,"Job profile, qualifications required etc.",所需的工作概況，學歷等。
DocType: Journal Entry Account,Account Balance,賬戶餘額
DocType: Rename Tool,Type of document to rename.,的文件類型進行重命名。
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +578,We buy this Item,我們買這個項目
DocType: Address,Billing,計費
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +76,Flanging,翻邊
DocType: Bulk Email,Not Sent,未發送
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +72,Explosive forming,爆炸成形
DocType: Purchase Invoice,Total Taxes and Charges (Company Currency),總稅費和費用（公司貨幣）
DocType: Shipping Rule,Shipping Account,送貨賬戶
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +41,Scheduled to send to {0} recipients,原定發送到{0}受助人
DocType: Quality Inspection,Readings,閱讀
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,Sub Assemblies,子組件
DocType: Shipping Rule Condition,To Value,To值
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +159,Source warehouse is mandatory for row {0},列{0}的來源倉是必要的
DocType: Packing Slip,Packing Slip,裝箱單
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +111,Office Rent,辦公室租金
apps/erpnext/erpnext/config/setup.py +80,Setup SMS gateway settings,設置短信閘道設置
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +59,Import Failed!,導入失敗！
sites/assets/js/erpnext.min.js +19,No address added yet.,沒有地址添加呢。
DocType: Workstation Working Hour,Workstation Working Hour,工作站工作時間
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +78,Analyst,分析人士
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +191,Row {0}: Allocated amount {1} must be less than or equals to JV amount {2},行{0}：分配量{1}必須小於或等於合資量{2}
DocType: Item,Inventory,庫存
DocType: Item,Sales Details,銷售信息
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +148,Pinning,鋼釘
DocType: Opportunity,With Items,隨著項目
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,In Qty,在數量
DocType: Notification Control,Expense Claim Rejected,費用索賠被拒絕
DocType: Sales Invoice,"The date on which next invoice will be generated. It is generated on submit.
",在這接下來的發票將生成的日期。它在提交生成。
DocType: Item Attribute,Item Attribute,項目屬性
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +100,Government,政府
DocType: Item,Re-order,重新排序
DocType: Company,Services,服務
apps/erpnext/erpnext/accounts/report/financial_statements.py +149,Total ({0}),總計（{0}）
DocType: Cost Center,Parent Cost Center,父成本中心
DocType: Sales Invoice,Source,源
DocType: Leave Type,Is Leave Without Pay,是無薪休假
DocType: Purchase Order Item,"If Supplier Part Number exists for given Item, it gets stored here",如果供應商零件編號存在給定的項目，它被存放在這裡
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +175,No records found in the Payment table,沒有在支付表中找到記錄
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +403,Financial Year Start Date,財政年度開始日期
DocType: Employee External Work History,Total Experience,總經驗
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +99,Countersinking,擴孔
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +255,Packing Slip(s) cancelled,裝箱單（ S）取消
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +96,Freight and Forwarding Charges,貨運代理費
DocType: Material Request Item,Sales Order No,銷售訂單號
DocType: Item Group,Item Group Name,項目組名稱
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +47,Taken,拍攝
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +63,Transfer Materials for Manufacture,轉移製造材料
DocType: Pricing Rule,For Price List,對於價格表
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +26,Executive Search,獵頭
apps/erpnext/erpnext/stock/stock_ledger.py +385,"Purchase rate for item: {0} not found, which is required to book accounting entry (expense). Please mention item price against a buying price list.",購買率的項目：{0}沒有找到，這是需要預訂會計分錄（費用）。請註明項目價格對買入價格表。
DocType: Maintenance Schedule,Schedules,時間表
DocType: Purchase Invoice Item,Net Amount,淨額
DocType: Purchase Order Item Supplied,BOM Detail No,BOM表詳細編號
DocType: Period Closing Voucher,CoA Help,輔酶幫助
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +533,Error: {0} > {1},錯誤： {0} > {1}
apps/erpnext/erpnext/accounts/doctype/account/account.js +8,Please create new account from Chart of Accounts.,請從科目表創建新帳戶。
DocType: Maintenance Visit,Maintenance Visit,維護訪問
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +49,Customer > Customer Group > Territory,客戶>客戶群>領地
DocType: Sales Invoice Item,Available Batch Qty at Warehouse,可用的批次數量在倉庫
DocType: Time Log Batch Detail,Time Log Batch Detail,時間日誌批量詳情
DocType: Workflow State,Tasks,任務
DocType: Landed Cost Voucher,Landed Cost Help,到岸成本幫助
DocType: Event,Tuesday,星期二
DocType: Leave Block List,Block Holidays on important days.,塊假期重要的日子。
,Accounts Receivable Summary,應收賬款匯總
apps/erpnext/erpnext/hr/doctype/employee/employee.py +178,Please set User ID field in an Employee record to set Employee Role,請在員工記錄設置員工角色設置用戶ID字段
DocType: UOM,UOM Name,計量單位名稱
DocType: Top Bar Item,Target,目標
apps/erpnext/erpnext/selling/report/sales_person_wise_transaction_summary/sales_person_wise_transaction_summary.py +33,Contribution Amount,貢獻金額
DocType: Sales Invoice,Shipping Address,送貨地址
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: Delivery Note,In Words will be visible once you save the Delivery Note.,送貨單一被儲存，就會顯示出來。
apps/erpnext/erpnext/config/stock.py +120,Brand master.,品牌大師。
DocType: ToDo,Due Date,到期日
DocType: Sales Invoice Item,Brand Name,商標名稱
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Box,箱
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +387,The Organization,本組織
DocType: Monthly Distribution,Monthly Distribution,月度分佈
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +66,Receiver List is empty. Please create Receiver List,收受方列表為空。請創建收受方列表
DocType: Production Plan Sales Order,Production Plan Sales Order,生產計劃銷售訂單
DocType: Sales Partner,Sales Partner Target,銷售合作夥伴目標
DocType: Pricing Rule,Pricing Rule,定價規則
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +57,Notching,開槽
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +44,Reserved warehouse required for stock item {0},所需的庫存項目保留倉庫{0}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +16,Bank Accounts,銀行賬戶
,Bank Reconciliation Statement,銀行對帳表
DocType: Address,Lead Name,鉛名稱
,POS,POS
apps/erpnext/erpnext/stock/doctype/item_attribute/item_attribute.py +14,{0} must appear only once,{0}必須只出現一次
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +371,Not allowed to tranfer more {0} than {1} against Purchase Order {2},不允許轉院更多{0}不是{1}對採購訂單{2}
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.py +58,Leaves Allocated Successfully for {0},{0}的排假成功
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +40,No Items to pack,無項目包裝
DocType: Shipping Rule Condition,From Value,從價值
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +579,Manufacturing Quantity is mandatory,生產數量是必填的
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +41,Amounts not reflected in bank,數額沒有反映在銀行
DocType: Quality Inspection Reading,Reading 4,4閱讀
apps/erpnext/erpnext/config/hr.py +23,Claims for company expense.,索賠費用由公司負責。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +7,Centrifugal casting,離心鑄造
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +118,Magnetic field-assisted finishing,磁場輔助整理
DocType: Company,Default Holiday List,默認假日列表
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +227,Task is Mandatory if Time Log is against a project,任務是強制性的，如果時間日誌是針對一個項目
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +165,Stock Liabilities,現貨負債
DocType: Purchase Receipt,Supplier Warehouse,供應商倉庫
DocType: Opportunity,Contact Mobile No,聯繫手機號碼
DocType: Production Planning Tool,Select Sales Orders,選擇銷售訂單
,Material Requests for which Supplier Quotations are not created,對該供應商報價的材料需求尚未建立
DocType: Features Setup,To track items using barcode. You will be able to enter items in Delivery Note and Sales Invoice by scanning barcode of item.,要使用條形碼跟踪項目。您將能夠通過掃描物品條碼，進入交貨單和銷售發票的項目。
apps/erpnext/erpnext/crm/doctype/lead/lead.js +34,Make Quotation,請報價
DocType: Dependent Task,Dependent Task,相關任務
apps/erpnext/erpnext/stock/doctype/item/item.py +291,Conversion factor for default Unit of Measure must be 1 in row {0},為缺省的計量單位轉換因子必須是1行{0}
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +193,You can not enter both Delivery Note No and Sales Invoice No. Please enter any one.,請輸入倉庫的材料要求將提高
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +142,Leave of type {0} cannot be longer than {1},請假類型{0}不能長於{1}
DocType: Manufacturing Settings,Try planning operations for X days in advance.,嘗試規劃X天行動提前。
DocType: HR Settings,Stop Birthday Reminders,停止生日提醒
DocType: SMS Center,Receiver List,收受方列表
DocType: Payment Tool Detail,Payment Amount,付款金額
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +46,Consumed Amount,消耗量
DocType: Salary Structure Deduction,Salary Structure Deduction,薪酬結構演繹
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +157,Selective laser sintering,選擇性激光燒結
apps/erpnext/erpnext/stock/doctype/item/item.py +286,Unit of Measure {0} has been entered more than once in Conversion Factor Table,計量單位{0}已經進入不止一次在轉換係數表
apps/frappe/frappe/core/page/data_import_tool/data_import_tool.js +74,Import Successful!,導入成功！
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +27,Cost of Issued Items,發布項目成本
DocType: Email Digest,Expenses Booked,支出預訂
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +168,Quantity must not be more than {0},數量必須不超過{0}
DocType: Quotation Item,Quotation Item,產品報價
DocType: Account,Account Name,帳戶名稱
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +34,From Date cannot be greater than To Date,起始日期不能大於結束日期
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +209,Serial No {0} quantity {1} cannot be a fraction,序列號{0}的數量量{1}不能是分數
apps/erpnext/erpnext/config/buying.py +59,Supplier Type master.,供應商類型高手。
DocType: Purchase Order Item,Supplier Part Number,供應商零件編號
apps/frappe/frappe/core/page/permission_manager/permission_manager.js +372,Add,添加
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +87,Conversion rate cannot be 0 or 1,轉化率不能為0或1
DocType: Accounts Settings,Credit Controller,信用控制器
DocType: Delivery Note,Vehicle Dispatch Date,車輛調度日期
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +56,Task is mandatory if Expense Claim is against a Project,任務是強制性的，如果費用報銷是對一個項目
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +196,Purchase Receipt {0} is not submitted,外購入庫單{0}未提交
DocType: Company,Default Payable Account,預設應付賬款
DocType: Party Type,Contacts,往來
apps/erpnext/erpnext/config/website.py +13,"Settings for online shopping cart such as shipping rules, price list etc.",設置網上購物車，如航運規則，價格表等
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +601,Setup Complete,安裝完成
apps/erpnext/erpnext/controllers/website_list_for_contact.py +48,{0}% Billed,{0}％帳單
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +33,Reserved Qty,保留數量
DocType: Party Account,Party Account,黨的帳戶
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +69,Human Resources,人力資源
DocType: Lead,Upper Income,高收入
apps/erpnext/erpnext/support/doctype/issue/issue.py +52,My Issues,我的問題
DocType: BOM Item,BOM Item,BOM項目
DocType: Appraisal,For Employee,對於員工
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +188,Row {0}: Payment amount can not be negative,行{0}：付款金額不能為負
DocType: Expense Claim,Total Amount Reimbursed,報銷金額合計
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +151,Press fitting,按擬合
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +60,Against Supplier Invoice {0} dated {1},對供應商發票{0}日期{1}
DocType: Party Type,Default Price List,默認價格表
DocType: Journal Entry,User Remark will be added to Auto Remark,用戶備註將被添加到自動注
DocType: Payment Reconciliation,Payments,付款
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +23,Hot isostatic pressing,熱等靜壓
DocType: ToDo,Medium,中
DocType: Budget Detail,Budget Allocated,預算分配
,Customer Credit Balance,客戶信用平衡
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +42,Customer required for 'Customerwise Discount',需要' Customerwise折扣“客戶
apps/erpnext/erpnext/config/accounts.py +53,Update bank payment dates with journals.,更新與期刊銀行付款日期。
DocType: Quotation,Term Details,長期詳情
DocType: Manufacturing Settings,Capacity Planning For (Days),容量規劃的期限（天）
DocType: Warranty Claim,Warranty Claim,保修索賠
,Lead Details,鉛詳情
DocType: Authorization Rule,Approving User,批准用戶
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +36,Forging,鍛造
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +125,Plating,電鍍
DocType: Purchase Invoice,End date of current invoice's period,當前發票的期限的最後一天
DocType: Pricing Rule,Applicable For,適用
DocType: Bank Reconciliation,From Date,從日期
DocType: Backup Manager,Validate,驗證
DocType: Maintenance Visit,Partially Completed,部分完成
DocType: Sales Invoice,Packed Items,盒裝項目
apps/erpnext/erpnext/config/support.py +18,Warranty Claim against Serial No.,針對序列號保修索賠
DocType: BOM Replace 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",在它使用的所有其他材料明細表替換特定的BOM。它將取代舊的BOM鏈接，更新成本和再生“BOM爆炸物品”表按照新的BOM
DocType: Shopping Cart Settings,Enable Shopping Cart,讓購物車
DocType: Employee,Permanent Address,永久地址
apps/erpnext/erpnext/stock/get_item_details.py +123,Item {0} must be a Service Item.,項{0}必須是一個服務項目。
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +158,Please select item code,請選擇商品代碼
DocType: Salary Structure Deduction,Reduce Deduction for Leave Without Pay (LWP),減少扣除停薪留職（LWP）
DocType: Territory,Territory Manager,區域經理
DocType: Selling Settings,Selling Settings,銷售設置
apps/erpnext/erpnext/stock/doctype/item/item.py +155,Item cannot be a variant of a variant,項目不能是變體的變體
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +38,Online Auctions,網上拍賣
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +89,Please specify either Quantity or Valuation Rate or both,請註明無論是數量或估價率或兩者
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +36,"Company, Month and Fiscal Year is mandatory",公司、月分與財務年度是必填的
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +102,Marketing Expenses,市場推廣開支
,Item Shortage Report,商品短缺報告
apps/erpnext/erpnext/stock/doctype/item/item.js +208,"Weight is mentioned,\nPlease mention ""Weight UOM"" too",權重被提及，\n請註明“重量計量單位”太
DocType: Stock Entry Detail,Material Request used to make this Stock Entry,材料要求用來做這個股票輸入
DocType: Journal Entry,View Details,查看詳情
apps/erpnext/erpnext/config/support.py +43,Single unit of an Item.,該產品的一個單元。
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +160,Time Log Batch {0} must be 'Submitted',時間日誌批量{0}必須是'提交'
DocType: Accounts Settings,Make Accounting Entry For Every Stock Movement,為每股份轉移做會計分錄
DocType: Leave Allocation,Total Leaves Allocated,分配的總葉
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +334,Warehouse required at Row No {0},在行無需倉庫{0}
DocType: Employee,Date Of Retirement,退休日
DocType: Upload Attendance,Get Template,獲取模板
DocType: Address,Postal,郵政
DocType: Email Digest,Total amount of invoices sent to the customer during the digest period,的過程中消化期間發送給客戶的發票總金額
DocType: Item,Weightage,權重
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +158,Mining,礦業
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +16,Resin casting,樹脂澆注
apps/erpnext/erpnext/selling/doctype/customer/customer.py +79,A Customer Group exists with same name please change the Customer name or rename the Customer Group,客戶群組存在相同名稱，請更改客戶名稱或重新命名客戶群組
DocType: Territory,Parent Territory,家長領地
DocType: Quality Inspection Reading,Reading 2,閱讀2
DocType: Stock Entry,Material Receipt,材料收據
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +570,Products,產品
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +41,Party Type and Party is required for Receivable / Payable account {0},黨的類型和黨的需要應收/應付帳戶{0}
DocType: Lead,Next Contact By,下一個聯絡人由
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +218,Quantity required for Item {0} in row {1},列{1}項目{0}必須有數量
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +85,Warehouse {0} can not be deleted as quantity exists for Item {1},倉庫{0} ，從量存在項目不能被刪除{1}
DocType: Quotation,Order Type,訂單類型
DocType: Purchase Invoice,Notification Email Address,通知電子郵件地址
DocType: Payment Tool,Find Invoices to Match,查找發票到匹配
,Item-wise Sales Register,項目明智的銷售登記
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +397,"e.g. ""XYZ National Bank""",例如“XYZ國家銀行“
DocType: Purchase Taxes and Charges,Is this Tax included in Basic Rate?,包括在基本速率此稅？
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +57,Total Target,總目標
DocType: Job Applicant,Applicant for a Job,申請人作業
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +178,No Production Orders created,沒有創建生產訂單
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +131,Salary Slip of employee {0} already created for this month,員工{0}於本月的工資單已經創建
DocType: Stock Reconciliation,Reconciliation JSON,JSON對賬
apps/erpnext/erpnext/accounts/report/financial_statements.html +3,Too many columns. Export the report and print it using a spreadsheet application.,太多的列。導出報表，並使用電子表格應用程序進行打印。
DocType: Sales Invoice Item,Batch No,批號
apps/erpnext/erpnext/setup/doctype/company/company.py +142,Main,主頁
DocType: DocPerm,Delete,刪除
apps/erpnext/erpnext/stock/doctype/item/item_list.js +11,Variant,變種
sites/assets/js/desk.min.js +836,New {0},新的{0}
DocType: Naming Series,Set prefix for numbering series on your transactions,為你的交易編號序列設置的前綴
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +154,Stopped order cannot be cancelled. Unstop to cancel.,已停止訂單無法取消。 撤銷停止再取消。
apps/erpnext/erpnext/stock/doctype/item/item.py +308,Default BOM ({0}) must be active for this item or its template,默認BOM（{0}）必須是活動的這個項目或者其模板
DocType: Employee,Leave Encashed?,離開兌現？
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +31,Opportunity From field is mandatory,機會從字段是強制性的
DocType: Sales Invoice,Considered as an Opening Balance,視為期初餘額
DocType: Item,Variants,變種
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation.js +468,Make Purchase Order,做採購訂單
DocType: SMS Center,Send To,發送到
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +111,There is not enough leave balance for Leave Type {0},沒有足夠的餘額休假請假類型{0}
DocType: Sales Team,Contribution to Net Total,貢獻合計淨
DocType: Sales Invoice Item,Customer's Item Code,客戶的產品編號
DocType: Stock Reconciliation,Stock Reconciliation,庫存對賬
DocType: Territory,Territory Name,地區名稱
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +143,Work-in-Progress Warehouse is required before Submit,工作在進展倉庫提交之前，需要
apps/erpnext/erpnext/config/hr.py +43,Applicant for a Job.,申請職位
DocType: Sales Invoice Item,Warehouse and Reference,倉庫及參考
DocType: Supplier,Statutory info and other general information about your Supplier,法定的信息和你的供應商等一般資料
DocType: Country,Country,國家
apps/erpnext/erpnext/shopping_cart/utils.py +48,Addresses,地址
DocType: Communication,Received,收到
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +156,Against Journal Entry {0} does not have any unmatched {1} entry,對日記條目{0}沒有任何無與倫比{1}進入
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +216,Duplicate Serial No entered for Item {0},重複的序列號輸入的項目{0}
DocType: Shipping Rule Condition,A condition for a Shipping Rule,為航運規則的條件
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +201,"Name of new Account. Note: Please don't create accounts for Customers and Suppliers, they are created automatically from the Customer and Supplier master",新帳戶的名稱。注意：請不要新增客戶和供應商的帳戶，它們會自動從客戶和供應商主檔新增。
DocType: DocField,Attach Image,附上圖片
DocType: Packing Slip,The net weight of this package. (calculated automatically as sum of net weight of items),淨重這個包。 （當項目的淨重量總和自動計算）
DocType: Stock Reconciliation Item,Leave blank if no change,離開，如果沒有變化的空白
apps/erpnext/erpnext/config/manufacturing.py +24,Time Logs for manufacturing.,時間日誌製造。
DocType: Item,Apply Warehouse-wise Reorder Level,適用於倉庫明智的重新排序水平
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +426,BOM {0} must be submitted,BOM {0}必須提交
DocType: Authorization Control,Authorization Control,授權控制
apps/erpnext/erpnext/config/projects.py +23,Time Log for tasks.,時間日誌中的任務。
DocType: Production Order Operation,Actual Time and Cost,實際時間和成本
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +52,Material Request of maximum {0} can be made for Item {1} against Sales Order {2},最大的材料要求{0}可為項目{1}對銷售訂單{2}
DocType: Employee,Salutation,招呼
DocType: Offer Letter,Rejected,拒絕
DocType: Pricing Rule,Brand,牌
DocType: Item,Will also apply for variants,同時將申請變種
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +609,% Delivered,％交付
apps/erpnext/erpnext/config/selling.py +148,Bundle items at time of sale.,捆綁項目在銷售時。
DocType: Sales Order Item,Actual Qty,實際數量
DocType: Quality Inspection Reading,Reading 10,閱讀10
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +560,"List your products or services that you buy or sell. Make sure to check the Item Group, Unit of Measure and other properties when you start.",列出您售出或購買的產品或服務，並請確認品項群駔、單位與其它屬性。
DocType: Hub Settings,Hub Node,樞紐節點
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +78,You have entered duplicate items. Please rectify and try again.,您輸入重複的項目。請糾正，然後再試一次。
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +82,Associate,關聯
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +46,Item {0} is not a serialized Item,項{0}不是一個序列化的項目
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +573,"For 'Sales BOM' 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 'Sales BOM' item, those values can be entered in the main Item table, values will be copied to 'Packing List' table.",對於“銷售BOM”項目，倉庫，序列號和批號將被從“裝箱單”表考慮。如果倉庫和批號相同，為任何“銷售BOM”項目的所有包裝的物品，這些值可以在主項表輸入，值將被複製到“裝箱單”表。
DocType: SMS Center,Create Receiver List,創建接收器列表
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +5,Expired,過期
DocType: Packing Slip,To Package No.,以包號
DocType: DocType,System,系統
DocType: Warranty Claim,Issue Date,發行日期
DocType: Activity Cost,Activity Cost,活動費用
DocType: Purchase Receipt Item Supplied,Consumed Qty,消耗的數量
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +51,Telecommunications,電信
DocType: Packing Slip,Indicates that the package is a part of this delivery (Only Draft),表示該包是這個交付的一部分（僅草案）
DocType: Payment Tool,Make Payment Entry,使付款輸入
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +119,Quantity for Item {0} must be less than {1},項目{0}的數量必須小於{1}
DocType: Backup Manager,Never,從來沒有
,Sales Invoice Trends,銷售發票趨勢
DocType: Leave Application,Apply / Approve Leaves,申請/審批葉
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +90,Can refer row only if the charge type is 'On Previous Row Amount' or 'Previous Row Total',可以參考的行只有在充電類型是“在上一行量'或'前行總計”
DocType: Item,Allowance Percent,津貼百分比
DocType: SMS Settings,Message Parameter,消息參數
DocType: Serial No,Delivery Document No,交貨證明文件號碼
DocType: Landed Cost Voucher,Get Items From Purchase Receipts,獲取項目從購買收據
DocType: Serial No,Creation Date,創建日期
apps/erpnext/erpnext/stock/doctype/item_price/item_price.py +34,Item {0} appears multiple times in Price List {1},項{0}中多次出現價格表{1}
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +37,"Selling must be checked, if Applicable For is selected as {0}",銷售必須進行檢查，如果適用於被選擇為{0}
DocType: Purchase Order Item,Supplier Quotation Item,供應商報價項目
apps/erpnext/erpnext/hr/doctype/employee/employee.js +27,Make Salary Structure,製作薪酬結構
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +53,Shearing,剪毛
DocType: Item,Has Variants,有變種
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +22,Click on 'Make Sales Invoice' button to create a new Sales Invoice.,單擊“製作銷售發票”按鈕來創建一個新的銷售發票。
apps/erpnext/erpnext/controllers/recurring_document.py +164,Period From and Period To dates mandatory for recurring %s,期間從和週期要強制日期為重複％S
DocType: Journal Entry Account,Against Expense Claim,對報銷
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +165,Packaging and labeling,包裝和標籤
DocType: Monthly Distribution,Name of the Monthly Distribution,每月分配的名稱
DocType: Sales Person,Parent Sales Person,母公司銷售人員
apps/erpnext/erpnext/setup/utils.py +14,Please specify Default Currency in Company Master and Global Defaults,請在公司主及全球默認指定默認貨幣
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +221,"Payment against {0} {1} cannot be greater \
					than Outstanding Amount {2}","支付對{0} {1}不能大於\
多名優秀金額{2}"
DocType: Backup Manager,Dropbox Access Secret,Dropbox的訪問秘密
DocType: Purchase Invoice,Recurring Invoice,經常性發票
DocType: Item,Net Weight of each Item,每個項目的淨重
DocType: Supplier,Supplier of Goods or Services.,供應商的商品或服務。
DocType: Budget Detail,Fiscal Year,財政年度
DocType: Cost Center,Budget,預算
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +50,Achieved,實現
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +65,Territory / Customer,區域/客戶
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +502,e.g. 5,例如5
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +195,Row {0}: Allocated amount {1} must be less than or equals to invoice outstanding amount {2},行{0}：已分配量{1}必須小於或等於發票餘額{2}
DocType: Sales Invoice,In Words will be visible once you save the Sales Invoice.,在詞將是可見的，一旦你保存銷售發票。
DocType: Item,Is Sales Item,是銷售項目
apps/erpnext/erpnext/setup/doctype/item_group/item_group.js +21,Item Group Tree,由於生產訂單可以為這個項目， \作
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +70,Item {0} is not setup for Serial Nos. Check Item master,項{0}不是設置為序列號檢查項目主
DocType: Maintenance Visit,Maintenance Time,維護時間
,Amount to Deliver,量交付
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +568,A Product or Service,產品或服務
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +139,There were errors.,有錯誤。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +100,Tapping,竊聽
DocType: Naming Series,Current Value,當前值
apps/erpnext/erpnext/stock/doctype/item/item.py +145,Item Template cannot have stock and varaiants. Please remove stock from warehouses {0},項目模板不能有股市和varaiants。請從倉庫取出的股票{0}
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +176,{0} created,{0}創建
DocType: Journal Entry Account,Against Sales Order,對銷售訂單
,Serial No Status,序列號狀態
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +502,Item table can not be blank,項目表不能為空
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +148,"Row {0}: To set {1} periodicity, difference between from and to date \
						must be greater than or equal to {2}","行{0}：設置{1}的週期性，從和到日期\
之間差必須大於或等於{2}"
DocType: Pricing Rule,Selling,銷售
DocType: Employee,Salary Information,薪資信息
DocType: Sales Person,Name and Employee ID,姓名和僱員ID
apps/erpnext/erpnext/accounts/party.py +186,Due Date cannot be before Posting Date,到期日不能在寄發日期之前
DocType: Website Item Group,Website Item Group,網站項目組
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +170,Duties and Taxes,關稅和稅款
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +275,Please enter Reference date,參考日期請輸入
DocType: Item Website Specification,Table for Item that will be shown in Web Site,表項，將在網站顯示出來
DocType: Purchase Order Item Supplied,Supplied Qty,附送數量
DocType: Material Request Item,Material Request Item,材料要求項目
apps/erpnext/erpnext/config/stock.py +103,Tree of Item Groups.,樹的項目組。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +100,Cannot refer row number greater than or equal to current row number for this Charge type,不能引用的行號大於或等於當前行號碼提供給充電式
,Item-wise Purchase History,項目明智的購買歷史
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +147,Red,紅
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +237,Please click on 'Generate Schedule' to fetch Serial No added for Item {0},請點擊“生成表”來獲取序列號增加了對項目{0}
DocType: Account,Frozen,凍結的
,Open Production Orders,開啟生產訂單
DocType: Installation Note,Installation Time,安裝時間
apps/erpnext/erpnext/setup/doctype/company/company.js +36,Delete all the Transactions for this Company,刪除所有交易本公司
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +204,Row #{0}: Operation {1} is not completed for {2} qty of finished goods in Production Order # {3}. Please update operation status via Time Logs,行＃{0}：操作{1}未完成的成品{2}在生產數量訂單{3}。請通過時間日誌更新運行狀態
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +57,Investments,投資
DocType: Issue,Resolution Details,詳細解析
apps/erpnext/erpnext/config/stock.py +84,Change UOM for an Item.,更改品項的計量單位。
DocType: Quality Inspection Reading,Acceptance Criteria,驗收標準
DocType: Item Attribute,Attribute Name,屬性名稱
apps/erpnext/erpnext/controllers/selling_controller.py +256,Item {0} must be Sales or Service Item in {1},項{0}必須在銷售或服務項目{1}
DocType: Item Group,Show In Website,顯示在網站
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +569,Group,組
DocType: Task,Expected Time (in hours),預期時間（以小時計）
,Qty to Order,訂購數量
DocType: Sales Order,PO No,訂單號碼
apps/erpnext/erpnext/config/projects.py +51,Gantt chart of all tasks.,所有任務的甘特圖。
DocType: Appraisal,For Employee Name,對於員工姓名
DocType: Holiday List,Clear Table,清除表格
DocType: Features Setup,Brands,品牌
DocType: C-Form Invoice Detail,Invoice No,發票號碼
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +497,From Purchase Order,從採購訂單
apps/erpnext/erpnext/accounts/party.py +139,Please select company first.,請先選擇公司。
DocType: Activity Cost,Costing Rate,成本率
DocType: Journal Entry Account,Against Journal Entry,對日記帳分錄
DocType: Employee,Resignation Letter Date,辭退信日期
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +37,Pricing Rules are further filtered based on quantity.,定價規則進一步過濾基於數量。
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +137,Not Set,沒有設置
DocType: Communication,Date,日期
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +61,Repeat Customer Revenue,重複客戶收入
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +592,Sit tight while your system is being setup. This may take a few moments.,坐好囉！您的系統正在安裝。這可能需要一些時間。
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +46,{0} ({1}) must have role 'Expense Approver',{0}（{1}）必須有作用“支出審批”
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Pair,對
DocType: Bank Reconciliation Detail,Against Account,針對帳戶
DocType: Maintenance Schedule Detail,Actual Date,實際日期
DocType: Item,Has Batch No,有批號
DocType: Delivery Note,Excise Page Number,消費頁碼
DocType: Employee,Personal Details,個人資料
,Maintenance Schedules,保養時間表
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +43,Embossing,壓花
,Quotation Trends,報價趨勢
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +135,Item Group not mentioned in item master for item {0},在主項未提及的項目項目組{0}
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +243,Debit To account must be a Receivable account,借記帳戶必須是應收賬款
apps/erpnext/erpnext/stock/doctype/item/item.py +295,"As Production Order can be made for this item, it must be a stock item.",由於生產訂單可以為這個項目提出，它必須是一個股票項目。
DocType: Shipping Rule Condition,Shipping Amount,航運量
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +139,Joining,加盟
DocType: Authorization Rule,Above Value,上述值
,Pending Amount,待審核金額
DocType: Purchase Invoice Item,Conversion Factor,轉換因子
DocType: Serial No,Delivered,交付
apps/erpnext/erpnext/config/hr.py +160,Setup incoming server for jobs email id. (e.g. jobs@example.com),設置接收服務器的工作電子郵件ID 。 （例如jobs@example.com ）
DocType: Purchase Invoice,The date on which recurring invoice will be stop,在其經常性發票將被停止日期
DocType: Journal Entry,Accounts Receivable,應收帳款
,Supplier-Wise Sales Analytics,供應商相關的銷售分析
DocType: Address Template,This format is used if country specific format is not found,此格式用於如果找不到特定國家的格式
DocType: Custom Field,Custom,自訂
DocType: Production Order,Use Multi-Level BOM,採用多級物料清單
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +25,Injection molding,注塑
DocType: Bank Reconciliation,Include Reconciled Entries,包括對賬項目
apps/erpnext/erpnext/config/accounts.py +41,Tree of finanial accounts.,樹finanial帳戶。
DocType: Leave Control Panel,Leave blank if considered for all employee types,保持空白如果考慮到所有的員工類型
DocType: Landed Cost Voucher,Distribute Charges Based On,分銷費基於
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +253,Account {0} must be of type 'Fixed Asset' as Item {1} is an Asset Item,帳戶{0}的類型必須為“固定資產”作為項目{1}是一個資產項目
DocType: HR Settings,HR Settings,人力資源設置
apps/frappe/frappe/config/setup.py +130,Printing,印花
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +107,Expense Claim is pending approval. Only the Expense Approver can update status.,使項目所需的質量保證和質量保證在沒有採購入庫單
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +99,The day(s) on which you are applying for leave are holiday. You need not apply for leave.,在天在你申請許可的假期。你不需要申請許可。
sites/assets/js/desk.min.js +684,and,和
DocType: Leave Block List Allow,Leave Block List Allow,休假區塊清單准許
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +49,Sports,體育
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.py +61,Total Actual,實際總
DocType: Stock Entry,"Get valuation rate and available stock at source/target warehouse on mentioned posting date-time. If serialized item, please press this button after entering serial nos.",獲取估值率和可用庫存在上提到過賬日期 - 時間源/目標倉庫。如果序列化的項目，請輸入序列號後，按下此按鈕。
apps/erpnext/erpnext/templates/includes/cart.js +288,Something went wrong.,出事了。
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +574,Unit,單位
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_dropbox.py +129,Please set Dropbox access keys in your site config,請在您的網站配置設置Dropbox的存取碼
apps/erpnext/erpnext/stock/get_item_details.py +114,Please specify Company,請註明公司
,Customer Acquisition and Loyalty,客戶獲得和忠誠度
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +103,From Time cannot be greater than To Time,從時間不能大於時間
DocType: Purchase Receipt,Warehouse where you are maintaining stock of rejected items,倉庫你在哪裡維護拒絕的項目庫存
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +406,Your financial year ends on,您的財政年度結束於
DocType: POS Setting,Price List,價格表
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +20,{0} is now the default Fiscal Year. Please refresh your browser for the change to take effect.,{0}現在是默認的財政年度。請刷新您的瀏覽器，以使更改生效。
apps/erpnext/erpnext/projects/doctype/project/project.js +41,Expense Claims,報銷
DocType: Email Digest,Support,支持
DocType: Authorization Rule,Approving Role,審批角色
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +89,Please specify currency in Company,請公司指定的貨幣
DocType: Workstation,Wages per hour,每小時工資
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +43,Stock balance in Batch {0} will become negative {1} for Item {2} at Warehouse {3},在批量庫存餘額{0}將成為負{1}的在倉庫項目{2} {3}
apps/erpnext/erpnext/config/setup.py +53,"Show / Hide features like Serial Nos, POS etc.",顯示／隱藏功能。如序列號， POS等
DocType: Purchase Receipt,LR No,LR無
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +34,UOM Conversion factor is required in row {0},計量單位換算係數是必需的行{0}
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +51,Clearance date cannot be before check date in row {0},清拆日期不能行檢查日期前{0}
DocType: Salary Slip,Deduction,扣除
DocType: Address Template,Address Template,地址模板
DocType: Territory,Classification of Customers by region,客戶按區域分類
DocType: Project,% Tasks Completed,％完成的任務
DocType: Project,Gross Margin,毛利
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +137,Please enter Production Item first,請先輸入生產項目
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +76,disabled user,禁用的用戶
DocType: Opportunity,Quotation,報價
DocType: Salary Slip,Total Deduction,扣除總額
apps/erpnext/erpnext/templates/includes/cart.js +99,Hey! Go ahead and add an address,嘿！來吧，添加地址
DocType: Quotation,Maintenance User,維護用戶
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +144,Cost Updated,成本更新
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +764,Are you sure you want to UNSTOP,你確定你要UNSTOP
DocType: Employee,Date of Birth,出生日期
DocType: Salary Manager,Salary Manager,薪資管理
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +425,Item {0} has already been returned,項{0}已被退回
DocType: Fiscal Year,**Fiscal Year** represents a Financial Year. All accounting entries and other major transactions are tracked against **Fiscal Year**.,**財年**表示財政年度。所有的會計分錄和其他重大交易進行跟踪打擊**財年**。
DocType: Opportunity,Customer / Lead Address,客戶/鉛地址
DocType: Production Order Operation,Actual Operation Time,實際操作時間
DocType: Authorization Rule,Applicable To (User),適用於（用戶）
DocType: Purchase Taxes and Charges,Deduct,扣除
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +165,Job Description,職位描述
DocType: Purchase Order Item,Qty as per Stock UOM,數量按庫存計量單位
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +34,Please select a valid csv file with data,請選擇有合格資料的csv檔案
DocType: Features Setup,To track items in sales and purchase documents with batch nos<br><b>Preferred Industry: Chemicals etc</b>,為了跟踪與批次號在銷售和採購文件的項目<br> <b>首選行業：化工等</b>
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +91,Coating,塗層
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +121,"Special Characters except ""-"", ""#"", ""."" and ""/"" not allowed in naming series",特殊字符除了“ - ”，“”，“＃”，和“/”未命名序列允許
DocType: Campaign,"Keep Track of Sales Campaigns. Keep track of Leads, Quotations, Sales Order etc from Campaigns to gauge Return on Investment.",保持銷售計劃的軌道。跟踪的信息，報價，銷售訂單等，從戰役來衡量投資回報。
DocType: Expense Claim,Approver,審批人
,SO Qty,SO數量
apps/erpnext/erpnext/accounts/doctype/account/account.py +127,"Stock entries exist against warehouse {0}, hence you cannot re-assign or modify Warehouse",Stock條目對倉庫存在{0}，因此你不能重新分配或修改倉庫
DocType: Appraisal,Calculate Total Score,計算總分
DocType: Salary Slip Deduction,Depends on LWP,依賴於LWP
DocType: Supplier Quotation,Manufacturing Manager,生產經理
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +201,Serial No {0} is under warranty upto {1},序列號{0}在保修期內直到{1}
apps/erpnext/erpnext/config/stock.py +69,Split Delivery Note into packages.,分裂送貨單成包。
apps/erpnext/erpnext/shopping_cart/utils.py +46,Shipments,發貨
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +28,Dip molding,浸成型
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +25,Time Log Status must be Submitted.,時間日誌狀態必須被提交。
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +591,Setting Up,設置
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +90,Make Debit Note,讓繳費單
DocType: Purchase Invoice,In Words (Company Currency),在字（公司貨幣）
DocType: Pricing Rule,Supplier,供應商
DocType: C-Form,Quarter,季
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +105,Miscellaneous Expenses,雜項開支
DocType: Global Defaults,Default Company,默認公司
apps/erpnext/erpnext/controllers/stock_controller.py +165,Expense or Difference account is mandatory for Item {0} as it impacts overall stock value,費用或差異帳戶是強制性的項目{0} ，因為它影響整個股票價值
apps/erpnext/erpnext/controllers/accounts_controller.py +285,"Cannot overbill for Item {0} in row {1} more than {2}. To allow overbilling, please set in Stock Settings",不能行overbill的項目{0} {1}超過{2}。要允許超額計費，請在股票設置設置
DocType: Employee,Bank Name,銀行名稱
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +38,-Above,-Above
apps/erpnext/erpnext/hr/doctype/employee/employee.py +131,User {0} is disabled,用戶{0}被禁用
DocType: Leave Application,Total Leave Days,總休假天數
DocType: Email Digest,Note: Email will not be sent to disabled users,注：電子郵件將不會被發送到被禁用的用戶
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +36,Select Company...,選擇公司...
DocType: Leave Control Panel,Leave blank if considered for all departments,保持空白如果考慮到全部部門
apps/erpnext/erpnext/config/hr.py +95,"Types of employment (permanent, contract, intern etc.).",就業（永久，合同，實習生等）的類型。
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +305,{0} is mandatory for Item {1},{0}是強制性的項目{1}
DocType: Currency Exchange,From Currency,從貨幣
DocType: DocField,Name,名稱
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +199,"Please select Allocated Amount, Invoice Type and Invoice Number in atleast one row",請ATLEAST一行選擇分配金額，發票類型和發票號碼
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +61,Last Sales Order Date,最後的銷售訂單日期
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +90,Sales Order required for Item {0},所需的{0}項目銷售訂單
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +42,Amounts not reflected in system,量以不反映在系統
DocType: Purchase Invoice Item,Rate (Company Currency),率（公司貨幣）
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +40,Others,他人
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +313,Production might not be able to finish by the Expected Delivery Date.,生產可能無法通過預計交貨日期完成。
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +19,Set as Stopped,設為停止
DocType: POS Setting,Taxes and Charges,稅收和收費
DocType: Item,"A Product or a Service that is bought, sold or kept in stock.",A產品或已購買，出售或持有的股票服務。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +94,Cannot select charge type as 'On Previous Row Amount' or 'On Previous Row Total' for first row,不能選擇充電式為'在上一行量'或'在上一行總'的第一行
apps/frappe/frappe/core/doctype/doctype/boilerplate/controller_list.html +31,Completed,已完成
DocType: Web Form,Select DocType,選擇DocType
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +103,Broaching,拉床
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +11,Banking,銀行業
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +48,Please click on 'Generate Schedule' to get schedule,請在“生成表”點擊獲取時間表
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +276,New Cost Center,新的成本中心
DocType: Bin,Ordered Quantity,訂購數量
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +395,"e.g. ""Build tools for builders""",例如「建設建設者工具“
DocType: Quality Inspection,In Process,在過程
DocType: Authorization Rule,Itemwise Discount,Itemwise折扣
DocType: Purchase Receipt,Detailed Breakup of the totals,總計詳細分手
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +286,{0} against Sales Order {1},{0}對銷售訂單{1}
DocType: Account,Fixed Asset,固定資產
DocType: Time Log Batch,Total Billing Amount,總結算金額
apps/erpnext/erpnext/accounts/report/item_wise_sales_register/item_wise_sales_register.py +47,Receivable Account,應收賬款
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.py +140,No Updates For,沒有更新有關
,Stock Balance,庫存餘額
DocType: Expense Claim Detail,Expense Claim Detail,報銷詳情
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +259,Time Logs created:,時間日誌創建：
DocType: Company,If Yearly Budget Exceeded,如果年度預算超出
DocType: Item,Weight UOM,重量計量單位
DocType: Employee,Blood Group,血型
DocType: Purchase Invoice Item,Page Break,分頁符
DocType: Production Order Operation,Pending,擱置
DocType: Employee Leave Approver,Users who can approve a specific employee's leave applications,用戶誰可以批准特定員工的休假申請
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +50,Office Equipments,辦公設備
DocType: Purchase Invoice Item,Qty,數量
DocType: Fiscal Year,Companies,企業
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +23,Electronics,電子
DocType: Email Digest,"Balances of Accounts of type ""Bank"" or ""Cash""",鍵入“銀行”賬戶的餘額或“現金”
DocType: Shipping Rule,"Specify a list of Territories, for which, this Shipping Rule is valid",新界指定一個列表，其中，該運費規則是有效的
DocType: Stock Settings,Raise Material Request when stock reaches re-order level,當庫存到達需重新訂購水平時提高物料需求
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +18,From Maintenance Schedule,對維護期間
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +51,Full-time,全日制
DocType: Company,Country Settings,國家設置
DocType: Employee,Contact Details,聯繫方式
DocType: C-Form,Received Date,接收日期
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: Backup Manager,Upload Backups to Google Drive,上傳備份到 Google Drive
DocType: Stock Entry,Total Incoming Value,總傳入值
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,Purchase Price List,採購價格表
DocType: Offer Letter Term,Offer Term,要約期限
DocType: Quality Inspection,Quality Manager,質量經理
DocType: Job Applicant,Job Opening,開放職位
DocType: Payment Reconciliation,Payment Reconciliation,付款對賬
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +164,Please select Incharge Person's name,請選擇Incharge人的名字
DocType: Delivery Note,Date on which lorry started from your warehouse,日期從倉庫上貨車開始
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +50,Technology,技術
DocType: Purchase Order,Supplier (vendor) name as entered in supplier master,供應商（供應商）的名稱在供應商主進入
DocType: Offer Letter,Offer Letter,報價函
apps/erpnext/erpnext/config/manufacturing.py +51,Generate Material Requests (MRP) and Production Orders.,生成材料要求（MRP）和生產訂單。
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +68,Total Invoiced Amt,總開票金額
DocType: Time Log,To Time,要時間
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +25,"To add child nodes, explore tree and click on the node under which you want to add more nodes.",要添加子節點，探索樹，然後單擊要在其中添加更多節點的節點上。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +94,Credit To account must be a Payable account,信用帳戶必須是應付賬款
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +236,BOM recursion: {0} cannot be parent or child of {2},BOM遞歸： {0}不能父母或兒童{2}
DocType: Production Order Operation,Completed Qty,完成數量
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +135,"For {0}, only debit accounts can be linked against another credit entry",{0}，只有借記卡賬戶可以對另一記入聯
apps/erpnext/erpnext/stock/get_item_details.py +236,Price List {0} is disabled,價格表{0}被禁用
DocType: Manufacturing Settings,Allow Overtime,允許加班
apps/erpnext/erpnext/controllers/selling_controller.py +247,Sales Order {0} is stopped,銷售訂單{0}被停止
DocType: Email Digest,New Leads,新信息
DocType: Stock Reconciliation Item,Current Valuation Rate,目前的估值價格
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +239,"Advance paid against {0} {1} cannot be greater \
					than Grand Total {2}","提前對{0} {1}不能大於付出比\
總計{2}"
DocType: Opportunity,Lost Reason,失落的原因
apps/erpnext/erpnext/config/accounts.py +68,Create Payment Entries against Orders or Invoices.,創建付款項對訂單或發票。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +140,Welding,焊接
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +18,New Stock UOM is required,新的庫存計量單位是必需的
DocType: Quality Inspection,Sample Size,樣本大小
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +418,All items have already been invoiced,所有項目已開具發票
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +47,Please specify a valid 'From Case No.',請指定一個有效的“從案號”
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +280,Further cost centers can be made under Groups but entries can be made against non-Groups,進一步的成本中心可以根據組進行，但項可以對非組進行
DocType: Project,External,外部
DocType: Features Setup,Item Serial Nos,產品序列號
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +8,Not Received,未收到
DocType: Branch,Branch,支
DocType: Sales Invoice,Customer (Receivable) Account,客戶（應收）帳
DocType: Bin,Actual Quantity,實際數量
DocType: Shipping Rule,example: Next Day Shipping,例如：次日發貨
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +198,Serial No {0} not found,序列號{0}未找到
DocType: Shopping Cart Settings,Price Lists,價格表
DocType: Purchase Invoice,Considered as Opening Balance,視為期初餘額
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +513,Your Customers,您的客戶
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +26,Compression molding,壓縮成型
DocType: Leave Block List Date,Block Date,座日期
DocType: Sales Order,Not Delivered,未交付
,Bank Clearance Summary,銀行結算摘要
apps/erpnext/erpnext/config/setup.py +75,"Create and manage daily, weekly and monthly email digests.",創建和管理每日，每週和每月的電子郵件摘要。
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +46,Item Code > Item Group > Brand,產品編號>項目組>品牌
DocType: Appraisal Goal,Appraisal Goal,考核目標
DocType: Event,Friday,星期五
DocType: Time Log,Costing Amount,成本核算金額
DocType: Salary Manager,Submit Salary Slip,提交工資單
DocType: Salary Structure,Monthly Earning & Deduction,每月入息和扣除
apps/erpnext/erpnext/controllers/selling_controller.py +162,Maxiumm discount for Item {0} is {1}%,品項{0}的最大折扣：{1}％
DocType: Supplier,Address & Contacts,地址及聯繫方式
DocType: SMS Log,Sender Name,發件人名稱
DocType: Page,Title,標題
sites/assets/js/list.min.js +92,Customize,定制
DocType: POS Setting,[Select],[選擇]
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +28,Make Sales Invoice,做銷售發票
DocType: Company,For Reference Only.,僅供參考。
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +45,Invalid {0}: {1},無效的{0}：{1}
DocType: Sales Invoice Advance,Advance Amount,提前量
DocType: Manufacturing Settings,Capacity Planning,容量規劃
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +49,'From Date' is required,“起始日期”是必需的
DocType: Journal Entry,Reference Number,參考號碼
DocType: Employee,Employment Details,就業信息
DocType: Employee,New Workplace,新工作空間
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +17,Set as Closed,設置為關閉
apps/erpnext/erpnext/stock/get_item_details.py +104,No Item with Barcode {0},沒有條碼{0}的品項
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +51,Case No. cannot be 0,案號不能為0
DocType: Features Setup,If you have Sales Team and Sale Partners (Channel Partners)  they can be tagged and maintain their contribution in the sales activity,如果你有銷售團隊和銷售合作夥伴（渠道合作夥伴），他們可以被標記，並維持其在銷售貢獻活動
DocType: Item,Show a slideshow at the top of the page,顯示幻燈片在頁面頂部
apps/erpnext/erpnext/setup/doctype/company/company.py +71,Stores,商店
DocType: Time Log,Projects Manager,項目經理
DocType: Serial No,Delivery Time,交貨時間
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +27,Ageing Based On,老齡化基於
DocType: Item,End of Life,壽命結束
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +41,Travel,旅遊
DocType: Leave Block List,Allow Users,允許用戶
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +199,Operation is Mandatory,操作強制性
DocType: Purchase Order,Recurring,經常性
DocType: Cost Center,Track separate Income and Expense for product verticals or divisions.,跟踪獨立收入和支出進行產品垂直或部門。
DocType: Rename Tool,Rename Tool,重命名工具
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +11,Update Cost,更新成本
DocType: Item Reorder,Item Reorder,項目重新排序
DocType: Address,Check to make primary address,勾選以設定主地址
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +507,Transfer Material,轉印材料
DocType: BOM,"Specify the operations, operating cost and give a unique Operation no to your operations.",指定作業、作業成本並給予該作業一個專屬的作業編號。
DocType: Purchase Invoice,Price List Currency,價格表貨幣
DocType: Naming Series,User must always select,用戶必須始終選擇
DocType: Stock Settings,Allow Negative Stock,允許負庫存
DocType: Installation Note,Installation Note,安裝注意事項
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +491,Add Taxes,添加稅賦
,Financial Analytics,財務分析
DocType: Quality Inspection,Verified By,認證機構
DocType: Address,Subsidiary,副
apps/erpnext/erpnext/setup/doctype/company/company.py +37,"Cannot change company's default currency, because there are existing transactions. Transactions must be cancelled to change the default currency.",不能改變公司的預設貨幣，因為有存在的交易。交易必須取消更改默認貨幣。
DocType: Quality Inspection,Purchase Receipt No,購買收據號碼
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +30,Earnest Money,保證金
DocType: Salary Manager,Create Salary Slip,建立工資單
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +44,Expected balance as per bank,預計結餘按銀行
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +114,Buffing,拋光
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +158,Source of Funds (Liabilities),資金來源（負債）
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +383,Quantity in row {0} ({1}) must be same as manufactured quantity {2},列{0}的數量（{1}）必須與生產量{2}相同
DocType: Appraisal,Employee,僱員
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +10,Import Email From,導入電子郵件發件人
DocType: Features Setup,After Sale Installations,銷售後安裝
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +233,{0} {1} is fully billed,{0} {1}完全開票
DocType: Workstation Working Hour,End Time,結束時間
apps/erpnext/erpnext/config/setup.py +42,Standard contract terms for Sales or Purchase.,銷售或採購的標準合同條款。
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +79,Group by Voucher,集團透過券
apps/erpnext/erpnext/templates/form_grid/material_request_grid.html +7,Required On,要求在
DocType: Sales Invoice,Mass Mailing,郵件群發
DocType: Page,Standard,標準
DocType: Rename Tool,File to Rename,文件重命名
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +175,Purchse Order number required for Item {0},項目{0}需要採購訂單號
apps/erpnext/erpnext/controllers/buying_controller.py +246,Specified BOM {0} does not exist for Item {1},指定BOM {0}的項目不存在{1}
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +183,Maintenance Schedule {0} must be cancelled before cancelling this Sales Order,維護時間表{0}必須取消早於取消這個銷售訂單
DocType: Email Digest,Payments Received,收到付款
DocType: Cost Center,"Define Budget for this Cost Center. To set budget action, see <a href=""#!List/Company"">Company Master</a>","定義預算這個成本中心。要設置預算行動，見<a href=""#!List/Company"">公司主</a>"
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +138,Size,尺寸
DocType: Notification Control,Expense Claim Approved,報銷批准
DocType: Email Digest,Calendar Events,日曆事件
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +108,Pharmaceutical,製藥
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Cost of Purchased Items,購買的物品成本
DocType: Selling Settings,Sales Order Required,銷售訂單需求
apps/erpnext/erpnext/crm/doctype/lead/lead.js +30,Create Customer,創建客戶
DocType: Purchase Invoice,Credit To,信貸
DocType: Employee Education,Post Graduate,研究生
DocType: Backup Manager,"Note: Backups and files are not deleted from Dropbox, you will have to delete them manually.",注意：備份和文件不會從Dropbox刪除，你必續手動刪除它們。
DocType: Maintenance Schedule Detail,Maintenance Schedule Detail,維護計劃細節
DocType: Quality Inspection Reading,Reading 9,9閱讀
DocType: Buying Settings,Buying Settings,求購設置
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +121,Mass finishing,質量精加工
DocType: Stock Entry Detail,BOM No. for a Finished Good Item,BOM編號為成品產品
DocType: Upload Attendance,Attendance To Date,出席會議日期
apps/erpnext/erpnext/config/selling.py +153,Setup incoming server for sales email id. (e.g. sales@example.com),設置接收服務器銷售的電子郵件ID 。 （例如sales@example.com ）
DocType: Warranty Claim,Raised By,提出
DocType: Payment Tool,Payment Account,付款帳號
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +725,Please specify Company to proceed,請註明公司以處理
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +14,Google Drive,Google Drive
sites/assets/js/list.min.js +22,Draft,草稿
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +45,Compensatory Off,補假
DocType: Quality Inspection Reading,Accepted,接受的
DocType: User,Female,女
apps/erpnext/erpnext/setup/doctype/company/company.js +19,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: Print Settings,Modern,現代
DocType: Communication,Replied,回答
DocType: Payment Tool,Total Payment Amount,總付款金額
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +136,{0} ({1}) cannot be greater than planned quanitity ({2}) in Production Order {3},{0}（{1}）不能大於計劃quanitity（{2}）的生產訂單{3}
DocType: Shipping Rule,Shipping Rule Label,送貨規則標籤
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +212,Raw Materials cannot be blank.,原材料不能為空。
DocType: Newsletter,Test,測試
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.js +84,You can not change rate if BOM mentioned agianst any item,你不能改變速度，如果BOM中提到反對的任何項目
DocType: Employee,Previous Work Experience,以前的工作經驗
DocType: Stock Entry,For Quantity,對於數量
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +162,Please enter Planned Qty for Item {0} at row {1},請輸入列{1}的品項{0}的計劃數量
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +218,{0} {1} is not submitted,{0} {1}未提交
apps/erpnext/erpnext/config/stock.py +13,Requests for items.,需求的項目。
DocType: Production Planning Tool,Separate production order will be created for each finished good item.,將對每個成品項目創建獨立的生產訂單。
DocType: Email Digest,New Communications,新通訊
DocType: Purchase Invoice,Terms and Conditions1,條款及條件1
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard_page.html +18,Complete Setup,完成安裝
DocType: Accounts Settings,"Accounting entry frozen up to this date, nobody can do / modify entry except role specified below.",會計分錄凍結至該日期，除以下指定職位權限外，他人無法修改。
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +124,Please save the document before generating maintenance schedule,請在產生維護計畫前儲存文件
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +28,Project Status,項目狀態
DocType: UOM,Check this to disallow fractions. (for Nos),選中此選項禁止分數。 （對於NOS）
apps/erpnext/erpnext/config/crm.py +86,Newsletter Mailing List,時事通訊錄
DocType: Delivery Note,Transporter Name,轉運名稱
DocType: Contact,Enter department to which this Contact belongs,輸入聯繫屬於的部門
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Absent,共缺席
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +716,Item or Warehouse for row {0} does not match Material Request,項目或倉庫為行{0}不匹配材料要求
apps/erpnext/erpnext/config/stock.py +109,Unit of Measure,計量單位
DocType: Fiscal Year,Year End Date,年結日
DocType: Task Depends On,Task Depends On,任務取決於
DocType: Lead,Opportunity,機會
DocType: Salary Structure Earning,Salary Structure Earning,薪酬結構盈利
,Completed Production Orders,已完成生產訂單
DocType: Operation,Default Workstation,默認工作站
DocType: Email Digest,Inventory & Support,庫存與支持
DocType: Notification Control,Expense Claim Approved Message,報銷批准的消息
DocType: Email Digest,How frequently?,多久？
DocType: Purchase Receipt,Get Current Stock,獲取當前庫存
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +619,Make Installation Note,使安裝注意事項
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +208,Maintenance start date can not be before delivery date for Serial No {0},維護開始日期不能交付日期序列號前{0}
DocType: Production Order,Actual End Date,實際結束日期
DocType: Authorization Rule,Applicable To (Role),適用於（角色）
DocType: Stock Entry,Purpose,目的
DocType: Item,Will also apply for variants unless overrridden,同時將申請變種，除非overrridden
DocType: Purchase Invoice,Advances,進展
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +32,Approving User cannot be same as user the rule is Applicable To,批准用戶作為用戶的規則適用於不能相同
DocType: SMS Log,No of Requested SMS,無的請求短信
DocType: Campaign,Campaign-.####,運動 - ＃＃ ＃ ＃
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +485,Make Invoice,製作發票
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +54,Piercing,沖孔
DocType: Customer,Your Customer's TAX registration numbers (if applicable) or any general information,你的客戶的稅務登記證號碼（如適用）或任何股東信息
apps/erpnext/erpnext/hr/doctype/employee/employee.py +113,Contract End Date must be greater than Date of Joining,合同結束日期必須大於加入的日期
DocType: Sales Partner,A third party distributor / dealer / commission agent / affiliate / reseller who sells the companies products for a commission.,第三方分銷商/經銷商/代理商/分支機構/分銷商誰銷售公司產品的佣金。
DocType: Customer Group,Has Child Node,有子節點
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +299,{0} against Purchase Order {1},{0}對採購訂單{1}
DocType: SMS Settings,"Enter static url parameters here (Eg. sender=ERPNext, username=ERPNext, password=1234 etc.)",在這裡輸入靜態URL參數（如稱發件人= ERPNext，用戶名= ERPNext，密碼= 1234等）
apps/erpnext/erpnext/setup/page/setup_wizard/default_website.py +26,This is an example website auto-generated from ERPNext,這是一個示例網站從ERPNext自動生成
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +37,Ageing Range 1,老齡範圍1
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +109,Photochemical machining,光化學加工
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。添加或扣除：無論你是想增加或扣除的稅。"
DocType: Note,Note,注釋
DocType: Email Digest,New Material Requests,新物料需求
DocType: Purchase Receipt Item,Recd Quantity,RECD數量
DocType: Email Account,Email Ids,電子郵件ID
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +95,Cannot produce more Item {0} than Sales Order quantity {1},不能產生更多的項目{0}不是銷售訂單數量{1}
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +23,Set as Unstopped,設為堵塞通
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +440,Stock Entry {0} is not submitted,股票輸入{0}不提交
DocType: Payment Reconciliation,Bank / Cash Account,銀行／現金賬戶
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +43,This Leave Application is pending approval. Only the Leave Approver can update status.,這請假申請正在等待批准。只有請假審批者可以更新狀態。
DocType: Global Defaults,Hide Currency Symbol,隱藏貨幣符號
apps/erpnext/erpnext/config/accounts.py +154,"e.g. Bank, Cash, Credit Card",例如：銀行，現金，信用卡
DocType: Journal Entry,Credit Note,信用票據
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +206,Completed Qty cannot be more than {0} for operation {1},完成數量不能超過{0}操作{1}
DocType: Features Setup,Quality,品質
DocType: Contact Us Settings,Introduction,介紹
DocType: Warranty Claim,Service Address,服務地址
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +71,Max 100 rows for Stock Reconciliation.,最大100行的股票和解。
DocType: Stock Entry,Manufacture,製造
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +13,Please Delivery Note first,請送貨單第一
DocType: Shopping Cart Taxes and Charges Master,Tax Master,稅務碩士
DocType: Opportunity,Customer / Lead Name,客戶/鉛名稱
apps/erpnext/erpnext/accounts/doctype/bank_reconciliation/bank_reconciliation.py +61,Clearance Date not mentioned,清拆日期未提及
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +66,Production,生產
DocType: Item,Allow Production Order,允許生產訂單
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +60,Row {0}:Start Date must be before End Date,列#{0}：開始日期必須早於結束日期
apps/erpnext/erpnext/controllers/trends.py +19,Total(Qty),總計（數量）
DocType: Installation Note Item,Installed Qty,安裝數量
DocType: Lead,Fax,傳真
DocType: Purchase Taxes and Charges,Parenttype,Parenttype
sites/assets/js/list.min.js +26,Submitted,提交
DocType: Salary Structure,Total Earning,總盈利
DocType: Purchase Receipt,Time at which materials were received,收到材料在哪個時間
apps/erpnext/erpnext/config/hr.py +100,Organization branch master.,組織分支主檔。
DocType: Purchase Invoice,Will be calculated automatically when you enter the details,當你輸入詳細信息將自動計算
DocType: Delivery Note,Transporter lorry number,轉運貨車數量
DocType: Sales Order,Billing Status,計費狀態
DocType: Backup Manager,Backup Right Now,即刻備份
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +135,Utility Expenses,公用事業費用
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +45,90-Above,90以上
DocType: Buying Settings,Default Buying Price List,默認情況下採購價格表
DocType: Notification Control,Sales Order Message,銷售訂單信息
apps/erpnext/erpnext/config/setup.py +15,"Set Default Values like Company, Currency, Current Fiscal Year, etc.",設置默認值如公司，貨幣，當前財政年度等
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.js +20,Payment Type,付款類型
DocType: Salary Manager,Select Employees,選擇僱員
DocType: Bank Reconciliation,To Date,至今
DocType: Opportunity,Potential Sales Deal,潛在的銷售交易
sites/assets/js/form.min.js +286,Details,詳細信息
DocType: Purchase Invoice,Total Taxes and Charges,總營業稅金及費用
DocType: Email Digest,Payments Made,支付的款項
DocType: Employee,Emergency Contact,緊急聯絡人
DocType: Item,Quality Parameters,質量參數
DocType: Target Detail,Target  Amount,目標金額
DocType: Shopping Cart Settings,Shopping Cart Settings,購物車設置
DocType: Journal Entry,Accounting Entries,會計分錄
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +24,Duplicate Entry. Please check Authorization Rule {0},重複的條目。請檢查授權規則{0}
DocType: Purchase Order,Ref SQ,參考SQ
apps/erpnext/erpnext/config/manufacturing.py +56,Replace Item / BOM in all BOMs,更換項目/物料清單中的所有材料明細表
DocType: Purchase Order Item,Received Qty,收到數量
DocType: Stock Entry Detail,Serial No / Batch,序列號/批次
DocType: Sales BOM,Parent Item,父項目
DocType: Account,Account Type,賬戶類型
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +222,Maintenance Schedule is not generated for all the items. Please click on 'Generate Schedule',維護計畫不會為全部品項生成。請點擊“生成表”
,To Produce,以生產
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +119,"For row {0} in {1}. To include {2} in Item rate, rows {3} must also be included",對於行{0} {1}。以包括{2}中的檔案速率，行{3}也必須包括
DocType: Packing Slip,Identification of the package for the delivery (for print),送達包裹的識別（用於打印）
DocType: Bin,Reserved Quantity,保留數量
DocType: Landed Cost Voucher,Purchase Receipt Items,採購入庫項目
DocType: Party Type,Parent Party Type,父方類型
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +61,Cutting,切割
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +68,Flattening,壓扁
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +27,Backups will be uploaded to,備份將被上傳到
DocType: Account,Income Account,收入賬戶
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +21,Molding,模
DocType: Stock Reconciliation Item,Current Qty,目前數量
DocType: BOM Item,"See ""Rate Of Materials Based On"" in Costing Section",見“率材料基於”在成本核算節
DocType: Appraisal Goal,Key Responsibility Area,關鍵責任區
DocType: Item Reorder,Material Request Type,材料需求類型
apps/frappe/frappe/desk/moduleview.py +61,Documents,文件
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +17,Ref,參考
DocType: Cost Center,Cost Center,成本中心
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.js +48,Voucher #,＃ ＃＃ ＃，＃＃
DocType: Notification Control,Purchase Order Message,採購訂單的消息
DocType: Upload Attendance,Upload HTML,上傳HTML
apps/erpnext/erpnext/controllers/accounts_controller.py +323,"Total advance ({0}) against Order {1} cannot be greater \
				than the Grand Total ({2})","預付款總額（{0}）反對令{1}不能大於\
比總計（{2}）"
DocType: Employee,Relieving Date,解除日期
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +12,"Pricing Rule is made to overwrite Price List / define discount percentage, based on some criteria.",定價規則是由覆蓋價格表/定義折扣百分比，基於某些條件。
DocType: Serial No,Warehouse can only be changed via Stock Entry / Delivery Note / Purchase Receipt,倉庫只能通過股票輸入/送貨單/外購入庫單變
DocType: Employee Education,Class / Percentage,類／百分比
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +87,Head of Marketing and Sales,營銷和銷售主管
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +31,Income Tax,所得稅
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +156,Laser engineered net shaping,激光直接成型
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +15,"If selected Pricing Rule is made for 'Price', it will overwrite Price List. Pricing Rule price is the final price, 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.",如果選擇的定價規則是由為'價格'，它將覆蓋價目表。定價規則價格是最終價格，所以沒有進一步的折扣應適用。因此，在像銷售訂單，採購訂單等交易，這將是“速度”字段進賬，而不是“價格單率”字段。
apps/erpnext/erpnext/config/selling.py +158,Track Leads by Industry Type.,軌道信息通過行業類型。
DocType: Item Supplier,Item Supplier,產品供應商
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +331,Please enter Item Code to get batch no,請輸入產品編號，以獲得批號
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +679,Please select a value for {0} quotation_to {1},請選擇一個值{0} quotation_to {1}
DocType: Global Defaults,For automatic exchange rates go to jsonrates.com and signup for an API key,對於自動匯率去jsonrates.com和註冊獲取API密鑰
apps/erpnext/erpnext/config/selling.py +33,All Addresses.,所有地址。
DocType: Company,Stock Settings,庫存設置
DocType: User,Bio,生物
apps/erpnext/erpnext/accounts/doctype/account/account.py +166,"Merging is only possible if following properties are same in both records. Is Group, Root Type, Company",合併是唯一可能的，如果以下屬性中均有記載相同。是集團，根型，公司
apps/erpnext/erpnext/config/crm.py +62,Manage Customer Group Tree.,管理客戶組樹。
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +278,New Cost Center Name,新的成本中心名稱
DocType: Leave Control Panel,Leave Control Panel,休假控制面板
apps/erpnext/erpnext/utilities/doctype/address/address.py +67,No default Address Template found. Please create a new one from Setup > Printing and Branding > Address Template.,沒有默認的地址找到模板。請創建一個從設置＞印刷與品牌＞地址模板。
DocType: Appraisal,HR User,HR用戶
DocType: Purchase Invoice,Taxes and Charges Deducted,稅收和費用扣除
apps/erpnext/erpnext/shopping_cart/utils.py +47,Issues,問題
apps/erpnext/erpnext/utilities/__init__.py +24,Status must be one of {0},狀態必須是一個{0}
DocType: Sales Invoice,Debit To,借記
DocType: Delivery Note,Required only for sample item.,只對樣品項目所需。
DocType: Stock Ledger Entry,Actual Qty After Transaction,交易後實際數量
,Pending SO Items For Purchase Request,待處理的SO項目對於採購申請
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +143,Extra Large,特大號
,Profit and Loss Statement,損益表
DocType: Bank Reconciliation Detail,Cheque Number,支票號碼
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +42,Pressing,壓制
DocType: Payment Tool Detail,Payment Tool Detail,支付工具的詳細信息
,Sales Browser,銷售瀏覽器
DocType: Journal Entry,Total Credit,總積分
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +443,Warning: Another {0} # {1} exists against stock entry {2},警告：另一個{0}＃{1}存在對股票入門{2}
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +390,Local,當地
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +26,Loans and Advances (Assets),貸款及墊款（資產）
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +12,Debtors,債務人
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +142,Large,大
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +18,No employee found!,無發現任何員工！
DocType: C-Form Invoice Detail,Territory,領土
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +162,Please mention no of visits required,請註明無需訪問
DocType: Stock Settings,Default Valuation Method,默認的估值方法
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +126,Polishing,拋光
DocType: Production Order Operation,Planned Start Time,計劃開始時間
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +46,Allocated,分配
apps/erpnext/erpnext/config/accounts.py +63,Close Balance Sheet and book Profit or Loss.,關閉資產負債表和賬面利潤或虧損。
DocType: Currency Exchange,Specify Exchange Rate to convert one currency into another,指定的匯率將一種貨幣兌換成另一種
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +81,Row{0}: Party Type and Party is only applicable against Receivable / Payable account,行{0}：黨的類型和黨的只適用對應收/應付帳
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +135,Quotation {0} is cancelled,{0}報價被取消
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +26,Total Outstanding Amount,未償還總額
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +29,Employee {0} was on leave on {1}. Cannot mark attendance.,員工{0}於{1}休假。不能標記考勤。
DocType: Sales Partner,Targets,目標
DocType: Price List,Price List Master,價格表主檔
DocType: Sales Person,All Sales Transactions can be tagged against multiple **Sales Persons** so that you can set and monitor targets.,所有的銷售交易，可以用來標記針對多個**銷售**的人，這樣你可以設置和監控目標。
,S.O. No.,SO號
DocType: Production Order Operation,Make Time Log,讓時間日誌
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +162,Please create Customer from Lead {0},請牽頭建立客戶{0}
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +44,Computers,電腦
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +111,Electro-chemical grinding,電化學磨
apps/erpnext/erpnext/setup/doctype/customer_group/customer_group.js +14,This is a root customer group and cannot be edited.,ERPNext是一個開源的基於Web的ERP系統通過網絡注技術私人有限公司向提供集成的工具，在一個小的組織管理大多數進程。有關Web註釋，或購買託管楝更多信息，請訪問
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +39,Please setup your chart of accounts before you start Accounting Entries,請設置您的會計科目表你開始會計分錄前
DocType: Purchase Invoice,Ignore Pricing Rule,忽略定價規則
sites/assets/js/list.min.js +23,Cancelled,註銷
DocType: Employee Education,Graduate,畢業生
DocType: Leave Block List,Block Days,天座
DocType: Journal Entry,Excise Entry,海關入境
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的方式。地址和公司聯繫。"
DocType: Attendance,Leave Type,休假類型
apps/erpnext/erpnext/controllers/stock_controller.py +171,Expense / Difference account ({0}) must be a 'Profit or Loss' account,費用/差異帳戶（{0}）必須是一個'溢利或虧損的賬戶
DocType: Account,Accounts User,用戶帳戶
DocType: Purchase Invoice,"Check if recurring invoice, uncheck to stop recurring or put proper End Date",檢查經常性發票，取消，停止經常性或將適當的結束日期
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +18,Attendance for employee {0} is already marked,員工{0}的考勤已標記
DocType: Packing Slip,If more than one package of the same type (for print),如果不止一個相同類型的包裹（用於打印）
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +38,Maximum {0} rows allowed,最多允許{0}列
DocType: C-Form Invoice Detail,Net Total,總淨值
DocType: Bin,FCFS Rate,FCFS率
apps/erpnext/erpnext/accounts/page/pos/pos.js +15,Billing (Sales Invoice),計費（銷售發票）
DocType: Payment Reconciliation Invoice,Outstanding Amount,未償還的金額
DocType: Project Task,Working,工作的
DocType: Stock Ledger Entry,Stock Queue (FIFO),庫存序列（先進先出）
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +13,Please select Time Logs.,請選擇時間記錄。
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +43,{0} does not belong to Company {1},{0}不屬於公司{1}
,Requested Qty,要求數量
DocType: BOM Item,Scrap %,廢鋼％
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +38,"Charges will be distributed proportionately based on item qty or amount, as per your selection",費用將被分配比例根據項目數量或金額，按您的選擇
DocType: Maintenance Visit,Purposes,用途
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +67,"Operation {0} longer than any available working hours in workstation {1}, break down the operation into multiple operations",操作{0}比任何可用的工作時間更長工作站{1}，分解成運行多個操作
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +133,Electrochemical machining,電化學加工
,Requested,要求
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +62,No Remarks,暫無產品說明
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice_list.js +11,Overdue,過期的
DocType: Account,Stock Received But Not Billed,庫存接收，但不付款
DocType: Salary Slip,Gross Pay + Arrear Amount +Encashment Amount - Total Deduction,工資總額+欠費​​金額​​+兌現金額 - 扣除項目金額
DocType: Monthly Distribution,Distribution Name,分配名稱
DocType: Features Setup,Sales and Purchase,買賣
DocType: Pricing Rule,Price / Discount,價格/折扣
DocType: Purchase Order Item,Material Request No,材料需求編號
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +201,Quality Inspection required for Item {0},項目{0}需要品質檢驗
DocType: Quotation,Rate at which customer's currency is converted to company's base currency,客戶貨幣被換算成公司基礎貨幣的匯率
DocType: Purchase Invoice,Discount Amount (Company Currency),優惠金額（公司貨幣）
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +105,{0} has been successfully unsubscribed from this list.,{0}已經從這個名單退訂成功！
DocType: Purchase Invoice Item,Net Rate (Company Currency),淨利率（公司貨幣）
apps/erpnext/erpnext/config/crm.py +71,Manage Territory Tree.,管理領地樹。
DocType: Payment Reconciliation Payment,Sales Invoice,銷售發票
DocType: Journal Entry Account,Party Balance,黨平衡
DocType: Sales Invoice Item,Time Log Batch,時間日誌批
apps/erpnext/erpnext/controllers/taxes_and_totals.py +344,Please select Apply Discount On,請選擇適用的折扣
DocType: Company,Default Receivable Account,預設應收帳款
DocType: Salary Manager,Create Bank Entry for the total salary paid for the above selected criteria,對支付上述選擇條件的薪資總額新增銀行分錄
DocType: Item,Item will be saved by this name in the data base.,項目將以此名稱在資料庫中保存。
DocType: Stock Entry,Material Transfer for Manufacture,材料轉讓用於製造
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +18,Discount Percentage can be applied either against a Price List or for all Price List.,折扣百分比可以應用於單一價目表或所有價目表。
DocType: Purchase Invoice,Half-yearly,每半年一次
apps/erpnext/erpnext/accounts/report/financial_statements.py +16,Fiscal Year {0} not found.,會計年度{0}未找到。
DocType: Bank Reconciliation,Get Relevant Entries,獲取相關條目
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +299,Accounting Entry for Stock,會計分錄的股票
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +63,Coining,鑄幣
DocType: Sales Invoice,Sales Team1,銷售團隊1
apps/erpnext/erpnext/stock/doctype/item/item.py +408,Item {0} does not exist,項目{0}不存在
DocType: Item,"Selecting ""Yes"" will allow you to make a Production Order for this item.",選擇「是」將允許你為這個項目做一個生產訂單。
DocType: Sales Invoice,Customer Address,客戶地址
DocType: Purchase Invoice,Total,總
DocType: Backup Manager,System for managing Backups,系統管理備份
DocType: Account,Root Type,root類型
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +52,Plot,情節
DocType: Item Group,Show this slideshow at the top of the page,這顯示在幻燈片頁面頂部
DocType: BOM,Item UOM,項目計量單位
DocType: Sales Taxes and Charges,Tax Amount After Discount Amount (Company Currency),稅額後，優惠金額（公司貨幣）
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +165,Target warehouse is mandatory for row {0},目標倉庫是強制性的行{0}
DocType: Quality Inspection,Quality Inspection,品質檢驗
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +139,Extra Small,超小
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +19,Spray forming,噴射成形
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +468,Warning: Material Requested Qty is less than Minimum Order Qty,警告：材料要求的數量低於最低起訂量
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +157,Account {0} is frozen,帳戶{0}被凍結
DocType: Company,Legal Entity / Subsidiary with a separate Chart of Accounts belonging to the Organization.,法人/子公司與賬戶的獨立走勢屬於該組織。
apps/erpnext/erpnext/config/setup.py +116,Address master.,地址主人。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +28,"Food, Beverage & Tobacco",食品、飲料＆煙草
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +20,PL or BS,PL或BS
apps/erpnext/erpnext/controllers/selling_controller.py +127,Commission rate cannot be greater than 100,佣金率不能大於100
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +41,Minimum Inventory Level,最低庫存水平
DocType: Stock Entry,Subcontract,轉包
DocType: Production Planning Tool,Get Items From Sales Orders,獲取項目從銷售訂單
DocType: Production Order Operation,Actual End Time,實際結束時間
DocType: Production Planning Tool,Download Materials Required,下載所需材料
DocType: Item,Manufacturer Part Number,製造商零件編號
DocType: Production Order Operation,Estimated Time and Cost,估計時間和成本
DocType: Bin,Bin,箱子
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +49,Nosing,減噪
DocType: SMS Log,No of Sent SMS,沒有發送短信
DocType: Account,Company,公司
DocType: Account,Expense Account,費用帳戶
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +48,Software,軟件
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +146,Colour,顏色
DocType: Maintenance Visit,Scheduled,預定
DocType: Sales Partner,Select Monthly Distribution to unevenly distribute targets across months.,選擇按月分佈橫跨幾個月不均勻分佈的目標。
DocType: Purchase Invoice Item,Valuation Rate,估值率
DocType: Address,Check to make Shipping Address,勾選成為送貨地址
apps/erpnext/erpnext/stock/get_item_details.py +253,Price List Currency not selected,尚未選擇價格表貨幣
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +63,Item Row {0}: Purchase Receipt {1} does not exist in above 'Purchase Receipts' table,項目行{0}：採購入庫{1}不在上述“外購入庫單”表中存在
DocType: Pricing Rule,Applicability,適用性
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +135,Employee {0} has already applied for {1} between {2} and {3},員工{0}已經申請了{1}的{2}和{3}
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Project Start Date,專案開始日期
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +8,Until,直到
DocType: Rename Tool,Rename Log,重命名日誌
DocType: Installation Note Item,Against Document No,對文件編號
apps/erpnext/erpnext/config/selling.py +93,Manage Sales Partners.,管理銷售合作夥伴。
DocType: Quality Inspection,Inspection Type,檢驗類型
apps/erpnext/erpnext/controllers/recurring_document.py +160,Please select {0},請選擇{0}
DocType: C-Form,C-Form No,C-表格編號
DocType: BOM,Exploded_items,Exploded_items
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +90,Researcher,研究員
apps/frappe/frappe/custom/doctype/customize_form/customize_form.js +87,Update,更新
apps/erpnext/erpnext/crm/doctype/newsletter/newsletter.py +75,Please save the Newsletter before sending,請在發送之前保存信件
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +23,Name or Email is mandatory,姓名或電子郵件是強制性
apps/erpnext/erpnext/config/stock.py +74,Incoming quality inspection.,來料質量檢驗。
DocType: Employee,Exit,出口
apps/erpnext/erpnext/accounts/doctype/account/account.py +108,Root Type is mandatory,root類型是強制性的
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +292,Serial No {0} created,序列號{0}創建
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +124,Vibratory finishing,震盪整理
DocType: Item,"For the convenience of customers, these codes can be used in print formats like Invoices and Delivery Notes",為方便客戶，這些代碼可以在打印格式，如發票和送貨單使用
DocType: Journal Entry Account,Against Purchase Order,對採購訂單
DocType: Employee,You can enter any date manually,您可以手動輸入任何日期
DocType: Sales Invoice,Advertisement,廣告
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +160,Probationary Period,試用期
DocType: Customer Group,Only leaf nodes are allowed in transaction,只有葉節點中允許交易
DocType: Expense Claim,Expense Approver,費用審批
DocType: Purchase Receipt Item Supplied,Purchase Receipt Item Supplied,採購入庫項目供應商
sites/assets/js/erpnext.min.js +43,Pay,付
apps/erpnext/erpnext/projects/report/daily_time_log_summary/daily_time_log_summary.py +17,To Datetime,以日期時間
DocType: SMS Settings,SMS Gateway URL,短信閘道的URL
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +136,Grinding,磨碎
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +33,Shrink wrapping,收縮包裝
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +52,Supplier > Supplier Type,供應商>供應商類型
apps/erpnext/erpnext/hr/doctype/employee/employee.py +123,Please enter relieving date.,請輸入解除日期。
apps/erpnext/erpnext/controllers/trends.py +137,Amt,AMT
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +237,Serial No {0} status must be 'Available' to Deliver,序列號{0}的狀態必須為「有」才可交付
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +52,Only Leave Applications with status 'Approved' can be submitted,只允許提交狀態為「已批准」的休假申請
apps/erpnext/erpnext/utilities/doctype/address/address.py +21,Address Title is mandatory.,地址標題是強制性的。
DocType: Opportunity,Enter name of campaign if source of enquiry is campaign,輸入活動的名稱，如果查詢來源是運動
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +37,Newspaper Publishers,報紙出版商
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +31,Select Fiscal Year,選擇財政年度
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +87,Smelting,熔煉
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +40,You are the Leave Approver for this record. Please Update the 'Status' and Save,您是第休假審批此記錄。請更新“狀態”並保存
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +43,Reorder Level,重新排序級別
DocType: Attendance,Attendance Date,考勤日期
DocType: Salary Structure,Salary breakup based on Earning and Deduction.,工資分手基於盈利和演繹。
apps/erpnext/erpnext/accounts/doctype/account/account.py +77,Account with child nodes cannot be converted to ledger,賬戶與子節點不能轉換到總賬
DocType: Address,Preferred Shipping Address,偏好的送貨地址
DocType: Purchase Receipt Item,Accepted Warehouse,收料倉庫
DocType: Bank Reconciliation Detail,Posting Date,發布日期
DocType: Item,Valuation Method,估值方法
DocType: Sales Invoice,Sales Team,銷售團隊
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +76,Duplicate entry,重複的條目
DocType: Serial No,Under Warranty,在保修期
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +425,[Error],[錯誤]
DocType: Sales Order,In Words will be visible once you save the Sales Order.,在詞將是可見的，一旦你保存銷售訂單。
,Employee Birthday,員工生日
DocType: GL Entry,Debit Amt,借記額
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +54,Venture Capital,創業投資
DocType: UOM,Must be Whole Number,必須是整數
DocType: Leave Control Panel,New Leaves Allocated (In Days),新的排假（天）
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +51,Serial No {0} does not exist,序列號{0}不存在
DocType: Pricing Rule,Discount Percentage,折扣百分比
DocType: Payment Reconciliation Invoice,Invoice Number,發票號碼
apps/erpnext/erpnext/shopping_cart/utils.py +44,Orders,訂單
DocType: Leave Control Panel,Employee Type,員工類型
DocType: Employee Leave Approver,Leave Approver,休假審批人
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +69,Swaging,模鍛
DocType: Expense Claim,"A user with ""Expense Approver"" role",與“費用審批人”角色的用戶
,Issued Items Against Production Order,發出對項目生產訂單
DocType: Pricing Rule,Purchase Manager,採購經理
DocType: Payment Tool,Payment Tool,支付工具
DocType: Target Detail,Target Detail,目標詳細信息
DocType: Sales Order,% of materials billed against this Sales Order,針對這張銷售訂單的已出帳物料的百分比(%)
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +50,Period Closing Entry,期末進入
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +36,Cost Center with existing transactions can not be converted to group,與現有的交易成本中心，不能轉化為組
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +90,Depreciation,折舊
apps/erpnext/erpnext/stock/report/supplier_wise_sales_analytics/supplier_wise_sales_analytics.py +49,Supplier(s),供應商（S）
DocType: Email Digest,Payments received during the digest period,在消化期間收到付款
DocType: Customer,Credit Limit,信用額度
DocType: Features Setup,To enable <b>Point of Sale</b> features,為了使<b>銷售點</b>功能
DocType: Purchase Receipt,LR Date,LR日期
apps/erpnext/erpnext/accounts/page/pos/pos_page.html +4,Select type of transaction,交易的選擇類型
DocType: GL Entry,Voucher No,無憑證
DocType: Leave Allocation,Leave Allocation,排假
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +398,'Update Stock' for Sales Invoice {0} must be set,銷貨發票的'更新庫存'{0}必須設定
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +402,Material Requests {0} created,{0}材料需求創建
apps/erpnext/erpnext/config/selling.py +117,Template of terms or contract.,模板條款或合同。
DocType: Employee,Feedback,反饋
apps/erpnext/erpnext/accounts/party.py +192,Note: Due / Reference Date exceeds allowed customer credit days by {0} day(s),注：由於/參考日期由{0}天超過了允許客戶信用天（S）
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +107,Abrasive jet machining,磨料噴射加工
DocType: Stock Settings,Freeze Stock Entries,凍結庫存項目
DocType: Website Settings,Website Settings,網站設置
DocType: Activity Cost,Billing Rate,結算利率
,Qty to Deliver,數量交付
DocType: Monthly Distribution Percentage,Month,月
,Stock Analytics,庫存分析
DocType: Installation Note Item,Against Document Detail No,對文件詳細編號
DocType: Quality Inspection,Outgoing,發送
DocType: Material Request,Requested For,要求
DocType: Quotation Item,Against Doctype,針對文檔類型
DocType: Delivery Note,Track this Delivery Note against any Project,跟踪此送貨單反對任何項目
apps/erpnext/erpnext/accounts/doctype/account/account.py +141,Root account can not be deleted,root帳號不能被刪除
DocType: GL Entry,Credit Amt,信用額
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +72,Show Stock Entries,顯示Stock條目
DocType: Production Order,Work-in-Progress Warehouse,工作在建倉庫
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +273,Reference #{0} dated {1},參考＃ {0}於{1}
DocType: Pricing Rule,Item Code,產品編號
DocType: Supplier,Material Manager,材料經理
DocType: Production Planning Tool,Create Production Orders,創建生產訂單
DocType: Time Log,Costing Rate (per hour),成本率（每小時）
DocType: Serial No,Warranty / AMC Details,保修/ AMC詳情
DocType: Journal Entry,User Remark,用戶備註
apps/erpnext/erpnext/config/accounts.py +117,Point-of-Sale Setting,銷售點的設置
DocType: Lead,Market Segment,市場分類
DocType: Communication,Phone,電話
DocType: Purchase Invoice,Supplier (Payable) Account,供應商（應付）帳
DocType: Employee Internal Work History,Employee Internal Work History,員工內部工作經歷
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +192,Closing (Dr),關閉（Dr）
DocType: Contact,Passive,被動
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +242,Serial No {0} not in stock,序列號{0}無貨
apps/erpnext/erpnext/config/selling.py +122,Tax template for selling transactions.,稅務模板賣出的交易。
DocType: Sales Invoice,Write Off Outstanding Amount,核銷額（億元）
DocType: Features Setup,"Check if you need automatic recurring invoices. After submitting any sales invoice, Recurring section will be visible.",檢查是否需要自動週期性發票。提交任何銷售發票後，經常性部分可見。
DocType: Account,Accounts Manager,帳戶管理器
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +36,Time Log {0} must be 'Submitted',時間日誌{0}必須是'提交'
DocType: Stock Settings,Default Stock UOM,默認的庫存計量單位
DocType: Production Planning Tool,Create Material Requests,創建材料要求
DocType: Employee Education,School/University,學校/大學
DocType: Sales Invoice Item,Available Qty at Warehouse,有貨數量在倉庫
,Billed Amount,賬單金額
DocType: Bank Reconciliation,Bank Reconciliation,銀行對帳
DocType: Purchase Invoice,Total Amount To Pay,支付總計
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +174,Material Request {0} is cancelled or stopped,材料需求{0}被取消或停止
DocType: Event,Groups,組
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.js +85,Group by Account,以帳戶分群組
DocType: Sales Order,Fully Delivered,完全交付
DocType: Lead,Lower Income,較低的收入
DocType: Period Closing Voucher,"The account head under Liability, in which Profit/Loss will be booked",根據責任賬號頭，其中利潤/虧損將被黃牌警告
DocType: Payment Tool,Against Vouchers,對優惠券
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +23,Quick Help,快速幫助
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +184,Source and target warehouse cannot be same for row {0},列{0}的來源和目標倉庫不可相同
DocType: Features Setup,Sales Extras,額外銷售
apps/erpnext/erpnext/accounts/utils.py +311,{0} budget for Account {1} against Cost Center {2} will exceed by {3},{0}預算帳戶{1}對成本中心{2}將超過{3}
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +127,Purchase Order number required for Item {0},所需物品{0}的採購訂單號
DocType: Leave Allocation,Carry Forwarded Leaves,進行轉發葉
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +18,'From Date' must be after 'To Date',“起始日期”必須經過'終止日期'
,Stock Projected Qty,此貨幣被禁用。允許使用的交易
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +143,Customer {0} does not belong to project {1},客戶{0}不屬於項目{1}
DocType: Warranty Claim,From Company,從公司
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +95,Value or Qty,價值或數量
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +575,Minute,分鐘
DocType: Purchase Invoice,Purchase Taxes and Charges,購置稅和費
DocType: Backup Manager,Upload Backups to Dropbox,上傳備份到 Dropbox
,Qty to Receive,接收數量
DocType: Leave Block List,Leave Block List Allowed,准許的休假區塊清單
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +104,Conversion factor cannot be in fractions,轉換係數不能在分數
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +356,You will use it to Login,你會用它來登錄
DocType: Sales Partner,Retailer,零售商
apps/erpnext/erpnext/buying/page/purchase_analytics/purchase_analytics.js +128,All Supplier Types,所有供應商類型
apps/erpnext/erpnext/stock/doctype/item/item.py +35,Item Code is mandatory because Item is not automatically numbered,產品編號是強制性的，因為項目沒有自動編號
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +61,Quotation {0} not of type {1},報價{0}非為{1}類型
DocType: Maintenance Schedule Item,Maintenance Schedule Item,維護計劃項目
DocType: Sales Order,%  Delivered,％交付
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +177,Bank Overdraft Account,銀行透支戶口
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +15,Make Salary Slip,製作工資單
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +83,Unstop,Unstop
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +175,Secured Loans,抵押貸款
apps/erpnext/erpnext/utilities/doctype/rename_tool/rename_tool.py +49,Ignored:,忽略：
apps/erpnext/erpnext/shopping_cart/__init__.py +68,{0} cannot be purchased using Shopping Cart,{0}不能使用購物車購買
apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +3,Awesome Products,真棒產品
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +189,Opening Balance Equity,期初餘額權益
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +80,Cannot approve leave as you are not authorized to approve leaves on Block Dates,不能批准休假，你無權在批准休假在被標記的日期
DocType: Appraisal,Appraisal,評價
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +12,Lost-foam casting,失模鑄造
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +46,Drawing,圖紙
apps/erpnext/erpnext/hr/doctype/leave_block_list/leave_block_list.py +22,Date is repeated,日期重複
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +149,Leave approver must be one of {0},休假審批人必須是一個{0}
DocType: Hub Settings,Seller Email,賣家電子郵件
DocType: Project,Total Purchase Cost (via Purchase Invoice),總購買成本（通過採購發票）
DocType: Workstation Working Hour,Start Time,開始時間
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +183,Select Quantity,選擇數量
DocType: Sales Taxes and Charges Template,"Specify a list of Territories, for which, this Taxes Master is valid",新界指定一個列表，其中，該稅金法師是有效的
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +34,Approving Role cannot be same as role the rule is Applicable To,審批角色作為角色的規則適用於不能相同
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +41,Message Sent,發送消息
DocType: Production Plan Sales Order,SO Date,SO日期
DocType: Sales Invoice,Rate at which Price list currency is converted to customer's base currency,價目表貨幣被換算成客戶基礎貨幣的匯率
DocType: Purchase Invoice Item,Net Amount (Company Currency),淨金額（公司貨幣）
DocType: BOM Operation,Hour Rate,小時率
DocType: Stock Settings,Item Naming By,產品命名規則
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.js +650,From Quotation,從報價
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +35,Another Period Closing Entry {0} has been made after {1},另一個期末錄入{0}作出後{1}
DocType: Production Order,Material Transferred for Manufacturing,材料移送製造
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +25,Account {0} does not exists,帳戶{0}不存在
DocType: Purchase Receipt Item,Purchase Order Item No,採購訂單編號
DocType: System Settings,System Settings,系統設置
DocType: Project,Project Type,專案類型
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +16,Either target qty or target amount is mandatory.,無論是數量目標或目標量是強制性的。
apps/erpnext/erpnext/config/projects.py +38,Cost of various activities,各種活動的費用
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +93,Not allowed to update stock transactions older than {0},不允許更新比年長的股票交易{0}
DocType: Item,Inspection Required,需要檢驗
DocType: Purchase Invoice Item,PR Detail,詳細新聞稿
DocType: Sales Order,Fully Billed,完全開票
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +20,Cash In Hand,手頭現金
DocType: Packing Slip,The gross weight of the package. Usually net weight + packaging material weight. (for print),包的總重量。通常淨重+包裝材料的重量。 （用於打印）
DocType: Accounts Settings,Users with this role are allowed to set frozen accounts and create / modify accounting entries against frozen accounts,具有此角色的用戶可以設置凍結帳戶，並創建/修改對凍結賬戶的會計分錄
DocType: Serial No,Is Cancelled,被註銷
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +291,My Shipments,我的出貨量
DocType: Journal Entry,Bill Date,帳單日期
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +43,"Even if there are multiple Pricing Rules with highest priority, then following internal priorities are applied:",即使有更高優先級的多個定價規則，然後按照內部優先級應用：
DocType: Supplier,Supplier Details,供應商詳細信息
DocType: Communication,Recipients,受助人
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +145,Screwing,擰
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +95,Knurling,滾花
DocType: Expense Claim,Approval Status,審批狀態
DocType: Hub Settings,Publish Items to Hub,發布項目到集線器
apps/erpnext/erpnext/accounts/doctype/shipping_rule/shipping_rule.py +38,From value must be less than to value in row {0},來源值必須小於列{0}的值
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +128,Wire Transfer,電匯
apps/erpnext/erpnext/accounts/report/bank_clearance_summary/bank_clearance_summary.py +25,Please select Bank Account,請選擇銀行帳戶
DocType: Newsletter,Create and Send Newsletters,創建和發送簡訊
sites/assets/js/report.min.js +107,From Date must be before To Date,起始日期必須早於終點日期
DocType: Sales Order,Recurring Order,經常訂購
DocType: Company,Default Income Account,默認情況下收入賬戶
apps/erpnext/erpnext/selling/page/sales_analytics/sales_analytics.js +33,Customer Group / Customer,集團客戶／客戶
DocType: Item Group,Check this if you want to show in website,勾選本項以顯示在網頁上
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +189,Welcome to ERPNext,歡迎來到ERPNext
DocType: Payment Reconciliation Payment,Voucher Detail Number,憑單詳細人數
DocType: Lead,From Customer,從客戶
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +37,Calls,電話
DocType: Project,Total Costing Amount (via Time Logs),總成本核算金額（通過時間日誌）
DocType: Purchase Order Item Supplied,Stock UOM,庫存計量單位
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +192,Purchase Order {0} is not submitted,採購訂單{0}未提交
apps/erpnext/erpnext/stock/doctype/item/item.py +161,{0} {1} is entered more than once in Item Variants table,{0} {1}多次輸入項變異表
,Projected,預計
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +232,Serial No {0} does not belong to Warehouse {1},序列號{0}不屬於倉庫{1}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +105,Note: Reference Date exceeds allowed credit days by {0} days for {1} {2},注：參考日期由{0}幾天超過允許的信用天{1} {2}
apps/erpnext/erpnext/controllers/status_updater.py +96,Note: System will not check over-delivery and over-booking for Item {0} as quantity or amount is 0,注：系統將不檢查過交付和超額預訂的項目{0}的數量或金額為0
DocType: Notification Control,Quotation Message,報價信息
DocType: Issue,Opening Date,開幕日期
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +23,POS Setting {0} already created for user: {1} and company {2},POS機設置{0}已創建：{2}公司{1}
DocType: Journal Entry,Remark,備註
DocType: Purchase Receipt Item,Rate and Amount,率及金額
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +94,Boring,無聊
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +680,From Sales Order,從銷售訂單
DocType: Blog Category,Parent Website Route,父網站路由
DocType: Sales Order,Not Billed,不發單
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +107,Both Warehouse must belong to same Company,這兩個倉庫必須屬於同一個公司
sites/assets/js/erpnext.min.js +20,No contacts added yet.,添加暫時還沒有接觸。
apps/frappe/frappe/workflow/doctype/workflow/workflow_list.js +7,Not active,不活躍
apps/erpnext/erpnext/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +43,Against Invoice Posting Date,對發票發布日期
DocType: Purchase Receipt Item,Landed Cost Voucher Amount,到岸成本憑證金額
DocType: Time Log,Batched for Billing,批量計費
apps/erpnext/erpnext/config/accounts.py +23,Bills raised by Suppliers.,由供應商提出的帳單。
DocType: POS Setting,Write Off Account,核銷帳戶
DocType: Purchase Invoice,Discount Amount,折扣金額
DocType: Item,Warranty Period (in days),保修期限（天數）
DocType: Email Digest,Expenses booked for the digest period,預訂了消化期間費用
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +500,e.g. VAT,例如增值稅
DocType: Journal Entry Account,Journal Entry Account,日記帳分錄帳號
DocType: Shopping Cart Settings,Quotation Series,報價系列
apps/erpnext/erpnext/setup/doctype/item_group/item_group.py +51,"An item exists with same name ({0}), please change the item group name or rename the item",具有相同名稱的項目存在（ {0} ） ，請更改項目組名或重命名的項目
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +81,Hot metal gas forming,鐵水形成氣
DocType: Sales Order Item,Sales Order Date,銷售訂單日期
DocType: Sales Invoice Item,Delivered Qty,交付數量
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +63,Warehouse {0}: Company is mandatory,倉庫{0}：公司是強制性的
DocType: Item,Percentage variation in quantity to be allowed while receiving or delivering this item.,同時接收或傳送資料被允許在數量上的變化百分比。
DocType: Shopping Cart Taxes and Charges Master,Shopping Cart Taxes and Charges Master,購物車稅費碩士
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +36,"Go to the appropriate group (usually Source of Funds > Current Liabilities > Taxes and Duties and create a new Account (by clicking on Add Child) of type ""Tax"" and do mention the Tax rate.",轉到相應的群組（通常基金>流動負債>稅和關稅的來源，並新增一個新帳戶（通過點擊輸入“稅”添加兒童），做提稅率。
,Payment Period Based On Invoice Date,基於發票日的付款期
apps/erpnext/erpnext/shopping_cart/doctype/shopping_cart_settings/shopping_cart_settings.py +113,Missing Currency Exchange Rates for {0},缺少貨幣匯率{0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +134,Laser cutting,激光切割
DocType: Event,Monday,星期一
DocType: Journal Entry,Stock Entry,庫存輸入
DocType: Account,Payable,支付
DocType: Salary Slip,Arrear Amount,欠款金額
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +57,New Customers,新客戶
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +68,Gross Profit %,毛利％
DocType: Appraisal Goal,Weightage (%),權重（％）
DocType: Bank Reconciliation Detail,Clearance Date,清拆日期
DocType: Newsletter,Newsletter List,通訊名單
DocType: Salary Manager,Check if you want to send salary slip in mail to each employee while submitting salary slip,當提交工資單時確認是否要發送工資單郵件給每個員工。
DocType: Lead,Address Desc,地址倒序
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +33,Atleast one of the Selling or Buying must be selected,至少需選擇銷售或購買
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +230,"Difference Account must be a 'Liability' type account, since this Stock Reconciliation is an Opening Entry",差的帳戶必須是'責任'類型的帳戶，因為這個股票和解是一個開放報名
apps/erpnext/erpnext/stock/doctype/item/item.js +215,"Variants can not be created manually, add item attributes in the template item",變體不能手動創建，在模板添加物品屬性
apps/erpnext/erpnext/config/manufacturing.py +34,Where manufacturing operations are carried.,其中，生產操作進行。
DocType: Page,All,所有
DocType: Stock Entry Detail,Source Warehouse,來源倉庫
DocType: Installation Note,Installation Date,安裝日期
DocType: Employee,Confirmation Date,確認日期
DocType: C-Form,Total Invoiced Amount,發票總金額
DocType: Communication,Sales User,銷售用戶
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +46,Min Qty can not be greater than Max Qty,最小數量不能大於最大數量
apps/frappe/frappe/core/page/permission_manager/permission_manager.js +421,Set,集合
DocType: Item,Warehouse-wise Reorder Levels,倉庫明智的重新排序水平
DocType: Lead,Lead Owner,鉛所有者
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +241,Warehouse is required,倉庫是必需的
DocType: Employee,Marital Status,婚姻狀況
DocType: Stock Settings,Auto Material Request,汽車材料要求
DocType: Time Log,Will be updated when billed.,計費時將被更新。
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +25,Current BOM and New BOM can not be same,當前BOM和新BOM不能相同
apps/erpnext/erpnext/hr/doctype/employee/employee.py +107,Date Of Retirement must be greater than Date of Joining,日期退休必須大於加入的日期
DocType: Sales Invoice,Against Income Account,對收入賬戶
apps/erpnext/erpnext/controllers/website_list_for_contact.py +52,{0}% Delivered,{0}％交付
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +82,Item {0}: Ordered qty {1} cannot be less than minimum order qty {2} (defined in Item).,項目{0}：有序數量{1}不能低於最低訂貨量{2}（項中定義）。
DocType: Monthly Distribution Percentage,Monthly Distribution Percentage,每月分配比例
DocType: Territory,Territory Targets,境內目標
DocType: Delivery Note,Transporter Info,轉運信息
DocType: Purchase Order Item Supplied,Purchase Order Item Supplied,採購訂單項目供應商
apps/erpnext/erpnext/config/setup.py +27,Letter Heads for print templates.,信頭的打印模板。
apps/erpnext/erpnext/config/setup.py +32,Titles for print templates e.g. Proforma Invoice.,標題打印模板例如形式發票。
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +140,Valuation type charges can not marked as Inclusive,估值類型罪名不能標記為包容性
DocType: POS Setting,Update Stock,庫存更新
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +127,Superfinishing,超精研
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +100,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.,不同計量單位的項目會導致不正確的（總）淨重值。確保每個項目的淨重是在同一個計量單位。
apps/erpnext/erpnext/stock/report/item_prices/item_prices.py +39,BOM Rate,BOM率
DocType: Shopping Cart Settings,"<a href=""#Sales Browser/Territory"">Add / Edit</a>","<a href=""#Sales Browser/Territory"">添加/編輯</a>"
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +94,Please pull items from Delivery Note,請送貨單拉項目
apps/erpnext/erpnext/accounts/utils.py +235,Journal Entries {0} are un-linked,日記條目{0}都是非聯
DocType: Purchase Invoice,Terms,條款
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +235,Create New,創建新
DocType: Buying Settings,Purchase Order Required,購貨訂單要求
,Item-wise Sales History,項目明智的銷售歷史
DocType: Expense Claim,Total Sanctioned Amount,總被制裁金額
,Purchase Analytics,採購分析
DocType: Sales Invoice Item,Delivery Note Item,送貨單項目
DocType: Expense Claim,Task,任務
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +56,Shaving,刮
DocType: Purchase Taxes and Charges,Reference Row #,參考列#
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +67,Batch number is mandatory for Item {0},批號是強制性的項目{0}
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.js +14,This is a root sales person and cannot be edited.,您可以通過選擇備份頻率啟動和\
,Stock Ledger,庫存總帳
DocType: Salary Slip Deduction,Salary Slip Deduction,工資單上扣除
apps/erpnext/erpnext/stock/doctype/item/item.py +368,"To set reorder level, item must be a Purchase Item",要設置訂貨水平，項目必須購買項目
apps/frappe/frappe/desk/doctype/note/note_list.js +3,Notes,筆記
DocType: Opportunity,From,從
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +192,Select a group node first.,首先選擇一組節點。
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +88,Purpose must be one of {0},目的必須是一個{0}
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.js +101,Fill the form and save it,填寫表格，並將其保存
DocType: Production Planning Tool,Download a report containing all raw materials with their latest inventory status,下載一個包含所有原料一份報告，他們最新的庫存狀態
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +93,Facing,面對
DocType: Leave Application,Leave Balance Before Application,離開平衡應用前
DocType: SMS Center,Send SMS,發送短信
DocType: Company,Default Letter Head,默認信頭
DocType: Time Log,Billable,計費
DocType: Authorization Rule,This will be used for setting rule in HR module,這將用於在人力資源模塊的設置規則
DocType: Account,Rate at which this tax is applied,此稅適用的匯率
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +34,Reorder Qty,再訂購數量
DocType: Company,Stock Adjustment Account,庫存調整賬戶
DocType: Sales Invoice,Write Off,抹殺
DocType: Time Log,Operation ID,操作ID
DocType: Employee,"System User (login) ID. If set, it will become default for all HR forms.",系統用戶（登錄）的標識。如果設置，這將成為默認的所有人力資源的形式。
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +16,{0}: From {1},{0}：從{1}
DocType: Task,depends_on,depends_on
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +81,Opportunity Lost,失去的機會
DocType: Features Setup,"Discount Fields will be available in Purchase Order, Purchase Receipt, Purchase Invoice",折扣欄位出現在採購訂單，採購入庫單，採購發票
DocType: Report,Report Type,報告類型
apps/frappe/frappe/core/doctype/user/user.js +136,Loading,載入中
DocType: BOM Replace Tool,BOM Replace Tool,BOM替換工具
apps/erpnext/erpnext/config/setup.py +37,Country wise default Address Templates,依據國家別啟發式的默認地址模板
apps/erpnext/erpnext/accounts/party.py +196,Due / Reference Date cannot be after {0},由於/參考日期不能後{0}
DocType: Features Setup,If you involve in manufacturing activity. Enables Item 'Is Manufactured',如果您涉及製造活動。啟動項目「製造的」
DocType: Sales Invoice,Rounded Total,總圓角
DocType: Sales BOM,List items that form the package.,形成包列表項。
apps/erpnext/erpnext/accounts/doctype/monthly_distribution/monthly_distribution.py +26,Percentage Allocation should be equal to 100%,百分比分配總和應該等於100%
DocType: Serial No,Out of AMC,出資產管理公司
DocType: Purchase Order Item,Material Request Detail No,材料要求詳細說明編號
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +96,Hard turning,硬車削
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.js +33,Make Maintenance Visit,使維護訪問
apps/erpnext/erpnext/selling/doctype/customer/customer.py +165,Please contact to the user who have Sales Master Manager {0} role,請聯繫，誰擁有碩士學位的銷售經理{0}角色的用戶
DocType: Company,Default Cash Account,默認的現金賬戶
apps/erpnext/erpnext/config/setup.py +91,Company (not Customer or Supplier) master.,公司（不是客戶或供應商）的主人。
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +68,Please enter 'Expected Delivery Date',請輸入「預定交付日」
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +492,"List your tax heads (e.g. VAT, Excise; they should have unique names) and their standard rates. This will create a standard template, which you can edit and add more later.",列出你的頭稅（如增值稅，消費稅，他們應該有唯一的名稱）及其標準費率。
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +168,Delivery Notes {0} must be cancelled before cancelling this Sales Order,送貨單{0}必須先取消才能取消銷貨訂單
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +323,Paid amount + Write Off Amount can not be greater than Grand Total,支付的金額+寫的抵銷金額不能大於總計
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +69,{0} is not a valid Batch Number for Item {1},{0}不是對項目的有效批號{1}
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +109,Note: There is not enough leave balance for Leave Type {0},注：沒有足夠的休假餘額請假類型{0}
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +9,"Note: If payment is not made against any reference, make Journal Entry manually.",注：如果付款不反對任何參考製作，手工製作日記條目。
DocType: Item,Supplier Items,供應商項目
apps/erpnext/erpnext/stock/doctype/item/item.py +165,Please enter atleast one attribute row in Item Variants table,請輸入用於至少一個屬性列項異體表
DocType: Opportunity,Opportunity Type,機會型
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +42,New Company,新公司
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +50,Cost Center is required for 'Profit and Loss' account {0},成本中心是必需的“損益”賬戶{0}
apps/erpnext/erpnext/setup/doctype/company/delete_company_transactions.py +16,Transactions can only be deleted by the creator of the Company,交易只能由公司的創建者被刪除
apps/erpnext/erpnext/accounts/general_ledger.py +21,Incorrect number of General Ledger Entries found. You might have selected a wrong Account in the transaction.,不正確的數字總帳條目中找到。你可能會在交易中選擇了錯誤的帳戶。
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +31,To create a Bank Account,要創建一個銀行帳戶
DocType: Hub Settings,Publish Availability,發布房源
apps/erpnext/erpnext/hr/doctype/employee/employee.py +101,Date of Birth cannot be greater than today.,出生日期不能大於今天。
,Stock Ageing,股票老齡化
DocType: Purchase Receipt,Automatically updated from BOM table,從BOM表自動更新
apps/erpnext/erpnext/controllers/accounts_controller.py +170,{0} '{1}' is disabled,{0}“{1}”被禁用
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity_list.js +13,Set as Open,設置為打開
DocType: Notification Control,Send automatic emails to Contacts on Submitting transactions.,發送電子郵件的自動對提交的交易聯繫。
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +282,"Row {0}: Qty not avalable in warehouse {1} on {2} {3}.
					Available Qty: {4}, Transfer Qty: {5}","行{0}：數量不是在倉庫avalable {1} {2} {3}。
可用數量：{4}，轉讓數量：{5}"
DocType: Backup Manager,Sync with Dropbox,同步與Dropbox
DocType: Event,Sunday,星期天
DocType: Sales Team,Contribution (%),貢獻（％）
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +412,Note: Payment Entry will not be created since 'Cash or Bank Account' was not specified,注：付款項將不會被創建因為“現金或銀行帳戶”未指定
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +166,Responsibilities,職責
apps/erpnext/erpnext/stock/doctype/item/item_list.js +9,Template,模板
DocType: Sales Person,Sales Person Name,銷售人員的姓名
apps/erpnext/erpnext/accounts/doctype/c_form/c_form.py +54,Please enter atleast 1 invoice in the table,請在表中輸入至少一筆發票
DocType: Pricing Rule,Item Group,項目組
DocType: Task,Actual Start Date (via Time Logs),實際開始日期（通過時間日誌）
DocType: Stock Reconciliation Item,Before reconciliation,前和解
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.py +12,To {0},{0}
DocType: Purchase Invoice,Taxes and Charges Added (Company Currency),稅收和收費上架（公司貨幣）
apps/erpnext/erpnext/stock/doctype/item/item.py +334,Item Tax Row {0} must have account of type Tax or Income or Expense or Chargeable,商品稅行{0}必須有帳戶類型稅或收入或支出或課稅的
DocType: Sales Order,Partly Billed,天色帳單
DocType: Item,Default BOM,默認的BOM
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +78,Decambering,Decambering
apps/erpnext/erpnext/setup/doctype/company/company.js +17,Please re-type company name to confirm,請確認重新輸入公司名稱
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +70,Total Outstanding Amt,總街貨量金額
DocType: Time Log Batch,Total Hours,總時數
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +266,Total Debit must be equal to Total Credit. The difference is {0},總借記必須等於總積分。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +10,Automotive,汽車
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +40,Leaves for type {0} already allocated for Employee {1} for Fiscal Year {0},{0}財務年度{1}員工的休假別{0}已排定
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +15,Item is required,項目是必需的
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +24,Metal injection molding,金屬注射成型
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +697,From Delivery Note,從送貨單
DocType: Time Log,From Time,從時間
DocType: Notification Control,Custom Message,自定義消息
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +32,Investment Banking,投資銀行業務
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +259,"Select your Country, Time Zone and Currency",選擇國家時區和貨幣
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +319,Cash or Bank Account is mandatory for making payment entry,現金或銀行帳戶是強制性的付款項
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +214,{0} {1} status is Unstopped,{0} {1}狀態為開通
DocType: Purchase Invoice,Price List Exchange Rate,價目表匯率
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +90,Pickling,酸洗
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +17,Sand casting,砂型鑄造
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +116,Electroplating,電鍍
DocType: Purchase Invoice Item,Rate,率
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +57,Intern,實習生
DocType: Newsletter,A Lead with this email id should exist,與此電子郵件id一個鉛應該存在
DocType: Stock Entry,From BOM,從BOM
DocType: Time Log,Billing Rate (per hour),開票率（每小時）
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +34,Basic,基本的
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +86,Stock transactions before {0} are frozen,{0}前的庫存交易被凍結
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +226,Please click on 'Generate Schedule',請點擊“生成表”
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.js +78,To Date should be same as From Date for Half Day leave,日期應該是一樣的起始日期為半天假
apps/erpnext/erpnext/config/stock.py +110,"e.g. Kg, Unit, Nos, m",如公斤，單位，NOS，M
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +115,Reference No is mandatory if you entered Reference Date,如果你輸入的參考日期，參考編號是強制性的
apps/erpnext/erpnext/hr/doctype/employee/employee.py +104,Date of Joining must be greater than Date of Birth,加入日期必須大於出生日期
DocType: Salary Structure,Salary Structure,薪酬結構
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +237,"Multiple Price Rule exists with same criteria, please resolve \
			conflict by assigning priority. Price Rules: {0}","多次價格規則存在著同樣的標準，請解決衝突\
通過分配優先級。價格規則：{0}"
DocType: Account,Bank,銀行
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +8,Airline,航空公司
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +511,Issue Material,發行材料
DocType: Material Request Item,For Warehouse,對於倉​​庫
DocType: Employee,Offer Date,到職日期
DocType: Hub Settings,Access Token,訪問令牌
DocType: Sales Invoice Item,Serial No,序列號
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +154,Please enter Maintaince Details first,請先輸入維護細節
DocType: Item,Is Fixed Asset Item,是固定資產項目
DocType: Stock Entry,Including items for sub assemblies,包括子組件項目
DocType: Features Setup,"If you have long print formats, this feature can be used to split the page to be printed on multiple pages with all headers and footers on each page",如果你有很長的打印格式，這個功能可以被用來分割要打印多個頁面，每個頁面上的所有頁眉和頁腳的頁
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +130,Hobbing,滾齒機
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +93,All Territories,所有的領土
DocType: Party Type,Party Type Name,黨的類型名稱
DocType: Purchase Invoice,Items,項目
DocType: Fiscal Year,Year Name,今年名稱
DocType: Salary Manager,Process Payroll,處理工資
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +59,There are more holidays than working days this month.,還有比這個月工作日更多的假期。
DocType: Sales Partner,Sales Partner Name,銷售合作夥伴名稱
DocType: Purchase Order Item,Image View,圖像查看
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +112,Finishing & industrial finishing,精加工和精加工工業
DocType: Issue,Opening Time,開放時間
apps/erpnext/erpnext/stock/report/itemwise_recommended_reorder_level/itemwise_recommended_reorder_level.py +92,From and To dates required,需要起始和到達日期
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +45,Securities & Commodity Exchanges,證券及商品交易所
DocType: Shipping Rule,Calculate Based On,計算的基礎上
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +97,Drilling,鑽孔
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +27,Blow molding,吹塑
DocType: Purchase Taxes and Charges,Valuation and Total,估值與總
apps/erpnext/erpnext/stock/doctype/item/item.js +65,This Item is a Variant of {0} (Template). Attributes will be copied over from the template unless 'No Copy' is set,該項目是{0}（模板）的變體。屬性將被複製的模板，除非“不複製”設置
DocType: Account,Purchase User,購買用戶
DocType: Sales Order,Customer's Purchase Order Number,客戶的採購訂單編號
DocType: Notification Control,Customize the Notification,自定義通知
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +86,Hammering,鍛造
DocType: Web Page,Slideshow,連續播放
apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +24,Default Address Template cannot be deleted,默認地址模板不能被刪除
DocType: Sales Invoice,Shipping Rule,送貨規則
DocType: Journal Entry,Print Heading,打印標題
DocType: Quotation,Maintenance Manager,維護經理
DocType: Workflow State,Search,搜索
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +54,Total cannot be zero,總不能為零
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +14,'Days Since Last Order' must be greater than or equal to zero,“自從最後訂購日”必須大於或等於零
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +141,Brazing,銅焊
DocType: C-Form,Amended From,從修訂
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +571,Raw Material,原料
DocType: Leave Application,Follow via Email,通過電子郵件跟隨
DocType: Purchase Taxes and Charges,Tax Amount After Discount Amount,稅額折後金額
apps/erpnext/erpnext/accounts/doctype/account/account.py +146,Child account exists for this account. You can not delete this account.,此帳戶存在子帳戶。您無法刪除此帳戶。
apps/erpnext/erpnext/setup/doctype/territory/territory.py +19,Either target qty or target amount is mandatory,無論是數量目標或目標量是必需的
apps/erpnext/erpnext/stock/get_item_details.py +421,No default BOM exists for Item {0},項目{0}不存在預設的的BOM
DocType: Leave Allocation,Carry Forward,發揚
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +28,Cost Center with existing transactions can not be converted to ledger,與現有的交易成本中心，不能轉換為總賬
DocType: Department,Days for which Holidays are blocked for this department.,天的假期被封鎖這個部門。
,Produced,生產
DocType: Issue,Raised By (Email),提出（電子郵件）
DocType: Email Digest,General,一般
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +475,Attach Letterhead,附加信
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +272,Cannot deduct when category is for 'Valuation' or 'Valuation and Total',不能抵扣當類別為“估值”或“估值及總'
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +244,Serial Nos Required for Serialized Item {0},序列號為必填項序列為{0}
DocType: Journal Entry,Bank Entry,銀行進入
DocType: Authorization Rule,Applicable To (Designation),適用於（指定）
DocType: Blog Post,Blog Post,網誌文章
apps/erpnext/erpnext/templates/generators/item.html +32,Add to Cart,添加到購物車
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.js +28,Group By,集團通過
apps/erpnext/erpnext/config/accounts.py +133,Enable / disable currencies.,啟用／禁用的貨幣。
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +114,Postal Expenses,郵政費用
apps/erpnext/erpnext/controllers/trends.py +19,Total(Amt),共（AMT）
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +25,Entertainment & Leisure,娛樂休閒
DocType: Purchase Order,The date on which recurring order will be stop,上反复出現的訂單將被終止日期
DocType: Quality Inspection,Item Serial No,產品序列號
apps/erpnext/erpnext/controllers/status_updater.py +102,{0} must be reduced by {1} or you should increase overflow tolerance,{0}必須通過{1}會減少或應增加溢出寬容
apps/erpnext/erpnext/hr/report/monthly_attendance_sheet/monthly_attendance_sheet.py +56,Total Present,總現
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +575,Hour,小時
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +133,"Serialized Item {0} cannot be updated \
					using Stock Reconciliation","系列化項目{0}不能\
使用股票和解更新"
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +480,Transfer Material to Supplier,轉印材料供應商
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +30,New Serial No cannot have Warehouse. Warehouse must be set by Stock Entry or Purchase Receipt,新的序列號不能有倉庫。倉庫必須由股票輸入或外購入庫單進行設置
DocType: Lead,Lead Type,引線型
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +77,Create Quotation,創建報價
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +316,All these items have already been invoiced,所有這些項目已開具發票
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +37,Can be approved by {0},可以通過{0}的批准
DocType: Shipping Rule,Shipping Rule Conditions,送貨規則條件
DocType: BOM Replace Tool,The new BOM after replacement,更換後的新物料清單
DocType: Features Setup,Point of Sale,銷售點
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +82,Curling,冰壺
DocType: Account,Tax,稅
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +34,Row {0}: {1} is not a valid {2},行{0}：{1}不是有效的{2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +88,Refining,精製
DocType: Production Planning Tool,Production Planning Tool,生產規劃工具
DocType: Quality Inspection,Report Date,報告日期
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +129,Routing,路由
DocType: C-Form,Invoices,發票
DocType: Job Opening,Job Title,職位
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +84,{0} Recipients,{0}收件人
DocType: Features Setup,Item Groups in Details,在詳細信息產品組
apps/erpnext/erpnext/accounts/doctype/pos_setting/pos_setting.py +32,Expense Account is mandatory,費用帳戶是必需的
apps/erpnext/erpnext/accounts/page/pos/pos.js +4,Start Point-of-Sale (POS),起點的銷售終端（POS）
DocType: Item,A new variant (Item) will be created for each attribute value combination,一個新的變種（項目）會為每個屬性值組合創建
apps/erpnext/erpnext/config/support.py +28,Visit report for maintenance call.,訪問報告維修電話。
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個單位量。
DocType: Pricing Rule,Customer Group,集團客戶
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +163,Expense account is mandatory for item {0},交際費是強制性的項目{0}
DocType: Item,Website Description,網站簡介
DocType: Serial No,AMC Expiry Date,AMC到期時間
,Sales Register,銷售登記
DocType: Quotation,Quotation Lost Reason,報價遺失原因
DocType: Address,Plant,廠
apps/frappe/frappe/desk/moduleview.py +64,Setup,設置
apps/erpnext/erpnext/setup/doctype/supplier_type/supplier_type.js +5,There is nothing to edit.,對於如1美元= 100美分
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +38,Cold rolling,冷軋
DocType: Customer Group,Customer Group Name,客戶群組名稱
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +358,Please remove this Invoice {0} from C-Form {1},請刪除此發票{0}從C-表格{1}
DocType: Leave Control Panel,Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year,請選擇結轉，如果你還需要包括上一會計年度的資產負債葉本財年
DocType: GL Entry,Against Voucher Type,對憑證類型
DocType: POS Setting,POS Setting,POS機設置
DocType: Packing Slip,Get Items,找項目
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +185,Please enter Write Off Account,請輸入核銷帳戶
DocType: DocField,Image,圖像
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +220,Make Excise Invoice,使消費稅發票
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.js +628,Make Packing Slip,製作裝箱單
DocType: Communication,Other,其他
DocType: C-Form,C-Form,C-表
apps/erpnext/erpnext/projects/doctype/time_log/time_log.py +134,Operation ID not set,操作ID沒有設置
DocType: Production Order,Planned Start Date,計劃開始日期
DocType: Serial No,Creation Document Type,創建文件類型
DocType: Leave Type,Is Encash,為兌現
DocType: Purchase Invoice,Mobile No,手機號碼
DocType: Payment Tool,Make Journal Entry,使日記帳分錄
DocType: Leave Allocation,New Leaves Allocated,新的排假
apps/erpnext/erpnext/controllers/trends.py +257,Project-wise data is not available for Quotation,項目明智的數據不適用於報價
DocType: Project,Expected End Date,預計結束日期
DocType: Appraisal Template,Appraisal Template Title,評估模板標題
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +366,Commercial,商業
DocType: Cost Center,Distribution Id,分配標識
apps/erpnext/erpnext/setup/page/setup_wizard/data/sample_home_page.html +14,Awesome Services,真棒服務
apps/erpnext/erpnext/config/manufacturing.py +29,All Products or Services.,所有的產品或服務。
DocType: Purchase Invoice,Supplier Address,供應商地址
DocType: Contact Us Settings,Address Line 2,地址行2
DocType: ToDo,Reference,參考
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +58,Perforating,射孔
apps/erpnext/erpnext/stock/report/batch_wise_balance_history/batch_wise_balance_history.py +35,Out Qty,輸出數量
apps/erpnext/erpnext/config/accounts.py +118,Rules to calculate shipping amount for a sale,規則用於計算銷售運輸量
apps/erpnext/erpnext/selling/doctype/customer/customer.py +31,Series is mandatory,系列是強制性的
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +27,Financial Services,金融服務
DocType: Opportunity,Sales,銷售
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +166,Warehouse required for stock Item {0},需要現貨產品倉庫{0}
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.js +87,Cr,鉻
DocType: Customer,Default Receivable Accounts,預設應收帳款
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +101,Sawing,鋸切
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +31,Laminating,層壓
DocType: Item Reorder,Transfer,轉讓
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +567,Fetch exploded BOM (including sub-assemblies),取得爆炸BOM（包括子組件）
DocType: Authorization Rule,Applicable To (Employee),適用於（員工）
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +142,Sintering,燒結
DocType: Journal Entry,Pay To / Recd From,支付/ RECD從
DocType: Naming Series,Setup Series,設置系列
DocType: Supplier,Contact HTML,聯繫HTML
DocType: Landed Cost Voucher,Purchase Receipts,購買收據
DocType: Payment Reconciliation,Maximum Amount,最高金額
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +27,How Pricing Rule is applied?,定價規則被如何應用？
DocType: Quality Inspection,Delivery Note No,送貨單號
DocType: Company,Retail,零售
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +106,Customer {0} does not exist,客戶{0}不存在
DocType: Attendance,Absent,缺席
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +164,Crushing,破碎
DocType: Purchase Taxes and Charges Template,Purchase Taxes and Charges Template,購置稅和費模板
DocType: Upload Attendance,Download Template,下載模板
DocType: GL Entry,Remarks,備註
DocType: Purchase Order Item Supplied,Raw Material Item Code,原料產品編號
DocType: Journal Entry,Write Off Based On,核銷的基礎上
DocType: Features Setup,POS View,POS機查看
apps/erpnext/erpnext/config/stock.py +33,Installation record for a Serial No.,對於一個序列號安裝記錄
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +8,Continuous casting,連鑄
sites/assets/js/erpnext.min.js +6,Please specify a,請指定一個
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.js +490,Make Purchase Invoice,做出購買發票
DocType: Offer Letter,Awaiting Response,正在等待回應
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +79,Cold sizing,冷上漿
DocType: Salary Slip,Earning & Deduction,收入及扣除
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +70,Account {0} cannot be a Group,帳戶{0}不能為集團
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +257,Region,區域
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +208,Optional. This setting will be used to filter in various transactions.,可選。此設置將被應用於過濾各種交易進行。
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +99,Negative Valuation Rate is not allowed,負面評價率是不允許的
DocType: Holiday List,Weekly Off,每週關閉
DocType: Fiscal Year,"For e.g. 2012, 2012-13",對於例如2012、2012-13
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +13,Dropbox,Dropbox
apps/erpnext/erpnext/accounts/report/balance_sheet/balance_sheet.py +32,Provisional Profit / Loss (Credit),臨時溢利/（虧損）（信用）
apps/erpnext/erpnext/accounts/utils.py +243,Please set default value {0} in Company {1},請設置在公司默認值{0} {1}
DocType: Serial No,Creation Time,創作時間
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +62,Total Revenue,總收入
,Monthly Attendance Sheet,每月考勤表
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +17,No record found,沒有資料
apps/erpnext/erpnext/controllers/stock_controller.py +174,{0} {1}: Cost Center is mandatory for Item {2},{0} {1}：成本中心是強制性的項目{2}
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +73,Account {0} is inactive,帳戶{0}為未啟用
DocType: GL Entry,Is Advance,為進
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.js +20,Attendance From Date and Attendance To Date is mandatory,考勤起始日期和出席的日期，是強制性的
apps/erpnext/erpnext/controllers/buying_controller.py +132,Please enter 'Is Subcontracted' as Yes or No,請輸入'轉包' YES或NO
DocType: Sales Team,Contact No.,聯絡電話
apps/erpnext/erpnext/accounts/doctype/gl_entry/gl_entry.py +61,'Profit and Loss' type account {0} not allowed in Opening Entry,“損益”賬戶類型{0}不開放允許入境
DocType: Workflow State,Time,時間
DocType: Features Setup,Sales Discounts,銷售折扣
DocType: Hub Settings,Seller Country,賣家國家
DocType: Authorization Rule,Authorization Rule,授權規則
DocType: Sales Invoice,Terms and Conditions Details,條款及細則詳情
apps/erpnext/erpnext/templates/generators/item.html +49,Specifications,產品規格
DocType: Sales Taxes and Charges Template,Sales Taxes and Charges Template,營業稅金及費用套版
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +9,Apparel & Accessories,服裝及配飾
DocType: Item,"Mandatory if Stock Item is ""Yes"". Also the default warehouse where reserved quantity is set from Sales Order.",如果股票的強制性項目為“是”。也是默認倉庫，保留數量從銷售訂單設置。
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +57,Number of Order,訂購數量
DocType: Item Group,HTML / Banner that will show on the top of product list.,HTML／橫幅，將顯示在產品列表的頂部。
DocType: Shipping Rule,Specify conditions to calculate shipping amount,指定條件來計算運費金額
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +117,Add Child,添加子項目
DocType: Accounts Settings,Role Allowed to Set Frozen Accounts & Edit Frozen Entries,角色允許設置凍結帳戶和編輯冷凍項
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +26,Cannot convert Cost Center to ledger as it has child nodes,不能成本中心轉換為總賬，因為它有子節點
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +25,Conversion Factor is required,轉換係數是必需的
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +32,Serial #,序列號
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +87,Commission on Sales,銷售佣金
DocType: Offer Letter Term,Value / Description,值/說明
,Customers Not Buying Since Long Time,客戶已久未購買
DocType: Production Order,Expected Delivery Date,預計交貨日期
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +47,Bulging,挺著
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +10,Evaporative-pattern casting,蒸發圖案鑄造
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +93,Entertainment Expenses,娛樂費用
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +176,Sales Invoice {0} must be cancelled before cancelling this Sales Order,銷售發票{0}必須早於此銷售訂單之前取消
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.py +34,Age,年齡
DocType: Time Log,Billing Amount,開票金額
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.js +84,Invalid quantity specified for item {0}. Quantity should be greater than 0.,為項目指定了無效的數量{0} 。量應大於0 。
apps/erpnext/erpnext/config/hr.py +18,Applications for leave.,申請許可。
apps/erpnext/erpnext/accounts/doctype/account/account.py +144,Account with existing transaction can not be deleted,帳戶與現有的交易不能被刪除
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +99,Legal Expenses,法律費用
DocType: Sales Order,"The day of the month on which auto order will be generated e.g. 05, 28 etc",該月的一天，在這汽車的訂單將產生如05，28等
DocType: Sales Invoice,Posting Time,發布時間
DocType: Sales Order,% Amount Billed,（％）金額帳單
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +129,Telephone Expenses,電話費
DocType: Sales Partner,Logo,標誌
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +212,{0} Serial Numbers required for Item {0}. Only {0} provided.,{0}所需的物品序列號{0} 。只有{0}提供。
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.,如果要強制用戶在保存之前選擇了一系列檢查。將不會有默認的，如果你檢查這個。
apps/erpnext/erpnext/stock/get_item_details.py +108,No Item with Serial No {0},沒有序號{0}的品項
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +68,Direct Expenses,直接費用
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +645,Do you really want to UNSTOP this Material Request?,難道你真的想要UNSTOP此材料要求？
apps/erpnext/erpnext/selling/report/customer_acquisition_and_loyalty/customer_acquisition_and_loyalty.py +60,New Customer Revenue,新客戶收入
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +132,Travel Expenses,差旅費
DocType: Maintenance Visit,Breakdown,擊穿
DocType: Bank Reconciliation Detail,Cheque Date,支票日期
apps/erpnext/erpnext/accounts/doctype/account/account.py +43,Account {0}: Parent account {1} does not belong to company: {2},帳戶{0}：父帳戶{1}不屬於公司：{2}
apps/erpnext/erpnext/setup/doctype/company/company.js +33,Successfully deleted all transactions related to this company!,成功刪除與該公司相關的所有交易！
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +110,Honing,珩磨
DocType: Serial No,"Only Serial Nos with status ""Available"" can be delivered.",序列號狀態為「可用」的才可交付。
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +53,Probation,緩刑
apps/erpnext/erpnext/stock/doctype/item/item.py +94,Default Warehouse is mandatory for stock Item.,默認倉庫是強制性的股票項目。
DocType: Feed,Full Name,全名
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +147,Clinching,鉚
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +188,Payment of salary for the month {0} and year {1},{1}年{0}月的工資支付
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +25,Total Paid Amount,總支付金額
apps/erpnext/erpnext/accounts/general_ledger.py +91,Debit and Credit not equal for this voucher. Difference is {0}.,借記和信用為這個券不相等。不同的是{0} 。
,Transferred Qty,轉讓數量
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +132,Planning,規劃
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +9,Make Time Log Batch,做時間記錄批
DocType: Project,Total Billing Amount (via Time Logs),總結算金額（通過時間日誌）
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +577,We sell this Item,我們賣這種產品
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +66,Supplier Id,供應商編號
DocType: Journal Entry,Cash Entry,現金入境
DocType: Sales Partner,Contact Desc,聯繫倒序
apps/erpnext/erpnext/stock/doctype/item/item.py +190,Item Variants {0} created,項目變種{0}創建
apps/erpnext/erpnext/config/hr.py +135,"Type of leaves like casual, sick etc.",葉似漫不經心，生病等類型
DocType: Email Digest,Send regular summary reports via Email.,通過電子郵件發送定期匯總報告。
DocType: Cost Center,Add rows to set annual budgets on Accounts.,在帳戶的年度預算中加入新一列。
DocType: Buying Settings,Default Supplier Type,默認的供應商類別
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +159,Quarrying,採石
DocType: Production Order,Total Operating Cost,總營運成本
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +153,Note: Item {0} entered multiple times,注：項目{0}多次輸入
apps/erpnext/erpnext/config/crm.py +27,All Contacts.,所有聯繫人。
DocType: Newsletter,Test Email Id,測試電子郵件Id
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +392,Company Abbreviation,公司縮寫
DocType: Features Setup,If you follow Quality Inspection. Enables Item QA Required and QA No in Purchase Receipt,如果你遵循質量檢驗。使產品的質量保證要求和質量保證在沒有採購入庫單
DocType: GL Entry,Party Type,黨的類型
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +68,Raw material cannot be same as main Item,原料不能同主品相
DocType: Item Attribute Value,Abbreviation,縮寫
apps/erpnext/erpnext/setup/doctype/authorization_control/authorization_control.py +36,Not authroized since {0} exceeds limits,不允許因為{0}超出範圍
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +29,Rotational molding,滾塑成型
apps/erpnext/erpnext/config/hr.py +115,Salary template master.,薪資套版主檔。
DocType: Leave Type,Max Days Leave Allowed,允許的最長休假天
DocType: Payment Tool,Set Matching Amounts,設置相同的金額
DocType: Purchase Invoice,Taxes and Charges Added,稅費上架
,Sales Funnel,銷售漏斗
apps/erpnext/erpnext/shopping_cart/utils.py +34,Cart,車
,Qty to Transfer,轉移數量
apps/erpnext/erpnext/config/selling.py +18,Quotes to Leads or Customers.,行情到引線或客戶。
DocType: Stock Settings,Role Allowed to edit frozen stock,角色可以編輯凍結的庫存
,Territory Target Variance Item Group-Wise,境內目標差異項目組，智者
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +96,All Customer Groups,所有客戶群
apps/erpnext/erpnext/controllers/accounts_controller.py +366,{0} is mandatory. Maybe Currency Exchange record is not created for {1} to {2}.,{0}是強制性的。也許外幣兌換記錄為{1}到{2}尚未建立。
apps/erpnext/erpnext/accounts/doctype/account/account.py +37,Account {0}: Parent account {1} does not exist,帳戶{0}：父帳戶{1}不存在
DocType: Purchase Invoice Item,Price List Rate (Company Currency),價格列表費率（公司貨幣）
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +83,{0} {1} status is 'Stopped',{0} {1}狀態為“停止”
DocType: Account,Temporary,臨時
DocType: Address,Preferred Billing Address,偏好的帳單地址
DocType: Monthly Distribution Percentage,Percentage Allocation,百分比分配
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +81,Secretary,秘書
DocType: Serial No,Distinct unit of an Item,一個項目的不同的單元
apps/erpnext/erpnext/config/setup.py +96,Item master.,項目主。
DocType: Pricing Rule,Buying,求購
DocType: HR Settings,Employee Records to be created by,員工紀錄的創造者
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.js +24,This Time Log Batch has been cancelled.,此時日誌批次已被取消。
DocType: Purchase Invoice,Apply Discount On,申請折扣
DocType: Salary Slip Earning,Salary Slip Earning,工資單盈利
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +161,Creditors,債權人
DocType: Purchase Taxes and Charges,Item Wise Tax Detail,項目智者稅制明細
,Item-wise Price List Rate,項目明智的價目表率
DocType: Purchase Order Item,Supplier Quotation,供應商報價
DocType: Quotation,In Words will be visible once you save the Quotation.,在詞將是可見的，一旦你保存報價。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +67,Ironing,熨衣服
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +236,{0} {1} is stopped,{0} {1}停止
apps/erpnext/erpnext/stock/doctype/item/item.py +346,Barcode {0} already used in Item {1},條碼{0}已經用在項目{1}
DocType: Lead,Add to calendar on this date,在此日期加到日曆
apps/erpnext/erpnext/config/selling.py +127,Rules for adding shipping costs.,增加運輸成本的規則。
apps/erpnext/erpnext/support/doctype/warranty_claim/warranty_claim.py +20,Customer is required,客戶是必需的
DocType: Letter Head,Letter Head,信頭
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +32,Shrink fitting,冷縮配合
DocType: Email Digest,Income / Expense,收入／支出
DocType: Employee,Personal Email,個人電子郵件
apps/erpnext/erpnext/selling/report/territory_target_variance_item_group_wise/territory_target_variance_item_group_wise.py +58,Total Variance,總方差
DocType: Accounts Settings,"If enabled, the system will post accounting entries for inventory automatically.",如果啟用，系統將自動為發布庫存會計分錄。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +14,Brokerage,佣金
DocType: Production Order Operation,"in Minutes
Updated via 'Time Log'","在分
通過“時間日誌”更新"
DocType: Customer,From Lead,從鉛
apps/erpnext/erpnext/config/manufacturing.py +19,Orders released for production.,發布生產訂單。
apps/erpnext/erpnext/accounts/page/financial_analytics/financial_analytics.js +42,Select Fiscal Year...,選擇會計年度...
DocType: Hub Settings,Name Token,名令牌
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +105,Planing,刨
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.py +159,Standard Selling,標準銷售
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +153,Atleast one warehouse is mandatory,至少要有一間倉庫
DocType: Serial No,Out of Warranty,超出保修期
DocType: BOM Replace Tool,Replace,更換
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +281,{0} against Sales Invoice {1},{0}對銷售發票{1}
apps/erpnext/erpnext/stock/doctype/item/item.py +47,Please enter default Unit of Measure,請輸入預設的計量單位
DocType: Purchase Invoice Item,Project Name,專案名稱
DocType: Workflow State,Edit,編輯
DocType: Journal Entry Account,If Income or Expense,如果收入或支出
DocType: Email Digest,New Support Tickets,新的客服支援回報單
DocType: Features Setup,Item Batch Nos,項目批NOS
DocType: Stock Ledger Entry,Stock Value Difference,庫存價值差異
DocType: Payment Reconciliation Payment,Payment Reconciliation Payment,付款方式付款對賬
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +36,Tax Assets,所得稅資產
DocType: BOM Item,BOM No,BOM No.
DocType: Contact Us Settings,Pincode,PIN代碼
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +147,Journal Entry {0} does not have account {1} or already matched against other voucher,日記條目{0}沒有帳號{1}或已經匹配其他憑證
DocType: Item,Moving Average,移動平均線
DocType: BOM Replace Tool,The BOM which will be replaced,這將被替換的物料清單
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +21,New Stock UOM must be different from current stock UOM,全新庫存計量單位必須不同於目前的計量單位
DocType: Account,Debit,借方
apps/erpnext/erpnext/hr/doctype/leave_allocation/leave_allocation.py +32,Leaves must be allocated in multiples of 0.5,休假必須安排成0.5倍的
DocType: Production Order,Operation Cost,運營成本
apps/erpnext/erpnext/config/hr.py +71,Upload attendance from a .csv file,從。csv文件上傳考勤
apps/erpnext/erpnext/selling/report/customer_credit_balance/customer_credit_balance.py +39,Outstanding Amt,優秀的金額
DocType: Sales Person,Set targets Item Group-wise for this Sales Person.,設定目標項目組間的這種銷售人員。
DocType: Warranty Claim,"To assign this issue, use the ""Assign"" button in the sidebar.",要分配這個問題，請使用“分配”按鈕，在側邊欄。
DocType: Stock Settings,Freeze Stocks Older Than [Days],凍結早於[Days]的庫存
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +40,"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/accounts/report/payment_period_based_on_invoice_date/payment_period_based_on_invoice_date.py +42,Against Invoice,對發票
apps/erpnext/erpnext/controllers/trends.py +36,Fiscal Year: {0} does not exists,會計年度：{0}不存在
DocType: Currency Exchange,To Currency,以貨幣
DocType: Leave Block List,Allow the following users to approve Leave Applications for block days.,允許以下用戶批准許可申請的區塊天。
apps/erpnext/erpnext/config/hr.py +155,Types of Expense Claim.,報銷的類型。
DocType: Item,Taxes,稅
DocType: Project,Default Cost Center,默認的成本中心
DocType: Purchase Invoice,End Date,結束日期
DocType: Employee,Internal Work History,內部工作經歷
DocType: DocField,Column Break,分欄符
DocType: Event,Thursday,星期四
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +41,Private Equity,私募股權投資
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +92,Turning,車削
DocType: Maintenance Visit,Customer Feedback,客戶反饋
DocType: Account,Expense,費用
DocType: Sales Invoice,Exhibition,展覽
apps/erpnext/erpnext/stock/utils.py +89,Item {0} ignored since it is not a stock item,項{0}忽略，因為它不是一個股票項目
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +28,Submit this Production Order for further processing.,提交此生產訂單進行進一步的處理。
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.js +21,"To not apply Pricing Rule in a particular transaction, all applicable Pricing Rules should be disabled.",要在一個特定的交易不適用於定價規則，所有適用的定價規則應該被禁用。
DocType: Company,Domain,網域
,Sales Order Trends,銷售訂單趨勢
DocType: Employee,Held On,舉行
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order_calendar.js +24,Production Item,生產項目
,Employee Information,僱員資料
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +502,Rate (%),率（ ％ ）
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +405,Financial Year End Date,財政年度年結日
apps/erpnext/erpnext/accounts/report/general_ledger/general_ledger.py +32,"Can not filter based on Voucher No, if grouped by Voucher",是冷凍的帳戶。要禁止該帳戶創建/編輯事務，你需要角色
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +502,Make Supplier Quotation,讓供應商報價
DocType: Quality Inspection,Incoming,來
DocType: Item,Name and Description,名稱和說明
apps/erpnext/erpnext/stock/doctype/item/item.py +134,"Default Unit of Measure can not be changed directly because you have already made some transaction(s) with another UOM. To change default UOM, use 'UOM Replace Utility' tool under Stock module.",整合進來支持電子郵件，支持票
DocType: BOM,Materials Required (Exploded),所需材料（分解）
DocType: Salary Structure Earning,Reduce Earning for Leave Without Pay (LWP),降低盈利停薪留職（LWP）
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +44,Casual Leave,事假
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +92,Credit To account must be a liability account,信用帳戶必須是一個負債帳戶
DocType: Batch,Batch ID,批次ID
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +303,Note: {0},注： {0}
,Delivery Note Trends,送貨單趨勢
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +72,{0} must be a Purchased or Sub-Contracted Item in row {1},{0}必須是購買或分包項目中列{1}
apps/erpnext/erpnext/accounts/general_ledger.py +100,Account: {0} can only be updated via Stock Transactions,賬號：{0}只能通過股票的交易進行更新
DocType: GL Entry,Party,黨
DocType: Sales Order,Delivery Date,交貨日期
DocType: DocField,Currency,貨幣
DocType: Opportunity,Opportunity Date,機會日期
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order_list.js +10,To Bill,比爾
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +56,Piecework,計件工作
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +64,Avg. Buying Rate,平均。買入價
DocType: Task,Actual Time (in Hours),實際時間（小時）
DocType: Employee,History In Company,公司歷史
DocType: Address,Shipping,航運
DocType: Stock Ledger Entry,Stock Ledger Entry,庫存總帳條目
DocType: Department,Leave Block List,休假區塊清單
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +203,Item {0} is not setup for Serial Nos. Column must be blank,項{0}不是設置為序列號列必須為空白
DocType: Accounts Settings,Accounts Settings,賬戶設置
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +53,Plant and Machinery,廠房及機器
DocType: Item,You can enter the minimum quantity of this item to be ordered.,您可以輸入資料到訂購的最小數量。
DocType: Sales Partner,Partner's Website,合作夥伴的網站
DocType: Opportunity,To Discuss,為了討論
DocType: SMS Settings,SMS Settings,短信設置
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +60,Temporary Accounts,臨時賬戶
DocType: Payment Tool,Column Break 1,分欄符1
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +150,Black,黑
DocType: BOM Explosion Item,BOM Explosion Item,BOM爆炸物品
DocType: Account,Auditor,核數師
DocType: Purchase Order,End date of current order's period,當前訂單的週期的最後一天
apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.js +17,Make Offer Letter,使錄取通知書
DocType: DocField,Fold,折
DocType: Production Order Operation,Production Order Operation,生產訂單操作
DocType: Pricing Rule,Disable,關閉
DocType: Project Task,Pending Review,待審核
sites/assets/js/desk.min.js +558,Please specify,請註明
DocType: Task,Total Expense Claim (via Expense Claim),總費用報銷（通過費用報銷）
apps/erpnext/erpnext/accounts/report/sales_register/sales_register.py +65,Customer Id,客戶ID
DocType: Page,Page Name,網頁名稱
DocType: Purchase Invoice,Exchange Rate,匯率
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +422,Sales Order {0} is not submitted,銷售訂單{0}未提交
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +74,Warehouse {0}: Parent account {1} does not bolong to the company {2},倉庫{0}：家長帳戶{1}不博隆該公司{2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +123,Spindle finishing,主軸整理
DocType: Material Request,% of materials ordered against this Material Request,％的下令對這種材料申請材料
DocType: BOM,Last Purchase Rate,最後預訂價
DocType: Account,Asset,財富
DocType: Project Task,Task ID,任務ID
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +393,"e.g. ""MC""",例如“MC”
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +75,Stock cannot exist for Item {0} since has variants,股票可以為項目不存在{0}，因為有變種
,Sales Person-wise Transaction Summary,銷售人員相關的交易匯總
DocType: System Settings,Time Zone,時區
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +104,Warehouse {0} does not exist,倉庫{0}不存在
apps/erpnext/erpnext/hub_node/page/hub/register_in_hub.html +2,Register For ERPNext Hub,立即註冊ERPNext中心
DocType: Monthly Distribution,Monthly Distribution Percentages,每月分佈百分比
apps/erpnext/erpnext/stock/doctype/batch/batch.py +16,The selected item cannot have Batch,所選項目不能批
DocType: Delivery Note,% of materials delivered against this Delivery Note,％的交付對本送貨單材料
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +150,Stapling,裝訂
DocType: Customer,Customer Details,客戶詳細信息
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +104,Shaping,成型
DocType: Employee,Reports to,隸屬於
DocType: SMS Settings,Enter url parameter for receiver nos,輸入URL參數的接收器號
DocType: Sales Invoice,Paid Amount,支付的金額
apps/erpnext/erpnext/accounts/doctype/period_closing_voucher/period_closing_voucher.py +25,Closing Account {0} must be of type 'Liability',關閉帳戶{0}必須是類型'責任'
,Available Stock for Packing Items,可用庫存包裝項目
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +275,Reserved Warehouse is missing in Sales Order,保留倉庫在銷售訂單失踪
DocType: Item Variant,Item Variant,項目變
apps/erpnext/erpnext/utilities/doctype/address_template/address_template.py +15,Setting this Address Template as default as there is no other default,設置此地址模板為預設當沒有其它的預設值
apps/erpnext/erpnext/accounts/doctype/account/account.py +71,"Account balance already in Debit, you are not allowed to set 'Balance Must Be' as 'Credit'",帳戶餘額已歸為Debit帳戶，不允許設為信用帳戶
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +71,Quality Management,品質管理
DocType: Production Planning Tool,Filter based on customer,過濾器可根據客戶
DocType: Payment Tool Detail,Against Voucher No,針對券無
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +46,Please enter quantity for Item {0},請輸入項目{0}的量
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +35,Warning: Sales Order {0} already exists against same Purchase Order number,警告：銷售訂單{0}已經存在對同一採購訂單號
DocType: Employee External Work History,Employee External Work History,員工對外工作歷史
DocType: Notification Control,Purchase,採購
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +178,Status of {0} {1} is now {2},{0} {1}現在狀態{2}
apps/erpnext/erpnext/stock/report/stock_ledger/stock_ledger.py +29,Balance Qty,餘額數量
DocType: Item Group,Parent Item Group,父項目組
apps/erpnext/erpnext/projects/doctype/activity_cost/activity_cost.py +18,{0} for {1},{0} {1}
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +92,Cost Centers,成本中心
apps/erpnext/erpnext/config/stock.py +115,Warehouses.,倉庫。
DocType: Purchase Order,Rate at which supplier's currency is converted to company's base currency,供應商貨幣被換算成公司基礎貨幣的匯率
apps/erpnext/erpnext/manufacturing/doctype/workstation/workstation.py +36,Row #{0}: Timings conflicts with row {1},行＃{0}：與排時序衝突{1}
DocType: Employee,Employment Type,就業類型
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +40,Fixed Assets,固定資產
DocType: Item Group,Default Expense Account,默認費用帳戶
DocType: Employee,Notice (days),通告（天）
DocType: Page,Yes,是的
DocType: Cost Center,Material User,材料成員
DocType: Employee,Encashment Date,兌現日期
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +73,Electroforming,電鑄
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +147,"Against Voucher Type must be one of Purchase Order, Purchase Invoice or Journal Entry",對憑證類型必須是採購訂單，採購發票或日記帳分錄
DocType: Account,Stock Adjustment,庫存調整
DocType: Production Order,Planned Operating Cost,計劃運營成本
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +118,New {0} Name,新{0}名稱
apps/erpnext/erpnext/controllers/recurring_document.py +126,Please find attached {0} #{1},隨函附上{0}＃{1}
DocType: Global Defaults,jsonrates.com API Key,jsonrates.com API密鑰
DocType: Job Applicant,Applicant Name,申請人名稱
DocType: Authorization Rule,Customer / Item Name,客戶／品項名稱
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +44,Serial No is mandatory for Item {0},項目{0}的序列號是強制性的
sites/assets/js/desk.min.js +536,Created By,創建人
DocType: Serial No,Under AMC,在AMC
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +47,Item valuation rate is recalculated considering landed cost voucher amount,物品估價率重新計算考慮到岸成本憑證金額
apps/erpnext/erpnext/config/selling.py +65,Default settings for selling transactions.,默認設置為賣出交易。
DocType: BOM Replace Tool,Current BOM,當前BOM表
sites/assets/js/erpnext.min.js +5,Add Serial No,添加序列號
DocType: Production Order,Warehouses,倉庫
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +117,Print and Stationary,印刷和文具
apps/erpnext/erpnext/selling/page/sales_browser/sales_browser.js +119,Group Node,組節點
DocType: Payment Reconciliation,Minimum Amount,最低金額
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.js +68,Update Finished Goods,更新成品
DocType: Item,"Automatically set. If this item has variants, then it cannot be selected in sales orders etc.",自動設置。如果此項目已變種，那麼它不能在銷售訂單等選擇
DocType: Workstation,per hour,每小時
apps/frappe/frappe/core/doctype/doctype/doctype.py +97,Series {0} already used in {1},系列{0}已經被應用在{1}
DocType: Warehouse,Account for the warehouse (Perpetual Inventory) will be created under this Account.,賬戶倉庫（永續盤存）將在該帳戶下創建。
apps/erpnext/erpnext/stock/doctype/warehouse/warehouse.py +95,Warehouse can not be deleted as stock ledger entry exists for this warehouse.,股票分類帳項存在這個倉庫倉庫不能被刪除。
DocType: Company,Distribution,分配
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +86,Project Manager,專案經理
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +67,Dispatch,調度
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +70,Max discount allowed for item: {0} is {1}%,{0}允許的最大折扣：{1}％
DocType: Account,Receivable,應收賬款
DocType: Accounts Settings,Role that is allowed to submit transactions that exceed credit limits set.,作用是允許提交超過設定信用額度交易的。
DocType: Sales Invoice,Supplier Reference,供應商參考
DocType: Production Planning Tool,"If checked, BOM for sub-assembly items will be considered for getting raw materials. Otherwise, all sub-assembly items will be treated as a raw material.",如果選中，則BOM的子裝配項目將被視為獲取原料。否則，所有的子組件件，將被視為一個原料。
DocType: Material Request,Material Issue,材料問題
DocType: Hub Settings,Seller Description,賣家描述
DocType: Item,Is Stock Item,是庫存項目
DocType: Shopping Cart Price List,Shopping Cart Price List,購物車價格表
DocType: Employee Education,Qualification,合格
DocType: Item Price,Item Price,商品價格
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +47,Soap & Detergent,肥皂和洗滌劑
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +35,Motion Picture & Video,電影和視頻
apps/erpnext/erpnext/buying/doctype/supplier_quotation/supplier_quotation_list.js +5,Ordered,訂購
DocType: Company,Default Settings,默認設置
DocType: Warehouse,Warehouse Name,倉庫名稱
DocType: Naming Series,Select Transaction,選擇交易
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +30,Please enter Approving Role or Approving User,請輸入核准角色或審批用戶
DocType: Journal Entry,Write Off Entry,核銷進入
DocType: BOM,Rate Of Materials Based On,率材料的基礎上
apps/erpnext/erpnext/support/page/support_analytics/support_analytics.js +21,Support Analtyics,支援分析
DocType: Journal Entry,eg. Cheque Number,例如：。支票號碼
apps/erpnext/erpnext/accounts/doctype/accounts_settings/accounts_settings.py +25,Company is missing in warehouses {0},公司在倉庫缺少{0}
DocType: Stock UOM Replace Utility,Stock UOM Replace Utility,庫存計量單位更換工具
DocType: POS Setting,Terms and Conditions,條款和條件
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.py +43,To Date should be within the Fiscal Year. Assuming To Date = {0},日期應該是在財政年度內。假設終止日期= {0}
DocType: Employee,"Here you can maintain height, weight, allergies, medical concerns etc",在這裡，你可以保持身高，體重，過敏，醫療問題等
DocType: Leave Block List,Applies to Company,適用於公司
apps/erpnext/erpnext/manufacturing/doctype/production_order/production_order.py +156,Cannot cancel because submitted Stock Entry {0} exists,不能取消，因為提交股票輸入{0}存在
DocType: Purchase Invoice,In Words,中字
apps/erpnext/erpnext/hr/doctype/employee/employee.py +204,Today is {0}'s birthday!,今天是{0}的生日！
DocType: Production Planning Tool,Material Request For Warehouse,倉庫材料需求
DocType: Sales Order Item,For Production,對於生產
apps/erpnext/erpnext/manufacturing/doctype/production_planning_tool/production_planning_tool.py +107,Please enter sales order in the above table,請在上表輸入訂單
DocType: Project Task,View Task,查看任務
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +404,Your financial year begins on,您的會計年度自
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +46,Please enter Purchase Receipts,請輸入購買收據
DocType: Sales Invoice,Get Advances Received,取得進展收稿
DocType: Email Digest,Add/Remove Recipients,添加／刪除收件人
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +471,Transaction not allowed against stopped Production Order {0},交易不反對停止生產訂單允許{0}
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.js +19,"To set this Fiscal Year as Default, click on 'Set as Default'",要設置這個財政年度為默認值，點擊“設為默認”
apps/erpnext/erpnext/config/support.py +54,Setup incoming server for support email id. (e.g. support@example.com),設置接收郵件服務器支持電子郵件ID 。 （例如support@example.com ）
apps/erpnext/erpnext/stock/report/stock_projected_qty/stock_projected_qty.py +35,Shortage Qty,短缺數量
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +79,Row{0}: Party Type and Party is required for Receivable / Payable account {1},行{0}：黨的類型和黨的需要應收/應付帳戶{1}
DocType: Salary Slip,Salary Slip,工資單
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +115,Burnishing,打磨
DocType: Features Setup,To enable <b>Point of Sale</b> view,為了使<b>銷售點</b>看法
apps/erpnext/erpnext/stock/report/stock_balance/stock_balance.py +54,'To Date' is required,“至日期”是必需填寫的
DocType: Packing Slip,"Generate packing slips for packages to be delivered. Used to notify package number, package contents and its weight.",生成裝箱單的包裹交付。用於通知包號，包的內容和它的重量。
DocType: Sales Invoice Item,Sales Order Item,銷售訂單項目
DocType: Salary Slip,Payment Days,付款日
DocType: BOM,Manage cost of operations,管理運營成本
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +86,Make Credit Note,使信貸注
DocType: Features Setup,Item Advanced,項目高級
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +39,Hot rolling,熱軋
DocType: Notification Control,"When any of the checked transactions are ""Submitted"", an email pop-up automatically opened to send an email to the associated ""Contact"" in that transaction, with the transaction as an attachment. The user may or may not send the email.",當任何選中的交易都是“已提交”，郵件彈出窗口自動打開，在該事務發送電子郵件到相關的“聯繫”，與交易作為附件。用戶可能會或可能不會發送電子郵件。
apps/erpnext/erpnext/config/setup.py +101,Customer master.,客戶主。
apps/erpnext/erpnext/config/setup.py +14,Global Settings,全局設置
DocType: Employee Education,Employee Education,員工教育
DocType: Salary Slip,Net Pay,淨收費
DocType: Account,Account,帳戶
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +227,Serial No {0} has already been received,序列號{0}已收到
,Requested Items To Be Transferred,要訂購的傳送項目
DocType: Purchase Invoice,Recurring Id,經常性標識
DocType: Customer,Sales Team Details,銷售團隊詳細
DocType: Expense Claim,Total Claimed Amount,總索賠額
apps/erpnext/erpnext/config/crm.py +22,Potential opportunities for selling.,潛在的銷售機會。
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +46,Sick Leave,病假
DocType: Email Digest,Email Digest,電子郵件摘要
DocType: Delivery Note,Billing Address Name,帳單地址名稱
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +21,Department Stores,百貨
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.py +39,System Balance,系統平衡
DocType: Workflow,Is Active,為活躍
apps/erpnext/erpnext/controllers/stock_controller.py +70,No accounting entries for the following warehouses,沒有以下的倉庫會計分錄
apps/erpnext/erpnext/projects/doctype/project/project.js +22,Save the document first.,首先保存文檔。
DocType: Account,Chargeable,收費
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +120,Linishing,Linishing
DocType: Company,Change Abbreviation,變化縮寫
DocType: Workflow State,Primary,主要的
DocType: Expense Claim Detail,Expense Date,犧牲日期
DocType: Item,Max Discount (%),最大折讓（％）
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.py +60,Last Order Amount,最後訂單金額
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +160,Blasting,爆破
DocType: Company,Warn,警告
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +82,Item valuation updated,物品估價更新
DocType: Appraisal,"Any other remarks, noteworthy effort that should go in the records.",任何其他言論，值得一提的努力，應該在記錄中。
DocType: BOM,Manufacturing User,製造業用戶
DocType: Purchase Order,Raw Materials Supplied,提供供應商
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +239,Total valuation ({0}) for manufactured or repacked item(s) can not be less than total valuation of raw materials ({1}),總估價（{0}）用於生產或重新包裝項目（S）不能小於原料總估價（{1}）
DocType: Email Digest,New Projects,新專案
DocType: Communication,Series,系列
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +28,Expected Delivery Date cannot be before Purchase Order Date,預計交貨日期不能早於採購訂單日期
DocType: Appraisal,Appraisal Template,評估模板
DocType: Communication,Email,電子郵件
DocType: Item Group,Item Classification,項目分類
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +84,Business Development Manager,業務發展經理
DocType: Maintenance Visit Purpose,Maintenance Visit Purpose,維護訪問目的
apps/erpnext/erpnext/accounts/report/budget_variance_report/budget_variance_report.js +15,Period,期間
,General Ledger,總帳
apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,查看信息
DocType: Item Attribute Value,Attribute Value,屬性值
apps/erpnext/erpnext/crm/doctype/lead/lead.py +65,"Email id must be unique, already exists for {0}",電子郵件ID必須是唯一的，已經存在{0}
,Itemwise Recommended Reorder Level,Itemwise推薦級別重新排序
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +216,Please select {0} first,請先選擇{0}
DocType: Features Setup,To get Item Group in details table,為了讓項目組在詳細信息表
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +66,Redrawing,重繪
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +119,Etching,蝕刻
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +55,Commission,佣金
apps/erpnext/erpnext/templates/pages/ticket.py +31,You are not allowed to reply to this ticket.,你不能回复此票。
DocType: Address Template,"<h4>Default Template</h4>
<p>Uses <a href=""http://jinja.pocoo.org/docs/templates/"">Jinja Templating</a> and all the fields of Address (including Custom Fields if any) will be available</p>
<pre><code>{{ address_line1 }}&lt;br&gt;
{% if address_line2 %}{{ address_line2 }}&lt;br&gt;{% endif -%}
{{ city }}&lt;br&gt;
{% if state %}{{ state }}&lt;br&gt;{% endif -%}
{% if pincode %} PIN:  {{ pincode }}&lt;br&gt;{% endif -%}
{{ country }}&lt;br&gt;
{% if phone %}Phone: {{ phone }}&lt;br&gt;{% endif -%}
{% if fax %}Fax: {{ fax }}&lt;br&gt;{% endif -%}
{% if email_id %}Email: {{ email_id }}&lt;br&gt;{% endif -%}
</code></pre>","<H4>默認模板</ H4> 
 <p> <a用途神社href=""http://jinja.pocoo.org/docs/templates/"">模板</A>和地址的所有領域（包括自定義字段如果有的話）將可</ P> 
 <前> <代碼> {{address_line1}}＆LT; BR＆GT; 
 {％，如果address_line2％} {{address_line2}}＆LT; BR＆GT; { ENDIF％ - ％} 
 {{城市}}＆LT; BR＆GT; 
 {％，如果狀態％} {{狀態}}＆LT; BR＆GT; {％ENDIF - ％} {
％，如果PIN代碼％} PIN：{{PIN碼}}＆LT; BR＆GT; {％ENDIF - ％} 
 {{國家}}＆LT; BR＆GT; 
 {％，如果電話％}電話：{{電話}}＆LT; BR＆GT; { ％ENDIF - ％} 
 {％，如果傳真％}傳真：{{傳真}}＆LT; BR＆GT; {％ENDIF - ％} 
 {％，如果email_id％}電子郵件：{{email_id}}＆LT; BR＆GT {％ENDIF - ％} 
 </代碼> </ PRE>"
DocType: Salary Slip Deduction,Default Amount,違約金額
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +84,Warehouse not found in the system,倉庫系統中未找到
DocType: Quality Inspection Reading,Quality Inspection Reading,質量檢驗閱讀
DocType: Party Account,col_break1,col_break1
apps/erpnext/erpnext/stock/doctype/stock_settings/stock_settings.py +26,`Freeze Stocks Older Than` should be smaller than %d days.,`凍結股票早於`應該是％d天前小。
,Project wise Stock Tracking,項目明智的庫存跟踪
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +176,Maintenance Schedule {0} exists against {0},維護時間表{0}針對存在{0}
DocType: Stock Entry Detail,Actual Qty (at source/target),實際的數量（在源/目標）
DocType: Item Customer Detail,Ref Code,參考代碼
apps/erpnext/erpnext/config/hr.py +13,Employee records.,員工記錄。
DocType: HR Settings,Payroll Settings,薪資設置
apps/erpnext/erpnext/config/accounts.py +58,Match non-linked Invoices and Payments.,匹配非聯的發票和付款。
DocType: Email Digest,New Purchase Orders,新的採購訂單
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +22,Root cannot have a parent cost center,root不能有一個父成本中心
DocType: Sales Invoice,C-Form Applicable,C-表格適用
DocType: UOM Conversion Detail,UOM Conversion Detail,計量單位換算詳細
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +476,Keep it web friendly 900px (w) by 100px (h),900px （寬）x 100像素（高）
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +44,Charges are updated in Purchase Receipt against each item,費用在外購入庫單對每個項目更新
DocType: Payment Tool,Get Outstanding Vouchers,獲得傑出禮券
DocType: Warranty Claim,Resolved By,議決
DocType: Appraisal,Start Date,開始日期
sites/assets/js/desk.min.js +512,Value,值
apps/erpnext/erpnext/config/hr.py +130,Allocate leaves for a period.,離開一段時間。
apps/erpnext/erpnext/accounts/doctype/account/account.py +39,Account {0}: You can not assign itself as parent account,帳戶{0}：你不能指定自己為父帳戶
DocType: Purchase Invoice Item,Price List Rate,價格列表費率
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +166,Delivered Serial No {0} cannot be deleted,交付序號{0}無法刪除
DocType: Item,"Show ""In Stock"" or ""Not in Stock"" based on stock available in this warehouse.",基於倉庫內存貨的狀態顯示「有或」或「無貨」。
apps/erpnext/erpnext/config/manufacturing.py +13,Bill of Materials (BOM),材料清單（BOM）
DocType: Time Log,Hours,小時
DocType: Project,Expected Start Date,預計開始日期
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +37,Rolling,滾動
DocType: ToDo,Priority,優先
apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +168,"Cannot delete Serial No {0} in stock. First remove from stock, then delete.",不能刪除序號{0}。先從庫存中移除，再刪除。
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.js +41,Remove item if charges is not applicable to that item,刪除項目，如果收費並不適用於該項目
DocType: Backup Manager,Dropbox Access Allowed,允許訪問Dropbox
DocType: Backup Manager,Weekly,每週
DocType: SMS Settings,Eg. smsgateway.com/api/send_sms.cgi,例如：。 smsgateway.com / API / send_sms.cgi
DocType: Maintenance Visit,Fully Completed,全面完成
DocType: Item,"Products will be sorted by weight-age in default searches. More the weight-age, higher the product will appear in the list.",產品將重量年齡在默認搜索排序。更多的重量，年齡，更高的產品會出現在列表中。
apps/erpnext/erpnext/projects/doctype/project/project_list.js +6,{0}% Complete,{0}％完成
DocType: Employee,Educational Qualification,學歷
DocType: Workstation,Operating Costs,運營成本
DocType: Employee Leave Approver,Employee Leave Approver,員工請假審批
apps/erpnext/erpnext/templates/includes/footer_extension.html +9,Stay Updated,保持更新
apps/erpnext/erpnext/stock/doctype/item/item.py +376,Row {0}: An Reorder entry already exists for this warehouse {1},行{0}：一個重新排序條目已存在這個倉庫{1}
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.py +66,"Cannot declare as lost, because Quotation has been made.",不能聲明為丟失，因為報價已經取得進展。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +132,Electron beam machining,電子束加工
DocType: Purchase Taxes and Charges Template,Purchase Master Manager,採購主檔經理
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +468,Production Order {0} must be submitted,生產訂單{0}必須提交
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +160,Please select Start Date and End Date for Item {0},請選擇項目{0}的開始日期和結束日期
apps/erpnext/erpnext/config/stock.py +141,Main Reports,主報告
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +73,Stock Ledger entries balances updated,庫存總帳條目更新結餘
apps/erpnext/erpnext/hr/doctype/leave_control_panel/leave_control_panel.js +16,To date cannot be before from date,無效的主名稱
DocType: Purchase Receipt Item,Prevdoc DocType,Prevdoc的DocType
apps/erpnext/erpnext/stock/doctype/item/item.js +201,Add / Edit Prices,添加/編輯價格
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.js +54,Chart of Cost Centers,成本中心的圖
,Requested Items To Be Ordered,要訂購的需求項目
apps/erpnext/erpnext/selling/doctype/sales_order/sales_order.py +238,My Orders,我的訂單
DocType: Price List,Price List Name,價格列表名稱
DocType: Time Log,For Manufacturing,對於製造業
DocType: BOM,Manufacturing,製造業
,Ordered Items To Be Delivered,訂購項目交付
DocType: Account,Income,收入
,Setup Wizard,設置嚮導
DocType: Industry Type,Industry Type,行業類型
apps/erpnext/erpnext/templates/includes/cart.js +264,Something went wrong!,出事了！
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +68,Warning: Leave application contains following block dates,警告：離開應用程序包含以下模塊日期
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +235,Sales Invoice {0} has already been submitted,銷售發票{0}已提交
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +30,Completion Date,完成日期
DocType: Purchase Invoice Item,Amount (Company Currency),金額（公司貨幣）
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +9,Die casting,壓鑄模具
DocType: Email Alert,Reference Date,參考日期
apps/erpnext/erpnext/config/hr.py +105,Organization unit (department) master.,組織單位（部門）的主人。
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +25,Please enter valid mobile nos,請輸入有效的手機號
DocType: Email Digest,User Specific,特定用戶
DocType: Budget Detail,Budget Detail,預算案詳情
apps/erpnext/erpnext/selling/doctype/sms_center/sms_center.py +73,Please enter message before sending,在發送前，請填寫留言
DocType: Communication,Status,狀態
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +36,Stock UOM updated for Item {0},股票UOM更新的項目{0}
DocType: Company History,Year,年
apps/erpnext/erpnext/setup/doctype/sms_settings/sms_settings.py +69,Please Update SMS Settings,請更新短信設置
apps/erpnext/erpnext/projects/doctype/time_log_batch/time_log_batch.py +34,Time Log {0} already billed,時間日誌{0}已結算
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +176,Unsecured Loans,無抵押貸款
DocType: Cost Center,Cost Center Name,成本中心名稱
apps/erpnext/erpnext/selling/doctype/installation_note/installation_note.py +59,Item {0} with Serial No {1} is already installed,項{0}與序列號{1}已經安裝
apps/erpnext/erpnext/setup/doctype/backup_manager/backup_manager.js +10,You can start by selecting backup frequency and granting access for sync,您可以通過選擇備份的頻率和授權訪問的同步啟動
DocType: Maintenance Schedule Detail,Scheduled Date,預定日期
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +69,Total Paid Amt,數金額金額
DocType: SMS Center,Messages greater than 160 characters will be split into multiple messages,大於160個字元的訊息將被分割成多個訊息送出
DocType: Purchase Receipt Item,Received and Accepted,收到並接受
DocType: Item Attribute,"Lower the number, higher the priority in the Item Code suffix that will be created for this Item Attribute for the Item Variant",數值越低，優先級越高的，將這個項目屬性的變項創建的項目代碼後綴
,Serial No Service Contract Expiry,序號服務合同到期
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +79,Employee can not be changed,僱員不能改變
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +257,You cannot credit and debit same account at the same time,你無法信用卡和借記同一賬戶在同一時間
DocType: Naming Series,Help HTML,HTML幫助
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +50,Total weightage assigned should be 100%. It is {0},分配的總權重應為100 ％ 。這是{0}
apps/erpnext/erpnext/controllers/status_updater.py +100,Allowance for over-{0} crossed for Item {1},備抵過{0}越過為項目{1}
DocType: Address,Name of person or organization that this address belongs to.,此地址所屬的人或組織的名稱。
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +536,Your Suppliers,您的供應商
apps/erpnext/erpnext/selling/doctype/quotation/quotation.py +62,Cannot set as Lost as Sales Order is made.,不能設置為失落的銷售訂單而成。
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +58,Another Salary Structure {0} is active for employee {1}. Please make its status 'Inactive' to proceed.,另外工資結構{0}激活員工{1}。請其狀態“無效”繼續。
DocType: Purchase Invoice,Contact,聯繫
DocType: Features Setup,Exports,出口
DocType: Lead,Converted,轉換
DocType: Item,Has Serial No,有序列號
DocType: Employee,Date of Issue,發行日期
apps/erpnext/erpnext/hr/doctype/expense_claim/expense_claim.py +16,{0}: From {0} for {1},{0}：從{0} {1}
DocType: Issue,Content Type,內容類型
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +16,Computer,電腦
DocType: Item,List this Item in multiple groups on the website.,列出這個項目在網站上多個組。
apps/erpnext/erpnext/manufacturing/doctype/bom/bom.py +62,Item: {0} does not exist in the system,項：{0}不存在於系統中
apps/erpnext/erpnext/accounts/doctype/account/account.py +63,You are not authorized to set Frozen value,您無權設定值凍結
DocType: Payment Reconciliation,Get Unreconciled Entries,獲取未調節項
DocType: Purchase Receipt,Date on which lorry started from supplier warehouse,日期從供應商的倉庫上貨車開始
DocType: Cost Center,Budgets,預算
apps/frappe/frappe/core/page/modules_setup/modules_setup.py +11,Updated,已更新
DocType: Employee,Emergency Contact Details,緊急聯繫方式
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +394,What does it do?,它有什麼作用？
DocType: Delivery Note,To Warehouse,到倉庫
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +56,Account {0} has been entered more than once for fiscal year {1},帳戶{0}已多次輸入會計年度{1}
,Average Commission Rate,平均佣金率
apps/erpnext/erpnext/stock/doctype/item/item.py +298,'Has Serial No' can not be 'Yes' for non-stock item,'有序列號'不能為'是'非庫存項目
apps/erpnext/erpnext/hr/doctype/attendance/attendance.py +34,Attendance can not be marked for future dates,考勤不能標記為未來的日期
DocType: Pricing Rule,Pricing Rule Help,定價規則說明
DocType: Purchase Taxes and Charges,Account Head,帳戶頭
DocType: Price List,"Specify a list of Territories, for which, this Price List is valid",指定領土的名單，為此，本價格表是有效的
apps/erpnext/erpnext/config/stock.py +79,Update additional costs to calculate landed cost of items,更新的額外成本來計算項目的到岸成本
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +106,Electrical,電子的
DocType: Stock Entry,Total Value Difference (Out - In),總價值差（輸出 - ）
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +94,Difference Account mandatory for purpose '{0}',差別賬戶強制性目標“{0}”
apps/erpnext/erpnext/setup/doctype/sales_person/sales_person.py +27,User ID not set for Employee {0},用戶ID不為員工設置{0}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +71,Peening,噴丸
apps/erpnext/erpnext/support/doctype/maintenance_visit/maintenance_visit.js +30,From Warranty Claim,從保修索賠
DocType: Stock Entry,Default Source Warehouse,默認信號源倉庫
DocType: Item,Customer Code,客戶代碼
apps/erpnext/erpnext/hr/doctype/employee/employee.py +203,Birthday Reminder for {0},生日提醒{0}
DocType: Item,Default Purchase Account in which cost of the item will be debited.,預設帳戶購買該項目的成本將被扣除。
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +162,Lapping,精研
apps/erpnext/erpnext/selling/report/customers_not_buying_since_long_time/customers_not_buying_since_long_time.js +8,Days Since Last Order,天自上次訂購
DocType: Buying Settings,Naming Series,命名系列
DocType: Leave Block List,Leave Block List Name,休假區塊清單名稱
DocType: User,Enabled,啟用
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +32,Stock Assets,庫存資產
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.js +22,Do you really want to Submit all Salary Slip for month {0} and year {1},難道你真的想要提交的所有{1}年{0}月的工資單
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +8,Import Subscribers,進口認購
DocType: Target Detail,Target Qty,目標數量
DocType: Attendance,Present,現在
apps/erpnext/erpnext/stock/doctype/packing_slip/packing_slip.py +35,Delivery Note {0} must not be submitted,送貨單{0}不能提交
DocType: Notification Control,Sales Invoice Message,銷售發票信息
DocType: Email Digest,Income Booked,收入預訂
DocType: Authorization Rule,Based On,基於
,Ordered Qty,訂購數量
DocType: Stock Settings,Stock Frozen Upto,股票凍結到...為止
apps/erpnext/erpnext/config/projects.py +13,Project activity / task.,專案活動／任務。
apps/erpnext/erpnext/config/hr.py +65,Generate Salary Slips,生成工資條
apps/frappe/frappe/utils/__init__.py +85,{0} is not a valid email id,{0}不是一個有效的電子郵件ID
apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +41,"Buying must be checked, if Applicable For is selected as {0}",採購必須進行檢查，如果適用於被選擇為{0}
apps/erpnext/erpnext/setup/doctype/authorization_rule/authorization_rule.py +40,Discount must be less than 100,折扣必須小於100
DocType: ToDo,Low,低
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +70,Spinning,紡織
DocType: Landed Cost Voucher,Landed Cost Voucher,到岸成本憑證
apps/erpnext/erpnext/hr/doctype/salary_manager/salary_manager.py +55,Please set {0},請設置{0}
DocType: Purchase Invoice,Repeat on Day of Month,在月內的一天重複
DocType: Employee,Health Details,健康細節
DocType: Offer Letter,Offer Letter Terms,報價函條款
DocType: Features Setup,To track any installation or commissioning related work after sales,跟踪銷售後的任何安裝或調試相關工作
DocType: Project,Estimated Costing,估計成本計算
DocType: Purchase Invoice Advance,Journal Entry Detail No,日記條目詳細說明暫無
DocType: Employee External Work History,Salary,薪水
DocType: Serial No,Delivery Document Type,交付文件類型
DocType: Salary Manager,Submit all salary slips for the above selected criteria,對上面選擇的條件提交所有工資單
apps/erpnext/erpnext/hub_node/doctype/hub_settings/hub_settings.py +93,{0} Items synced,{0}項目同步
DocType: Sales Order,Partly Delivered,部分交付
DocType: Sales Invoice,Existing Customer,現有客戶
DocType: Email Digest,Receivables,應收賬款
DocType: Quality Inspection Reading,Reading 5,閱讀5
DocType: Purchase Order,"Enter email id separated by commas, order will be mailed automatically on particular date",輸入電子郵件ID以逗號分隔，訂單將自動在特定日期郵寄
apps/erpnext/erpnext/crm/doctype/lead/lead.py +37,Campaign Name is required,活動名稱是必需的
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +120,Rounded Off,四捨五入
DocType: Maintenance Visit,Maintenance Date,維修日期
DocType: Purchase Receipt Item,Rejected Serial No,拒絕序列號
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +50,Deep drawing,深拉伸
apps/erpnext/erpnext/selling/doctype/sales_bom/sales_bom.js +13,"Please select Item where ""Is Stock Item"" is ""No"" and ""Is Sales Item"" is ""Yes"" and there is no other Sales BOM",請選擇項目，其中“是股票項目”是“否”和“是銷售項目”為“是” ，並沒有其他的銷售BOM
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.js +40,New Newsletter,新的通訊
apps/erpnext/erpnext/support/doctype/maintenance_schedule/maintenance_schedule.py +167,Start date should be less than end date for Item {0},項目{0}的開始日期必須小於結束日期
apps/erpnext/erpnext/stock/doctype/item/item.js +46,Show Balance,展會平衡
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: Upload Attendance,Upload Attendance,上傳出席
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +143,BOM and Manufacturing Quantity are required,BOM和生產量是必需的
apps/erpnext/erpnext/accounts/report/accounts_payable/accounts_payable.js +44,Ageing Range 2,老齡範圍2
DocType: Journal Entry Account,Amount,量
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +146,Riveting,鉚
apps/erpnext/erpnext/manufacturing/doctype/bom_replace_tool/bom_replace_tool.py +21,BOM replaced,BOM取代
,Sales Analytics,銷售分析
DocType: Manufacturing Settings,Manufacturing Settings,製造設置
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +85,Please enter default currency in Company Master,請在公司主輸入默認貨幣
DocType: Stock Entry Detail,Stock Entry Detail,庫存輸入明細
apps/erpnext/erpnext/templates/includes/cart.js +286,You need to be logged in to view your cart.,您需要登錄才能查看您的購物車。
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +200,New Account Name,新帳號名稱
DocType: Purchase Invoice Item,Raw Materials Supplied Cost,原料供應成本
DocType: Selling Settings,Settings for Selling Module,設置銷售模塊
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +68,Customer Service,顧客服務
DocType: Item Customer Detail,Item Customer Detail,項目客戶詳細
apps/erpnext/erpnext/config/hr.py +53,Offer candidate a Job.,報價候選作業。
DocType: Notification Control,Prompt for Email on Submission of,提示電子郵件的提交
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +61,Item {0} must be a stock Item,項{0}必須是一個缺貨登記
apps/erpnext/erpnext/config/accounts.py +102,Default settings for accounting transactions.,默認設置的會計事務。
apps/frappe/frappe/model/naming.py +40,{0} is required,{0}是必需的
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +20,Vacuum molding,真空成型
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +57,Expected Date cannot be before Material Request Date,消息大於160個字符將會被分成多個消息
DocType: Contact Us Settings,City,城市
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +131,Ultrasonic machining,超聲波加工
apps/erpnext/erpnext/stock/get_item_details.py +126,Item {0} must be a Sales Item,項{0}必須是一個銷售項目
DocType: Naming Series,Update Series Number,更新序列號
DocType: Account,Equity,公平
DocType: Task,Closing Date,截止日期
DocType: Sales Order Item,Produced Quantity,生產的產品數量
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +79,Engineer,工程師
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +329,Item Code required at Row No {0},於列{0}需要產品編號
DocType: Sales Partner,Partner Type,合作夥伴類型
DocType: Purchase Taxes and Charges,Actual,實際
DocType: Purchase Order,% of materials received against this Purchase Order,％的材料收到反對這個採購訂單
DocType: Authorization Rule,Customerwise Discount,Customerwise折扣
DocType: Purchase Invoice,Against Expense Account,對費用帳戶
DocType: Production Order,Production Order,生產訂單
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +242,Installation Note {0} has already been submitted,安裝注意{0}已提交
DocType: Quotation Item,Against Docname,對Docname
DocType: SMS Center,All Employee (Active),所有員工（活動）
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +9,View Now,立即觀看
DocType: Purchase Invoice,Select the period when the invoice will be generated automatically,選擇發票會自動生成期間
DocType: BOM,Raw Material Cost,原材料成本
DocType: Item Reorder,Re-Order Level,重新排序級別
DocType: Production Planning Tool,Enter items and planned qty for which you want to raise production orders or download raw materials for analysis.,輸入您想要提高生產訂單或下載的原材料進行分析的項目和計劃數量。
sites/assets/js/list.min.js +160,Gantt Chart,甘特圖
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +52,Part-time,兼任
DocType: Employee,Applicable Holiday List,適用假期表
DocType: Employee,Cheque,支票
apps/erpnext/erpnext/setup/doctype/naming_series/naming_series.py +52,Series Updated,系列更新
apps/erpnext/erpnext/accounts/doctype/account/account.py +105,Report Type is mandatory,報告類型是強制性的
DocType: Item,Serial Number Series,序列號系列
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +67,Warehouse is mandatory for stock Item {0} in row {1},倉庫是強制性的股票項目{0}行{1}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +44,Retail & Wholesale,零售及批發
DocType: Issue,First Responded On,首先作出回應
DocType: Website Item Group,Cross Listing of Item in multiple groups,在多組項目的交叉上市
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +349,The First User: You,第一個用戶：您
apps/erpnext/erpnext/accounts/doctype/fiscal_year/fiscal_year.py +48,Fiscal Year Start Date and Fiscal Year End Date are already set in Fiscal Year {0},會計年度開始日期和財政年度結束日期已經在財政年度設置{0}
apps/erpnext/erpnext/accounts/doctype/payment_reconciliation/payment_reconciliation.py +161,Successfully Reconciled,不甘心成功
DocType: Production Order,Planned End Date,計劃的結束日期
apps/erpnext/erpnext/config/stock.py +43,Where items are stored.,項目的存儲位置。
apps/erpnext/erpnext/accounts/report/accounts_receivable/accounts_receivable.html +19,Invoiced Amount,發票金額
DocType: Attendance,Attendance,出勤
DocType: Page,No,無
DocType: BOM,Materials,物料
DocType: Leave Block List,"If not checked, the list will have to be added to each Department where it has to be applied.",如果未選中，則列表將被添加到每個應被添加的部門。
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.js +663,Make Delivery,使交貨
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +261,Posting date and posting time is mandatory,發布日期和發布時間是必需的
apps/erpnext/erpnext/config/buying.py +79,Tax template for buying transactions.,稅務模板購買交易。
,Item Prices,產品價格
DocType: Purchase Order,In Words will be visible once you save the Purchase Order.,在詞將是可見的，一旦你保存採購訂單。
DocType: Period Closing Voucher,Period Closing Voucher,期末券
apps/erpnext/erpnext/config/stock.py +125,Price List master.,價格表師傅。
DocType: Task,Review Date,評論日期
DocType: DocPerm,Level,級別
DocType: Purchase Taxes and Charges,On Net Total,在總淨
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +176,Target warehouse in row {0} must be same as Production Order,行目標倉庫{0}必須與生產訂單
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +61,No permission to use Payment Tool,沒有權限使用支付工具
apps/erpnext/erpnext/controllers/recurring_document.py +191,'Notification Email Addresses' not specified for recurring %s,為重複％不是指定的“通知電子郵件地址”
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +85,Milling,磨
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +59,Nibbling,嗑
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +84,Administrative Expenses,行政開支
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/industry_type.py +17,Consulting,諮詢
DocType: Customer Group,Parent Customer Group,母公司集團客戶
sites/assets/js/erpnext.min.js +45,Change,變化
DocType: Purchase Invoice,Contact Email,聯絡電郵
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.py +103,Purchase Order {0} is 'Stopped',採購訂單{0}是「停止」的
DocType: Appraisal Goal,Score Earned,獲得得分
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +391,"e.g. ""My Company LLC""",例如“我的公司有限責任公司”
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +168,Notice Period,通知期
DocType: Bank Reconciliation Detail,Voucher ID,優惠券編號
apps/erpnext/erpnext/setup/doctype/territory/territory.js +14,This is a root territory and cannot be edited.,集團或Ledger ，借方或貸方，是特等帳戶
DocType: Packing Slip,Gross Weight UOM,毛重計量單位
DocType: Email Digest,Receivables / Payables,應收/應付賬款
DocType: Journal Entry Account,Against Sales Invoice,對銷售發票
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +62,Stamping,沖壓
DocType: Landed Cost Item,Landed Cost Item,到岸成本項目
apps/erpnext/erpnext/accounts/report/trial_balance/trial_balance.js +56,Show zero values,顯示零值
DocType: BOM,Quantity of item obtained after manufacturing / repacking from given quantities of raw materials,製造/從原材料數量給予重新包裝後獲得的項目數量
DocType: Payment Reconciliation,Receivable / Payable Account,應收/應付賬款
DocType: Delivery Note Item,Against Sales Order Item,對銷售訂單項目
DocType: Item,Default Warehouse,默認倉庫
DocType: Task,Actual End Date (via Time Logs),實際結束日期（通過時間日誌）
apps/erpnext/erpnext/accounts/doctype/cost_center/cost_center.py +20,Please enter parent cost center,請輸入父成本中心
DocType: Delivery Note,Print Without Amount,打印量不
apps/erpnext/erpnext/controllers/buying_controller.py +70,Tax Category can not be 'Valuation' or 'Valuation and Total' as all items are non-stock items,稅務類別不能為'估值'或'估值及總，因為所有的項目都是非庫存產品
DocType: User,Last Name,姓
DocType: Web Page,Left,左
DocType: Event,All Day,全日
DocType: Communication,Support Team,支持團隊
DocType: Appraisal,Total Score (Out of 5),總分（滿分5分）
DocType: Contact Us Settings,State,狀態
DocType: Batch,Batch,批量
apps/erpnext/erpnext/hr/report/employee_leave_balance/employee_leave_balance.py +48,Balance,平衡
DocType: Project,Total Expense Claim (via Expense Claims),總費用報銷（通過費用報銷）
DocType: User,Gender,性別
DocType: Journal Entry,Debit Note,繳費單
DocType: Stock Entry,As per Stock UOM,按庫存計量單位
apps/erpnext/erpnext/stock/doctype/batch/batch_list.js +7,Not Expired,沒有過期
DocType: Journal Entry,Total Debit,總借記
apps/erpnext/erpnext/accounts/report/gross_profit/gross_profit.py +70,Sales Person,銷售人員
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +496,Unstop Purchase Order,如果銷售BOM定義，該包的實際BOM顯示為表。
DocType: Sales Invoice,Cold Calling,自薦
DocType: SMS Parameter,SMS Parameter,短信參數
DocType: Maintenance Schedule Item,Half Yearly,半年度
DocType: Lead,Blog Subscriber,網誌訂閱者
DocType: Email Digest,Income Year to Date,收入年初至今
apps/erpnext/erpnext/config/setup.py +58,Create rules to restrict transactions based on values.,創建規則來限制基於價值的交易。
DocType: HR Settings,"If checked, Total no. of Working Days will include holidays, and this will reduce the value of Salary Per Day",如果選中，則總數。工作日將包括節假日，這將縮短每天的工資的價值
DocType: Purchase Invoice,Total Advance,總墊款
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +543,Unstop Material Request,Unstop材料要求
DocType: Workflow State,User,使用者
DocType: Opportunity Item,Basic Rate,基礎匯率
apps/erpnext/erpnext/crm/doctype/opportunity/opportunity.js +122,Set as Lost,設為失落
apps/erpnext/erpnext/stock/doctype/stock_uom_replace_utility/stock_uom_replace_utility.py +57,Stock balances updated,庫存餘額更新
DocType: Selling Settings,Maintain Same Rate Throughout Sales Cycle,保持同樣的速度在整個銷售週期
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +427,Cannot return more than {0} for Item {1},不能返回超過{0}的項目{1}
DocType: Manufacturing Settings,Plan time logs outside Workstation Working Hours.,規劃工作站工作時間以外的時間日誌。
apps/erpnext/erpnext/buying/doctype/purchase_common/purchase_common.py +91,{0} {1} has already been submitted,{0} {1}已經提交
,Items To Be Requested,項目要請求
DocType: Purchase Order,Get Last Purchase Rate,獲取最新預訂價
DocType: Company,Company Info,公司信息
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +75,Seaming,封罐
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +194,"Company Email ID not found, hence mail not sent",公司電子郵件ID沒有找到，因此郵件無法發送
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +9,Application of Funds (Assets),基金中的應用（資產）
DocType: Production Planning Tool,Filter based on item,根據項目篩選
DocType: Fiscal Year,Year Start Date,今年開始日期
DocType: Attendance,Employee Name,員工姓名
apps/erpnext/erpnext/accounts/doctype/sales_invoice/sales_invoice.py +241,Debit To account must be a liability account,借記帳戶必須是一個負債帳戶
DocType: Sales Invoice,Rounded Total (Company Currency),圓潤的總計（公司貨幣）
apps/erpnext/erpnext/accounts/doctype/account/account.py +89,Cannot covert to Group because Account Type is selected.,不能隱蔽到組，因為帳戶類型選擇的。
DocType: Purchase Common,Purchase Common,採購普通
apps/erpnext/erpnext/stock/doctype/material_request/material_request.py +93,{0} {1} has been modified. Please refresh.,{0} {1}已被修改。請刷新。
DocType: Leave Block List,Stop users from making Leave Applications on following days.,停止用戶在下面日期提出休假申請。
apps/erpnext/erpnext/selling/doctype/quotation/quotation.js +626,From Opportunity,從機會
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +45,Blanking,消隱
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +161,Employee Benefits,員工福利
DocType: Sales Invoice,Is POS,是POS機
apps/erpnext/erpnext/stock/doctype/delivery_note/delivery_note.py +224,Packed quantity must equal quantity for Item {0} in row {1},盒裝數量必須等於{1}列品項{0}的數量
DocType: Production Order,Manufactured Qty,生產數量
DocType: Purchase Receipt Item,Accepted Quantity,允收數量
apps/erpnext/erpnext/config/accounts.py +18,Bills raised to Customers.,客戶提出的賬單。
DocType: DocField,Default,默認
apps/erpnext/erpnext/projects/report/project_wise_stock_tracking/project_wise_stock_tracking.py +26,Project Id,項目編號
DocType: Item,"Selecting ""Yes"" will allow this item to appear in Purchase Order , Purchase Receipt.",選擇“是”將允許這個項目出現在採購訂單，採購入庫單。
apps/erpnext/erpnext/crm/doctype/newsletter_list/newsletter_list.py +41,{0} subscribers added,{0}新增用戶
DocType: Maintenance Schedule,Schedule,時間表
DocType: Account,Parent Account,父帳戶
DocType: Serial No,Available,可用的
DocType: Quality Inspection Reading,Reading 3,閱讀3
,Hub,樞紐
DocType: GL Entry,Voucher Type,憑證類型
DocType: Expense Claim,Approved,批准
DocType: Pricing Rule,Price,價格
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +79,Employee relieved on {0} must be set as 'Left',員工解除對{0}必須設置為“左”
DocType: Item,"Selecting ""Yes"" will give a unique identity to each entity of this item which can be viewed in the Serial No master.",選擇“Yes”將提供一個獨特的身份，以這個項目的每個實體可在序列號主觀看。
apps/erpnext/erpnext/hr/doctype/appraisal/appraisal.py +39,Appraisal {0} created for Employee {1} in the given date range,鑑定{0}為員工在給定日期範圍{1}創建
DocType: Employee,Education,教育
DocType: Selling Settings,Campaign Naming By,活動命名由
DocType: Employee,Current Address Is,當前地址是
DocType: Address,Office,辦公室
apps/frappe/frappe/desk/moduleview.py +67,Standard Reports,標準報告
apps/erpnext/erpnext/config/accounts.py +13,Accounting journal entries.,會計日記帳分錄。
apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +210,Please select Employee Record first.,請選擇員工記錄第一。
apps/erpnext/erpnext/accounts/page/accounts_browser/accounts_browser.js +35,To create a Tax Account,要創建一個納稅帳戶
apps/erpnext/erpnext/stock/doctype/stock_reconciliation/stock_reconciliation.py +227,Please enter Expense Account,請輸入您的費用帳戶
DocType: Account,Stock,庫存
DocType: Employee,Current Address,當前地址
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",如果項目是另一項目，然後描述，圖像，定價，稅費等會從模板中設置的一個變體，除非明確指定
DocType: Serial No,Purchase / Manufacture Details,採購／製造詳細信息
DocType: Employee,Contract End Date,合同結束日期
DocType: Sales Order,Track this Sales Order against any Project,跟踪對任何項目這個銷售訂單
apps/erpnext/erpnext/templates/includes/cart.js +284,Price List not configured.,沒有配置價格表。
DocType: Production Planning Tool,Pull sales orders (pending to deliver) based on the above criteria,基於上述標準拉銷售訂單（待定提供）
DocType: DocShare,Document Type,文件類型
apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +558,From Supplier Quotation,從供應商報價
DocType: Deduction Type,Deduction Type,扣類型
DocType: Attendance,Half Day,半天
DocType: Serial No,Not Available,不可用
DocType: Pricing Rule,Min Qty,最小數量
DocType: GL Entry,Transaction Date,交易日期
DocType: Production Plan Item,Planned Qty,計劃數量
apps/erpnext/erpnext/accounts/report/purchase_register/purchase_register.py +92,Total Tax,總稅收
DocType: Stock Entry,Default Target Warehouse,默認目標倉庫
DocType: Purchase Invoice,Net Total (Company Currency),總淨值（公司貨幣）
DocType: Notification Control,Purchase Receipt Message,外購入庫單信息
DocType: Production Order,Actual Start Date,實際開始日期
DocType: Sales Order,% of materials delivered against this Sales Order,針對這張銷售訂單的已交貨物料的百分比(%)
apps/erpnext/erpnext/config/stock.py +18,Record item movement.,記錄項目移動。
DocType: Newsletter List Subscriber,Newsletter List Subscriber,通訊訂戶名單
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +163,Morticing,Morticing
DocType: Email Account,Service,服務
DocType: Hub Settings,Hub Settings,中心設置
DocType: Project,Gross Margin %,毛利率％
DocType: BOM,With Operations,隨著運營
,Monthly Salary Register,月薪註冊
apps/frappe/frappe/website/template.py +120,Next,下一個
DocType: Warranty Claim,If different than customer address,如果與客戶地址不同
DocType: BOM Operation,BOM Operation,BOM的操作
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +117,Electropolishing,電解
DocType: Purchase Taxes and Charges,On Previous Row Amount,在上一行金額
DocType: Email Digest,New Delivery Notes,新交付票據
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +30,Please enter Payment Amount in atleast one row,請ATLEAST一行輸入付款金額
apps/erpnext/erpnext/templates/pages/tickets.py +34,Please write something in subject and message!,請寫東西的主題和消息！
apps/erpnext/erpnext/config/accounts.py +143,"Seasonality for setting budgets, targets etc.",季節性設置預算，目標等。
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.js +190,Row {0}: Payment Amount cannot be greater than Outstanding Amount,行{0}：付款金額不能大於傑出金額
apps/erpnext/erpnext/projects/doctype/time_log/time_log_list.js +21,Time Log is not billable,時間日誌是不計費
apps/erpnext/erpnext/stock/get_item_details.py +129,"Item {0} is a template, please select one of its variants",項目{0}是一個模板，請選擇它的一個變體
DocType: System Settings,Localization,本土化
apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.py +74,Net pay cannot be negative,淨工資不能為負
apps/erpnext/erpnext/accounts/doctype/payment_tool/payment_tool.py +70,Please enter the Against Vouchers manually,請手動輸入對優惠券
DocType: SMS Settings,Static Parameters,靜態參數
DocType: Purchase Order,Advance Paid,提前支付
DocType: Item,Item Tax,產品稅
DocType: Expense Claim,Employees Email Id,員工的電子郵件ID
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +159,Current Liabilities,流動負債
apps/erpnext/erpnext/config/crm.py +43,Send mass SMS to your contacts,發送群發短信到您的聯繫人
DocType: Purchase Taxes and Charges,Consider Tax or Charge for,考慮稅收或收費
apps/erpnext/erpnext/stock/doctype/stock_ledger_entry/stock_ledger_entry.py +53,Actual Qty is mandatory,實際數量是強制性
DocType: Item,"Select ""Yes"" if you are maintaining stock of this item in your Inventory.",選擇「是」，如果你正在維護倉庫內此品項的庫存。
apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.py +415,Item {0} does not exist in {1} {2},項目{0}不存在於{1} {2}
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +41,Cross-rolling,交叉軋製
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +127,Credit Card,信用卡
DocType: BOM,Item to be manufactured or repacked,產品被製造或重新包裝
apps/erpnext/erpnext/config/stock.py +95,Default settings for stock transactions.,默認設置為股票交易。
DocType: Purchase Invoice,Next Date,下一個日期
DocType: Employee Education,Major/Optional Subjects,大/選修課
apps/erpnext/erpnext/stock/doctype/landed_cost_voucher/landed_cost_voucher.py +49,Please enter Taxes and Charges,請輸入稅費
apps/erpnext/erpnext/setup/page/setup_wizard/fixtures/operations.py +84,Machining,加工
DocType: Employee,"Here you can maintain family details like name and occupation of parent, spouse and children",在這裡，您可以維繫家庭的詳細信息，如姓名的父母，配偶和子女及職業
DocType: Hub Settings,Seller Name,賣家名稱
DocType: Purchase Invoice,Taxes and Charges Deducted (Company Currency),稅收和扣除（公司貨幣）
DocType: Item Group,General Settings,常規設置
apps/erpnext/erpnext/setup/doctype/currency_exchange/currency_exchange.py +19,From Currency and To Currency cannot be same,原始貨幣和目標貨幣不能相同
DocType: Stock Entry,Repack,改裝
apps/erpnext/erpnext/setup/doctype/email_digest/email_digest.js +6,You must Save the form before proceeding,在繼續之前，您必須儲存表單
apps/erpnext/erpnext/setup/page/setup_wizard/setup_wizard.js +480,Attach Logo,附加標誌
DocType: Customer,Commission Rate,佣金率
apps/erpnext/erpnext/config/hr.py +145,Block leave applications by department.,按部門封鎖離開申請。
DocType: Production Order,Actual Operating Cost,實際運行成本
apps/erpnext/erpnext/accounts/doctype/account/account.py +55,Root cannot be edited.,root不能被編輯。
apps/erpnext/erpnext/accounts/utils.py +188,Allocated amount can not greater than unadusted amount,分配的金額不能超過未調整金額
DocType: Manufacturing Settings,Allow Production on Holidays,允許生產的假日
DocType: Sales Order,Customer's Purchase Order Date,客戶的採購訂單日期
apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +183,Capital Stock,股本
DocType: Packing Slip,Package Weight Details,包裝重量詳情
apps/erpnext/erpnext/hr/doctype/upload_attendance/upload_attendance.py +105,Please select a csv file,請選擇一個csv文件
apps/erpnext/erpnext/setup/page/setup_wizard/install_fixtures.py +89,Designer,設計師
apps/erpnext/erpnext/config/selling.py +116,Terms and Conditions Template,條款及細則範本
DocType: Serial No,Delivery Details,交貨細節
DocType: Party Type,Allow Children,允許兒童
apps/erpnext/erpnext/stock/doctype/purchase_receipt/purchase_receipt.py +362,Cost Center is required in row {0} in Taxes table for type {1},成本中心是必需的行{0}稅表型{1}
DocType: Purchase Invoice Item,Discount %,折扣％
,Item-wise Purchase Register,項目明智的購買登記
DocType: Batch,Expiry Date,到期時間
,Supplier Addresses and Contacts,供應商的地址和聯繫方式
apps/erpnext/erpnext/accounts/doctype/purchase_invoice/purchase_invoice.js +268,Please select Category first,請先選擇分類
apps/erpnext/erpnext/config/projects.py +18,Project master.,專案主持。
DocType: Global Defaults,Do not show any symbol like $ etc next to currencies.,不要顯示如$等任何貨幣符號。
DocType: Supplier,Credit Days,信貸天
DocType: Leave Type,Is Carry Forward,是弘揚
apps/erpnext/erpnext/stock/doctype/material_request/material_request.js +496,Get Items from BOM,獲取項目從物料清單
DocType: Item,Lead Time Days,交貨期天
DocType: Backup Manager,Send Notifications To,發送通知給
apps/erpnext/erpnext/accounts/report/bank_reconciliation_statement/bank_reconciliation_statement.html +26,Ref Date,參考日期
DocType: Employee,Reason for Leaving,離職原因
DocType: Expense Claim Detail,Sanctioned Amount,制裁金額
DocType: GL Entry,Is Opening,是開幕
apps/erpnext/erpnext/accounts/doctype/journal_entry/journal_entry.py +188,Row {0}: Debit entry can not be linked with a {1},行{0}：借記條目不能與連接的{1}
apps/erpnext/erpnext/accounts/doctype/account/account.py +160,Account {0} does not exist,帳戶{0}不存在
DocType: Account,Cash,現金
DocType: Employee,Short biography for website and other publications.,網站和其他出版物的短的傳記。
apps/erpnext/erpnext/hr/doctype/salary_slip/salary_slip.py +31,Please create Salary Structure for employee {0},請對{0}員工建立薪酬結構
