static void Main(string[] args)
{
//Создаём объект класса Response для того, чтобы записать туда ответ.
Response <AccountModel> response = new Response <AccountModel>();
//Создаём объект класса HttpClient.
HttpClient client = CreateClient();
//Создаём объект класса RequestExample для того, чтобы через него вызывать методы, которые выполняют запросы
RequestExample request = new RequestExample();
//Создаём список частей операций.
List <OperationItemRequest> items = new List <OperationItemRequest>();
//Заполняем список частей операции
items.Add(new OperationItemRequest {
CalculationDate = "2020-02-25", ContrAgentId = null, Value = 123, IsCalculationCommitted = false, OperationCategoryId = null, ProjectId = null
});
//Создаём объект класса AccountCreationRequest и заполняем его данными для добавления счёта.
AccountCreationRequest dataForPost = new AccountCreationRequest {
Title = "test", AccountBank = null, AccountBik = null, AccountType = "Cash", AccountAcct = null, Active = true, CompanyId = 41104, CurrencyCode = "USD", Description = null, LongTitle = "", Remainder = 0, RemainderDate = "2020-03-02"
};
//Создаём объект класса OperationModificationRequest и заполняем его данными для изменнения операции.
OperationModificationRequest dataForPut = new OperationModificationRequest {
AccountId = 106080, Comment = "", IsCommitted = false, OperationDate = "2020-02-25", Items = items
};
//Создаём переменую для хранения api-ключа.
string apiKey = "Ваш api-ключ";
//Вызываем метод Delete для удаления операции и передаём ему в виде параметров api-ключ, id операции и объект класса HttpClient.
request.Delete(apiKey, 16367698, client);
//Вызываем метод Get для получения списка счетов и передаём ему в виде параметров api-ключ и объект класса HttpClient.
request.Get(apiKey, client);
//Выводим в консоль результат метода Post для добавления счёта. В параметрах этого метода передаём api-ключ, данные счёта, который мы хотим добавить, объект класса HttpClient.
Console.WriteLine(request.Post(apiKey, dataForPost, client).GetAwaiter().GetResult());
//Выводим в консоль результат метода Put для изменения операции. В параметрах этого метода передаём api-ключ, id операции, изменённые данные операции, объект класса HttpClient.
Console.WriteLine(request.Put(apiKey, 16367698, dataForPut, client).GetAwaiter().GetResult());
}
public BaseResponse <AccountResponse> RegisterAccount([FromBody] AccountCreationRequest request, [FromHeader] Guid SessionID)
{
return(BaseResponse <AccountResponse> .ConstructResponse(
HttpStatusCode.OK,
HttpStatusCode.OK.ToString(),
accountService.RegisterAccount(request, SessionID)));
}
public void TestCreateNewAzureMediaServiceAsync()
{
var fakeHttpHandler = new FakeHttpMessageHandler();
string responseText = "{\"AccountId\":\"abe5afa0-704b-4d07-b5d8-5b0b039474e7\",\"AccountName\":\"tmp\",\"StatusCode\":201,\"Subscription\":\"f7190519-c29e-47f2-9019-c5a94c8e75f9\"}";
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new FakeHttpContent(responseText)
};
fakeHttpHandler.Send = request => response;
var fakeHttpClient = fakeHttpHandler.CreateIMediaServicesHttpClient();
var target = new MediaServicesClient(
new SubscriptionData {
SubscriptionId = _subscriptionId
},
null,
fakeHttpClient,
fakeHttpClient);
var creationRequest = new AccountCreationRequest {
AccountName = _accountName
};
var result = target.CreateNewAzureMediaServiceAsync(creationRequest).Result;
Assert.AreEqual("tmp", result.Name);
}
bool AccountRequestExpired(AccountCreationRequest req)
{
var date = DateTimeOffset.Now.ToUnixTimeSeconds();
var expiry = req.Date + _apiSettings.CreationExpiryMinutes * 60;
return(date > expiry);
}
public async Task <IActionResult> Create([FromQuery] AccountCreationRequest request)
{
var(succeeded, errorMessage) = await mediator.Send(request);
if (succeeded)
{
return(Ok());
}
return(BadRequest(new BadRequestResponse(errorMessage)));
}
/// <summary>
/// Creates a new account using the specified username, provider token, password, and email
/// </summary>
/// <param name="username"></param>
/// <param name="tokenType"></param>
/// <param name="token"></param>
/// <param name="password"></param>
/// <param name="email"></param>
/// <param name="loginWhenComplete"></param>
/// <param name="options">The options for this request</param>
/// <returns></returns>
public async Task CreateAccountAsync(string username, AccountTokenType tokenType, string token, string password = null, string email = null, bool loginWhenComplete = true, RequestOptions options = null)
{
AccountCreationRequest request = new AccountCreationRequest()
{
Username = username,
Password = password,
Email = email,
};
switch (tokenType)
{
case AccountTokenType.FacebookAuthCode:
request.Provider = FacebookProvider;
request.AuthCode = token;
break;
case AccountTokenType.FacebookAccessToken:
request.Provider = FacebookProvider;
request.AccessToken = token;
break;
case AccountTokenType.TwitterToken:
request.Provider = TwitterProvider;
request.Token = token;
break;
case AccountTokenType.TwitterVerifier:
request.Provider = TwitterProvider;
request.Verifier = token;
break;
case AccountTokenType.TwitterOauthToken:
request.Provider = TwitterProvider;
request.OauthToken = token;
break;
case AccountTokenType.TwitterOauthTokenSecret:
request.Provider = TwitterProvider;
request.OauthTokenSecret = token;
break;
}
ClientAccountAuthResponse response = await ApiClient.CreateAccountAsync(request, options).ConfigureAwait(false);
if (loginWhenComplete)
{
AccessToken = response.AccessToken;
RefreshToken = response.RefreshToken;
}
}
public async Task <ApiResult> Create(
[FromBody, BindRequired] AccountCreationRequest request)
{
try
{
// Attempt to create the account through the AccountService
// implementation we were provided
Account account = await _accountService.CreateAsync(request);
return(Success(AccountCreationData.FromAccount(
account,
// TODO: Email verification
emailVerificationRequired: false,
verificationEmailSent: false
)));
}
catch (AccountCreationException e)
{
var errors = new List <ApiError>();
if ((e.ErrorFlags & AccountCreationErrorFlags.InvalidAccount) != 0)
{
errors.Add(new ApiError(
"Unable to create valid Account with supplied data.",
ApiErrorCode.AccountCreationFailed
));
}
if ((e.ErrorFlags & AccountCreationErrorFlags.UsernameTaken) != 0)
{
errors.Add(new ApiError(
"An account has already been created under that username.",
ApiErrorCode.AccountUsernameInUse
));
}
if ((e.ErrorFlags & AccountCreationErrorFlags.EmailInUse) != 0)
{
errors.Add(new ApiError(
"An account has already been created under that email address.",
ApiErrorCode.AccountEmailInUse
));
}
return(Error(
StatusCodes.Status422UnprocessableEntity,
errors
));
}
}
/// <summary>
/// POST-запрос для добавления счёта
/// </summary>
/// <param name="apiKey">Ваш api-ключ</param>
/// <param name="data">Данные счёта для добавления (данные хранятся в объекте класса AccountCreationReques)</param>
/// <param name="client">Объект класса HttpClient</param>
/// <returns>Возвращает строку с ответом</returns>
public async Task <string> Post(string apiKey, AccountCreationRequest data, HttpClient client)
{
client.DefaultRequestHeaders.Add("X-ApiKey", apiKey);
var request = new HttpRequestMessage(HttpMethod.Post, "https://api.planfact.io/api/v1/accounts");
var json = JsonConvert.SerializeObject(data);
var stringContent = new StringContent(json, Encoding.UTF8, "application/json");
request.Content = stringContent;
var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
response.EnsureSuccessStatusCode();
var responseBody = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var result = JsonConvert.DeserializeObject <Response <AccountModel> >(responseBody);
return(await response.Content.ReadAsStringAsync());
}
public void TestCreateNewAzureMediaServiceAsyncInvalidAccount()
{
var fakeHttpHandler = new FakeHttpMessageHandler();
string responseText = "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">{\"Code\":\"BadRequest\",\"Message\":\"Account Creation Request contains an invalid account name.\"}</string>";
var response = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new FakeHttpContent(responseText)
};
fakeHttpHandler.Send = request => response;
var fakeHttpClient = fakeHttpHandler.CreateIMediaServicesHttpClient();
var target = new MediaServicesClient(
new SubscriptionData {
SubscriptionId = _subscriptionId
},
null,
fakeHttpClient,
fakeHttpClient);
var creationRequest = new AccountCreationRequest {
AccountName = _accountName
};
try
{
var result = target.CreateNewAzureMediaServiceAsync(creationRequest).Result;
}
catch (AggregateException ax)
{
ServiceManagementClientException x = (ServiceManagementClientException)ax.InnerExceptions.Single();
Assert.AreEqual(HttpStatusCode.BadRequest, x.HttpStatus);
return;
}
Assert.Fail("ServiceManagementClientException expected");
}
public IActionResult CreateAccount([FromBody] AccountCreationRequest account)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Account domainModel = account.ToDomain();
domainModel = _accountService.Add(domainModel);
return(Ok(new AccountCreationResponse(domainModel)));
}
catch (InvalidParametersException)
{
return(BadRequest("Account properties are not setted corretly."));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <Account> CreateAsync(
AccountCreationRequest request)
{
var errorFlags = AccountCreationErrorFlags.None;
// Attempt to create an Account instance from the request data
if (!Account.TryCreateFromRequest(request, _passwordHasher, out var account))
{
errorFlags |= AccountCreationErrorFlags.InvalidAccount;
}
// Make sure that an account does not exist with the same username
if (await IsUsernameTaken(account.Username))
{
errorFlags |= AccountCreationErrorFlags.UsernameTaken;
}
// Make sure that an account does not exist with the same email
if (await IsEmailInUse(account.Email))
{
errorFlags |= AccountCreationErrorFlags.EmailInUse;
}
// If there was a confliction, do not attempt to insert into the database
if (errorFlags != AccountCreationErrorFlags.None)
{
throw new AccountCreationException(
"An error occurred while creating the account.",
errorFlags
);
}
// Attempt to add the new account to the database
_accountContext.Add(account);
await _accountContext.SaveChangesAsync();
return(account);
}
public override void ExecuteCmdlet()
{
MediaServicesClient = MediaServicesClient ?? new MediaServicesClient(CurrentSubscription, WriteDebug);
StorageService storage = null;
Uri storageEndPoint = null;
string storageAccountKey = null;
CatchAggregatedExceptionFlattenAndRethrow(() => { storage = MediaServicesClient.GetStorageServiceKeys(StorageAccountName).Result; });
storageAccountKey = storage.StorageServiceKeys.Primary;
CatchAggregatedExceptionFlattenAndRethrow(() => { storage = MediaServicesClient.GetStorageServiceProperties(StorageAccountName).Result; });
if (storage.StorageServiceProperties != null && storage.StorageServiceProperties.Endpoints.Count > 0)
{
storageEndPoint = new Uri(storage.StorageServiceProperties.Endpoints[0]);
}
else
{
throw new Exception(string.Format(Utilities.Properties.Resources.EndPointNotFoundForBlobStorage, Name));
}
AccountCreationResult result = null;
var request = new AccountCreationRequest
{
AccountName = Name,
BlobStorageEndpointUri = storageEndPoint.ToString(),
Region = Location,
StorageAccountKey = storageAccountKey,
StorageAccountName = StorageAccountName
};
CatchAggregatedExceptionFlattenAndRethrow(() => { result = MediaServicesClient.CreateNewAzureMediaServiceAsync(request).Result; });
WriteObject(result, false);
}
public AccountResponse RegisterAccount(AccountCreationRequest request, Guid SessionID)
{
Sessions session = dbContext.Sessions
.Where(s => s.SessionId.Equals(SessionID) && s.LastActivity < DateTime.Now.AddDays(1))
.FirstOrDefault();
if (session == null)
{
throw new BusinessLogicException(HttpStatusCode.BadRequest, ResponseCode.INVALID_SESSION.ToString());
}
Users checkUser = dbContext.Users
.Where(u => u.Email.Equals(request.Email))
.FirstOrDefault();
if (checkUser != null)
{
throw new BusinessLogicException(HttpStatusCode.BadRequest, ResponseCode.USER_ALREADY_REGISTERED.ToString());
}
Genders gender = dbContext.Genders.Find(request.Gender);
if (gender == null)
{
throw new BusinessLogicException(HttpStatusCode.BadRequest, ResponseCode.NOT_VALID_GENDER.ToString());
}
Users newUser = new Users();
newUser.UserId = Guid.NewGuid();
newUser.FirstName = request.FirstName;
newUser.LastName = request.LastName;
newUser.Email = request.Email;
newUser.PasswordHash = PasswordHelper.ConvertToSHA512(request.Password);
newUser.GenderId = request.Gender;
newUser.Age = request.Age;
newUser.CreatedDate = DateTime.Now;
newUser.CreatedBy = request.Email;
newUser.UpdatedDate = DateTime.Now;
newUser.UpdatedBy = request.Email;
Roles role = dbContext.Roles.Where(r => r.Name.Equals("Client")).FirstOrDefault();
UserRoles userRoles = new UserRoles();
userRoles.UserId = newUser.UserId;
userRoles.RoleId = role.RoleId;
using (IDbContextTransaction transaction = dbContext.Database.BeginTransaction())
{
try
{
dbContext.Users.Add(newUser);
dbContext.UserRoles.Add(userRoles);
dbContext.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
throw new BusinessLogicException(HttpStatusCode.InternalServerError, ResponseCode.FAILED_TO_REGISTER_ACCOUNT.ToString());
}
}
var task = kafkaProducer.SendToKafka(JsonConvert.SerializeObject(ConstructKafkaRequest(newUser, gender, "CREATE")));
return(ConstructResponse(newUser, gender));
}
/// <summary>
/// Create new azure media service async.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public Task <AccountCreationResult> CreateNewAzureMediaServiceAsync(AccountCreationRequest request)
{
return(_httpClient.PostAsJsonAsyncWithoutEnsureSuccessStatusCode(MediaServicesUriElements.Accounts, JObject.FromObject(request), Logger).ContinueWith(tr => ProcessJsonResponse <AccountCreationResult>(tr)));
}
public void NewMediaServiceAccountShouldPassWithValidParameters()
{
// Setup
var clientMock = new Mock <IMediaServicesClient>();
const string storageAccountName = "teststorage";
const string storageAccountKey = "key";
const string accountName = "testaccount";
const string region = "West US";
const string blobStorageEndpointUri = "http://awesome.blob.core.windows.net/";
AccountCreationRequest request = new AccountCreationRequest()
{
AccountName = accountName,
BlobStorageEndpointUri = blobStorageEndpointUri,
Region = region,
StorageAccountKey = storageAccountKey,
StorageAccountName = storageAccountName
};
clientMock.Setup(f => f.CreateNewAzureMediaServiceAsync(It.Is <AccountCreationRequest>(creationRequest => request.AccountName == accountName))).Returns(Task.Factory.StartNew(() =>
{
return(new AccountCreationResult()
{
AccountId = Guid.NewGuid().ToString(),
Name = request.AccountName,
Subscription = Guid.NewGuid().ToString()
});
}));
clientMock.Setup(f => f.GetStorageServiceKeys(storageAccountName)).Returns(Task.Factory.StartNew(() =>
{
return(new StorageService()
{
StorageServiceKeys = new StorageServiceKeys()
{
Primary = storageAccountKey,
Secondary = storageAccountKey
}
});
}));
clientMock.Setup(f => f.GetStorageServiceProperties(storageAccountName)).Returns(Task.Factory.StartNew(() =>
{
return(new StorageService()
{
StorageServiceProperties = new StorageServiceProperties()
{
Endpoints = new EndpointList()
{
blobStorageEndpointUri
}
}
});
}));
// Test
var command = new NewAzureMediaServiceCommand()
{
CommandRuntime = new MockCommandRuntime(),
Name = accountName,
Location = region,
StorageAccountName = storageAccountName,
MediaServicesClient = clientMock.Object,
};
command.ExecuteCmdlet();
Assert.AreEqual(1, ((MockCommandRuntime)command.CommandRuntime).OutputPipeline.Count);
var accountCreationResult = (AccountCreationResult)((MockCommandRuntime)command.CommandRuntime).OutputPipeline.FirstOrDefault();
Assert.IsNotNull(accountCreationResult);
Assert.AreEqual(accountName, accountCreationResult.Name);
}
