Added template support for cogs and refactored basic form code

basicform.go

 type BasicForm struct {
 	formParams *FormParams
 
-	autofillFields []string
-	fields         map[string]string
-	errors         map[string]string
+	prefillFields []string
+	fields        map[string]string
+	errors        map[string]string
 }
 
-func (c *BasicForm) AutofillFields() []string {
-	return c.autofillFields
+func (c *BasicForm) PrefillFields() []string {
+	return c.prefillFields
 }
 
 func (c *BasicForm) Fields() map[string]string {
 
 }
 
-func (c *BasicForm) SetAutofillFields(autofillFields []string) {
-	c.autofillFields = autofillFields
+func (c *BasicForm) SetPrefillFields(prefillFields []string) {
+	c.prefillFields = prefillFields
 }
 
 func (c *BasicForm) SetFields(fields map[string]string) {
 }
 
 func (c *BasicForm) PopulateFields() {
-	for _, fieldName := range c.autofillFields {
+	for _, fieldName := range c.prefillFields {
 		c.fields[fieldName] = FormValue(c.FormParams(), fieldName)
 	}
 }
 		}
 	}
 }
+
+func (c *BasicForm) RegenerateErrors() {
+
+	c.errors = make(map[string]string)
+
+	if OperatingEnvironment() == WebBrowserEnvironment && c.formParams.FormElement != nil {
+		errorSpans := c.formParams.FormElement.QuerySelectorAll(".formError")
+		for _, v := range errorSpans {
+			v.SetInnerHTML(c.errors[strings.Replace(v.GetAttribute("id"), "Error", "", -1)])
+		}
+	}
+
+}

template.go

 )
 
 type RenderParams struct {
-	Data        interface{}
-	Writer      io.Writer
-	Element     dom.Element
-	Disposition int8
-	Attributes  map[string]string
+	Data                          interface{}
+	Writer                        io.Writer
+	Element                       dom.Element
+	Disposition                   int8
+	Attributes                    map[string]string
+	ShouldPopulateRenderedContent bool
+	RenderedContent               string
+	ShouldSkipFinalRenderStep     bool
 }
 
 func (t *Template) GetTemplateType() int8 {
 		println("Error encountered when attempting to render template on client: ", err)
 	}
 
+	if params.ShouldPopulateRenderedContent == true {
+		params.RenderedContent = string(tpl.Bytes())
+	}
+
+	if params.ShouldSkipFinalRenderStep == true {
+		return
+	}
+
 	div := dom.GetWindow().Document().CreateElement("div").(*dom.HTMLDivElement)
 	div.SetInnerHTML(string(tpl.Bytes()))
 

templatebundle.go

 	return nil
 
 }
+
+func (t *TemplateBundle) importTemplateFileContentsForCog(templatesPath string, prefixName string, templateFileExtension string) error {
+
+	templateDirectory := filepath.Clean(templatesPath)
+	println("td: ", templateDirectory)
+	if err := filepath.Walk(templateDirectory, func(path string, info os.FileInfo, err error) error {
+		if strings.HasSuffix(path, templateFileExtension) {
+			name := strings.TrimSuffix(strings.TrimPrefix(path, templateDirectory+string(os.PathSeparator)), TemplateFileExtension)
+			name = prefixName + "/" + name
+			contents, err := ioutil.ReadFile(path)
+			t.items[name] = string(contents)
+
+			if err != nil {
+				fmt.Println("error encountered while walking directory: ", err)
+				return err
+			}
+
+		}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	return nil
+
+}

templateset.go

 	t.bundle = bundle
 
 }
+
+func (t *TemplateSet) GatherCogTemplates(cogTemplatePath string, prefixName string, templateFileExtension string) {
+
+	bundle := NewTemplateBundle()
+
+	templatesPath := cogTemplatePath
+	bundle.importTemplateFileContentsForCog(templatesPath, prefixName, templateFileExtension)
+	t.ImportTemplatesFromMap(bundle.Items())
+
+	for k, v := range bundle.Items() {
+		t.bundle.items[k] = v
+	}
+	//	t.bundle = bundle
+
+}