Beispiel #1
0
// Controller to handle content editor submission.
func ContentEditorSubmit(w *wrapper.Wrapper) {
	elementid := w.APIParams[0]
	e, err := elements.LoadContentElement(elementid, w)
	post := make(map[string]interface{})
	err = form.GetValidFormData(w, &post)
	if err != nil {
		return
	}
	e.ContentValues.Content = post
	delete(e.ContentValues.Content, "mongolartype")
	delete(e.ContentValues.Content, "mongolarid")
	delete(e.ContentValues.Content, "form_id")
	err = e.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Element not saved %s by %s", w.APIParams[0], w.Request.Host)
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to save element.", "Error", w)
		w.Serve()
		return
	}
	services.AddMessage("Element content saved.", "Success", w)
	dynamic := services.Dynamic{
		Target:     elementid,
		Id:         elementid,
		Controller: "admin/element",
		Template:   "admin/element.html",
	}
	services.SetDynamic(dynamic, w)
	w.Serve()
	return

}
Beispiel #2
0
// Controller to delete an element and all references to the element
func DeleteElement(w *wrapper.Wrapper) {
	id := w.APIParams[0]
	err := elements.Delete(id, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to delete %s : %s", id, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to delete element.", "Error", w)
	}
	err = elements.WrapperDeleteAllChild(id, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to delete reference to element %s : %s", id, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to delete all references to your element.", "Error", w)
	}
	err = elements.SlugDeleteAllChild(id, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to delete reference to element %s : %s", id, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to delete all references to your element.", "Error", w)
	}
	err = paths.DeleteAllChild(id, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to delete reference to %s : %s", id, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to delete all references to your element.", "Error", w)
	}
	dynamic := services.Dynamic{
		Target:   id,
		Template: "default.html",
	}
	services.SetDynamic(dynamic, w)
	services.AddMessage("Successfully deleted element", "Success", w)
	w.Serve()
	return
}
Beispiel #3
0
// Controller for adding existing element to path form submission.
func AddExistingPathSubmit(w *wrapper.Wrapper) {
	parentid := w.APIParams[0]
	var post map[string]string
	err := form.GetValidFormData(w, &post)
	if err != nil {
		return
	}
	var parent paths.Path
	parent, err = paths.LoadPath(parentid, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to loap parent element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not load parent element.", "Error", w)
		w.Serve()
		return
	}
	parent.Elements = append(parent.Elements, post["element"])
	err = parent.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to save parent element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not save parent element.", "Error", w)
		w.Serve()
		return
	}
	dynamic := services.Dynamic{
		Target:     "centereditor",
		Controller: "admin/path_elements",
		Template:   "admin/path_elements.html",
		Id:         parentid,
	}
	services.SetDynamic(dynamic, w)
	services.AddMessage("You have added an existing element.", "Success", w)
	w.Serve()
}
Beispiel #4
0
func AddSlugChild(w *wrapper.Wrapper) {
	parentid := w.APIParams[0]
	e := elements.NewElement()
	e.Title = "New Element"
	e.Controller = "content"
	err := e.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to create new element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not create a new element.", "Error", w)
		w.Serve()
		return
	}
	var parent elements.SlugElement
	parent, err = elements.LoadSlugElement(parentid, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to loap parent element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not load parent element.", "Error", w)
		w.Serve()
		return
	}
	if parent.Slugs == nil {
		slug := map[string]string{e.MongoId.Hex(): e.MongoId.Hex()}
		parent.Slugs = slug
	} else {
		parent.Slugs[e.MongoId.Hex()] = e.MongoId.Hex()
	}
	err = parent.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to save parent element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not save parent element.", "Error", w)
		w.Serve()
		return
	}
	dynamic := services.Dynamic{
		Target:     parentid,
		Controller: "admin/element",
		Template:   "admin/element.html",
		Id:         parentid,
	}
	services.SetDynamic(dynamic, w)
	services.AddMessage("You have added a new element.", "Success", w)
	w.Serve()

}
Beispiel #5
0
// Controller for path sort submission.
func SortPathSubmit(w *wrapper.Wrapper) {
	var parentid string
	if len(w.APIParams) > 0 {
		parentid = w.APIParams[0]
	} else {
		http.Error(w.Writer, "Forbidden", 403)
		w.Serve()
		return
	}
	pes := paths.NewPathElements()
	err := json.NewDecoder(w.Request.Body).Decode(&pes)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to marshall elements %s by %s: %s", parentid, w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to save elements.", "Error", w)
		w.Serve()
		return
	}
	pe, err := paths.LoadPath(parentid, w)
	if err != nil {
		errmessage := fmt.Sprintf("Path not found to sort for %s by %s.", parentid, w.Request.Host)
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("This path was not found", "Error", w)
		w.Serve()
		return
	}
	pe.PathElements = pes
	err = pe.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to save path %s by %s : %s", parentid, w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not save path.", "Error", w)
		w.Serve()
		return
	}
	dynamic := services.Dynamic{
		Target:     "centereditor",
		Controller: "admin/path_elements",
		Template:   "admin/path_elements.html",
		Id:         w.APIParams[1],
	}
	services.SetDynamic(dynamic, w)
	services.AddMessage("You elements have been updated.", "Success", w)
	w.Serve()
	return
}
Beispiel #6
0
// Controller for wrapper sort submission.
func SortWrapperSubmit(w *wrapper.Wrapper) {
	var parentid string
	if len(w.APIParams) > 0 {
		parentid = w.APIParams[0]
	} else {
		http.Error(w.Writer, "Forbidden", 403)
		w.Serve()
		return
	}
	wes := elements.NewWrapperElements()
	err := json.NewDecoder(w.Request.Body).Decode(&wes)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to marshall elements %s by %s: %s", parentid, w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to save elements.", "Error", w)
		w.Serve()
		return
	}
	we, err := elements.LoadWrapperElement(parentid, w)
	if err != nil {
		errmessage := fmt.Sprintf("Element not found to sort for %s by %s.", parentid, w.Request.Host)
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("This element was not found", "Error", w)
		w.Serve()
		return
	}
	we.WrapperElements = wes
	we.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to save wrapper element %s by %s : %s", parentid, w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not save parent element.", "Error", w)
		w.Serve()
		return
	}
	dynamic := services.Dynamic{
		Target:     parentid,
		Controller: "admin/element",
		Template:   "admin/element.html",
		Id:         parentid,
	}
	services.SetDynamic(dynamic, w)
	services.AddMessage("You elements have been updated.", "Success", w)
	w.Serve()
	return
}
Beispiel #7
0
// Controller for adding children to wrapper element.
func AddWrapperChild(w *wrapper.Wrapper) {
	parentid := w.APIParams[0]
	e := elements.NewElement()
	e.Title = "New Element"
	err := e.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to create new element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not create a new element.", "Error", w)
		w.Serve()
		return
	}
	var parent elements.WrapperElement
	parent, err = elements.LoadWrapperElement(parentid, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to loap parent element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not load parent element.", "Error", w)
		w.Serve()
		return
	}
	parent.Elements = append(parent.Elements, e.MongoId.Hex())
	err = parent.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to loap parent element  by %s : %s", w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Could not load parent element.", "Error", w)
		w.Serve()
		return
	}
	dynamic := services.Dynamic{
		Target:     parentid,
		Controller: "admin/element",
		Template:   "admin/element.html",
		Id:         parentid,
	}
	services.SetDynamic(dynamic, w)
	services.AddMessage("You have added a new element.", "Success", w)
	w.Serve()
	return

}
Beispiel #8
0
// Controller to delete a path
func DeletePath(w *wrapper.Wrapper) {
	id := w.APIParams[0]
	err := paths.Delete(id, w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to delete path %s : %s", id, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to delete.", "Error", w)
		w.Serve()
		return
	}
	dynamic := services.Dynamic{
		Target:     "pathbar",
		Controller: "admin/paths",
		Template:   "admin/path_list.html",
	}
	services.SetDynamic(dynamic, w)
	services.AddMessage("Successfully deleted path", "Success", w)
	w.Serve()
	return
}
Beispiel #9
0
// Controller to handle path editor form submissions.
func PathEditorSubmit(w *wrapper.Wrapper) {
	pathid := w.APIParams[0]
	var path paths.Path
	var err error
	if pathid != "new" {
		path, err = paths.LoadPath(pathid, w)
		if err != nil {
			errmessage := fmt.Sprintf("Unable to save path %s by %s: %s", pathid,
				w.Request.Host, err.Error())
			w.SiteConfig.Logger.Error(errmessage)
			services.AddMessage("There was a problem saving your path.", "Error", w)
			w.Serve()
			return
		}
	}
	err = form.GetValidFormData(w, &path)
	if err != nil {
		return
	}
	err = path.Save(w)
	if err != nil {
		errmessage := fmt.Sprintf("Unable to save path %s by %s: %s", pathid,
			w.Request.Host, err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("There was a problem saving your path.", "Error", w)
		w.Serve()
		return
	}
	services.AddMessage("Your path was saved.", "Success", w)
	dynamic := services.Dynamic{
		Target:     "pathbar",
		Controller: "admin/paths",
		Template:   "admin/path_list.html",
	}
	services.SetDynamic(dynamic, w)
	w.Serve()
	return

}
Beispiel #10
0
// Controller to edit an elements properties
// TODO: break this into smaller functions to make it easier to maintain
func ElementEditor(w *wrapper.Wrapper) {
	var elementid string
	if len(w.APIParams) > 0 {
		elementid = w.APIParams[0]
	} else {
		http.Error(w.Writer, "Forbidden", 403)
	}
	if w.Request.Method != "POST" {
		f := form.NewForm()
		f.AddText("title", "text").AddLabel("Title")
		op := make([]map[string]string, 0)
		for _, ec := range w.SiteConfig.ElementControllers {
			uc := []rune(ec)
			uc[0] = unicode.ToUpper(uc[0])
			name := string(uc)
			op = append(op, map[string]string{"name": name, "value": ec})
		}
		f.AddSelect("controller", op).AddLabel("Controller")
		f.AddText("template", "text").AddLabel("Template")
		f.AddText("dyn", "text").AddLabel("Dynamic Id")
		f.AddText("classes", "text").AddLabel("Classes")
		f.AddText("id", "text").Hidden()
		if elementid != "new" {
			e := elements.NewElement()
			err := elements.GetById(elementid, &e, w)
			if err != nil {
				errmessage := fmt.Sprintf("Element not found to edit for %s by %s", elementid, w.Request.Host, err.Error())
				w.SiteConfig.Logger.Error(errmessage)
				services.AddMessage("This element was not found", "Error", w)
				w.Serve()
				return
			}
			// Have to do this for namespacing stuff on the AngularJs side.
			data := map[string]string{
				"controller": e.Controller,
				"template":   e.Template,
				"dyn":        e.DynamicId,
				"classes":    e.Classes,
				"id":         e.MongoId.Hex(),
				"title":      e.Title,
			}
			f.FormData = data
		}
		f.Register(w)
		w.SetTemplate("admin/form.html")
		w.SetPayload("form", f)
	} else {
		post := make(map[string]string)
		err := form.GetValidFormData(w, &post)
		if err != nil {
			return
		} else {
			c := w.DbSession.DB("").C("elements")
			if post["mongolarid"] == "new" {
				p := elements.Element{
					Controller: post["controller"],
					DynamicId:  post["dyn"],
					Template:   post["template"],
					Title:      post["title"],
					Classes:    post["classes"],
				}
				err := c.Insert(p)
				if err != nil {
					errmessage := fmt.Sprintf("Unable to save new element by %s : %s", w.Request.Host, err.Error())
					w.SiteConfig.Logger.Error(errmessage)
					services.AddMessage("There was a problem saving your element.", "Error", w)
				} else {
					services.AddMessage("Your element was saved.", "Success", w)
				}
			} else {
				p := bson.M{
					"$set": bson.M{
						"template":   post["template"],
						"title":      post["title"],
						"dynamic_id": post["dyn"],
						"controller": post["controller"],
						"classes":    post["classes"],
					},
				}
				s := bson.M{"_id": bson.ObjectIdHex(post["mongolarid"])}
				err := c.Update(s, p)
				if err != nil {
					errmessage := fmt.Sprintf("Unable to save element %s by %s : %s",
						post["mongolarid"], w.Request.Host, err.Error())
					w.SiteConfig.Logger.Error(errmessage)
					services.AddMessage("There was a problem saving your element.", "Error", w)
				} else {
					services.AddMessage("Your element was saved.", "Success", w)
					dynamic := services.Dynamic{
						Target:     post["mongolarid"],
						Id:         post["mongolarid"],
						Controller: "admin/element",
						Template:   "admin/element.html",
					}
					services.SetDynamic(dynamic, w)
				}
			}
		}
	}
	w.Serve()
	return
}
Beispiel #11
0
func EditContentTypeSubmit(w *wrapper.Wrapper) {
	post := make(map[string]interface{})
	err := form.GetValidFormData(w, &post)
	if err != nil {
		return
	}
	elements := reflect.ValueOf(post["elements"])
	f := form.NewForm()
	for i := 0; i < elements.Len(); i++ {
		var field *form.Field
		element := elements.Index(i).Interface().(map[string]interface{})
		switch element["type"].(string) {
		case "input":
			field = f.AddText(element["key"].(string), "text")
		case "textarea":
			field = f.AddTextArea(element["key"].(string))
		case "radio":
			values := strings.Split(element["options"].(string), "\n")
			opt := make([]map[string]string, 0)
			for _, value := range values {
				namval := strings.Split(value, "|")
				if len(namval) < 2 {
					errmessage := fmt.Sprintf("Attempt to set incorrect form option %s by %s", value, w.Request.Host)
					w.SiteConfig.Logger.Error(errmessage)
					services.AddMessage("Your options must be of the format Name|Value", "Error", w)
					w.Serve()
					return
				}
				newval := map[string]string{
					"name":  namval[0],
					"value": namval[1],
				}
				opt = append(opt, newval)
			}
			field = f.AddRadio(element["key"].(string), opt)
		case "checkbox":
			field = f.AddCheckBox(element["key"].(string))
		default:
			//TODO messaging and logging
			return
		}
		if _, ok := element["label"]; ok {
			if element["label"].(string) != "" {
				field.AddLabel(element["label"].(string))
			}
		}
		if _, ok := element["placeholder"]; ok {
			if element["placeholder"].(string) != "" {
				field.AddPlaceHolder(element["placeholder"].(string))
			}
		}
		if _, ok := element["rows"]; ok {
			if _, ok := element["cols"]; ok {
				if element["rows"].(float64) != 0 && element["cols"] != 0 {
					field.AddRowsCols(int(element["rows"].(float64)), int(element["cols"].(float64)))
				}
			}
		}
	}

	var id bson.ObjectId
	if post["mongolarid"].(string) == "new" {
		id = bson.NewObjectId()
	} else {
		id = bson.ObjectIdHex(post["mongolarid"].(string))
	}
	ct := ContentType{
		Form:    f.Fields,
		Type:    post["content_type"].(string),
		MongoId: id,
	}
	s := bson.M{"_id": id}
	c := w.DbSession.DB("").C("content_types")
	_, err = c.Upsert(s, ct)
	if err != nil {
		errmessage := fmt.Sprintf("Cannnot save content type %s : %s", post["mongolarid"].(string), err.Error())
		w.SiteConfig.Logger.Error(errmessage)
		services.AddMessage("Unable to save content type.", "Error", w)
		w.Serve()
		return
	}
	services.AddMessage("Content type saved.", "Success", w)
	dynamic := services.Dynamic{
		Target:     "contenttypelist",
		Controller: "admin/all_content_types",
		Template:   "admin/content_type_list.html",
	}
	services.SetDynamic(dynamic, w)
	w.Serve()
	return

}
Beispiel #12
0
// Controller to edit a menu element
// TODO: break this into smaller functions
func MenuEditor(w *wrapper.Wrapper) {
	if len(w.APIParams) == 0 {
		http.Error(w.Writer, "Forbidden", 403)
		return
	}
	menuid := w.APIParams[0]
	if w.Request.Method != "POST" {
		e, err := elements.LoadMenuElement(menuid, w)
		if err != nil {
			errmessage := fmt.Sprintf("Element not found to edit for %s by %s.", menuid, w.Request.Host)
			w.SiteConfig.Logger.Error(errmessage)
			services.AddMessage("This element was not found", "Error", w)
			w.Serve()
			return
		}
		if e.MenuItems == nil {
			items := make(map[string][]map[string]string)
			items["menu_items"] = make([]map[string]string, 0)
			w.SetPayload("menu", items)
		} else {
			w.SetPayload("menu", e)
		}
		w.SetPayload("title", e.Title)
		w.SetTemplate("admin/menu_editor.html")
		w.Serve()
		return
	} else {
		e, err := elements.LoadMenuElement(menuid, w)
		if err != nil {
			errmessage := fmt.Sprintf("Element not found to edit for %s by %s.", menuid, w.Request.Host)
			w.SiteConfig.Logger.Error(errmessage)
			services.AddMessage("This element was not found", "Error", w)
			w.Serve()
			return
		}
		err = json.NewDecoder(w.Request.Body).Decode(&e)
		if err != nil {
			errmessage := fmt.Sprintf("Unable to update marshall menu elements by %s: %s", w.Request.Host, err.Error())
			w.SiteConfig.Logger.Error(errmessage)
			services.AddMessage("Unable to save menu element.", "Error", w)
			w.Serve()
			return
		}
		err = e.Save(w)
		if err != nil {
			errmessage := fmt.Sprintf("Unable to update menu element %s by %s: %s", menuid, w.Request.Host, err.Error())
			w.SiteConfig.Logger.Error(errmessage)
			services.AddMessage("Unable to save menu element.", "Error", w)
			w.Serve()
			return
		}
		dynamic := services.Dynamic{
			Target:     "modaleditor",
			Controller: "",
			Template:   "",
			Id:         "",
		}
		services.SetDynamic(dynamic, w)
		services.AddMessage("You menu element have been updated.", "Success", w)
		w.Serve()
	}

}