Shipping Request Form Template: Fill & Download for Free

I found a template that contains a lot of mail templates that are being used at ecommerce websites. Big plus is that it also contains a Chinese version of each email besides the English version. Includes:Payment reminder templatePayment confirmation templateShipment send messageOrder received messagePackage damage messageOrder received thanks messageOut of stock messageDiscount request responsePayment reminderPayment confirmation messageStatus shipment query responseShipment received confirmation messageThanks messageFeedback request messageLow price request messageInquiry request messageFree shipping request answerDiscount offer answerBusiness trust messageShipping issue resolve answerChristmas offerThanks for comment messageDrop shipping service messageYou can find this free template at the following location: Free Service email message in Chinese and English

Rather than answer the precise question, it’s more important to make a fundamental distinction very clear.Django (using the Python language) is, like Rails (using the Ruby language), a server-side solution to creating dynamic websites/web apps. There is nothing in this approach that parallels the using of Angular (or React) in the browser (front-end).The primary purpose of a Django/Rails server-side solution is to provide for server-side rendering, in which all of the business logic and all of the templates to create the page displays in HTML are on the server. (This is why these solutions can be entirely in Python or Ruby, because JavaScript — the language of the browser — is not needed.). In a Django or Rails application, the user (meaning the browser) is making requests on the Django (or Rails) server, and that server figures out everything that should happen in response to a request, including getting any necessary data from the database and composing/customizing that data into html pages (rendered HTML) using templates. The server then simply ships the finished web page down to the browser to replace the current page.By contrast, Angular (and React) embrace the more modern approach of the so-called Single Page Application (SPA). In this approach, as much as possible of the business logic, and all of the HTML display templates, are provided in a JavaScript application running in the browser. After an initial download of everything needed by the browser, and the loading of the initial HTML page, the browser app will never request a replacement page, but will rather provide the entire user experience (which appears the same as changing “pages”) from its own logic, using the HTML templates it has already downloaded, and will only make XHR/AJAX requests on the server for raw data in JSON form. This is client-side rendering, something very important on mobile because full page swaps from the server can be very slow on mobile. The SPA is taking over because it feels so much more responsive to the mobile user.There is much more to understand, but this is basic. It means that your main choice is between the traditional server-driven, server-rendered application and the more modern client-rendered, front-end SPA backed by only data services (typically a REST API) from the server. Not between Django/Python and Node/Angular specifically.If you go with the SPA using Angular or React (or any other alternative), your server can be anything you choose. Node.js (meaning most probably express.js) is great for many reasons in the SPA context, not least because it means programming the “full stack” (client and server apps) in a single language — JavaScript. But you can build the same kind of server in Django (or other Python-based approach) or Rails or using any useful language for building http servers. The only point is that, if you are using Django or Rails, you won’t be taking advantage of the templates and server-side rendering, and will be just using it for a static server (to download file contents) and a data server (to download raw data from a database in JSON format).Extra credit/confusion: You can definitely do server-side rendering on a node/express server using templates, and there are reasons to do this even with SPA’s — mostly to download the first page of a website/web app in pre-rendered form to give the user immediate gratification before the whole client-side app starts running. (In Angular, this is provided via Angular Universal.) But this is not the main thrust of the SPA concept at all. (If this final point confuses you, just forget about it until you understand the basics.)

Let’s back up for a second to get the bigger picture.In the old days, all of the business logic with respect to a website/web app was on the server side. Take Rails as the classic example.The client side of the application — what the user sees in the browser — operates as follows:The user makes some choice about something he or she wants to see or do.The client app turns this request into a “route” — a classic URL. Like what you see in the address bar when you request a single question in Quora by clicking on a link. This route is sent to the server in a standard HTTP request.This URL or “route” is parsed by the server to figure out what the user wanted. The server then pulls whatever is needed from the database and then composes a HTML page using templates customized with the specific data — like the question and answers in the Quora example. This is called “server-side rendering” and the “router” was effectively on the server as the functionality that determined how to respond to the URL.The HTML page is then shipped down to the browser to replace the current page entirely.Quora still works like this, not only because it’s been around for a while, but also because, until recently, server-side rendering was the only way to feel assured of strong SEO (search engine optimization).Fast forward to now and the world of the Single Page Application (SPA). This is the opposite of server-side rendering, and is driven by the pressures of the mobile experience, which really stalls every time you swap a full html page out of a mobile browser (many, many seconds delay). The idea is that all possible business logic is moved to the client-side application. After the initial download, the app will only ask the server for raw data — which the client will compose into HTML using templates. Thus server-side rendering is replaced with client-side rendering. (“Rendering” meaning the process of composing the HTML elements that the browser DOM will use to create the display.)Note that this SPA approach — which is that of Angular and React as well as other frameworks — involves downloading a complete HTML page only once. From that point on, everything is handled by JavaScript running in the browser. But — to simplify and leave out some other factors — the user still wants to know “where they are” in the app, and especially wants to have real URL “links” associated with a given “page” so that the same screen can be recalled at will from the URL, perhaps from browser history but also in every other way. And search engines — like Google — absolutely need linkable URLs to be generated by SPA’s or the search engines become worthless.Thus enter client-side routers — which like all of the front-end app are implemented in JavaScript. The idea is to transparently preserve the classic user experience with URLs. But instead of the URL being something to request from a server, it is just a means of capturing the precise client-side HTML template and the precise data (from the server, if necessary) to fill it out. So you can understand “routes” as snapshots of desired screens (UI states) reflecting their associated data states — and routers as the JavaScript libraries that create these routes. These routers are among the most sophisticated and challenging parts of contemporary SPA frameworks, and the development of Angular’s went through such major contortions that it delayed the final release of the platform by many months. (But it was worth it because this has to be right.)Note that this does not mean that routers have disappeared from the server, even in the SPA context. The standard REST API on the server — from which your front-end app will request raw JSON data (instead of rendered HTML) — involves the same classic routing. In other words, the client app requests data by sending up an AJAX/XHR request with a specific URL, and the routing functionality of the server parses it to figure out what data to return to the client. The only difference — though a big difference — is that the server returns only the data and does not compose (render) it into HTML.