func createChannel(c *Context, w http.ResponseWriter, r *http.Request) { channel := model.ChannelFromJson(r.Body) if channel == nil { c.SetInvalidParam("createChannel", "channel") return } if len(channel.TeamId) == 0 { channel.TeamId = c.TeamId } if channel.Type == model.CHANNEL_DIRECT { c.Err = model.NewLocAppError("createDirectChannel", "api.channel.create_channel.direct_channel.app_error", nil, "") return } if strings.Index(channel.Name, "__") > 0 { c.Err = model.NewLocAppError("createDirectChannel", "api.channel.create_channel.invalid_character.app_error", nil, "") return } if channel.Type == model.CHANNEL_OPEN && !HasPermissionToTeamContext(c, channel.TeamId, model.PERMISSION_CREATE_PUBLIC_CHANNEL) { return } if channel.Type == model.CHANNEL_PRIVATE && !HasPermissionToTeamContext(c, channel.TeamId, model.PERMISSION_CREATE_PRIVATE_CHANNEL) { return } if channel.TeamId == c.TeamId { // Get total number of channels on current team if result := <-app.Srv.Store.Channel().GetTeamChannels(channel.TeamId); result.Err != nil { c.Err = model.NewLocAppError("createChannel", "api.channel.get_channels.error", nil, result.Err.Message) return } else { data := result.Data.(*model.ChannelList) if int64(len(*data)+1) > *utils.Cfg.TeamSettings.MaxChannelsPerTeam { c.Err = model.NewLocAppError("createChannel", "api.channel.create_channel.max_channel_limit.app_error", map[string]interface{}{"MaxChannelsPerTeam": *utils.Cfg.TeamSettings.MaxChannelsPerTeam}, "") return } } } channel.CreatorId = c.Session.UserId if sc, err := app.CreateChannel(channel, true); err != nil { c.Err = err return } else { c.LogAudit("name=" + channel.Name) w.Write([]byte(sc.ToJson())) } }
func createChannelCmdF(cmd *cobra.Command, args []string) error { initDBCommandContextCobra(cmd) if !utils.IsLicensed { return errors.New(utils.T("cli.license.critical")) } name, errn := cmd.Flags().GetString("name") if errn != nil || name == "" { return errors.New("Name is required") } displayname, errdn := cmd.Flags().GetString("display_name") if errdn != nil || displayname == "" { return errors.New("Display Name is required") } teamArg, errteam := cmd.Flags().GetString("team") if errteam != nil || teamArg == "" { return errors.New("Team is required") } header, _ := cmd.Flags().GetString("header") purpose, _ := cmd.Flags().GetString("purpose") useprivate, _ := cmd.Flags().GetBool("private") channelType := model.CHANNEL_OPEN if useprivate { channelType = model.CHANNEL_PRIVATE } team := getTeamFromTeamArg(teamArg) c := getMockContext() channel := &model.Channel{ TeamId: team.Id, Name: name, DisplayName: displayname, Header: header, Purpose: purpose, Type: channelType, CreatorId: c.Session.UserId, } if _, err := app.CreateChannel(channel, false); err != nil { return err } return nil }
func cmdCreateChannel() { if flagCmdCreateChannel { if len(flagTeamName) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -team_name") os.Exit(1) } if len(flagChannelName) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -channel_name") os.Exit(1) } if len(flagEmail) == 0 { fmt.Fprintln(os.Stderr, "flag needs an argument: -email") os.Exit(1) } if flagChannelType != "O" && flagChannelType != "P" { fmt.Fprintln(os.Stderr, "flag channel_type must have on of the following values: O or P") os.Exit(1) } if !utils.IsLicensed { fmt.Fprintln(os.Stderr, utils.T("cli.license.critical")) os.Exit(1) } var team *model.Team if result := <-app.Srv.Store.Team().GetByName(flagTeamName); result.Err != nil { l4g.Error("%v %v", utils.T(result.Err.Message), result.Err.DetailedError) flushLogAndExit(1) } else { team = result.Data.(*model.Team) } var user *model.User if result := <-app.Srv.Store.User().GetByEmail(flagEmail); result.Err != nil { l4g.Error("%v %v", utils.T(result.Err.Message), result.Err.DetailedError) flushLogAndExit(1) } else { user = result.Data.(*model.User) } c := getMockContext() c.Session.UserId = user.Id channel := &model.Channel{} channel.DisplayName = flagChannelName channel.CreatorId = user.Id channel.Name = flagChannelName channel.TeamId = team.Id channel.Type = flagChannelType channel.Header = flagChannelHeader channel.Purpose = flagChannelPurpose if _, err := app.CreateChannel(channel, true); err != nil { l4g.Error("%v %v", utils.T(err.Message), err.DetailedError) flushLogAndExit(1) } os.Exit(0) } }
func manualTest(c *api.Context, w http.ResponseWriter, r *http.Request) { // Let the world know l4g.Info(utils.T("manaultesting.manual_test.setup.info")) // URL Parameters params, err := url.ParseQuery(r.URL.RawQuery) if err != nil { c.Err = model.NewLocAppError("/manual", "manaultesting.manual_test.parse.app_error", nil, "") return } // Grab a uuid (if available) to seed the random number generator so we don't get conflicts. uid, ok := params["uid"] if ok { hasher := fnv.New32a() hasher.Write([]byte(uid[0] + strconv.Itoa(int(time.Now().UTC().UnixNano())))) hash := hasher.Sum32() rand.Seed(int64(hash)) } else { l4g.Debug(utils.T("manaultesting.manual_test.uid.debug")) } // Create a client for tests to use client := model.NewClient("http://localhost" + utils.Cfg.ServiceSettings.ListenAddress) // Check for username parameter and create a user if present username, ok1 := params["username"] teamDisplayName, ok2 := params["teamname"] var teamID string var userID string if ok1 && ok2 { l4g.Info(utils.T("manaultesting.manual_test.create.info")) // Create team for testing team := &model.Team{ DisplayName: teamDisplayName[0], Name: utils.RandomName(utils.Range{20, 20}, utils.LOWERCASE), Email: "success+" + model.NewId() + "simulator.amazonses.com", Type: model.TEAM_OPEN, } if result := <-app.Srv.Store.Team().Save(team); result.Err != nil { c.Err = result.Err return } else { createdTeam := result.Data.(*model.Team) channel := &model.Channel{DisplayName: "Town Square", Name: "town-square", Type: model.CHANNEL_OPEN, TeamId: createdTeam.Id} if _, err := app.CreateChannel(channel, false); err != nil { c.Err = err return } teamID = createdTeam.Id } // Create user for testing user := &model.User{ Email: "success+" + model.NewId() + "simulator.amazonses.com", Nickname: username[0], Password: api.USER_PASSWORD} result, err := client.CreateUser(user, "") if err != nil { c.Err = err return } <-app.Srv.Store.User().VerifyEmail(result.Data.(*model.User).Id) <-app.Srv.Store.Team().SaveMember(&model.TeamMember{TeamId: teamID, UserId: result.Data.(*model.User).Id}) newuser := result.Data.(*model.User) userID = newuser.Id // Login as user to generate auth token _, err = client.LoginById(newuser.Id, api.USER_PASSWORD) if err != nil { c.Err = err return } // Respond with an auth token this can be overriden by a specific test as required sessionCookie := &http.Cookie{ Name: model.SESSION_COOKIE_TOKEN, Value: client.AuthToken, Path: "/", MaxAge: *utils.Cfg.ServiceSettings.SessionLengthWebInDays * 60 * 60 * 24, HttpOnly: true, } http.SetCookie(w, sessionCookie) http.Redirect(w, r, "/channels/town-square", http.StatusTemporaryRedirect) } // Setup test environment env := TestEnvironment{ Params: params, Client: client, CreatedTeamId: teamID, CreatedUserId: userID, Context: c, Writer: w, Request: r, } // Grab the test ID and pick the test testname, ok := params["test"] var err2 *model.AppError switch testname[0] { case "autolink": err2 = testAutoLink(env) // ADD YOUR NEW TEST HERE! case "general": err2 = nil } if err != nil { c.Err = err2 return } }