diff --git a/erpnext/translations/zh.csv b/erpnext/translations/zh.csv
index 9204112..4b32f8e 100644
--- a/erpnext/translations/zh.csv
+++ b/erpnext/translations/zh.csv
@@ -365,7 +365,7 @@
 apps/erpnext/erpnext/accounts/report/asset_depreciation_ledger/asset_depreciation_ledger.py +81,Amount After Depreciation,折旧金额后
 apps/erpnext/erpnext/setup/doctype/email_digest/templates/default.html +97,Upcoming Calendar Events,即将到来的日历事件
 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",请输入邮件地址列表，用英文逗号分割。发票在特定的日期会被自动发送。
+DocType: Purchase Invoice,"Enter Email Address separated by commas, invoice will be mailed automatically on particular date",请输入邮件地址列表，用英文逗号分割。发票在特定的日期会被自动发送。
 DocType: Employee,Company Email,企业邮箱
 DocType: GL Entry,Debit Amount in Account Currency,在账户币种借记金额
 apps/erpnext/erpnext/config/accounts.py +27,Bank/Cash transactions against party or for internal transfer,银行/现金对一方或内部转让交易
@@ -683,7 +683,7 @@
 apps/erpnext/erpnext/hr/doctype/salary_structure/salary_structure.js +368,Preview Salary Slip,预览工资单
 apps/erpnext/erpnext/accounts/doctype/budget/budget.py +53,Account {0} has been entered multiple times,帐户{0}已多次输入
 DocType: Account,Expenses Included In Valuation,开支计入估值
-DocType: Employee,Provide email id registered in company,提供的电子邮件ID在公司注册
+DocType: Employee,Provide Email Address registered in company,提供的电子邮件ID在公司注册
 DocType: Hub Settings,Seller City,卖家城市
 apps/erpnext/erpnext/schools/doctype/announcement/announcement.py +22,Please select a Student Group,请选择一个学生组
 ,Absent Student Report,缺席学生报告
@@ -1118,7 +1118,7 @@
 apps/erpnext/erpnext/setup/setup_wizard/install_fixtures.py +165,Blue,蓝色
 DocType: Purchase Invoice,Is Return,再来
 DocType: Price List Country,Price List Country,价目表国家
-apps/erpnext/erpnext/utilities/doctype/contact/contact.py +69,Please set Email ID,请设置电子邮件ID
+apps/erpnext/erpnext/utilities/doctype/contact/contact.py +69,Please set Email Address,请设置电子邮件ID
 DocType: Item,UOMs,计量单位
 apps/erpnext/erpnext/stock/utils.py +181,{0} valid serial nos for Item {1},品目{1}有{0}个有效序列号
 apps/erpnext/erpnext/stock/doctype/serial_no/serial_no.py +57,Item Code cannot be changed for Serial No.,品目编号不能因序列号改变
@@ -2208,7 +2208,7 @@
 DocType: Task Depends On,Task Depends On,任务取决于
 DocType: Supplier Quotation,Opportunity,机会
 ,Completed Production Orders,已完成生产订单
-apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,Row {0}: For supplier {0} email id is required to send email,行{0}：对于供应商{0}电子邮件ID需要发送电子邮件
+apps/erpnext/erpnext/buying/doctype/request_for_quotation/request_for_quotation.py +42,Row {0}: For supplier {0} Email Address is required to send email,行{0}：对于供应商{0}电子邮件ID需要发送电子邮件
 DocType: Operation,Default Workstation,默认工作台
 DocType: Notification Control,Expense Claim Approved Message,报销批准消息
 DocType: Payment Entry,Deductions or Loss,扣除或损失
@@ -3664,7 +3664,7 @@
 apps/erpnext/erpnext/hr/doctype/leave_application/leave_application.py +90,Application period cannot be across two alocation records,申请期间不能跨两个alocation记录
 DocType: Item Group,Default Expense Account,默认支出账户
 apps/erpnext/erpnext/schools/doctype/student_attendance/student_attendance.py +22,Student Batch or Course Schedule is mandatory,学生批处理或课程表是强制性
-DocType: Student,Student Email ID,学生的电子邮件ID
+DocType: Student,Student Email Address,学生的电子邮件ID
 DocType: Employee,Notice (days),通告（天）
 DocType: Tax Rule,Sales Tax Template,销售税模板
 apps/erpnext/erpnext/accounts/page/pos/pos.js +1626,Select items to save the invoice,选取要保存发票
@@ -3815,7 +3815,7 @@
 apps/erpnext/erpnext/selling/doctype/campaign/campaign.js +10,View Leads,查看信息
 DocType: Program Enrollment Tool,New Program,新程序
 DocType: Item Attribute Value,Attribute Value,属性值
-apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +42,"Email id must be unique, already exists for {0}",邮件地址{0}已存在
+apps/erpnext/erpnext/hr/doctype/job_applicant/job_applicant.py +42,"Email Address must be unique, already exists for {0}",邮件地址{0}已存在
 ,Itemwise Recommended Reorder Level,品目特定的推荐重订购级别
 DocType: Salary Detail,Salary Detail,薪酬详细
 apps/erpnext/erpnext/accounts/doctype/payment_entry/payment_entry.js +944,Please select {0} first,请选择{0}第一
@@ -4017,7 +4017,7 @@
 apps/erpnext/erpnext/config/projects.py +18,Project activity / task.,项目活动/任务。
 DocType: Vehicle Log,Refuelling Details,加油详情
 apps/erpnext/erpnext/config/hr.py +104,Generate Salary Slips,生成工资条
-apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email id,接着联系到不能等同于铅电子邮件ID
+apps/erpnext/erpnext/crm/doctype/lead/lead.py +44,Next Contact By cannot be same as the Lead Email Address,接着联系到不能等同于铅电子邮件ID
 apps/erpnext/erpnext/accounts/doctype/pricing_rule/pricing_rule.py +42,"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
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.py +106,Last purchase rate not found,最后购买率未找到
@@ -4313,7 +4313,7 @@
 DocType: Item,Item Tax,品目税项
 apps/erpnext/erpnext/buying/doctype/purchase_order/purchase_order.js +752,Material to Supplier,材料到供应商
 apps/erpnext/erpnext/stock/doctype/stock_entry/stock_entry.js +173,Excise Invoice,消费税发票
-DocType: Expense Claim,Employees Email Id,雇员的邮件地址
+DocType: Expense Claim,Employees Email Address,雇员的邮件地址
 DocType: Employee Attendance Tool,Marked Attendance,显着的出席
 apps/erpnext/erpnext/accounts/doctype/account/chart_of_accounts/verified/standard_chart_of_accounts.py +136,Current Liabilities,流动负债
 apps/erpnext/erpnext/config/selling.py +278,Send mass SMS to your contacts,向你的联系人群发短信。
