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)
channel := &model.Channel{
TeamId: team.Id,
Name: name,
DisplayName: displayname,
Header: header,
Purpose: purpose,
Type: channelType,
}
c := getMockContext()
if _, err := api.CreateChannel(c, channel, false); err != nil {
return err
}
return nil
}
func manualTest(c *api.Context, w http.ResponseWriter, r *http.Request) {
// Let the world know
l4g.Info("Setting up for manual test...")
// URL Parameters
params, err := url.ParseQuery(r.URL.RawQuery)
if err != nil {
c.Err = model.NewAppError("/manual", "Unable to parse URL", "")
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("No uid in url")
}
// 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("Creating user and team")
// Create team for testing
team := &model.Team{
DisplayName: teamDisplayName[0],
Name: utils.RandomName(utils.Range{20, 20}, utils.LOWERCASE),
Email: utils.RandomEmail(utils.Range{20, 20}, utils.LOWERCASE),
Type: model.TEAM_OPEN,
}
if result := <-api.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 := api.CreateChannel(c, channel, false); err != nil {
c.Err = err
return
}
teamID = createdTeam.Id
}
// Create user for testing
user := &model.User{
TeamId: teamID,
Email: utils.RandomEmail(utils.Range{20, 20}, utils.LOWERCASE),
Nickname: username[0],
Password: api.USER_PASSWORD}
result, err := client.CreateUser(user, "")
if err != nil {
c.Err = err
return
}
api.Srv.Store.User().VerifyEmail(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
}
}
func cmdCreateChannel() {
if flagCmdCreateChannel {
if len(flagTeamName) == 0 {
fmt.Fprintln(os.Stderr, "flag needs an argument: -team_name")
flag.Usage()
os.Exit(1)
}
if len(flagChannelName) == 0 {
fmt.Fprintln(os.Stderr, "flag needs an argument: -channel_name")
flag.Usage()
os.Exit(1)
}
if len(flagEmail) == 0 {
fmt.Fprintln(os.Stderr, "flag needs an argument: -email")
flag.Usage()
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")
flag.Usage()
os.Exit(1)
}
if !utils.IsLicensed {
fmt.Fprintln(os.Stderr, utils.T("cli.license.critical"))
flag.Usage()
os.Exit(1)
}
var team *model.Team
if result := <-api.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 := <-api.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 := api.CreateChannel(c, channel, true); err != nil {
l4g.Error("%v %v", utils.T(err.Message), err.DetailedError)
flushLogAndExit(1)
}
os.Exit(0)
}
}
