public virtual async Task <ApiResult> PostSendEmailLoginAsync(TwoFactorEmailRequest requestObj)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected());
}
using (var client = HttpService.ApiClient)
{
var requestMessage = new TokenHttpRequestMessage(requestObj)
{
Method = HttpMethod.Post,
RequestUri = new Uri(client.BaseAddress, string.Concat(ApiRoute, "/send-email-login")),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync(response).ConfigureAwait(false));
}
return(ApiResult.Success(response.StatusCode));
}
catch
{
return(HandledWebException());
}
}
}
public virtual async Task <ApiResult <TResponse> > PostAsync(TRequest requestObj)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected <TResponse>());
}
using (var client = new ApiHttpClient())
{
var requestMessage = new TokenHttpRequestMessage(requestObj)
{
Method = HttpMethod.Post,
RequestUri = new Uri(client.BaseAddress, ApiRoute),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync <TResponse>(response).ConfigureAwait(false));
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var responseObj = JsonConvert.DeserializeObject <TResponse>(responseContent);
return(ApiResult <TResponse> .Success(responseObj, response.StatusCode));
}
catch (WebException)
{
return(HandledWebException <TResponse>());
}
}
}
public async Task AddUserRegistrationOrganizationAsync(IEnumerable <string> deviceIds, string organizationId)
{
if (!deviceIds.Any())
{
return;
}
var tokenStateResponse = await HandleTokenStateAsync();
if (!tokenStateResponse)
{
return;
}
var requestModel = new PushUpdateRequestModel(deviceIds, organizationId);
var message = new TokenHttpRequestMessage(requestModel, AccessToken)
{
Method = HttpMethod.Put,
RequestUri = new Uri(string.Concat(PushClient.BaseAddress, "/push/add-organization"))
};
try
{
await PushClient.SendAsync(message);
}
catch (Exception e)
{
_logger.LogError(12337, e, "Unable to add user org push registration.");
}
}
public async Task CreateOrUpdateRegistrationAsync(string pushToken, string deviceId, string userId,
string identifier, DeviceType type)
{
var tokenStateResponse = await HandleTokenStateAsync();
if (!tokenStateResponse)
{
return;
}
var requestModel = new PushRegistrationRequestModel
{
DeviceId = deviceId,
Identifier = identifier,
PushToken = pushToken,
Type = type,
UserId = userId
};
var message = new TokenHttpRequestMessage(requestModel, AccessToken)
{
Method = HttpMethod.Post,
RequestUri = new Uri(string.Concat(PushClient.BaseAddress, "/push/register"))
};
try
{
await PushClient.SendAsync(message);
}
catch (Exception e)
{
_logger.LogError(12335, e, "Unable to create push registration.");
}
}
public virtual async Task <ApiResult> DeleteAsync(TId id)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected());
}
using (var client = HttpService.Client)
{
var requestMessage = new TokenHttpRequestMessage()
{
Method = HttpMethod.Delete,
RequestUri = new Uri(client.BaseAddress, string.Concat(ApiRoute, "/", id)),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync(response).ConfigureAwait(false));
}
return(ApiResult.Success(response.StatusCode));
}
catch (WebException)
{
return(HandledWebException());
}
}
}
public virtual async Task <ApiResult> PutClearTokenAsync(string identifier)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected());
}
using (var client = new ApiHttpClient())
{
var requestMessage = new TokenHttpRequestMessage
{
Method = HttpMethod.Put,
RequestUri = new Uri(client.BaseAddress,
string.Concat(ApiRoute, "/identifier/", identifier, "/clear-token"))
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync(response).ConfigureAwait(false));
}
return(ApiResult.Success(response.StatusCode));
}
catch (WebException)
{
return(HandledWebException());
}
}
}
public virtual async Task <ApiResult <ListResponse <FolderResponse> > > GetByRevisionDateAsync(DateTime since)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected <ListResponse <FolderResponse> >());
}
using (var client = HttpService.Client)
{
var requestMessage = new TokenHttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(client.BaseAddress, string.Concat(ApiRoute, "?since=", since)),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync <ListResponse <FolderResponse> >(response).ConfigureAwait(false));
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var responseObj = JsonConvert.DeserializeObject <ListResponse <FolderResponse> >(responseContent);
return(ApiResult <ListResponse <FolderResponse> > .Success(responseObj, response.StatusCode));
}
catch (WebException)
{
return(HandledWebException <ListResponse <FolderResponse> >());
}
}
}
public virtual async Task <ApiResult> PostPasswordHintAsync(PasswordHintRequest requestObj)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected());
}
using (var client = new ApiHttpClient())
{
var requestMessage = new TokenHttpRequestMessage(requestObj)
{
Method = HttpMethod.Post,
RequestUri = new Uri(client.BaseAddress, string.Concat(ApiRoute, "/password-hint")),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync(response).ConfigureAwait(false));
}
return(ApiResult.Success(response.StatusCode));
}
catch (WebException)
{
return(HandledWebException());
}
}
}
public virtual async Task <ApiResult <DateTime?> > GetAccountRevisionDateAsync()
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected <DateTime?>());
}
var tokenStateResponse = await HandleTokenStateAsync <DateTime?>();
if (!tokenStateResponse.Succeeded)
{
return(tokenStateResponse);
}
using (var client = HttpService.ApiClient)
{
var requestMessage = new TokenHttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(string.Concat(client.BaseAddress, ApiRoute, "/revision-date")),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync <DateTime?>(response).ConfigureAwait(false));
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (responseContent.Contains("null"))
{
return(ApiResult <DateTime?> .Success(null, response.StatusCode));
}
long ms;
if (!long.TryParse(responseContent, out ms))
{
return(await HandleErrorAsync <DateTime?>(response).ConfigureAwait(false));
}
return(ApiResult <DateTime?> .Success(Helpers.Epoc.AddMilliseconds(ms), response.StatusCode));
}
catch
{
return(HandledWebException <DateTime?>());
}
}
}
public virtual async Task <ApiResult <CipherResponse> > PostAttachmentAsync(string cipherId, byte[] data,
string key, string fileName)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected <CipherResponse>());
}
var tokenStateResponse = await HandleTokenStateAsync <CipherResponse>();
if (!tokenStateResponse.Succeeded)
{
return(tokenStateResponse);
}
using (var client = HttpService.ApiClient)
using (var content = new MultipartFormDataContent("--BWMobileFormBoundary" + DateTime.UtcNow.Ticks))
{
content.Add(new StringContent(key), "key");
content.Add(new StreamContent(new MemoryStream(data)), "data", fileName);
var requestMessage = new TokenHttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri(string.Concat(client.BaseAddress, ApiRoute, "/", cipherId, "/attachment")),
Content = content
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync <CipherResponse>(response).ConfigureAwait(false));
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var responseObj = JsonConvert.DeserializeObject <CipherResponse>(responseContent);
return(ApiResult <CipherResponse> .Success(responseObj, response.StatusCode));
}
catch
{
return(HandledWebException <CipherResponse>());
}
}
}
public virtual async Task <ApiResult <ListResponse <CipherResponse> > > GetAsync()
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected <ListResponse <CipherResponse> >());
}
var tokenStateResponse = await HandleTokenStateAsync <ListResponse <CipherResponse> >();
if (!tokenStateResponse.Succeeded)
{
return(tokenStateResponse);
}
using (var client = HttpService.Client)
{
var requestMessage = new TokenHttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(client.BaseAddress,
string.Format("{0}?includeFolders=false&includeShared=true", ApiRoute)),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync <ListResponse <CipherResponse> >(response).ConfigureAwait(false));
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var responseObj = JsonConvert.DeserializeObject <ListResponse <CipherResponse> >(responseContent);
return(ApiResult <ListResponse <CipherResponse> > .Success(responseObj, response.StatusCode));
}
catch
{
return(HandledWebException <ListResponse <CipherResponse> >());
}
}
}
public virtual async Task <ApiResult <DomainsResponse> > GetDomains(bool excluded = false)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected <DomainsResponse>());
}
var tokenStateResponse = await HandleTokenStateAsync <DomainsResponse>();
if (!tokenStateResponse.Succeeded)
{
return(tokenStateResponse);
}
using (var client = HttpService.Client)
{
var requestMessage = new TokenHttpRequestMessage()
{
Method = HttpMethod.Get,
RequestUri = new Uri(client.BaseAddress,
string.Concat(ApiRoute, "/domains?excluded=", excluded.ToString().ToLowerInvariant())),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync <DomainsResponse>(response).ConfigureAwait(false));
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var responseObj = JsonConvert.DeserializeObject <DomainsResponse>(responseContent);
return(ApiResult <DomainsResponse> .Success(responseObj, response.StatusCode));
}
catch
{
return(HandledWebException <DomainsResponse>());
}
}
}
public virtual async Task <ApiResult <TResponse> > PutAsync(TId id, TRequest requestObj)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected <TResponse>());
}
var tokenStateResponse = await HandleTokenStateAsync <TResponse>();
if (!tokenStateResponse.Succeeded)
{
return(tokenStateResponse);
}
using (var client = HttpService.ApiClient)
{
var requestMessage = new TokenHttpRequestMessage(requestObj)
{
Method = HttpMethod.Put,
RequestUri = new Uri(client.BaseAddress, string.Concat(ApiRoute, "/", id)),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync <TResponse>(response).ConfigureAwait(false));
}
var responseContent = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var responseObj = JsonConvert.DeserializeObject <TResponse>(responseContent);
return(ApiResult <TResponse> .Success(responseObj, response.StatusCode));
}
catch
{
return(HandledWebException <TResponse>());
}
}
}
public virtual async Task <ApiResult> DeleteAttachmentAsync(string cipherId, string attachmentId)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected());
}
var tokenStateResponse = await HandleTokenStateAsync();
if (!tokenStateResponse.Succeeded)
{
return(tokenStateResponse);
}
using (var client = HttpService.ApiClient)
{
var requestMessage = new TokenHttpRequestMessage()
{
Method = HttpMethod.Delete,
RequestUri = new Uri(
string.Concat(client.BaseAddress, ApiRoute, "/", cipherId, "/attachment/", attachmentId)),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync(response).ConfigureAwait(false));
}
return(ApiResult.Success(response.StatusCode));
}
catch
{
return(HandledWebException());
}
}
}
public virtual async Task <ApiResult> PutTokenAsync(string identifier, DeviceTokenRequest request)
{
if (!Connectivity.IsConnected)
{
return(HandledNotConnected());
}
var tokenStateResponse = await HandleTokenStateAsync();
if (!tokenStateResponse.Succeeded)
{
return(tokenStateResponse);
}
using (var client = HttpService.ApiClient)
{
var requestMessage = new TokenHttpRequestMessage(request)
{
Method = HttpMethod.Put,
RequestUri = new Uri(client.BaseAddress, string.Concat(ApiRoute, "/identifier/", identifier, "/token")),
};
try
{
var response = await client.SendAsync(requestMessage).ConfigureAwait(false);
if (!response.IsSuccessStatusCode)
{
return(await HandleErrorAsync(response).ConfigureAwait(false));
}
return(ApiResult.Success(response.StatusCode));
}
catch
{
return(HandledWebException());
}
}
}
protected async Task SendAsync(HttpMethod method, string path, object requestModel = null)
{
var tokenStateResponse = await HandleTokenStateAsync();
if (!tokenStateResponse)
{
return;
}
var message = new TokenHttpRequestMessage(requestModel, AccessToken)
{
Method = method,
RequestUri = new Uri(string.Concat(Client.BaseAddress, path))
};
try
{
var response = await Client.SendAsync(message);
}
catch (Exception e)
{
_logger.LogError(12334, e, "Failed to send to {0}.", message.RequestUri.ToString());
}
}
private async Task SendAsync(PushSendRequestModel requestModel)
{
var tokenStateResponse = await HandleTokenStateAsync();
if (!tokenStateResponse)
{
return;
}
var message = new TokenHttpRequestMessage(requestModel, AccessToken)
{
Method = HttpMethod.Post,
RequestUri = new Uri(string.Concat(PushClient.BaseAddress, "/push/send"))
};
try
{
await PushClient.SendAsync(message);
}
catch (Exception e)
{
_logger.LogError(12334, e, "Unable to send push notification.");
}
}
public async Task DeleteRegistrationAsync(string deviceId)
{
var tokenStateResponse = await HandleTokenStateAsync();
if (!tokenStateResponse)
{
return;
}
var message = new TokenHttpRequestMessage(AccessToken)
{
Method = HttpMethod.Delete,
RequestUri = new Uri(string.Concat(PushClient.BaseAddress, "/push/", deviceId))
};
try
{
await PushClient.SendAsync(message);
}
catch (Exception e)
{
_logger.LogError(12336, e, "Unable to delete push registration.");
}
}
