public int Add(/*[FromBody]*/ AddressItem item)
{
this.ControllerContext.HttpContext.Response.Headers.Add("Access-Control-Allow-Origin", AccessControlForUrlBase);
var result = new AddressService().Add(item);
return(result);
}
public AddressItemData AddAddressItem(AddressItemData data)
{
AddressItem item = AddressItemMapper.Convert(data);
itemRepository.Add(item);
return(AddressItemMapper.Convert(item));
}
public void ShouldConvertReturnedAddressItemsToViewModel()
{
ICustomerRepository customerRepository = Substitute.For <ICustomerRepository>();
Customer customer = new Customer();
customerRepository.GetCustomer(Arg.Any <Guid>()).Returns(customer);
IAddressItemRepository itemRepository = Substitute.For <IAddressItemRepository>();
AddressItem[] items = new AddressItem[] { new AddressItem() };
itemRepository.GetAddressItems(customer).Returns(items);
IAddressItemMapper mapper = Substitute.For <IAddressItemMapper>();
mapper.Convert(Arg.Any <AddressItem>()).Returns(new AddressItemData());
AddressItemAdapter adapter = new AddressItemAdapter(customerRepository, itemRepository);
adapter.AddressItemMapper = mapper;
string customerId = Guid.Empty.ToString("N");
IEnumerable <AddressItemData> models = adapter.GetAddressItems(customerId);
Assert.AreEqual(1, models.Count(), "The wrong number of view models were returned.");
customerRepository.Received(1).GetCustomer(Arg.Any <Guid>());
itemRepository.Received(1).GetAddressItems(customer);
mapper.Received(1).Convert(Arg.Any <AddressItem>());
}
private List <(Dictionary <string, AddressItem>, string, AddressItem)> CleanEmptyItems(LinkerResult result)
{
List <(Dictionary <string, AddressItem>, string, AddressItem)> ret = new List <(Dictionary <string, AddressItem>, string, AddressItem)>();
foreach (string name in result.DataSectionHeader.Keys.ToList())
{
AddressItem item = result.DataSectionHeader[name];
if (item.IsEmpty)
{
ret.Add((result.DataSectionHeader, name, item));
result.DataSectionHeader.Remove(name);
}
}
foreach (KeyValuePair <(int, int), Dictionary <string, AddressItem> > section in result.HiddenDataSectionItems)
{
foreach (string name in section.Value.Keys.ToList())
{
AddressItem item = section.Value[name];
if (item.IsEmpty)
{
ret.Add((section.Value, name, item));
section.Value.Remove(name);
}
}
}
return(ret);
}
/// <summary>
/// Event for double clicking a project node.
/// </summary>
/// <param name="sender">Sending object.</param>
/// <param name="e">Tree node mouse event args.</param>
private void ProjectExplorerTreeViewNodeMouseDoubleClick(Object sender, TreeNodeAdvMouseEventArgs e)
{
if (e == null || e.Node == null)
{
return;
}
ProjectItem projectItem = this.GetProjectItemFromNode(e.Node);
if (projectItem is AddressItem)
{
ValueEditorModel valueEditor = new ValueEditorModel();
AddressItem addressItem = projectItem as AddressItem;
dynamic result = valueEditor.EditValue(null, null, addressItem);
if (CheckSyntax.CanParseValue(addressItem.ElementType, result?.ToString()))
{
addressItem.Value = result;
}
}
else if (projectItem is ScriptItem)
{
ScriptEditorModel scriptEditor = new ScriptEditorModel();
ScriptItem scriptItem = projectItem as ScriptItem;
scriptItem.Script = scriptEditor.EditValue(null, null, scriptItem.Script) as String;
}
}
private void btnGenMulti_Click(object sender, RoutedEventArgs e)
{
int count = 1;
try
{
count = int.Parse(txbCount.Text);
} catch (Exception)
{
count = 1;
}
for (int i = 0; i < count; i++)
{
byte[] privateKey = new byte[32];
using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
{
rng.GetBytes(privateKey);
}
KeyPair key = new KeyPair(privateKey, KeyType.Transparent);
string address = Wallet.ToAddress(key.PublicKeyHash);
TAddrs.GetInstance().SaveAddress(privateKey, address);
AddressItem item = new AddressItem(address, privateKey.ToHexString());
lstAddrs.Add(item);
item.DeleteAddressEvent += DeleteAddrEvent;
spAddrsPan.Children.Add(item);
}
}
private void Save_Clicked(object sender, EventArgs e)
{
string message = CheckInfor();
if (message != "")
{
DisplayAlert("Error", message, "OK");
return;
}
AddressItem newAddress = new AddressItem
{
Country = CountryText.Text,
City = CityText.Text,
HouseNumber = HouseNumberText.Text,
District = DistrictText.Text
};
//(App.Current.MainPage.Navigation.NavigationStack.ElementAt(0).BindingContext as StoreSetttingViewModel).ChangeAddress(newAddress);
if (parentName == "StoreSetting")
{
(TabbarStoreManager.GetInstance().Children.ElementAt(4).BindingContext as StoreSetttingViewModel).ChangeAddress(newAddress);
}
else
{
(UserSettingView.GetInstance().BindingContext as UserSettingViewModel).ChangeAddress(newAddress);
}
App.Current.MainPage.Navigation.PopAsync();
}
protected void UpdateAccountAddress(int accountId, AddressItem item)
{
var dsAccount = GetDataSet();
DataRow addr;
if (item.AddressID == 0)
{
addr = dsAccount.Tables["Address"].NewRow();
}
else
{
addr = dsAccount.Tables["Address"].Rows.Find(item.AddressID);
}
addr.SetField("AddressType", item.AddressType);
addr.SetField("InternalAddress", item.Attention);
addr.SetField("StrAddress1", item.AddressLine1);
addr.SetField("StrAddress2", item.AddressLine2);
addr.SetField("City", item.City);
addr.SetField("State", item.State);
addr.SetField("Zip", item.Zip);
addr.SetField("Country", item.Country);
if (item.AddressID == 0)
{
dsAccount.Tables["Address"].Rows.Add(addr);
}
var acct = dsAccount.Tables["Account"].Rows.Find(accountId);
acct[item.AddressType] = addr["AddressID"];
ContextBase.SetCacheData(dsAccount);
}
public void ChangeAddress(AddressItem newAddress)
{
string address = newAddress.HouseNumber + "#" + newAddress.District + "#" + newAddress.City + "#" + newAddress.Country;
Address = address;
CurrentUser.Address = address;
}
private void AddAccountAddress(int accountId, AddressItem item)
{
if (accountId > 0)
{
var dsAccount = GetDataSet();
DataRow ndr = dsAccount.Tables["Address"].NewRow();
ndr.SetField("AddressType", item.AddressType);
ndr.SetField("InternalAddress", item.Attention);
ndr.SetField("StrAddress1", item.AddressLine1);
ndr.SetField("StrAddress2", item.AddressLine2);
ndr.SetField("City", item.City);
ndr.SetField("State", item.State);
ndr.SetField("Zip", item.Zip);
ndr.SetField("Country", item.Country);
dsAccount.Tables["Address"].Rows.Add(ndr);
int addressId = ndr.Field <int>("AddressID");
DataRow acct = dsAccount.Tables["Account"].Rows.Find(accountId);
acct.SetField(item.AddressType, addressId);
ContextBase.SetCacheData(dsAccount);
}
}
private AddressItem GetDefaultAddress(string addressType, int orgId)
{
var ds = GetDataSet();
DataRow org = ds.Tables["Org"].Rows.Find(orgId);
int addressId = org.Field <int>(string.Format("Def{0}", addressType));
var result = new AddressItem();
if (addressId != 0)
{
DataRow addr = ds.Tables["Address"].Rows.Find(addressId);
if (addr != null)
{
result.AddressType = addressType;
result.AddressID = addr.Field <int>("AddressID");
result.Attention = addr.Field <string>("InternalAddress");
result.AddressLine1 = addr.Field <string>("StrAddress1");
result.AddressLine2 = addr.Field <string>("StrAddress2");
result.City = addr.Field <string>("City");
result.State = addr.Field <string>("State");
result.Zip = addr.Field <string>("Zip");
result.Country = addr.Field <string>("Country");
}
}
return(result);
}
public OperationResult GetItem(AddressItem elType, int elementId)
{
var res = GetAddressElement(elType, elementId);
return(res == null
? new OperationResult(false, "Element was not found.")
: new OperationResult(true, res));
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueEditor" /> class.
/// </summary>
/// <param name="addressItem">The initial address being edited.</param>
public ValueEditor(AddressItem addressItem)
{
this.InitializeComponent();
this.ValueHexDecBoxViewModel = this.ValueHexDecBox.DataContext as HexDecBoxViewModel;
this.ValueHexDecBoxViewModel.PropertyChanged += HexDecBoxViewModelPropertyChanged;
this.ValueHexDecBoxViewModel.DataType = addressItem.DataType;
}
private void DeleteAddrEvent(object sender, AddressItem item)
{
item.DeleteAddressEvent -= DeleteAddrEvent;
lstAddrs.Remove(item);
TAddrs.GetInstance().RemoveAddress(item.GetAddress());
ReloadAddrs();
}
internal StoreListItem(Domain.Store user, IIdSerializer serializer)
{
Address = new AddressItem(user.Address);
Id = serializer.Serialize("Query", nameof(Store), user.Id);
Name = user.Name;
Picture = user.Picture;
HasProducers = user.ProducersCount > 0;
Producers = user.ProducersCount;
}
/// <summary>
/// Initializes a new instance of the <see cref="ValueEditor" /> class.
/// </summary>
/// <param name="addressItem">The initial address being edited.</param>
public ValueEditor(AddressItem addressItem)
{
this.InitializeComponent();
this.ValueHexDecBox = new HexDecTextBox(addressItem.DataType);
this.ValueHexDecBox.TextChanged += this.ValueHexDecBoxTextChanged;
this.ValueHexDecBox.IsHex = addressItem.IsValueHex;
this.ValueHexDecBox.SetValue(addressItem.AddressValue);
this.ValueEditorTextEditorContainer.Children.Add(WinformsHostingHelper.CreateHostedControl(this.ValueHexDecBox));
}
public async Task <IActionResult> Edit(AddressItem addressItem)
{
if (!ModelState.IsValid)
{
return(View(addressItem));
}
await _addressRepository.EditItem(addressItem);
return(RedirectToAction(DefaultView));
}
public bool SpawnItem(AddressItem item, int address)
{
if (this.addressItems[address] != AddressItem.None)
{
return(false);
}
this.addressItems[address] = item;
this.OnSpawnedItem?.Invoke(item, address);
return(true);
}
public void GetAddressItemFromAddress(out AddressItem addressItem, Address address)
{
addressItem = new AddressItem()
{
Id = address.Id,
FullName = address.FullName,
Email = address.Email,
PhoneNumber = address.PhoneNumber,
PhysicalAddress = address.PhysicalAddress,
};
}
public void GetAddressFromAddressItem(AddressItem addressItem, out Address address)
{
address = new Address
{
Id = addressItem.Id,
FullName = addressItem.FullName,
Email = addressItem.Email,
PhoneNumber = addressItem.PhoneNumber,
PhysicalAddress = addressItem.PhysicalAddress,
};
}
public void RemoveAddressItem(string settingId)
{
PrimitiveMapper mapper = new PrimitiveMapper();
AddressItem item = itemRepository.GetAddressItem(mapper.ToGuid(settingId));
if (item == null)
{
throw new AdapterException(HttpStatusCode.NotFound, "An address item with the given ID was not found.");
}
itemRepository.Remove(item);
}
public static string GetParentPropertyName(this AddressItem elType)
{
return(elType switch
{
AddressItem.State => AddressItem.Country.ToString(),
AddressItem.City => AddressItem.State.ToString(),
AddressItem.Street => AddressItem.City.ToString(),
AddressItem.House => AddressItem.Street.ToString(),
AddressItem.Apartment => AddressItem.House.ToString(),
_ => null
});
public void ShowDialog(AddressItem addressItem)
{
View.Editors.ValueEditor valueEditor = new View.Editors.ValueEditor(addressItem)
{
Owner = Application.Current.MainWindow
};
if (valueEditor.ShowDialog() == true && addressItem != null)
{
addressItem.AddressValue = this.Value;
}
}
private void UserControl_Loaded(object sender, RoutedEventArgs e)
{
spAddrsPan.Children.Clear();
foreach (TAddressType addrInfo in TAddrs.GetInstance().GetAddress())
{
AddressItem item = new AddressItem(addrInfo.address, addrInfo.privKey);
lstAddrs.Add(item);
item.DeleteAddressEvent += DeleteAddrEvent;
spAddrsPan.Children.Add(item);
}
}
/// <summary>
/// Adds a .Net object to the project explorer.
/// </summary>
/// <param name="dotNetObjectViewModel">The view model of the .Net object.</param>
private void AddDotNetObject(DotNetObjectViewModel dotNetObjectViewModel)
{
DotNetObject dotNetObject = dotNetObjectViewModel.DotNetObject;
AddressItem addressItem = new AddressItem();
addressItem.Description = dotNetObject.Name;
addressItem.ElementType = dotNetObject.ElementType == typeof(Boolean) ? typeof(Byte) : dotNetObject.ElementType;
addressItem.BaseIdentifier = dotNetObject.GetFullName();
addressItem.ResolveType = AddressResolver.ResolveTypeEnum.DotNet;
ProjectExplorerViewModel.GetInstance().AddNewProjectItems(true, addressItem);
}
public async Task <IActionResult> Add(AddressItem addressItem)
{
if (!ModelState.IsValid)
{
return(View());
}
_addressRepository.GetAddressFromAddressItem(addressItem, out var address);
await _addressRepository.AddNewItem(address);
return(RedirectToAction(DefaultView));
}
public IActionResult UpdateItem([Required] AddressItem elType, [Required] int elementId, string newName,
int parentId)
{
if (string.IsNullOrEmpty(newName) && parentId == 0)
{
return(Ok("No changed data."));
}
OperationResult Update() => _service.UpdateItem(elType, elementId, newName, parentId);
return(HandleRequest(Update));
}
private IAddressElement GetAddressElement(AddressItem elType, int elementId)
{
return(elType switch
{
AddressItem.Country => (IAddressElement)_repository.Get <Country>(elementId),
AddressItem.State => _repository.GetWithRelated <State>(elementId, s => s.Include(x => x.Country)),
AddressItem.City => _repository.GetWithRelated <City>(elementId, queryable => queryable.IncludeAllAddressItems()),
AddressItem.Street => _repository.GetWithRelated <Street>(elementId, queryable => queryable.IncludeAllAddressItems()),
AddressItem.House => _repository.GetWithRelated <House>(elementId, queryable => queryable.IncludeAllAddressItems()),
AddressItem.Apartment => _repository.GetWithRelated <Apartment>(elementId, queryable => queryable.IncludeAllAddressItems()),
_ => null
});
public static TransactionItem[] CreateTransactions(this TransferItem transferItem, string remainderAddress, params AddressItem[] fromAddressItems)
{
if (fromAddressItems == null)
{
fromAddressItems = new AddressItem[] { }
}
;
var totalBalance = fromAddressItems.Sum(f => f.Balance);
var needBalance = transferItem.Value; //transferItems.Sum(t => t.Value);
if (needBalance > totalBalance)
{
throw new NotEnoughBalanceException(needBalance, totalBalance);
}
InputValidator.ValidateTransfer(transferItem);
var depositTransaction = CreateDepositTransaction(transferItem).ToArray();
TransactionItem[] withdrawalTransactions = null;
if (needBalance > 0)
{
withdrawalTransactions = CreateWithdrawalTransactions(transferItem.Tag, needBalance, remainderAddress, fromAddressItems)
.ToArray();
}
var transactions = new List <TransactionItem>();
transactions.AddRange(depositTransaction);
if (withdrawalTransactions != null)
{
transactions.AddRange(withdrawalTransactions);
}
var bundleHash = transactions.FinalizeAndNormalizeBundleHash(new Crypto.Kerl());
if (withdrawalTransactions != null)
{
withdrawalTransactions.SignSignatures(fromAddressItems);
}
var transactionsBalance = transactions.Sum(t => t.Value);
if (transactionsBalance != 0)
{
throw new IotaException($"Total transactions balance should be zero. Current is '{transactionsBalance}'. There is some bug in code.");
}
return(transactions.ToArray());
}
public bool SpawnItem(AddressItem item)
{
int address = this.RandomAvailableAddress();
if (address == -1)
{
return(false);
}
this.addressItems[address] = item;
this.OnSpawnedItem?.Invoke(item, address);
return(true);
}
