Erstellen eines CMS: goPress

package goPress

//

// Package:          goPress

//

// Description:		This package is for the goPress CMS

//     				written in the go programming

//					language made by Google. This package

// 					defines everything for a full

//					CMS.

//

//

// Import the libraries we use for this program.

//

import (

	"encoding/json"

	"github.com/hoisie/web"

	"io/ioutil"

	"log"

	"os"

	"strings"

)

//

// Define a structure to contain all the information

// important to the CMS. Capticalized

// variables within the structure is imported 

// and exported.

//

type goPressData struct {

	CurrentLayout  string

	CurrentStyling string

	ServerAddress  string

	SiteTitle      string

	Sitebase       string

	TemplatBase    string

	CapatchaWidth  int

	CapatchaHeight int

	Cache          bool

	MainBase       string

	content        map[string]string

	layoutBase     string

	mainpg         string

	postbase       string

	scripts        string

	stylesheet     string

	stylingBase    string

	template       string

}

var SiteData = new(goPressData)

var ServerParamFile string = "server.json"

//

// Function:		GetGlobals

//

// Description:		This function is used to create the

// 					global variables initialize the

//					global variables.

//

// Inputs:

//

func GetGlobals() {

	//

	// Load the Server Parameters from a file.

	//

	LoadServerParameters()

	//

	// Setup the basic paths to everything.

	//

	SiteData.layoutBase = SiteData.TemplatBase + "layouts/"

	SiteData.stylingBase = SiteData.TemplatBase + "styling/"

	SiteData.postbase = SiteData.Sitebase + "posts/"

	//

	// Create the content array that will hold the site 

	// fragments. Set the title now.

	//

	SiteData.content = make(map[string]string)

	SiteData.content["title"] = SiteData.SiteTitle

	//

	// Log that the data is being loaded.

	//

	log.Println("Loading data for site: " + SiteData.SiteTitle)

	//

	// Get all the basic information that is generic and 

	// in the styles and layout directories.

	// These will then be over written if a new default 

	// in the site area is found. This gives

	// the flexibility to load defaults from a directory 

	// without having to make sure that all

	// the necessary ones are loaded.

	//

	//

	// Get the 404 page contents

	//

	SiteData.content["404"] = GetPageContents(SiteData.stylingBase + SiteData.CurrentStyling + "/404")

	//

	// Get the sidebar contents

	//

	SiteData.content["sidebar"] = GetPageContents(SiteData.stylingBase + SiteData.CurrentStyling + "/sidebar")

	//

	// Get the footer contents

	//

	SiteData.content["footer"] = GetPageContents(SiteData.stylingBase + SiteData.CurrentStyling + "/footer")

	//

	// Get the template contents

	//

	SiteData.template = GetPageContents(SiteData.layoutBase + SiteData.CurrentLayout + "/template")

	//

	// Get the header contents

	//

	SiteData.content["header"] = GetPageContents(SiteData.stylingBase + SiteData.CurrentStyling + "/header")

	//

	// Get the main page contents

	//

	SiteData.mainpg = GetPageContents(SiteData.Sitebase + "pages/" + "main")

	//

	// The following will load page parts from the 

	// "parts" directory for the site. These might

	// overload those already defined or add new stuff 

	// that the users site templates

	// will need.

	//

	partsdir := SiteData.Sitebase + "parts/"

	//

	// Read the directory.

	//

	fileList, err := ioutil.ReadDir(partsdir)

	if err != nil {

		//

		// Error reading the directory.

		//

		log.Printf("Error reading directory: %s\n", partsdir)

	} else {

		//

		// Get the number of items in the directory list.

		//

		count := len(fileList)

		//

		// Loop through each directory element.

		//

		for i := 0; i < count; i++ {

			if !fileList[i].IsDir() {

				//

				// It is a file. Read it and add to the 

				// scripts variable.

				//

				filename := fileList[i].Name()

				parts := strings.Split(filename, ".")

				if filename != ".DS_Store" {

					SiteData.content[parts[0]] = LoadFile(partsdir + filename)

				}

			}

		}

	}

	//

	// Clear out the global variables not set.

	//

	SiteData.scripts = ""

	SiteData.stylesheet = ""

}

//

// Function:		SaveServerParameters

//

// Description:		This function is for saving the 

// 					authorization secret for DropBox.

//

// Inputs:

//

func SaveServerParameters() {

	if wfile, err := os.Create(ServerParamFile); err == nil {

		enc := json.NewEncoder(wfile)

		enc.Encode(&SiteData)

		wfile.Close()

	} else {

		log.Println("Writing Server file denied.")

	}

}

//

// Function:		LoadServerParameters

//

// Description:		This function is used to load the 

//					parameters for this server.

//

// Inputs:

//

func LoadServerParameters() {

	if wfile, err := os.Open(ServerParamFile); err == nil {

		enc := json.NewDecoder(wfile)

		enc.Decode(&SiteData)

		wfile.Close()

		log.Println("Read the " + ServerParamFile + " server parameter file. Site Title is: " + SiteData.SiteTitle)

	} else {

		log.Println("No Server File found.")

	}

}

//

// Function:		DefaultRoutes

//

// Description:		This function sets the default 

//					routes for a CMS.

//

// Inputs:

//

func DefaultRoutes() {

	SetGetRoute("/", Mainpage)

	SetGetRoute("/sitemap.xml", SiteMap)

	SetGetRoute("/stylesheets.css", GetStylesheets)

	SetGetRoute("/scripts.js", GetScripts)

	SetGetRoute("/theme/images/(.*)", LoadThemeImage)

	SetGetRoute("/(favicon.ico)", ImagesLoad)

	SetGetRoute("/images/(.*)", ImagesLoad)

	SetGetRoute("/posts/([a-zA-Z0-9]*)/([a-zA-Z0-9]*)", PostIndex)

	SetGetRoute("/posts/([a-zA-Z0-9]*)/([a-zA-Z0-9]*)/(.*)", PostPages)

	SetGetRoute("/(.*)", TopPages)

}

//

// Function:		SetGetRoute

//

// Description:		This function gives an easy access 

//					to the web variable setup in this 

//					library.

//

// Inputs:

// 		route 		Route to setup

//		handler		Function to run that route.

//

func SetGetRoute(route string, handler interface{}) {

	web.Get(route, handler)

}

//

// Function:		StartServer

//

// Description:		This function is for starting the web 

//					server using the SiteData 

//					configuration.

//

// Inputs:

//

func StartServer(serverAddress string) {

	web.Run(serverAddress)

}

package goPress

import (

	"bytes"

	"encoding/json"

	"github.com/eknkc/amber"

	"github.com/hoisie/web"

	"github.com/murz/go-handlebars/handlebars"

	"github.com/russross/blackfriday"

	"io/ioutil"

	"log"

	"os"

	"strings"

	"time"

)

//

// Function: 		Mainpage

//

// Description: 	This function is used to generate 

// 					and display the main page for the

// 					web site. This function will guide 

// 					the user to setup the DropBox

// 					account if this is the first time 

// 					being ran or the dropbox 

// 					authorization secret gets zeroed.

//

// Inputs:

//					ctx 	Contents from the request

//

func Mainpage(ctx *web.Context) string {

	//

	// Render the main page.

	//

	page := RenderPageContents(ctx, SiteData.mainpg, SiteData.Sitebase+"pages/main")

	return page

}

//

// Function: 		SiteMap

//

// Description: 	This function is to give a site map 

//					to requesters.

//

// Inputs:

//					ctx 	Contents from the request

//

func SiteMap(ctx *web.Context) string {

	var contents string

	wfile, err := os.Open(SiteData.Sitebase + "sitemap.xml")

	if err == nil {

		bcontents, _ := ioutil.ReadAll(wfile)

		contents = string(bcontents)

		wfile.Close()

	}

	return contents

}

//

// Function: 		PostPages

//

// Description: 	This function generates the needed 

//					post page.

//

// Inputs:

//                    ctx        What the browser sends

//                    posttype   The type of post

//                    postname   The name of the post 

//									type instance

//                    val        The name of the post 

//									page to display

//

func PostPages(ctx *web.Context, posttype string, postname string, val string) string {

	//

	// Get the page contents and process it.

	//

	pgloc := SiteData.postbase + posttype + "/" + postname + "/" + val

	return RenderPageContents(ctx, GetPageContents(pgloc), pgloc)

}

//

// Function:          PostIndex

//

// Description:       This function generates the needed post index.

//

// Inputs:

//                    ctx       What the browser sends

//                    posttype  The type of post

//                    postname  The name of the post type instance

//

func PostIndex(ctx *web.Context, posttype string, postname string) string {

	//

	// Get the page contents and process it.

	//

	pgloc := SiteData.postbase + posttype + "/" + postname + "/index"

	return RenderPageContents(ctx, GetPageContents(pgloc), pgloc)

}

//

// Function: 		topPages

//

// Description: 	This function will generate a 

//					"static" top level page that is not

// 					a post page.

//

// Inputs:

//                    val         The name of the top level page

//

func TopPages(ctx *web.Context, val string) string {

	//

	// Look for the markdown of the page.

	//

	pgloc := SiteData.Sitebase + "pages/" + val

	return RenderPageContents(ctx, GetPageContents(pgloc), pgloc)

}

//

// Function: 		GetPageContents

//

// Description: 	This function is used to retrieve 

//					the page contents. It will first look 

//					for a markdown page, then for a html 

//					page, and then it looks for an amber

//					page.

//

// Inputs:

//					filename 		The name of the file

//

func GetPageContents(filename string) string {

	//

	// Assume the page can not be found.

	//

	contents := SiteData.content["404"]

	//

	// Let's look for a markdown version first.

	//

	wfile, err := os.Open(filename + ".md")

	if err == nil {

		bcontents, _ := ioutil.ReadAll(wfile)

		wfile.Close()

		contents = string(blackfriday.MarkdownCommon(bcontents))

		//

		// Double quotes were turned into “ and

		// ”. Turn them back. Without this, and 

		// Handlebar macros will be broken.

		//

		contents = strings.Replace(contents, "“", "\"", -1)

		contents = strings.Replace(contents, "”", "\"", -1)

	} else {

		//

		// It must be an html. Look for that.

		//

		wfile, err = os.Open(filename + ".html")

		if err == nil {

			bcontents, _ := ioutil.ReadAll(wfile)

			contents = string(bcontents)

			wfile.Close()

		} else {

			//

			// It must be an amber. Look for that.

			//

			wfile, err = os.Open(filename + ".amber")

			if err == nil {

				wfile.Close()

				template, err2 := amber.CompileFile(filename+".amber", amber.Options{true, false})

				if err2 != nil {

					//

					// Bad amber file.

					log.Println("Amber file bad: " + filename)

				} else {

					//

					// Put the default site info.

					//

					pgData := SiteData.content

					//

					// read in that pages specific data 

					// to be added to the rest

					// of the data. It is stored at the 

					// same place, but in a json

					// file.

					//

					if wfile, err := os.Open(filename + ".json"); err == nil {

						//

						// Load the json file of extra 

						// data for this page. This could 

						// override the standard data as 

						// well.

						//

						enc := json.NewDecoder(wfile)

						enc.Decode(&pgData)

						wfile.Close()

					} else {

						log.Println("The page: " + filename + " did not have a json file.")

					}

					pgData["PageName"] = filename

					//

					// The amber source compiles okay. 

					// Run the template and return

					// the results.

					//

					var b bytes.Buffer

					template.Execute(&b, pgData)

					contents = b.String()

				}

			} else {

				//

				// A file could not be found.

				//

				log.Println("Could not find file:  " + filename)

			}

		}

	}

	//

	// Return the file contains obtained.

	//

	return contents

}

//

// Function: 		RenderPageContents

//

// Description: 	This function is used to process 

//					and render the contents of a page.

// 					It can be the main page, or a post 

//					page, or any page. It accepts the

// 					input as the contents for the page 

//					template, run the page template

// 					with it, process all shortcodes and 

//					embedded codes, and return the

// 					results.

//

// Inputs:

//				ctx				The calling context

// 				contents 		The pages main contents.

//				filename		The name of the file the 

//								contents was taken from.

//

func RenderPageContents(ctx *web.Context, contents string, filename string) string {

	//

	// Set the header information

	//

	SetStandardHeader(ctx)

	//

	// Put the default site info.

	//

	pgData := SiteData.content

	//

	// Add data specific to this page.

	//

	pgData["content"] = contents

	//

	// read in that pages specific data to be added to 

	// the rest of the data. It is stored at the same 

	// place, but in a json file.

	//

	if wfile, err := os.Open(filename + ".json"); err == nil {

		//

		// Load the json file of extra data for this 

		// page. This could override the standard data as 

		// well.

		//

		enc := json.NewDecoder(wfile)

		enc.Decode(&pgData)

		wfile.Close()

	} else {

		log.Println("The page: " + filename + " did not have a json file.")

	}

	//

	// Set the Page Name data field.

	//

	pgData["PageName"] = filename

	//

	// Register the helpers.

	//

	// NOTICE:	All helpers can not have spaces in the 

	//			parameter. Therefore, all of these 

	//			helpers assume a "-" is a space. It gets 

	//			translated to a space before using.

	//

	// Helper: 			save

	//

	// Description:     This helper allows you do define 

	//					macros for expanding inside the 

	//					template. You give it a name, 

	//					"|", and text to expand into. 

	//					Currently, all spaces have to be 

	//					"-".

	//

	handlebars.RegisterHelper("save", func(params ...interface{}) string {

		if text, ok := params[0].(string); ok {

			parts := strings.Split(text, "|")

			content := strings.Replace(parts[1], "-", " ", -1)

			pgData[parts[0]] = content

			return content

		}

		return ""

	})

	//

	//  The format has to use these sets of constants:

	//            Stdlongmonth = "January"

	//            Stdmonth = "Jan"

	//            Stdnummonth = "1"

	//            Stdzeromonth = "01"

	//            Stdlongweekday = "Monday"

	//            Stdweekday = "Mon"

	//            Stdday = "2"

	//            Stdunderday = "_2"

	//            Stdzeroday = "02"

	//            Stdhour = "15"

	//            stdHour12 = "3"

	//            stdZeroHour12 = "03"

	//            Stdminute = "4"

	//            Stdzerominute = "04"

	//            Stdsecond = "5"

	//            Stdzerosecond = "05"

	//            Stdlongyear = "2006"

	//            Stdyear = "06"

	//            Stdpm = "Pm"

	//            Stdpm = "Pm"

	//            Stdtz = "Mst"

	//

	//  Helper:			date

	//

	//  Description: 	This helper prints the current 

	//					date/time in the format

	// 					given. Please refer to the above 

	//					chart for proper format codes. 

	//					EX:  07/20/2015 is "01/02/2006"

	//

	handlebars.RegisterHelper("date", func(params ...interface{}) string {

		if format, ok := params[0].(string); ok {

			format = strings.Replace(format, "-", " ", -1)

			tnow := time.Now()

			return tnow.Format(format)

		}

		return ""

	})

	//

	// Render the current for the first pass.

	//

	page := handlebars.Render(SiteData.template, pgData)

	//

	// Process any shortcodes on the page.

	//

	page1 := ProcessShortCodes(page)

	//

	// Render new content from Short Code and filters.

	//

	page2 := handlebars.Render(page1, pgData)

	//

	// Return the results.

	//

	return page2}

//

// Function: 		SetStandardHeader

//

// Description: 	This function is used as a one place 

//					for setting the standard

// 					header information.

//

// Inputs:

//

func SetStandardHeader(ctx *web.Context) {

	//

	// Set caching for the item

	//

	ctx.SetHeader("Cache-Control", "public", false)

	//

	// Set the maximum age to one month (30 days)

	//

	ctx.SetHeader("Cache-Control", "max-age=2592000", false)

	//

	// Set the name to gpPress for the server type.

	//

	ctx.SetHeader("Server", "goPress - a CMS written in go from Custom Computer Tools: http://customct.com.", true)

}

package goPress

import (

	"github.com/hoisie/web"

	"io"

	"io/ioutil"

	"log"

	"math/big"

	"os"

	"path/filepath"

)

//

// Function:          ImagesLoad

//

// Description:       This function is called to upload an image for the

//                    images directory.

//

// Inputs:

//                    val        Name of the image with relative path

//

func ImagesLoad(ctx *web.Context, val string) {

	LoadImage(ctx, SiteData.Sitebase+"images/"+val)

}

//

// Function:		 LoadThemeImage

//

// Description:		 This function loads images from the theme's directory.

//

// Inputs

//					 image        Name of the image file to load

//

func LoadThemeImage(ctx *web.Context, image string) {

	LoadImage(ctx, SiteData.stylingBase+SiteData.CurrentStyling+"/images/"+image)

}

//

// Function: 		LoadImage

//

// Description: 	This function does the work of 

//					loading an image file and passing it 

//					on.

//

// Inputs:

//

func LoadImage(ctx *web.Context, val string) {

	//

	// Get the file extension.

	//

	fileExt := filepath.Ext(val)

	//

	// Set the http header based on the file type.

	//

	SetStandardHeader(ctx)

	ctx.ContentType(fileExt)

	if fileExt == ".svg" {

		//

		// This is a text based file. Read it and send to the browser.

		//

		wfile, err := os.Open(val)

		if err == nil {

			bcontents, _ := ioutil.ReadAll(wfile)

			wfile.Close()

			ctx.WriteString(string(bcontents))

		}

	} else {

		//

		// This is a binary based file. Read it and sent the contents to the browser.

		//

		fi, err := os.Open(val)

		//

		// Set the size of the binary coming down the pipe. Chrome has to have this value

		// one larger than real.

		//

		finfo, _ := os.Stat(val)

		i := big.NewInt(finfo.Size())

		ctx.SetHeader("Accept-Ranges", "bytes", true)

		ctx.SetHeader("Content-Length", i.String(), true)

		if err != nil {

			log.Println(err)

			return

		}

		defer fi.Close()

		//

		// Create a buffer to contain the image data. Binary images usually get

		// very big.

		//

		buf := make([]byte, 1024)

		//

		// Go through the binary file 1K at a time and send to the browser.

		//

		for {

			//

			// Read a buffer full.

			//

			n, err := fi.Read(buf)

			if err != nil && err != io.EOF {

				log.Println(err)

				break

			}

			//

			// If nothing was read, then exit.

			//

			if n == 0 {

				break

			}

			//

			// Write the binary buffer to the browser.

			//

			n2, err := ctx.Write(buf[:n])

			if err != nil {

				log.Println(err)

				break

			} else if n2 != n {

				log.Println("Error in sending " + val + " to the browser. Amount read does not equal the amount sent.")

				break

			}

		}

	}

}

package goPress

import (

	"github.com/hoisie/web"

	"io/ioutil"

	"log"

	"os"

)

//

// Function: 		GetStylesheets

//

// Description: 	This function is used to produce 

//					the stylesheet to the user.

//

// Inputs:

//

func GetStylesheets(ctx *web.Context) string {

	//

	// See if we have already loaded them or not. If so, 

	// just return the pre-loaded stylesheet.

	//

	ctx.SetHeader("Content-Type", "text/css", true)

	SetStandardHeader(ctx)

	tmp := ""

	if SiteData.stylesheet == "" {

		tmp = LoadFile(SiteData.Sitebase + "css/final/final.css")

		//

		// If we are testing, we do not want the server 

		// to cache the stylesheets. Therefore, if 

		// cache is true, cache them. Otherwise,

		// do not.

		//

		if SiteData.Cache == true {

			SiteData.stylesheet = tmp

		}

	} else {

		//

		// We have a cached style sheet. Send it to the 

		// browser.

		//

		tmp = SiteData.stylesheet

	}

	//

	// Return the stylesheet.

	//

	return tmp

}

//

// Function: 		GetScripts

//

// Description: 	This function is to load JavaScripts 

//					to the browser. This will

// 					actually load all the JavaScript 

//					files into one compressed file

// 					for uploading to the browser.

//

// Inputs:

//

func GetScripts(ctx *web.Context) string {

	//

	// See if we have already loaded them or not. If so, 

	// just return the pre-loaded scripts.

	//

	ctx.SetHeader("Content-Type", "text/javascript", true)

	SetStandardHeader(ctx)

	tmp := ""

	if SiteData.scripts == "" {

		tmp = LoadFile(SiteData.Sitebase + "js/final/final.js")

		//

		// If we are testing, we do not want the server 

		// to cache the scripts. Therefore, if cache is 

		// true, cache them. Otherwise, do not.

		//

		if SiteData.Cache == true {

			SiteData.scripts = tmp

		}

	} else {

		//

		// We have a cached style sheet. Send it to the 

		// browser.

		//

		tmp = SiteData.scripts

	}

	//

	// Return the resulting compiled stylesheet.

	//

	return tmp

}

//

// Function: 		LoadFile

//

// Description: 	This function if for loading 

//					individual file contents.

//

// Inputs

//					 file 		name of the file to be 

//								loaded

//

func LoadFile(file string) string {

	ret := ""

	log.Println("Loading file: " + file)

	wfile, err := os.Open(file)

	if err == nil {

		bcontents, err := ioutil.ReadAll(wfile)

		err = err

		ret = string(bcontents)

		wfile.Close()

	} else {

		//

		// Could not read the file.

		//

		log.Println("Could not read: " + file)

	}

	return ret

}

package goPress

//

// Library: 		Shortcodes

//

// Description: 	This library gives the functionality 

//					of shortcodes in the CMS. A shortcode 

//					runs a function with specified 

//					argument and a surrounded contents. 

//					The function should process the 

//					contents according to the arguments 

//					and return a string for placement 

//					into the page. Shortcodes are 

//					recursively processed, therefore you 

//					can have different shortcodes inside 

//					of other shortcodes.  You can not 

//					have the same shortcode inside of 

//					itself.

//

import (

	"bytes"

	"log"

	"regexp"

)

//

// Type: 			ShortcodeFunction

//

// Description: 	This type defines a function that 

//					implements a shortcode. The function

// 					should receive two strings and return 

//					a string.

//

type ShortcodeFunction func(string, string) string

//

// Library Variables:

//

// 			shortcodeStack 		This array of functions 

//								holds all of the 

//								shortcodes usable by the 

//								CMS. You add shortcodes 

//								using the AddShortCode 

//								function.

//

var (

	shortcodeStack map[string]ShortcodeFunction

)

//

// Library Function:

//

//				init 		This function is called upon 

//							library use to initialize any 

//							variables used for the 

//							library before anyone can 

//							make a call to a library 

//							function.

//

func init() {

	shortcodeStack = make(map[string]ShortcodeFunction)

}

//

// Function: 		AddShortCode

//

// Description: 	This function adds a new shortcode to 

//					be used.

//

// Inputs

// 		name           Name of the shortcode

// 		funct          function to process the shortcode

//

func AddShortCode(name string, funct ShortcodeFunction) {

	shortcodeStack[name] = funct

}

//

// Function:		ProcessShortCodes

//

// Description: 	This function takes in a string, 

//					searches for shortcodes, process the 

//					shortcode, put the results into the 

//					string, and then return the fully 

//					processed string.

//

// Inputs

//				page 	String with possible shortcodes

//

func ProcessShortCodes(page string) string {

	//

	// Create a work buffer.

	//

	var buff bytes.Buffer

	//

	// Search for shortcodes. We first capture a 

	// shortcode.

	//

	r, err := regexp.Compile(`\-\[([^\]]*)\]\-`)

	if err == nil {

		match := r.FindString(page)

		if match != "" {

			//

			// Get the indexes to the matching area.

			//

			index := r.FindStringIndex(page)

			//

			// Save all the text before the shortcode 

			// into the buffer.

			//

			buff.WriteString(page[0:index[0]])