Esempio n. 1
0
// Check ...
func (p *Package) Check() error {
	if p.Name == "" {
		return errors.New("name cannot be empty")
	}

	if p.Name != sanitize.Name(p.Name) {
		return errors.New("name has invalid characters")
	}

	if p.Version != sanitize.Name(p.Version) {
		return errors.New("version has invalid characters")
	}

	if p.Runtime == "" {
		return errors.New("runtime cannot be empty")
	}

	if p.Runtime != sanitize.Name(p.Runtime) {
		return errors.New("runtime has invalid characters")
	}

	if p.Main == "" {
		return errors.New("main cannot be empty")
	}

	if p.Main != sanitize.Name(p.Main) {
		return errors.New("Main has invalid characters")
	}

	return nil
}
Esempio n. 2
0
// fonction privée
// permet de créer les urls des projets
func (pul *PageUserList) injectDataToDisplay() {
	for key, _ := range pul.Users {

		// Génère l'URL du profil selon son prénom, nom et l'année de graduation
		fn := sanitize.Name(pul.Users[key].FirstName)
		ln := sanitize.Name(pul.Users[key].LastName)
		ug := pul.Users[key].Graduation
		pul.Users[key].Url = "/eleves/" + ug + "/" + fn + "_" + ln

		// Si l'utilisateur n'a pas choisi sa photo de profil,
		// une image générique lui est attribué
		if pul.Users[key].PhotoProfil == "" {
			pul.Users[key].PhotoProfil = "user_inconnu.jpg"
		}
	}
}
Esempio n. 3
0
// findUser permet de retrouver le user à partir de :
// son année de graduation
// et de son prénom formatté en url
// et de son nom formatté en url
// retourne un booleen permettan de savoir si oui ou non il a été trouvé
func (pu *PageUser) FindUser() (isFound bool) {

	listUsers := pu.User.GetUsersByGraduation()
	sfn := pu.User.FirstName
	sln := pu.User.LastName
	for key, _ := range listUsers {
		fn := sanitize.Name(listUsers[key].FirstName)
		ln := sanitize.Name(listUsers[key].LastName)
		//log.Println("sfn : " + sfn + " / fn : " + fn + " / sln : " + sln + " / ln : " + ln)
		if sfn == fn && sln == ln {
			pu.User = listUsers[key]
			isFound = true
		}
	}
	return
}
Esempio n. 4
0
// FIXME(ssx): maybe need to return error
func (p *Process) buildCommand() *kexec.KCommand {
	cmd := kexec.CommandString(p.Command)
	// cmd := kexec.Command(p.Command[0], p.Command[1:]...)
	logDir := filepath.Join(defaultConfigDir, "log", sanitize.Name(p.Name))
	if !IsDir(logDir) {
		os.MkdirAll(logDir, 0755)
	}
	var fout io.Writer
	var err error
	p.OutputFile, err = os.OpenFile(filepath.Join(logDir, "output.log"), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		log.Warn("create stdout log failed:", err)
		fout = ioutil.Discard
	} else {
		fout = p.OutputFile
	}
	cmd.Stdout = io.MultiWriter(p.Stdout, p.Output, fout)
	cmd.Stderr = io.MultiWriter(p.Stderr, p.Output, fout)
	// config environ
	cmd.Env = os.Environ() // inherit current vars
	environ := map[string]string{}
	if p.User != "" {
		err := cmd.SetUser(p.User)
		if err != nil {
			log.Warnf("[%s] chusr to %s failed", p.Name, p.User)
		} else {
			var homeDir string
			switch runtime.GOOS {
			case "linux":
				homeDir = "/home/" + p.User // FIXME(ssx): maybe there is a better way
			case "darwin":
				homeDir = "/Users/" + p.User
			}
			cmd.Env = append(cmd.Env, "HOME="+homeDir, "USER="******"HOME"] = homeDir
			environ["USER"] = p.User
		}
	}
	cmd.Env = append(cmd.Env, p.Environ...)
	mapping := func(key string) string {
		val := os.Getenv(key)
		if val != "" {
			return val
		}
		return environ[key]
	}
	cmd.Dir = os.Expand(p.Dir, mapping)
	if strings.HasPrefix(cmd.Dir, "~") {
		cmd.Dir = mapping("HOME") + cmd.Dir[1:]
	}
	log.Infof("[%s] use dir: %s\n", p.Name, cmd.Dir)
	return cmd
}
Esempio n. 5
0
func main() {

	m := martini.Classic()
	m.Use(render.Renderer())
	m.Use(martini.Static("assets"))
	m.Use(DB())

	// Get the list of apps.
	m.Get("/", func(r render.Render, db *mgo.Database) {
		r.HTML(200, "list", nil)
	})

	// Get an app.
	m.Get("/:app", func(r render.Render, db *mgo.Database, cfg *Config, params martini.Params) {
		appinfo := GetAppInfo(db, params["app"])
		appedit := GetCode(params["app"], cfg.Path)
		r.HTML(200, "app", appedit)
	})

	// Post a modified app.
	m.Post("/:app", func(r render.Render, db *mgo.Database, cfg *Config) {

		// Insert or update the app's information in the database.
		// Fields: Title and Name
		title := req.FormValue("Title")
		appname := sanitize.Name(req.FormValue("Title"))

		// Write the app files.
		SaveCode(appname, req.FormValue("HTMLcode"), req.FormValue("CSScode"), req.FormValue("JScode"), cfg)

		appedit := GetCode(appname, cfg)
		r.HTML(200, "app", appedit)
	})

	m.Run()
}
Esempio n. 6
0
func (t *Track) fileName() string {
	name := fmt.Sprintf("%s - %s.mp3", t.Artist, t.Title)

	return fmt.Sprintf("%s/%s", t.dirName(), sanitize.Name(name))
}
Esempio n. 7
0
func (q *Query) MapURL(u *url.URL) *Query {
	urlQuery := u.Query()

	q.Skip, _ = strconv.Atoi(urlQuery.Get("skip"))
	q.Limit, _ = strconv.Atoi(urlQuery.Get("limit"))

	q.Name = urlQuery.Get("name")
	if q.Name != "" {
		q.Name = escapeString(q.Name)
	}

	q.Slug = urlQuery.Get("slug")
	if q.Slug != "" {
		q.Slug = sanitize.Name(q.Slug)
	}

	q.GroupName = urlQuery.Get("groupName")
	if q.GroupName != "" {
		q.GroupName = sanitize.Name(q.GroupName)
	}

	q.Type = urlQuery.Get("type")
	if q.Type != "" {
		q.Type = sanitize.Name(q.Type)
	}

	q.Privacy = urlQuery.Get("privacy")
	if q.Privacy != "" {
		q.Privacy = sanitize.Name(q.Privacy)
	}

	q.Id, _ = GetURIInt64(u, "id")
	q.AccountId, _ = GetURIInt64(u, "accountId")

	q.AccountNickname = urlQuery.Get("accountNickname")
	if q.AccountNickname != "" {
		q.AccountNickname = sanitize.Name(q.AccountNickname)
	}

	q.GroupChannelId, _ = GetURIInt64(u, "groupChannelId")

	if to := urlQuery.Get("to"); to != "" {
		q.To, _ = time.Parse(time.RFC3339, to)
	}

	if from := urlQuery.Get("from"); from != "" {
		q.From, _ = time.Parse(time.RFC3339, from)
	}

	if showExempt := urlQuery.Get("showExempt"); showExempt != "" {
		isExempt, _ := strconv.ParseBool(showExempt)
		q.ShowExempt = isExempt
	}

	if addIsInteracted := urlQuery.Get("addIsInteracted"); addIsInteracted != "" {
		addIsInteracted, _ := strconv.ParseBool(addIsInteracted)
		q.AddIsInteracted = addIsInteracted
	}

	if replyLimit := urlQuery.Get("replyLimit"); replyLimit != "" {
		replyLimit, _ := strconv.Atoi(replyLimit)
		q.ReplyLimit = replyLimit
	}

	if replySkip := urlQuery.Get("replySkip"); replySkip != "" {
		replySkip, _ := strconv.Atoi(replySkip)
		q.ReplySkip = replySkip
	}

	if sortOrder := urlQuery.Get("sortOrder"); sortOrder != "" && IsIn(sortOrder, "ASC", "DESC") {
		q.SortOrder = sortOrder
	}

	q.ObjectId, _ = GetURIInt64(u, "objectId")

	return q
}
Esempio n. 8
0
// Upload de fichiers avec Go
// Code original : https://gist.github.com/sanatgersappa/5127317#file-app-go
func CoverHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("CoverHandler appelé!")

	// Initialisation des variables utiles
	var u User
	session, _ := store.Get(r, "cme_connecte")
	u.Id = session.Values["id"].(int64)
	userId := Itoa(int(u.Id))
	var strNomFichier string

	//parse the multipart form in the request
	err := r.ParseMultipartForm(100000)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	//get a ref to the parsed multipart form
	m := r.MultipartForm

	//get the *fileheaders
	files := m.File["cover-upload"]

	file, err := files[0].Open()

	defer file.Close()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Création d'un nom sanitizé pour
	strNomFichier = sanitize.Name(files[0].Filename)

	// Validation des extensions de fichiers
	if filepath.Ext(strNomFichier) != ".jpg" &&
		filepath.Ext(strNomFichier) != ".jpeg" &&
		filepath.Ext(strNomFichier) != ".png" &&
		filepath.Ext(strNomFichier) != ".gif" {
		return
	}

	//create destination file making sure the path is writeable.
	dst, err := os.Create("./public/img/uploads/users/" + userId + "/" + strNomFichier)

	// Vérification de l'existence du répertoire cible
	if err != nil {
		log.Println(err)
	}

	// Envoi du nom du fichier pour l'ajout à la BD
	u.SavePhoto(strNomFichier)

	defer dst.Close()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	//copy the uploaded file to the destination file
	if _, err := io.Copy(dst, file); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Redimensionnement de l'image

	// open "test.jpg"
	rfile, err := os.Open("./public/img/uploads/users/" + userId + "/" + strNomFichier)
	if err != nil {
		log.Fatal(err)
	}

	// decode jpeg into image.Image
	rimg, err := jpeg.Decode(rfile)
	if err != nil {
		log.Fatal(err)
	}
	rfile.Close()

	image := resize.Thumbnail(1280, 200, rimg, resize.Bilinear)

	out, err := os.Create("./public/img/uploads/users/" + userId + "/" + strNomFichier)
	if err != nil {
		log.Fatal(err)
	}
	defer out.Close()

	// write new image to file
	jpeg.Encode(out, image, nil)

}
Esempio n. 9
0
// fonction privée
// permet de créer les urls des projets
func (pu *PageUser) injectDataToDisplay() {
	for key, _ := range pu.Projects {
		pu.Projects[key].Url = "/eleves/" + pu.User.Graduation + "/" + pu.User.FirstName + "_" + pu.User.LastName + "/" + sanitize.Name(pu.Projects[key].Title)
	}

}
Esempio n. 10
0
// uploadImage permet de charger une image sur le serveur depuis un formulaire HTML
// le formulaire doit avoir une balise avec :
// <form enctype="multipart/form-data" action="http://localhost:8080/upload" method="post">
//     <input type="file" name="image" />
//     <input type="submit" value="upload" />
// </form>
func UploadImage(destination string, r *http.Request) (imgPath string, err error) {
	var strNomFichier string

	//parse the multipart form in the request
	err = r.ParseMultipartForm(MAX_SIZE_FILE_UPLOAD)
	if err != nil {
		err = errors.New("le fichier n' a pas les droits pour être créé")
		return "", err
	}

	//get a ref to the parsed multipart form
	m := r.MultipartForm

	//get the *fileheaders
	files := m.File["image"]
	file, err := files[0].Open()
	defer file.Close()
	if err != nil {
		err = errors.New("le fichier n' a pas les droits pour être ouvert")
		return "", err
	}
	// Création d'un nom sanitizé pour
	strNomFichier = sanitize.Name(files[0].Filename)
	// Validation des extensions de fichiers
	if filepath.Ext(strNomFichier) != ".jpg" &&
		filepath.Ext(strNomFichier) != ".jpeg" &&
		filepath.Ext(strNomFichier) != ".png" &&
		filepath.Ext(strNomFichier) != ".gif" {
		err = errors.New("le fichier a une extention qui n'est pas autorisé")
		return "", err
	}

	// permet de voir si le dossier année existe
	// si il n'existe pas le créer
	// si il n'y arrive pas envoyer une erreur
	destination = destination + YS + "/"
	if _, err := os.Stat(destination); os.IsNotExist(err) {
		err := os.Mkdir(destination, 0777)
		if err != nil {
			err = errors.New("le dossier n'arrive pas à se créer")
			return "", err
		}
	}

	// permet de voir si le dossier mois existe
	// si il n'existe pas le créer
	// si il n'y arrive pas envoyer une erreur
	destination = destination + MS + "/"
	if _, err := os.Stat(destination); os.IsNotExist(err) {
		err := os.Mkdir(destination, 0777)
		if err != nil {
			err = errors.New("le dossier n'arrive pas à se créer")
			return "", err
		}
	}

	// création du fichier de destination
	imgPath = destination + strNomFichier
	dst, err := os.Create(imgPath)
	if err != nil {
		err = errors.New("le fichier n' a pas les droits pour être créé")
		return "", err
	}

	//copy the uploaded file to the destination file
	if _, err := io.Copy(dst, file); err != nil {
		errors.New("le fichier n' a pas les droits pour être copié")
		return "", err
	}

	// envoie du path de l'image avec son nom
	return imgPath, nil
}