public void Test_Zip_Code_Retrieval()
{
//Arrange
Mock <IZipCodeRepository> mockZipCodeRepository = new Mock <IZipCodeRepository>();
ZipCode zipCode = new ZipCode()
{
City = "LINCOLN PARK",
State = new State()
{
Abbreviation = "NJ"
},
Zip = "07035"
};
mockZipCodeRepository.Setup(obj => obj.GetByZip("07035")).Returns(zipCode);
//Act
IGeoService geoService = new GeoManager(mockZipCodeRepository.Object);
ZipCodeData data = geoService.GetZipInfo("07035");
//Assert
Assert.IsTrue(data.City.ToUpper() == "LINCOLN PARK");
Assert.AreEqual(data.State, "NJ");
}
private void imgBtn_Search_Click(object sender, System.Web.UI.ImageClickEventArgs e)
{
try
{
zipCode = new ZipCodeData();
dsResult = zipCode.Search(this.tb_Dong.Text);
if (dsResult.Tables[0].Rows.Count > 0)
{
this.St_Panel.Visible = false;
this.Ed_Panel.Visible = true;
this.selAddr.DataSource = dsResult;
this.selAddr.DataTextField = "TEXT";
this.selAddr.DataValueField = "VALUE";
this.selAddr.DataBind();
}
else
{
this.lblResult.Text = "검색된 결과가 없습니다.";
}
}
catch (Exception ex)
{
Response.Write(ex.ToString());
}
}
public List <ZipCodeData> GetZipCodes(string state)
{
List <ZipCodeData> zipCodeData = new List <ZipCodeData>();
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
List <ZipCode> zipCodeList = zipCodeRepository.GetByState(state);
// ReSharper disable once InvertIf
if (zipCodeList != null && zipCodeList.Count > 0)
{
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (ZipCode zipCode in zipCodeList)
{
ZipCodeData newZipCodeData = new ZipCodeData
{
City = zipCode.City,
State = zipCode.State.Abbreviation,
ZipCode = zipCode.Zip
};
zipCodeData.Add(newZipCodeData);
}
}
else
{
string message = $"State {state} not found";
throw new FaultException(message);
}
return(zipCodeData);
}
private void btnGetInfo_Click(object sender, RoutedEventArgs e)
{
if (txtZipCode.Text != "")
{
GeoClient proxy = new GeoClient();
try
{
ZipCodeData data = proxy.GetZipInfo(txtZipCode.Text);
if (data != null)
{
lblCity.Content = data.City;
lblState.Content = data.State;
}
proxy.Close();
}
catch (Exception ex)
{
MessageBox.Show("Exception thrown by service.\n\rException type: " +
ex.GetType().Name + "\n\r" +
"Message: " + ex.Message + "\n\r" +
"Proxy state: " + proxy.State.ToString());
}
}
}
public List <ZipCodeData> GetZipCodes(string zipCode, int zipCodeRange)
{
List <ZipCodeData> zipCodeData = new List <ZipCodeData>();
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZipCode(zipCode);
List <ZipCode> zipCodeList = zipCodeRepository.GetZipCodesForRange(zipCodeEntity, zipCodeRange);
// ReSharper disable once InvertIf
if (zipCodeList != null && zipCodeList.Count > 0)
{
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (ZipCode zipCode2 in zipCodeList)
{
ZipCodeData newZipCodeData = new ZipCodeData
{
City = zipCode2.City,
State = zipCode2.State.Abbreviation,
ZipCode = zipCode2.Zip
};
zipCodeData.Add(newZipCodeData);
}
}
else
{
string message = $"Zip code range ({zipCode}, {zipCodeRange}) not found";
throw new FaultException(message);
}
return(zipCodeData);
}
public void test_zip_code_retrieval()
{
// nadefinujeme si mock
Mock <IZipCodeRepository> mockZipCodeRepository = new Mock <IZipCodeRepository>();
// udelame mock object
ZipCode zipCode = new ZipCode()
{
City = "LINCOLN PARK",
State = new State()
{
Abbreviation = "NJ"
},
Zip = "07035"
};
// pokud mock dostane request na GetByZip("07035"), tak vratime nas zipCode entity]
// testujeme kod uvnitr service a ne uvnitr repository
mockZipCodeRepository.Setup(obj => obj.GetByZip("07035")).Returns(zipCode);
IGeoService geoService = new GeoManager(mockZipCodeRepository.Object);
ZipCodeData data = geoService.GetZipInfo("07035");
Assert.IsTrue(data.City.ToUpper() == "LINCOLN PARK");
Assert.IsTrue(data.State == "NJ");
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
ApplicationException ex = new ApplicationException(string.Format("Zip code {0} not found.", zip));
throw new FaultException <ApplicationException>(ex, "Just another message");
}
return(zipCodeData);
}
public void ZipCodeRetrival()
{
//Framework of mocking for .Net
// it create a fake representation of the repositories
Mock <IZipCodeRepository> mockZipRep = new Mock <IZipCodeRepository>();
ZipCode zip = new ZipCode
{
City = "New Orleans",
State = new State {
Abbreviation = "LA"
},
Zip = "70112"
};
// each time the GetByZip with this parameter returns
//a copy of the ZipCode instance hard-coded above
mockZipRep.Setup(o => o.GetByZip("70112")).Returns(zip);
IGeoService service = new GeoManager(null, mockZipRep.Object);
ZipCodeData data = service.GetZipInfo("70112");
Assert.IsTrue(data.City == "New Orleans");
Assert.IsTrue(data.State == "LA");
}
public List <ZipCodeData> GetZipCodes(string state)
{
List <ZipCodeData> zipCodeData = new List <ZipCodeData>();
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
List <ZipCode> zipCodes = zipCodeRepository.GetByState(state);
// ReSharper disable once InvertIf
if (zipCodes != null)
{
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (ZipCode zipCode in zipCodes)
{
ZipCodeData newZipCodeData = new ZipCodeData
{
City = zipCode.City,
State = zipCode.State.Abbreviation,
ZipCode = zipCode.Zip
};
zipCodeData.Add(newZipCodeData);
}
}
return(zipCodeData);
}
private void btnGetInfo_Click(object sender, RoutedEventArgs e)
{
if (txtZipCode.Text != "")
{
GeoClient proxy = new GeoClient(new InstanceContext(this));
try
{
ZipCodeData data = proxy.GetZipInfo(txtZipCode.Text);
if (data != null)
{
lblCity.Content = data.City;
lblState.Content = data.State;
}
proxy.Close();
}
catch (FaultException ex)
{
MessageBox.Show("Fault Exception: " + ex.Message);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
}
public ZipCodeData GetZipInfo(string zip)
{
//Test after set timeout to 5 seconds. It throws a timeout exception.
//Thread.Sleep(10000);
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
//Used as Unhandled Exception. Sets the proxy state at the client to "Faulted"
//throw new ApplicationException(string.Format("Zip code {0} not found.", zip));
//Used as Handled Exception. Keeps the proxy state at the client to "Opened"
//throw new FaultException(string.Format("Zip code {0} not found.", zip));
//Used with FaultContract that must be declared at the contract level, the IGeoService in this case. Keeps the proxy state at the client to "Opened"
//ApplicationException ex = new ApplicationException(string.Format("Zip code {0} not found.", zip));
//throw new FaultException<ApplicationException>(ex, "Just another message");
//Better and most powerful way to throw an exception. Using FaultContract that must be declared at the contract level,
//and using a custom Class to define and send the information needed. Keeps the proxy state at the client to "Opened"
NotFoundData data = new NotFoundData()
{
Message = string.Format("Zip code {0} not found.", zip),
When = DateTime.Now.ToString(),
User = "******" //It can be recovered by Identity or anythin else.
};
throw new FaultException <NotFoundData>(data, "Just another message.");
}
//lock (this)
//{
// _Counter++;
//}
//MyStaticResource.DoSomething();
//Keep this only if the Host is a Console.
//Console.WriteLine("Count = {0}", _Counter.ToString());
//Used in Instancing and Concurrency for demonstration. Need reference to PresentationFramework and using System.Window;
//MessageBox.Show(string.Format("{0} = {1}, {2}", zip, zipCodeData.City, zipCodeData.State), "Call Counter " + _Counter.ToString());
return(zipCodeData);
}
public void test_zip_code_retrieval()
{
IGeoService geoService = new GeoManager();
ZipCodeData data = geoService.GetZipInfo("07035");
Assert.IsTrue(data.City.ToUpper() == "LINCOLN PARK");
Assert.IsTrue(data.State == "NJ");
}
private void bthGetPushedInfo_Click(object sender, RoutedEventArgs e)
{
ZipCodeData data = _ProxyStateful.GetZipInfo();
if (data != null)
{
lblCity.Content = data.City;
lblState.Content = data.State;
}
}
private void GetInfoBtn_OnClick(object sender, RoutedEventArgs e)
{
var proxy = new GeoClient();
ZipCodeData data = proxy.GetZipInfo("");
GetInfoTextBlock.Text = $"{data.City} \r\n {data.State} \r\n {data.ZipCode}";
proxy.Close();
}
private void btnGetInfo_Click(object sender, RoutedEventArgs e)
{
if (txtZipCode.Text != "")
{
GeoClient proxy = new GeoClient(new InstanceContext(this), "tcpEp");
try
{
ZipCodeData data = proxy.GetZipInfo(txtZipCode.Text);
if (data != null)
{
lblCity.Content = data.City;
lblState.Content = data.State;
}
else
{
lblCity.Content = "N/A";
lblState.Content = "N/A";
}
proxy.Close();
}
catch (FaultException <ExceptionDetail> ex)
{
MessageBox.Show("Exception thrown by service.\n\rException type: " +
"FaultException<ExceptionDetail>" + "\n\r" +
"Message: " + ex.Detail.Message + "\n\r" + "Proxy state: " + proxy.State);
}
catch (FaultException <ApplicationException> ex)
{
MessageBox.Show("Exception thrown by service.\n\rException type: " +
"FaultException<ApplicationException>" + "\n\r" +
"Reason: " + ex.Message + "\n\r" +
"Message: " + ex.Detail.Message + "\n\r" + "Proxy state: " + proxy.State);
}
catch (FaultException <NotFoundData> ex)
{
MessageBox.Show("Exception thrown by service.\n\rException type: " +
"FaultException<NotFoundData>" + "\n\r" +
"Reason: " + ex.Message + "\n\r" +
"Message: " + ex.Detail.Message + "\n\r" + "Proxy state: " + proxy.State);
}
catch (FaultException ex)
{
MessageBox.Show("Faultxception thrown by service.\n\rException type: " +
"FaultException" + "\n\r" +
"Message: " + ex.Message + "\n\r" + "Proxy state: " + proxy.State);
}
catch (Exception ex)
{
MessageBox.Show("Exception thrown by service.\n\rException type: " + ex.GetType().Name + "\n\r" +
"Message: " + ex.Message + "\n\r" + "Proxy state: " + proxy.State);
}
}
}
private void GetZipInfoStateful()
{
if (!string.IsNullOrWhiteSpace(txtZipSearch.Text))
{
ZipCodeData data = _ProxyStateful.GetZipInfo();
if (data != null)
{
lblResponseCity.Content = data.City;
lblResponseState.Content = data.State;
}
}
}
public async Task <IActionResult> Index([FromBody] ZipCodeData data)
{
if (ModelState.IsValid)
{
if (ZipCode.TryParse(data.Value, out ZipCode zipCode))
{
ZipCodeResult zipCodeResult = await ZipCodeLoad.FindAsync(zipCode);
return(Json(zipCodeResult));
}
}
return(Json(new { IsValid = false }));
}
public void GetZipInfo_Should_Return_ZipCodeData()
{
var repo = Substitute.For <IZipCodeDataAccess>();
repo.GetZipCodeByZip(Arg.Any <string>()).Returns(new ZipCode {
});
var manager = new GeoManager(repo);
ZipCodeData result = manager.GetZipInfo("");
Assert.NotNull(result);
}
private void btnGetInfo_Click(object sender, RoutedEventArgs e)
{
if (txtZipCode.Text != "")
{
GeoClient proxy = new GeoClient("tcpEP"); //Pass tcpEP or httpEP
ZipCodeData data = proxy.GetZipInfo(txtZipCode.Text);
if (data != null)
{
lblCity.Content = data.City;
lblState.Content = data.State;
}
}
}
public ZipCodeData GetZipInfo()
{
ZipCodeData zipCodeData = null;
if (_zipCodeEntity != null)
{
zipCodeData = LocalConfiguration.Mapper.Map <ZipCodeData>(_zipCodeEntity);
}
else
{
throw new ArgumentException("Uh no");
}
return(zipCodeData);
}
public ZipCodeData GetZipInfo()
{
ZipCodeData zipCodeData = null;
if (_zipCodeEntity != null)
{
zipCodeData = new ZipCodeData
{
City = _zipCodeEntity.City,
State = _zipCodeEntity.State.Abbreviation,
ZipCode = _zipCodeEntity.Zip
};
}
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
// verifying if is coming from unit test or real call
IZipCodeRepository rep = _repZip ?? new ZipCodeRepository();
// Doing the encapsulated thing that it should
ZipCode zipCode = rep.GetByZip(zip);
if (zipCode == null)
{
Exception ex = new InvalidOperationException("Zip code not found");
//Every exception thrown by the service will be a FaultException
//but this will be considered as unhandled one and will receive a generic message
//throw ex;
//Even with IncludeExceptionDetailInFaults false is possible to send a fail message
//this is the simplest form of handled FaultException just explaining the reason.
//throw new FaultException(new FaultReason("Zip code not found"));
//Is possible also to send the actual exception details like:
//message, inner exception, stack trace, etc.
//just put the ex exception in a new exception detail.
throw new FaultException <ExceptionDetail>(new ExceptionDetail(ex), "No records");
// Custom error object.
//NotFoundData data = new NotFoundData
//{
// Message = "Zip code not found",
// When = DateTime.Now.ToString(),
// User = "******"
//};
//It is possible even send a kind of exception like InvalidOperationException
// or in this case a custom error object
//throw new FaultException<NotFoundData>(data, "No records");
}
ZipCodeData result = new ZipCodeData
{
City = zipCode.City,
State = zipCode.State.Abbreviation,
ZipCode = zipCode.Zip
};
// returning what the client is expecting
return(result);
}
private void btnGetInfo_Click(object sender, RoutedEventArgs e)
{
if (txtZipCode.Text != "")
{
GeoClient proxy = new GeoClient("GeoLibRouter");
ZipCodeData data = proxy.GetZipInfo(txtZipCode.Text);
if (data != null)
{
lblCity.Content = data.City;
lblState.Content = data.State;
}
proxy.Close();
}
}
private void btnGetInfo_Click(object sender, RoutedEventArgs e)
{
if (txtZipCode.Text != "")
{
//GeoClient proxy = new GeoClient("tcpEP");
string zipCode = txtZipCode.Text;
try
{
ZipCodeData data = _proxy.GetZipInfo(zipCode);
if (data != null)
{
lblCity.Content = data.City;
lblState.Content = data.State;
}
}
catch (FaultException <ExceptionDetail> ex)
{
MessageBox.Show($"Exception thrown by service.\n\rException type :" +
$"FaultException<ExceptionDetail>\n\r" +
$"Message: {ex.Detail.Message}\n\r" +
$"Proxy state: {_proxy.State}");
}
catch (FaultException <ApplicationException> ex)
{
MessageBox.Show($"FaultException<ApplicationException> thrown by service.\n\rException type :" +
$"FaultException<ApplicationException>\n\r" +
$"Message: {ex.Detail.Message}\n\r" +
$"Proxy state: {_proxy.State}");
}
catch (FaultException ex)
{
MessageBox.Show($"FaultException thrown by service.\n\rException type :" +
$"{ex.GetType().Name}\n\r" +
$"Message: {ex.Message}\n\r" +
$"Proxy state: {_proxy.State}");
}
catch (Exception ex)
{
MessageBox.Show($"Exception thrown by service.\n\rException type :" +
$"{ex.GetType().Name}\n\r" +
$"Message: {ex.Message}\n\r" +
$"Proxy state: {_proxy.State}");
}
//proxy.Close();
}
}
private void buttonInfo_Click(object sender, RoutedEventArgs e)
{
if (textBoxInfo.Text != "")
{
GeoClient geoClientProxy = new GeoClient();
ZipCodeData zipCodeData = geoClientProxy.GetZipInfo(textBoxInfo.Text);
if (zipCodeData != null)
{
lblCity.Content = zipCodeData.City;
lblState.Content = zipCodeData.State;
}
geoClientProxy.Close();
}
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
IZipCodeRepository zipCodeRepository = _zipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
return(zipCodeData);
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
string hostIdentity = WindowsIdentity.GetCurrent().Name;
//string primaryIdentity = ServiceSecurityContext.Current.PrimaryIdentity.Name;
//string windowsIdentity = ServiceSecurityContext.Current.WindowsIdentity.Name;
//string threadIdentity = Thread.CurrentPrincipal.Identity.Name;
IZipCodeRepository zipCodeRepository = _ZipCodeRepository ?? new ZipCodeRepository();
ZipCode zipCodeEntity = zipCodeRepository.GetByZip(zip);
if (zipCodeEntity != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCodeEntity.City,
State = zipCodeEntity.State.Abbreviation,
ZipCode = zipCodeEntity.Zip
};
}
else
{
//throw new ApplicationException($"Zip code {zip} not found.");
//throw new FaultException($"Zip code {zip} not found.");
//ApplicationException ex = new ApplicationException($"Zip code {zip} not found.");
//throw new FaultException<ApplicationException>(ex, "Just another message");
NotFoundData data = new NotFoundData()
{
Message = $"Zip code {zip} not found.",
When = DateTime.Now.ToString(),
User = "******"
};
throw new FaultException <NotFoundData>(data, "Just another message");
}
_Counter++;
//Console.WriteLine($"Counter = {_Counter.ToString()}");
//Thread.Sleep(10000);
//MessageBox.Show($"{zip} = {zipCodeData.City}, {zipCodeData.State}", "Call Counter " + _Counter);
return(zipCodeData);
}
public void test_zip_code_retrieval()
{
string address = "net.pipe://localhost/GeoService";
Binding binding = new NetNamedPipeBinding();
ServiceHost host = new ServiceHost(typeof(GeoManager));
host.AddServiceEndpoint(typeof(IGeoService), binding, address);
host.Open();
ChannelFactory <IGeoService> factory = new ChannelFactory <IGeoService>(binding, new EndpointAddress(address));
IGeoService proxy = factory.CreateChannel();
ZipCodeData data = proxy.GetZipInfo("07035");
Assert.IsTrue(data.City.ToUpper() == "LINCOLN PARK");
Assert.IsTrue(data.State == "NJ");
}
public ZipCodeData GetZipInfo(string zip)
{
ZipCodeData zipCodeData = null;
var zipCode = _zipCodeRepo.GetByZip(zip);
if (zipCode != null)
{
zipCodeData = new ZipCodeData()
{
City = zipCode.City,
State = zipCode.State.Abbreviation,
ZipCode = zipCode.Zip
};
}
return(zipCodeData);
}
private void btnGetInfo2_Click(object sender, RoutedEventArgs e)
{
//GeoClient proxy = new GeoClient("tcpEp");
ZipCodeData data = _Proxy2.GetZipInfo();
if (data != null)
{
lblCity2.Content = data.City;
lblState2.Content = data.State;
}
else
{
lblCity2.Content = "N/A";
lblState.Content = "N/A";
}
// proxy.Close();
}
