public ConfirmPage(WizardData wizardData)
{
InitializeComponent();
AccountResource account = wizardData.Account;
try
{
IJKEService channel = ServiceManager.GetChannel();
string today = DateTime.Now.ToShortDateString();
TransactionResource previewTansaction = channel.GetTransactionPreview(account.AccountNumber,
wizardData.Organization.Name, today, wizardData.Percentage);
wizardData.PreviewTransaction = previewTansaction;
AccountResource previewAccount = new AccountResource();
previewAccount.Balance = previewTansaction.PostBalance;
previewAccount.Dividends = account.Dividends;
previewAccount.DividendsETD = account.DividendsETD;
previewAccount.Contributions = account.Contributions + previewTansaction.Amount;
previewAccount.ContributionsETD = account.ContributionsETD + previewTansaction.Amount;
wizardData.PreviewAccount = previewAccount;
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
// Bind wizard state to UI
this.DataContext = wizardData;
}
public void BatchAccountContextFromResourceTest()
{
string account = "account";
string tenantUrlEnding = "batch-test.windows-int.net";
string endpoint = string.Format("{0}.{1}", account, tenantUrlEnding);
string subscription = "00000000-0000-0000-0000-000000000000";
string resourceGroup = "resourceGroup";
string id = string.Format("id/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Batch/batchAccounts/abc", subscription, resourceGroup);
AccountResource resource = new AccountResource(
coreQuota: BatchTestHelpers.DefaultQuotaCount,
poolQuota: BatchTestHelpers.DefaultQuotaCount,
activeJobAndJobScheduleQuota: BatchTestHelpers.DefaultQuotaCount,
id: id,
type: "type")
{
Location = "location",
AccountEndpoint = endpoint,
ProvisioningState = AccountProvisioningState.Succeeded,
};
BatchAccountContext context = BatchAccountContext.ConvertAccountResourceToNewAccountContext(resource);
Assert.Equal <string>(context.Id, resource.Id);
Assert.Equal <string>(context.AccountEndpoint, resource.AccountEndpoint);
Assert.Equal <string>(context.Location, resource.Location);
Assert.Equal <string>(context.State, resource.ProvisioningState.ToString());
Assert.Equal <string>(context.AccountName, account);
Assert.Equal <string>(context.TaskTenantUrl, string.Format("https://{0}", endpoint));
Assert.Equal <string>(context.Subscription, subscription);
Assert.Equal <string>(context.ResourceGroupName, resourceGroup);
}
public void BatchAccountContextFromResourceTest()
{
string account = "account";
string tenantUrlEnding = "batch-test.windows-int.net";
string endpoint = string.Format("{0}.{1}", account, tenantUrlEnding);
string subscription = "00000000-0000-0000-0000-000000000000";
string resourceGroup = "resourceGroup";
AccountResource resource = new AccountResource()
{
Id = string.Format("id/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Batch/batchAccounts/abc", subscription, resourceGroup),
Location = "location",
Properties = new AccountProperties()
{
AccountEndpoint = endpoint, ProvisioningState = AccountProvisioningState.Succeeded
},
Type = "type"
};
BatchAccountContext context = BatchAccountContext.ConvertAccountResourceToNewAccountContext(resource);
Assert.Equal <string>(context.Id, resource.Id);
Assert.Equal <string>(context.AccountEndpoint, resource.Properties.AccountEndpoint);
Assert.Equal <string>(context.Location, resource.Location);
Assert.Equal <string>(context.State, resource.Properties.ProvisioningState.ToString());
Assert.Equal <string>(context.AccountName, account);
Assert.Equal <string>(context.TaskTenantUrl, string.Format("https://{0}", endpoint));
Assert.Equal <string>(context.Subscription, subscription);
Assert.Equal <string>(context.ResourceGroupName, resourceGroup);
}
/// <summary>
/// Create a new BAC and fill it in
/// </summary>
/// <param name="resource">Resource info returned by RP</param>
/// <returns>new instance of BatchAccountContext</returns>
internal static BatchAccountContext CrackAccountResourceToNewAccountContext(AccountResource resource)
{
var baContext = new BatchAccountContext();
baContext.CrackAccountResourceToAccountContext(resource);
return(baContext);
}
public void ListBatchAccountsTest()
{
List <BatchAccountContext> pipelineOutput = new List <BatchAccountContext>();
string accountName01 = "account01";
string resourceGroup = "resourceGroup";
AccountResource accountResource01 = BatchTestHelpers.CreateAccountResource(accountName01, resourceGroup);
string accountName02 = "account02";
AccountResource accountResource02 = BatchTestHelpers.CreateAccountResource(accountName02, resourceGroup);
BatchAccountContext expected01 = BatchAccountContext.ConvertAccountResourceToNewAccountContext(accountResource01);
BatchAccountContext expected02 = BatchAccountContext.ConvertAccountResourceToNewAccountContext(accountResource02);
batchClientMock.Setup(b => b.ListAccounts(resourceGroup, null)).Returns(new List <BatchAccountContext>()
{
expected01, expected02
});
cmdlet.AccountName = null;
cmdlet.ResourceGroupName = resourceGroup;
cmdlet.Tag = null;
cmdlet.ExecuteCmdlet();
commandRuntimeMock.Verify(r => r.WriteObject(expected01), Times.Once());
commandRuntimeMock.Verify(r => r.WriteObject(expected02), Times.Once());
}
public void GetTransactionsForAccountTest()
{
using (JKEFactory factory = ServiceManager.CreateFactory())
{
IJKEService target = factory.CreateChannel();
string userId = "jbrown";
AccountResource[] accounts = target.GetUserAccounts(userId);
Assert.IsNotNull(accounts);
Assert.IsTrue(accounts.Length > 0);
AccountResource account = accounts[0];
TransactionResource[] transactions = target.GetTransactionsForAccount(userId, account.Type);
Assert.IsNotNull(transactions);
if (transactions.Length > 0)
{
foreach (TransactionResource transaction in transactions)
{
Assert.AreEqual(account.AccountNumber, transaction.AccountNumber);
}
TransactionResource lastTransaction = transactions[transactions.Length - 1];
Assert.AreEqual(account.Balance, lastTransaction.PostBalance);
}
}
}
public void UpdateAccountTest()
{
string accountName = "account01";
string resourceGroup = "resourceGroup";
Hashtable[] tags = new[]
{
new Hashtable
{
{ "Name", "tagName" },
{ "Value", "tagValue" }
}
};
AccountResource accountResource = BatchTestHelpers.CreateAccountResource(accountName, resourceGroup, tags);
BatchAccountContext expected = BatchAccountContext.ConvertAccountResourceToNewAccountContext(accountResource);
batchClientMock.Setup(b => b.UpdateAccount(resourceGroup, accountName, tags)).Returns(expected);
cmdlet.AccountName = accountName;
cmdlet.ResourceGroupName = resourceGroup;
cmdlet.Tag = tags;
cmdlet.ExecuteCmdlet();
commandRuntimeMock.Verify(r => r.WriteObject(expected), Times.Once());
}
/// <summary>
/// Builds an AccountResource object using the specified parameters
/// </summary>
public static AccountResource CreateAccountResource(string accountName, string resourceGroupName, Hashtable[] tags = null)
{
string tenantUrlEnding = "batch-test.windows-int.net";
string endpoint = string.Format("{0}.{1}", accountName, tenantUrlEnding);
string subscription = Guid.Empty.ToString();
string resourceGroup = resourceGroupName;
AccountResource resource = new AccountResource()
{
Id = string.Format("id/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Batch/batchAccounts/abc", subscription, resourceGroup),
Location = "location",
Properties = new AccountProperties()
{
AccountEndpoint = endpoint, ProvisioningState = AccountProvisioningState.Succeeded
},
Type = "type"
};
if (tags != null)
{
resource.Tags = Microsoft.Azure.Commands.Batch.Helpers.CreateTagDictionary(tags, true);
}
return(resource);
}
public ActionResult Edit(SessionDto session)
{
var accountCreatureCardsInDb = _context.AccountCreatureCards.Where(acc => acc.AccountId == session.AccountId).ToList();
var accountResourcesInDb = _context.AccountResources.Where(ar => ar.AccountId == session.AccountId).ToList();
if (accountCreatureCardsInDb.Count > 0)
{
_context.AccountCreatureCards.RemoveRange(accountCreatureCardsInDb);
}
if (accountResourcesInDb.Count > 0)
{
_context.AccountResources.RemoveRange(accountResourcesInDb);
}
_context.SaveChanges();
session.CreatureCards.ForEach(cc =>
{
var entity = new AccountCreatureCard();
entity.AccountId = session.AccountId;
entity.CreatureCardId = cc.CreatureCardId;
_context.AccountCreatureCards.Add(entity);
});
session.Resources.ForEach(r =>
{
var entity = new AccountResource();
entity.AccountId = session.AccountId;
entity.ResourceId = r.ResourceId;
_context.AccountResources.Add(entity);
});
_context.SaveChanges();
return(Ok());
}
/// <summary>
/// Take an AccountResource and turn it into a BatchAccountContext
/// </summary>
/// <param name="resource">Resource info returned by RP</param>
/// <returns>Void</returns>
internal void CrackAccountResourceToAccountContext(AccountResource resource)
{
var accountEndpoint = resource.Properties.AccountEndpoint;
if (Uri.CheckHostName(accountEndpoint) != UriHostNameType.Dns)
{
throw new ArgumentException(String.Format(Resources.InvalidEndpointType, accountEndpoint), "AccountEndpoint");
}
this.Id = resource.Id;
this.AccountEndpoint = accountEndpoint;
this.Location = resource.Location;
this.State = resource.Properties.ProvisioningState.ToString();
this.Tags = Helpers.TagsDictionaryToArray(resource.Tags);
// extract the host and strip off the account name for the TaskTenantUrl and AccountName
var hostParts = accountEndpoint.Split('.');
this.AccountName = hostParts[0];
this.TaskTenantUrl = Uri.UriSchemeHttps + Uri.SchemeDelimiter + String.Join(".", hostParts, 1, hostParts.Length - 1);
// get remaining fields from Id which looks like:
// /subscriptions/4a06fe24-c197-4353-adc1-058d1a51924e/resourceGroups/clwtest/providers/Microsoft.Batch/batchAccounts/clw
var idParts = resource.Id.Split('/');
this.Subscription = idParts[2];
this.ResourceGroupName = idParts[4];
}
public async Task <IActionResult> CreateAccount([FromBody] AccountResource newUser)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.ToList()));
}
var userIdentity = _mapper.Map <Account>(newUser);
// var result = await _userManager.CreateAsync(userIdentity, newUser.Password);
// if (!result.Succeeded)
// return BadRequest(result.Errors);
// //var role = _roleManager.Roles.Where(r => r.Name == "user");
// await _userManager.AddToRoleAsync(userIdentity, Roles.user.ToString());
// out IEnumerable<string> errors = null;
var createdUser = await _accountService.Create(userIdentity, newUser.Password);
if (createdUser.Item1 == null)
{
foreach (var error in createdUser.Item2)
{
ModelState.AddModelError(error.Key, error.Value);
}
return(BadRequest(this.ModelState));
}
var resultUser = _mapper.Map <AccountResource>(createdUser.Item1);
return(Ok(resultUser));
}
public void Setup()
{
var resource = new AccountResource();
var persistentModel = new AccountEntity();
var context = new PutContext <AccountResource, AccountEntity>(resource, new ValidationState())
{
PersistentModel = persistentModel
};
var eTagProvider = Stub <IETagProvider>();
eTagProvider.Stub(x => x.GetETag(null))
.IgnoreArguments()
.Throw(new Exception("Some Fun Exception"));
StubRepository <AccountEntity> repository = New.StubRepository <AccountEntity>()
.ResourceIsNeverCreatedOrModified;
var step = new PersistEntityModel <PutContext <AccountResource, AccountEntity>, PutResult, AccountResource, AccountEntity>(
repository,
eTagProvider);
step.ExecuteAsync(context, _putResult, CancellationToken.None).WaitSafely();
}
/// <summary>
/// Builds an AccountResource object using the specified parameters
/// </summary>
public static AccountResource CreateAccountResource(string accountName, string resourceGroupName, Hashtable tags = null, string storageId = null)
{
string tenantUrlEnding = "batch-test.windows-int.net";
string endpoint = string.Format("{0}.{1}", accountName, tenantUrlEnding);
string subscription = Guid.Empty.ToString();
string resourceGroup = resourceGroupName;
string id = string.Format("id/subscriptions/{0}/resourceGroups/{1}/providers/Microsoft.Batch/batchAccounts/abc", subscription, resourceGroup);
AccountResource resource = new AccountResource(
coreQuota: DefaultQuotaCount,
poolQuota: DefaultQuotaCount,
activeJobAndJobScheduleQuota: DefaultQuotaCount,
id: id,
type: "type")
{
Location = "location",
AccountEndpoint = endpoint,
ProvisioningState = AccountProvisioningState.Succeeded,
AutoStorage = new AutoStorageProperties()
{
StorageAccountId = storageId
}
};
if (tags != null)
{
resource.Tags = TagsConversionHelper.CreateTagDictionary(tags, true);
}
return(resource);
}
public Client(Credentials credentials, IEnvironment env = null)
{
if (credentials == null)
{
throw new ArgumentNullException(nameof(credentials));
}
environment = env ?? Environments.Production;
requester = new Requester(credentials, environment, null, this.apiVersion);
Account = new AccountResource(requester);
Balance = new BalanceResource(requester);
Charges = new ChargeResource(requester);
Customers = new CustomerResource(requester);
Disputes = new DisputeResource(requester);
Events = new EventResource(requester);
Forex = new ForexResource(requester);
Links = new LinkResource(requester);
Occurrences = new OccurrenceResource(requester);
Sources = new PaymentSourceResource(requester);
Receipts = new ReceiptResource(requester);
Recipients = new RecipientResource(requester);
Refunds = new RefundResource(requester);
Schedules = new ScheduleResource(requester);
Tokens = new TokenResource(requester);
Transactions = new TransactionResource(requester);
Transfers = new TransferResource(requester);
}
public static async Task <AccountResource> CreateAccountAsync(ITwilioRestClient client, string friendlyName)
{
var options = new CreateAccountOptions()
{
FriendlyName = friendlyName
};
return(await AccountResource.CreateAsync(options, client));
}
public static async Task <AccountResource> GetAccountAsync(ITwilioRestClient client, string accountSid)
{
var options = new FetchAccountOptions
{
PathSid = accountSid
};
return(await AccountResource.FetchAsync(options, client));
}
private void AccountsComboBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
AccountResource account = AccountsComboBox.SelectedItem as AccountResource;
if (account != null)
{
Populate(account);
}
}
/// <summary>
/// Builds a BatchAccountContext object with the keys set for testing
/// </summary>
public static BatchAccountContext CreateBatchContextWithKeys()
{
AccountResource resource = CreateAccountResource("account", "resourceGroup");
BatchAccountContext context = BatchAccountContext.ConvertAccountResourceToNewAccountContext(resource);
string dummyKey = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
SetProperty(context, "PrimaryAccountKey", dummyKey);
SetProperty(context, "SecondaryAccountKey", dummyKey);
return(context);
}
public async Task <AccountResource> GetAccountAsync(int id)
{
_logger.LogInformation("Fetching a single account from the database");
AccountResource accountResource = new AccountResource();
var result = await _accountRepository.GetAccountAsync(id);
accountResource = _mapper.Map <AccountResource>(result);
return(accountResource);
}
public static async Task <AccountResource> UpdateAccountAsync(ITwilioRestClient client, string accountSid, string friendlyName, AccountResource.StatusEnum status)
{
var options = new UpdateAccountOptions
{
Status = status,
FriendlyName = friendlyName,
PathSid = accountSid
};
return(await AccountResource.UpdateAsync(options, client));
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var account = AccountResource.Fetch(pathSid: "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
Console.WriteLine(account.FriendlyName);
}
public static async Task <ResourceSet <AccountResource> > GetAccountsAsync(ITwilioRestClient client, string friendlyName = null, AccountResource.StatusEnum status = null, long?limit = null)
{
var options = new ReadAccountOptions
{
FriendlyName = friendlyName,
Status = status,
Limit = limit,
PageSize = null
};
return(await AccountResource.ReadAsync(options, client));
}
static void Main(string[] args)
{
// Find your Account Sid and Auth Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var account = AccountResource.Create("Submarine");
Console.WriteLine(account.Sid);
}
static void Main(string[] args)
{
// Find your Account Sid and Auth Token at twilio.com/console
// To set up environmental variables, see http://twil.io/secure
const string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
const string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
TwilioClient.Init(accountSid, authToken);
var account = AccountResource.Create("Submarine");
Console.WriteLine(account.Sid);
}
private void Hyperlink_Click(object sender, RoutedEventArgs e)
{
Hyperlink hyperlink = sender as Hyperlink;
if (hyperlink != null)
{
AccountResource account = hyperlink.DataContext as AccountResource;
if (account != null && AccountDetails != null)
{
AccountDetails(this, new AccountArgs(account));
}
}
}
static void Main(string[] args)
{
// Find your Account Sid and Auth Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string accountSidToSuspend = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
AccountResource.Update(
pathSid: accountSidToSuspend,
status: AccountResource.StatusEnum.Suspended);
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
// DANGER! This is insecure. See http://twil.io/secure
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var account = AccountResource.Create();
Console.WriteLine(account.Sid);
}
static void Main(string[] args)
{
// Find your Account Sid and Auth Token at twilio.com/console
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string accountSidToActivate = "ACxxxxxxxxxxxxxxxxxxx";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
AccountResource.Update(
sid: accountSidToActivate,
status: AccountResource.StatusEnum.Active);
}
static void Main(string[] args)
{
// Find your Account Sid and Auth Token at twilio.com/console
// To set up environmental variables, see http://twil.io/secure
const string accountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
const string accountSidToClose = Environment.GetEnvironmentVariable("TWILIO_SUBACCOUNT_SID");
const string authToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
TwilioClient.Init(accountSid, authToken);
AccountResource.Update(
pathSid: accountSidToClose,
status: AccountResource.StatusEnum.Closed);
}
public static IList <string> Authenticate()
{
const string apiKey = "SKXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; // You can generate this from www.twilio.com/console/runtime/api-keys/create
const string apiSecret = "your_api_secret"; // You can generate this from www.twilio.com/console/runtime/api-keys/create
// DANGER! This is insecure. See http://twil.io/secure
TwilioClient.Init(apiKey, apiSecret, TWILIO_ACCOUNT_SID);
// Proof request to check credentials are working.
// Retrieving your account information
var accounts = AccountResource.Read();
return(accounts.Select(acnt => acnt.Sid).ToList());
}
public Client(Credentials credentials) {
if (credentials == null) throw new ArgumentNullException("credentials");
requester = new Requester(credentials);
Account = new AccountResource(requester);
Balance = new BalanceResource(requester);
Cards = new CardResourceShim(requester);
Charges = new ChargeResource(requester);
Customers = new CustomerResource(requester);
Disputes = new DisputeResource(requester);
Events = new EventResource(requester);
Recipients = new RecipientResource(requester);
Refunds = new RefundResourceShim(requester);
Tokens = new TokenResource(requester);
Transactions = new TransactionResource(requester);
Transfers = new TransferResource(requester);
}
