protected void btnAdd_Click(object sender, EventArgs e)
{
var footer = GetFooter();
var ddlTypeF = (DropDownList)footer.FindControl("ddlTypeF");
var txtAttentionLineF = (TextBox)footer.FindControl("txtAttentionLineF");
var txtStreetAddressLine1F = (TextBox)footer.FindControl("txtStreetAddressLine1F");
var txtStreetAddressLine2F = (TextBox)footer.FindControl("txtStreetAddressLine2F");
var txtCityF = (TextBox)footer.FindControl("txtCityF");
var txtStateF = (TextBox)footer.FindControl("txtStateF");
var txtZipF = (TextBox)footer.FindControl("txtZipF");
var txtCountryF = (TextBox)footer.FindControl("txtCountryF");
if (!string.IsNullOrEmpty(txtStreetAddressLine1F.Text))
{
var type = AddressTypes.First(x => x.Field == ddlTypeF.SelectedValue).Field;
AddressItem item = new AddressItem()
{
AddressID = 0,
AddressType = type,
Attention = txtAttentionLineF.Text,
AddressLine1 = txtStreetAddressLine1F.Text,
AddressLine2 = txtStreetAddressLine2F.Text,
City = txtCityF.Text,
State = txtStateF.Text,
Zip = txtZipF.Text,
Country = txtCountryF.Text
};
CreateAddress?.Invoke(this, new CreateAddressEventArgs()
{
NewItem = item
});
}
}
public void CreateAddress_Action_Fails()
{
// Arrange
var addressDto = TestHelper.AddressDto();
GenericServiceResponse <bool> fakeResponse = null;
mockClientServicesProvider.Setup(x => x.Logger).Returns(mockLogger.Object).Verifiable();
mockClientServicesProvider.Setup(x => x.AddressService.CreateAddress(addressDto)).Returns(fakeResponse).Verifiable();
var viewModel = new GenericViewModel();
var action = new CreateAddress <GenericViewModel>(mockClientServicesProvider.Object)
{
OnComplete = model => viewModel = model
};
// Act
var result = action.Invoke(addressDto);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(GenericViewModel));
Assert.IsNotNull(result.Notifications);
Assert.IsInstanceOfType(result.Notifications, typeof(NotificationCollection));
Assert.IsTrue(result.Notifications.Count() == 1);
Assert.IsTrue(result.HasErrors);
Assert.IsNotNull(result.Success);
Assert.IsInstanceOfType(result.Success, typeof(bool));
Assert.IsFalse(result.Success);
}
private static async Task RunInternationalAddressValidationExample(ShippoClient resource)
{
var parameters = new CreateAddress
{
Name = "Shippo Hippo",
Company = "Shippo",
StreetNo = null,
Street1 = "40 Bay St",
Street2 = null,
City = "Toronto",
State = "ON",
PostalCode = "M5J 2X2",
Country = "CA",
Phone = "+1 555 341 9393",
Email = "*****@*****.**",
Metadata = "Customer ID 123456",
Validate = true
};
Address address = await resource.CreateAddress(parameters);
Console.Out.WriteLine("Address IsValid: " + address.ValidationResults.IsValid);
if (address.ValidationResults.Messages != null)
{
foreach (ValidationMessage message in address.ValidationResults.Messages)
{
Console.Out.WriteLine("Address Message Code: " + message.Code);
Console.Out.WriteLine("Address Message Text: " + message.Text);
Console.Out.WriteLine();
}
}
}
public async Task <IActionResult> CreateAddress([FromBody] CreateAddress command)
{
try
{
await _busPublisher.SendAsync(command.BindId(x => x.Id), CorrelationContext.Empty);
}
catch (Exception ex) { }
return(Accepted());
}
public async Task <IActionResult> CreateAddress([FromQuery] CreateAddress command)
{
try
{
//Publish message to RabbitMq
await _busPublisher.PublishAsync(new AddressCreated(command.Id, command.AddressLine1, command.AddressLine2, command.AddressLine3, command.PostalCode, command.AddressType, command.UserId), CorrelationContext.Empty);
}
catch (Exception ex) { }
return(Accepted());
}
public async Task <AddressDto> CreateAddressAsync(int id, CreateAddress createAddress)
{
var user = await _userRepository.GetAsync(id);
user.ThrowIfNull(id);
var address = await _addressRepository.CreateAsync(_mapper.Map <Address>(createAddress));
user.AddressId = address.Id;
await _userRepository.UpdateAsync(user);
return(_mapper.Map <AddressDto>(address));
}
public IActionResult CreateAddress([FromBody] CreateAddress address)
{
var aggregate =
_addressFactory.Create(new AddressFactoryInput
{
AddressId = address.AddressId,
FullAddressName = address.FullAddress
});
_addressRepository.Add(aggregate);
return(CreatedAtRoute("GetAddress", new { address.AddressId }, aggregate));
}
public static async Task <Batch> GetDefaultObject()
{
// Grab USPS carrier account to get the correct object ID for further testing.
// This should be changed to be more generic in future versions of this test. In
// other words, remove the depedence on a USPS carrier account to exist.
ShippoCollection <CarrierAccount> carrierAccounts = await GetShippoClient().AllCarrierAccounts();
string defaultCarrierAccount = "";
foreach (CarrierAccount account in carrierAccounts)
{
if (account.Carrier.ToString() == "usps")
{
defaultCarrierAccount = account.ObjectId;
}
}
var addressFrom = CreateAddress.CreateForPurchase("Mr. Hippo", "965 Mission St.", "Ste 201", "SF",
"CA", "94103", "US", "4151234567", "*****@*****.**");
var addressTo = CreateAddress.CreateForPurchase("Mrs. Hippo", "965 Missions St.", "Ste 202", "SF",
"CA", "94103", "US", "4151234568", "*****@*****.**");
CreateParcel[] parcels = { CreateParcel.CreateForShipment(5, 5, 5, DistanceUnits.@in, 2, MassUnits.oz) };
var shipment = CreateShipment.CreateForBatch(addressFrom, addressTo, parcels);
var batchShipment = CreateBatchShipment.CreateForBatchShipments(defaultCarrierAccount, "usps_priority", shipment);
var batchShipments = new List <CreateBatchShipment>();
batchShipments.Add(batchShipment);
Batch batch = await GetShippoClient().CreateBatch(new CreateBatch
{
DefaultCarrierAccount = defaultCarrierAccount,
DefaultServicelevelToken = "usps_priority",
LabelFiletype = ShippoEnums.LabelFiletypes.PDF_4x6,
Metadata = "BATCH #170",
BatchShipments = batchShipments
});
Assert.AreEqual(ShippoEnums.Statuses.VALIDATING, batch.Status);
return(batch);
}
public static async Task <Address> GetDefaultObject2()
{
var parameters = new CreateAddress
{
Name = "Undefault New Wu",
Company = "Shippo",
Street1 = "Francis St.",
StreetNo = "56",
Street2 = null,
City = "San Francisco",
State = "CA",
PostalCode = "94112",
Country = "US",
Phone = "+1 555 341 9393",
Email = "*****@*****.**",
Metadata = "Customer ID 123456"
};
return(await GetShippoClient().CreateAddress(parameters));
}
public void Do_not_load_order_on_inactive_address()
{
var createAddress = new CreateAddress();
Fixture(createAddress);
Run(new UpdateCommand());
Fixture(new UnconfirmedOrder());
Fixture(new UnconfirmedOrder {
Address = createAddress.Address,
Clean = false
});
var config = localSession.Query <AddressConfig>().First(x => x.Address.Id == createAddress.Address.Id);
Assert.IsTrue(config.IsActive);
config.IsActive = false;
Run(new UpdateCommand());
var orders = localSession.Query <Order>().ToArray();
Assert.AreEqual(1, orders.Length);
}
public void Validate_CreateUser_RequiredFields()
{
var addr = new CreateAddress()
{
Street1 = "Street1",
Street2 = "Street2",
City = "City",
State = "State",
Zip = "Zip"
};
List <ValidationResult> results = new List <ValidationResult>();
ValidationContext vc = new ValidationContext(addr);
//All Fields
Assert.True(Validator.TryValidateObject(addr, vc, results, true));
//Missing Street2
addr.Street2 = null;
Assert.True(Validator.TryValidateObject(addr, vc, results, true));
//Missing Street1
addr.Street1 = null;
Assert.False(Validator.TryValidateObject(addr, vc, results, true));
addr.Street1 = "Street1";
//Missing City
addr.City = null;
Assert.False(Validator.TryValidateObject(addr, vc, results, true));
addr.City = "City";
//Missing State
addr.State = null;
Assert.False(Validator.TryValidateObject(addr, vc, results, true));
addr.State = "State";
//Missing Zip
addr.Zip = null;
Assert.False(Validator.TryValidateObject(addr, vc, results, true));
addr.Zip = "Zip";
}
public void TestInvalidCreate()
{
var invalidAddressTo = new CreateAddress
{
Name = "Undefault New Wu",
Company = "Shippo",
StreetNo = "215",
Street1 = "Clayton St.",
Street2 = null,
City = "Mickey Town",
State = "CA",
PostalCode = "1183",
Country = "US",
Phone = "+1 555 9393",
Email = "*****@*****.**",
Metadata = "Customer ID 123456",
Validate = true
};
Assert.That(async() => await ManifestTest.GetDefaultObject(invalidAddressTo), Throws.TypeOf <ShippoException>());
}
public async Task can_create_address()
{
SetupServerSingleResponse(Address1WithName("ddd"));
var create = new CreateAddress {
Name = "ddd"
};
var add = await client.Addresses.CreateAddressAsync("fff", create);
var truth = new Response <AddressEntity>
{
Data = Address1Model
};
truth.Data.Name = "ddd";
truth.Should().BeEquivalentTo(add);
server.ShouldHaveExactCall("https://api.coinbase.com/v2/accounts/fff/addresses")
.WithVerb(HttpMethod.Post);
}
private static async Task RunBatchExample(ShippoClient resource)
{
ShippoCollection <CarrierAccount> carrierAccounts = await resource.AllCarrierAccounts();
string defaultCarrierAccount = "";
foreach (CarrierAccount account in carrierAccounts)
{
if (account.Carrier.ToString() == "usps")
{
defaultCarrierAccount = account.ObjectId;
}
}
var addressFrom = CreateAddress.CreateForPurchase("Mr. Hippo", "965 Mission St.", "Ste 201", "SF",
"CA", "94103", "US", "4151234567", "*****@*****.**");
var addressTo = CreateAddress.CreateForPurchase("Mrs. Hippo", "965 Missions St.", "Ste 202", "SF",
"CA", "94103", "US", "4151234568", "*****@*****.**");
CreateParcel[] parcels = { CreateParcel.CreateForShipment(5, 5, 5, DistanceUnits.@in, 2, MassUnits.oz) };
var shipment = CreateShipment.CreateForBatch(addressFrom, addressTo, parcels);
var batchShipment = CreateBatchShipment.CreateForBatchShipments(defaultCarrierAccount, "usps_priority", shipment);
var batchShipments = new List <CreateBatchShipment>();
batchShipments.Add(batchShipment);
Batch batch = await resource.CreateBatch(new CreateBatch
{
DefaultCarrierAccount = defaultCarrierAccount,
DefaultServicelevelToken = "usps_priority",
LabelFiletype = ShippoEnums.LabelFiletypes.PDF_4x6,
Metadata = "BATCH #170",
BatchShipments = batchShipments
});
Console.WriteLine("Batch Status = " + batch.Status);
Console.WriteLine("Metadata = " + batch.Metadata);
}
public static void Main(string[] args)
{
// replace with your Shippo Token
// don't have one? get more info here
// (https://goshippo.com/docs/#overview)
var client = new ShippoClient("<YourShippoToken>");
// to address
var toAddressTable = new CreateAddress
{
Name = "Mr. Hippo",
Company = "Shippo",
Street1 = "215 Clayton St.",
City = "San Francisco",
State = "CA",
PostalCode = "94117",
Country = "US",
Phone = "+1 555 341 9393",
Email = "*****@*****.**"
};
// from address
var fromAddressTable = new CreateAddress
{
Name = "Ms Hippo",
Company = "San Diego Zoo",
Street1 = "2920 Zoo Drive",
City = "San Diego",
State = "CA",
PostalCode = "92101",
Country = "US",
Email = "*****@*****.**",
Phone = "+1 619 231 1515",
Metadata = "Customer ID 123456"
};
// parcel
var parcelTable = new CreateParcel
{
Length = 5,
Width = 5,
Height = 5,
DistanceUnit = DistanceUnits.@in,
Weight = 2,
MassUnit = MassUnits.lb
};
// shipment
var shipmentTable = new CreateShipment
{
AddressTo = toAddressTable,
AddressFrom = fromAddressTable,
Async = false
};
shipmentTable.AddParcel(parcelTable);
// create Shipment object
Console.WriteLine("Creating Shipment object..");
Task.Run(async() =>
{
Shipment shipment = await client.CreateShipment(shipmentTable);
// select desired shipping rate according to your business logic
// we simply select the first rate in this example
Rate rate = shipment.Rates[0];
Console.WriteLine("Getting shipping label..");
var transactionParameters = new CreateTransaction
{
Rate = rate.ObjectId,
Async = false
};
Transaction transaction = await client.CreateTransaction(transactionParameters);
if (transaction.Status == ShippoEnums.TransactionStatuses.SUCCESS)
{
Console.WriteLine("Label url : " + transaction.LabelURL);
Console.WriteLine("Tracking number : " + transaction.TrackingNumber);
}
else
{
Console.WriteLine("An Error has occured while generating your label. Messages : " + transaction.Messages);
}
Console.WriteLine("\nBatch\n");
await RunBatchExample(client);
Console.WriteLine("\nTrack\n");
await RunTrackingExample(client);
Console.WriteLine("\nValidating International Address\n");
await RunInternationalAddressValidationExample(client);
}).Wait();
}
/// <inheritdoc />
Task <Response <AddressEntity> > IAddressesEndpoint.CreateAddressAsync(string accountId, CreateAddress createAddress, CancellationToken cancellationToken)
{
return(this.AccountsEndpoint
.AppendPathSegmentsRequire(accountId, "addresses")
.WithClient(this)
.PostJsonAsync(createAddress, cancellationToken)
.ReceiveJson <Response <AddressEntity> >());
}
public async Task <Address> CreateAddress(CreateAddress createAddress)
{
string ep = string.Format("{0}/addresses", apiEndpoint);
return(await this.apiClient.DoRequestAsync <Address>(ep, HttpMethod.Post, Serialize(createAddress)));
}
public async Task <IActionResult> Post([FromBody] CreateAddress command)
{
await _addressService.CreateAddress(ObjectId.GenerateNewId(), command.Link, command.Category);
return(Created("/link", null));
}
