diff --git a/erpnext/accounts/page/accounts_browser/accounts_browser.js b/erpnext/accounts/page/accounts_browser/accounts_browser.js
index 222682e..ec906f8 100644
--- a/erpnext/accounts/page/accounts_browser/accounts_browser.js
+++ b/erpnext/accounts/page/accounts_browser/accounts_browser.js
@@ -232,7 +232,7 @@
 				$(fd.tax_rate.wrapper).toggle(false);
 				$(fd.warehouse.wrapper).toggle(false);
 			} else {
-				$(fd.account_type.wrapper).toggle(true);
+				$(fd.account_type.wrapper).toggle(node.root ? false : true);
 				fd.account_type.$input.trigger("change");
 			}
 		});
@@ -243,9 +243,6 @@
 			$(fd.warehouse.wrapper).toggle(fd.account_type.get_value()==='Warehouse');
 		})
 
-		// root type if root
-		$(fd.root_type.wrapper).toggle(node.root);
-
 		// create
 		d.set_primary_action(__("Create New"), function() {
 			var btn = this;
@@ -262,10 +259,10 @@
 			v.company = me.company;
 
 			if(node.root) {
-				v.is_root = true;
+				v.is_root = 1;
 				v.parent_account = null;
 			} else {
-				v.is_root = false;
+				v.is_root = 0;
 				v.root_type = null;
 			}
 
@@ -289,6 +286,11 @@
 		}
 
 		$(fd.is_group.input).prop("checked", false).change();
+		
+		// In case of root, show root type and hide account_type, is_group
+		$(fd.root_type.wrapper).toggle(node.root);
+		$(fd.is_group.wrapper).toggle(!node.root);
+		
 		d.show();
 	},
 
diff --git a/erpnext/accounts/report/accounts_payable/accounts_payable.html b/erpnext/accounts/report/accounts_payable/accounts_payable.html
index d3020b2..07f9e47 100644
--- a/erpnext/accounts/report/accounts_payable/accounts_payable.html
+++ b/erpnext/accounts/report/accounts_payable/accounts_payable.html
@@ -1 +1 @@
-{% include "accounts/report/accounts_receivable/accounts_receivable.html" %}
+{% include "erpnext/accounts/report/accounts_receivable/accounts_receivable.html" %}
diff --git a/erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.html b/erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.html
index d3020b2..07f9e47 100644
--- a/erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.html
+++ b/erpnext/accounts/report/accounts_payable_summary/accounts_payable_summary.html
@@ -1 +1 @@
-{% include "accounts/report/accounts_receivable/accounts_receivable.html" %}
+{% include "erpnext/accounts/report/accounts_receivable/accounts_receivable.html" %}
diff --git a/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.html b/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.html
index d3020b2..07f9e47 100644
--- a/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.html
+++ b/erpnext/accounts/report/accounts_receivable_summary/accounts_receivable_summary.html
@@ -1 +1 @@
-{% include "accounts/report/accounts_receivable/accounts_receivable.html" %}
+{% include "erpnext/accounts/report/accounts_receivable/accounts_receivable.html" %}
diff --git a/erpnext/accounts/report/balance_sheet/balance_sheet.html b/erpnext/accounts/report/balance_sheet/balance_sheet.html
index d4ae54d..14dc0a6 100644
--- a/erpnext/accounts/report/balance_sheet/balance_sheet.html
+++ b/erpnext/accounts/report/balance_sheet/balance_sheet.html
@@ -1 +1 @@
-{% include "accounts/report/financial_statements.html" %}
+{% include "erpnext/accounts/report/financial_statements.html" %}
diff --git a/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.html b/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.html
index d4ae54d..14dc0a6 100644
--- a/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.html
+++ b/erpnext/accounts/report/profit_and_loss_statement/profit_and_loss_statement.html
@@ -1 +1 @@
-{% include "accounts/report/financial_statements.html" %}
+{% include "erpnext/accounts/report/financial_statements.html" %}
diff --git a/erpnext/accounts/report/trial_balance/trial_balance.html b/erpnext/accounts/report/trial_balance/trial_balance.html
index d4ae54d..14dc0a6 100644
--- a/erpnext/accounts/report/trial_balance/trial_balance.html
+++ b/erpnext/accounts/report/trial_balance/trial_balance.html
@@ -1 +1 @@
-{% include "accounts/report/financial_statements.html" %}
+{% include "erpnext/accounts/report/financial_statements.html" %}
diff --git a/erpnext/accounts/utils.py b/erpnext/accounts/utils.py
index 48668fa..077fcb4 100644
--- a/erpnext/accounts/utils.py
+++ b/erpnext/accounts/utils.py
@@ -4,7 +4,7 @@
 from __future__ import unicode_literals
 
 import frappe
-from frappe.utils import nowdate, cstr, flt, now, getdate, add_months
+from frappe.utils import nowdate, cstr, flt, cint, now, getdate, add_months
 from frappe import throw, _
 from frappe.utils import formatdate
 import frappe.desk.reportview
@@ -129,12 +129,13 @@
 	if not args:
 		args = frappe.local.form_dict
 		args.pop("cmd")
-
+	
 	ac = frappe.new_doc("Account")
 	ac.update(args)
 	ac.old_parent = ""
 	ac.freeze_account = "No"
-	if ac.get("is_root"):
+	if cint(ac.get("is_root")):
+		ac.parent_account = None
 		ac.flags.ignore_mandatory = True
 	ac.insert()
 
diff --git a/erpnext/crm/doctype/opportunity/opportunity.py b/erpnext/crm/doctype/opportunity/opportunity.py
index 1aa1e67..b977e26 100644
--- a/erpnext/crm/doctype/opportunity/opportunity.py
+++ b/erpnext/crm/doctype/opportunity/opportunity.py
@@ -3,7 +3,7 @@
 
 from __future__ import unicode_literals
 import frappe, json
-from frappe.utils import cstr, cint
+from frappe.utils import cstr, cint, get_fullname
 from frappe import msgprint, _
 from frappe.model.mapper import get_mapped_doc
 from erpnext.setup.utils import get_exchange_rate
@@ -46,10 +46,20 @@
 		if not (self.lead or self.customer):
 			lead_name = frappe.db.get_value("Lead", {"email_id": self.contact_email})
 			if not lead_name:
+				sender_name = get_fullname(self.contact_email)
+				if sender_name == self.contact_email:
+					sender_name = None 
+				
+				account = ''
+				email_name = self.contact_email[0:self.contact_email.index('@')]
+				email_split = email_name.split('.')
+				for s in email_split:
+					account = account + s.capitalize() + ' '
+
 				lead = frappe.get_doc({
 					"doctype": "Lead",
 					"email_id": self.contact_email,
-					"lead_name": self.contact_email
+					"lead_name": sender_name or account
 				})
 				lead.insert(ignore_permissions=True)
 				lead_name = lead.name
diff --git a/erpnext/docs/user/manual/de/CRM/customer.md b/erpnext/docs/user/manual/de/CRM/customer.md
index e16504a..3ec4281 100644
--- a/erpnext/docs/user/manual/de/CRM/customer.md
+++ b/erpnext/docs/user/manual/de/CRM/customer.md
@@ -17,7 +17,7 @@
 
 Kontakte und Adressen werden in ERPNext getrennt gespeichert, damit Sie mehrere verschiedene Kontakte oder Adressen mit Kunden und Lieferanten verknüpfen können.
 
-Lesen Sie hierzu auch [Kontakt]({{docs_base_url}}/user/manual/en/crm/contact.html).
+Lesen Sie hierzu auch [Kontakt]({{docs_base_url}}/user/manual/de/CRM/contact.html).
 
 ### Einbindung in Konten
 
diff --git a/erpnext/docs/user/manual/de/CRM/setup/campaign.md b/erpnext/docs/user/manual/de/CRM/setup/campaign.md
index 9d070ff..c9b1ac8 100644
--- a/erpnext/docs/user/manual/de/CRM/setup/campaign.md
+++ b/erpnext/docs/user/manual/de/CRM/setup/campaign.md
@@ -5,7 +5,7 @@
 
 <img class="screenshot" alt="Kampagne" src="{{docs_base_url}}/assets/img/crm/campaign.png">
 
-Sie können in einer Kampagne [Leads]({{docs_base_url}}/user/manual/en/crm/lead.html), [Opportunities]({{docs_base_url}}/user/manual/en/crm/opportunity.html) und [Angebote]({{docs_base_url}}/user/manual/en/selling/quotation.html) nachverfolgen.
+Sie können in einer Kampagne [Leads]({{docs_base_url}}/user/manual/de/CRM/lead.html), [Opportunities]({{docs_base_url}}/user/manual/de/CRM/opportunity.html) und [Angebote]({{docs_base_url}}/user/manual/de/selling/quotation.html) nachverfolgen.
 
 ### Leads zu einer Kampagne nachverfolgen
 
diff --git a/erpnext/docs/user/manual/de/CRM/setup/index.md b/erpnext/docs/user/manual/de/CRM/setup/index.md
index 7a4110e..ebc9191 100644
--- a/erpnext/docs/user/manual/de/CRM/setup/index.md
+++ b/erpnext/docs/user/manual/de/CRM/setup/index.md
@@ -1,6 +1,6 @@
 # Einrichtung
 <span class="text-muted contributed-by">Beigetragen von CWT Connector & Wire Technology GmbH</span>
 
-Themen
+### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/accounts/index.md b/erpnext/docs/user/manual/de/accounts/index.md
index fedcd99..28c8a65 100644
--- a/erpnext/docs/user/manual/de/accounts/index.md
+++ b/erpnext/docs/user/manual/de/accounts/index.md
@@ -9,6 +9,6 @@
 * Eingangsrechnung: Rechnungen, die Sie von Ihren Lieferanten für deren Produkte oder Dienstleistungen erhalten.
 * Journalbuchungen / Buchungssätze: Für Buchungen wie Zahlung, Gutschrift und andere.
 
-#### Themen
+### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/accounts/making-payments.md b/erpnext/docs/user/manual/de/accounts/making-payments.md
index 550953d..0c2e041 100644
--- a/erpnext/docs/user/manual/de/accounts/making-payments.md
+++ b/erpnext/docs/user/manual/de/accounts/making-payments.md
@@ -3,13 +3,10 @@
 
 Zahlungen zu Ausgangs- oder Eingangsrechnungen können über die Schaltfläche "Zahlungsbuchung erstellen" zu übertragenen Rechnungen erfasst werden.
 
-1\. Aktualisieren Sie das Bankkonto (Sie können hier auch ein Standardkonto in den Unternehmensstammdaten einstellen).
-
-2\. Aktualiseren Sie das Veröffentlichungsdatum.
-
-3\. Geben Sie Schecknummer und Scheckdatum ein.
-
-4\. Speichern und Übertragen Sie.
+  1. Aktualisieren Sie das Bankkonto (Sie können hier auch ein Standardkonto in den Unternehmensstammdaten einstellen).
+  1. Aktualiseren Sie das Veröffentlichungsdatum.
+  1. Geben Sie Schecknummer und Scheckdatum ein.
+  1. Speichern und Übertragen Sie.
 
 <img class="screenshot" alt="Zahlungen durchführen" src="{{docs_base_url}}/assets/img/accounts/make-payment.png">
 
diff --git a/erpnext/docs/user/manual/de/accounts/opening-entry.md b/erpnext/docs/user/manual/de/accounts/opening-entry.md
index b3d7718..8195faf 100644
--- a/erpnext/docs/user/manual/de/accounts/opening-entry.md
+++ b/erpnext/docs/user/manual/de/accounts/opening-entry.md
@@ -3,6 +3,6 @@
 
 Wenn Sie eine neue Firma erstellen, dann können Sie das ERPNext-Modul Rechnungswesen starten, indem Sie in den Kontenplan gehen.
 
-Wenn Sie aber von einem reinen Buchhaltungsprogramm wie Tally oder einer FoxPro-basieren Software migrieren, dann lesen Sie unter [Eröffnungsbilanz]({{docs_base_url}}/user/manual/en/accounts/opening-accounts.html) nach.
+Wenn Sie aber von einem reinen Buchhaltungsprogramm wie Tally oder einer FoxPro-basieren Software migrieren, dann lesen Sie unter [Eröffnungsbilanz]({{docs_base_url}}/user/manual/de/accounts/opening-accounts.html) nach.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/accounts/point-of-sales-invoice.md b/erpnext/docs/user/manual/de/accounts/point-of-sales-invoice.md
index 5cbc382..d64e272 100644
--- a/erpnext/docs/user/manual/de/accounts/point-of-sales-invoice.md
+++ b/erpnext/docs/user/manual/de/accounts/point-of-sales-invoice.md
@@ -11,9 +11,8 @@
 
 In ERPNext können über den POS alle Verkaufs- und Einkaufstransaktionen, wie Ausgangsrechnung, Angebot, Kundenauftrag, Lieferantenauftrag, usw. bearbeitet werden. Über folgende zwei Schritte richten Sie den POS ein:
 
-1\. Aktivieren Sie die POS-Ansicht über Einstellungen > Anpassen > Funktionseinstellungen
-
-2\. Erstellen Sie einen Datensatz für die [POS-Einstellungen]({{docs_base_url}}/user/manual/en/setting-up/pos-setting.html)
+1. Aktivieren Sie die POS-Ansicht über Einstellungen > Anpassen > Funktionseinstellungen
+2. Erstellen Sie einen Datensatz für die [POS-Einstellungen]({{docs_base_url}}/user/manual/de/setting-up/pos-setting.html)
 
 #### Auf die POS-Ansicht umschalten
 
@@ -57,17 +56,15 @@
 
 Wenn alle Artikel mit Mengenangabe im Einkaufswagen hinzugefügt wurden, können Sie die Zahlung durchführen. Der Zahlungsprozess untergliedert sich in drei Schritte:
 
-1\. Klicken Sie auf "Zahlung durchführen" um das Zahlungsfenster zu öffnen.
-
-2\. Wählen Sie die Zahlungsart aus.
-
-3\. Klicken Sie auf die Schaltfläche "Zahlen" um das Dokument abzuspeichern.
+1. Klicken Sie auf "Zahlung durchführen" um das Zahlungsfenster zu öffnen.
+2. Wählen Sie die Zahlungsart aus.
+3. Klicken Sie auf die Schaltfläche "Zahlen" um das Dokument abzuspeichern.
 
 ![POS-Zahlung]({{docs_base_url}}/assets/old_images/erpnext/pos-make-payment.png)
 
 Übertragen Sie das Dokument um den Datensatz abzuschliessen. Nachdem das Dokument übertragen wurde, können Sie es entweder ausdrucken oder per E-Mail versenden.
 
-#### Buchungssätze (Hauptbuch) für einen POS:
+#### Buchungssätze (Hauptbuch) für einen POS
 
 Soll:
 
diff --git a/erpnext/docs/user/manual/de/accounts/setup/index.txt b/erpnext/docs/user/manual/de/accounts/setup/index.txt
index 439c184..f59526c 100644
--- a/erpnext/docs/user/manual/de/accounts/setup/index.txt
+++ b/erpnext/docs/user/manual/de/accounts/setup/index.txt
@@ -1,4 +1,3 @@
-
 fiscal-year
 cost-center
 accounts-settings
diff --git a/erpnext/docs/user/manual/de/accounts/setup/tax-rule.md b/erpnext/docs/user/manual/de/accounts/setup/tax-rule.md
index 0e1d00d..73d4907 100644
--- a/erpnext/docs/user/manual/de/accounts/setup/tax-rule.md
+++ b/erpnext/docs/user/manual/de/accounts/setup/tax-rule.md
@@ -1,7 +1,7 @@
 # Steuerregeln
 <span class="text-muted contributed-by">Beigetragen von CWT Connector & Wire Technology GmbH</span>
 
-Sie können festlegen, welche [Steuervorlage]({{docs_base_url}}/user/manual/en/setting-up/setting-up-taxes.html) auf eine Verkaufs-/Einkaufstransaktion angewendet wird, wenn Sie die Funktion Steuerregel verwenden.
+Sie können festlegen, welche [Steuervorlage]({{docs_base_url}}/user/manual/de/setting-up/setting-up-taxes.html) auf eine Verkaufs-/Einkaufstransaktion angewendet wird, wenn Sie die Funktion Steuerregel verwenden.
 
 <img class="screenshot" alt="Steuerregel" src="{{docs_base_url}}/assets/img/accounts/tax-rule.png">
 
diff --git a/erpnext/docs/user/manual/de/buying/index.md b/erpnext/docs/user/manual/de/buying/index.md
index 4d18d59..c5bdd04 100644
--- a/erpnext/docs/user/manual/de/buying/index.md
+++ b/erpnext/docs/user/manual/de/buying/index.md
@@ -7,6 +7,6 @@
 
 ERPNext beinhaltet einen Satz an Transaktionen, die Ihren Einkaufprozess so effektiv und störungsfrei machen, wie nur möglich.
 
-### Topics
+### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/buying/setup/buying-settings.md b/erpnext/docs/user/manual/de/buying/setup/buying-settings.md
index 863e208..e6f0d97 100644
--- a/erpnext/docs/user/manual/de/buying/setup/buying-settings.md
+++ b/erpnext/docs/user/manual/de/buying/setup/buying-settings.md
@@ -17,7 +17,7 @@
 
 > Einstellungen > Einstellungen > Nummernkreis
 
-[Klicken Sie hier, wenn Sie mehr über Nummernkreise wissen möchten]({{docs_base_url}}/user/manual/en/setting-up/settings/naming-series.html)
+[Klicken Sie hier, wenn Sie mehr über Nummernkreise wissen möchten]({{docs_base_url}}/user/manual/de/setting-up/settings/naming-series.html)
 
 ### 2. Standard-Lieferantentyp
 
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/custom-doctype.md b/erpnext/docs/user/manual/de/customize-erpnext/custom-doctype.md
index 1e33282..01bfaa7 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/custom-doctype.md
+++ b/erpnext/docs/user/manual/de/customize-erpnext/custom-doctype.md
@@ -11,15 +11,11 @@
 
 ### Einzelheiten zum DocType
 
-1\. Modul: Wählen Sie das Modul aus, in dem dieser DocType verwendet wird.
-
-2\. Dokumententyp: Geben Sie an, ob dieser DocType Hauptdaten befördern oder Transaktionen nachverfolgen soll. Der DocType für das Buch wird als Vorlage hinzugefügt.
-
-3\. Ist Untertabelle: Wenn dieser DocType als Tabelle in einen anderen DocType eingefügt wird, wie die Artikeltabelle in den DocType Kundenauftrag, dann sollten Sie auch "Ist Untertabelle" ankreuzen. Ansonsten nicht.
-
-4\. Ist einzeln: Wenn diese Option aktiviert ist, wird dieser DocType zu einem einzeln verwendeten Formular, wie die Vertriebseinstellungen, die nicht von Benutzern reproduziert werden können.
-
-5\. Benutzerdefiniert?: Dieses Feld ist standardmäßig aktiviert, wenn ein benutzerdefinierter DocType hinzugefügt wird.
+1. Modul: Wählen Sie das Modul aus, in dem dieser DocType verwendet wird.
+2. Dokumententyp: Geben Sie an, ob dieser DocType Hauptdaten befördern oder Transaktionen nachverfolgen soll. Der DocType für das Buch wird als Vorlage hinzugefügt.
+3. Ist Untertabelle: Wenn dieser DocType als Tabelle in einen anderen DocType eingefügt wird, wie die Artikeltabelle in den DocType Kundenauftrag, dann sollten Sie auch "Ist Untertabelle" ankreuzen. Ansonsten nicht.
+4. Ist einzeln: Wenn diese Option aktiviert ist, wird dieser DocType zu einem einzeln verwendeten Formular, wie die Vertriebseinstellungen, die nicht von Benutzern reproduziert werden können.
+5. Benutzerdefiniert?: Dieses Feld ist standardmäßig aktiviert, wenn ein benutzerdefinierter DocType hinzugefügt wird.
 
 ![Grundlagen zum Doctype]({{docs_base_url}}/assets/img/setup/customize/doctype-basics.png)
 
@@ -29,17 +25,12 @@
 
 Felder sind viel mehr als Datenbankspalten; sie können sein:
 
-1\. Spalten in der Datenbank
-
-2\. Wichtig für das Layout (Bereiche, Spaltentrennung)
-
-3\. Untertabellen (Feld vom Typ Tabelle)
-
-4\. HTML
-
-5\. Aktionen (Schaltflächen)
-
-6\. Anhänge oder Bilder
+1. Spalten in der Datenbank
+2. Wichtig für das Layout (Bereiche, Spaltentrennung)
+3. Untertabellen (Feld vom Typ Tabelle)
+4. HTML
+5. Aktionen (Schaltflächen)
+6. Anhänge oder Bilder
 
 ![Felder im DocType]({{docs_base_url}}/assets/img/setup/customize/Doctype-all-fields.png)
 
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/custom-field.md b/erpnext/docs/user/manual/de/customize-erpnext/custom-field.md
index efd5980..c3bec3f 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/custom-field.md
+++ b/erpnext/docs/user/manual/de/customize-erpnext/custom-field.md
@@ -64,17 +64,12 @@
 
 Sie können weitere Eigenschaften auswählen wie:
 
-1\. Ist Pflichtfeld: Ist das Feld zwingend erforderlich oder nicht?
-
-2\. Beim Drucken verbergen: Soll dieses Feld beim Ausdruck sichtbar sein oder nicht?
-
-3\. Feldbeschreibung: Hier steht eine kurze Beschreibung des Feldes die gleich unter dem Feld erscheint.
-
-4\. Standardwert: Der Wert in diesem Feld wird automatisch aktualisiert.
-
-5\. Schreibgeschützt: Wenn diese Option aktiviert ist, kann das benutzerdefinierte Feld nicht geändert werden.
-
-6\. Beim Übertragen zulassen: Wenn diese Option ausgewählt wird, ist es erlaubt den Wert des Feldes zu ändern, wenn er in einer Transaktion übertragen wird.
+1. Ist Pflichtfeld: Ist das Feld zwingend erforderlich oder nicht?
+2. Beim Drucken verbergen: Soll dieses Feld beim Ausdruck sichtbar sein oder nicht?
+3. Feldbeschreibung: Hier steht eine kurze Beschreibung des Feldes die gleich unter dem Feld erscheint.
+4. Standardwert: Der Wert in diesem Feld wird automatisch aktualisiert.
+5. Schreibgeschützt: Wenn diese Option aktiviert ist, kann das benutzerdefinierte Feld nicht geändert werden.
+6. Beim Übertragen zulassen: Wenn diese Option ausgewählt wird, ist es erlaubt den Wert des Feldes zu ändern, wenn er in einer Transaktion übertragen wird.
 
 ![Eigenschaften von benutzerdefinierten Feldern]({{docs_base_url}}/assets/old_images/erpnext/custom-field-properties.png)
 
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md b/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
index 36f7894..c4e41ec 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
+++ b/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/custom-script-fetch-values-from-master.md
@@ -5,7 +5,7 @@
 
 > add_fetch(link_fieldname, source_fieldname, target_fieldname)
 
-### Beispiel:
+### Beispiel
 
 Sie erstellen ein benutzerdefiniertes Feld **VAT ID** (vat_id) unter **Kunde** und **Ausgangsrechnung** und Sie möchten sicher stellen, dass dieser Wert immer aktualisiert wird, wenn Sie einen Kunden oder eine Ausgangsrechnung aufrufen.
 
@@ -15,6 +15,6 @@
 
 * * *
 
-Sehen Sie hierzu auch: [Wie man ein benutzerdefiniertes Skript erstellt]({{docs_base_url}}/user/manual/en/customize-erpnext/custom-scripts.html).
+Sehen Sie hierzu auch: [Wie man ein benutzerdefiniertes Skript erstellt]({{docs_base_url}}/user/manual/de/customize-erpnext/custom-scripts/).
 
 {next}
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/index.md b/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/index.md
index 35cc4f7..43770ef 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/index.md
+++ b/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/custom-script-examples/index.md
@@ -5,20 +5,17 @@
 
 Sie erstellen ein benutzerdefiniertes Skript wie folgt (Sie müssen dafür Systemadministrator sein!):
 
-1\. Gehen Sie zu: Einstellungen > Benutzerdefiniertes Skript > Neu
-
-2\. Wählen Sie den DocType, in dem Sie ein benutzerdefiniertes Skript hinzufügen möchten, aus.
+1. Gehen Sie zu: Einstellungen > Benutzerdefiniertes Skript > Neu
+2. Wählen Sie den DocType, in dem Sie ein benutzerdefiniertes Skript hinzufügen möchten, aus.
 
 * * *
 
-### Anmerkungen:
+### Anmerkungen
 
-1\. Auf benutzerdefinierte Skripte für Server kann nur der Administrator zugreifen.
+1. Auf benutzerdefinierte Skripte für Server kann nur der Administrator zugreifen.
+2. Benutzerdefinierte Skripte für Clients werden in Javascript geschrieben, die für Server in Python.
+3. Zum Testen gehen Sie auf Werkzeuge > Cache leeren und laden Sie die Seite neu, wenn Sie ein benutzerdefiniertes Skript aktualisieren.
 
-2\. Benutzerdefinierte Skripte für Clients werden in Javascript geschrieben, die für Server in Python.
-
-3\. Zum Testen gehen Sie auf Werkzeuge > Cache leeren und laden Sie die Seite neu, wenn Sie ein benutzerdefiniertes Skript aktualisieren.
-
-### Themen:
+### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/index.md b/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/index.md
index a4ad75a..8e2e842 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/index.md
+++ b/erpnext/docs/user/manual/de/customize-erpnext/custom-scripts/index.md
@@ -5,6 +5,8 @@
 
 > Einstellungen > Anpassen > Benutzerdefiniertes Skript
 
+<img alt="Custom Script" class="screenshot" src="{{docs_base_url}}/assets/img/customize/custom-script-1.png">
+
 ### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/document-title.md b/erpnext/docs/user/manual/de/customize-erpnext/document-title.md
index 4ab5154..3b13208 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/document-title.md
+++ b/erpnext/docs/user/manual/de/customize-erpnext/document-title.md
@@ -13,11 +13,9 @@
 
 Um eine Standard-Bezeichnung einzufügen, gehen Sie zu:
 
-1\. Einstellungen > Anpassen > Formular anpassen
-
-2\. Wählen Sie Ihre Transaktion aus
-
-3\. Bearbeiten Sie das Feld "Standard" in Ihrem Formular
+1. Einstellungen > Anpassen > Formular anpassen
+2. Wählen Sie Ihre Transaktion aus
+3. Bearbeiten Sie das Feld "Standard" in Ihrem Formular
 
 ### Bezeichnungen definieren
 
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/index.txt b/erpnext/docs/user/manual/de/customize-erpnext/index.txt
index 1113395..bf6d52e 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/index.txt
+++ b/erpnext/docs/user/manual/de/customize-erpnext/index.txt
@@ -5,4 +5,4 @@
 document-title
 hiding-modules-and-features
 print-format
-articles
+custom-scripts
diff --git a/erpnext/docs/user/manual/de/customize-erpnext/print-format.md b/erpnext/docs/user/manual/de/customize-erpnext/print-format.md
index ca6c771..85b1589 100644
--- a/erpnext/docs/user/manual/de/customize-erpnext/print-format.md
+++ b/erpnext/docs/user/manual/de/customize-erpnext/print-format.md
@@ -14,7 +14,7 @@
 
 > Einstellungen > Druck > Druckformate
 
-![Druckformat]({{docs_base_url}}/assets/old_images/erpnext/customize/print-format.png)
+![Druckformat]({{docs_base_url}}/assets/img/customize/print-settings.png)
 
 Wählen Sie den Typ des Druckformats, welches Sie bearbeiten wollen, und klicken Sie auf die Schaltfläche "Kopieren" in der rechten Spalte. Es öffnet sich ein neues Druckformat mit der Einstellung NEIN für "für "Ist Standard" und Sie kännen das Druckformat bearbeiten.
 
@@ -26,11 +26,10 @@
 
 > Anmerkung: Vorgedrucktes Briefpapier zu verwenden ist normalerweise keine gute Idee, weil Ihre Ausdrucke unfertig (inkonsistent) aussehen, wenn Sie per E-mail verschickt werden.
 
-### Referenzen:
+### Referenzen
 
-1\. [Programmiersprache Jinja Templating: Referenz](http://jinja.pocoo.org/docs/templates/)
-
-2\. [Bootstrap CSS Framework](http://getbootstrap.com/)
+1. [Programmiersprache Jinja Templating: Referenz](http://jinja.pocoo.org/docs/templates/)
+1. [Bootstrap CSS Framework](http://getbootstrap.com/)
 
 ### Druckeinstellungen
 
@@ -38,9 +37,9 @@
 
 > Einstellungen > Druck und Branding > Druckeinstellungen
 
-![Druckformat]({{docs_base_url}}/assets/old_images/erpnext/customize/print-settings.png)
+![Druckformat]({{docs_base_url}}/assets/img/customize/print-settings.png)
 
-### Beispiel:
+### Beispiel
 
 <h3>{{ doc.select<em>print</em>heading or "Invoice" }}</h3>
     <div class="row">
@@ -84,9 +83,8 @@
 
 ### Anmerkungen
 
-1\. Um nach Datum und Währung formatiert Werte zu erhalten, verwenden Sie: `doc.get_formatted("fieldname")`
-
-2\. Für übersetzbare Zeichenfolgen verwenden Sie: `{{ _("This string is translated") }}`
+1. Um nach Datum und Währung formatiert Werte zu erhalten, verwenden Sie: `doc.get_formatted("fieldname")`
+1. Für übersetzbare Zeichenfolgen verwenden Sie: `{{ _("This string is translated") }}`
 
 ### Fußzeilen
 
diff --git a/erpnext/docs/user/manual/de/human-resources/attendance.md b/erpnext/docs/user/manual/de/human-resources/attendance.md
index a889cd8..9dd45ab 100644
--- a/erpnext/docs/user/manual/de/human-resources/attendance.md
+++ b/erpnext/docs/user/manual/de/human-resources/attendance.md
@@ -9,6 +9,6 @@
 
 Sie können einen monatlichen Report über Ihre Anwesenheiten erhalten, indem Sie zum "Monatlichen Anwesenheitsbericht" gehen.
 
-Sie können auch ganz einfach Anwesenheiten über das [Werkzeug zum Hochladen von Anwesenheiten]({{docs_base_url}}/user/manual/en/human-resources/tools/upload-attendance.html) hochladen.
+Sie können auch ganz einfach Anwesenheiten über das [Werkzeug zum Hochladen von Anwesenheiten]({{docs_base_url}}/user/manual/de/human-resources/tools/upload-attendance.html) hochladen.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/human-resources/job-applicant.md b/erpnext/docs/user/manual/de/human-resources/job-applicant.md
index 92819e8..51b0359 100644
--- a/erpnext/docs/user/manual/de/human-resources/job-applicant.md
+++ b/erpnext/docs/user/manual/de/human-resources/job-applicant.md
@@ -1,7 +1,7 @@
 # Bewerber
 <span class="text-muted contributed-by">Beigetragen von CWT Connector & Wire Technology GmbH</span>
 
-Sie können eine Liste von Bewerbern auf [offene Stellen]({{docs_base_url}}/user/manual/en/human-resources/job-opening.html) verwalten.
+Sie können eine Liste von Bewerbern auf [offene Stellen]({{docs_base_url}}/user/manual/de/human-resources/job-opening.html) verwalten.
 
 Um einen neuen Bewerber anzulegen, gehen Sie zu:
 
diff --git a/erpnext/docs/user/manual/de/human-resources/leave-application.md b/erpnext/docs/user/manual/de/human-resources/leave-application.md
index 0f28e6f..fc16d83 100644
--- a/erpnext/docs/user/manual/de/human-resources/leave-application.md
+++ b/erpnext/docs/user/manual/de/human-resources/leave-application.md
@@ -14,8 +14,8 @@
 
 <img class="screenshot" alt="Urlaubsgenehmiger" src="{{docs_base_url}}/assets/img/human-resources/employee-leave-approver.png">
 
-> Tipp: Wenn Sie möchten, dass alle Benutzer ihre Urlaubsanträge selbst erstellen, können Sie in den Einstellungen zur Urlaubsgenehmigung Ihre Mitarbeiter-IDs als so einstellen, dass sie für die Regel zutreffend sind. Für weiterführende Informationen kesen Sie hierzu die Diskussion zum Thema [Einstellungen zu Genehmigungen]({{docs_base_url}}/user/manual/en/setting-up/users-and-permissions.html).
+> Tipp: Wenn Sie möchten, dass alle Benutzer ihre Urlaubsanträge selbst erstellen, können Sie in den Einstellungen zur Urlaubsgenehmigung Ihre Mitarbeiter-IDs als so einstellen, dass sie für die Regel zutreffend sind. Für weiterführende Informationen kesen Sie hierzu die Diskussion zum Thema [Einstellungen zu Genehmigungen]({{docs_base_url}}/user/manual/de/setting-up/users-and-permissions/user-permissions.html).
 
-Um einem Mitarbeiter Urlaub zuzuteilen, kreuzen Sie [Urlaubszuteilung]({{docs_base_url}}/user/manual/en/human-resources/setup/leave-allocation.html) an.
+Um einem Mitarbeiter Urlaub zuzuteilen, kreuzen Sie [Urlaubszuteilung]({{docs_base_url}}/user/manual/de/human-resources/setup/leave-allocation.html) an.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/human-resources/offer-letter.md b/erpnext/docs/user/manual/de/human-resources/offer-letter.md
index 562b24c..5566071 100644
--- a/erpnext/docs/user/manual/de/human-resources/offer-letter.md
+++ b/erpnext/docs/user/manual/de/human-resources/offer-letter.md
@@ -9,7 +9,7 @@
 
 <img class="screenshot" alt="Angebotsschreiben" src="{{docs_base_url}}/assets/img/human-resources/offer-letter.png">
 
-> Anmerkung: Angebotsschreiben kann nur zu einem [Bewerber]({{docs_base_url}}/user/manual/en/human-resources/job-applicant.html) erstellt werden.
+> Anmerkung: Angebotsschreiben kann nur zu einem [Bewerber]({{docs_base_url}}/user/manual/de/human-resources/job-applicant.html) erstellt werden.
 
 Es gibt ein vordefiniertes Druckformat zum Angebotsschreiben.
 
diff --git a/erpnext/docs/user/manual/de/human-resources/salary-and-payroll.md b/erpnext/docs/user/manual/de/human-resources/salary-and-payroll.md
index 5d7eb61..a8eb33a 100644
--- a/erpnext/docs/user/manual/de/human-resources/salary-and-payroll.md
+++ b/erpnext/docs/user/manual/de/human-resources/salary-and-payroll.md
@@ -7,11 +7,9 @@
 
 Um in ERPNext eine Gehaltsabrechnung durchzuführen
 
-1\. Erstellen Sie Gehaltsstrukturen für alle Arbeitnehmer.
-
-2\. Erstellen Sie über den Prozess Gehaltsabrechnung Gehaltsabrechnungen.
-
-3\. Buchen Sie das Gehalt in Ihren Konten.
+1. Erstellen Sie Gehaltsstrukturen für alle Arbeitnehmer.
+2. Erstellen Sie über den Prozess Gehaltsabrechnung Gehaltsabrechnungen.
+3. Buchen Sie das Gehalt in Ihren Konten.
 
 ### Gehaltsstruktur
 
@@ -19,11 +17,9 @@
 
 Gehaltsstrukturen werden verwendet um Organisationen zu helfen
 
-1\. Gehaltslevel zu erhalten, die am Markt wettbewerbsfähig sind.
-
-2\. Ein ausgeglichenes Verhältnis zwischen den Entlohnungen intern anfallender Jobs zu erreichen.
-
-3\. Unterschiede in den Ebenen von Verwantwortung, Begabungen und Leistungen zu erkennen und entsprechend zu vergüten und Gehaltserhöhungen zu verwalten.
+1. Gehaltslevel zu erhalten, die am Markt wettbewerbsfähig sind.
+2. Ein ausgeglichenes Verhältnis zwischen den Entlohnungen intern anfallender Jobs zu erreichen.
+3. Unterschiede in den Ebenen von Verwantwortung, Begabungen und Leistungen zu erkennen und entsprechend zu vergüten und Gehaltserhöhungen zu verwalten.
 
 Eine Gehaltsstruktur kann folgende Komponenten enthalten:
 
@@ -83,15 +79,11 @@
 
 Beim Bearbeiten einer Gehaltsabrechnung
 
-1\. Wählen Sie die Firma, für die Sie Gehaltsabrechnungen erstellen wollen.
-
-2\. Wählen Sie den ensprechenden Monat und das Jahr.
-
-3\. Klicken Sie auf "Gehaltsabrechnung erstellen". Hierdurch werden für jeden aktiven Mitarbeiter für den gewählten Monat Datensätze für die Gehaltsabrechnung angelegt. Wenn die Gehaltsabrechnungen einmal angelegt sind, erstellt das System keine weiteren Gehaltsabrechnungen. Alle Aktualisierungen werden im Bereich "Aktivitätsprotokoll" angezeigt.
-
-4\. Wenn alle Gehaltsabrechnungen erstellt wurden, können Sie prüfen, ob Sie richtig sind, und sie bearbeiten, wenn Sie unbezahlten Urlaub abziehen wollen.
-
-5\. Wenn Sie das geprüft haben, können Sie sie alle gemeinsam "übertragen" indem Sie auf die Schaltfläche "Gehaltsabrechnung übertragen" klicken. Wenn Sie möchten, dass Sie automatisch per E-Mail an einen Mitarbeiter verschickt werden, stellen Sie sicher, dass Sie die Option "E-Mail absenden" angeklickt haben.
+1. Wählen Sie die Firma, für die Sie Gehaltsabrechnungen erstellen wollen.
+2. Wählen Sie den ensprechenden Monat und das Jahr.
+3. Klicken Sie auf "Gehaltsabrechnung erstellen". Hierdurch werden für jeden aktiven Mitarbeiter für den gewählten Monat Datensätze für die Gehaltsabrechnung angelegt. Wenn die Gehaltsabrechnungen einmal angelegt sind, erstellt das System keine weiteren Gehaltsabrechnungen. Alle Aktualisierungen werden im Bereich "Aktivitätsprotokoll" angezeigt.
+4. Wenn alle Gehaltsabrechnungen erstellt wurden, können Sie prüfen, ob Sie richtig sind, und sie bearbeiten, wenn Sie unbezahlten Urlaub abziehen wollen.
+5. Wenn Sie das geprüft haben, können Sie sie alle gemeinsam "übertragen" indem Sie auf die Schaltfläche "Gehaltsabrechnung übertragen" klicken. Wenn Sie möchten, dass Sie automatisch per E-Mail an einen Mitarbeiter verschickt werden, stellen Sie sicher, dass Sie die Option "E-Mail absenden" angeklickt haben.
 
 ### Gehälter in Konten buchen
 
diff --git a/erpnext/docs/user/manual/de/human-resources/setup/leave-allocation.md b/erpnext/docs/user/manual/de/human-resources/setup/leave-allocation.md
index f9162ca..2e80ddf 100644
--- a/erpnext/docs/user/manual/de/human-resources/setup/leave-allocation.md
+++ b/erpnext/docs/user/manual/de/human-resources/setup/leave-allocation.md
@@ -5,6 +5,6 @@
 
 <img class="screenshot" alt="Urlaubszuordnung" src="{{docs_base_url}}/assets/img/human-resources/leave-allocation.png">
 
-Um mehreren verschhiedenen Mitarbeitern Urlaub zuzuteilen, nutzen Sie das [Urlaubszuordnungs-Werkzeug]({{docs_base_url}}/user/manual/en/human-resources/tools/leave-allocation-tool.html).
+Um mehreren verschhiedenen Mitarbeitern Urlaub zuzuteilen, nutzen Sie das [Urlaubszuordnungs-Werkzeug]({{docs_base_url}}/user/manual/de/human-resources/tools/leave-allocation-tool.html).
 
 {next}
diff --git a/erpnext/docs/user/manual/de/index.md b/erpnext/docs/user/manual/de/index.md
index 5d2aeab..4dddaf5 100644
--- a/erpnext/docs/user/manual/de/index.md
+++ b/erpnext/docs/user/manual/de/index.md
@@ -1,6 +1,6 @@
 # Benutzerhandbuch (Deutsch)
 <span class="text-muted contributed-by">Beigetragen von CWT Connector & Wire Technology GmbH</span>
 
-### Inhalt:
+### Inhalt
 
 {index}
diff --git a/erpnext/docs/user/manual/de/introduction/concepts-and-terms.md b/erpnext/docs/user/manual/de/introduction/concepts-and-terms.md
index ab70d18..ad4d0c4 100644
--- a/erpnext/docs/user/manual/de/introduction/concepts-and-terms.md
+++ b/erpnext/docs/user/manual/de/introduction/concepts-and-terms.md
@@ -151,7 +151,7 @@
 > Lagerbestand > Dokumente > Lager
 
 #### Lagerbuchung
-Materialübertrag von einem Lager, in ein Lager oder zwischen mehreren Lägern.
+Materialübertrag von einem Lager, in ein Lager oder zwischen mehreren Lagern.
 
 > Lagerbestand > Dokumente > Lagerbuchung
 
diff --git a/erpnext/docs/user/manual/de/introduction/implementation-strategy.md b/erpnext/docs/user/manual/de/introduction/implementation-strategy.md
index 3c41659..8218f8e 100644
--- a/erpnext/docs/user/manual/de/introduction/implementation-strategy.md
+++ b/erpnext/docs/user/manual/de/introduction/implementation-strategy.md
@@ -11,7 +11,7 @@
 * Lesen Sie das Handbuch.
 * Legen Sie ein kostenloses Konto auf [https://erpnext.com](https://erpnext.com) an. (Das ist der einfachste Weg um zu experimentieren.)
 * Legen Sie Ihre ersten Kunden, Lieferanten und Artikel an. Erstellen Sie weitere, um sich mit diesen Verfahren vertraut zu machen.
-* Legen Sie Kundengruppen, Artikelgruppen, Läger und Lieferantengruppen an, damit Sie Ihre Artikel klassifizieren können.
+* Legen Sie Kundengruppen, Artikelgruppen, Lager und Lieferantengruppen an, damit Sie Ihre Artikel klassifizieren können.
 * Durchlaufen Sie einen Standard-Vertriebszyklus: Lead -> Opportunity -> Angebot -> Kundenauftrag -> Lieferschein -> Ausgangsrechnung -> Zahlung (Journalbuchung/Buchungssatz)
 * Durchlaufen Sie einen Standard-Einkaufszyklus: Materialanfrage -> Lieferantenauftrag -> Eingangsrechnung -> Zahlung (Journalbuchung/Buchungssatz)
 * Durchlaufen Sie einen Fertigungszyklus (wenn anwendbar): Stückliste -> Planungswerkzeug zur Fertigung -> Fertigungsauftrag -> Materialausgabe
@@ -25,7 +25,7 @@
 * Säubern Sie Ihr Testkonto oder legen Sie besser noch eine frische Installation an.
 * Wenn Sie nur Ihre Transaktionen, nicht aber Ihre Stammdaten wie Artikel, Kunde, Lieferant, Stückliste, etc. löschen wollen, brauchen Sie nur auf die Firma klicken, für die Sie diese Transaktionen erstellt haben, und mit einer frischen Stückliste starten. Um eine Firma zu löschen, öffnen Sie den Datensatz zur Firma über Einstellungen > Vorlagen > Firma und löschen Sie die Firma indem Sie die **"Löschen"-Schaltfläche** am unteren Ende anklicken.
 * Sie können auch auf [https://erpnext.com](https://erpnext.com) ein neues Konto erstellen, und die Dreißig-Tage-Probezeit nutzen. [Finden Sie hier mehr zum Thema Einsatz von ERPNext heraus](/introduction/getting-started-with-erpnext).
-* Richten Sie Kundengruppen, Artikelgruppen, Läger und Stücklisten für alle Module ein.
+* Richten Sie Kundengruppen, Artikelgruppen, Lager und Stücklisten für alle Module ein.
 * Importieren Sie Kunden, Lieferanten, Artikel, Kontakte und Adressen mit Hilfe des Datenimportwerkzeuges.
 * Importieren Sie den Anfangsbestand des Lagers über das Werkzeug zum Lagerabgleich.
 * Erstellen Sie Eröffnungsbuchungen über Journalbuchungen/Buchungssätze und geben Sie offene Ausgangs- und Eingangsrechnungen ein.
diff --git a/erpnext/docs/user/manual/de/introduction/index.md b/erpnext/docs/user/manual/de/introduction/index.md
index f9e30f5..2b6a45a 100644
--- a/erpnext/docs/user/manual/de/introduction/index.md
+++ b/erpnext/docs/user/manual/de/introduction/index.md
@@ -31,6 +31,6 @@
 
 Und vieles vieles mehr.
 
-#### Themen:
+#### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/manufacturing/production-order.md b/erpnext/docs/user/manual/de/manufacturing/production-order.md
index 3bbcce0..e6ddd7b 100644
--- a/erpnext/docs/user/manual/de/manufacturing/production-order.md
+++ b/erpnext/docs/user/manual/de/manufacturing/production-order.md
@@ -17,7 +17,7 @@
 * Geben Sie das geplante Startdatum an (ein geschätztes Datum zu dem die Produktion beginnen soll).
 * Wählen Sie das Lager aus. Das Fertigungslager ist der Ort zu dem die Artikel gelangen, wenn Sie mit der Herstellung beginnen, und das Eingangslager ist der Ort, wo fertige Erzeugnisse lagern, bevor sie versandt werden.
 
-> Anmerkung: Sie können einen Fertigungsauftrag abspeichern ohne ein Lager auszuwählen. Läger sind jedoch zwingend erforderlich um einen Fertigungsauftrag zu übertragen.
+> Anmerkung: Sie können einen Fertigungsauftrag abspeichern ohne ein Lager auszuwählen. Lager sind jedoch zwingend erforderlich um einen Fertigungsauftrag zu übertragen.
 
 ### Arbeitsplätze neu zuordnen/Dauer von Arbeitsgängen
 
@@ -84,11 +84,11 @@
 * Wenn Sie einen Fertigungsauftrag anhalten, wird sein Status auf "Angehalten" gesetzt, mit der Folge, dass alle Herstellungsprozesse für diesen Fertigungsauftrag eingestellt werden.
 * Um den Fertigungsauftrag anzuhalten klicken Sie auf die Schaltfläche "Anhalten".
 
-1\. Wenn Sie den Fertigungsauftrag übertragen, reserviert das System für jeden Arbeitsgang des Fertigungsauftrags in Serie gemäß dem geplanten Startdatum basierend auf der Verfügbarkeit des Arbeitsplatzes ein Zeitfenster. Die Verfügbarkeit des Arbeitsplatzes hängt von den Arbeitszeiten des Arbeitsplatzes und der Urlaubsliste ab und davon, ob ein anderer Arbeitsgang des Fertigungsauftrages in diesem Zeitfenster eingeplant wurde. Sie können in den Fertigungseinstellungen die Anzahl der Tage angeben, in denen das System versucht den Arbeitsgang einzuplanen. Standardmäßig ist dieser Wert auf 30 Tage eingestellt. Wenn der Arbeitsgang über das verfügbare Zeitfenster hinaus Zeit benötigt, fragt Sie das System, ob der Arbeitsgang pausieren soll. Wenn das System die Terminplanung erstellen konnte, legt es Zeitprotokolle an und speichert sie. Sie können diese verändern und später übertragen.
-2\. Sie können außerdem zusätzliche Zeitprotokolle für einen Arbeitsgang erstellen. Hierzu wählen Sie den betreffenden Arbeitsgang aus und klicken Sie auf "Zeitprotokoll erstellen".
-3\. Rohmaterial übertragen: Dieser Schritt erstellt eine Lagerbuchung mit allen Artikeln, die benötigt werden, um dem Fertigungsauftrag abzuschliessen, und dem Fertigungslager hinzugefügt werden müssen (Unterartikel werden entweder als EIN Artikel mit Stücklister ODER in aufgelöster Form gemäß Ihren Einstellungen hinzugefügt).
-4\. Fertigerzeugnisse aktualisieren: Dieser Schritt erstellt eine Lagerbuchung, welche alle Unterartikel vom Fertigungslager abzieht und dem Lager Fertige Erzeugnisse hinzufügt.
-5\. Um die zum Fertigungsauftrag erstellten Zeitprotokolle anzusehen, klicken Sie auf "Zeitprotokolle anzeigen".
+1. Wenn Sie den Fertigungsauftrag übertragen, reserviert das System für jeden Arbeitsgang des Fertigungsauftrags in Serie gemäß dem geplanten Startdatum basierend auf der Verfügbarkeit des Arbeitsplatzes ein Zeitfenster. Die Verfügbarkeit des Arbeitsplatzes hängt von den Arbeitszeiten des Arbeitsplatzes und der Urlaubsliste ab und davon, ob ein anderer Arbeitsgang des Fertigungsauftrages in diesem Zeitfenster eingeplant wurde. Sie können in den Fertigungseinstellungen die Anzahl der Tage angeben, in denen das System versucht den Arbeitsgang einzuplanen. Standardmäßig ist dieser Wert auf 30 Tage eingestellt. Wenn der Arbeitsgang über das verfügbare Zeitfenster hinaus Zeit benötigt, fragt Sie das System, ob der Arbeitsgang pausieren soll. Wenn das System die Terminplanung erstellen konnte, legt es Zeitprotokolle an und speichert sie. Sie können diese verändern und später übertragen.
+2. Sie können außerdem zusätzliche Zeitprotokolle für einen Arbeitsgang erstellen. Hierzu wählen Sie den betreffenden Arbeitsgang aus und klicken Sie auf "Zeitprotokoll erstellen".
+3. Rohmaterial übertragen: Dieser Schritt erstellt eine Lagerbuchung mit allen Artikeln, die benötigt werden, um dem Fertigungsauftrag abzuschliessen, und dem Fertigungslager hinzugefügt werden müssen (Unterartikel werden entweder als EIN Artikel mit Stücklister ODER in aufgelöster Form gemäß Ihren Einstellungen hinzugefügt).
+4. Fertigerzeugnisse aktualisieren: Dieser Schritt erstellt eine Lagerbuchung, welche alle Unterartikel vom Fertigungslager abzieht und dem Lager Fertige Erzeugnisse hinzufügt.
+5. Um die zum Fertigungsauftrag erstellten Zeitprotokolle anzusehen, klicken Sie auf "Zeitprotokolle anzeigen".
 
 <img class="screenshot" alt="Fertigungsauftrag anhalten" src="{{docs_base_url}}/assets/img/manufacturing/PO-stop.png">
 
diff --git a/erpnext/docs/user/manual/de/manufacturing/subcontracting.md b/erpnext/docs/user/manual/de/manufacturing/subcontracting.md
index 901d242..28fa3cd 100644
--- a/erpnext/docs/user/manual/de/manufacturing/subcontracting.md
+++ b/erpnext/docs/user/manual/de/manufacturing/subcontracting.md
@@ -7,11 +7,9 @@
 
 ### Fremdvergabe einstellen
 
-1\. Erstellen Sie getrennte Artikel für unbearbeitete und bearbeitet Produkte. Beispiel: Wenn Sie Ihrem Lieferanten unlackierte Artikel X übergeben und Ihnen der Lieferant lackierte Produkte X zurückliefert, dann erstellen Sie zwei Artikel: "X unlackiert" und "X".
-
-2\. Erstellen Sie ein Lager für den Lieferanten, damit Sie die übergebenen Artikel nachverfolgen können (möglicherweise geben Sie ja Artikel im Wert einer Monatslieferung außer Haus).
-
-3\. Stellen Sie für den bearbeiteten Artikel  und der Artikelvorlage den Punkt "Ist Fremdvergabe" auf JA ein.
+1. Erstellen Sie getrennte Artikel für unbearbeitete und bearbeitet Produkte. Beispiel: Wenn Sie Ihrem Lieferanten unlackierte Artikel X übergeben und Ihnen der Lieferant lackierte Produkte X zurückliefert, dann erstellen Sie zwei Artikel: "X unlackiert" und "X".
+2. Erstellen Sie ein Lager für den Lieferanten, damit Sie die übergebenen Artikel nachverfolgen können (möglicherweise geben Sie ja Artikel im Wert einer Monatslieferung außer Haus).
+3. Stellen Sie für den bearbeiteten Artikel  und der Artikelvorlage den Punkt "Ist Fremdvergabe" auf JA ein.
 
 ![Fremdvergabe]({{docs_base_url}}/assets/old_images/erpnext/subcontract.png)
 
diff --git a/erpnext/docs/user/manual/de/manufacturing/tools/bom-replace-tool.md b/erpnext/docs/user/manual/de/manufacturing/tools/bom-replace-tool.md
index e8dc3f4..922c32a 100644
--- a/erpnext/docs/user/manual/de/manufacturing/tools/bom-replace-tool.md
+++ b/erpnext/docs/user/manual/de/manufacturing/tools/bom-replace-tool.md
@@ -11,37 +11,26 @@
 
 Wenn eine Firma Computer herstellt, besteht die Stückliste des fertigen Erzeugnisses in etwa so aus:
 
-1\. Bildschirm
-
-2\. Tastatur
-
-3\. Maus
-
-4\. Zentraleinheit
+1. Bildschirm
+2. Tastatur
+3. Maus
+4. Zentraleinheit
 
 Von den oben aufgelisteten Artikeln wird die Zentraleinheit separat zusammengebaut. Somit wird eine eigenständige Stückliste für die Zentraleinheit ersellt. Im folgenden werden die Artikel der Stückliste der Zentraleinheit angegeben:
 
-1\. 250 GByte Festplatte
-
-2\. Hauptplatine
-
-3\. Prozessor
-
-4\. SMTP
-
-5\. DVD-Laufwerk
+1. 250 GByte Festplatte
+2. Hauptplatine
+3. Prozessor
+4. SMTP
+5. DVD-Laufwerk
 
 Wenn zur Stückliste der Zentraleinheit weitere Artikel hinzugefügt werden sollen, oder enthaltene Artikel bearbeitet werden sollen, sollte eine neue Stückliste erstellt werden.
 
-1\. _350 GByte Festplatte_
-
-2\. Hauptplatine
-
-3\. Prozessor
-
-4\. SMTP
-
-5\. DVD-Laufwerk
+1. _350 GByte Festplatte_
+2. Hauptplatine
+3. Prozessor
+4. SMTP
+5. DVD-Laufwerk
 
 Um die Stückliste, bei der die Zentraleinheit als Rohmaterial enthalten ist, in der Stückliste des fertigen Produktes zu aktualisieren, können Sie das Stücklisten-Austauschwerkzeug verwenden.
 
diff --git a/erpnext/docs/user/manual/de/manufacturing/workstation.md b/erpnext/docs/user/manual/de/manufacturing/workstation.md
index e9db7f2..2405382 100644
--- a/erpnext/docs/user/manual/de/manufacturing/workstation.md
+++ b/erpnext/docs/user/manual/de/manufacturing/workstation.md
@@ -13,6 +13,6 @@
 
 Geben Sie unter "Arbeitszeit" die Betriebszeiten des Arbeitsplatzes an. Sie können die Betriebszeiten auch mit Hilfe von Schichten angeben. Wenn Sie einen Fertigungauftrag einplanen, prüft das System die Verfügbarkeit des Arbeitsplatzes basierend auf den angegebenen Betrieszeiten.
 
-> Anmerkung: Sie können Überstunden für einen Arbeitsplatz über die [Fertigungseinstellungen]({{docs_base_url}}/user/manual/en/manufacturing/setup/manufacturing-settings.html) aktivieren.
+> Anmerkung: Sie können Überstunden für einen Arbeitsplatz über die [Fertigungseinstellungen]({{docs_base_url}}/user/manual/de/manufacturing/setup/manufacturing-settings.html) aktivieren.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/projects/project.md b/erpnext/docs/user/manual/de/projects/project.md
index 6a9db66..518443b 100644
--- a/erpnext/docs/user/manual/de/projects/project.md
+++ b/erpnext/docs/user/manual/de/projects/project.md
@@ -8,7 +8,7 @@
 ### Aufgaben verwalten
 
 Ein Projekt kann in mehrere verschiedene Aufgaben aufgeteilt werden. 
-Eine Aufgabe kann über das Projektdokument selbst erstellt werden oder über die Schaltfläche [Aufgabe]({{docs_base_url}}/user/manual/en/projects/tasks.html).
+Eine Aufgabe kann über das Projektdokument selbst erstellt werden oder über die Schaltfläche [Aufgabe]({{docs_base_url}}/user/manual/de/projects/tasks.html).
 
 <img class="screenshot" alt="Projekt" src="{{docs_base_url}}/assets/img/project/project_task.png">
 
@@ -24,7 +24,7 @@
 
 ### Zeitmanagement
 
-ERPNext verwendet [Zeitprotokolle]({{docs_base_url}}/user/manual/en/projects/time-log.html) um den Fortschritt eines Projektes nachzuverfolgen. Sie können Zeitprotokolle zu jeder Aufgabe erstellen. Das aktuelle Start- und Enddatum wird dann zusammen mit der Kostenberechnung  basierend auf dem Zeitprotokoll aktualisiert.
+ERPNext verwendet [Zeitprotokolle]({{docs_base_url}}/user/manual/de/projects/time-log.html) um den Fortschritt eines Projektes nachzuverfolgen. Sie können Zeitprotokolle zu jeder Aufgabe erstellen. Das aktuelle Start- und Enddatum wird dann zusammen mit der Kostenberechnung  basierend auf dem Zeitprotokoll aktualisiert.
 
 * Um ein Zeitprotokoll zu einem Projekt anzusehen, klicken Sie auf "Zeitprotokolle"
 
@@ -38,7 +38,7 @@
 
 ### Aufwände verwalten
 
-Sie können [Aufwandsabrechnungen]({{docs_base_url}}/user/manual/en/human-resources/expense-claim.html) mit Projektaufgaben verbuchen. Das System aktualisiert die Gesamtsumme der Aufwände im Abschnitt Kostenabrechnung.
+Sie können [Aufwandsabrechnungen]({{docs_base_url}}/user/manual/de/human-resources/expense-claim.html) mit Projektaufgaben verbuchen. Das System aktualisiert die Gesamtsumme der Aufwände im Abschnitt Kostenabrechnung.
 
 * Um die Aufwandsabrechnungen zu einem Projekt anzusehen, klicken Sie auf "Aufwandsabrechnung".
 
@@ -54,7 +54,7 @@
 
 ### Kostenstelle
 
-Sie können zu einem Projekt eine [Kostenstelle]({{docs_base_url}}/user/manual/en/accounts/setup/cost-center.html) erstellen oder Sie können eine existierende Kostenstelle verwenden um alle Aufwände die zu einem Projekt entstehen mitzuverfolgen.
+Sie können zu einem Projekt eine [Kostenstelle]({{docs_base_url}}/user/manual/de/accounts/setup/cost-center.html) erstellen oder Sie können eine existierende Kostenstelle verwenden um alle Aufwände die zu einem Projekt entstehen mitzuverfolgen.
 
 <img class="screenshot" alt="Projekt - Kostenstelle" src="{{docs_base_url}}/assets/img/project/project_cost_center.png">
 
@@ -69,7 +69,7 @@
 
 ### Abrechnung
 
-Sie können einen [Kundenauftrag]({{docs_base_url}}/user/manual/en/selling/sales-order.html) zu einem Projekt erstellen bzw. ihn mit dem Projekt verknüpfen. Wenn er einmal verlinkt ist, können Sie das Vertriebsmodul dazu nutzen, dass Projekt mit Ihrem Kunden abzurechnen.
+Sie können einen [Kundenauftrag]({{docs_base_url}}/user/manual/de/selling/sales-order.html) zu einem Projekt erstellen bzw. ihn mit dem Projekt verknüpfen. Wenn er einmal verlinkt ist, können Sie das Vertriebsmodul dazu nutzen, dass Projekt mit Ihrem Kunden abzurechnen.
 
 <img class="screenshot" alt="Projekt - Kundenauftrag" src="{{docs_base_url}}/assets/img/project/project_sales_order.png">
 
diff --git a/erpnext/docs/user/manual/de/projects/tasks.md b/erpnext/docs/user/manual/de/projects/tasks.md
index 73e19fe..163fb68 100644
--- a/erpnext/docs/user/manual/de/projects/tasks.md
+++ b/erpnext/docs/user/manual/de/projects/tasks.md
@@ -25,7 +25,7 @@
 
 ### Zeitmanagement
 
-ERPNext verwendet [Zeitprotokolle]({{docs_base_url}}/user/manual/en/projects/time-log.html) um den Fortschritt einer Aufgabe mitzuprotokollieren. Sie können mehrere unterschiedliche Zeitprotokolle zu jeder Aufgabe erstellen. Das aktuelle Start- und Enddatum kann dann zusammen mit der auf dem Zeitprotokoll basierenden Kostenberechnung aktualisiert werden.
+ERPNext verwendet [Zeitprotokolle]({{docs_base_url}}/user/manual/de/projects/time-log.html) um den Fortschritt einer Aufgabe mitzuprotokollieren. Sie können mehrere unterschiedliche Zeitprotokolle zu jeder Aufgabe erstellen. Das aktuelle Start- und Enddatum kann dann zusammen mit der auf dem Zeitprotokoll basierenden Kostenberechnung aktualisiert werden.
 
 * Um ein zu einer Aufgabe erstelltes Zeitprotokoll anzuschauen, klicken Sie auf "Zeitprotokolle".
 
@@ -39,7 +39,7 @@
 
 ### Ausgabenmanagement
 
-Sie können [Aufwandsabrechnungen]({{docs_base_url}}/user/manual/en/human-resource-management/expense-claim.html) mit einer Aufgabe verbuchen. Das System aktualisiert den Gesamtbetrag der Aufwandsabrechnungen im Abschnitt Kostenberechnung.
+Sie können [Aufwandsabrechnungen]({{docs_base_url}}/user/manual/de/human-resources/expense-claim.html) mit einer Aufgabe verbuchen. Das System aktualisiert den Gesamtbetrag der Aufwandsabrechnungen im Abschnitt Kostenberechnung.
 
 * Um eine Aufwandsabrechnung, die zu einer Aufgabe erstellt wurde, anzuschauen, klicken Sie auf "Aufwandsabrechnung".
 
diff --git a/erpnext/docs/user/manual/de/projects/time-log.md b/erpnext/docs/user/manual/de/projects/time-log.md
index b65bf5e..d90e27a 100644
--- a/erpnext/docs/user/manual/de/projects/time-log.md
+++ b/erpnext/docs/user/manual/de/projects/time-log.md
@@ -37,12 +37,12 @@
 ### Abrechnung über Zeitprotokolle
 
 * Wenn Sie ein Zeitprotokoll abrechnen wollen, müssem Sie die Option "Abrechenbar" anklicken.
-* Im Abschnitt Kostenberechnung erstellt das System den Rechungsbetrag über die [Aktivitätskosten]({{docs_base_url}}/user/manual/en/projects/activity-cost.html)  basierend auf dem angegebenen Mitarbeiter und der angegebenen Aktivitätsart.
+* Im Abschnitt Kostenberechnung erstellt das System den Rechungsbetrag über die [Aktivitätskosten]({{docs_base_url}}/user/manual/de/projects/activity-cost.html)  basierend auf dem angegebenen Mitarbeiter und der angegebenen Aktivitätsart.
 * Das System kalkuliert dann den Rechnungsbetrag basierend auf den im Zeitprotokoll angegebenen Stunden.
 * Wenn "Abrechenbar" nicht markiert wurde, zeigt das System beim "Rechnungsbetrag" 0 an.
 
 <img class="screenshot" alt="Zeitprotokoll - Abrechnung" src="{{docs_base_url}}/assets/img/project/time_log_costing.png">
 
-* Nach dem Übertragen des Zeitprotokolls müssen Sie einen [Zeitprotokollstapel]({{docs_base_url}}/user/manual/en/projects/time-log-batch.html) erstellen um mit der Abrechnung fortfahren zu können.
+* Nach dem Übertragen des Zeitprotokolls müssen Sie einen [Zeitprotokollstapel]({{docs_base_url}}/user/manual/de/projects/time-log-batch.html) erstellen um mit der Abrechnung fortfahren zu können.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/selling/quotation.md b/erpnext/docs/user/manual/de/selling/quotation.md
index f7b6833..3434e26 100644
--- a/erpnext/docs/user/manual/de/selling/quotation.md
+++ b/erpnext/docs/user/manual/de/selling/quotation.md
@@ -34,12 +34,12 @@
 
 Die Preise, die sie abgeben, hängen von zwei Dingen ab:
 
-* Die Preisliste: Wenn Sie mehrere verschiedene Preislisten haben, können Sie eine Preisliste auswählen oder sie mit dem Kunden markieren (so dass sie automatisch vorselektiert wird). Ihre Artikelpreise werden automatisch über die Preisliste aktualisert. Für weitere Informationen bitte bei [Preisliste]({{docs_base_url}}/user/manual/en/setting-up/price-lists.html) weiterlesen.
+* Die Preisliste: Wenn Sie mehrere verschiedene Preislisten haben, können Sie eine Preisliste auswählen oder sie mit dem Kunden markieren (so dass sie automatisch vorselektiert wird). Ihre Artikelpreise werden automatisch über die Preisliste aktualisert. Für weitere Informationen bitte bei [Preisliste]({{docs_base_url}}/user/manual/de/setting-up/price-lists.html) weiterlesen.
 * Die Währung: Wenn Sie einem Kunden in einer anderen Währung anbieten, müssen Sie die Umrechnungsfaktoren aktualisieren um ERPNext in die Lage zu versetzen die Information in Ihrer Standardwährung zu speichern. Das hilft Ihnen dabei den Wert Ihres Angebots in der Standardwährung zu analysieren.
 
 ### Steuern
 
-Um Steuern zu Ihrem Angebot hinzu zu fügen, können Sie entweder eine Steuervorlage oder eine Verkaufssteuern- und Gebühren-Vorlage auswählen oder die Steuern selbst hinzufügen. Um Steuern im Einzelnen zu verstehen, lesen Sie bitte [Steuern]({{docs_base_url}}/user/manual/en/setting-up/setting-up-taxes.html).
+Um Steuern zu Ihrem Angebot hinzu zu fügen, können Sie entweder eine Steuervorlage oder eine Verkaufssteuern- und Gebühren-Vorlage auswählen oder die Steuern selbst hinzufügen. Um Steuern im Einzelnen zu verstehen, lesen Sie bitte [Steuern]({{docs_base_url}}/user/manual/de/setting-up/setting-up-taxes.html).
 
 Sie können Steuern auf die gleiche Art hinzufügen wie die Vorlage Verkaufssteuern und Gebühren.
 
diff --git a/erpnext/docs/user/manual/de/setting-up/authorization-rule.md b/erpnext/docs/user/manual/de/setting-up/authorization-rule.md
index 462c196..7b202f1 100644
--- a/erpnext/docs/user/manual/de/setting-up/authorization-rule.md
+++ b/erpnext/docs/user/manual/de/setting-up/authorization-rule.md
@@ -13,27 +13,27 @@
 
 Nehmen wir an dass ein Vertriebsmitarbeiter Kundenbestellungen nur dann genehmigen lassen muss, wenn der Gesamtwert 10.000 Euro übersteigt. Wenn die Kundenbestellung 10.000 Euro nicht übersteigt, dann kann auch ein Vertriebsmitarbeiter diese Transaktion übertragen. Das bedeutet, dass die Berechtigung des Vertriebsmitarbeiters zum Übertragen auf Kundenaufträge mit einer Maximalsumme von 10.000 Euro beschränkt wird.
 
-#### Schritt 1:
+#### Schritt 1
 
 Öffnen Sie eine neue Autorisierungsregel.
 
-#### Schritt 2: 
+#### Schritt 2
 
 Wählen Sie die Firma und die Transaktion aus, für die diese Autorisierungsregel angewendet werden soll. Diese Funktionalität ist nur für beschränkte Transaktionen verfügbar.
 
-#### Schritt 3: 
+#### Schritt 3
 
 Wählen Sie einen Wert für "Basiert auf" aus. Eine Autorisierungsregel wird auf Grundlage eines Wertes in diesem Feld angewendet.
 
-#### Schritt 4: 
+#### Schritt 4
 
 Wählen Sie eine Rolle, auf die die Autorisierungsregel angewendet werden soll. Für unser angenommenes Beispiel wird die Rolle "Nutzer Vertrieb" über "Anwenden auf (Rolle)" als Rolle ausgewählt. Um noch etwas genauer zu werden, können Sie auch über "Anwenden auf (Benutzer)" einen bestimmten Benutzer auswählen, wenn Sie eine Regel speziell auf einen Mitarbeiter anwenden wollen, und nicht auf alle Mitarbeiter aus dem Vertrieb. Es ist auch in Ordnung, keinen Benutzer aus dem Vertrieb anzugeben, weil es nicht zwingend erforderlich ist.
 
-#### Schritt 5: 
+#### Schritt 5
 
 Wählen Sie die Rolle des Genehmigers aus. Das könnte z. B. die Rolle des Vertriebsleiters sein, die Kundenaufträge über 10.000 Euro übertragen darf. Sie können auch hier einen bestimmten Vertriebsleiter auswählen, und dann die Regel so gestalten, dass Sie nur auf diesen Benutzer anwendbar ist. Einen genehmigenden Benutzer anzugeben ist nicht zwingend erfoderlich.
 
-#### Schritt 6: 
+#### Schritt 6
 
 Geben Sie "Autorisierter Wert" ein. Im Beispiel stellen wir das auf 10.000 Euro ein.
 
diff --git a/erpnext/docs/user/manual/de/setting-up/data/data-import-tool.md b/erpnext/docs/user/manual/de/setting-up/data/data-import-tool.md
index 9e9f340..90dc38c 100644
--- a/erpnext/docs/user/manual/de/setting-up/data/data-import-tool.md
+++ b/erpnext/docs/user/manual/de/setting-up/data/data-import-tool.md
@@ -36,10 +36,10 @@
 
 <img alt="Upload" class="screenshot" src="{{docs_base_url}}/assets/img/setup/data-import/data-import-3.png">
 
-#### Anmerkungen:
+#### Anmerkungen
 
-1\. Stellen Sie sicher, dass Sie als Verschlüsselung UTF-8 verwenden, wenn Ihre Anwendung das zulässt.
-2\. Lassen Sie die Spalte ID für einen neuen Datensatz leer.
+1. Stellen Sie sicher, dass Sie als Verschlüsselung UTF-8 verwenden, wenn Ihre Anwendung das zulässt.
+2. Lassen Sie die Spalte ID für einen neuen Datensatz leer.
 
 ### 4. Hochladen aller Tabellen (übergeordnete und Untertabellen)
 
diff --git a/erpnext/docs/user/manual/de/setting-up/data/index.md b/erpnext/docs/user/manual/de/setting-up/data/index.md
index 3586885..68460b0 100644
--- a/erpnext/docs/user/manual/de/setting-up/data/index.md
+++ b/erpnext/docs/user/manual/de/setting-up/data/index.md
@@ -3,6 +3,6 @@
 
 Mithilfe des Werkzeuges zum Datenimport und -export können Sie Massenimporte und -exporte aus und nach Tabellenkalkulationsdateien (**.csv**) durchführen. Dieses Werkzeug ist sehr hilfreich zu Beginn des Einrichtungsprozesses um Daten aus anderen Systemen zu übernehmen.
 
-Themen
+### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/setting-up/email/email-alerts.md b/erpnext/docs/user/manual/de/setting-up/email/email-alerts.md
index 732d648..58f6fe3 100644
--- a/erpnext/docs/user/manual/de/setting-up/email/email-alerts.md
+++ b/erpnext/docs/user/manual/de/setting-up/email/email-alerts.md
@@ -3,19 +3,13 @@
 
 Sie können verschiedene E-Mail-Benachrichtigungen in Ihrem System einstellen, um Sie an wichtige Aktivitäten zu erinnern, beispielsweise an:
 
-1\. das Enddatum einer Aufgabe.
-
-2\. einen vom Kunden erwarteten Liefertermin eines Kundenauftrages.
-
-3\. einen vom Lieferanten erwarteten Zahlungstermin.
-
-4\. eine Erinnerung zum Nachfassen.
-
-5\. Wenn der Wert einer Bestellung einen bestimmten Betrag überschreitet.
-
-6\. Wenn ein Vertrag ausläuft.
-
-7\. Wenn eine Aufgabe abgeschlossen ist oder Ihren Status ändert.
+1. das Enddatum einer Aufgabe.
+2. einen vom Kunden erwarteten Liefertermin eines Kundenauftrages.
+3. einen vom Lieferanten erwarteten Zahlungstermin.
+4. eine Erinnerung zum Nachfassen.
+5. Wenn der Wert einer Bestellung einen bestimmten Betrag überschreitet.
+6. Wenn ein Vertrag ausläuft.
+7. Wenn eine Aufgabe abgeschlossen ist oder Ihren Status ändert.
 
 Hierfür müssen Sie eine E-Mail-Erinnerung einstellen.
 
@@ -25,29 +19,20 @@
 
 Um eine E-Mail-Erinnerung einzustellen, gehen Sie wie folgt vor:
 
-1\. Wählen Sie das Dokument aus, welches Sie beobachten wollen.
-
-2\. Geben Sie an, welche Ereignisse Sie beobachten wollen. Ereignisse sind:
-
-2\.1 Neu: Wenn ein Dokument des gewählten Typs erstellt wird.
-
-2\.2 Speichern / Übertragen / Stornieren: Wenn ein Dokument des gewählten Typs gespeichert, übertragen oder storniert wird.
-
-2\.3 Änderung des Wertes: Wenn sich ein bestimmter Wert ändert.
-
-2\.4 Tage vor / Tage nach: Stellen Sie eine Benachrichtigung einige Tage vor oder nach einem **Referenzdatum** ein. Um die Anzahl der Tage einzugeben, geben Sie einen Wert in **Tage vor oder nach** ein. Das kann sehr nützlich sein, wenn es sich um Fälligkeitstermine handelt oder es um das Nachverfolgen von Leads oder Angeboten geht.
-
-3\. Stellen Sie, wenn Sie möchten, Zusatzbedingungen ein.
-
-4\. Geben Sie die Empfänger der Erinnerung an. Der Empfänger kann sowohl über ein Feld des Dokumentes als auch über eine feste Liste ausgewählt werden.
-
-5\. Verfassen Sie die Nachricht.
+1. Wählen Sie das Dokument aus, welches Sie beobachten wollen.
+2. Geben Sie an, welche Ereignisse Sie beobachten wollen. Ereignisse sind:
+    1. Neu: Wenn ein Dokument des gewählten Typs erstellt wird.
+    2. Speichern / Übertragen / Stornieren: Wenn ein Dokument des gewählten Typs gespeichert, übertragen oder storniert wird.
+    3. Änderung des Wertes: Wenn sich ein bestimmter Wert ändert.
+    4. Tage vor / Tage nach: Stellen Sie eine Benachrichtigung einige Tage vor oder nach einem **Referenzdatum** ein. Um die Anzahl der Tage einzugeben, geben Sie einen Wert in **Tage vor oder nach** ein. Das kann sehr nützlich sein, wenn es sich um Fälligkeitstermine handelt oder es um das Nachverfolgen von Leads oder Angeboten geht.
+3. Stellen Sie, wenn Sie möchten, Zusatzbedingungen ein.
+4. Geben Sie die Empfänger der Erinnerung an. Der Empfänger kann sowohl über ein Feld des Dokumentes als auch über eine feste Liste ausgewählt werden.
+5. Verfassen Sie die Nachricht.
 
 ---
 
 #### Beispiel
-1\. [Kriterien definieren](<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/email/email-alert-1.png">)
-
-2\. [Empfänger und Nachrichtentext eingeben](<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/email/email-alert-2.png">)
+1. [Kriterien definieren](<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/email/email-alert-1.png">)
+2. [Empfänger und Nachrichtentext eingeben](<img class="screenshot" src="{{docs_base_url}}/assets/img/setup/email/email-alert-2.png">)
 
 {next}
diff --git a/erpnext/docs/user/manual/de/setting-up/email/sending-email.md b/erpnext/docs/user/manual/de/setting-up/email/sending-email.md
index 730cae5..d2087ca 100644
--- a/erpnext/docs/user/manual/de/setting-up/email/sending-email.md
+++ b/erpnext/docs/user/manual/de/setting-up/email/sending-email.md
@@ -5,6 +5,6 @@
 
 <img class="screenshot" alt="Emails versenden" src="{{docs_base_url}}/assets/img/setup/email/send-email.gif">
 
-**Anmerkung:** Es müssen Konten zum [E-Mail-Versand]({{docs_base_url}}/user/manual/en/setting-up/email/email-account.html) eingerichtet sein.
+**Anmerkung:** Es müssen Konten zum [E-Mail-Versand]({{docs_base_url}}/user/manual/de/setting-up/email/email-account.html) eingerichtet sein.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/setting-up/settings/naming-series.md b/erpnext/docs/user/manual/de/setting-up/settings/naming-series.md
index ca41025..1a6f336 100644
--- a/erpnext/docs/user/manual/de/setting-up/settings/naming-series.md
+++ b/erpnext/docs/user/manual/de/setting-up/settings/naming-series.md
@@ -23,11 +23,9 @@
 
 In diesem Formular,
 
-1\. Wählen Sie die Transaktion aus, für die Sie den Nummernkreis einstellen wollen. Das System wird den aktuellen Nummernkreis in der Textbox aktualisieren.
-
-2\. Passen Sie den Nummernkreis nach Ihren Wünschen mit eindeutigen Präfixen an. Jedes Präfix muss in einer neuen Zeile stehen.
-
-3\. Das erste Präfix wird zum Standard-Präfix. Wenn Sie möchten, dass ein Benutzer explizit einen Nummernkreis statt der Standardeinstellung auswählt, markieren Sie die Option "Benutzer muss immer auswählen".
+1. Wählen Sie die Transaktion aus, für die Sie den Nummernkreis einstellen wollen. Das System wird den aktuellen Nummernkreis in der Textbox aktualisieren.
+2. Passen Sie den Nummernkreis nach Ihren Wünschen mit eindeutigen Präfixen an. Jedes Präfix muss in einer neuen Zeile stehen.
+3. Das erste Präfix wird zum Standard-Präfix. Wenn Sie möchten, dass ein Benutzer explizit einen Nummernkreis statt der Standardeinstellung auswählt, markieren Sie die Option "Benutzer muss immer auswählen".
 
 Sie können auch den Startpunkt eines Nummernkreises auswählen, indem Sie den Namen und den Startpunkt des Nummernkreises im Abschnitt "Seriennummer aktualisieren" angeben.
 
diff --git a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-5-letterhead-and-logo.md b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-5-letterhead-and-logo.md
index eca0a67..f32815d 100644
--- a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-5-letterhead-and-logo.md
+++ b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-5-letterhead-and-logo.md
@@ -15,7 +15,7 @@
 
 Wenn Ihr Briefkopf noch nicht fertig ist, können Sie diesen Schritt auch überspringen.
 
-Um später einen Briefkopf über das Modul "Einstellungen" auszuwählen, lesen Sie im Bereich [Briefkopf]({{docs_base_url}}/user/manual/en/setting-up/print/letter-head.html) weiter.
+Um später einen Briefkopf über das Modul "Einstellungen" auszuwählen, lesen Sie im Bereich [Briefkopf]({{docs_base_url}}/user/manual/de/setting-up/print/letter-head.html) weiter.
 
 ### Anhang als Internetverknüpfung
 
diff --git a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-7-tax-details.md b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-7-tax-details.md
index cedbe30..76f1538 100644
--- a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-7-tax-details.md
+++ b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-7-tax-details.md
@@ -18,6 +18,6 @@
 
 Das Anliegen der Mehrwertsteuer ist es, für den Staat ähnlich der Körperschaftssteuer und der Einkommensteuer Steuererträge zu generieren. Beispiel: Wenn Sie in einem Kaufhaus einkaufen schlägt Ihnen das Geschäft 19% als Mehrwertsteuer auf die Rechnung auf.
 
-Um im Einstellungsassistenten die Mehrwertsteuer einzustellen, geben Sie einfach den Prozentsatz der vom Staat erhoben wird, ein. Um die Mehrwertsteuer zu einem späteren Zeitpunkt einzustellen, lesen Sie bitte den Abschnitt [Einstellen von Steuern]({{docs_base_url}}/user/manual/en/setting-up/setting-up-taxes.html).
+Um im Einstellungsassistenten die Mehrwertsteuer einzustellen, geben Sie einfach den Prozentsatz der vom Staat erhoben wird, ein. Um die Mehrwertsteuer zu einem späteren Zeitpunkt einzustellen, lesen Sie bitte den Abschnitt [Einstellen von Steuern]({{docs_base_url}}/user/manual/de/setting-up/setting-up-taxes.html).
 
 {next}
diff --git a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-8-customer-names.md b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-8-customer-names.md
index 65c4c7a..69fed2b 100644
--- a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-8-customer-names.md
+++ b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-8-customer-names.md
@@ -18,6 +18,6 @@
 
 Kontaktname: Shiv Agarwal
 
-Um mehr über Kunden zu erfahren, lesen Sie im Abschnitt [Details zu Kunden]({{docs_base_url}}/user/manual/en/CRM/customer.html) nach.
+Um mehr über Kunden zu erfahren, lesen Sie im Abschnitt [Details zu Kunden]({{docs_base_url}}/user/manual/de/CRM/customer.html) nach.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-9-suppliers.md b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-9-suppliers.md
index b880cb4..7d398b5 100644
--- a/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-9-suppliers.md
+++ b/erpnext/docs/user/manual/de/setting-up/setup-wizard/step-9-suppliers.md
@@ -8,6 +8,6 @@
 
 ---
 
-Um den Begriff "Lieferant" besser zu verstehen, lesen Sie unter [Lieferantenstammdaten]({{docs_base_url}}/user/manual/en/buying/supplier-master.html) nach.
+Um den Begriff "Lieferant" besser zu verstehen, lesen Sie unter [Lieferantenstammdaten]({{docs_base_url}}/user/manual/de/buying/supplier.html) nach.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/setting-up/third-party-backups.md b/erpnext/docs/user/manual/de/setting-up/third-party-backups.md
index 28ecce2..ba53f5e 100644
--- a/erpnext/docs/user/manual/de/setting-up/third-party-backups.md
+++ b/erpnext/docs/user/manual/de/setting-up/third-party-backups.md
@@ -27,7 +27,7 @@
 
 ![Dropbox-Zugriff]({{docs_base_url}}/assets/old_images/erpnext/dropbox-access.png)
 
-## Für OpenSource-Nutzer:
+## Für OpenSource-Nutzer
 
 Voreinstellungen:
 
diff --git a/erpnext/docs/user/manual/de/setting-up/users-and-permissions/role-based-permissions.md b/erpnext/docs/user/manual/de/setting-up/users-and-permissions/role-based-permissions.md
index 0dbcab4..6d101bc 100644
--- a/erpnext/docs/user/manual/de/setting-up/users-and-permissions/role-based-permissions.md
+++ b/erpnext/docs/user/manual/de/setting-up/users-and-permissions/role-based-permissions.md
@@ -31,7 +31,7 @@
 
 Um Benutzerberechtigungen zu setzen, gehen Sie zu:
 
-> Einstellungen > Berechtigungen > [Benutzerrechte-Manager]({{docs_base_url}}/user/manual/en/setting-up/users-and-permissions/user-permissions.html)
+> Einstellungen > Berechtigungen > [Benutzerrechte-Manager]({{docs_base_url}}/user/manual/de/setting-up/users-and-permissions/user-permissions.html)
 
 
 
diff --git a/erpnext/docs/user/manual/de/setting-up/users-and-permissions/user-permissions.md b/erpnext/docs/user/manual/de/setting-up/users-and-permissions/user-permissions.md
index de37271..a751693 100644
--- a/erpnext/docs/user/manual/de/setting-up/users-and-permissions/user-permissions.md
+++ b/erpnext/docs/user/manual/de/setting-up/users-and-permissions/user-permissions.md
@@ -12,7 +12,7 @@
 
 Abbildung: Übersicht aus dem Benutzerberechtigungs-Manager die aufzeigt, wie Benutzer nur auf bestimmte Firmen zugreifen können
 
-#### Beispiel:
+#### Beispiel
 
 Der Benutzer "aromn@example.com" hat die Rolle "Nutzer Vertrieb" und wir möchten die Zugriffsrechte des Benutzers so einschränken, dass er nur auf Datensätze einer bestimmten Firma, nämlich der Wind Power LLC, zugreifen kann.
 
diff --git a/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/index.md b/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/index.md
index 1212013..1a17675 100644
--- a/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/index.md
+++ b/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/index.md
@@ -9,7 +9,7 @@
 
 Wenn Sie Artikel kaufen und erhalten, werden diese Artikel als Vermögen des Unternehmens gebucht (Warenbestand/Anlagevermögen). Wenn Sie diese Artikel wieder verkaufen und ausliefern, werden Kosten (Selbstkosten) in Höhe der Bezugskosten der Artikel verbucht. Nach jeder Lagertransaktion werden Buchungen im Hauptbuch erstellt. Dies hat zum Ergebnis, dass der Wert im Lagerbuch immer gleich dem Wert in der Bilanz bleibt. Das verbessert die Aussagekraft der Bilanz und der Gewinn- und Verlustrechnung.
 
-Um Buchungen für bestimmte Lagertransaktionen zu überprüfen, bitte unter [Beispiele]({{docs_base_url}}/user/manual/en/stock/accounting-of-inventory-stock/perpetual-inventory.html) nachlesen.
+Um Buchungen für bestimmte Lagertransaktionen zu überprüfen, bitte unter [Beispiele]({{docs_base_url}}/user/manual/de/stock/accounting-of-inventory-stock/perpetual-inventory.html) nachlesen.
 
 #### Vorteile
 
@@ -33,6 +33,6 @@
 
 Dieser Gesamtprozess wird als Stichtagsinventur bezeichnet.
 
-Wenn Sie als bereits existierender Benutzer die Stichtagsinventur nutzen aber zur Ständigen Inventur wechseln möchten, müssen Sie der Migrationsanleitung folgen. Für weitere Details lesen Sie [Migration aus der Stichtagsinventur]({{docs_base_url}}/user/manual/en/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.html).
+Wenn Sie als bereits existierender Benutzer die Stichtagsinventur nutzen aber zur Ständigen Inventur wechseln möchten, müssen Sie der Migrationsanleitung folgen. Für weitere Details lesen Sie [Migration aus der Stichtagsinventur]({{docs_base_url}}/user/manual/de/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.html).
 
 {next}
diff --git a/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md b/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
index c233959..742d246 100644
--- a/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
+++ b/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/migrate-to-perpetual-inventory.md
@@ -1,14 +1,14 @@
 # Zur Ständigen Inventur wechseln
 <span class="text-muted contributed-by">Beigetragen von CWT Connector & Wire Technology GmbH</span>
 
-Bestehende Benutzer müssen sich an folgende Schritte halten um das neue System der Ständigen Inventur zu aktivieren. Da die Ständige Inventur immer auf einer Synchronisation zwischen Lager und Kontostand aufbaut, ist es nicht möglich diese Option in einer bestehenden Lagereinstellung zu übernehmen. Sie müssen einen komplett neuen Satz von Lägern erstellen, jedes davon verbunden mit dem betreffenden Konto.
+Bestehende Benutzer müssen sich an folgende Schritte halten um das neue System der Ständigen Inventur zu aktivieren. Da die Ständige Inventur immer auf einer Synchronisation zwischen Lager und Kontostand aufbaut, ist es nicht möglich diese Option in einer bestehenden Lagereinstellung zu übernehmen. Sie müssen einen komplett neuen Satz von Lagern erstellen, jedes davon verbunden mit dem betreffenden Konto.
 
 Schritte:
 
 
   * Heben Sie die Salden der Konten, die Sie zur Pflege des verfügbaren Lagerwertes verwenden, (Warenbestände/Anlagevermögen) durch eine Journalbuchung auf.
 
-  * Da bereits angelegte Läger mit Lagertransaktionen verbunden sind, es aber keine verknüpften Buchungssätze gibt, können diese Läger nicht in einer ständigen Inventur genutzt werden. Sie müssen für zukünftige Lagertransaktionen neue Läger anlegen, die dann mit den zutreffenden Konten verknüpft sind. Wählen Sie bei der Erstellung neuer Läger eine Artikelgruppe unter der das Unterkonto für das Lager erstellt wird.
+  * Da bereits angelegte Lager mit Lagertransaktionen verbunden sind, es aber keine verknüpften Buchungssätze gibt, können diese Lager nicht in einer ständigen Inventur genutzt werden. Sie müssen für zukünftige Lagertransaktionen neue Lager anlegen, die dann mit den zutreffenden Konten verknüpft sind. Wählen Sie bei der Erstellung neuer Lager eine Artikelgruppe unter der das Unterkonto für das Lager erstellt wird.
 
   * Erstellen Sie folgende Standardkonten für jede Firma: 
 
@@ -25,6 +25,6 @@
 
 * Erstellen Sie Lagerbuchungen (Materialübertrag) um verfügbare Lagerbestände von einem existierenden Lager auf ein neues Lager zu übertragen. Sobald im neuen Lager der Lagerbestand verfügbar wird, sollten Sie für zukünftige Transaktionen nur noch das neue Lager verwenden.
 
-Das System wird für bereits existierende Lagertransaktionen keine Buchungssätze erstellen, wenn sie vor der Aktivierung der Ständigen Inventur übertragen wurden, da die alten Läger nicht mit Konten verknüpft werden. Wenn Sie eine neue Transaktion mit einem alten Lager erstellen oder eine existierende Transaktion ändern, gibt es keine korrespondierenden Buchungssätze. Sie müssen Lager und Kontostände manuell über das Journal synchronisieren.
+Das System wird für bereits existierende Lagertransaktionen keine Buchungssätze erstellen, wenn sie vor der Aktivierung der Ständigen Inventur übertragen wurden, da die alten Lager nicht mit Konten verknüpft werden. Wenn Sie eine neue Transaktion mit einem alten Lager erstellen oder eine existierende Transaktion ändern, gibt es keine korrespondierenden Buchungssätze. Sie müssen Lager und Kontostände manuell über das Journal synchronisieren.
 
 > Anmerkung: Wenn Sie bereits das alte System der Ständigen Inventur nutzen, wird dieses automatisch deaktiviert. Sie müssen den Schritten oben folgen um es wieder zu aktivieren.
diff --git a/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/perpetual-inventory.md b/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/perpetual-inventory.md
index e41d0c5..9a7f431 100644
--- a/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/perpetual-inventory.md
+++ b/erpnext/docs/user/manual/de/stock/accounting-of-inventory-stock/perpetual-inventory.md
@@ -7,22 +7,19 @@
 
 ### Aktivierung
 
-1\. Richten Sie die folgenden Standard-Konten für jede Firma ein:
-
-* Lagerwaren erhalten aber noch nicht abgerechnet
-* Lagerabgleichskonto
-* In der Bewertung enthaltene Kosten
-* Kostenstelle
-
-2\. In der Ständigen Inventur verwaltet das System für jedes Lager einen eigenen Kontostand unter einer eigenen Kontobezeichnung. Um diese Kontobezeichnung zu erstellen, gehen Sie zu "Konto erstellen unter" in den Lagerstammdaten.
-
-3\. Aktivieren Sie die Ständige Inventur.
+1. Richten Sie die folgenden Standard-Konten für jede Firma ein:
+    * Lagerwaren erhalten aber noch nicht abgerechnet
+    * Lagerabgleichskonto
+    * In der Bewertung enthaltene Kosten
+    * Kostenstelle
+2. In der Ständigen Inventur verwaltet das System für jedes Lager einen eigenen Kontostand unter einer eigenen Kontobezeichnung. Um diese Kontobezeichnung zu erstellen, gehen Sie zu "Konto erstellen unter" in den Lagerstammdaten.
+3. Aktivieren Sie die Ständige Inventur.
 
 > Einstellungen > Rechnungswesen > Kontoeinstellungen > Eine Buchung für jede Lagerbewegung erstellen
 
 ---
 
-### Beispiel:
+### Beispiel
 
 Wir nehmen folgenden Kontenplan und folgende Lagereinstellungen für Ihre Firma an:
 
@@ -60,7 +57,7 @@
       * Versandgebühren
       * Zoll
 
-#### Kontenkonfiguration des Lagers:
+#### Kontenkonfiguration des Lagers
 
 * In Verkaufsstellen
 * In der Fertigung
diff --git a/erpnext/docs/user/manual/de/stock/articles/index.md b/erpnext/docs/user/manual/de/stock/articles/index.md
index 59fa9ae..2dbba4a 100644
--- a/erpnext/docs/user/manual/de/stock/articles/index.md
+++ b/erpnext/docs/user/manual/de/stock/articles/index.md
@@ -18,7 +18,7 @@
 
 ### Lagerbestand: Lager- und Bestandseinstellungen
 
-In ERPNext können Sie verschiedene Typen von Lägern einstellen um Ihre unterschiedlichen Artikel zu lagern. Die Auswahl kann aufgrund der Artikeltypen getroffen werden. Das kann ein Artikel des Anlagevermögens sein, ein Lagerartikel oder auch ein Fertigungsartikel.
+In ERPNext können Sie verschiedene Typen von Lagern einstellen um Ihre unterschiedlichen Artikel zu lagern. Die Auswahl kann aufgrund der Artikeltypen getroffen werden. Das kann ein Artikel des Anlagevermögens sein, ein Lagerartikel oder auch ein Fertigungsartikel.
 
 * **Lagerartikel:** Wenn Sie Lagerartikel dieses Typs in Ihrem Lagerbestand verwalten, erzeugt ERPNext für jede Transaktion dieses Artikels eine Buchung im Lagerhauptbuch.
 * **Standardlager:** Das ist das Lager, welches automatisch bei Ihren Transaktionen ausgewählt wird.
diff --git a/erpnext/docs/user/manual/de/stock/delivery-note.md b/erpnext/docs/user/manual/de/stock/delivery-note.md
index 98ae787..00e66ca 100644
--- a/erpnext/docs/user/manual/de/stock/delivery-note.md
+++ b/erpnext/docs/user/manual/de/stock/delivery-note.md
@@ -19,7 +19,7 @@
 
 ### Pakete oder Artikel mit Produkt-Bundles versenden
 
-Wenn Sie Artikel, die ein [Produkt-Bundle]({{docs_base_url}}/user/manual/en/selling/setup/sales-bom.html), ERPNext will automatically beinhalten, versenden, erstellt Ihnen ERPNext automatisch eine Tabelle "Packliste" basierend auf den Unterartikeln dieses Artikels.
+Wenn Sie Artikel, die ein [Produkt-Bundle]({{docs_base_url}}/user/manual/de/selling/setup/product-bundle.html), ERPNext will automatically beinhalten, versenden, erstellt Ihnen ERPNext automatisch eine Tabelle "Packliste" basierend auf den Unterartikeln dieses Artikels.
 
 Wenn Ihre Artikel serialisiert sind, dann müssen Sie für Artikel vom Typ Produkt-Bundle die Seriennummer in der Tabelle "Packliste" aktualisieren.
 
diff --git a/erpnext/docs/user/manual/de/stock/index.md b/erpnext/docs/user/manual/de/stock/index.md
index 4241104..5a0c2dd 100644
--- a/erpnext/docs/user/manual/de/stock/index.md
+++ b/erpnext/docs/user/manual/de/stock/index.md
@@ -21,6 +21,6 @@
 
 Um dies umzusetzen, sammelt ERPNext alle Bestandstransaktionen in einer Tabelle, die als Lagerhauptbuch bezeichnet wird. Alle Kaufbelege, Lagerbuchungen und Lieferscheine aktualisieren diese Tabelle.
 
-### Themen:
+### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/stock/material-request.md b/erpnext/docs/user/manual/de/stock/material-request.md
index ab5977b..0f55b1e 100644
--- a/erpnext/docs/user/manual/de/stock/material-request.md
+++ b/erpnext/docs/user/manual/de/stock/material-request.md
@@ -16,9 +16,9 @@
 Eine Materialanfrage kann auf folgende Arten erstellt werden:
 
 * Automatisch aus einem Kundenauftrag heraus.
-* Automatisch, wenn die projizierte Menge eines Artikels in den Lägern einen bestimmten Bestand erreicht.
+* Automatisch, wenn die projizierte Menge eines Artikels in den Lagern einen bestimmten Bestand erreicht.
 * Automatisch aus einer Stückliste heraus, wenn Sie das Modul "Produktionsplanung" benutzen, um Ihre Fertigungsaktivitäten zu planen.
-* Wenn Ihre Artikel Bestandsposten sind, müssen Sie überdies das Lager angeben, auf welches diese Artikel geliefert werden sollen. Das hilft dabei die [projizierte Menge]({{docs_base_url}}/user/manual/en/stock/projected-quantity.html) für diesen Artikel im Auge zu behalten.
+* Wenn Ihre Artikel Bestandsposten sind, müssen Sie überdies das Lager angeben, auf welches diese Artikel geliefert werden sollen. Das hilft dabei die [projizierte Menge]({{docs_base_url}}/user/manual/de/stock/projected-quantity.html) für diesen Artikel im Auge zu behalten.
 
 Es gibt folgende Typen von Materialanfragen:
 
diff --git a/erpnext/docs/user/manual/de/stock/stock-entry.md b/erpnext/docs/user/manual/de/stock/stock-entry.md
index 699713a..4b9fe08 100644
--- a/erpnext/docs/user/manual/de/stock/stock-entry.md
+++ b/erpnext/docs/user/manual/de/stock/stock-entry.md
@@ -21,7 +21,7 @@
 
 In einer Lagerbuchung müssen Sie die Artikelliste mit all Ihren Transaktionen aktualisieren. Für jede Zeile müssen Sie ein Ausgangslager oder ein Eingangslager oder beides eingeben (wenn Sie eine Bewegung erfassen).
 
-#### Zusätzliche Kosten:
+#### Zusätzliche Kosten
 
 Wenn die Lagerbuchung eine Eingangsbuchung ist, d. h. wenn ein beliebiger Artikel an einem Ziellager angenommen wird, können Sie zusätzliche Kosten erfassen (wie Versandgebühren, Zollgebühren, Betriebskosten, usw.), die mit dem Prozess verbunden sind. Die Zusatzkosten werden berücksichtigt, um den Wert des Artikels zu kalkulieren.
 
diff --git a/erpnext/docs/user/manual/de/stock/tools/landed-cost-voucher.md b/erpnext/docs/user/manual/de/stock/tools/landed-cost-voucher.md
index 1a311e2..340e104 100644
--- a/erpnext/docs/user/manual/de/stock/tools/landed-cost-voucher.md
+++ b/erpnext/docs/user/manual/de/stock/tools/landed-cost-voucher.md
@@ -27,10 +27,8 @@
 
 ### Was passiert bei der Ausgabe?
 
-1\. Bei der Ausgabe des Einstandskostenbelegs werden die zutreffenden Einstandskosten in der Artikelliste des Kaufbelegs aktualisiert.
-
-2\. Die Bewertung der Artikel wird basierend auf den neuen Einstandskosten neu berechnet.
-
-3\. Wenn Sie die Ständige Inventur nutzen, verbucht das System Buchungen im Hauptbuch um den Lagerbestand zu korrigieren. Es belastet (erhöht) das Konto des zugehörigen Lagers und entlastet (erniedrigt) das Konto "Ausgaben in Bewertung eingerechnet". Wenn Artikel schon geliefert wurden, wurden die Selbstkosten zur alten Bewertung verbucht. Daher werden Hauptbuch-Buchungen erneut für alle zukünftigen ausgehenden Buchungen verbundener Artikel erstellt um den Selbstkosten-Betrag zu korrigieren.
+1. Bei der Ausgabe des Einstandskostenbelegs werden die zutreffenden Einstandskosten in der Artikelliste des Kaufbelegs aktualisiert.
+2. Die Bewertung der Artikel wird basierend auf den neuen Einstandskosten neu berechnet.
+3. Wenn Sie die Ständige Inventur nutzen, verbucht das System Buchungen im Hauptbuch um den Lagerbestand zu korrigieren. Es belastet (erhöht) das Konto des zugehörigen Lagers und entlastet (erniedrigt) das Konto "Ausgaben in Bewertung eingerechnet". Wenn Artikel schon geliefert wurden, wurden die Selbstkosten zur alten Bewertung verbucht. Daher werden Hauptbuch-Buchungen erneut für alle zukünftigen ausgehenden Buchungen verbundener Artikel erstellt um den Selbstkosten-Betrag zu korrigieren.
 
 {next}
diff --git a/erpnext/docs/user/manual/de/stock/warehouse.md b/erpnext/docs/user/manual/de/stock/warehouse.md
index 5025d16..a2e6c43 100644
--- a/erpnext/docs/user/manual/de/stock/warehouse.md
+++ b/erpnext/docs/user/manual/de/stock/warehouse.md
@@ -1,7 +1,7 @@
 # Lager
 <span class="text-muted contributed-by">Beigetragen von CWT Connector & Wire Technology GmbH</span>
 
-Ein Lager ist ein geschäftlich genutztes Gebäude zum Lagern von Waren. Läger werden von Herstellern, Importeuren, Exporteuren, Großhändlern, Transporteuren, vom Zoll, usw. genutzt. Es handelt sich normalerweise um große, flache Gebäude in Industriegebieten von Städten und Ortschaften. Meistens verfügen sie über Ladestationen um Waren auf LKWs zu verladen und sie aus LKWs zu entladen.
+Ein Lager ist ein geschäftlich genutztes Gebäude zum Lagern von Waren. Lager werden von Herstellern, Importeuren, Exporteuren, Großhändlern, Transporteuren, vom Zoll, usw. genutzt. Es handelt sich normalerweise um große, flache Gebäude in Industriegebieten von Städten und Ortschaften. Meistens verfügen sie über Ladestationen um Waren auf LKWs zu verladen und sie aus LKWs zu entladen.
 
 Um zum Bereich "Lager" zu gelangen, klicken Sie auf "Lagerbestand" und gehen Sie unter "Dokumente" auf "Lager". Sie können auch über das Modul "Einstellungen" gehen und auf "Lagerbestand" und "Lager-Einstellungen" klicken.
 
@@ -9,13 +9,13 @@
 
 <img class="screenshot" alt="Lager" src="{{docs_base_url}}/assets/img/stock/warehouse.png">
 
-In ERPNext muss jedes Lager einer festen Firma zugeordnet sein, um einen unternehmensbezogenen Lagerbestand zu erhalten. Die Läger werden mit den ihnen zugeordneten Firmenkürzeln abgespeichert. Dies erleichtert es auf einen Blick herauszufinden, welches Lager zu welcher Firma gehört.
+In ERPNext muss jedes Lager einer festen Firma zugeordnet sein, um einen unternehmensbezogenen Lagerbestand zu erhalten. Die Lager werden mit den ihnen zugeordneten Firmenkürzeln abgespeichert. Dies erleichtert es auf einen Blick herauszufinden, welches Lager zu welcher Firma gehört.
 
-Sie können für diese Läger Benutzereinschränkungen mit einstellen. Wenn Sie nicht möchten, dass ein bestimmter Benutzer mit einem bestimmten Lager arbeiten kann, können Sie diesen Benutzer vom Zugriff auf das Lager ausschliessen.
+Sie können für diese Lager Benutzereinschränkungen mit einstellen. Wenn Sie nicht möchten, dass ein bestimmter Benutzer mit einem bestimmten Lager arbeiten kann, können Sie diesen Benutzer vom Zugriff auf das Lager ausschliessen.
 
-### Läger verschmelzen
+### Lager verschmelzen
 
-Bei der täglichen Arbeit kommt es vor, dass fälschlicherweise doppelte Einträge erstellt werden, was zu doppelten Lägern führt. Doppelte Datensätze können zu einem einzigen Lagerort verschmolzen werden. Wählen Sie hierzu aus der Kopfmenüleiste des Systems das Menü "Datei" aus. Wählen Sie "Umbenennen" und geben Sie das richtige Lager ein, drücken Sie danach die Schaltfläche "Verschmelzen". Das System ersetzt in allen Transaktionen alle falschen Lagereinträge durch das richtige Lager. Weiterhin wird die verfügbare Menge (tatsächliche Menge, reservierte Menge, bestellte Menge, usw.) aller Artikel im doppelt vorhandenen Lager auf das richtige Lager übertragen. Löschen Sie nach dem Abschluß der Verschmelzung das doppelte Lager.
+Bei der täglichen Arbeit kommt es vor, dass fälschlicherweise doppelte Einträge erstellt werden, was zu doppelten Lagern führt. Doppelte Datensätze können zu einem einzigen Lagerort verschmolzen werden. Wählen Sie hierzu aus der Kopfmenüleiste des Systems das Menü "Datei" aus. Wählen Sie "Umbenennen" und geben Sie das richtige Lager ein, drücken Sie danach die Schaltfläche "Verschmelzen". Das System ersetzt in allen Transaktionen alle falschen Lagereinträge durch das richtige Lager. Weiterhin wird die verfügbare Menge (tatsächliche Menge, reservierte Menge, bestellte Menge, usw.) aller Artikel im doppelt vorhandenen Lager auf das richtige Lager übertragen. Löschen Sie nach dem Abschluß der Verschmelzung das doppelte Lager.
 
 > Hinweis: ERPNext berechnet den Lagerbestand für jede mögliche Kombination aus Artikel und Lager. Aus diesem Grund können Sie sich für jeden beliebigen Artikel den Lagerbestand in einem bestimmten Lager zu einem bestimmten Datum anzeigen lassen.
 
diff --git a/erpnext/docs/user/manual/de/support/index.md b/erpnext/docs/user/manual/de/support/index.md
index a4bb1f4..3b43a4d 100644
--- a/erpnext/docs/user/manual/de/support/index.md
+++ b/erpnext/docs/user/manual/de/support/index.md
@@ -5,6 +5,6 @@
 
 In diesem Modul können Sie eingehende Supportanfragen über Supporttickets abwickeln. Sie können somit auch Kundenanfragen zu bestimmten Seriennummern im Auge behalten und diese basierend auf der Garantie und anderen Informationen beantworten. Weiterhin können Sie Wartungspläne für Seriennummern erstellen und Wartungsbesuche bei Ihren Kunden aufzeichnen.
 
-Themen
+### Themen
 
 {index}
diff --git a/erpnext/docs/user/manual/de/using-erpnext/collaborating-around-forms.md b/erpnext/docs/user/manual/de/using-erpnext/collaborating-around-forms.md
index b84dac7..3107a2b 100644
--- a/erpnext/docs/user/manual/de/using-erpnext/collaborating-around-forms.md
+++ b/erpnext/docs/user/manual/de/using-erpnext/collaborating-around-forms.md
@@ -13,6 +13,6 @@
 
 ### Schlagworte
 
-Lesen Sie hier mehr über [Schlagworte]({{docs_base_url}}/user/manual/en/collaboration-tools/tags.html)
+Lesen Sie hier mehr über [Schlagworte]({{docs_base_url}}/user/manual/de/using-erpnext/tags.html)
 
 {next}
diff --git a/erpnext/docs/user/manual/de/website/index.md b/erpnext/docs/user/manual/de/website/index.md
index 2f8b4de..ca0310b 100644
--- a/erpnext/docs/user/manual/de/website/index.md
+++ b/erpnext/docs/user/manual/de/website/index.md
@@ -13,11 +13,9 @@
 
 Wir haben uns genau das gleiche gedacht und haben deshalb eine kleine aber feine App zur Webseitenentwicklung gebaut, direkt in ERPNext! Wenn Sie das Webseitenmodul von ERPNext nutzen, können Sie:
 
-1\. Webseiten erstellen
-
-2\. Einen Blog schreiben
-
-3\. Ihren Produktkatalog basierend auf den Artikelstammdaten erstellen 
+1. Webseiten erstellen
+2. Einen Blog schreiben
+3. Ihren Produktkatalog basierend auf den Artikelstammdaten erstellen 
 
 In Kürze werden wir einen Einkaufswagen mit bereit stellen, so dass Ihre Kunden Bestellung aufgeben können und online zahlen können.
 
diff --git a/erpnext/docs/user/manual/de/website/setup/website-settings.md b/erpnext/docs/user/manual/de/website/setup/website-settings.md
index efab665..45a4498 100644
--- a/erpnext/docs/user/manual/de/website/setup/website-settings.md
+++ b/erpnext/docs/user/manual/de/website/setup/website-settings.md
@@ -7,7 +7,7 @@
 
 ### Zielseite
 
-* Homepage: Sie können angeben, welche [Webseite]({{docs_base_url}}/user/manual/en/website/web-page.html) die Startseite der Homepage ist.
+* Homepage: Sie können angeben, welche [Webseite]({{docs_base_url}}/user/manual/de/website/web-page.html) die Startseite der Homepage ist.
 * Startseite ist "Products": Wenn diese Option markiert ist, ist die Standard-Artikelgruppe die Startseite der Webseite.
 * Titel-Präfix: Stellt den Browser-Titel ein.
 
diff --git a/erpnext/docs/user/manual/de/website/web-form.md b/erpnext/docs/user/manual/de/website/web-form.md
index ce660f6..473f2c7 100644
--- a/erpnext/docs/user/manual/de/website/web-form.md
+++ b/erpnext/docs/user/manual/de/website/web-form.md
@@ -13,13 +13,10 @@
 
 > Webseite > Web-Formular > Neu
 
-1\. Geben Sie die Bezeichnung und die URL des Web-Formulars an.
-
-2\. Wählen Sie den DocType aus, in dem der Benutzer Datensätze speichern soll.
-
-3\. Geben Sie an, ob sich der Benutzer einloggen muss, Daten ändern muss, mehrere verschiedene Datensätze verwalten soll, etc.
-
-4\. Fügen Sie die Felder, die Sie in den Datensätzen haben wollen, hinzu.
+1. Geben Sie die Bezeichnung und die URL des Web-Formulars an.
+2. Wählen Sie den DocType aus, in dem der Benutzer Datensätze speichern soll.
+3. Geben Sie an, ob sich der Benutzer einloggen muss, Daten ändern muss, mehrere verschiedene Datensätze verwalten soll, etc.
+4. Fügen Sie die Felder, die Sie in den Datensätzen haben wollen, hinzu.
 
 <img class="screenshot" alt="Webformular" src="{{docs_base_url}}/assets/img/website/web-form.png">
 
diff --git a/erpnext/docs/user/manual/en/CRM/customer.md b/erpnext/docs/user/manual/en/CRM/customer.md
index 90a4228..88f9e66 100644
--- a/erpnext/docs/user/manual/en/CRM/customer.md
+++ b/erpnext/docs/user/manual/en/CRM/customer.md
@@ -21,9 +21,9 @@
 Contacts and Addresses in ERPNext are stored separately so that you can
 attach multiple Contacts or Addresses to Customers and Suppliers.
 
-Read [Contact]({{docs_base_url}}/user/manual/en/crm/contact.html) to know more.
+Read [Contact]({{docs_base_url}}/user/manual/en/CRM/contact.html) to know more.
 
-Thus we may have identical Customer Names that are uniquely identified by the ID. Since the email address is not part of the customer information the linking of customer and User is through [Contacts]({{docs_base_url}}/user/manual/en/crm/contact.html)
+Thus we may have identical Customer Names that are uniquely identified by the ID. Since the email address is not part of the customer information the linking of customer and User is through [Contacts]({{docs_base_url}}/user/manual/en/CRM/contact.html)
 
 ### Integration with Accounts
 
@@ -52,12 +52,12 @@
 “Credit Limit”. You can also set a global “Credit Limit” in the Company
 master. Classifying Customers
 
-ERPNext allows you to group your Customers using [Customer Group]({{docs_base_url}}/user/manual/en/crm/setup/customer-group.html) 
-and also divide them into [Territories]({{docs_base_url}}/user/manual/en/crm/setup/territory.html)
+ERPNext allows you to group your Customers using [Customer Group]({{docs_base_url}}/user/manual/en/CRM/setup/customer-group.html) 
+and also divide them into [Territories]({{docs_base_url}}/user/manual/en/CRM/setup/territory.html)
 Grouping will help you get better analysis of your data and
 identify which Customers are profitable and which are not. Territories will
 help you set sales targets for the respective territories.
-You can also mention [Sales Person]({{docs_base_url}}/user/manual/en/crm/setup/sales-person.html) against a customer.
+You can also mention [Sales Person]({{docs_base_url}}/user/manual/en/CRM/setup/sales-person.html) against a customer.
 
 ### Sales Partner
 
diff --git a/erpnext/docs/user/manual/en/CRM/setup/campaign.md b/erpnext/docs/user/manual/en/CRM/setup/campaign.md
index baf6ba4..9714350 100644
--- a/erpnext/docs/user/manual/en/CRM/setup/campaign.md
+++ b/erpnext/docs/user/manual/en/CRM/setup/campaign.md
@@ -4,7 +4,7 @@
 
 <img class="screenshot" alt="Campaign" src="{{docs_base_url}}/assets/img/crm/campaign.png">
 
-You can track [Lead]({{docs_base_url}}/user/manual/en/crm/lead.html), [Opportunity]({{docs_base_url}}/user/manual/en/crm/opportunity.html), [Quotation]({{docs_base_url}}/user/manual/en/selling/quotation.html) against a campaign.
+You can track [Lead]({{docs_base_url}}/user/manual/en/CRM/lead.html), [Opportunity]({{docs_base_url}}/user/manual/en/CRM/opportunity.html), [Quotation]({{docs_base_url}}/user/manual/en/selling/quotation.html) against a campaign.
 
 ###Track Leads against Campaign
 
diff --git a/erpnext/docs/user/manual/en/accounts/tools/payment-tool.md b/erpnext/docs/user/manual/en/accounts/tools/payment-tool.md
index a5d6966..2b2ec36 100644
--- a/erpnext/docs/user/manual/en/accounts/tools/payment-tool.md
+++ b/erpnext/docs/user/manual/en/accounts/tools/payment-tool.md
@@ -11,14 +11,14 @@
 6. Click on Get Outstanding Vouchers to fetch all the valid Vouchers, Invoices and Orders against which a payment can be made/received. These will appear in the Against Voucher section.
 	* __Note:__ In case User is paying a customer or receiving payment from a supplier, add the details regarding the relevant invoices and orders manually.
 
-<img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-1.png">
+   <img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-1.png">
 
 7. Once details have been fetched, click on the detail entry and enter the payment amount made against that Invoice/Order/Voucher
 
-<img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-2.png">
+   <img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-2.png">
 
 8. Click on 'Make Journal Entry' to generate a new Journal Entry with the relevant Party Details and Credit/Debit details filled in.
 
-<img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-3.png">
+   <img class="screenshot" alt="Payment Tool" src="{{docs_base_url}}/assets/img/accounts/payment-tool-3.png">
 	
 {next}
diff --git a/erpnext/docs/user/manual/en/human-resources/leave-application.md b/erpnext/docs/user/manual/en/human-resources/leave-application.md
index 59c963f..824cd04 100644
--- a/erpnext/docs/user/manual/en/human-resources/leave-application.md
+++ b/erpnext/docs/user/manual/en/human-resources/leave-application.md
@@ -17,8 +17,8 @@
 
 > Tip : If you want all users to create their own Leave Applications, you can set
 their “Employee ID” as a match rule in the Leave Application Permission
-settings. See the earlier discussion on [Setting Up Permissions]({{docs_base_url}}/user/manual/en/setting-up/users-and-permissions.html)
+settings. See the earlier discussion on [Setting Up Permissions]({{docs_base_url}}/user/manual/en/setting-up/users-and-permissions/user-permissions.html)
 for more info.
 
-You assign Leaves aginast an Employee check [Leave Allocation]({{docs_base_url}}/user/manual/en/human-resources/setup/leave-allocation.html)
+You assign Leaves aginast an Employee check [Leave Allocation]({{docs_base_url}}/user/manual/en/human-resources/leave.html)
 {next}
\ No newline at end of file
diff --git a/erpnext/docs/user/manual/en/projects/tasks.md b/erpnext/docs/user/manual/en/projects/tasks.md
index f04406f..dd9d77a 100644
--- a/erpnext/docs/user/manual/en/projects/tasks.md
+++ b/erpnext/docs/user/manual/en/projects/tasks.md
@@ -41,7 +41,7 @@
 
 ### Managing Expenses
 
-You can book [Expense Claim]({{docs_base_url}}/user/manual/en/human-resource-management/expense-claim.html) against a task.
+You can book [Expense Claim]({{docs_base_url}}/user/manual/en/human-resources/expense-claim.html) against a task.
 The system shall update the total amount from expense claims in the costing section.
 
 * To view Expense Claims made against a Task click on 'Expense Claims'
diff --git a/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-9-suppliers.md b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-9-suppliers.md
index 0e4b96a..762c984 100644
--- a/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-9-suppliers.md
+++ b/erpnext/docs/user/manual/en/setting-up/setup-wizard/step-9-suppliers.md
@@ -7,6 +7,6 @@
 
 ---
 
-To understand Suppliers in detail visit [Supplier Master]({{docs_base_url}}/user/manual/en/buying/supplier-master.html)
+To understand Suppliers in detail visit [Supplier Master]({{docs_base_url}}/user/manual/en/buying/supplier.html)
 
 {next}
diff --git a/erpnext/docs/user/manual/en/stock/delivery-note.md b/erpnext/docs/user/manual/en/stock/delivery-note.md
index 358f037..236e24b 100644
--- a/erpnext/docs/user/manual/en/stock/delivery-note.md
+++ b/erpnext/docs/user/manual/en/stock/delivery-note.md
@@ -22,7 +22,7 @@
 
 ### Shipping Packets or Items with Product Bundle
 
-If you are shipping Items that have a [Product Bundle]({{docs_base_url}}/user/manual/en/selling/setup/sales-bom.html), ERPNext will automatically
+If you are shipping Items that have a [Product Bundle]({{docs_base_url}}/user/manual/en/selling/setup/product-bundle.html), ERPNext will automatically
 create a “Packing List” table for you based on the sub-Items in that Item.
 
 If your Items are serialized, then for Product Bundle type of Items, you will have
diff --git a/erpnext/docs/user/manual/en/using-erpnext/collaborating-around-forms.md b/erpnext/docs/user/manual/en/using-erpnext/collaborating-around-forms.md
index 8ce9b68..7418d73 100644
--- a/erpnext/docs/user/manual/en/using-erpnext/collaborating-around-forms.md
+++ b/erpnext/docs/user/manual/en/using-erpnext/collaborating-around-forms.md
@@ -14,6 +14,6 @@
 
 ### Tags
 
-[Read more about Tags]({{docs_base_url}}/user/manual/en/collaboration-tools/tags.html)  
+[Read more about Tags]({{docs_base_url}}/user/manual/en/using-erpnext/tags.html)  
 
 {next}
diff --git a/erpnext/docs/user/manual/en/website/setup/index.md b/erpnext/docs/user/manual/en/website/setup/index.md
index e14b2fd..212ccfb 100644
--- a/erpnext/docs/user/manual/en/website/setup/index.md
+++ b/erpnext/docs/user/manual/en/website/setup/index.md
@@ -1,5 +1,5 @@
 Settings for your website can be mentioned under setup.
 
-###Topics
+### Topics
 
 {index}
\ No newline at end of file
diff --git a/erpnext/patches.txt b/erpnext/patches.txt
index 4758325..10af7b6 100644
--- a/erpnext/patches.txt
+++ b/erpnext/patches.txt
@@ -264,3 +264,4 @@
 erpnext.patches.v7_0.update_item_projected
 erpnext.patches.v7_0.fix_duplicate_icons
 erpnext.patches.v7_0.remove_features_setup
+erpnext.patches.v7_0.update_home_page
\ No newline at end of file
diff --git a/erpnext/patches/v7_0/remove_features_setup.py b/erpnext/patches/v7_0/remove_features_setup.py
index 2e7f893..60d1926 100644
--- a/erpnext/patches/v7_0/remove_features_setup.py
+++ b/erpnext/patches/v7_0/remove_features_setup.py
@@ -1,11 +1,13 @@
 import frappe
 
 from erpnext.setup.install import create_compact_item_print_custom_field
+from frappe.utils import cint
 
 def execute():
-	if not frappe.db.get_value("Features Setup", None, "fs_item_barcode"):
-		# hide barcode fields
-		frappe.make_property_setter(dict(fieldname='barcode', property='hidden', value=1))
+	frappe.reload_doctype('Stock Settings')
+	stock_settings = frappe.get_doc('Stock Settings', 'Stock Settings')
+	stock_settings.show_barcode_field = cint(frappe.db.get_value("Features Setup", None, "fs_item_barcode"))
+	stock_settings.save()
 
 	create_compact_item_print_custom_field()
 
diff --git a/erpnext/patches/v7_0/update_home_page.py b/erpnext/patches/v7_0/update_home_page.py
new file mode 100644
index 0000000..2cb6b40
--- /dev/null
+++ b/erpnext/patches/v7_0/update_home_page.py
@@ -0,0 +1,19 @@
+import frappe
+import erpnext
+
+def execute():
+	frappe.reload_doctype('Homepage')
+
+	website_settings = frappe.get_doc('Website Settings', 'Website Settings')
+	if frappe.db.exists('Web Page', website_settings.home_page):
+		header = frappe.db.get_value('Web Page', website_settings.home_page, 'header')
+		if header and header.startswith("<div class='hero text-center'>"):
+			homepage = frappe.get_doc('Homepage', 'Homepage')
+			homepage.company = erpnext.get_default_company()
+			homepage.tagline = header.split('<h1>')[1].split('</h1>')[0] or 'Default Website'
+			homepage.setup_items()
+			homepage.save()
+
+			website_settings.home_page = 'home'
+			website_settings.save()
+
diff --git a/erpnext/portal/doctype/homepage/homepage.json b/erpnext/portal/doctype/homepage/homepage.json
index c927e31..cbe58c7 100644
--- a/erpnext/portal/doctype/homepage/homepage.json
+++ b/erpnext/portal/doctype/homepage/homepage.json
@@ -135,7 +135,7 @@
    "print_hide_if_no_value": 0, 
    "read_only": 0, 
    "report_hide": 0, 
-   "reqd": 1, 
+   "reqd": 0, 
    "search_index": 0, 
    "set_only_once": 0, 
    "unique": 0, 
@@ -151,7 +151,7 @@
  "issingle": 1, 
  "istable": 0, 
  "max_attachments": 0, 
- "modified": "2016-05-02 18:03:13.165280", 
+ "modified": "2016-05-12 14:19:41.689519", 
  "modified_by": "Administrator", 
  "module": "Portal", 
  "name": "Homepage", 
diff --git a/erpnext/portal/doctype/homepage/homepage.py b/erpnext/portal/doctype/homepage/homepage.py
index 6f55a59..a817230 100644
--- a/erpnext/portal/doctype/homepage/homepage.py
+++ b/erpnext/portal/doctype/homepage/homepage.py
@@ -7,4 +7,19 @@
 from frappe.model.document import Document
 
 class Homepage(Document):
-	pass
+	def validate(self):
+		if not self.products:
+			self.setup_items()
+		if not self.description:
+			self.description = frappe._("This is an example website auto-generated from ERPNext")
+
+	def setup_items(self):
+		for d in frappe.get_all('Item', fields=['name', 'item_name', 'description', 'image'],
+			filters={'show_in_website': 1}, limit=3):
+
+			# set missing routes (?)
+			doc = frappe.get_doc('Item', d.name)
+			doc.save()
+			self.append('products', dict(item_code=d.name,
+				item_name=d.item_name, description=d.description, image=d.image))
+
diff --git a/erpnext/public/css/website.css b/erpnext/public/css/website.css
index de0b02b..6c239c5 100644
--- a/erpnext/public/css/website.css
+++ b/erpnext/public/css/website.css
@@ -23,7 +23,8 @@
   background-size: cover;
   background-repeat: no-repeat;
   background-position: center top;
-  border-radius: 4px;
+  border-radius-top: 4px;
+  border-radius-right: 4px;
 }
 .product-image.missing-image {
   width: 100%;
@@ -32,7 +33,8 @@
   background-size: cover;
   background-repeat: no-repeat;
   background-position: center top;
-  border-radius: 4px;
+  border-radius-top: 4px;
+  border-radius-right: 4px;
   position: relative;
   background-color: #EBEFF2;
 }
@@ -124,6 +126,12 @@
   border-top: 1px solid #d1d8dd;
   padding-top: 15px;
 }
+.order-container .tax-grand-total {
+  display: inline-block;
+  font-size: 16px;
+  font-weight: bold;
+  margin-top: 5px;
+}
 .cart-container {
   margin: 50px 0px;
 }
@@ -228,7 +236,7 @@
   height: 75px;
 }
 .product-image-wrapper {
-  padding-bottom: 30px;
+  padding-bottom: 40px;
 }
 .featured-product-heading,
 .all-products {
diff --git a/erpnext/public/less/website.less b/erpnext/public/less/website.less
index 357bb8a..37e3616 100644
--- a/erpnext/public/less/website.less
+++ b/erpnext/public/less/website.less
@@ -32,7 +32,8 @@
 	background-size: cover;
 	background-repeat: no-repeat;
 	background-position: center top;
-	border-radius: 4px;
+	border-radius-top: 4px;
+	border-radius-right: 4px;
 }
 
 .product-image.missing-image {
@@ -157,6 +158,13 @@
 		border-top: 1px solid @border-color;
 		padding-top: 15px;
 	}
+
+	.tax-grand-total {
+		display: inline-block;
+		font-size: 16px;
+		font-weight: bold;
+		margin-top: 5px;
+	}
 }
 
 .cart-container {
@@ -200,7 +208,7 @@
 		border-top: 1px solid @border-color;
 		padding-top: 15px;
 	}
-	
+
 	.cart-addresses {
 		margin-top: 50px;
 	}
@@ -209,43 +217,43 @@
 .cart-items .cart-dropdown,
 .item_name_dropdown {
 	display:none;
-	
+
 }
 .cart-dropdown-container {
 	width: 320px;
 	padding: 15px;
-	
+
 	.item-price {
 		display: block !important;
 		padding-bottom: 10px;
 	}
-	
+
 	.cart-item-header {
 		border-bottom: 1px solid #d1d8dd;
 	}
-	
+
 	.cart-items .cart-dropdown {
 		display:block;
 	   	margin-top:15px;
 	}
-		
+
 	.item_name_dropdown {
 		display:block;
 	}
-	
+
 	.item-description,
 	.cart-items .checkout,
 	.item_name_and_description {
 		display: none;
 	}
-	
+
 	.checkout-btn {
 		padding-top:25px;
 	}
 	.col-name-description {
 		margin-bottom:8px;
 	}
-	
+
 }
 
 .product-list-link {
@@ -281,20 +289,20 @@
 	margin-top: 30px;
 }
 
-.product-image-img {	
+.product-image-img {
 	border: 1px solid @light-border-color;
 	border-radius: 3px;
 }
 
-.product-text {	
+.product-text {
 	border-top: 1px solid @light-border-color;
 	padding: 15px;
 	word-wrap: break-word;
 	height: 75px;
 }
 
-.product-image-wrapper {	
-	padding-bottom: 30px;
+.product-image-wrapper {
+	padding-bottom: 40px;
 }
 
 
@@ -302,11 +310,11 @@
  text-transform: uppercase;
  letter-spacing: 0.5px;
  font-size: 12px;
- font-weight: 500;	
+ font-weight: 500;
 }
 
 .all-products {
- font-weight: 300;	
+ font-weight: 300;
  padding-left: 25px;
  padding-right: 25px;
  padding-top: 10px;
diff --git a/erpnext/setup/doctype/item_group/item_group.py b/erpnext/setup/doctype/item_group/item_group.py
index d7dae68..dc30de1 100644
--- a/erpnext/setup/doctype/item_group/item_group.py
+++ b/erpnext/setup/doctype/item_group/item_group.py
@@ -74,7 +74,7 @@
 	child_groups = ", ".join(['"' + i[0] + '"' for i in get_child_groups(product_group)])
 
 	# base query
-	query = """select name, item_name, item_code, page_name, website_image, thumbnail, item_group,
+	query = """select name, item_name, item_code, page_name, image, website_image, thumbnail, item_group,
 			description, web_long_description as website_description,
 			concat(parent_website_route, "/", page_name) as route
 		from `tabItem`
diff --git a/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html b/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html
index fe8a963..cd4d977 100644
--- a/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html
+++ b/erpnext/setup/page/welcome_to_erpnext/welcome_to_erpnext.html
@@ -22,7 +22,7 @@
 			<ul class="list-unstyled">
 				<li><a class="text-muted" href="#">{%= __("Go to the Desktop and start using ERPNext") %}</a></li>
 				<li><a class="text-muted" href="#modules/Learn">{%= __("View a list of all the help videos") %}</a></li>
-				<li><a class="text-muted" href="https://manual.erpnext.com" target="_blank">{%= __("Read the ERPNext Manual") %}</a></li>
+				<li><a class="text-muted" href="https://frappe.github.io/erpnext/user" target="_blank">{%= __("Read the ERPNext Manual") %}</a></li>
 				<li><a class="text-muted" href="https://discuss.erpnext.com" target="_blank">{%= __("Community Forum") %}</a></li>
 			</ul>
 
diff --git a/erpnext/setup/setup_wizard/data/sample_home_page.css b/erpnext/setup/setup_wizard/data/sample_home_page.css
deleted file mode 100644
index 723bcb9..0000000
--- a/erpnext/setup/setup_wizard/data/sample_home_page.css
+++ /dev/null
@@ -1,40 +0,0 @@
-.page-header {
-	color: white;
-	background: #263248;
-	text-align: center;
-	padding: 80px 0px;
-}
-
-.page-header .page-header-left {
-	width: 100%;
-}
-
-.page-header h1 {
-	color: white;
-}
-
-.slide h2 {
-	margin-bottom: 30px;
-}
-
-.slides {
-	margin-top: -15px;
-}
-
-.slide {
-	padding: 30px 40px;
-	max-width: 800px;
-	margin: auto;
-}
-
-.container {
-	max-width: 900px;
-}
-
-.img-wrapper {
-	text-align: center;
-	padding: 30px;
-	background-color: #eee;
-	border-radius: 5px;
-	margin-bottom: 15px;
-}
diff --git a/erpnext/setup/setup_wizard/data/sample_home_page.html b/erpnext/setup/setup_wizard/data/sample_home_page.html
deleted file mode 100644
index 990bc1e..0000000
--- a/erpnext/setup/setup_wizard/data/sample_home_page.html
+++ /dev/null
@@ -1,28 +0,0 @@
-<div class="slides">
-	<div class="row slide">
-		<h2 class="text-center">{{ _("Awesome Products") }}</h2>
-		<div class="col-md-6 text-center">
-			<div class="img-wrapper">
-				<i class="icon-wrench text-muted" style="font-size: 100px;"></i>
-			</div>
-		</div>
-		<div class="col-md-6">
-			<p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat.</p>
-		</div>
-	</div>
-	<div class="row slide alt">
-		<h2 class="text-center">{{ _("Awesome Services") }}</h2>
-		<div class="col-md-6 text-center">
-			<div class="img-wrapper">
-				<i class="icon-phone text-muted" style="font-size: 100px;"></i>
-			</div>
-		</div>
-		<div class="col-md-6">
-			<p>Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat. Ut wisi enim ad minim veniam, quis nostrud exerci tation ullamcorper suscipit lobortis nisl ut aliquip ex ea commodo consequat.</p>
-		</div>
-	</div>
-</div>
-<p class="text-center" style="margin-bottom: 50px;">
-	<a href="/products" class="btn btn-success">Explore <i class="icon-chevron-right"></i></a>
-</p>
-<!-- no-sidebar -->
diff --git a/erpnext/setup/setup_wizard/default_website.py b/erpnext/setup/setup_wizard/default_website.py
index e8d4eb43..d137676 100644
--- a/erpnext/setup/setup_wizard/default_website.py
+++ b/erpnext/setup/setup_wizard/default_website.py
@@ -8,34 +8,27 @@
 from frappe.utils import nowdate
 
 class website_maker(object):
-	def __init__(self, company, tagline, user):
-		self.company = company
-		self.tagline = tagline
-		self.user = user
+	def __init__(self, args):
+		self.args = args
+		self.company = args.company_name
+		self.tagline = args.company_tagline
+		self.user = args.name
 		self.make_web_page()
 		self.make_website_settings()
 		self.make_blog()
 
 	def make_web_page(self):
 		# home page
-		self.webpage = frappe.get_doc({
-			"doctype": "Web Page",
-			"title": self.company,
-			"published": 1,
-			"header": "<div class='hero text-center'><h1>{0}</h1>".format(self.tagline or "Headline")+\
-				'<p>'+_("This is an example website auto-generated from ERPNext")+"</p>"+\
-				'<p><a class="btn btn-primary" href="/login">Login</a></p></div>',
-			"description": self.company + ":" + (self.tagline or ""),
-			"css": frappe.get_template("setup/setup_wizard/data/sample_home_page.css").render(),
-			"main_section": frappe.get_template("setup/setup_wizard/data/sample_home_page.html").render({
-				"company": self.company, "tagline": (self.tagline or "")
-			})
-		}).insert()
+		homepage = frappe.get_doc('Homepage', 'Homepage')
+		homepage.company = self.company
+		homepage.tag_line = self.tagline
+		homepage.setup_items()
+		homepage.save()
 
 	def make_website_settings(self):
 		# update in home page in settings
 		website_settings = frappe.get_doc("Website Settings", "Website Settings")
-		website_settings.home_page = self.webpage.name
+		website_settings.home_page = 'home'
 		website_settings.brand_html = self.company
 		website_settings.copyright = self.company
 		website_settings.top_bar_items = []
@@ -88,5 +81,5 @@
 	frappe.delete_doc("Blog Post", "welcome")
 	frappe.delete_doc("Blogger", "administrator")
 	frappe.delete_doc("Blog Category", "general")
-	website_maker("Test Company", "Better Tools for Everyone", "Administrator")
+	website_maker({'company':"Test Company", 'company_tagline': "Better Tools for Everyone", 'name': "Administrator"})
 	frappe.db.commit()
diff --git a/erpnext/setup/setup_wizard/domainify.py b/erpnext/setup/setup_wizard/domainify.py
index df4afd4..a866869 100644
--- a/erpnext/setup/setup_wizard/domainify.py
+++ b/erpnext/setup/setup_wizard/domainify.py
@@ -22,7 +22,9 @@
 		'remove_roles': ['Manufacturing User', 'Manufacturing Manager', 'Maintenance User'],
 		'properties': [
 			{'doctype': 'Item', 'fieldname': 'is_stock_item', 'property': 'default', 'value': 0},
-			{'fieldname': 'barcode', 'property': 'hidden', 'value': 1}
+		],
+		'set_value': [
+			['Stock Settings', None, 'show_barcode', 0]
 		]
 	}
 }
@@ -45,6 +47,12 @@
 		for args in data.properties:
 			frappe.make_property_setter(args)
 
+	if data.set_value:
+		for args in data.set_value:
+			doc = frappe.get_doc(args[0], args[1] or args[0])
+			doc.set(args[2], args[3])
+			doc.save()
+
 	frappe.clear_cache()
 
 def reset():
diff --git a/erpnext/setup/setup_wizard/setup_wizard.py b/erpnext/setup/setup_wizard/setup_wizard.py
index a360d4f..48766bf 100644
--- a/erpnext/setup/setup_wizard/setup_wizard.py
+++ b/erpnext/setup/setup_wizard/setup_wizard.py
@@ -35,7 +35,7 @@
 	frappe.local.message_log = []
 	setup_domain(args.get('domain'))
 
-	website_maker(args.company_name.strip(), args.company_tagline, args.name)
+	website_maker(args)
 	create_logo(args)
 
 	frappe.db.commit()
diff --git a/erpnext/shopping_cart/cart.py b/erpnext/shopping_cart/cart.py
index c85dd8f..daecaa6 100644
--- a/erpnext/shopping_cart/cart.py
+++ b/erpnext/shopping_cart/cart.py
@@ -93,7 +93,7 @@
 	set_cart_count(quotation)
 
 	context = get_cart_quotation(quotation)
-	
+
 	if cint(with_items):
 		return {
 			"items": frappe.render_template("templates/includes/cart/cart_items.html",
@@ -106,12 +106,12 @@
 			'name': quotation.name,
 			'shopping_cart_menu': get_shopping_cart_menu(context)
 		}
-		
+
 @frappe.whitelist()
 def get_shopping_cart_menu(context=None):
 	if not context:
 		context = get_cart_quotation()
-		
+
 	return frappe.render_template('templates/includes/cart/cart_dropdown.html', context)
 
 @frappe.whitelist()
@@ -307,6 +307,8 @@
 		return frappe.get_doc(party_doctype, party)
 
 	else:
+		if not cart_settings.enabled:
+			return None
 		customer = frappe.new_doc("Customer")
 		fullname = get_fullname(user)
 		customer.update({
@@ -368,6 +370,9 @@
 	if not party:
 		party = get_party()
 
+	if not party:
+		return []
+
 	address_docs = frappe.db.sql("""select * from `tabAddress`
 		where `{0}`=%s order by name limit {1}, {2}""".format(party.doctype.lower(),
 			limit_start, limit_page_length), party.name,
diff --git a/erpnext/stock/doctype/item/item.py b/erpnext/stock/doctype/item/item.py
index d403b18..9e48fed 100644
--- a/erpnext/stock/doctype/item/item.py
+++ b/erpnext/stock/doctype/item/item.py
@@ -144,22 +144,22 @@
 			return
 
 		# find if website image url exists as public
-		file = frappe.get_all("File", filters={
+		file_doc = frappe.get_all("File", filters={
 			"file_url": self.website_image
 		}, fields=["name", "is_private"], order_by="is_private asc", limit_page_length=1)
-		
-		
-		if file:
-			file = file[0]
 
-		if not file:
+
+		if file_doc:
+			file_doc = file_doc[0]
+
+		if not file_doc:
 			if not auto_set_website_image:
 				frappe.msgprint(_("Website Image {0} attached to Item {1} cannot be found")
 					.format(self.website_image, self.name))
 
 			self.website_image = None
 
-		elif file.is_private:
+		elif file_doc.is_private:
 			if not auto_set_website_image:
 				frappe.msgprint(_("Website Image should be a public file or website URL"))
 
@@ -508,21 +508,21 @@
 			clear_cache(self.page_name)
 
 		frappe.db.set_value("Item", newdn, "item_code", newdn)
-		
+
 		if merge:
 			self.set_last_purchase_rate(newdn)
 			self.recalculate_bin_qty(newdn)
-			
+
 		for dt in ("Sales Taxes and Charges", "Purchase Taxes and Charges"):
-			for d in frappe.db.sql("""select name, item_wise_tax_detail from `tab{0}` 
+			for d in frappe.db.sql("""select name, item_wise_tax_detail from `tab{0}`
 					where ifnull(item_wise_tax_detail, '') != ''""".format(dt), as_dict=1):
-				
+
 				item_wise_tax_detail = json.loads(d.item_wise_tax_detail)
 				if olddn in item_wise_tax_detail:
 					item_wise_tax_detail[newdn] = item_wise_tax_detail[olddn]
 					item_wise_tax_detail.pop(olddn)
-					
-					frappe.db.set_value(dt, d.name, "item_wise_tax_detail", 
+
+					frappe.db.set_value(dt, d.name, "item_wise_tax_detail",
 						json.dumps(item_wise_tax_detail), update_modified=False)
 
 	def set_last_purchase_rate(self, newdn):
@@ -620,8 +620,8 @@
 			variant = get_variant(self.variant_of, args, self.name)
 			if variant:
 				frappe.throw(_("Item variant {0} exists with same attributes")
-					.format(variant), ItemVariantExistsError)			
-			
+					.format(variant), ItemVariantExistsError)
+
 
 @frappe.whitelist()
 def get_dashboard_data(name):
diff --git a/erpnext/stock/doctype/stock_settings/stock_settings.json b/erpnext/stock/doctype/stock_settings/stock_settings.json
index d56daf5..4a6e6e9 100644
--- a/erpnext/stock/doctype/stock_settings/stock_settings.json
+++ b/erpnext/stock/doctype/stock_settings/stock_settings.json
@@ -2,6 +2,7 @@
  "allow_copy": 0, 
  "allow_import": 0, 
  "allow_rename": 0, 
+ "beta": 0, 
  "creation": "2013-06-24 16:37:54", 
  "custom": 0, 
  "description": "Settings", 
@@ -188,6 +189,32 @@
    "allow_on_submit": 0, 
    "bold": 0, 
    "collapsible": 0, 
+   "default": "1", 
+   "fieldname": "show_barcode_field", 
+   "fieldtype": "Check", 
+   "hidden": 0, 
+   "ignore_user_permissions": 0, 
+   "ignore_xss_filter": 0, 
+   "in_filter": 0, 
+   "in_list_view": 0, 
+   "label": "Show Barcode Field", 
+   "length": 0, 
+   "no_copy": 0, 
+   "permlevel": 0, 
+   "precision": "", 
+   "print_hide": 0, 
+   "print_hide_if_no_value": 0, 
+   "read_only": 0, 
+   "report_hide": 0, 
+   "reqd": 0, 
+   "search_index": 0, 
+   "set_only_once": 0, 
+   "unique": 0
+  }, 
+  {
+   "allow_on_submit": 0, 
+   "bold": 0, 
+   "collapsible": 0, 
    "fieldname": "section_break_7", 
    "fieldtype": "Section Break", 
    "hidden": 0, 
@@ -487,7 +514,7 @@
  "issingle": 1, 
  "istable": 0, 
  "max_attachments": 0, 
- "modified": "2016-04-15 06:51:47.497431", 
+ "modified": "2016-05-12 12:28:29.374452", 
  "modified_by": "Administrator", 
  "module": "Stock", 
  "name": "Stock Settings", 
@@ -517,5 +544,6 @@
  "quick_entry": 1, 
  "read_only": 0, 
  "read_only_onload": 0, 
+ "sort_order": "ASC", 
  "track_seen": 0
 }
\ No newline at end of file
diff --git a/erpnext/stock/doctype/stock_settings/stock_settings.py b/erpnext/stock/doctype/stock_settings/stock_settings.py
index bd71d46..7c67a65 100644
--- a/erpnext/stock/doctype/stock_settings/stock_settings.py
+++ b/erpnext/stock/doctype/stock_settings/stock_settings.py
@@ -6,11 +6,9 @@
 from __future__ import unicode_literals
 import frappe
 from frappe import _
-from frappe.utils import cint
 from frappe.model.document import Document
 
 class StockSettings(Document):
-
 	def validate(self):
 		for key in ["item_naming_by", "item_group", "stock_uom", "allow_negative_stock"]:
 			frappe.db.set_default(key, self.get(key, ""))
@@ -25,4 +23,6 @@
 			self.stock_frozen_upto_days = stock_frozen_limit
 			frappe.msgprint (_("`Freeze Stocks Older Than` should be smaller than %d days.") %stock_frozen_limit)
 
-
+		# show/hide barcode field
+		frappe.make_property_setter({'fieldname': 'barcode', 'property': 'hidden',
+			'value': 0 if self.show_barcode_field else 1})
diff --git a/erpnext/support/doctype/warranty_claim/warranty_claim.js b/erpnext/support/doctype/warranty_claim/warranty_claim.js
index 0511ff6..cf9d806 100644
--- a/erpnext/support/doctype/warranty_claim/warranty_claim.js
+++ b/erpnext/support/doctype/warranty_claim/warranty_claim.js
@@ -3,8 +3,6 @@
 
 frappe.provide("erpnext.support");
 
-{% include "erpnext/public/js/utils.js" %}
-
 frappe.ui.form.on("Warranty Claim", {
 	customer: function(frm) {
 		erpnext.utils.get_party_details(frm);
diff --git a/erpnext/templates/generators/item.html b/erpnext/templates/generators/item.html
index e074fa3..cf6f89b 100644
--- a/erpnext/templates/generators/item.html
+++ b/erpnext/templates/generators/item.html
@@ -20,7 +20,7 @@
 			</div>
 			<div class="col-sm-6" style="padding-left:20px;">
 				 <h2 itemprop="name" style="margin-top: 0px;">{{ item_name }}</h2>
-				
+
 				<p class="text-muted">
 					{{ _("Item Code") }}: <span itemprop="productID">{{ variant and variant.name or name }}</span></p>
 				<br>
@@ -55,7 +55,7 @@
 					<div itemprop="offers" itemscope itemtype="http://schema.org/Offer">
 						<h4 class="item-price" itemprop="price"></h4>
 						<div class="item-stock" itemprop="availability"></div>
-					</div>	
+					</div>
                     <div class="item-cart hide">
     					<div id="item-add-to-cart">
     						<button class="btn btn-primary btn-sm">
@@ -79,7 +79,7 @@
 		</div>
 		</div>
 		</div>
-		
+
 		{% if website_specifications -%}
 		<div class="row item-website-specification" style="margin-top: 40px">
 			<div class="col-md-12">
diff --git a/erpnext/templates/includes/order/order_macros.html b/erpnext/templates/includes/order/order_macros.html
index 1bb7b2c..3f8affe 100644
--- a/erpnext/templates/includes/order/order_macros.html
+++ b/erpnext/templates/includes/order/order_macros.html
@@ -9,15 +9,15 @@
         </div>
         <div class="col-xs-8 col-sm-10">
             {{ d.item_code }}
-            <p class="text-muted small item-description">{{ d.description }}</p>
+            <div class="text-muted small item-description">{{ d.description }}</div>
         </div>
     </div>
-	
+
     <div class="row item_name_dropdown">
         <div class="col-xs-4 col-sm-4 order-image-col">
             <div class="order-image">
               <span class="cart-count-badge pull-right small"> {{ d.get_formatted('qty') }} </span>{{ product_image_square(d.image) }}
-            </div>		
+            </div>
         </div>
         <div class="col-xs-8 col-sm-8">
             {{ d.item_code }}
diff --git a/erpnext/templates/includes/order/order_taxes.html b/erpnext/templates/includes/order/order_taxes.html
index 564e31e..24ae088 100644
--- a/erpnext/templates/includes/order/order_taxes.html
+++ b/erpnext/templates/includes/order/order_taxes.html
@@ -13,9 +13,9 @@
 </div>
 {% endfor %}
 <div class="row tax-grand-total-row">
-    <div class="col-xs-8 text-right">{{ _("Grand Total") }}</div>
+    <div class="col-xs-8 text-right text-uppercase h6 text-muted">{{ _("Grand Total") }}</div>
     <div class="col-xs-4 text-right">
-        <span class="tax-grand-total">
+        <span class="tax-grand-total bold">
             {{ doc.get_formatted("grand_total") }}
         </span>
     </div>
diff --git a/erpnext/templates/includes/transaction_row.html b/erpnext/templates/includes/transaction_row.html
index 2165a06..17f9b90 100644
--- a/erpnext/templates/includes/transaction_row.html
+++ b/erpnext/templates/includes/transaction_row.html
@@ -3,17 +3,17 @@
 		<div class="row">
 			<div class="col-sm-5">
 				<span class="indicator small {{ doc.indicator_color or "darkgrey" }}">
-				{{ doc.name }}</span>	
+				{{ doc.name }}</span>
 				<div class="small text-muted transaction-time"
 					title="{{ frappe.utils.format_datetime(doc.modified, "medium") }}">
 					{{ frappe.utils.format_datetime(doc.modified, "medium") }}
-				</div>			
+				</div>
 			</div>
 			<div class="col-sm-4 items-preview text-ellipsis">
 				{{ doc.items_preview }}
 			</div>
-			<div class="col-sm-3 text-right">
-				{{ doc.get_formatted("grand_total") }}				
+			<div class="col-sm-3 text-right bold">
+				{{ doc.get_formatted("grand_total") }}
 			</div>
 			<!-- <div class="col-sm-3 text-right">
 
diff --git a/erpnext/templates/pages/home.html b/erpnext/templates/pages/home.html
index 5ec396d..689d94e 100644
--- a/erpnext/templates/pages/home.html
+++ b/erpnext/templates/pages/home.html
@@ -27,7 +27,7 @@
 				</div>
 			</div>
 			<!-- TODO: remove hardcoding of /products -->
-			<div class=" text-center text-uppercase"><a href="/products" class="btn btn-primary all-products">  {{ _("View All Products") }}</a></div>
+			<div class="text-center"><a href="/products" class="btn btn-primary all-products">  {{ _("View All Products") }}</a></div>
 		</div>
 		{% endif %}
 	</div>
@@ -46,7 +46,7 @@
 	.btn-login {
 		width: 80px;
 	}
-	
-	
+
+
 </style>
 {% endblock %}
diff --git a/erpnext/templates/pages/home.py b/erpnext/templates/pages/home.py
index e7ff2ce..4440f7e 100644
--- a/erpnext/templates/pages/home.py
+++ b/erpnext/templates/pages/home.py
@@ -3,19 +3,27 @@
 
 from __future__ import unicode_literals
 import frappe
-from frappe.utils import cstr, nowdate
-from erpnext.setup.doctype.item_group.item_group import get_item_for_list_in_html
 
 no_cache = 1
 no_sitemap = 1
 
 def get_context(context):
 	homepage = frappe.get_doc('Homepage')
-	
+
 	for item in homepage.products:
-		item.route = '/' + '/'.join(frappe.db.get_value('Item', item.item_code, ['parent_website_route', 'page_name']))
-		
-	
+		parent_website_route, page_name = frappe.db.get_value('Item', item.item_code,
+			['parent_website_route', 'page_name'])
+		item.route = '/' + '/'.join(filter(None, [parent_website_route, page_name]))
+
+	# show atleast 3 products
+	if len(homepage.products) < 3:
+		for i in xrange(3 - len(homepage.products)):
+			homepage.append('products', {
+				'item_code': 'product-{0}'.format(i),
+				'item_name': frappe._('Product {0}').format(i),
+				'route': '#'
+			})
+
 	return {
 		'homepage': homepage
 	}
\ No newline at end of file
diff --git a/erpnext/templates/pages/order.html b/erpnext/templates/pages/order.html
index 98f7431..61b4546 100644
--- a/erpnext/templates/pages/order.html
+++ b/erpnext/templates/pages/order.html
@@ -59,7 +59,7 @@
             <div class="col-sm-2 col-xs-3 text-right">
                 {{ d.get_formatted("amount")	 }}
                 <p class="text-muted small">{{
-                    _("Rate: {0}").format(d.get_formatted("rate")) }}</p>
+                    _("@ {0}").format(d.get_formatted("rate")) }}</p>
             </div>
         </div>
         {% endfor %}
