public void ProbeOperation(FindCriteria findCriteria)
{
ProbeMessageCD1 request = new ProbeMessageCD1();
request.Probe = FindCriteriaCD1.FromFindCriteria(findCriteria);
this.duplexInnerClient.ProbeOperation(request);
}
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>
/// Creates Task to handle Probe request
/// </summary>
/// <param name="criteria"><see cref="FindCriteria"/> for finding correct endpoints</param>
/// <returns>Returns <see cref="Task<IEnumerable<EndpointDiscoveryMetadata>>"/> object which encapsulates request handler</returns>
Task <Collection <EndpointDiscoveryMetadata> > IProbeTaskFactory.Create(FindCriteria criteria)
{
// Create Task containing Rx LINQ query
return(criteria.ContractTypeNames // Each requested contract name
.ToObservable() // As Observable
.ObserveOn(Scheduler.NewThread) // Asynchronously
.TakeUntil(Observable.Return(XmlQualifiedName.Empty) // Take until...
.Delay(criteria.Duration)) // ...until timeout
.Where(name => { return _dictionary.ContainsKey(name); }) // Select only contract names present in the dictionary
.SelectMany(name => { return _dictionary[name].ToObservable(); }) // Endpoints implementing requested Contract name
.Where(endpoint =>
{
return _scopesPredicate(endpoint.Scopes, // With matching scopes
criteria.Scopes,
criteria.ScopeMatchBy)
&& _extensionsPredicate(endpoint.Extensions, // and matching extensions
criteria.Extensions);
})
.Take(criteria.MaxResults) // Take requested number of results
.Aggregate(new Collection <EndpointDiscoveryMetadata>(),
(context, endpoint) =>
{
context.Add(endpoint); // Add matching endpoints
return context;
})
.ToTask());
}
private DiscoveryEndpoint DiscoverEndpoint(DiscoveryEndpoint endpoint, bool required)
{
using (var discover = new DiscoveryClient(UdpDiscoveryEndpoint ?? new UdpDiscoveryEndpoint()))
{
var criteria = new FindCriteria(endpoint.Contract.ContractType)
{
MaxResults = 1
};
if (DiscoveryDuration.HasValue)
{
criteria.Duration = DiscoveryDuration.Value;
}
var discovered = discover.Find(criteria);
if (discovered.Endpoints.Count > 0)
{
var endpointMetadata = discovered.Endpoints[0];
var binding = Binding ?? AbstractChannelBuilder.GetBindingFromMetadata(endpointMetadata);
return(new DiscoveryEndpoint(binding, endpointMetadata.Address));
}
if (required)
{
throw new EndpointNotFoundException("Unable to locate a ServiceCatalog on the network.");
}
return(null);
}
}
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);
}
public static void Main(string[] args)
{
var endPoint = new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscoveryApril2005);
var discoveryClient = new System.ServiceModel.Discovery.DiscoveryClient(endPoint);
var findCriteria = new FindCriteria
{
Duration = TimeSpan.FromSeconds(3),
MaxResults = int.MaxValue
};
findCriteria.ContractTypeNames.Add(new XmlQualifiedName("NetworkVideoTransmitter", @"http://www.onvif.org/ver10/network/wsdl"));
Console.WriteLine("Initiating find operation.");
var response = discoveryClient.Find(findCriteria);
List <string> lst = new List <string>();
foreach (var e in response.Endpoints)
{
foreach (var item in e.ListenUris)
{
string uri = item.OriginalString;
string host = item.Host;
lst.Add(host + ": " + uri);
}
}
lst = lst.Distinct().ToList();
lst.ForEach(x => Console.WriteLine(x));
Console.WriteLine($"Operation returned - Found {lst.Count} endpoints.");
Console.ReadKey();
}
public TService Discover <TService>() where TService : class
{
var discoveryBinding = _options.DiscoveryBindingFactory.Invoke();
if (!string.Equals(discoveryBinding.Scheme, _options.ProbeEndpoint.Scheme))
{
throw new ArgumentException("ProbeEndpoint is not valid for the given DiscoveryBinding", nameof(ServiceModelDiscoveryOptions.ProbeEndpoint));
}
var probeEndpointAddress = new EndpointAddress(_options.ProbeEndpoint);
var discoveryEndpoint = new DiscoveryEndpoint(discoveryBinding, probeEndpointAddress);
try
{
var criteria = new FindCriteria(typeof(TService));
var endpoints = _discoveryClient.FindEndpoints(discoveryEndpoint, criteria);
var items = from endpoint in endpoints
let binding = _bindingFactory.Create(typeof(TService), endpoint.Address.Uri.Scheme)
where binding != null
let channel = _channelFactory.CreateChannel <TService>(binding, endpoint.Address)
select channel;
return(items.FirstOrDefault());
}
catch (Exception ex)
{
_logger.LogError(ex, $"An error occurred while resolving the service {typeof(TService).Name}");
}
return(null);
}
public virtual EndpointDiscoveryMetadata[] FindEndpoints(FindCriteria criteria)
{
using (@lock.ForReading())
{
return(MatchTargets(criteria).ToArray());
}
}
private static DiscoveryClient BuildDiscoveryClient(string adapterId, DiscoveryVersion version)
{
var epDiscovery = new UdpDiscoveryEndpoint(version);
var b = (CustomBinding)epDiscovery.Binding;
if (b == null)
{
return(null);
}
epDiscovery.TransportSettings.MulticastInterfaceId = adapterId;
b.Elements.Insert(0, new MulticastCapabilitiesBindingElement(true));
var discoveryClient = new DiscoveryClient(epDiscovery);
discoveryClient.FindProgressChanged += DiscoveryClientFindProgressChanged;
//discoveryClient.FindCompleted += DiscoveryClientFindCompleted;
FindCriteria findCriteria = new FindCriteria
{
Duration = TimeSpan.FromMinutes(5),
MaxResults = int.MaxValue
};
foreach (var ctn in CtNs)
{
findCriteria.ContractTypeNames.Add(ctn);
}
discoveryClient.FindAsync(findCriteria);
return(discoveryClient);
}
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;
}
void RemoveOnlineService(EndpointDiscoveryMetadata endpointDiscoveryMetadata)
{
if (endpointDiscoveryMetadata == null)
{
throw new Exception("Metadata is invalid.");
}
var mexCriteria = new FindCriteria(typeof(IMetadataExchange));
if (mexCriteria.IsMatch(endpointDiscoveryMetadata))
{
return;
}
lock (this._onlineServices)
{
XElement delService = endpointDiscoveryMetadata.Extensions.FirstOrDefault(x =>
x.Name.LocalName == "Id" && x.Value != "") ??
endpointDiscoveryMetadata.Extensions.FirstOrDefault(x =>
x.Name.LocalName == "Contract" && x.Value != "");
if (delService == null)
{
return;
}
this._onlineServices.Remove(delService.Value);
}
PrintDiscoveryMetadata(endpointDiscoveryMetadata, "Removing");
}
/// <summary>
/// Gets the endpoint discovery metadata.
/// </summary>
/// <param name="contractTypeName">Name of the contract type.</param>
/// <returns>SerializableEndpoint[][].</returns>
public SerializableEndpoint[] GetEndpoints(string contractTypeName)
{
using (var clt = CreateDiscoveryClient())
{
try
{
var lst = new List <XmlQualifiedName>()
{
new XmlQualifiedName(contractTypeName)
};
var criteria = FindCriteria.CreateMetadataExchangeEndpointCriteria(lst);
var resp = clt.Find(criteria);
var serviceEndpoints = new List <SerializableEndpoint>();
foreach (var it in resp.Endpoints)
{
serviceEndpoints.AddRange(MetadataHelper
.GetEndpoints(it.Address.Uri.AbsoluteUri)
.Select(ep => new SerializableEndpoint(ep, 0)));
}
return(serviceEndpoints.ToArray());
}
catch (Exception ex)
{
FxLog <Discos> .LogException(ex);
return(null);
}
finally
{
CloseClient(clt);
}
}
}
private void IPCameraList()
{
var endPoint = new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscoveryApril2005);
var discoveryClient = new DiscoveryClient(endPoint);
var findCriteria = new FindCriteria
{
Duration = TimeSpan.FromSeconds(3),
MaxResults = int.MaxValue
};
findCriteria.ContractTypeNames.Add(new XmlQualifiedName("NetworkVideoTransmitter", @"http://www.onvif.org/ver10/network/wsdl"));
var response = discoveryClient.Find(findCriteria);
List <string> lst = new List <string>();
foreach (var e in response.Endpoints)
{
foreach (var item in e.ListenUris)
{
string uri = item.OriginalString;
string host = item.Host;
lst.Add(host);
}
}
lst = lst.Distinct().ToList();
lst.ForEach(x => cmbCameraDevices.Items.Add(x));
}
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 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);
}
private static void Main()
{
var client = new DiscoveryClient(new UdpDiscoveryEndpoint());
// Найти все доступные конечные точки
// Note: вы также можете вызвать этот метод асинхронно
var criteria = new FindCriteria(typeof(FileServiceLib.IFileService));
var response = client.Find(criteria);
// Связаться с одной из них
FileServiceClient svcClient = null;
foreach (var endpoint in response.Endpoints)
{
svcClient = new FileServiceClient();
svcClient.Endpoint.Address = endpoint.Address;
break;
}
// Вызвать службу
if (svcClient != null)
{
var dirs = svcClient.GetSubDirectories(@"C:\");
foreach (var dir in dirs)
{
Console.WriteLine(dir);
}
}
Console.ReadLine();
}
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");
}
}
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());
}
/// <summary>
/// Gets all endpoints.
/// </summary>
/// <returns>SerializableEndpoint[][].</returns>
public SerializableEndpoint[] GetAllEndpoints()
{
using (var clt = CreateDiscoveryClient())
{
try
{
var criteria = FindCriteria.CreateMetadataExchangeEndpointCriteria();
var resp = clt.Find(criteria);
var serviceEndpoints = new List <SerializableEndpoint>();
foreach (var it in resp.Endpoints)
{
try
{
var sep = MetadataHelper.GetEndpoints(it.Address.Uri.AbsoluteUri);
serviceEndpoints.AddRange(sep.Select(ep => new SerializableEndpoint(ep, 0)));
}
catch (Exception e)
{
FxLog <Discos> .LogException(e);
}
}
return(serviceEndpoints.ToArray());
}
catch (Exception ex)
{
FxLog <Discos> .LogException(ex);
return(null);
}
finally
{
CloseClient(clt);
}
}
}
public EndpointDiscoveryMetadata ChooseTarget(FindCriteria criteria = null)
{
var choose = new ChooseContext(this, criteria);
ChooseTarget(choose);
return(choose.SelectedEndpoint);
}
internal void InitializeFrom(FindCriteria fc)
{
foreach (var ctn in fc.ContractTypeNames)
{
ContractTypeNames.Add(new ContractTypeNameElement()
{
Name = ctn.Name, Namespace = ctn.Namespace
});
}
Duration = fc.Duration;
var doc = new XmlDocument();
foreach (var ext in fc.Extensions)
{
var xr = ext.CreateReader();
xr.MoveToContent();
Extensions.Add(new XmlElementElement()
{
XmlElement = (XmlElement)doc.ReadNode(xr)
});
}
MaxResults = fc.MaxResults;
ScopeMatchBy = fc.ScopeMatchBy;
foreach (var scope in fc.Scopes)
{
Scopes.Add(new ScopeElement()
{
Scope = scope
});
}
}
public DiscoveryClient startDiscovery(TimeSpan span)
{
try
{
var endPoint = new UdpDiscoveryEndpoint(DiscoveryVersion.WSDiscoveryApril2005);
var discoveryClient = new DiscoveryClient(endPoint);
discoveryClient.FindCompleted += DiscoveryClient_FindCompleted;
discoveryClient.FindProgressChanged += discoveryClient_FindProgressChanged;
FindCriteria findCriteria = new FindCriteria();
findCriteria.Duration = span;
findCriteria.MaxResults = int.MaxValue;
findCriteria.ContractTypeNames.Add(new System.Xml.XmlQualifiedName("NetworkVideoTransmitter", "http://www.onvif.org/ver10/network/wsdl"));
discoveryClient.FindAsync(findCriteria);
this.OnRecoveryChange("", DiscoveryEvent.EventTypes.startEvent);
System.Diagnostics.Trace.WriteLine("DiscoveryClient.startDiscovery O.K ...");
return(discoveryClient);
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine("DiscoveryServer.startDiscovery: " + ex.Message);
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());
}
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 FindCriteria CreateSearchCriteria(DiscoveredEndpointModel model)
{
var searchContract = model.SearchContract ?? contract;
var criteria = new FindCriteria(searchContract)
{
MaxResults = model.MaxResults
};
if (model.Duration.HasValue)
{
criteria.Duration = model.Duration.Value;
}
var discovery = model.Extensions.OfType <WcfInstanceExtension>()
.Select(extension => extension.Instance)
.OfType <EndpointDiscoveryBehavior>()
.FirstOrDefault();
if (discovery != null)
{
criteria.Scopes.AddAll(discovery.Scopes);
if (model.ScopeMatchBy != null)
{
criteria.ScopeMatchBy = model.ScopeMatchBy;
}
criteria.Extensions.AddAll(discovery.Extensions);
}
return(criteria);
}
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());
}
private void Validate(FindCriteria findCriteria)
{
if (!string.IsNullOrWhiteSpace(findCriteria.OrderBy))
{
ValidateOrderBy(findCriteria.OrderBy);
}
}
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 IAsyncResult BeginProbeOperation(FindCriteria findCriteria, AsyncCallback callback, object state)
{
ProbeMessageCD1 request = new ProbeMessageCD1();
request.Probe = FindCriteriaCD1.FromFindCriteria(findCriteria);
return(this.duplexInnerClient.BeginProbeOperation(request, callback, state));
}
public static FindCriteriaApril2005 FromFindCriteria(FindCriteria findCriteria)
{
if (findCriteria == null)
{
throw FxTrace.Exception.ArgumentNull("findCriteria");
}
return new FindCriteriaApril2005(findCriteria);
}
internal void ApplyConfiguration(FindCriteria findCriteria)
{
foreach (ContractTypeNameElement contractTypeNameElement in this.ContractTypeNames)
{
findCriteria.ContractTypeNames.Add(
new XmlQualifiedName(
contractTypeNameElement.Name,
contractTypeNameElement.Namespace));
}
foreach (ScopeElement scopeElement in this.Scopes)
{
findCriteria.Scopes.Add(scopeElement.Scope);
}
foreach (XmlElementElement xmlElement in this.Extensions)
{
findCriteria.Extensions.Add(XElement.Parse(xmlElement.XmlElement.OuterXml));
}
findCriteria.ScopeMatchBy = this.ScopeMatchBy;
findCriteria.Duration = this.Duration;
findCriteria.MaxResults = this.MaxResults;
}
FindCriteriaApril2005()
{
this.findCriteria = new FindCriteria();
}
FindCriteriaApril2005(FindCriteria findCriteria)
{
this.findCriteria = findCriteria;
}
internal FindCriteria CreateInstance ()
{
var fc = new FindCriteria ();
foreach (ContractTypeNameElement ctn in ContractTypeNames)
fc.ContractTypeNames.Add (new XmlQualifiedName (ctn.Name, ctn.Namespace));
fc.Duration = Duration;
foreach (XmlElementElement ext in Extensions)
fc.Extensions.Add (XElement.Load (new XmlNodeReader (ext.XmlElement)));
fc.MaxResults = MaxResults;
fc.ScopeMatchBy = ScopeMatchBy;
foreach (ScopeElement scope in Scopes)
fc.Scopes.Add (scope.Scope);
return fc;
}
internal void InitializeFrom (FindCriteria fc)
{
foreach (var ctn in fc.ContractTypeNames)
ContractTypeNames.Add (new ContractTypeNameElement () { Name = ctn.Name, Namespace = ctn.Namespace});
Duration = fc.Duration;
var doc = new XmlDocument ();
foreach (var ext in fc.Extensions) {
var xr = ext.CreateReader ();
xr.MoveToContent ();
Extensions.Add (new XmlElementElement () { XmlElement = (XmlElement) doc.ReadNode (xr) });
}
MaxResults = fc.MaxResults;
ScopeMatchBy = fc.ScopeMatchBy;
foreach (var scope in fc.Scopes)
Scopes.Add (new ScopeElement () { Scope = scope});
}
internal FindCriteriaApril2005 (FindCriteria source)
{
this.source = source;
}
public static FindCriteriaApril2005 FromFindCriteria (FindCriteria findCriteria)
{
return new FindCriteriaApril2005 (findCriteria);
}
FindCriteriaCD1()
{
this.findCriteria = new FindCriteria();
}
/// <summary>
/// Find open opportunities based on contact or org.
/// </summary>
/// <param name="attribute"></param>
/// <param name="value"></param>
/// <returns></returns>
public List<OpportunityModel> FindOpenOpportunities(string attribute, string value)
{
try
{
ViewCriteriaItem item = new ViewCriteriaItem();
item.upperCaseCompare = false;
item.attribute = attribute;
item.@operator = "=";
item.Items = new[] {value};
ViewCriteriaItem item2 = new ViewCriteriaItem();
item2.upperCaseCompare = true;
item2.attribute = "StatusCode";
item2.@operator = "=";
item2.Items = new[] {"Open"};
ViewCriteriaRow condition1 = new ViewCriteriaRow();
condition1.upperCaseCompare = false;
condition1.item = new[] {item, item2};
ViewCriteria viewCriteria = new ViewCriteria();
viewCriteria.conjunction = Conjunction.And;
viewCriteria.group = new[] {condition1};
//Sorting by Creation date.
SortAttribute sortAttr = new SortAttribute();
sortAttr.name = "CreationDate";
sortAttr.descending = true;
FindCriteria findCriteria = new FindCriteria();
findCriteria.fetchStart = 0;
findCriteria.fetchSize = 500;
findCriteria.filter = viewCriteria;
findCriteria.sortOrder = new[] {sortAttr};
findCriteria.findAttribute = new string[]
{
"KeyContactId",
"PrimaryContactPartyName",
"SalesAccountId",
"TargetPartyName",
"OptyId",
"OptyNumber",
"PartyName1",
"EmailAddress",
"Name",
"Description",
"StatusCode",
"SalesMethod",
"SalesStage",
"SalesChannelCd",
"CurrencyCode",
"Revenue",
"WinProb",
"CreatedBy",
"CreationDate",
"EffectiveDate"
};
FindControl findControl = new FindControl();
Opportunity[] opp = _opportunityClient.findOpportunity(findCriteria, findControl);
return getOpportunityModels(opp);
}
catch (EndpointNotFoundException wex)
{
//Handling incorrect opportunity endpoint
_logger.Error(wex.Message, wex.StackTrace);
MessageBox.Show(OSCExceptionMessages.EndpointNotFound,
OSCOpportunitiesCommon.EndpointNotFound, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (MessageSecurityException mse)
{
//Handling incorrect credentials
_logger.Error(mse.Message, mse.StackTrace);
MessageBox.Show(OSCExceptionMessages.OpportunityAuthError,
OSCOpportunitiesCommon.OpportunityAuthError, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
catch (CommunicationException ce)
{
//Handling maximum reponse size exceeded
_logger.Error(ce.Message, ce.StackTrace);
MessageBox.Show(OSCExceptionMessages.MaxReceivedMessageSizeExceeded,
OSCOpportunitiesCommon.MaxReceivedMessageSizeExceededTitle, MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
catch (Exception ex)
{
_logger.Error(ex.Message, ex.StackTrace);
MessageBox.Show(OSCExceptionMessages.UnexpectedError,
"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
return null;
}
FindCriteriaCD1(FindCriteria findCriteria)
{
this.findCriteria = findCriteria;
}
public static FindCriteriaCD1 FromFindCriteria (FindCriteria findCriteria)
{
return new FindCriteriaCD1 (findCriteria);
}
internal FindCriteriaCD1 (FindCriteria source)
{
this.source = source;
}
public void ReadXml (XmlReader reader)
{
source = FindCriteria.ReadXml (reader, version);
}
public static FindCriteriaApril2005 FromFindCriteria (FindCriteria findCriteria)
{
throw new NotImplementedException ();
}
