private static async Task AsyncDownloadWithProgress <TResponse>(IReturn <TResponse> requestDto)
{
var hold = AsyncServiceClient.BufferSize;
AsyncServiceClient.BufferSize = 100;
try
{
var asyncClient = new JsonServiceClient(Config.ServiceStackBaseUri);
var progress = new List <string>();
//Note: total = -1 when 'Transfer-Encoding: chunked'
//Available in ASP.NET or in HttpListener when downloading responses with known lengths:
//E.g: Strings, Files, etc.
asyncClient.OnDownloadProgress = (done, total) =>
progress.Add("{0}/{1} bytes downloaded".Fmt(done, total));
var response = await asyncClient.PostAsync(requestDto);
progress.Each(x => x.Print());
Assert.That(progress.Count, Is.GreaterThan(0));
Assert.That(progress.First(), Is.EqualTo("100/1160 bytes downloaded"));
Assert.That(progress.Last(), Is.EqualTo("1160/1160 bytes downloaded"));
}
finally
{
AsyncServiceClient.BufferSize = hold;
}
}
public async Task ShouldCreateScheduleWhenRequested()
{
var scheduleWebApiClient = new JsonServiceClient(ScheduleWebApiBaseUrl);
var maintenanceWindowServiceLocation = new ServiceLocation
{
Location = new Uri("http://localhost:5678")
};
_mockServer.Given(
Request.Create().UsingGet().WithPath("/MaintenanceWindowService"))
.RespondWith(
Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindowServiceLocation));
var maintenanceWindows = Any.Instance <MaintenanceWindow>();
_mockServer.Given(
Request.Create().UsingGet().WithPath("/Planned"))
.RespondWith(
Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindows));
var workloadItems = new List <WorkloadItem>
{
Any.Instance <WorkloadItem>(),
Any.Instance <WorkloadItem>()
};
var createScheduleRequest = new CreateScheduleRequest
{
WorkloadItems = workloadItems
};
var result = await scheduleWebApiClient.PostAsync(createScheduleRequest).ConfigureAwait(false);
result.Id.Should().NotBe(Guid.Empty);
}
public async Task Does_deserialize_json_RequestBody_Async()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var response = await client.PostAsync(new CreateMovies {
Movies = ResetMoviesService.Top5Movies
});
Assert.That(response.Movies, Is.EquivalentTo(ResetMoviesService.Top5Movies));
var responseAsync = await client.PostAsync(new CreateMoviesAsync {
Movies = ResetMoviesService.Top5Movies
});
Assert.That(responseAsync.Movies, Is.EquivalentTo(ResetMoviesService.Top5Movies));
}
public void WhenISendDataThruPostAsyncAction(Table table)
{
Order order = table.CreateSet <Order>().Single();
JsonServiceClient client = GetClient();
client.PostAsync(order).Wait();
}
public async Task Can_Cancel_long_running_request()
{
var tag = Guid.NewGuid().ToString();
var client = new JsonServiceClient(Config.AbsoluteBaseUri)
{
RequestFilter = req => req.Headers[HttpHeaders.XTag] = tag
};
var responseTask = client.PostAsync(new TestCancelRequest
{
Tag = tag
});
await Task.Delay(1000);
var cancelResponse = client.Post(new CancelRequest {
Tag = tag
});
Assert.That(cancelResponse.Tag, Is.EqualTo(tag));
try
{
var response = await responseTask;
Assert.Fail("Should throw");
}
catch (WebServiceException ex)
{
Assert.That(ex.ErrorCode, Is.EqualTo(typeof(OperationCanceledException).Name));
}
}
public async Task Can_call_return_void()
{
client.Post(new ReturnsVoid {
Message = "Foo"
});
Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo"));
await client.PostAsync(new ReturnsVoid { Message = "Foo" });
Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo"));
using (client.Post <HttpWebResponse>(new ReturnsVoid {
Message = "Bar"
})) { }
Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Bar"));
}
public Task AuthorizeAsync(ILoginSettings loginSettings)
{
var taskCompletionSource = new TaskCompletionSource <AuthResponse>();
_jsonServiceClient.LocalHttpWebRequestFilter = LocalHttpWebRequestFilter(loginSettings);
var request = new Auth
{
UserName = loginSettings.UserName,
Password = loginSettings.Password,
RememberMe = true, //important tell client to retain permanent cookies
};
_jsonServiceClient.PostAsync(request, taskCompletionSource.SetResult,
(authResponse, error) => taskCompletionSource.SetException(error));
return(taskCompletionSource.Task);
}
public void WhenISendDataThruPostAsyncWithResponseAction(Table table)
{
Order order = table.CreateSet <Order>().Single();
JsonServiceClient client = GetClient();
bool response = client.PostAsync <bool>(order).Result;
ScenarioContext.Current[ResopnseKey] = response;
}
public async Task <IActionResult> OnPost()
{
IServiceClient client = new JsonServiceClient(baseUrl).WithCache();
var result = await client.PostAsync <CreateProductResponseDTO>("/products", new CreateProductRequestDTO { Name = Name, Category = Category, Description = Description, Price = Price });
return(Redirect("/"));
}
public async Task Can_POST_to_IdWithAlias_with_JsonServiceClient_async()
{
var client = new JsonServiceClient(Config.AbsoluteBaseUri);
var response = await client.PostAsync(new IdWithAlias { Id = 1 });
Assert.That(response.Id, Is.EqualTo(1));
}
public async Task ShouldRetrieveCreatedSchedule()
{
var scheduleWebApiClient = new JsonServiceClient(ScheduleWebApiBaseUrl);
var maintenanceWindowServiceLocation = new ServiceLocation
{
Location = new Uri("http://localhost:5678")
};
_mockServer.Given(
Request.Create().UsingGet().WithPath("/MaintenanceWindowService"))
.RespondWith(
Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindowServiceLocation));
var maintenanceWindows = new MaintenanceWindow
{
LengthInHours = 5
};
_mockServer.Given(
Request.Create().UsingGet().WithPath("/Planned"))
.RespondWith(
Response.Create().WithSuccess().WithBodyAsJson(maintenanceWindows));
var workloadItems = new List <WorkloadItem>
{
new WorkloadItem
{
Identifier = Guid.NewGuid(),
DurationInHours = 7
},
new WorkloadItem
{
Identifier = Guid.NewGuid(),
DurationInHours = 3
}
};
var createScheduleRequest = new CreateScheduleRequest
{
WorkloadItems = workloadItems
};
var createScheduleResponse = await scheduleWebApiClient.PostAsync(createScheduleRequest).ConfigureAwait(false);
var getScheduleByIdRequest = new GetScheduleByIdRequest
{
ScheduleId = createScheduleResponse.Id
};
var getScheduleByIdResponse = await scheduleWebApiClient.GetAsync(getScheduleByIdRequest).ConfigureAwait(false);
getScheduleByIdResponse.Schedule.Count.Should().Be(2);
getScheduleByIdResponse.Schedule.Should().Contain(x => x.Identifier == workloadItems[0].Identifier &&
x.Order == 2);
getScheduleByIdResponse.Schedule.Should().Contain(x => x.Identifier == workloadItems[1].Identifier &&
x.Order == 1);
}
public Task <SubscriptionDTO> Subscribe(SubscriptionDTO subscriptionDTO)
{
var client = new JsonServiceClient(BaseUrl);
client.AddHeader("Authorization", "Basic bXlfdXNlcm5hbWU6bXlfcGFzc3dvcmQ=");
var result = client.PostAsync <SubscriptionDTO>("/api/Subscription", subscriptionDTO);
return(result);
}
public async Task Can_send_async_compressed_client_request(string compressionType)
{
var client = new JsonServiceClient(Config.ListeningOn)
{
RequestCompressionType = compressionType,
};
var response = await client.PostAsync(new HelloZip { Name = compressionType });
Assert.That(response.Result, Is.EqualTo($"Hello, {compressionType}"));
}
public async Task Can_call_return_void()
{
client.Post(new ReturnsVoid {
Message = "Foo"
});
Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo"));
await client.PostAsync(new ReturnsVoid { Message = "Foo" });
Assert.That(TestAsyncService.ReturnVoidMessage, Is.EqualTo("Foo"));
}
public void PostAsync <TResponse>(
IReturn <TResponse> request,
Action <TResponse> onSuccess,
Action <TResponse, Exception> onError)
{
_client.PostAsync <TResponse>(request /*, onSuccess, onError*/);
}
private async Task <T> Post <T>(RpcMethod method, string[] parameters = null)
{
using (var client = new JsonServiceClient(baseUrl))
{
var command = new RpcCommand
{
Method = method,
Params = parameters
};
var response = await client.PostAsync(command);
var rpcresult = response.FromJson <RpcResult <T> >();
return(rpcresult.result);
}
}
public async Task Can_send_GZip_client_request_list_async()
{
var client = new JsonServiceClient(Config.ListeningOn)
{
RequestCompressionType = CompressionTypes.GZip,
};
var response = await client.PostAsync(new HelloZip
{
Name = "GZIP",
Test = new List <string> {
"Test"
}
});
Assert.That(response.Result, Is.EqualTo("Hello, GZIP (1)"));
}
public async Task CreateTimer(TimerInfo info)
{
DateTime startTime = info.StartDate.AddSeconds(info.PrePaddingSeconds * -1);
DateTime endTime = info.EndDate.AddSeconds(info.PostPaddingSeconds);
CreateTimerResponse response = await client.PostAsync(new CreateTimerRequest
{
file = info.Name,
channel = info.ChannelId,
eventid = info.ProgramId,
start = int.Parse(startTime.ToLocalTime().ToString("HHmm")),
stop = int.Parse(endTime.ToLocalTime().ToString("HHmm")),
day = startTime.ToString("yyyy-MM-dd"),
weekdays = "-------",
});
}
public void SendConfirmation(MailAddress confirmer, ApiKey toBeConfirmed, Uri confirmationUrl)
{
string emailApiKey = ConfigurationManager.AppSettings["email_api_key"];
var jsonClient = new JsonServiceClient("https://mandrillapp.com/api/1.0/");
jsonClient.PostAsync <ConfirmationResponse[]>("messages/send-template",
new ConfirmationRequest(emailApiKey, "api-key-confirmation", confirmer, toBeConfirmed, confirmationUrl),
success =>
{
if (!isRejected(success) && hasId(success))
{
Debug.Write(success[0]._id);
}
},
(error, ex) => Debug.Fail(error[0].Failure));
}
public void Handles_error_from_Filter_async()
{
try
{
var client = new JsonServiceClient(BaseUrl);
client.PostAsync(new ActionError {
Id = "ActionError"
}).Wait();
}
catch (AggregateException aex)
{
var ex = (WebServiceException)aex.UnwrapIfSingleException();
Assert.That(ex.StatusCode, Is.EqualTo(500));
Assert.That(ex.StatusDescription, Is.EqualTo("NullReferenceException"));
Assert.That(ex.Message, Is.EqualTo("Object reference not set to an instance of an object."));
}
}
internal async Task <bool> GetCsrfToken(string resourceUrl)
{
var client = new JsonServiceClient(_creds.ApiBaseURL);
var body = new { username = _creds.Username, password = _creds.Password };
_cookie = null;
var json = await client.PostAsync <string>(resourceUrl, body);
if (!Json.TryDeserialize <D8Cookie>(json, out _cookie))
{
return(false);
}
_csrfToken = await CookieAuthClient().GetAsync <string>("rest/session/token");
return(!_csrfToken.IsBlank());
}
private async static void TestService()
{
var client = new JsonServiceClient("http://localhost:2020/");
try
{
var request = new UpdateAddressVoid();
request.ToGetUrl().Print();
request.ToPostUrl().Print();
await client.PostAsync(request);
//var response = client.Post(request);
}
catch (WebServiceException ex)
{
ex.StatusCode.ToString().Print();
ex.StatusDescription.Print();
ex.ResponseBody.Print();
ex.ResponseStatus.PrintDump();
}
}
private async void btnAuth_Click(object sender, RoutedEventArgs e)
{
try
{
await client.PostAsync(new Authenticate
{
provider = "credentials",
UserName = "******",
Password = "******",
});
var response = await client.GetAsync(new HelloAuth { Name = "Secure " + txtName.Text });
lblResults.Text = response.Result;
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
}
public async Task <bool> ReproduceBug()
{
MyExampleService request = new MyExampleService();
request.Param = "test";
using (JsonServiceClient client = new JsonServiceClient(serviceURL))
{
try
{
var result = await client.PostAsync(request);
Debug.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
return(true);
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
return(false);
}
}
}
public async Task Can_proxy_to_test_servicestack_Async()
{
var client = new JsonServiceClient(ListeningOn.CombineWith("test"));
var request = new EchoTypes
{
Byte = 1,
Short = 2,
Int = 3,
Long = 4,
Float = 1.1f,
String = "foo"
};
var response = await client.PostAsync(request);
Assert.That(response.Byte, Is.EqualTo(1));
Assert.That(response.Short, Is.EqualTo(2));
Assert.That(response.Int, Is.EqualTo(3));
Assert.That(response.Long, Is.EqualTo(4));
Assert.That(response.Float, Is.EqualTo(1.1f));
Assert.That(response.String, Is.EqualTo("foo"));
}
private async void btnAuth_Click(object sender, RoutedEventArgs e)
{
try
{
var client = new JsonServiceClient("http://localhost:81/");
await client.PostAsync(new Authenticate
{
provider = "credentials",
UserName = "******",
Password = "******",
});
var response = await client.GetAsync(new HelloAuth { Name = "secure" });
lblResults.Content = response.Result;
}
catch (Exception ex)
{
lblResults.Content = ex.ToString();
}
}
static void Main(string[] args)
{
int amount = -1;
JsonServiceClient client = null;
client = new JsonServiceClient("http://localhost:4057") { UserName = "******", Password = "******" };
var assignRResp = client.Send<AssignRolesResponse>(new AssignRoles
{
UserName = "******",
Roles = new ArrayOfString("StatusUser"),
Permissions = new ArrayOfString("GetStatus")
});
try
{
var repsspp = client.Send<StatusResponse>(new StatusQuery() { Date = DateTime.Now });
}
catch (WebServiceException ex)
{
if (ex.Message != null) { }
}
client.PostAsync<MagicResponse>(new MagicRequest { Id = 1 },
resp => Console.WriteLine(resp.OutId), (resp, err) => { Console.WriteLine(err.Message); });
while (amount != 0)
{
Console.WriteLine("Enter a protein amount (press 0 to exit)");
if (int.TryParse(Console.ReadLine(), out amount))
{
var response = client.Send<EntryResponse>(new Entry { Amount = amount, Time = DateTime.Now });
Console.WriteLine("Response, ID: " + response.Id);
}
}
var reps2 = client.Post<StatusResponse>("status", new StatusQuery { Date = DateTime.Now });
Console.WriteLine("{0} / {1}", reps2.Total, reps2.Goal);
Console.WriteLine(reps2.Message);
Console.ReadLine();
}
private async void btnAuth_Click(object sender, RoutedEventArgs e)
{
try
{
var client = new JsonServiceClient("http://localhost:81/");
await client.PostAsync(new Authenticate
{
provider = "credentials",
UserName = "******",
Password = "******",
});
var response = await client.GetAsync(new HelloAuth { Name = "secure" });
lblResults.Content = response.Result;
}
catch (Exception ex)
{
lblResults.Content = ex.ToString();
}
}
public MainWindowViewModel()
{
Locator.CurrentMutable.RegisterConstant(this);
User = new CurrentUserViewModel();
Locator.CurrentMutable.RegisterConstant <ICurrentUser>(User);
configuration = Locator.Current.GetService <IConfiguration>();
settings = configuration?.GetSection("ChatClientSettings")?.Get <ChatClientSettings>();
var mapper = Locator.Current.GetService <IMapper>();
if (settings == null)
{
settings = new ChatClientSettings();
}
if (settings.HostUrl.IsNullOrEmpty())
{
settings.HostUrl = "http://localhost:5000";
}
if (settings.AttachmentDefaultPath.IsNullOrEmpty())
{
settings.AttachmentDefaultPath = "\\Download";
}
serviceClient = new JsonServiceClient(settings.HostUrl);
ProfileViewModel = new ProfileViewModel(serviceClient);
Locator.CurrentMutable.RegisterConstant <IProfile>(ProfileViewModel);
ProfileViewModel.IsOpenProfileEvent += () => WindowStates(WindowState.OpenProfile);
AttachmentViewModel = new SendAttachmentsViewModel(serviceClient);
SettingsViewModel = new SettingsViewModel(serviceClient);
SettingsViewModel.OpenSettingsActiveEvent += (e) => { WindowStates(WindowState.WindowSettings); };
SettingsViewModel.TypeEnterEvent += (e) => { KeySendMessage = e; };
SettingsViewModel.ContextMenuSettingsActiveEvent += (e) => { WindowStates(WindowState.HeaderMenuPopup); };
SettingsViewModel.SetSelectedOnSettingsItemEvent += e => { TextHeaderMenuInSettings = SettingsViewModel.SettingsMenuActiveMain ? "Сообщения и чаты" : "Аудит входа"; };
Width(false);
User.UserName = settings.UserName;
Tokens = new TokenResult {
AccessToken = settings.AccessToken, RefreshToken = settings.RefreshToken
};
Messages = new ObservableCollection <IMessagesContainerViewModel>();
var bits = Environment.Is64BitOperatingSystem ? "PC 64bit, " : "PC 32bit, ";
var operatingSystem = bits + RuntimeInformation.OSDescription;
string ipAddress = "";
try
{
ipAddress = new WebClient().DownloadString("https://api.ipify.org");
}
catch (Exception e)
{
try
{
IPHostEntry ipHost = Dns.GetHostEntry("localhost");
if (ipHost.AddressList.Length > 0)
{
ipAddress = ipHost.AddressList.Last().ToString();
}
}
catch (Exception exception) { }
}
var nameVersionClient = "SkillChat Avalonia Client 1.0";
ConnectCommand = ReactiveCommand.CreateFromTask(async() =>
{
try
{
_connection = new HubConnectionBuilder()
.WithUrl(settings.HostUrl + "/ChatHub")
.Build();
_hub = _connection.CreateHub <IChatHub>();
ProfileViewModel.SetChatHub(_hub);
AttachmentViewModel.SetChatHub(_hub);
if (Tokens == null || Tokens.AccessToken.IsNullOrEmpty())
{
Tokens = await serviceClient.PostAsync(new AuthViaPassword
{
Login = User.UserName, Password = User.Password
});
settings.AccessToken = Tokens.AccessToken;
settings.RefreshToken = Tokens.RefreshToken;
settings.UserName = User.UserName;
configuration.GetSection("ChatClientSettings").Set(settings);
}
serviceClient.BearerToken = Tokens.AccessToken;
this.ObservableForProperty(m => m.ExpireTime).Subscribe(change =>
{
if (change.Value != null)
{
//TODO запуск обновления токена
}
});
_connection.Subscribe <LogOn>(async data =>
{
if (data.Error)
{
IsSignedIn = false;
serviceClient.BearerToken = Tokens.RefreshToken;
try
{
Tokens = await serviceClient.PostAsync(new PostRefreshToken());
settings.AccessToken = Tokens.AccessToken;
settings.RefreshToken = Tokens.RefreshToken;
configuration.GetSection("ChatClientSettings").Set(configuration);
await _hub.Login(Tokens.AccessToken, operatingSystem, ipAddress, nameVersionClient);
}
catch (Exception e)
{
Tokens = null;
}
}
else
{
IsSignedIn = true;
User.Id = data.Id;
User.Login = data.UserLogin;
ExpireTime = data.ExpireTime;
var chats = await serviceClient.GetAsync(new GetChatsList());
var chat = chats.Chats.FirstOrDefault();
ChatId = chat?.Id;
ChatName = chat?.ChatName;
LoadMessageHistoryCommand.Execute(null);
//Получаем настройки
SettingsViewModel.ChatSettings = await serviceClient.GetAsync(new GetMySettings());
KeySendMessage = SettingsViewModel.ChatSettings.SendingMessageByEnterKey;
}
});
_connection.Subscribe <UpdateUserDisplayName>(async user =>
{
try
{
var updateMessages = Messages.Where(s => s is UserMessagesContainerViewModel);
foreach (var message in updateMessages)
{
foreach (var item in message.Messages.Where(s => s.UserId == user.Id))
{
item.UserNickname = user.DisplayName;
}
}
ProfileViewModel.UpdateUserProfile(user.DisplayName, user.Id);
}
catch (Exception e)
{
SignOutCommand.Execute(null);
}
});
_connection.Subscribe <ReceiveMessage>(async data =>
{
var isMyMessage = User.Id == data.UserId;
var hasAttachments = data.Attachments != null && data.Attachments.Count > 0;
MessageViewModel newMessage;
if (isMyMessage)
{
newMessage = hasAttachments ? new MyAttachmentViewModel() : new MyMessageViewModel();
}
else
{
newMessage = hasAttachments ? new UserAttachmentViewModel() : new UserMessageViewModel();
}
newMessage.Id = data.Id;
newMessage.Text = data.Message;
newMessage.PostTime = data.PostTime;
newMessage.UserNickname = data.UserNickname ?? data.UserLogin;
newMessage.UserId = data.UserId;
newMessage.Attachments = data.Attachments?
.Select(s =>
{
var attah = mapper?.Map <AttachmentMold>(s);
return(new AttachmentMessageViewModel(attah));
}).ToList();
var container = Messages.LastOrDefault();
if (isMyMessage)
{
if (!(container is MyMessagesContainerViewModel))
{
container = new MyMessagesContainerViewModel();
Messages.Add(container);
}
}
else
{
if (container is UserMessagesContainerViewModel)
{
var lastMessage = container.Messages.LastOrDefault();
if (lastMessage?.UserId != newMessage.UserId)
{
container = new UserMessagesContainerViewModel();
Messages.Add(container);
}
}
else
{
container = new UserMessagesContainerViewModel();
Messages.Add(container);
}
if (!windowIsFocused || SettingsViewModel.IsOpened)
{
Notify.NewMessage(newMessage.UserNickname, newMessage.Text.Replace("\r\n", " "));
}
}
container.Messages.Add(newMessage);
if (container.Messages.First() == newMessage)
{
newMessage.ShowNickname = true;
}
MessageReceived?.Invoke(new ReceivedMessageArgs(newMessage));
});
_connection.Closed += connectionOnClosed();
await _connection.StartAsync();
await _hub.Login(Tokens.AccessToken, operatingSystem, ipAddress, nameVersionClient);
//Messages.Add("Connection started");
IsShowingLoginPage = false;
IsShowingRegisterPage = false;
ValidationError = "";
IsConnected = true;
User.Password = "";
}
catch (Exception ex)
{
//Изменение параеметров TextBox в случае ошибки
User.Error("неверный логин или пароль");
ErrorBe?.Invoke();
IsShowingLoginPage = _connection.State != HubConnectionState.Connected ? true : false;
//Messages.Add(ex.Message);
}
});
if (Tokens.AccessToken.IsNullOrEmpty() == false)
{
ConnectCommand.Execute(null);
}
SendCommand = ReactiveCommand.CreateFromTask(async() =>
{
try
{
await _hub.SendMessage(new HubMessage(ChatId, MessageText));
MessageText = null;
}
catch (Exception ex)
{
SignOutCommand.Execute(null);
}
},
this.WhenAnyValue(m => m.IsConnected, m => m.MessageText,
(b, m) => b == true && !string.IsNullOrEmpty(m)));
LoadMessageHistoryCommand = ReactiveCommand.CreateFromTask(async() =>
{
try
{
var first = Messages.FirstOrDefault()?.Messages.FirstOrDefault();
var request = new GetMessages {
ChatId = ChatId, BeforePostTime = first?.PostTime
};
// Логика выбора сообщений по id чата
var result = await serviceClient.GetAsync(request);
foreach (var item in result.Messages)
{
var isMyMessage = User.Id == item.UserId;
var hasAttachments = item.Attachments != null && item.Attachments.Count > 0;
MessageViewModel newMessage;
if (isMyMessage)
{
newMessage = hasAttachments ? new MyAttachmentViewModel() : new MyMessageViewModel();
}
else
{
newMessage = hasAttachments ? new UserAttachmentViewModel() : new UserMessageViewModel();
}
newMessage.Id = item.Id;
newMessage.Text = item.Text;
newMessage.PostTime = item.PostTime;
newMessage.UserNickname = item.UserNickName;
newMessage.UserId = item.UserId;
newMessage.Attachments = item.Attachments?.Select(s => new AttachmentMessageViewModel(s)).ToList();
var container = Messages.FirstOrDefault();
if (isMyMessage)
{
if (!(container is MyMessagesContainerViewModel))
{
container = new MyMessagesContainerViewModel();
Messages.Insert(0, container);
}
}
else
{
if (container is UserMessagesContainerViewModel)
{
var firstMessage = container.Messages.FirstOrDefault();
if (firstMessage?.UserId != newMessage.UserId)
{
container = new UserMessagesContainerViewModel();
Messages.Insert(0, container);
}
}
else
{
container = new UserMessagesContainerViewModel();
Messages.Insert(0, container);
}
}
container.Messages.Insert(0, newMessage);
var firstInBlock = container.Messages.First();
foreach (var message in container.Messages)
{
message.ShowNickname = firstInBlock == message;
}
}
}
catch (Exception e)
{
}
});
SignOutCommand = ReactiveCommand.CreateFromTask(async() =>
{
try
{
Messages.Clear();
MessageText = null;
Tokens = null;
IsSignedIn = false;
IsConnected = false;
serviceClient.BearerToken = null;
if (_connection != null)
{
_connection.Closed -= connectionOnClosed();
await _connection.StopAsync();
}
_connection = null;
_hub = null;
settings.AccessToken = null;
settings.RefreshToken = null;
configuration.GetSection("ChatClientSettings").Set(settings);
WindowStates(WindowState.SignOut);
}
catch (Exception ex)
{
}
finally
{
IsShowingLoginPage = true;
}
});
IsShowingLoginPage = true;
// Скрывает окно регистрации
IsShowingRegisterPage = false;
IsShowingLoginPage = true;
GoToRegisterCommand = ReactiveCommand.Create <object>(_ =>
{
IsShowingRegisterPage = true;
IsShowingLoginPage = false;
RegisterUser.Login = User.UserName;
User.Password = "";
});
RegisterUser = new RegisterUserViewModel();
RegisterUser.GoToLoginCommand = ReactiveCommand.Create <object>(_ =>
{
IsShowingRegisterPage = false;
IsShowingLoginPage = true;
RegisterUser.Password = "";
User.UserName = RegisterUser.Login;
});
IsConnected = false; //Скрывает окно чата
RegisterCommand = ReactiveCommand.CreateFromTask(async() =>
{
var request = new RegisterNewUser();
try
{
ValidationError = "";
if (string.IsNullOrWhiteSpace(RegisterUser.Login) ||
string.IsNullOrWhiteSpace(RegisterUser.Password))
{
throw new Exception("Не заполнены логин и/или пароль");
}
request.Login = RegisterUser.Login;
request.Password = RegisterUser.Password;
request.UserName = RegisterUser.UserName;
Tokens = await serviceClient.PostAsync(request);
settings.AccessToken = Tokens.AccessToken;
settings.RefreshToken = Tokens.RefreshToken;
settings.UserName = RegisterUser.Login;
configuration.GetSection("ChatClientSettings").Set(settings);
ConnectCommand.Execute(null);
}
catch (Exception ex)
{
Debug.WriteLine($"Ошибка регистрации {ex.Message}");
ValidationError = ex.Message;
}
});
NotifyCommand = ReactiveCommand.Create <object>(obj =>
{
if (obj is IHaveIsActive win)
{
windowIsFocused = win.IsActive;
}
});
PointerPressedCommand = ReactiveCommand.Create <object>(obj =>
{
ProfileViewModel.ContextMenuClose();
SettingsViewModel.CloseContextMenu();
});
ProfileViewModel.SignOutCommand = SignOutCommand;
ProfileViewModel.LoadMessageHistoryCommand = LoadMessageHistoryCommand;
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
//AndroidPclExportClient.Configure();
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
var btnSync = FindViewById <Button>(Resource.Id.btnSync);
var btnAsync = FindViewById <Button>(Resource.Id.btnAsync);
var btnAwait = FindViewById <Button>(Resource.Id.btnAwait);
var btnAuth = FindViewById <Button>(Resource.Id.btnAuth);
var btnShared = FindViewById <Button>(Resource.Id.btnShared);
var txtName = FindViewById <EditText>(Resource.Id.txtName);
var lblResults = FindViewById <TextView>(Resource.Id.lblResults);
//10.0.2.2 = loopback
//http://developer.android.com/tools/devices/emulator.html
var client = new JsonServiceClient("http://10.0.2.2:2000/");
var gateway = new SharedGateway("http://10.0.2.2:2000/");
btnSync.Click += delegate
{
try
{
var response = client.Get(new Hello {
Name = txtName.Text
});
lblResults.Text = response.Result;
using (var ms = new MemoryStream("Contents".ToUtf8Bytes()))
{
ms.Position = 0;
var fileResponse = client.PostFileWithRequest <HelloResponse>(
"/hello", ms, "filename.txt", new Hello {
Name = txtName.Text
});
lblResults.Text = fileResponse.Result;
}
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
btnAsync.Click += delegate
{
client.GetAsync(new Hello {
Name = txtName.Text
})
.Success(response => lblResults.Text = response.Result)
.Error(ex => lblResults.Text = ex.ToString());
};
btnAwait.Click += async delegate
{
try
{
var response = await client.GetAsync(new Hello { Name = txtName.Text });
lblResults.Text = response.Result;
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
btnAuth.Click += async delegate
{
try
{
await client.PostAsync(new Authenticate
{
provider = "credentials",
UserName = "******",
Password = "******",
});
var response = await client.GetAsync(new HelloAuth { Name = "Secure " + txtName.Text });
lblResults.Text = response.Result;
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
btnShared.Click += async delegate
{
try
{
var greeting = await gateway.SayHello(txtName.Text);
lblResults.Text = greeting;
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
}
public async Task<Deployment> CreateAsync(CreateDeploymentRequest request)
{
return (await client.PostAsync(request)).Deployment;
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
//AndroidPclExportClient.Configure();
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
var btnSync = FindViewById<Button>(Resource.Id.btnSync);
var btnAsync = FindViewById<Button>(Resource.Id.btnAsync);
var btnAwait = FindViewById<Button>(Resource.Id.btnAwait);
var btnAuth = FindViewById<Button>(Resource.Id.btnAuth);
var btnShared = FindViewById<Button>(Resource.Id.btnShared);
var txtName = FindViewById<EditText>(Resource.Id.txtName);
var lblResults = FindViewById<TextView>(Resource.Id.lblResults);
//10.0.2.2 = loopback
//http://developer.android.com/tools/devices/emulator.html
var client = new JsonServiceClient("http://10.0.2.2:2000/");
var gateway = new SharedGateway("http://10.0.2.2:2000/");
btnSync.Click += delegate
{
try
{
var response = client.Get(new Hello { Name = txtName.Text });
lblResults.Text = response.Result;
using (var ms = new MemoryStream("Contents".ToUtf8Bytes()))
{
ms.Position = 0;
var fileResponse = client.PostFileWithRequest<HelloResponse>(
"/hello", ms, "filename.txt", new Hello { Name = txtName.Text });
lblResults.Text = fileResponse.Result;
}
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
btnAsync.Click += delegate
{
client.GetAsync(new Hello { Name = txtName.Text })
.Success(response => lblResults.Text = response.Result)
.Error(ex => lblResults.Text = ex.ToString());
};
btnAwait.Click += async delegate
{
try
{
var response = await client.GetAsync(new Hello { Name = txtName.Text });
lblResults.Text = response.Result;
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
btnAuth.Click += async delegate
{
try
{
await client.PostAsync(new Authenticate
{
provider = "credentials",
UserName = "******",
Password = "******",
});
var response = await client.GetAsync(new HelloAuth { Name = "Secure " + txtName.Text });
lblResults.Text = response.Result;
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
btnShared.Click += async delegate
{
try
{
var greeting = await gateway.SayHello(txtName.Text);
lblResults.Text = greeting;
}
catch (Exception ex)
{
lblResults.Text = ex.ToString();
}
};
}
