/// <summary>
/// Gets the billing account and service account information.
/// </summary>
/// <param name="usi">The usi.</param>
/// <param name="headerArgs"></param>
/// <returns></returns>
public BillingandServiceAccountDto GetBillingServiceAccounts(string usi, HeaderArgs headerArgs)
{
var billingAndServiceAccounts = new BillingandServiceAccountDto();
var request = new LoadSubServiceRequest {USI = usi};
var esbAccounts = LoadSubscriberServices(request);
var esbServiceAccounts = (esbAccounts.ServiceAccounts.Any())
? esbAccounts.ServiceAccounts
: new List<ServiceAccount>();
billingAndServiceAccounts.ServiceAccounts = TypeAdapter.Adapt<List<ServiceAccount>, List<ServiceAccountDto>>(esbServiceAccounts);
billingAndServiceAccounts.CustomerAccount = GetAccountInfo(usi, headerArgs);
return billingAndServiceAccounts;
}
/// <summary>
/// Merges the specified subscriber triad.
/// </summary>
/// <param name="provisionedSubscriber">Subscriber object from provisioning</param>
/// <param name="billedSubscriber">Subscriber object from billing.</param>
/// <param name="provisionedSubscriberPhones">Phone object from provisioning.</param>
/// <returns></returns>
public static CompositeSubscriber Merge(SubscriberDto provisionedSubscriber, BillingandServiceAccountDto billedSubscriber, IEnumerable<PhoneDto> provisionedSubscriberPhones )
{
var compositeSubscriber = new CompositeSubscriber
{
SubscriberTriad = provisionedSubscriber ?? new SubscriberDto(),
SubscriberDpi = (billedSubscriber != null && billedSubscriber.CustomerAccount != null)
? billedSubscriber.CustomerAccount
: null
};
var billedServiceAccounts = (billedSubscriber != null && billedSubscriber.ServiceAccounts != null)
? billedSubscriber.ServiceAccounts : new List<ServiceAccountDto>();
compositeSubscriber.DpiServices = MergePhonesAndServiceAccounts(billedServiceAccounts, provisionedSubscriberPhones.ToList(), compositeSubscriber.SubscriberTriad.ID);
return compositeSubscriber;
}
public void User_can_load_a_subscriber_that_is_billed_but_not_provisioned()
{
using (ShimsContext.Create())
{
// Setup
const string subscriberID = "999999999999";
string deviceID = null;
const string state = "";
const string region = "PA";
const string subscriberName = "Billed Subscriber";
const string expectedTN = "5551231234";
var myContext = new SIMPLTestContext();
// Given a user
var fakeUserDto = myContext.GetFakeUserDtoObject();
ShimCurrentUser.AsUserDto = () => fakeUserDto;
ShimRosettianClient.AllInstances.LoadSubscriberStringUserDto = delegate
{
return new SubscriberDto();
};
ShimRosettianClient.AllInstances.LoadSubscriberPhonesStringUserDto = delegate
{
return new List<PhoneDto>();
};
ShimEnterpriseClient.AllInstances.GetBillingServiceAccountsStringHeaderArgs = delegate
{
var billingAccount = new BillingandServiceAccountDto();
billingAccount.ServiceAccounts = new List<ServiceAccountDto>();
var customerAccount = new CustomerAccountDto();
var customer = new CustomerDto();
customer.ContactName = subscriberName;
customerAccount.Customer = customer;
billingAccount.CustomerAccount = customerAccount;
var serviceAccountDto = new ServiceAccountDto
{
SubscriberName = subscriberName,
TN = expectedTN,
USI = subscriberID,
};
billingAccount.ServiceAccounts.Add(serviceAccountDto);
return billingAccount;
};
ShimCurrentSubscriber.SetInstanceCompositeSubscriberSubscriberModel = (myCompositeSubscriber, mySubscriberModel) => { };
ShimCurrentSubscriber.GetInstance = () => new ShimCurrentSubscriber
{
ProvisionedServicesListGet = () => new List<ServiceDto>()
};
// When loading that subscriber
var result = SubscriberControllerForTests.Index(subscriberID, deviceID, state, region) as ViewResult;
//Then the user receives a successful response
Assert.IsNotNull(result, "SubscriberController Index method returned null");
Assert.IsNotNull(result.Model, "result.Model method returned null");
var testSubscriberModel = result.Model as SubscriberModel;
Assert.IsNotNull(testSubscriberModel, "Subscriber Model returned null");
Assert.AreEqual("200", testSubscriberModel.ActionResponse.Code, "Test threw an exception {0}{0}{1}", Environment.NewLine, testSubscriberModel.ActionResponse.Message);
var subDetials = testSubscriberModel.SubDetailsModel;
Assert.AreEqual(subscriberID, subDetials.USI, string.Format("Billing USI not used: Actual-{0}, Expected-{1}", subDetials.USI, subscriberID));
Assert.AreEqual(subscriberName, subDetials.DisplayedName, string.Format("Billing Subscriber Name not used: Actual-{0}, Expected-{1}", subDetials.DisplayedName, subscriberName));
Assert.AreEqual(region, subDetials.BillingRegion, string.Format("Billing Region is incorrect: Actual-{0}, Expected-{1}", subDetials.BillingRegion, region));
Assert.AreEqual(expectedTN, subDetials.WTN, "WTN do not match billing TN");
}
}
//private string MapResponse(retrieveCustomerServiceConfigurationResponse1 esbResponse)
//{
// try
// {
// return esbResponse.retrieveCustomerServiceConfigurationResponse.retrieveCustomerServiceConfigurationOutput.Payload.First()
// .ResourceFacingServices.First()
// .logicalResource.First()
// .LogicalResourceCharacteristicValues.First()
// .Value.value;
// }
// catch (System.Exception e)
// {
// throw new EnterpriseServiceException("Error mapping retrieveCustomerServiceConfiguration response - no IP found in the response.", e);
// }
//}
private BillingandServiceAccountDto MapResponse(retrieveCustomerAccountSummaryResponse1 esbResponse)
{
var customerAndServiceAccounts = new BillingandServiceAccountDto();
if (esbResponse.retrieveCustomerAccountSummaryResponse.retrieveCustomerAccountSummaryOutput == null ||
esbResponse.retrieveCustomerAccountSummaryResponse.retrieveCustomerAccountSummaryOutput.Payload == null ||
!esbResponse.retrieveCustomerAccountSummaryResponse.retrieveCustomerAccountSummaryOutput.Payload.Any())
{
customerAndServiceAccounts.CustomerAccount = null;
customerAndServiceAccounts.ServiceAccounts = null;
return customerAndServiceAccounts;
}
// ReSharper disable once ForCanBeConvertedToForeach
for (var index = 0;
index < esbResponse.retrieveCustomerAccountSummaryResponse.retrieveCustomerAccountSummaryOutput.Payload.Length;
index++)
{
var payload = esbResponse.retrieveCustomerAccountSummaryResponse.retrieveCustomerAccountSummaryOutput.Payload[index];
var serviceAccount = new ServiceAccountDto();
if (payload.accountType != null && payload.accountType == "Billing")
{
serviceAccount.IsBTN = true;
customerAndServiceAccounts.CustomerAccount.Customer.CitizensPostalAddress.AddressTexts.Add(
new AddressTextDto()
{
Address = payload.AccountContact.ContactMedium.GeographicAddress.GeographicAddressExtension.AddressText[0].addressText ?? "No Data",
SequenceNumber = payload.AccountContact.ContactMedium.GeographicAddress.GeographicAddressExtension.AddressText[0].sequenceNumber
}
);
customerAndServiceAccounts.CustomerAccount.Customer.CitizensPostalAddress.Locality =
payload.AccountContact.ContactMedium.GeographicAddress.UrbanPropertyAddress.locality ?? "No Data";
customerAndServiceAccounts.CustomerAccount.Customer.CitizensPostalAddress.Postcode =
payload.AccountContact.ContactMedium.GeographicAddress.UrbanPropertyAddress.postcode ?? "No Data";
customerAndServiceAccounts.CustomerAccount.Customer.CitizensPostalAddress.StateOrProvince =
payload.AccountContact.ContactMedium.GeographicAddress.stateOrProvince ?? "No Data";
customerAndServiceAccounts.CustomerAccount.BillingAccountId.PhoneNumberAsId.TelephoneNumber.Number = payload.CustomerAccountExtension.AccountId.PhoneAsId.telephoneNumber;
customerAndServiceAccounts.CustomerAccount.BillingAccountId.UniversalServiceId = payload.CustomerAccountExtension.AccountId.universalServiceId;
customerAndServiceAccounts.CustomerAccount.Customer.ContactName = payload.CustomerAccountExtension.contactName;
customerAndServiceAccounts.CustomerAccount.Customer.EmailAddress =
payload.AccountContact.ContactMedium.eMailAddress;
}
serviceAccount.TN = payload.CustomerAccountExtension.AccountId.PhoneAsId.telephoneNumber;
serviceAccount.USI = payload.CustomerAccountExtension.AccountId.universalServiceId;
serviceAccount.SubscriberName = payload.CustomerAccountExtension.contactName;
var serviceLocation = payload.CustomerAccountProductInvolvement.First().product.Services.First().ServiceLocation;
serviceAccount.Address.LocationId = serviceLocation.ID;
var geoAddress = serviceLocation.GeographicAddress;
var urbanAddress = geoAddress.UrbanPropertyAddress;
if (urbanAddress != null)
{
var address1 = string.Empty;
const string space = " ";
if (!string.IsNullOrWhiteSpace(urbanAddress.streetNrFirst))
{
address1 += space + urbanAddress.streetNrFirst.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.streetNrFirstSuffix))
{
address1 += space + urbanAddress.streetNrFirstSuffix.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.streetName))
{
address1 += space + urbanAddress.streetName.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.streetNrLast))
{
address1 += space + urbanAddress.streetNrLast.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.streetNrLastSuffix))
{
address1 += space + urbanAddress.streetNrLastSuffix.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.streetType))
{
address1 += space + urbanAddress.streetType.Trim();
}
serviceAccount.Address.Address1 = address1.Trim();
serviceAccount.Address.Locality = urbanAddress.locality != null
? urbanAddress.locality.Trim()
: string.Empty;
serviceAccount.Address.Postcode = urbanAddress.postcode != null
? urbanAddress.postcode.Trim()
: string.Empty;
}
if (urbanAddress != null && urbanAddress.UrbanPropertySubAddress != null)
{
var address2 = string.Empty;
const string space = " ";
if (!string.IsNullOrWhiteSpace(urbanAddress.UrbanPropertySubAddress.subUnitType))
{
address2 += space + urbanAddress.UrbanPropertySubAddress.subUnitType.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.UrbanPropertySubAddress.subUnitNr))
{
address2 += space + urbanAddress.UrbanPropertySubAddress.subUnitNr.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.UrbanPropertySubAddress.levelType))
{
address2 += space + urbanAddress.UrbanPropertySubAddress.levelType.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.UrbanPropertySubAddress.levelNr))
{
address2 += space + urbanAddress.UrbanPropertySubAddress.levelNr.Trim();
}
if (!string.IsNullOrWhiteSpace(urbanAddress.UrbanPropertySubAddress.buildingName))
{
address2 += space + urbanAddress.UrbanPropertySubAddress.buildingName.Trim();
}
serviceAccount.Address.Address2 = address2.Trim();
}
serviceAccount.Address.StateOrProvince = geoAddress.stateOrProvince != null
? geoAddress.stateOrProvince.Trim()
: string.Empty;
foreach (
var service in
payload.CustomerAccountProductInvolvement.SelectMany(capi => capi.product.Services))
{
if (service.ResourceFacingServices != null && service.ResourceFacingServices.Any())
{
serviceAccount.Services.Add(
new ServiceDto
{
ServiceCode = service.ResourceFacingServices.First().ResourceFacingServiceId.ID,
ServiceDescription =
service.ResourceFacingServices.First().ResourceFacingServiceId.description
});
}
}
customerAndServiceAccounts.ServiceAccounts.Add(serviceAccount);
}
return customerAndServiceAccounts;
}
