<tr>
   <td>Search Postcode</td>
   <td><input name="epcSearchPostcode" type="text" id="epcSearchPostcode"></td>
</tr>
<tr>
   <td>Search Company</td>
   <td><input name="epcSearchCompany" type="text" id="epcSearchCompany"></td>
</tr>
<tr>
   <td>Search Street</td>
   <td><input name="epcSearchStreet" type="text" id="epcSearchStreet"></td>
</tr>
<tr>
   <td>Search Locality</td>
   <td><input name="epcSearchLocality" type="text" id="epcSearchLocality"></td>
</tr>
<tr>
   <td>Search Town</td>
   <td><input name="epcSearchTownOrCity" type="text" id="epcSearchTownOrCity"></td>
</tr>
<tr>
   <td>Search Number</td>
   <td><input name="epcSearchNumber" type="text" id="epcSearchNumber"></td>
</tr>

using System;
using System.Text;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Etellect.IQ.ECore;
using Etellect.IQ.ECms.ClientConfiguration;

namespace Etellect.Common.Controls.EPostcode
{
    /// <summary>
    /// Summary description for epostcode_lookup
    /// </summary>
    public class epostcode_lookup : IHttpHandler
    {

        public void ProcessRequest(HttpContext context)
        {
            context.Response.ContentType = "text/application";
            Client myClient = Client.Create(context);
            ePostcode_Licence = ##ENTER YOUR LICENSE GUID HERE##;
            ePostcode_Account = ## ENTER YOUR ACCOUNT NAME HERE ##t; 
            var searchResult = DoSearch(context);
            context.Response.Write(searchResult.ToJson());
        }

        public bool IsReusable
        {
            get
            {
                return false;
            }
        }

        private enum Status
        {
            OK = 0,
            notfound = 1,
            err = 2
        }

        private bool DEBUG = true;

   protected string ePostcode_Licence = ""; // get this from the ClientObject
   protected string ePostcode_Account = "";
   protected const string ePostcode_MachineID = "";

        public class Result
        {
            public string Status { get; set; }
            public string Message { get; set; }
            public List<PostcodeSearchAddress> Addresses { get; set; }
        }

        public class PostcodeSearchAddress
        {
            public string Organisation { get; set; }            
            public string BuildingName { get; set; }
            public string SubBuildingName { get; set; }

            public string Address1 { get; set; }
            public string Address2 { get; set; }
            public string Address3 { get; set; }
            public string TownCity { get; set; }
            public string Postcode { get; set; }
            public string DependentLocality { get; set; }
            public string CountyAdministrative { get; set; }

            public string FullAddress { get; set; }
        }

        private Result DoSearch(HttpContext context)
        {            
            string postcode = context.Request.QueryString["postcode"];
            string nameNumber = context.Request.QueryString["nameNumber"];            

            Etellect.IQ.Web.References.EPostcode.PostcodeServices13 WS = null;
            Etellect.IQ.Web.References.EPostcode.ListAllAddressPremises addressPremises = null;
            bool ErrorFlag = false;
            string sTmp = string.Empty;

            Result result = new Result();

if(string.IsNullOrEmpty(postcode))
            {
// WriteToLog("Blank postcode")
                result.Status = "err";
                result.Message = "blank postcode";
            }
            //else if(!Regex.IsMatch(Postcode, SnapDDA.Site.SanitisationRegexes(SnapDDA.Site.SanitisationMethod.UKPostcode)))
            //{
            //    // WriteToLog("Invalid postcode")
            //    sOut.Append(@"{""status"":""err"",""descr"":""invalid postcode""}");
            //}
            else
            {
WS = new Etellect.IQ.Web.References.EPostcode.PostcodeServices13();
WS.Timeout = 3000;

// WriteToLog("Looking up postcode: """ & Postcode & """")
try{
// addresses = WS.AdvancedSearch(Postcode, ePostcode_Account, "", "", ePostcode_Licence)
// addresses = WS.SearchPremise_ByPostcode(Postcode, ePostcode_Account, ePostcode_Licence, "")
                    addressPremises = WS.GetPremiseAddressesFromPostcodeAndHouseNumber(postcode, nameNumber, "100", ePostcode_Account, ePostcode_Licence, "");

}
                catch(Exception ex)
                {
// WriteToLog("Caught WS error - " & ex.Message)
                    result.Status = "err";
                    result.Message = "WS error 1"; // helpful message...
ErrorFlag = true;
}

if(!ErrorFlag)
                {
if(addressPremises == null)
                    {
// think this might be an error,  mais tant pis...
//WriteToLog("addresses = null")
                        result.Status = "not found";
                        result.Message = "";
                    }
else
                    {
if(addressPremises.IsError)
                        {
// WriteToLog("WS IsError = " & addressPremises.ErrorMessage)
                            result.Status = "err";
                            result.Message = "WS error 2";
}
                        else
                        {
// WriteToDebugLog("Addresses.list.length=" & addressPremises.List.Length)
if(addressPremises.List.Length == 0)
                            {
// WriteToDebugLog("Addresses.list.length=0: Nothing found")
                                result.Status = "not found";
                                result.Message = "";
                            }
else if((addressPremises.List.Length == 1) && (addressPremises.List[0].Return_Code == "0"))
                            {
// WriteToDebugLog("Address.list.length=1 + Return_Code=0: Nothing found")
                                result.Status = "not found";
                                result.Message = "";
                            }
else
                            {
Regex re = new Regex(@"\s{2,}");
                                result.Status = "OK";
                                result.Message = "";
                                result.Addresses = new List<PostcodeSearchAddress>();

                                foreach (Etellect.IQ.Web.References.EPostcode.AddressPremise a in addressPremises.List)
                                {
if(a.Return_Code == "0")
                                    {
// skip nulls
// WriteToDebugLog("Return_Code=0: skipped")
                                    }
else
                                    {
                                        PostcodeSearchAddress address = new PostcodeSearchAddress();                                        
                                        if (a.Organisation.Length > 0)
                                        {

                                            address.Organisation = a.Organisation;
                                        }

if(a.Sub_Building_Name.Length > 0)
                                        {
// "Flat 10"
// Prepend this to the building name
if(a.Building_Name.Length == 0)
a.Building_Name = a.Sub_Building_Name;
else
a.Building_Name = a.Sub_Building_Name + ", " + a.Building_Name;
}

if(a.Building_Name.Length > 0)
                                        {
// Check if this building name is just a number,  e.g. "9-17".  In which case,  if the Number is empty,  use this as the number
if(Regex.IsMatch(a.Building_Name, @"^[\d\-\s]+$"))
                                            {
// it's just a number...
if(a.Number.Length > 0 )
                                                {
// But they're using a number too.  So treat this building name as a building name
address.BuildingName = a.Building_Name;
                                                }
else
a.Number = a.Building_Name;
                                            }
else
address.BuildingName = a.Building_Name;
}

if(a.Number.Length + a.Street.Length > 0)
                                        {
if(a.Number.Length == 0)
address.Address1 = a.Street;
else
                                            {
if(a.Street.Length == 0)
address.Address1 = a.Number;
else
address.Address1 = a.Number + " " + a.Street;

}
}
                                        
if(a.Dependent_Locality.Length > 0) address.DependentLocality = a.Dependent_Locality;

if(a.Post_Town.Length > 0 && a.County_Administrative.Length > 0 && a.Post_Town == a.County_Administrative)
address.TownCity = a.Post_Town; // ' London, Manchester, etc. - don't add the county
else
                                        {
if(a.Post_Town.Length > 0) 
                                                address.TownCity = a.Post_Town;

                                            if(a.County_Administrative.Length > 0) 
                                                address.CountyAdministrative = a.County_Administrative;
}

                                        if (a.Postcode.Length > 0)
                                        {
                                            address.Postcode = a.Postcode;
                                        }

                                        var tmp = string.Empty;
                                        if (!string.IsNullOrWhiteSpace(address.BuildingName))
                                            tmp = address.BuildingName;
                                        if (!string.IsNullOrWhiteSpace(address.SubBuildingName))
                                        {
                                            tmp = (tmp.Length > 0 ? tmp + ", " + address.SubBuildingName : address.SubBuildingName);
                                        }
                                        if (!string.IsNullOrWhiteSpace(address.Address1))
                                        {
                                            tmp = (tmp.Length > 0 ? tmp + ", " + address.Address1 : address.Address1);
                                        }
                                        address.Address1 = tmp; // merge the building and street into line 1.

                                        address.FullAddress = Regex.Replace(a.FullAddress, @"(^\\r\\n)|(\\r\\n$)|(\\r\\n\s+(?=\\r))", "");
address.FullAddress = Regex.Replace(address.FullAddress, @"\\r\\n", ", ");

                                        result.Addresses.Add(address);
}
}
}
}
}
}
}

            return result;
        }

    }
}

msGUIDDemo=ConfigurationSettings.AppSettings["DemoGuid"];
msAccountNameDemo=ConfigurationSettings.AppSettings["DemoAccountName"];