public Task <IObjectState> LogInAsync(string username,
string password,
CancellationToken cancellationToken)
{
var data = new Dictionary <string, object>
{
{ "username", username },
{ "password", password }
};
var command = new ParseCommand(string.Format("login?{0}", ParseClient.BuildQueryString(data)),
method: "GET",
data: null);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken)
.ContinueWith(result =>
{
var serverState = ParseObjectCoder.Decode(result.Result.Item2, ParseDecoder.Instance);
serverState = serverState.MutatedClone(mutableClone =>
{
mutableClone.IsNew = result.Result.Item1 == System.Net.HttpStatusCode.Created;
});
return serverState;
}, TaskContinuationOptions.OnlyOnRanToCompletion));
}
public Task <IObjectState> SaveAsync(IObjectState state,
IDictionary <string, IParseFieldOperation> operations,
string sessionToken,
CancellationToken cancellationToken)
{
var objectJson = ParseObject.ToJsonObjectForSaving(operations);
var command = new ParseCommand(
(state.ObjectId == null
? string.Format("classes/{0}", Uri.EscapeDataString(state.ClassName))
: string.Format("classes/{0}/{1}", Uri.EscapeDataString(state.ClassName), state.ObjectId)),
method: (state.ObjectId == null ? "POST" : "PUT"),
sessionToken: sessionToken,
data: objectJson);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).OnSuccess(t =>
{
var serverState = ParseObjectCoder.Decode(t.Result.Item2, ParseDecoder.Instance);
serverState = serverState.MutatedClone(mutableClone =>
{
mutableClone.IsNew = t.Result.Item1 == System.Net.HttpStatusCode.Created;
});
return serverState;
}));
}
public Task TestRunCommandWithErrorCode()
{
var mockHttpClient = new Mock <IHttpClient>();
var mockInstallationIdController = new Mock <IInstallationIdController>();
var fakeResponse = Task.FromResult(new Tuple <HttpStatusCode, string>(HttpStatusCode.NotFound, "{ \"code\": 101, \"error\": \"Object not found.\" }"));
mockHttpClient.Setup(obj => obj.ExecuteAsync(It.IsAny <HttpRequest>(),
It.IsAny <IProgress <ParseUploadProgressEventArgs> >(),
It.IsAny <IProgress <ParseDownloadProgressEventArgs> >(),
It.IsAny <CancellationToken>())).Returns(fakeResponse);
mockInstallationIdController.Setup(i => i.GetAsync()).Returns(Task.FromResult <Guid?>(null));
ParseCommandRunner commandRunner = new ParseCommandRunner(mockHttpClient.Object, mockInstallationIdController.Object);
var command = new ParseCommand("endpoint", method: "GET", data: null);
return(commandRunner.RunCommandAsync(command).ContinueWith(t =>
{
Assert.IsTrue(t.IsFaulted);
Assert.IsFalse(t.IsCanceled);
Assert.IsInstanceOfType(t.Exception.InnerException, typeof(ParseException));
var parseException = t.Exception.InnerException as ParseException;
Assert.AreEqual(ParseException.ErrorCode.ObjectNotFound, parseException.Code);
Assert.AreEqual("Object not found.", parseException.Message);
}));
}
public Task TestRunCommandWithArrayResult()
{
var mockHttpClient = new Mock <IHttpClient>();
var mockInstallationIdController = new Mock <IInstallationIdController>();
var fakeResponse = Task.FromResult(new Tuple <HttpStatusCode, string>(HttpStatusCode.OK, "[]"));
mockHttpClient.Setup(obj => obj.ExecuteAsync(It.IsAny <HttpRequest>(),
It.IsAny <IProgress <ParseUploadProgressEventArgs> >(),
It.IsAny <IProgress <ParseDownloadProgressEventArgs> >(),
It.IsAny <CancellationToken>())).Returns(fakeResponse);
mockInstallationIdController.Setup(i => i.GetAsync()).Returns(Task.FromResult <Guid?>(null));
ParseCommandRunner commandRunner = new ParseCommandRunner(mockHttpClient.Object, mockInstallationIdController.Object);
var command = new ParseCommand("endpoint", method: "GET", data: null);
return(commandRunner.RunCommandAsync(command).ContinueWith(t =>
{
Assert.IsFalse(t.IsFaulted);
Assert.IsFalse(t.IsCanceled);
Assert.IsInstanceOfType(t.Result.Item2, typeof(IDictionary <string, object>));
Assert.AreEqual(1, t.Result.Item2.Count);
Assert.IsTrue(t.Result.Item2.ContainsKey("results"));
Assert.IsInstanceOfType(t.Result.Item2["results"], typeof(IList <object>));
}));
}
public void Compute(string commandLine)
{
var reciever = new ParseCommand();
//Add all the command
CommandList.Add(reciever.Action(commandLine));
}
public Task <IObjectState> LogInAsync(string authType,
IDictionary <string, object> data,
CancellationToken cancellationToken)
{
var authData = new Dictionary <string, object>();
authData[authType] = data;
var command = new ParseCommand("users",
method: "POST",
data: new Dictionary <string, object>
{
{ "authData", authData }
});
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).OnSuccess(t =>
{
var serverState = ParseObjectCoder.Decode(t.Result.Item2, ParseDecoder.Instance);
serverState = serverState.MutatedClone(mutableClone =>
{
mutableClone.IsNew = t.Result.Item1 == System.Net.HttpStatusCode.Created;
});
return serverState;
}));
}
protected override void Handle()
{
List <string> commands;
if (AppState.CurrentCommand.Parameters.ContainsKey("_0"))
{
commands = GetCommands(AppState.CurrentCommand.Parameters["_0"]);
}
else
{
commands = new List <string> {
"Help"
};
}
if (commands.Count == 0)
{
AppState.CurrentOutput = new CommandOutput("Couldn't find that command.", false);
return;
}
if (commands.Count > 1)
{
AppState.CurrentOutput = new CommandOutput($"Please specify which command you'd like to get help on: {string.Join(" ", commands)}", false);
return;
}
var commandObject = ParseCommand.GetCommandObject(AppState, AppState.AvailableCommands[commands[0]]);
AppState.CurrentOutput = new CommandOutput(GetHelpText(commands[0], commandObject));
}
public void TestMakeCommand()
{
ParseCommand command = new ParseCommand("endpoint", method: "GET", sessionToken: "abcd", headers: null, data: null);
Assert.AreEqual("/1/endpoint", command.Uri.AbsolutePath);
Assert.AreEqual("GET", command.Method);
Assert.IsTrue(command.Headers.Any(pair => pair.Key == "X-Parse-Session-Token" && pair.Value == "abcd"));
}
public Task RevokeAsync(string sessionToken, CancellationToken cancellationToken)
{
var command = new ParseCommand("logout",
method: "POST",
sessionToken: sessionToken,
data: new Dictionary <string, object>());
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken));
}
public Task <IObjectState> GetUserAsync(string sessionToken, CancellationToken cancellationToken)
{
var command = new ParseCommand("users/me",
method: "GET",
sessionToken: sessionToken,
data: null);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken)
.OnSuccess(t => ParseObjectCoder.Decode(t.Result.Item2, ParseDecoder.Instance)));
}
public Task SendPushNotificationAsync(IPushState state, CancellationToken cancellationToken)
{
return(currentUserController.GetCurrentSessionTokenAsync(cancellationToken).OnSuccess(sessionTokenTask => {
var command = new ParseCommand("push",
method: "POST",
sessionToken: sessionTokenTask.Result,
data: ParsePushEncoder.Instance.Encode(state));
return commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken);
}).Unwrap());
}
public Task <IObjectState> UpgradeToRevocableSessionAsync(string sessionToken,
CancellationToken cancellationToken)
{
var command = new ParseCommand("upgradeToRevocableSession",
method: "POST",
sessionToken: sessionToken,
data: new Dictionary <string, object>());
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken)
.OnSuccess(t => ParseObjectCoder.Decode(t.Result.Item2, ParseDecoder.Instance)));
}
public Task RequestPasswordResetAsync(string email, CancellationToken cancellationToken)
{
var command = new ParseCommand("requestPasswordReset",
method: "POST",
data: new Dictionary <string, object>
{
{ "email", email }
});
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken));
}
public Task DeleteAsync(IObjectState state,
string sessionToken,
CancellationToken cancellationToken)
{
var command = new ParseCommand(string.Format("classes/{0}/{1}",
state.ClassName, state.ObjectId),
method: "DELETE",
sessionToken: sessionToken,
data: null);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken));
}
private static int Main(string[] args)
{
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
Logger.Initialize();
return(Parser.Default.ParseArguments <GenerateCommand, ParseCommand, CleanCommand, LanguageCommand>(args)
.MapResult(
(GenerateCommand opts) => GenerateCommand.Handle(opts),
(ParseCommand opts) => ParseCommand.Handle(opts),
(CleanCommand opts) => CleanCommand.Handle(opts),
(LanguageCommand opts) => LanguageCommand.Handle(opts),
(DocumentationCommand opts) => DocumentationCommand.Handle(opts),
errs => 1));
}
public Task <FileState> SaveAsync(FileState state,
Stream dataStream,
string sessionToken,
IProgress <ParseUploadProgressEventArgs> progress,
CancellationToken cancellationToken = default(CancellationToken))
{
if (state.Url != null)
{
// !isDirty
return(Task.FromResult(state));
}
if (cancellationToken.IsCancellationRequested)
{
var tcs = new TaskCompletionSource <FileState>();
tcs.TrySetCanceled();
return(tcs.Task);
}
var oldPosition = dataStream.Position;
var command = new ParseCommand("files/" + state.Name,
method: "POST",
sessionToken: sessionToken,
contentType: state.MimeType,
stream: dataStream);
return(_commandRunner.RunCommandAsync(command,
uploadProgress: progress,
cancellationToken: cancellationToken).OnSuccess(uploadTask =>
{
var result = uploadTask.Result;
var jsonData = result.Item2;
cancellationToken.ThrowIfCancellationRequested();
return new FileState
{
Name = jsonData["name"] as string,
Url = new Uri(jsonData["url"] as string, UriKind.Absolute),
MimeType = state.MimeType
};
}).ContinueWith(t =>
{
// Rewind the stream on failure or cancellation (if possible)
if ((t.IsFaulted || t.IsCanceled) && dataStream.CanSeek)
{
dataStream.Seek(oldPosition, SeekOrigin.Begin);
}
return t;
}, cancellationToken).Unwrap());
}
public void RegularInputErtapenem_Deserialize_Success()
{
// Arrange
string jsonInput = TestConstants.Ertapenem;
ParseCommand command = new ParseCommand("test");
// Act
var result = command.Deserialize(jsonInput);
// Assert
Assert.Equal(1, result.Drugs.Count);
Assert.Equal("ertapenem", result.Drugs.AsQueryable().FirstOrDefault().Name);
Assert.Equal(2, result.Drugs.AsQueryable().FirstOrDefault().IndicationsDose.IndicationAndDoseGroups.Count());
}
public Task <IObjectState> FetchAsync(IObjectState state,
string sessionToken,
CancellationToken cancellationToken)
{
var command = new ParseCommand(string.Format("classes/{0}/{1}",
Uri.EscapeDataString(state.ClassName),
Uri.EscapeDataString(state.ObjectId)),
method: "GET",
sessionToken: sessionToken,
data: null);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken)
.OnSuccess(t => ParseObjectCoder.Decode(t.Result.Item2, ParseDecoder.Instance)));
}
public static void Main()
{
NationsBuilder nationsBuilder = new NationsBuilder();
while (true)
{
List <string> input = new List <string>(Console.ReadLine().Split().ToList());
ParseCommand.ExecuteCommand(input, nationsBuilder);
if (input[0] == "Quit")
{
break;
}
}
}
private Task <IDictionary <string, object> > FindAsync(string className,
IDictionary <string, object> parameters,
string sessionToken,
CancellationToken cancellationToken)
{
var command = new ParseCommand(string.Format("classes/{0}?{1}",
Uri.EscapeDataString(className),
ParseClient.BuildQueryString(parameters)),
method: "GET",
sessionToken: sessionToken,
data: null);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken)
.OnSuccess(t => t.Result.Item2));
}
public void DrugFileForParsing_Deserialize_Success()
{
// Arrange
string jsonInput = TestConstants.DrugFileForParsing;
ParseCommand command = new ParseCommand("test");
// Act
var result = command.Deserialize(jsonInput);
// Assert
Assert.Equal(3, result.Drugs.Count);
Assert.Single(result.Drugs[0].IndicationsDose.IndicationAndDoseGroups);
Assert.Single(result.Drugs[1].IndicationsDose.IndicationAndDoseGroups);
Assert.Single(result.Drugs[2].IndicationsDose.IndicationAndDoseGroups);
}
public Task <IObjectState> SignUpAsync(IObjectState state,
IDictionary <string, IParseFieldOperation> operations,
CancellationToken cancellationToken)
{
var objectJson = ParseObject.ToJsonObjectForSaving(operations);
var command = new ParseCommand("classes/_User",
method: "POST",
data: objectJson);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).OnSuccess(t =>
{
var serverState = ParseObjectCoder.Decode(t.Result.Item2, ParseDecoder.Instance);
serverState = serverState.MutatedClone(mutableClone => { mutableClone.IsNew = true; });
return serverState;
}));
}
public Task <ParseConfig> FetchConfigAsync(string sessionToken, CancellationToken cancellationToken)
{
var command = new ParseCommand("config",
method: "GET",
sessionToken: sessionToken,
data: null);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).OnSuccess(task =>
{
cancellationToken.ThrowIfCancellationRequested();
return new ParseConfig(task.Result.Item2);
}).OnSuccess(task =>
{
cancellationToken.ThrowIfCancellationRequested();
CurrentConfigController.SetCurrentConfigAsync(task.Result);
return task;
}).Unwrap());
}
public Task <T> CallFunctionAsync <T>(string name,
IDictionary <string, object> parameters,
string sessionToken,
CancellationToken cancellationToken)
{
var command = new ParseCommand(string.Format("functions/{0}", Uri.EscapeUriString(name)),
method: "POST",
sessionToken: sessionToken,
data: NoObjectsEncoder.Instance.Encode(parameters) as IDictionary <string, object>);
return(_commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken).ContinueWith(t =>
{
var decoded = ParseDecoder.Instance.Decode(t.Result.Item2) as IDictionary <string, object>;
return decoded != null && !decoded.ContainsKey("result")
? default(T)
: Conversion.To <T>(decoded["result"]);
}, TaskContinuationOptions.OnlyOnRanToCompletion));
}
public Task TrackAppOpenedAsync(string pushHash,
string sessionToken,
CancellationToken cancellationToken)
{
IDictionary <string, object> data = new Dictionary <string, object> {
{ "at", DateTime.Now }
};
if (pushHash != null)
{
data["push_hash"] = pushHash;
}
var command = new ParseCommand("events/AppOpened",
method: "POST",
sessionToken: sessionToken,
data: PointerOrLocalIdEncoder.Instance.Encode(data) as IDictionary <string, object>);
return(commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken));
}
public Task TestRunCommand()
{
var mockHttpClient = new Mock <IHttpClient>();
var fakeResponse = Task <Tuple <HttpStatusCode, string> > .FromResult(new Tuple <HttpStatusCode, string>(HttpStatusCode.OK, "{}"));
mockHttpClient.Setup(obj => obj.ExecuteAsync(It.IsAny <HttpRequest>(),
It.IsAny <IProgress <ParseUploadProgressEventArgs> >(),
It.IsAny <IProgress <ParseDownloadProgressEventArgs> >(),
It.IsAny <CancellationToken>())).Returns(fakeResponse);
ParseCommandRunner commandRunner = new ParseCommandRunner(mockHttpClient.Object);
var command = new ParseCommand("endpoint", method: "GET", data: null);
return(commandRunner.RunCommandAsync(command).ContinueWith(t => {
Assert.False(t.IsFaulted);
Assert.False(t.IsCanceled);
Assert.IsInstanceOf(typeof(IDictionary <string, object>), t.Result.Item2);
Assert.AreEqual(0, t.Result.Item2.Count);
}));
}
public Task TestRunCommandWithInvalidString()
{
var mockHttpClient = new Mock <IHttpClient>();
var fakeResponse = Task <Tuple <HttpStatusCode, string> > .FromResult(new Tuple <HttpStatusCode, string>(HttpStatusCode.OK, "invalid"));
mockHttpClient.Setup(obj => obj.ExecuteAsync(It.IsAny <HttpRequest>(),
It.IsAny <IProgress <ParseUploadProgressEventArgs> >(),
It.IsAny <IProgress <ParseDownloadProgressEventArgs> >(),
It.IsAny <CancellationToken>())).Returns(fakeResponse);
ParseCommandRunner commandRunner = new ParseCommandRunner(mockHttpClient.Object);
var command = new ParseCommand("endpoint", method: "GET", data: null);
return(commandRunner.RunCommandAsync(command).ContinueWith(t => {
Assert.True(t.IsFaulted);
Assert.False(t.IsCanceled);
Assert.IsInstanceOf <ParseException>(t.Exception.InnerException);
var parseException = t.Exception.InnerException as ParseException;
Assert.AreEqual(ParseException.ErrorCode.OtherCause, parseException.Code);
}));
}
public IStatement[] Parse(string payload, ScriptKind scriptKind)
{
var command = new ParseCommand()
{
Payload = payload,
ScriptKind = scriptKind
};
var response = this.ExecuteCommand(command);
var result = JsonConvert.DeserializeObject <ParseCommandResult>(response);
List <IStatement> ast = JsonConvert.DeserializeObject <List <IStatement> >(result.AstPayload, new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto,
NullValueHandling = NullValueHandling.Ignore,
MetadataPropertyHandling = MetadataPropertyHandling.ReadAhead
});
return(ast.ToArray());
}
public Task TrackEventAsync(string name,
IDictionary <string, string> dimensions,
string sessionToken,
CancellationToken cancellationToken)
{
IDictionary <string, object> data = new Dictionary <string, object> {
{ "at", DateTime.Now },
{ "name", name },
};
if (dimensions != null)
{
data["dimensions"] = dimensions;
}
var command = new ParseCommand("events/" + name,
method: "POST",
sessionToken: sessionToken,
data: PointerOrLocalIdEncoder.Instance.Encode(data) as IDictionary <string, object>);
return(commandRunner.RunCommandAsync(command, cancellationToken: cancellationToken));
}
static void Main(string[] args)
{
// 实例化创建消息命令类的对象。
CreateCommand ca1 = new CreateCommand();
CreateCommand ca2 = new CreateCommand();
CreateCommand ca3 = new CreateCommand(MessageType.Command, 0x00000001);
CreateCommand ca4 = new CreateCommand(MessageType.CommandACK);
CreateCommand ca5 = new CreateCommand(MessageType.CommandResult, 0x00000001);
// 采用 DES 密钥加密。
DESHelper des = new DESHelper();
byte[] desKey = des.GetSecretKey();
CreateCommand ca6 = new CreateCommand(MessageType.Event, desKey, 0x00000001);
CreateCommand ca7 = new CreateCommand(MessageType.EventACK);
// 获取数据报文字节数组。
byte[] cmd1 = new byte[] { ca1.GetHeartbeatDataCommand() };
byte[] cmd2 = new byte[] { ca2.GetHeartbeatResponseCommand() };
byte[] cmd3 = ca3.GetRequestCommand(MessageId.RealTimeControlLuminaire, ParameterType.Brightness, "100");
byte[] cmd4 = ca4.GetResponseCommand(0x0);
byte[] cmd5 = ca5.GetResultCommand(0x0, MessageId.RealTimeControlLuminaire, ErrorCode.Succeed, "成功");
byte[] cmd6 = ca6.GetEventCommand(MessageId.DataCollection, new List <Parameter> {
new Parameter(ParameterType.DeviceCategory, "02"), new Parameter(ParameterType.DeviceType, "01"), new Parameter(ParameterType.SerialNumber, 0x00000001), new Parameter(ParameterType.LuminaireId, "00000001".ToByteArray(true))
});
byte[] cmd7 = ca7.GetEventResponseCommand(0x01);
// 将字节数组转成十六进制字符串形式并打印。
Console.WriteLine("一、生成命令\n1、心跳包数据\n" + cmd1.ToHexString()
+ "\n\n2、心跳包响应\n" + cmd2.ToHexString()
+ "\n\n3、请求命令\n" + cmd3.ToHexString()
+ "\n\n4、响应命令\n" + cmd4.ToHexString()
+ "\n\n5、结果命令\n" + cmd5.ToHexString()
+ "\n\n6、事件命令\n" + cmd6.ToHexString()
+ "\n\n7、事件响应\n" + cmd7.ToHexString());
// 订阅消息报文处理事件。
ParseCommand pa1 = new ParseCommand(cmd1);
ParseCommand pa2 = new ParseCommand(cmd2);
ParseCommand pa3 = new ParseCommand(cmd3);
ParseCommand pa4 = new ParseCommand(cmd4);
ParseCommand pa5 = new ParseCommand(cmd5);
// 采用 DES 密钥解密。
ParseCommand pa6 = new ParseCommand(cmd6, desKey);
ParseCommand pa7 = new ParseCommand(cmd7);
pa1.DatagramProcess += Oa_DatagramProcess;
pa2.DatagramProcess += Oa_DatagramProcess;
pa3.DatagramProcess += Oa_DatagramProcess;
pa4.DatagramProcess += Oa_DatagramProcess;
pa5.DatagramProcess += Oa_DatagramProcess;
pa6.DatagramProcess += Oa_DatagramProcess;
pa7.DatagramProcess += Oa_DatagramProcess;
// 触发消息报文处理事件。
Console.WriteLine("\n\n二、解析命令\n1、心跳包数据");
pa1.OnDatagramProcess();
Console.WriteLine("\n2、心跳包响应");
pa2.OnDatagramProcess();
Console.WriteLine("\n3、请求命令");
pa3.OnDatagramProcess();
Console.WriteLine("\n4、响应命令");
pa4.OnDatagramProcess();
Console.WriteLine("\n5、结果命令");
pa5.OnDatagramProcess();
Console.WriteLine("\n6、事件命令");
pa6.OnDatagramProcess();
Console.WriteLine("\n7、事件响应");
pa7.OnDatagramProcess();
// 等待用户按键退出。
Console.ReadKey();
}
