static EndpointAddress FindCalculatorServiceAddress()
{
// Create DiscoveryClient
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
// Find ICalculatorService endpoints in the specified scope
Uri scope = new Uri("ldap:///ou=engineering,o=exampleorg,c=us");
FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService));
findCriteria.Scopes.Add(scope);
findCriteria.MaxResults = 1;
Console.WriteLine("Finding ICalculatorService endpoints within {0} scope...", scope);
Console.WriteLine();
FindResponse findResponse = discoveryClient.Find(findCriteria);
Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count);
Console.WriteLine();
if (findResponse.Endpoints.Count > 0)
{
return(findResponse.Endpoints[0].Address);
}
else
{
return(null);
}
}
static EndpointAddress FindCalculatorServiceAddress()
{
// Create DiscoveryClient
DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress("net.tcp://localhost:8001/DiscoveryRouter/"));
DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint);
Console.WriteLine("Finding ICalculatorService endpoints...");
Console.WriteLine();
// Find ICalculatorService endpoints
FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService));
findCriteria.Duration = TimeSpan.FromSeconds(10);
FindResponse findResponse = discoveryClient.Find(findCriteria);
Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count);
Console.WriteLine();
if (findResponse.Endpoints.Count > 0)
{
return(findResponse.Endpoints[0].Address);
}
else
{
return(null);
}
}
public FindResponse <string> GetDistance(string from, string to)
{
string uri = string.Format(GmapsURL, Uri.EscapeDataString(from), Uri.EscapeDataString(to));
HttpClient client = new HttpClient();
var resp = client.GetAsync(uri);
var result = resp.Result.Content.ReadAsStringAsync();
var qwe = JObject.Parse(result.Result);
string km = string.Empty;
float kilometers = -1;
string status = (string)qwe["status"];
if (status != "OK")
{
throw new Exception(status);
}
km = (string)qwe["rows"][0]["elements"][0]["distance"]["text"];
km = km.Split(' ')[0];
km = km.Replace('.', ',');
kilometers = float.Parse(km);
var response = new FindResponse <string>();
response.Result = kilometers.ToString();
return(response);
}
public Api()
{
FindResponse search = null;
using (DiscoveryClient discovery = new DiscoveryClient(new UdpDiscoveryEndpoint()))
{
FindCriteria filter = new FindCriteria(typeof(IApi));
filter.MaxResults = 1;
search = discovery.Find(filter);
}
if (search != null)
{
if (search.Endpoints != null)
{
if (search.Endpoints.Count.Equals(1))
{
ChannelFactory <IApi> factory = new ChannelFactory <IApi>(new NetTcpBinding(), search.Endpoints[0].Address);
_api = factory.CreateChannel();
}
}
}
}
/// <summary>
/// Discover specific servcie type.
/// </summary>
/// <param name="identifier">String identifier. Only used in console/log output.</param>
/// <param name="type">Service type.</param>
/// <param name="timespan">Timeout to discover a service.</param>
/// <returns></returns>
private static FindResponse Discover(string identifier, Type type, int timespan)
{
FindResponse discovered = null;
ILog _log = LogManager.GetCurrentClassLogger();
try
{
// ------- DISCOVERY ----------
LogHelper.Log(LogLevel.Info, String.Format("Start discovering {0} ...", identifier));
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindCriteria criteria = new FindCriteria(type);
criteria.Duration = TimeSpan.FromSeconds(timespan);
discovered = discoveryClient.Find(criteria);
LogHelper.Log(LogLevel.Info, String.Format("{0} Discovery: {1} services found.", identifier, discovered.Endpoints.Count));
LogHelper.PrintEndPoints(discovered.Endpoints);
discoveryClient.Close();
}
catch (FaultException <ArgumentException> exc)
{
_log.Fatal(m => m("FaultException: {0}", exc));
}
catch (Exception exc)
{
_log.Fatal(m => m("Exception: {0}", exc));
}
return(discovered);
}
public FindResponse FindArtices(FindRequest request)
{
var response = new FindResponse();
using (var db = DbContext)
{
var query = db.Artices
.AsQueryable();
if (!string.IsNullOrWhiteSpace(request.TextSearch))
{
request.TextSearch = request.TextSearch.ToLower().Trim();
query = query.Where(q => q.Name.ToLower().Contains(request.TextSearch)
|| q.Description.ToLower().Contains(request.TextSearch)
|| q.Content.ToLower().Contains(request.TextSearch)
|| q.Status.ToString().ToLower().Contains(request.TextSearch)
);
}
query = request.IsSortingValid ? request.ApplySortOption(query) : request.ApplyPageOption(query.OrderBy(q => q.Name));
var pagingResult = request.ApplyPageOption(query).ToList();
response.TotalRecords = query.Count();
response.Results = pagingResult.MapList<Artice>();
}
return response;
}
public static void Main()
{
// Create DiscoveryClient
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
Console.WriteLine("Finding ICalculatorService endpoints...");
Console.WriteLine();
// Find ICalculatorService endpoints
FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService));
findCriteria.Duration = TimeSpan.FromSeconds(5);
FindResponse findResponse = discoveryClient.Find(findCriteria);
Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count);
Console.WriteLine();
// Check to see if endpoints were found & print the XML metadata in them.
if (findResponse.Endpoints.Count > 0)
{
foreach (XElement xElement in findResponse.Endpoints[0].Extensions)
{
Console.WriteLine("Printing Metadata from ServiceEndpoint:");
Console.WriteLine("Endpoint Information: " + xElement.Element("Information").Value);
Console.WriteLine("Endpoint Started at Time: " + xElement.Element("Time").Value);
Console.WriteLine();
}
InvokeCalculatorService(findResponse.Endpoints[0].Address);
}
Console.WriteLine("Press <ENTER> to exit.");
Console.ReadLine();
}
private static EndpointDiscoveryMetadata FindService()
{
//Create Discovery Client
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
//Create Find Criteria
var findCriteria = new FindCriteria(typeof(IStringDuplicator))
{
Duration = TimeSpan.FromSeconds(1)
};
//Searching
FindResponse findResponse = null;
for (int i = 0; i < 11; i++)
{
Console.WriteLine($"{i + 1} attempt to find server with duration {findCriteria.Duration}");
findResponse = discoveryClient.Find(findCriteria);
if (findResponse.Endpoints.Count > 0)
{
break;
}
findCriteria.Duration += TimeSpan.FromSeconds(1);
}
discoveryClient.Close();
if (findResponse.Endpoints.Count > 0)
{
return(findResponse.Endpoints[0]);
}
else
{
return(null);
}
}
/// <summary>
/// Searches for Monitor&Control Services available on the network.
/// </summary>
public void DiscoverMonitorControlServices()
{
try
{
// ------- DISCOVERY ----------
_log.Trace(m => m("Start discovering <MonitorControl Service> ..."));
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindCriteria criteria = new FindCriteria(typeof(IMonitorAndControl));
discoveredMonitorControlServiceHosts = discoveryClient.Find(criteria);
discoveryClient.Close();
_log.Trace(m => m("{0} <MonitorControl Service> found.", discoveredMonitorControlServiceHosts.Endpoints.Count));
LogHelper.LogEndPoint(_log, discoveredMonitorControlServiceHosts.Endpoints);
if (discoveredMonitorControlServiceHosts.Endpoints.Count > 0)
{
// store service host address
monitorControlServiceHostAddress = discoveredMonitorControlServiceHosts.Endpoints[0].Address;
}
}
catch (Exception exc)
{
_log.Trace(m => m("Exception: during discovering <MonitorControl Service>: {0}", exc));
discoveredMonitorControlServiceHosts = null;
}
}
static List <FindResponse> GetResultadosBusqueda(IEnumerable <string> PalabrasParaBuscar)
{
List <FindResponse> ResultadoBusquedas = new List <FindResponse>();
foreach (string Palabra in PalabrasParaBuscar)
{
// Se guardará dentro de una lista el resultado de busqueda de cada palabra
// realizado en dos motores de busqueda
var Modelo = new FindResponse
{
Keyword = Palabra,
GoogleResults = 0,
YahooResults = 0
};
// Busqueda de Google
Modelo.GoogleResults = GetResult(Palabra, "GOOGLE");
// Busqueda de Yahoo
Modelo.YahooResults = GetResult(Palabra, "YAHOO");
ResultadoBusquedas.Add(Modelo);
}
return(ResultadoBusquedas);
}
public FindResponse FindAppSettings(FindRequest request)
{
var response = new FindResponse();
using (var db = DbContext)
{
var query = db.AppSettings.AsQueryable();
if (request.SettingType.HasValue)
{
query = query.Where(i => i.SettingType == request.SettingType);
}
if (request.ExcludeSettingTypes != null && request.ExcludeSettingTypes.Any())
{
query = query.Where(i => request.ExcludeSettingTypes.All(k => k != i.SettingType));
}
query = request.IsSortingValid ? request.ApplySortOption(query) : request.ApplyPageOption(query.OrderBy(q => q.Name));
var pagingResult = request.ApplyPageOption(query).ToList();
response.TotalRecords = query.Count();
response.Results = pagingResult.MapList<AppSetting>();
}
return response;
}
static void Main(string[] args)
{
// Create a DiscoveryEndpoint that points to the DiscoveryProxy
Uri probeEndpointAddress = new Uri("net.tcp://localhost:8001/Probe");
DiscoveryEndpoint discoveryEndpoint = new DiscoveryEndpoint(new NetTcpBinding(), new EndpointAddress(probeEndpointAddress));
DiscoveryClient discoveryClient = new DiscoveryClient(discoveryEndpoint);
Console.WriteLine("Finding ICalculatorService endpoints using the proxy at {0}", probeEndpointAddress);
Console.WriteLine();
try
{
// Find ICalculatorService endpoints
FindResponse findResponse = discoveryClient.Find(new FindCriteria(typeof(ICalculatorService)));
Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count);
Console.WriteLine();
// Check to see if endpoints were found, if so then invoke the service.
if (findResponse.Endpoints.Count > 0)
{
InvokeCalculatorService(findResponse.Endpoints[0].Address);
}
}
catch (Exception e)
{
Console.WriteLine("This client was unable to connect to and query the proxy. Ensure that the proxy is up and running.");
}
Console.WriteLine("Press <ENTER> to exit.");
Console.ReadLine();
}
public virtual async Task MaterializeAsync <TIncludedDoc>(FindResponse <TIncludedDoc> response, HttpResponseMessage httpResponse)
{
using (var content = await httpResponse.Content.ReadAsStreamAsync().ForAwait())
{
Serializer.Populate(response, content);
}
}
private void Search_Click(object sender, RoutedEventArgs e)
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindCriteria findCriteria = new FindCriteria(typeof(IServerService));
findCriteria.Duration = TimeSpan.FromSeconds(2);
FindResponse findResponse = discoveryClient.Find(findCriteria);
FoundServers = findResponse.Endpoints.Count;
foreach (EndpointDiscoveryMetadata edm in findResponse.Endpoints)
{
serverComboBox.Items.Add(edm.Address.Uri.ToString());
}
if (serverComboBox.Items.Count > 0)
{
serverComboBox.SelectedIndex = 0;
}
else
{
MessageBox.Show("Nie odnaleziono serwera");
}
}
FindResponse Find(FindCriteria criteria)
{
var req = new MessageContractsCD1.FindRequest()
{
Body = new FindCriteriaCD1(criteria)
};
Channel.BeginFind(req, delegate(IAsyncResult result) {
Channel.EndFind(result);
}, null);
var timeout = InnerChannel.OperationTimeout < criteria.Duration ? InnerChannel.OperationTimeout : criteria.Duration;
if (!reply_find_handle.WaitOne(timeout))
{
throw new EndpointNotFoundException("The discovery client could not receive Find operation response within the operation timeout.");
}
try {
var ir = find_completed();
var ret = new FindResponse();
foreach (var fr in ir.Body)
{
ret.Endpoints.Add(fr.ToEndpointDiscoveryMetadata());
}
return(ret);
} finally {
find_completed = null;
}
}
public FindResponse FindProducts(FindRequest request)
{
var response = new FindResponse();
using (var db = DbContext)
{
var query = db.Products
.Include("ProductImages")
.AsQueryable();
if (!string.IsNullOrWhiteSpace(request.TextSearch))
{
request.TextSearch = request.TextSearch.Trim().ToLower();
query = query.Where(q =>
q.Name.ToLower().Contains(request.TextSearch)
|| q.ProductCode.ToLower().Contains(request.TextSearch)
|| q.Category.Name.ToLower().Contains(request.TextSearch)
|| q.Unit.Name.ToLower().Contains(request.TextSearch)
);
}
query = request.IsSortingValid ? request.ApplySortOption(query) : request.ApplyPageOption(query.OrderBy(q => q.Name));
var pagingResult = request.ApplyPageOption(query).ToList();
response.TotalRecords = query.Count();
response.Results = pagingResult.MapList<Product>();
}
return response;
}
public static Binding DiscoverBinding <T>(Uri scope = null)
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindCriteria criteria = FindCriteria.CreateMetadataExchangeEndpointCriteria();
criteria.MaxResults = 1;
if (scope != null)
{
criteria.Scopes.Add(scope);
}
FindResponse discovered = discoveryClient.Find(criteria);
discoveryClient.Close();
Debug.Assert(discovered.Endpoints.Count == 1);
Uri mexAddress = discovered.Endpoints[0].Address.Uri;
ServiceEndpoint[] endpoints = MetadataHelper.GetEndpoints(mexAddress.AbsoluteUri, typeof(T));
Debug.Assert(endpoints.Length == 1);
return(endpoints[0].Binding);
}
static T[] CreateChannelsFromMex <T>(Uri scope = null) where T : class
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindCriteria criteria = FindCriteria.CreateMetadataExchangeEndpointCriteria();
FindResponse discovered = discoveryClient.Find(criteria);
discoveryClient.Close();
if (discovered.Endpoints.Count == 0)
{
return(new T[] {});
}
List <T> list = new List <T>();
foreach (EndpointDiscoveryMetadata mexEndpoint in discovered.Endpoints)
{
ServiceEndpoint[] endpoints = MetadataHelper.GetEndpoints(mexEndpoint.Address.Uri.AbsoluteUri, typeof(T));
foreach (ServiceEndpoint endpoint in endpoints)
{
T proxy = ChannelFactory <T> .CreateChannel(endpoint.Binding, endpoint.Address);
list.Add(proxy);
}
}
Debug.Assert(list.Count > 0);
return(list.ToArray());
}
private void DiscoverNodesSync()
{
using (var discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()))
{
FindResponse fileToMachineEndPoints =
discoveryClient.Find(new FindCriteria(typeof(IFileToMachineServiceContract)));
foreach (EndpointDiscoveryMetadata endpoint in fileToMachineEndPoints.Endpoints)
{
try
{
var client = new FileToMachineClient(new BasicHttpBinding(), endpoint.Address);
FileToMachineHandler.AddToRoutingTable(client.Ping().NodeIdentifier);
}
catch (CommunicationException e)
{
}
}
FindResponse reverseIndexEndPoints =
discoveryClient.Find(new FindCriteria(typeof(IReverseIndexServiceContract)));
foreach (EndpointDiscoveryMetadata endPoint in reverseIndexEndPoints.Endpoints)
{
try
{
var client = new ReverseIndexServiceClient(new BasicHttpBinding(), endPoint.Address);
ReverseIndexHandler.AddToRoutingTable(client.Ping().NodeIdentifier);
}
catch (CommunicationException e)
{
}
}
}
}
private EndpointAddress[] FindServiceAddress()
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindResponse findResponse = discoveryClient.Find(new FindCriteria(typeof(T)));
return(findResponse.Endpoints.Select(m => m.Address).ToArray());
}
static FindResponse FindServices()
{
// Create DiscoveryClient
FindResponse findResponse = null;
while (true)
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
Console.WriteLine("Scanning for endpoints.");
findResponse = discoveryClient.Find(new FindCriteria(typeof(IEchoService))
{
Duration = TimeSpan.FromSeconds(2)
});
if (findResponse == null || findResponse.Endpoints == null || findResponse.Endpoints.Count == 0)
{
Console.Write(".");
Thread.Sleep(5000);
}
else
{
return(findResponse);
}
}
}
static EndpointAddress FindCalculatorServiceAddress()
{
// Create a discovery client using the secure endpoint that applies and checks the compact signature
DiscoveryClient discoveryClient = new DiscoveryClient("udpSecureDiscoveryEndpoint");
Console.WriteLine("Finding ICalculatorService endpoints...");
Console.WriteLine();
FindCriteria findCriteria = new FindCriteria(typeof(ICalculatorService));
findCriteria.Duration = TimeSpan.FromSeconds(5);
// Find ICalculatorService endpoints
FindResponse findResponse = discoveryClient.Find(findCriteria);
Console.WriteLine("Found {0} ICalculatorService endpoint(s).", findResponse.Endpoints.Count);
Console.WriteLine();
if (findResponse.Endpoints.Count > 0)
{
return(findResponse.Endpoints[0].Address);
}
else
{
return(null);
}
}
public static MediaDevice[] GetAvailableMediaDevices()
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscoveryApril2005));
FindCriteria findCriteria = new FindCriteria
{
Duration = TimeSpan.FromSeconds(1),
MaxResults = 15
};
findCriteria.ContractTypeNames.Add(new XmlQualifiedName("NetworkVideoTransmitter", @"http://www.onvif.org/ver10/network/wsdl"));
FindResponse findResponse = discoveryClient.Find(findCriteria);
List <MediaDevice> cameras = new List <MediaDevice>();
foreach (var point in findResponse.Endpoints)
{
Uri uri = point.ListenUris.FirstOrDefault(u => u.HostNameType == UriHostNameType.IPv4);
if (uri != null)
{
string name = ONVIFAgent.GetDeviceInformation(uri);
cameras.Add(new MediaDevice(name, uri));
}
}
return(cameras.ToArray());
}
public override Task <FindResponse> FindPersons(FindRequest request, ServerCallContext context)
{
if (string.IsNullOrWhiteSpace(request?.Query))
{
return(Task.FromResult(new FindResponse()));
}
// we want our wildcard to be * like globbing, not % like sql
var find = request.Query.Replace('*', '%');
var resp = new FindResponse();
var results = m_dbcontext.People.Where(p => EF.Functions.Like(p.FirstName, find) || EF.Functions.Like(p.LastName, find)).Skip(request.Skip).Take(request.Take);
resp.Results.AddRange(results.Select(p => new GrpcPerson()
{
PersonId = p.PersonId,
FirstName = p.FirstName,
LastName = p.LastName,
Address = p.Address,
City = p.City,
State = p.State,
PostalCode = p.PostalCode,
}));
return(Task.FromResult(resp));
}
public void Find_Successful()
{
var resumes = new List <Found>();
resumes.Add(new Found()
{
IsDefault = true,
Modified = DateTime.Now,
ResumeID = 1234567890,
ResumeName = "Test Resume",
Timestamp = 1234567890
});
var response = new FindResponse()
{
ExecutionResult = SuccessResult(), Resumes = resumes.ToArray()
};
mockResumeService.Setup(m => m.Find(It.Is <FindRequest>(r => r.JobSeekerID == 1234567890)))
.Returns(response);
var service = SystemUnderTest();
var result = service.Find(1234567890);
Assert.IsNotNull(result);
Assert.AreEqual(result.First().ResumeId, resumes.First().ResumeID);
Assert.AreEqual(result.First().ResumeTitle, resumes.First().ResumeName);
Assert.AreEqual(result.First().Timestamp, resumes.First().Timestamp);
mockResumeService.Verify(m => m.Find(It.Is <FindRequest>(r => r.JobSeekerID == 1234567890)), Times.Once());
}
void CheckForServices()
{
btnRefresh.IsEnabled = false;
DiscoveryClient discoveryProxy = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindCriteria findCriteria = new FindCriteria(typeof(IGeoService))
{
MaxResults = 1,
Duration = new TimeSpan(0, 0, 5)
};
findCriteria.Scopes.Add(new Uri("http://www.pluralsight.com/miguel-castro/discoverability"));
FindResponse discoveryResponse = discoveryProxy.Find(findCriteria);
if (discoveryResponse.Endpoints.Count == 0)
{
_DiscoveredAddress = null;
btnGetInfo.IsEnabled = false;
btnGetZipCodes.IsEnabled = false;
}
else
{
EndpointDiscoveryMetadata discoveredEndpoint = discoveryResponse.Endpoints[0];
_DiscoveredAddress = discoveredEndpoint.Address;
btnGetInfo.IsEnabled = true;
btnGetZipCodes.IsEnabled = true;
}
btnRefresh.IsEnabled = true;
}
static string[] DiscoverMexAddresses()
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindResponse discovered = discoveryClient.Find(FindCriteria.CreateMetadataExchangeEndpointCriteria());
return(discovered.Endpoints.Select(mexEndpoint => mexEndpoint.Address.Uri.AbsoluteUri).ToArray());
}
public static T CreateChannel <T>(string serviceNamespace, string secret, Uri scope = null) where T : class
{
ServiceBusDiscoveryClient discoveryClient = new ServiceBusDiscoveryClient(serviceNamespace, secret);
FindCriteria criteria = FindCriteria.CreateMetadataExchangeEndpointCriteria();
criteria.MaxResults = 1;
if (scope != null)
{
criteria.Scopes.Add(scope);
}
FindResponse discovered = discoveryClient.Find(criteria);
discoveryClient.Close();
Debug.Assert(discovered.Endpoints.Count == 1);
Uri mexAddress = discovered.Endpoints[0].Address.Uri;
ServiceEndpoint[] endpoints = ServiceBusMetadataHelper.GetEndpoints(mexAddress.AbsoluteUri, typeof(T), secret);
Debug.Assert(endpoints.Length == 1);
Binding binding = endpoints[0].Binding;
EndpointAddress address = endpoints[0].Address;
ChannelFactory <T> factory = new ChannelFactory <T>(binding, address);
factory.SetServiceBusCredentials(secret);
return(factory.CreateChannel());
}
public FindResponse <Sucursal> FindById(int Id)
{
var resp = new FindResponse <Sucursal>();
resp.Result = business.FindById(Id);
return(resp);
}
public IEnumerable <IDeploymentAgent> Discover()
{
using (var discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint()))
{
FindResponse result = discoveryClient.Find(new FindCriteria(typeof(IAgentInfoService)));
return(result.Endpoints.Select(e => new DeploymentAgent(this.proxyFactory, e.Address.Uri.BaseAddress <IAgentInfoService>())));
}
}
EndpointAddress[] DiscoverAddresses <T>()
{
DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
FindCriteria criteria = new FindCriteria(typeof(T));
FindResponse discovered = discoveryClient.Find(criteria);
return(discovered.Endpoints.Select((endpoint) => endpoint.Address).ToArray());
}
public void FindRequest()
{
FindRequest request = new FindRequest(connection, "Knar66");
FindResponse response = request.Send();
Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK);
Assert.AreEqual(response.USER_ID, "6d9d9295-b538-47e4-b213-e039658a8e8b");
}
public FindResponse <Price> FindByKm(int km)
{
var resp = new FindResponse <Price>();
resp.Result = priceBusiness.FindByKm(km);
return(resp);
}
public FindResponse FindDataLogs(FindRequest request)
{
var response = new FindResponse();
using (var db = DbContext)
{
var query = db.DataLogs.AsQueryable();
if (request.Table.HasValue)
{
query = query.Where(q => q.Table == request.Table);
}
if (request.ItemId.HasValue)
{
query = query.Where(q => q.ItemId == request.ItemId);
}
if (!String.IsNullOrEmpty(request.TextSearch))
{
request.TextSearch = request.TextSearch.ToStr().Trim().ToLower();
query = query.Where(q =>
q.BeUser.FullName.ToLower().Contains(request.TextSearch)
|| q.OldData.ToLower().Contains(request.TextSearch)
|| q.NewData.ToLower().Contains(request.TextSearch)
|| q.Action.ToString().ToLower().Contains(request.TextSearch)
);
}
if (request.FromDate.HasValue)
{
query = query.Where(q => q.LogDate >= request.FromDate);
}
if (request.ToDate.HasValue)
{
query = query.Where(q => q.LogDate <= request.ToDate);
}
query = request.IsSortingValid ? request.ApplySortOption(query) : request.ApplyPageOption(query.OrderByDescending(q => q.LogDate));
var pagingResult = request.ApplyPageOption(query).ToList();
response.TotalRecords = query.Count();
response.Results = pagingResult.MapList<DataLog>();
}
return response;
}
public FindResponse FindBeUsers(FindRequest request)
{
var response = new FindResponse();
using (var db = DbContext)
{
var query = db.BeUsers
.AsQueryable();
if (!String.IsNullOrEmpty(request.TextSearch))
{
request.TextSearch = request.TextSearch.ToStr().Trim().ToLower();
query = query.Where(q =>
q.Code.ToLower().Contains(request.TextSearch)
|| q.FullName.ToLower().Contains(request.TextSearch)
|| q.Email.ToLower().Contains(request.TextSearch)
|| q.Phone.ToLower().Contains(request.TextSearch)
|| q.Address.ToLower().Contains(request.TextSearch)
|| q.Role.Name.ToLower().Contains(request.TextSearch)
|| q.Position.Name.ToLower().Contains(request.TextSearch)
|| q.Status.ToString().Contains(request.TextSearch)
);
}
query = request.IsSortingValid ? request.ApplySortOption(query) : request.ApplyPageOption(query.OrderBy(q => q.FullName));
var pagingResult = request.ApplyPageOption(query).ToList();
response.TotalRecords = query.Count();
response.Results = pagingResult.MapList<BeUser>();
}
return response;
}
