// 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
}
// 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"
}
}
}
// 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
}
// 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
}
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()
}
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))
}
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
}
// 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)
}
// 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)
}
}
// 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
}
