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
}
}
