private async Task Run()
{
// Setup is done, now
// Connect to slack
var success = await _app.Connect();
if (!success)
{
var help = new ParamParser <CommandLine>().Help();
Console.WriteLine(help);
return;
}
// Hold the console open
do
{
Console.WriteLine("Enter 'Stop' to exit");
var line = Console.ReadLine();
if (string.Compare(line, "Stop", StringComparison.OrdinalIgnoreCase) == 0)
{
break;
}
if (string.Compare(line, "cls", StringComparison.OrdinalIgnoreCase) == 0)
{
Console.Clear();
}
} while (true);
Console.WriteLine("Slack CLI Stopped");
}
public void Parse(string[] args)
{
try
{
var mainParamParsed = false;
foreach (var arg in args)
{
var match = ParamParser.Match(arg);
if (match.Success)
{
var name = match.Groups["name"].Value;
var content = match.Groups["content"].Value;
var paramFound = false;
foreach (var param in parameters.Where(param => param.Name == name))
{
paramFound = true;
if (string.IsNullOrWhiteSpace(content) && !(param is Flag))
{
throw new ParsingErrorException(
param, Language.Message("ParamNotAFlagNeedsValue", param.Name));
}
param.Parse(content);
break;
}
if (!paramFound)
{
throw new ParsingErrorException(null, Language.Message("UnknownParamName", name));
}
}
else
{
mainParamParsed = true;
mainParam.Parse(arg);
}
}
if (!mainParamParsed)
{
throw new ParsingErrorException(mainParam, Language.Message("RequiredParameter", mainParam.Name));
}
}
catch (ParsingErrorException e)
{
if (ParsingError != null)
{
ParsingError(e.Sender, e.Message);
}
else
{
throw;
}
}
}
public static Guid ParseAndValidateEntityId(this ApiController apiController, HttpRequestMessage request, string entityId)
{
Guid entityIdParsed = ParamParser.ParseGuid(entityId);
if (entityIdParsed == Guid.Empty)
{
var response = request.CreateErrorResponse(HttpStatusCode.BadRequest, String.Format("Entity Id '{0}' is not a GUID", entityId));
throw new HttpResponseException(response);
}
return(entityIdParsed);
}
public void Should_Return_True_For_Correct_Element()
{
// Given
var parser = new ParamParser();
var node = @"<param name=""test"">Hello World</param>".CreateXmlNode();
// When
var result = parser.CanParse(node);
// Then
Assert.True(result);
}
public void Should_Parse_Content_Recursivly()
{
// Given
var commentParser = Substitute.For <ICommentParser>();
var nodeParser = new ParamParser();
var node = @"<param name=""test"">Hello World</param>".CreateXmlNode();
// When
nodeParser.Parse(commentParser, node);
// Then
commentParser.Received(1).Parse(Arg.Any <XmlNode>());
}
public void Should_Parse_Parameter_Name()
{
// Given
var commentParser = Substitute.For <ICommentParser>();
var nodeParser = new ParamParser();
var node = @"<param name=""test"" />".CreateXmlNode();
// When
var result = nodeParser.Parse(commentParser, node);
// Then
Assert.Equal("test", result.Name);
}
/// <summary>
/// 查询元素
/// </summary>
/// <param name="document"></param>
/// <param name="source"></param>
/// <param name="param"></param>
/// <returns></returns>
internal IEnumerable <Element> Select(Document document, IEnumerable <Element> source, string param)
{
ElementFilter[] filters = ParamParser.Parse(param);
if (filters.Length > 1)
{
return(filters.SelectMany(i => i.Eval(document, source)).Distinct().OrderBy(i => i.Index));
}
else
{
return(filters[0].Eval(document, source).ToArray());
}
}
private void SetupSlackApp(string[] args)
{
// Parse any command line arguments and environment variables
_config = ParamParser <CommandLine> .Parse(args);
// Setup Slack integration
// Depending on the scenario, you will need to supply only some fields
// - SocketMode app. AppLevelToken from https://api.slack.com/apps/{id}/general
// - Make calls as a Bot. BotAccessToken or (ClientId + ClientSecret + BotScopes + RedirectUrl for browser login)
// - Make calls as a User. UserAccessToken or ((ClientId + ClientSecret + UserScopes + RedirectUrl for browser login)
// RedirectUrl is optional for browser login. The default url will be http://localhost:3100/ if it is not supplied
_app = new SlackApp
{
ClientId = _config.ClientId,
ClientSecret = _config.ClientSecret,
AppLevelToken = _config.AppLevelToken,
BotAccessToken = _config.BotAccessToken,
BotScopes = _config.BotScopes ?? DefaultBotScope,
UserAccessToken = _config.UserAccessToken,
UserScopes = _config.UserScopes ?? DefaultUserScope,
RedirectUrl = _config.RedirectUrl ?? DefaultRedirectUrl,
AccessTokensUpdated = slackApp =>
{
// If you aren't supplying a bot or user access token,
// After the user logs in using the browser
Console.WriteLine($"Bot Access Token: {slackApp.BotAccessToken}");
Console.WriteLine($"User Access Token: {slackApp.UserAccessToken}");
// TODO: Save new access tokens to a safe place
},
LogBuilder = builder =>
{
// Microsoft Logging framework. Configure as you feel best
// TODO: configure the Logger builder
builder
#if DEBUG
.SetMinimumLevel(LogLevel.Debug)
#endif
.AddDebug()
.AddConsole(options =>
{
options.LogToStandardErrorThreshold = LogLevel.Debug;
});
}
};
}
public CommandNode(ParamParser <TEnv> parser)
{
Parser = parser;
}
public DictMapper Then(string key, ParamParser parser)
{
parsers[key] = parser;
return(this);
}
public DictMapper Then(string key, ParamParser parser, object markedValue)
{
parsers[key] = parser;
markedValues[key] = markedValue;
return(this);
}
public CommandNode(ParamParser parser)
{
Parser = parser;
}
public RootCommandNode(ParamParser <TEnv> parser) : base(null)
{
}
void Awake()
{
Instance = this;
}
public DictMapper <TEnv> Rest(ParamParser <TEnv> parser)
{
RestParser = parser;
return(this);
}
//private readonly Dictionary<string, object> markedValues = new Dictionary<string, object>();
//public DictMapper Then(string key, ParamParser parser, object markedValue) {
// parsers[key] = parser;
// markedValues[key] = markedValue;
// return this;
//}
public DictMapper <TEnv> Then(string key, ParamParser <TEnv> parser)
{
Parsers[key] = parser;
return(this);
}
public CommandNode(string paramName, ParamParser parser)
{
ParamName = paramName;
Parser = parser;
}
/// <summary>
/// 查询元素
/// </summary>
/// <param name="document"></param>
/// <param name="param"></param>
/// <returns></returns>
internal IEnumerable <Element> Select(Document document, string param)
{
return(ParamParser.Parse(param).SelectMany(i => i.Eval(document)).Distinct().OrderBy(i => i.Index));
}
